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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
6,800 |
translog_set_sent_to_disk
|
eloqsql/storage/maria/ma_loghandler.c
|
static void translog_set_sent_to_disk(struct st_translog_buffer *buffer)
{
LSN lsn= buffer->last_lsn;
TRANSLOG_ADDRESS in_buffers= buffer->next_buffer_offset;
DBUG_ENTER("translog_set_sent_to_disk");
mysql_mutex_lock(&log_descriptor.sent_to_disk_lock);
DBUG_PRINT("enter", ("lsn: " LSN_FMT " in_buffers: " LSN_FMT " "
"in_buffers_only: " LSN_FMT " start: " LSN_FMT " "
"sent_to_disk: " LSN_FMT,
LSN_IN_PARTS(lsn),
LSN_IN_PARTS(in_buffers),
LSN_IN_PARTS(log_descriptor.log_start),
LSN_IN_PARTS(log_descriptor.in_buffers_only),
LSN_IN_PARTS(log_descriptor.sent_to_disk)));
/*
We write sequentially (first part of following assert) but we rewrite
the same page in case we started mysql and shut it down immediately
(second part of the following assert)
*/
DBUG_ASSERT(cmp_translog_addr(lsn, log_descriptor.sent_to_disk) >= 0 ||
cmp_translog_addr(lsn, log_descriptor.log_start) < 0);
log_descriptor.sent_to_disk= lsn;
/* LSN_IMPOSSIBLE == 0 => it will work for very first time */
if (cmp_translog_addr(in_buffers, log_descriptor.in_buffers_only) > 0)
{
log_descriptor.in_buffers_only= in_buffers;
DBUG_PRINT("info", ("set new in_buffers_only"));
}
mysql_mutex_unlock(&log_descriptor.sent_to_disk_lock);
DBUG_VOID_RETURN;
}
|
O0
|
c
|
translog_set_sent_to_disk:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x100000(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x100018(%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0x41c67f(%rip), %rdi # 0x4793c0
addq $0x800cc0, %rdi # imm = 0x800CC0
leaq 0xf4f88(%rip), %rsi # 0x151cd7
movl $0x8e9, %edx # imm = 0x8E9
callq 0x4fd20
jmp 0x5cd5b
jmp 0x5cd5d
jmp 0x5cd5f
movq -0x10(%rbp), %rax
movq %rax, 0xc1d2f6(%rip) # 0xc7a060
movq -0x18(%rbp), %rax
subq 0xc1d303(%rip), %rax # 0xc7a078
cmpq $0x0, %rax
jle 0x5cd8a
movq -0x18(%rbp), %rax
movq %rax, 0xc1d2f2(%rip) # 0xc7a078
jmp 0x5cd88
jmp 0x5cd8a
leaq 0x41c62f(%rip), %rdi # 0x4793c0
addq $0x800cc0, %rdi # imm = 0x800CC0
callq 0x4fd90
jmp 0x5cd9f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
translog_set_sent_to_disk:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax+100000h]
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
mov rax, [rax+100018h]
mov [rbp+var_18], rax
lea rdi, log_descriptor
add rdi, 800CC0h
lea rsi, aWorkspaceLlm4b_11; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 8E9h
call inline_mysql_mutex_lock_8
jmp short $+2
loc_5CD5B:
jmp short $+2
loc_5CD5D:
jmp short $+2
loc_5CD5F:
mov rax, [rbp+var_10]
mov cs:qword_C7A060, rax
mov rax, [rbp+var_18]
sub rax, cs:qword_C7A078
cmp rax, 0
jle short loc_5CD8A
mov rax, [rbp+var_18]
mov cs:qword_C7A078, rax
jmp short $+2
loc_5CD88:
jmp short $+2
loc_5CD8A:
lea rdi, log_descriptor
add rdi, 800CC0h
call inline_mysql_mutex_unlock_8
jmp short $+2
loc_5CD9F:
add rsp, 20h
pop rbp
retn
|
long long translog_set_sent_to_disk(long long a1)
{
long long v2; // [rsp+8h] [rbp-18h]
long long v3; // [rsp+10h] [rbp-10h]
v3 = *(_QWORD *)(a1 + 0x100000);
v2 = *(_QWORD *)(a1 + 1048600);
inline_mysql_mutex_lock_8(
(long long)&log_descriptor[1048984],
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x8E9u);
qword_C7A060 = v3;
if ( v2 - qword_C7A078 > 0 )
qword_C7A078 = v2;
return inline_mysql_mutex_unlock_8((long long)&log_descriptor[1048984]);
}
|
translog_set_sent_to_disk:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x100000]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x100018]
MOV qword ptr [RBP + -0x18],RAX
LEA RDI,[0x5793c0]
ADD RDI,0x800cc0
LEA RSI,[0x251cd7]
MOV EDX,0x8e9
CALL 0x0014fd20
JMP 0x0015cd5b
LAB_0015cd5b:
JMP 0x0015cd5d
LAB_0015cd5d:
JMP 0x0015cd5f
LAB_0015cd5f:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [0x00d7a060],RAX
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr [0x00d7a078]
CMP RAX,0x0
JLE 0x0015cd8a
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [0x00d7a078],RAX
JMP 0x0015cd88
LAB_0015cd88:
JMP 0x0015cd8a
LAB_0015cd8a:
LEA RDI,[0x5793c0]
ADD RDI,0x800cc0
CALL 0x0014fd90
JMP 0x0015cd9f
LAB_0015cd9f:
ADD RSP,0x20
POP RBP
RET
|
void translog_set_sent_to_disk(long param_1)
{
int8 uVar1;
long lVar2;
uVar1 = *(int8 *)(param_1 + 0x100000);
lVar2 = *(long *)(Elf64_Ehdr_00100000.e_ident_pad + param_1 + 0xf);
inline_mysql_mutex_lock
(&DAT_00d7a080,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x8e9);
if (0 < lVar2 - DAT_00d7a078) {
DAT_00d7a078 = lVar2;
}
DAT_00d7a060 = uVar1;
inline_mysql_mutex_unlock(&DAT_00d7a080);
return;
}
|
|
6,801 |
LefDefParser::lefiNonDefault::addViaRule(LefDefParser::lefiVia*)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiNonDefault.cpp
|
void
lefiNonDefault::addViaRule(lefiVia *v)
{
if (numVias_ == allocatedVias_) {
int i;
lefiVia **nv;
if (allocatedVias_ == 0)
allocatedVias_ = 2;
else
allocatedVias_ *= 2;
nv = (lefiVia**) lefMalloc(sizeof(lefiVia*) * allocatedVias_);
for (i = 0; i < numVias_; i++) {
nv[i] = viaRules_[i];
}
lefFree((char*) (viaRules_));
viaRules_ = nv;
}
viaRules_[numVias_++] = v->clone();
}
|
O3
|
cpp
|
LefDefParser::lefiNonDefault::addViaRule(LefDefParser::lefiVia*):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x90(%rdi), %eax
cmpl 0x94(%rdi), %eax
jne 0x1f469
leal (%rax,%rax), %ecx
testl %eax, %eax
movl $0x2, %eax
cmovnel %ecx, %eax
movl %eax, 0x94(%rbx)
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x24985
movq %rax, %r15
movslq 0x90(%rbx), %rax
testq %rax, %rax
jle 0x1f456
xorl %ecx, %ecx
movq 0x98(%rbx), %rdx
movq (%rdx,%rcx,8), %rdx
movq %rdx, (%r15,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x1f43f
movq 0x98(%rbx), %rdi
callq 0x26040
movq %r15, 0x98(%rbx)
movq %r14, %rdi
callq 0x13fb2
movq 0x98(%rbx), %rcx
movslq 0x90(%rbx), %rdx
leal 0x1(%rdx), %esi
movl %esi, 0x90(%rbx)
movq %rax, (%rcx,%rdx,8)
popq %rbx
popq %r14
popq %r15
retq
|
_ZN12LefDefParser14lefiNonDefault10addViaRuleEPNS_7lefiViaE:
push r15
push r14
push rbx
mov r14, rsi
mov rbx, rdi
mov eax, [rdi+90h]
cmp eax, [rdi+94h]
jnz short loc_1F469
lea ecx, [rax+rax]
test eax, eax
mov eax, 2
cmovnz eax, ecx
mov [rbx+94h], eax
movsxd rdi, eax
shl rdi, 3; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov r15, rax
movsxd rax, dword ptr [rbx+90h]
test rax, rax
jle short loc_1F456
xor ecx, ecx
loc_1F43F:
mov rdx, [rbx+98h]
mov rdx, [rdx+rcx*8]
mov [r15+rcx*8], rdx
inc rcx
cmp rax, rcx
jnz short loc_1F43F
loc_1F456:
mov rdi, [rbx+98h]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov [rbx+98h], r15
loc_1F469:
mov rdi, r14; this
call _ZN12LefDefParser7lefiVia5cloneEv; LefDefParser::lefiVia::clone(void)
mov rcx, [rbx+98h]
movsxd rdx, dword ptr [rbx+90h]
lea esi, [rdx+1]
mov [rbx+90h], esi
mov [rcx+rdx*8], rax
pop rbx
pop r14
pop r15
retn
|
long long LefDefParser::lefiNonDefault::addViaRule(
LefDefParser::lefiNonDefault *this,
LefDefParser::lefiVia *a2)
{
int v2; // eax
int v3; // ecx
bool v4; // zf
int v5; // eax
long long v6; // r15
long long v7; // rax
long long i; // rcx
long long result; // rax
long long v10; // rcx
long long v11; // rdx
v2 = *((_DWORD *)this + 36);
if ( v2 == *((_DWORD *)this + 37) )
{
v3 = 2 * v2;
v4 = v2 == 0;
v5 = 2;
if ( !v4 )
v5 = v3;
*((_DWORD *)this + 37) = v5;
v6 = LefDefParser::lefMalloc((LefDefParser *)(8LL * v5), (unsigned long long)a2);
v7 = *((int *)this + 36);
if ( v7 > 0 )
{
for ( i = 0LL; i != v7; ++i )
*(_QWORD *)(v6 + 8 * i) = *(_QWORD *)(*((_QWORD *)this + 19) + 8 * i);
}
LefDefParser::lefFree(*((LefDefParser **)this + 19), a2);
*((_QWORD *)this + 19) = v6;
}
result = LefDefParser::lefiVia::clone(a2, (unsigned long long)a2);
v10 = *((_QWORD *)this + 19);
v11 = *((int *)this + 36);
*((_DWORD *)this + 36) = v11 + 1;
*(_QWORD *)(v10 + 8 * v11) = result;
return result;
}
|
addViaRule:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
MOV EAX,dword ptr [RDI + 0x90]
CMP EAX,dword ptr [RDI + 0x94]
JNZ 0x0011f469
LEA ECX,[RAX + RAX*0x1]
TEST EAX,EAX
MOV EAX,0x2
CMOVNZ EAX,ECX
MOV dword ptr [RBX + 0x94],EAX
MOVSXD RDI,EAX
SHL RDI,0x3
CALL 0x00124985
MOV R15,RAX
MOVSXD RAX,dword ptr [RBX + 0x90]
TEST RAX,RAX
JLE 0x0011f456
XOR ECX,ECX
LAB_0011f43f:
MOV RDX,qword ptr [RBX + 0x98]
MOV RDX,qword ptr [RDX + RCX*0x8]
MOV qword ptr [R15 + RCX*0x8],RDX
INC RCX
CMP RAX,RCX
JNZ 0x0011f43f
LAB_0011f456:
MOV RDI,qword ptr [RBX + 0x98]
CALL 0x00126040
MOV qword ptr [RBX + 0x98],R15
LAB_0011f469:
MOV RDI,R14
CALL 0x00113fb2
MOV RCX,qword ptr [RBX + 0x98]
MOVSXD RDX,dword ptr [RBX + 0x90]
LEA ESI,[RDX + 0x1]
MOV dword ptr [RBX + 0x90],ESI
MOV qword ptr [RCX + RDX*0x8],RAX
POP RBX
POP R14
POP R15
RET
|
/* LefDefParser::lefiNonDefault::addViaRule(LefDefParser::lefiVia*) */
void __thiscall LefDefParser::lefiNonDefault::addViaRule(lefiNonDefault *this,lefiVia *param_1)
{
int iVar1;
int iVar2;
long lVar3;
int8 uVar4;
long lVar5;
iVar1 = *(int *)(this + 0x90);
if (iVar1 == *(int *)(this + 0x94)) {
iVar2 = 2;
if (iVar1 != 0) {
iVar2 = iVar1 * 2;
}
*(int *)(this + 0x94) = iVar2;
lVar3 = lefMalloc((LefDefParser *)((long)iVar2 << 3),(ulong)param_1);
iVar1 = *(int *)(this + 0x90);
if (0 < (long)iVar1) {
lVar5 = 0;
do {
*(int8 *)(lVar3 + lVar5 * 8) = *(int8 *)(*(long *)(this + 0x98) + lVar5 * 8);
lVar5 = lVar5 + 1;
} while (iVar1 != lVar5);
}
lefFree(*(void **)(this + 0x98));
*(long *)(this + 0x98) = lVar3;
}
uVar4 = lefiVia::clone();
iVar1 = *(int *)(this + 0x90);
*(int *)(this + 0x90) = iVar1 + 1;
*(int8 *)(*(long *)(this + 0x98) + (long)iVar1 * 8) = uVar4;
return;
}
|
|
6,802 |
fini_one_value
|
eloqsql/mysys/my_getopt.c
|
static void fini_one_value(const struct my_option *option, void *variable,
longlong value __attribute__ ((unused)))
{
DBUG_ENTER("fini_one_value");
switch ((option->var_type & GET_TYPE_MASK)) {
case GET_STR_ALLOC:
my_free(*((char**) variable));
*((char**) variable)= NULL;
break;
default: /* dummy default to avoid compiler warnings */
break;
}
DBUG_VOID_RETURN;
}
|
O3
|
c
|
fini_one_value:
movl 0x30(%rdi), %eax
andl $0x3f, %eax
cmpl $0xa, %eax
jne 0x698f0
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rdi
callq 0x6b256
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
fini_one_value:
mov eax, [rdi+30h]
and eax, 3Fh
cmp eax, 0Ah
jnz short locret_698F0
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rsi
mov rdi, [rsi]
call my_free
mov qword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
locret_698F0:
retn
|
long long fini_one_value(long long a1, _QWORD *a2)
{
long long result; // rax
result = *(_DWORD *)(a1 + 48) & 0x3F;
if ( (_DWORD)result == 10 )
{
result = my_free(*a2);
*a2 = 0LL;
}
return result;
}
|
fini_one_value:
MOV EAX,dword ptr [RDI + 0x30]
AND EAX,0x3f
CMP EAX,0xa
JNZ 0x001698f0
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV RDI,qword ptr [RSI]
CALL 0x0016b256
MOV qword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
LAB_001698f0:
RET
|
void fini_one_value(long param_1,int8 *param_2)
{
if ((*(uint *)(param_1 + 0x30) & 0x3f) == 10) {
my_free(*param_2);
*param_2 = 0;
}
return;
}
|
|
6,803 |
ma_init_alloc_root
|
eloqsql/libmariadb/libmariadb/ma_alloc.c
|
void ma_init_alloc_root(MA_MEM_ROOT *mem_root, size_t block_size, size_t pre_alloc_size)
{
mem_root->free= mem_root->used= mem_root->pre_alloc= 0;
mem_root->min_malloc=32;
mem_root->block_size= (block_size-MALLOC_OVERHEAD-sizeof(MA_USED_MEM)+8);
mem_root->error_handler=0;
mem_root->block_num= 4;
mem_root->first_block_usage= 0;
#if !(defined(HAVE_purify) && defined(EXTRA_DEBUG))
if (pre_alloc_size)
{
if ((mem_root->free = mem_root->pre_alloc=
(MA_USED_MEM*) malloc(pre_alloc_size+ ALIGN_SIZE(sizeof(MA_USED_MEM)))))
{
mem_root->free->size=pre_alloc_size+ALIGN_SIZE(sizeof(MA_USED_MEM));
mem_root->free->left=pre_alloc_size;
mem_root->free->next=0;
}
}
#endif
}
|
O3
|
c
|
ma_init_alloc_root:
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movq $0x20, 0x18(%rdi)
addq $-0x18, %rsi
movq %rsi, 0x20(%rdi)
movq %rax, 0x30(%rdi)
movq $0x4, 0x28(%rdi)
testq %rdx, %rdx
je 0x4195a
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x18(%rdx), %r15
movq %r15, %rdi
callq 0x36950
movq %rax, 0x10(%r14)
movq %rax, (%r14)
testq %rax, %rax
je 0x41950
movq %r15, 0x10(%rax)
movq %rbx, 0x8(%rax)
movq $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
ma_init_alloc_root:
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
xor eax, eax
mov [rdi+10h], rax
mov qword ptr [rdi+18h], 20h ; ' '
add rsi, 0FFFFFFFFFFFFFFE8h
mov [rdi+20h], rsi
mov [rdi+30h], rax
mov qword ptr [rdi+28h], 4
test rdx, rdx
jz short locret_4195A
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdx
mov r14, rdi
lea r15, [rdx+18h]
mov rdi, r15
call _malloc
mov [r14+10h], rax
mov [r14], rax
test rax, rax
jz short loc_41950
mov [rax+10h], r15
mov [rax+8], rbx
mov qword ptr [rax], 0
loc_41950:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
locret_4195A:
retn
|
_QWORD * ma_init_alloc_root(long long a1, long long a2, long long a3)
{
_QWORD *result; // rax
long long v5; // r15
*(_OWORD *)a1 = 0LL;
result = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
*(_QWORD *)(a1 + 24) = 32LL;
*(_QWORD *)(a1 + 32) = a2 - 24;
*(_QWORD *)(a1 + 48) = 0LL;
*(_QWORD *)(a1 + 40) = 4LL;
if ( a3 )
{
v5 = a3 + 24;
result = (_QWORD *)malloc(a3 + 24);
*(_QWORD *)(a1 + 16) = result;
*(_QWORD *)a1 = result;
if ( result )
{
result[2] = v5;
result[1] = a3;
*result = 0LL;
}
}
return result;
}
|
ma_init_alloc_root:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],RAX
MOV qword ptr [RDI + 0x18],0x20
ADD RSI,-0x18
MOV qword ptr [RDI + 0x20],RSI
MOV qword ptr [RDI + 0x30],RAX
MOV qword ptr [RDI + 0x28],0x4
TEST RDX,RDX
JZ 0x0014195a
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RDI
LEA R15,[RDX + 0x18]
MOV RDI,R15
CALL 0x00136950
MOV qword ptr [R14 + 0x10],RAX
MOV qword ptr [R14],RAX
TEST RAX,RAX
JZ 0x00141950
MOV qword ptr [RAX + 0x10],R15
MOV qword ptr [RAX + 0x8],RBX
MOV qword ptr [RAX],0x0
LAB_00141950:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
LAB_0014195a:
RET
|
void ma_init_alloc_root(int8 *param_1,long param_2,long param_3)
{
int8 *puVar1;
*param_1 = 0;
param_1[1] = 0;
param_1[2] = 0;
param_1[3] = 0x20;
param_1[4] = param_2 + -0x18;
param_1[6] = 0;
param_1[5] = 4;
if (param_3 != 0) {
puVar1 = (int8 *)malloc(param_3 + 0x18U);
param_1[2] = puVar1;
*param_1 = puVar1;
if (puVar1 != (int8 *)0x0) {
puVar1[2] = param_3 + 0x18U;
puVar1[1] = param_3;
*puVar1 = 0;
}
}
return;
}
|
|
6,804 |
my_message_stderr
|
eloqsql/mysys/my_mess.c
|
void my_message_stderr(uint error __attribute__((unused)),
const char *str, myf MyFlags)
{
DBUG_ENTER("my_message_stderr");
DBUG_PRINT("enter",("message: %s",str));
(void) fflush(stdout);
if (MyFlags & (ME_NOTE | ME_ERROR_LOG_ONLY))
DBUG_VOID_RETURN;
if (MyFlags & ME_BELL)
(void) fputc('\007', stderr);
if (my_progname)
{
(void)fputs(my_progname,stderr); (void)fputs(": ",stderr);
}
(void)fputs(str,stderr);
(void)fputc('\n',stderr);
(void)fflush(stderr);
DBUG_VOID_RETURN;
}
|
O3
|
c
|
my_message_stderr:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq 0x2e6a54(%rip), %rax # 0x390fa0
movq (%rax), %rdi
callq 0x2a400
testl $0x480, %r14d # imm = 0x480
je 0xaa562
popq %rbx
popq %r14
popq %rbp
retq
testb $0x4, %r14b
je 0xaa57c
movq 0x2e6a39(%rip), %rax # 0x390fa8
movq (%rax), %rsi
movl $0x7, %edi
callq 0x2a700
leaq 0xb6b30d(%rip), %rax # 0xc15890
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaa590
callq 0x308a5
movq 0x2e6a11(%rip), %r14 # 0x390fa8
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x2a2c0
movq (%r14), %rsi
movl $0xa, %edi
callq 0x2a700
movq (%r14), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2a400
nop
|
my_message_stderr:
push rbp
mov rbp, rsp
push r14
push rbx
mov r14, rdx
mov rbx, rsi
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
test r14d, 480h
jz short loc_AA562
pop rbx
pop r14
pop rbp
retn
loc_AA562:
test r14b, 4
jz short loc_AA57C
mov rax, cs:stderr_ptr
mov rsi, [rax]
mov edi, 7
call _fputc
loc_AA57C:
lea rax, my_progname
mov rdi, [rax]
test rdi, rdi
jz short loc_AA590
call my_message_stderr_cold_1
loc_AA590:
mov r14, cs:stderr_ptr
mov rsi, [r14]
mov rdi, rbx
call _fputs
mov rsi, [r14]
mov edi, 0Ah
call _fputc
mov rdi, [r14]
pop rbx
pop r14
pop rbp
jmp _fflush
|
long long my_message_stderr(long long a1, long long a2, __int16 a3)
{
long long result; // rax
result = fflush(stdout);
if ( (a3 & 0x480) == 0 )
{
if ( (a3 & 4) != 0 )
fputc(7LL, stderr);
if ( my_progname )
my_message_stderr_cold_1((long long)my_progname);
fputs(a2, stderr);
fputc(10LL, stderr);
return fflush(stderr);
}
return result;
}
|
my_message_stderr:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV R14,RDX
MOV RBX,RSI
MOV RAX,qword ptr [0x00490fa0]
MOV RDI,qword ptr [RAX]
CALL 0x0012a400
TEST R14D,0x480
JZ 0x001aa562
POP RBX
POP R14
POP RBP
RET
LAB_001aa562:
TEST R14B,0x4
JZ 0x001aa57c
MOV RAX,qword ptr [0x00490fa8]
MOV RSI,qword ptr [RAX]
MOV EDI,0x7
CALL 0x0012a700
LAB_001aa57c:
LEA RAX,[0xd15890]
MOV RDI,qword ptr [RAX]
TEST RDI,RDI
JZ 0x001aa590
CALL 0x001308a5
LAB_001aa590:
MOV R14,qword ptr [0x00490fa8]
MOV RSI,qword ptr [R14]
MOV RDI,RBX
CALL 0x0012a2c0
MOV RSI,qword ptr [R14]
MOV EDI,0xa
CALL 0x0012a700
MOV RDI,qword ptr [R14]
POP RBX
POP R14
POP RBP
JMP 0x0012a400
|
void my_message_stderr(int8 param_1,char *param_2,ulong param_3)
{
int *puVar1;
fflush(*(FILE **)PTR_stdout_00490fa0);
if ((param_3 & 0x480) != 0) {
return;
}
if ((param_3 & 4) != 0) {
fputc(7,*(FILE **)PTR_stderr_00490fa8);
}
if (my_progname != 0) {
my_message_stderr_cold_1();
}
puVar1 = PTR_stderr_00490fa8;
fputs(param_2,*(FILE **)PTR_stderr_00490fa8);
fputc(10,*(FILE **)puVar1);
fflush(*(FILE **)puVar1);
return;
}
|
|
6,805 |
fmt::v11::basic_appender<char> fmt::v11::detail::write_escaped_char<char, fmt::v11::basic_appender<char>>(fmt::v11::basic_appender<char>, char)
|
zkingston[P]unknot/build_O0/_deps/fmt-src/include/fmt/format.h
|
auto write_escaped_char(OutputIt out, Char v) -> OutputIt {
Char v_array[1] = {v};
*out++ = static_cast<Char>('\'');
if ((needs_escape(static_cast<uint32_t>(v)) && v != static_cast<Char>('"')) ||
v == static_cast<Char>('\'')) {
out = write_escaped_cp(out,
find_escape_result<Char>{v_array, v_array + 1,
static_cast<uint32_t>(v)});
} else {
*out++ = v;
}
*out++ = static_cast<Char>('\'');
return out;
}
|
O0
|
c
|
fmt::v11::basic_appender<char> fmt::v11::detail::write_escaped_char<char, fmt::v11::basic_appender<char>>(fmt::v11::basic_appender<char>, char):
subq $0x68, %rsp
movb %sil, %al
movq %rdi, 0x58(%rsp)
movb %al, 0x57(%rsp)
movb 0x57(%rsp), %al
movb %al, 0x56(%rsp)
leaq 0x58(%rsp), %rdi
xorl %esi, %esi
callq 0xac9d0
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xac9f0
movq %rax, %rdi
movl $0x27, %esi
callq 0xaca00
movsbl 0x57(%rsp), %edi
callq 0xaf100
testb $0x1, %al
jne 0xaf030
jmp 0xaf03a
movsbl 0x57(%rsp), %eax
cmpl $0x22, %eax
jne 0xaf044
movsbl 0x57(%rsp), %eax
cmpl $0x27, %eax
jne 0xaf08f
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x56(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x56(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
movsbl 0x57(%rsp), %eax
movl %eax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xaf140
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x58(%rsp)
jmp 0xaf0c1
movb 0x57(%rsp), %al
movb %al, 0xf(%rsp)
leaq 0x58(%rsp), %rdi
xorl %esi, %esi
callq 0xac9d0
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xac9f0
movq %rax, %rdi
movb 0xf(%rsp), %al
movsbl %al, %esi
callq 0xaca00
leaq 0x58(%rsp), %rdi
xorl %esi, %esi
callq 0xac9d0
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xac9f0
movq %rax, %rdi
movl $0x27, %esi
callq 0xaca00
movq 0x58(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopl (%rax)
|
_ZN3fmt3v116detail18write_escaped_charIcNS0_14basic_appenderIcEEEET0_S5_T_:
sub rsp, 68h
mov al, sil
mov [rsp+68h+var_10], rdi
mov [rsp+68h+var_11], al
mov al, [rsp+68h+var_11]
mov [rsp+68h+var_12], al
lea rdi, [rsp+68h+var_10]
xor esi, esi
call _ZN3fmt3v1114basic_appenderIcEppEi; fmt::v11::basic_appender<char>::operator++(int)
mov [rsp+68h+var_20], rax
lea rdi, [rsp+68h+var_20]
call _ZN3fmt3v1114basic_appenderIcEdeEv; fmt::v11::basic_appender<char>::operator*(void)
mov rdi, rax
mov esi, 27h ; '''; unsigned int
call _ZN3fmt3v1114basic_appenderIcEaSEc; fmt::v11::basic_appender<char>::operator=(char)
movsx edi, [rsp+68h+var_11]; this
call _ZN3fmt3v116detail12needs_escapeEj; fmt::v11::detail::needs_escape(uint)
test al, 1
jnz short loc_AF030
jmp short loc_AF03A
loc_AF030:
movsx eax, [rsp+68h+var_11]
cmp eax, 22h ; '"'
jnz short loc_AF044
loc_AF03A:
movsx eax, [rsp+68h+var_11]
cmp eax, 27h ; '''
jnz short loc_AF08F
loc_AF044:
mov rax, [rsp+68h+var_10]
mov [rsp+68h+var_30], rax
lea rax, [rsp+68h+var_12]
mov [rsp+68h+var_48], rax
lea rax, [rsp+68h+var_12]
add rax, 1
mov [rsp+68h+var_40], rax
movsx eax, [rsp+68h+var_11]
mov [rsp+68h+var_38], eax
mov rdi, [rsp+68h+var_30]
lea rsi, [rsp+68h+var_48]
call _ZN3fmt3v116detail16write_escaped_cpINS0_14basic_appenderIcEEcEET_S5_RKNS1_18find_escape_resultIT0_EE; fmt::v11::detail::write_escaped_cp<fmt::v11::basic_appender<char>,char>(fmt::v11::basic_appender<char>,fmt::v11::detail::find_escape_result<char> const&)
mov [rsp+68h+var_28], rax
mov rax, [rsp+68h+var_28]
mov [rsp+68h+var_10], rax
jmp short loc_AF0C1
loc_AF08F:
mov al, [rsp+68h+var_11]
mov [rsp+68h+var_59], al
lea rdi, [rsp+68h+var_10]
xor esi, esi
call _ZN3fmt3v1114basic_appenderIcEppEi; fmt::v11::basic_appender<char>::operator++(int)
mov [rsp+68h+var_50], rax
lea rdi, [rsp+68h+var_50]
call _ZN3fmt3v1114basic_appenderIcEdeEv; fmt::v11::basic_appender<char>::operator*(void)
mov rdi, rax
mov al, [rsp+68h+var_59]
movsx esi, al
call _ZN3fmt3v1114basic_appenderIcEaSEc; fmt::v11::basic_appender<char>::operator=(char)
loc_AF0C1:
lea rdi, [rsp+68h+var_10]
xor esi, esi
call _ZN3fmt3v1114basic_appenderIcEppEi; fmt::v11::basic_appender<char>::operator++(int)
mov [rsp+68h+var_58], rax
lea rdi, [rsp+68h+var_58]
call _ZN3fmt3v1114basic_appenderIcEdeEv; fmt::v11::basic_appender<char>::operator*(void)
mov rdi, rax
mov esi, 27h ; '''
call _ZN3fmt3v1114basic_appenderIcEaSEc; fmt::v11::basic_appender<char>::operator=(char)
mov rax, [rsp+68h+var_10]
mov [rsp+68h+var_8], rax
mov rax, [rsp+68h+var_8]
add rsp, 68h
retn
|
long long fmt::v11::detail::write_escaped_char<char,fmt::v11::basic_appender<char>>(long long a1, char a2)
{
long long **v2; // rax
long long **v3; // rax
long long **v4; // rax
char v6; // [rsp+Fh] [rbp-59h]
long long v7; // [rsp+10h] [rbp-58h] BYREF
long long v8; // [rsp+18h] [rbp-50h] BYREF
_QWORD v9[2]; // [rsp+20h] [rbp-48h] BYREF
int v10; // [rsp+30h] [rbp-38h]
long long v11; // [rsp+38h] [rbp-30h]
long long v12; // [rsp+40h] [rbp-28h]
long long v13; // [rsp+48h] [rbp-20h] BYREF
char v14; // [rsp+56h] [rbp-12h] BYREF
char v15; // [rsp+57h] [rbp-11h] BYREF
long long v16; // [rsp+58h] [rbp-10h] BYREF
v16 = a1;
v15 = a2;
v14 = a2;
v13 = fmt::v11::basic_appender<char>::operator++((long long)&v16);
v2 = (long long **)fmt::v11::basic_appender<char>::operator*((long long)&v13);
fmt::v11::basic_appender<char>::operator=(v2, 39);
if ( (fmt::v11::detail::needs_escape((fmt::v11::detail *)(unsigned int)v15, 0x27u) & 1) != 0 && v15 != 34 || v15 == 39 )
{
v11 = v16;
v9[0] = &v14;
v9[1] = &v15;
v10 = v15;
v12 = fmt::v11::detail::write_escaped_cp<fmt::v11::basic_appender<char>,char>(v16, v9);
v16 = v12;
}
else
{
v6 = v15;
v8 = fmt::v11::basic_appender<char>::operator++((long long)&v16);
v3 = (long long **)fmt::v11::basic_appender<char>::operator*((long long)&v8);
fmt::v11::basic_appender<char>::operator=(v3, v6);
}
v7 = fmt::v11::basic_appender<char>::operator++((long long)&v16);
v4 = (long long **)fmt::v11::basic_appender<char>::operator*((long long)&v7);
fmt::v11::basic_appender<char>::operator=(v4, 39);
return v16;
}
|
write_escaped_char<char,fmt::v11::basic_appender<char>>:
SUB RSP,0x68
MOV AL,SIL
MOV qword ptr [RSP + 0x58],RDI
MOV byte ptr [RSP + 0x57],AL
MOV AL,byte ptr [RSP + 0x57]
MOV byte ptr [RSP + 0x56],AL
LEA RDI,[RSP + 0x58]
XOR ESI,ESI
CALL 0x001ac9d0
MOV qword ptr [RSP + 0x48],RAX
LEA RDI,[RSP + 0x48]
CALL 0x001ac9f0
MOV RDI,RAX
MOV ESI,0x27
CALL 0x001aca00
MOVSX EDI,byte ptr [RSP + 0x57]
CALL 0x001af100
TEST AL,0x1
JNZ 0x001af030
JMP 0x001af03a
LAB_001af030:
MOVSX EAX,byte ptr [RSP + 0x57]
CMP EAX,0x22
JNZ 0x001af044
LAB_001af03a:
MOVSX EAX,byte ptr [RSP + 0x57]
CMP EAX,0x27
JNZ 0x001af08f
LAB_001af044:
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x38],RAX
LEA RAX,[RSP + 0x56]
MOV qword ptr [RSP + 0x20],RAX
LEA RAX,[RSP + 0x56]
ADD RAX,0x1
MOV qword ptr [RSP + 0x28],RAX
MOVSX EAX,byte ptr [RSP + 0x57]
MOV dword ptr [RSP + 0x30],EAX
MOV RDI,qword ptr [RSP + 0x38]
LEA RSI,[RSP + 0x20]
CALL 0x001af140
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x58],RAX
JMP 0x001af0c1
LAB_001af08f:
MOV AL,byte ptr [RSP + 0x57]
MOV byte ptr [RSP + 0xf],AL
LEA RDI,[RSP + 0x58]
XOR ESI,ESI
CALL 0x001ac9d0
MOV qword ptr [RSP + 0x18],RAX
LEA RDI,[RSP + 0x18]
CALL 0x001ac9f0
MOV RDI,RAX
MOV AL,byte ptr [RSP + 0xf]
MOVSX ESI,AL
CALL 0x001aca00
LAB_001af0c1:
LEA RDI,[RSP + 0x58]
XOR ESI,ESI
CALL 0x001ac9d0
MOV qword ptr [RSP + 0x10],RAX
LEA RDI,[RSP + 0x10]
CALL 0x001ac9f0
MOV RDI,RAX
MOV ESI,0x27
CALL 0x001aca00
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [RSP + 0x60]
ADD RSP,0x68
RET
|
/* fmt::v11::basic_appender<char> fmt::v11::detail::write_escaped_char<char,
fmt::v11::basic_appender<char> >(fmt::v11::basic_appender<char>, char) */
int8
fmt::v11::detail::write_escaped_char<char,fmt::v11::basic_appender<char>>
(int8 param_1,char param_2)
{
char cVar1;
basic_appender<char> *pbVar2;
ulong uVar3;
int8 local_58;
int8 local_50;
char *local_48;
char *local_40;
int local_38;
int8 local_30;
int8 local_28;
int8 local_20;
char local_12;
char local_11;
int8 local_10 [2];
local_12 = param_2;
local_11 = param_2;
local_10[0] = param_1;
local_20 = basic_appender<char>::operator++((basic_appender<char> *)local_10,0);
pbVar2 = (basic_appender<char> *)
basic_appender<char>::operator*((basic_appender<char> *)&local_20);
basic_appender<char>::operator=(pbVar2,'\'');
uVar3 = needs_escape((int)local_11);
cVar1 = local_11;
if ((((uVar3 & 1) == 0) || (local_11 == '\"')) && (local_11 != '\'')) {
local_50 = basic_appender<char>::operator++((basic_appender<char> *)local_10,0);
pbVar2 = (basic_appender<char> *)
basic_appender<char>::operator*((basic_appender<char> *)&local_50);
basic_appender<char>::operator=(pbVar2,cVar1);
}
else {
local_30 = local_10[0];
local_48 = &local_12;
local_40 = &local_11;
local_38 = (int)local_11;
local_28 = write_escaped_cp<fmt::v11::basic_appender<char>,char>(local_10[0]);
local_10[0] = local_28;
}
local_58 = basic_appender<char>::operator++((basic_appender<char> *)local_10,0);
pbVar2 = (basic_appender<char> *)
basic_appender<char>::operator*((basic_appender<char> *)&local_58);
basic_appender<char>::operator=(pbVar2,'\'');
return local_10[0];
}
|
|
6,806 |
Type_handler_null::make_conversion_table_field(st_mem_root*, TABLE*, unsigned int, Field const*) const
|
eloqsql/sql/sql_type.cc
|
Field *Type_handler_null::make_conversion_table_field(MEM_ROOT *root,
TABLE *table,
uint metadata,
const Field *target)
const
{
return new(root)
Field_null(NULL, 0, Field::NONE, &empty_clex_str, target->charset());
}
|
O0
|
cpp
|
Type_handler_null::make_conversion_table_field(st_mem_root*, TABLE*, unsigned int, Field const*) const:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x68(%rbp)
movl $0xd8, %edi
callq 0x6477b0
movq %rax, %rcx
movq %rcx, -0x60(%rbp)
movb $0x0, -0x29(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x58(%rbp)
je 0x7b0533
movb $0x1, -0x29(%rbp)
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
movq 0x348(%rax), %rax
callq *%rax
movq %rax, -0x70(%rbp)
jmp 0x7b04fe
movq -0x70(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x536f80
jmp 0x7b050d
movq -0x60(%rbp), %rdi
leaq 0xad8088(%rip), %r8 # 0x12885a0
xorl %ecx, %ecx
movl %ecx, %esi
leaq -0x40(%rbp), %r9
movl %ecx, %edx
callq 0x536fc0
jmp 0x7b0529
movq -0x60(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x7b0533
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x7b0551
jmp 0x7b055e
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdi
callq 0x6478c0
jmp 0x7b0560
movq -0x48(%rbp), %rdi
callq 0x433ff0
nopl (%rax)
|
_ZNK17Type_handler_null27make_conversion_table_fieldEP11st_mem_rootP5TABLEjPK5Field:
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_1C], ecx
mov [rbp+var_28], r8
mov rsi, [rbp+var_10]
mov [rbp+var_68], rsi
mov edi, 0D8h
call _ZN5FieldnwEmP11st_mem_root; Field::operator new(ulong,st_mem_root *)
mov rcx, rax
mov [rbp+var_60], rcx
mov [rbp+var_29], 0
xor eax, eax
cmp rcx, 0
mov [rbp+var_58], rax
jz short loc_7B0533
mov [rbp+var_29], 1
mov rdi, [rbp+var_28]
mov rax, [rdi]
mov rax, [rax+348h]
call rax
mov [rbp+var_70], rax
jmp short $+2
loc_7B04FE:
mov rsi, [rbp+var_70]; charset_info_st *
lea rdi, [rbp+var_40]; this
call _ZN11DTCollationC2EPK15charset_info_st; DTCollation::DTCollation(charset_info_st const*)
jmp short $+2
loc_7B050D:
mov rdi, [rbp+var_60]
lea r8, empty_clex_str
xor ecx, ecx
mov esi, ecx
lea r9, [rbp+var_40]
mov edx, ecx
call _ZN10Field_nullC2EPhjN5Field5utypeEPK25st_mysql_const_lex_stringRK11DTCollation; Field_null::Field_null(uchar *,uint,Field::utype,st_mysql_const_lex_string const*,DTCollation const&)
jmp short $+2
loc_7B0529:
mov rax, [rbp+var_60]
mov [rbp+var_58], rax
jmp short $+2
loc_7B0533:
mov rax, [rbp+var_58]
add rsp, 70h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_48], rcx
mov [rbp+var_4C], eax
test [rbp+var_29], 1
jnz short loc_7B0551
jmp short loc_7B055E
loc_7B0551:
mov rsi, [rbp+var_68]
mov rdi, [rbp+var_60]
call _ZN5FielddlEPvP11st_mem_root; Field::operator delete(void *,st_mem_root *)
loc_7B055E:
jmp short $+2
loc_7B0560:
mov rdi, [rbp+var_48]
call __Unwind_Resume
|
_QWORD * Type_handler_null::make_conversion_table_field(
long long a1,
long long a2,
long long a3,
int a4,
long long a5)
{
charset_info_st *v6; // [rsp+0h] [rbp-70h]
_QWORD *v7; // [rsp+10h] [rbp-60h]
long long v8; // [rsp+18h] [rbp-58h]
_BYTE v9[23]; // [rsp+30h] [rbp-40h] BYREF
char v10; // [rsp+47h] [rbp-29h]
long long v11; // [rsp+48h] [rbp-28h]
int v12; // [rsp+54h] [rbp-1Ch]
long long v13; // [rsp+58h] [rbp-18h]
long long v14; // [rsp+60h] [rbp-10h]
long long v15; // [rsp+68h] [rbp-8h]
v15 = a1;
v14 = a2;
v13 = a3;
v12 = a4;
v11 = a5;
v7 = (_QWORD *)Field::operator new(216LL, a2);
v10 = 0;
v8 = 0LL;
if ( v7 )
{
v10 = 1;
v6 = (charset_info_st *)(*(long long ( **)(long long))(*(_QWORD *)v11 + 840LL))(v11);
DTCollation::DTCollation((DTCollation *)v9, v6);
Field_null::Field_null(v7, 0, 0, 0, (long long)&empty_clex_str, (long long)v9);
return v7;
}
return (_QWORD *)v8;
}
|
inline_mysql_file_pwrite:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
LEA RAX,[0x14feeb0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x158]
MOV ESI,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x88]
MOV EDX,0x7
CALL RAX
MOV qword ptr [RBP + -0x40],RAX
CMP qword ptr [RBP + -0x40],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x007b05d1
LEA RAX,[0x14feeb0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x210]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x14]
CALL RAX
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + 0x10]
CALL 0x00d1bc50
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + 0x10]
AND RAX,0x6
CMP RAX,0x0
JZ 0x007b057c
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x007b0561
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x98],RAX
JMP 0x007b056c
LAB_007b0561:
XOR EAX,EAX
MOV qword ptr [RBP + -0x98],RAX
JMP 0x007b056c
LAB_007b056c:
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x90],RAX
JMP 0x007b05a9
LAB_007b057c:
CMP qword ptr [RBP + -0x38],-0x1
JZ 0x007b0590
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x007b059b
LAB_007b0590:
XOR EAX,EAX
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x007b059b
LAB_007b059b:
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0x90],RAX
LAB_007b05a9:
LEA RAX,[0x14feeb0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x90]
CALL RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x007b05f5
LAB_007b05d1:
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + 0x10]
CALL 0x00d1bc50
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
LAB_007b05f5:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0xa0
POP RBP
RET
|
/* inline_mysql_file_pwrite(char const*, unsigned int, int, unsigned char const*, unsigned long,
unsigned long long, unsigned long) */
ulong inline_mysql_file_pwrite
(char *param_1,uint param_2,int param_3,uchar *param_4,ulong param_5,
ulonglong param_6,ulong param_7)
{
ulong local_a8;
ulong local_a0;
ulong local_98;
int1 local_90 [72];
long local_48;
ulong local_40;
ulonglong local_38;
ulong local_30;
uchar *local_28;
int local_20;
uint local_1c;
char *local_18;
ulong local_10;
local_38 = param_6;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
local_48 = (**(code **)(PSI_server + 0x158))(local_90,param_3,7);
if (local_48 == 0) {
local_10 = my_pwrite(local_20,local_28,local_30,local_38,param_7);
}
else {
(**(code **)(PSI_server + 0x210))(local_48,local_30,local_18,local_1c);
local_40 = my_pwrite(local_20,local_28,local_30,local_38,param_7);
if ((param_7 & 6) == 0) {
local_a8 = local_40;
if (local_40 == 0xffffffffffffffff) {
local_a8 = 0;
}
local_98 = local_a8;
}
else {
if (local_40 == 0) {
local_a0 = local_30;
}
else {
local_a0 = 0;
}
local_98 = local_a0;
}
(**(code **)(PSI_server + 0x218))(local_48,local_98);
local_10 = local_40;
}
return local_10;
}
|
|
6,807 |
extend_directory
|
eloqsql/storage/maria/ma_blockrec.c
|
static my_bool extend_directory(MARIA_HA *info, uchar *buff, uint block_size,
uint max_entry, uint new_entry,
uint *empty_space, my_bool head_page)
{
uint length, first_pos;
uchar *dir, *first_dir;
DBUG_ENTER("extend_directory");
/*
Note that in if max_entry is 0, then first_dir will point to
an illegal directory entry. This is ok, as in this case we will
not access anything through first_dir.
*/
first_dir= dir_entry_pos(buff, block_size, max_entry) + DIR_ENTRY_SIZE;
if (make_space_for_directory(info, buff, max_entry,
new_entry - max_entry + 1,
first_dir, empty_space, &first_pos, head_page))
DBUG_RETURN(1);
/* Set the new directory entry to cover the max possible length */
dir= first_dir - DIR_ENTRY_SIZE * (new_entry - max_entry + 1);
length= (uint) (dir - buff - first_pos);
int2store(dir, first_pos);
int2store(dir+2, length);
*empty_space-= length;
if (new_entry-- > max_entry)
{
/* Link all row entries between new_entry and max_entry into free list */
uint free_entry= (uint) buff[DIR_FREE_OFFSET];
uint prev_entry= END_OF_DIR_FREE_LIST;
buff[DIR_FREE_OFFSET]= new_entry;
do
{
dir+= DIR_ENTRY_SIZE;
dir[0]= dir[1]= 0;
dir[2]= (uchar) prev_entry;
dir[3]= (uchar) new_entry-1;
prev_entry= new_entry;
} while (new_entry-- > max_entry);
if ((dir[3]= free_entry) != END_OF_DIR_FREE_LIST)
{
/* Relink next entry to point to newly freed entry */
uchar *next_entry= dir_entry_pos(buff, block_size, (uint) dir[3]);
DBUG_ASSERT(uint2korr(next_entry) == 0 &&
next_entry[2] == END_OF_DIR_FREE_LIST);
next_entry[2]= max_entry;
}
}
check_directory(info->s,
buff, block_size,
head_page ? MY_MIN(info->s->base.min_block_length, length) :
0, *empty_space);
DBUG_RETURN(0);
}
|
O0
|
c
|
extend_directory:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb 0x10(%rbp), %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
callq 0x74fd0
addq $0x4, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x20(%rbp), %edx
movl -0x24(%rbp), %ecx
subl -0x20(%rbp), %ecx
addl $0x1, %ecx
movq -0x48(%rbp), %r8
movq -0x30(%rbp), %r9
leaq -0x38(%rbp), %rax
movq %rax, (%rsp)
movsbl 0x10(%rbp), %eax
movl %eax, 0x8(%rsp)
callq 0x80270
cmpb $0x0, %al
je 0x7a1cb
jmp 0x7a1c2
movb $0x1, -0x1(%rbp)
jmp 0x7a2ff
movq -0x48(%rbp), %rax
movl -0x24(%rbp), %ecx
subl -0x20(%rbp), %ecx
addl $0x1, %ecx
shll $0x2, %ecx
movl %ecx, %ecx
movl %ecx, %edx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movl -0x38(%rbp), %ecx
subq %rcx, %rax
movl %eax, -0x34(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x38(%rbp), %eax
movw %ax, %cx
movq -0x50(%rbp), %rax
movw %cx, (%rax)
jmp 0x7a216
movq -0x40(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x58(%rbp)
movl -0x34(%rbp), %eax
movw %ax, %cx
movq -0x58(%rbp), %rax
movw %cx, (%rax)
movl -0x34(%rbp), %edx
movq -0x30(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movl -0x24(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x24(%rbp)
cmpl -0x20(%rbp), %eax
jbe 0x7a2f9
movq -0x18(%rbp), %rax
movzbl 0x9(%rax), %eax
movl %eax, -0x5c(%rbp)
movl $0xff, -0x60(%rbp)
movl -0x24(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x9(%rax)
movq -0x40(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x40(%rbp), %rax
movb $0x0, (%rax)
movl -0x60(%rbp), %eax
movb %al, %cl
movq -0x40(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x24(%rbp), %eax
movzbl %al, %eax
subl $0x1, %eax
movb %al, %cl
movq -0x40(%rbp), %rax
movb %cl, 0x3(%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x60(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x24(%rbp)
cmpl -0x20(%rbp), %eax
ja 0x7a26e
movl -0x5c(%rbp), %eax
movq -0x40(%rbp), %rcx
movb %al, 0x3(%rcx)
movzbl %al, %eax
cmpl $0xff, %eax
je 0x7a2f7
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x40(%rbp), %rax
movzbl 0x3(%rax), %edx
callq 0x74fd0
movq %rax, -0x68(%rbp)
jmp 0x7a2eb
movl -0x20(%rbp), %eax
movb %al, %cl
movq -0x68(%rbp), %rax
movb %cl, 0x2(%rax)
jmp 0x7a2f9
jmp 0x7a2fb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
extend_directory:
push rbp
mov rbp, rsp
sub rsp, 80h
mov al, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_20], ecx
mov [rbp+var_24], r8d
mov [rbp+var_30], r9
mov rdi, [rbp+var_18]
mov esi, [rbp+var_1C]
mov edx, [rbp+var_20]
call dir_entry_pos
add rax, 4
mov [rbp+var_48], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_20]
mov ecx, [rbp+var_24]
sub ecx, [rbp+var_20]
add ecx, 1
mov r8, [rbp+var_48]
mov r9, [rbp+var_30]
lea rax, [rbp+var_38]
mov [rsp+80h+var_80], rax
movsx eax, [rbp+arg_0]
mov [rsp+80h+var_78], eax
call make_space_for_directory
cmp al, 0
jz short loc_7A1CB
jmp short $+2
loc_7A1C2:
mov [rbp+var_1], 1
jmp loc_7A2FF
loc_7A1CB:
mov rax, [rbp+var_48]
mov ecx, [rbp+var_24]
sub ecx, [rbp+var_20]
add ecx, 1
shl ecx, 2
mov ecx, ecx
mov edx, ecx
xor ecx, ecx
sub rcx, rdx
add rax, rcx
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov rcx, [rbp+var_18]
sub rax, rcx
mov ecx, [rbp+var_38]
sub rax, rcx
mov [rbp+var_34], eax
mov rax, [rbp+var_40]
mov [rbp+var_50], rax
mov eax, [rbp+var_38]
mov cx, ax
mov rax, [rbp+var_50]
mov [rax], cx
jmp short $+2
loc_7A216:
mov rax, [rbp+var_40]
add rax, 2
mov [rbp+var_58], rax
mov eax, [rbp+var_34]
mov cx, ax
mov rax, [rbp+var_58]
mov [rax], cx
mov edx, [rbp+var_34]
mov rax, [rbp+var_30]
mov ecx, [rax]
sub ecx, edx
mov [rax], ecx
mov eax, [rbp+var_24]
mov ecx, eax
add ecx, 0FFFFFFFFh
mov [rbp+var_24], ecx
cmp eax, [rbp+var_20]
jbe loc_7A2F9
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+9]
mov [rbp+var_5C], eax
mov [rbp+var_60], 0FFh
mov eax, [rbp+var_24]
mov cl, al
mov rax, [rbp+var_18]
mov [rax+9], cl
loc_7A26E:
mov rax, [rbp+var_40]
add rax, 4
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov byte ptr [rax+1], 0
mov rax, [rbp+var_40]
mov byte ptr [rax], 0
mov eax, [rbp+var_60]
mov cl, al
mov rax, [rbp+var_40]
mov [rax+2], cl
mov eax, [rbp+var_24]
movzx eax, al
sub eax, 1
mov cl, al
mov rax, [rbp+var_40]
mov [rax+3], cl
mov eax, [rbp+var_24]
mov [rbp+var_60], eax
mov eax, [rbp+var_24]
mov ecx, eax
add ecx, 0FFFFFFFFh
mov [rbp+var_24], ecx
cmp eax, [rbp+var_20]
ja short loc_7A26E
mov eax, [rbp+var_5C]
mov rcx, [rbp+var_40]
mov [rcx+3], al
movzx eax, al
cmp eax, 0FFh
jz short loc_7A2F7
mov rdi, [rbp+var_18]
mov esi, [rbp+var_1C]
mov rax, [rbp+var_40]
movzx edx, byte ptr [rax+3]
call dir_entry_pos
mov [rbp+var_68], rax
jmp short $+2
loc_7A2EB:
mov eax, [rbp+var_20]
mov cl, al
mov rax, [rbp+var_68]
mov [rax+2], cl
loc_7A2F7:
jmp short $+2
loc_7A2F9:
jmp short $+2
loc_7A2FB:
mov [rbp+var_1], 0
loc_7A2FF:
mov al, [rbp+var_1]
add rsp, 80h
pop rbp
retn
|
char extend_directory(long long a1, long long a2, unsigned int a3, int a4, unsigned int a5, _DWORD *a6, char a7)
{
long long v7; // rax
unsigned int v8; // eax
unsigned int v9; // eax
long long v10; // rax
char v12; // [rsp+20h] [rbp-60h]
unsigned __int8 v13; // [rsp+24h] [rbp-5Ch]
long long v14; // [rsp+38h] [rbp-48h]
long long v15; // [rsp+40h] [rbp-40h]
int v16; // [rsp+48h] [rbp-38h] BYREF
int v17; // [rsp+4Ch] [rbp-34h]
_DWORD *v18; // [rsp+50h] [rbp-30h]
unsigned int v19; // [rsp+5Ch] [rbp-24h]
unsigned int v20; // [rsp+60h] [rbp-20h]
unsigned int v21; // [rsp+64h] [rbp-1Ch]
long long v22; // [rsp+68h] [rbp-18h]
long long v23; // [rsp+70h] [rbp-10h]
v23 = a1;
v22 = a2;
v21 = a3;
v20 = a4;
v19 = a5;
v18 = a6;
v7 = dir_entry_pos(a2, a3, a4);
v14 = v7 + 4;
if ( (unsigned __int8)make_space_for_directory(
a1,
a2,
v20,
v19 - v20 + 1,
(int)v7 + 4,
(_DWORD)v18,
(long long)&v16,
a7) )
return 1;
v15 = v14 - 4 * (v19 - v20 + 1);
v17 = v15 - v22 - v16;
*(_WORD *)v15 = v16;
*(_WORD *)(v15 + 2) = v17;
*v18 -= v17;
v8 = v19--;
if ( v8 > v20 )
{
v13 = *(_BYTE *)(v22 + 9);
v12 = -1;
*(_BYTE *)(v22 + 9) = v19;
do
{
v15 += 4LL;
*(_BYTE *)(v15 + 1) = 0;
*(_BYTE *)v15 = 0;
*(_BYTE *)(v15 + 2) = v12;
*(_BYTE *)(v15 + 3) = v19 - 1;
v12 = v19;
v9 = v19--;
}
while ( v9 > v20 );
*(_BYTE *)(v15 + 3) = v13;
if ( v13 != 255 )
{
v10 = dir_entry_pos(v22, v21, *(unsigned __int8 *)(v15 + 3));
*(_BYTE *)(v10 + 2) = v20;
}
}
return 0;
}
|
extend_directory:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV AL,byte ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV dword ptr [RBP + -0x20],ECX
MOV dword ptr [RBP + -0x24],R8D
MOV qword ptr [RBP + -0x30],R9
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x1c]
MOV EDX,dword ptr [RBP + -0x20]
CALL 0x00174fd0
ADD RAX,0x4
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x24]
SUB ECX,dword ptr [RBP + -0x20]
ADD ECX,0x1
MOV R8,qword ptr [RBP + -0x48]
MOV R9,qword ptr [RBP + -0x30]
LEA RAX,[RBP + -0x38]
MOV qword ptr [RSP],RAX
MOVSX EAX,byte ptr [RBP + 0x10]
MOV dword ptr [RSP + 0x8],EAX
CALL 0x00180270
CMP AL,0x0
JZ 0x0017a1cb
JMP 0x0017a1c2
LAB_0017a1c2:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0017a2ff
LAB_0017a1cb:
MOV RAX,qword ptr [RBP + -0x48]
MOV ECX,dword ptr [RBP + -0x24]
SUB ECX,dword ptr [RBP + -0x20]
ADD ECX,0x1
SHL ECX,0x2
MOV ECX,ECX
MOV EDX,ECX
XOR ECX,ECX
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,RCX
MOV ECX,dword ptr [RBP + -0x38]
SUB RAX,RCX
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x50],RAX
MOV EAX,dword ptr [RBP + -0x38]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x50]
MOV word ptr [RAX],CX
JMP 0x0017a216
LAB_0017a216:
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x2
MOV qword ptr [RBP + -0x58],RAX
MOV EAX,dword ptr [RBP + -0x34]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x58]
MOV word ptr [RAX],CX
MOV EDX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RAX]
SUB ECX,EDX
MOV dword ptr [RAX],ECX
MOV EAX,dword ptr [RBP + -0x24]
MOV ECX,EAX
ADD ECX,-0x1
MOV dword ptr [RBP + -0x24],ECX
CMP EAX,dword ptr [RBP + -0x20]
JBE 0x0017a2f9
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x9]
MOV dword ptr [RBP + -0x5c],EAX
MOV dword ptr [RBP + -0x60],0xff
MOV EAX,dword ptr [RBP + -0x24]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x9],CL
LAB_0017a26e:
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x4
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV byte ptr [RAX + 0x1],0x0
MOV RAX,qword ptr [RBP + -0x40]
MOV byte ptr [RAX],0x0
MOV EAX,dword ptr [RBP + -0x60]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x40]
MOV byte ptr [RAX + 0x2],CL
MOV EAX,dword ptr [RBP + -0x24]
MOVZX EAX,AL
SUB EAX,0x1
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x40]
MOV byte ptr [RAX + 0x3],CL
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x60],EAX
MOV EAX,dword ptr [RBP + -0x24]
MOV ECX,EAX
ADD ECX,-0x1
MOV dword ptr [RBP + -0x24],ECX
CMP EAX,dword ptr [RBP + -0x20]
JA 0x0017a26e
MOV EAX,dword ptr [RBP + -0x5c]
MOV RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RCX + 0x3],AL
MOVZX EAX,AL
CMP EAX,0xff
JZ 0x0017a2f7
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x40]
MOVZX EDX,byte ptr [RAX + 0x3]
CALL 0x00174fd0
MOV qword ptr [RBP + -0x68],RAX
JMP 0x0017a2eb
LAB_0017a2eb:
MOV EAX,dword ptr [RBP + -0x20]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x68]
MOV byte ptr [RAX + 0x2],CL
LAB_0017a2f7:
JMP 0x0017a2f9
LAB_0017a2f9:
JMP 0x0017a2fb
LAB_0017a2fb:
MOV byte ptr [RBP + -0x1],0x0
LAB_0017a2ff:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x80
POP RBP
RET
|
int1
extend_directory(int8 param_1,long param_2,int4 param_3,uint param_4,uint param_5,
int *param_6,char param_7)
{
bool bVar1;
char cVar2;
long lVar3;
int2 *puVar4;
uint uVar5;
uint local_68;
int2 *local_48;
int local_40;
int local_3c;
int *local_38;
uint local_2c;
uint local_28;
int4 local_24;
long local_20;
int8 local_18;
int1 local_9;
local_38 = param_6;
local_2c = param_5;
local_28 = param_4;
local_24 = param_3;
local_20 = param_2;
local_18 = param_1;
lVar3 = dir_entry_pos(param_2,param_3,param_4);
cVar2 = make_space_for_directory
(local_18,local_20,local_28,(local_2c - local_28) + 1,lVar3 + 4,local_38,
&local_40,(int)param_7);
if (cVar2 == '\0') {
puVar4 = (int2 *)((lVar3 + 4) - (ulong)(((local_2c - local_28) + 1) * 4));
local_3c = ((int)puVar4 - (int)local_20) - local_40;
*puVar4 = (short)local_40;
puVar4[1] = (short)local_3c;
*local_38 = *local_38 - local_3c;
if (local_28 < local_2c) {
cVar2 = *(char *)(local_20 + 9);
local_68 = 0xff;
*(char *)(local_20 + 9) = (char)(local_2c - 1);
local_2c = local_2c - 1;
do {
local_48 = puVar4;
*(int1 *)((long)local_48 + 5) = 0;
*(int1 *)(local_48 + 2) = 0;
*(char *)(local_48 + 3) = (char)local_68;
*(char *)((long)local_48 + 7) = (char)local_2c + -1;
local_68 = local_2c;
uVar5 = local_2c - 1;
bVar1 = local_28 < local_2c;
puVar4 = local_48 + 2;
local_2c = uVar5;
} while (bVar1);
*(char *)((long)local_48 + 7) = cVar2;
if (cVar2 != -1) {
lVar3 = dir_entry_pos(local_20,local_24,*(int1 *)((long)local_48 + 7));
*(char *)(lVar3 + 2) = (char)local_28;
}
}
local_9 = 0;
}
else {
local_9 = 1;
}
return local_9;
}
|
|
6,808 |
google::protobuf::io::CodedInputStream::DecrementRecursionDepthAndPopLimit(int)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/coded_stream.cc
|
bool CodedInputStream::DecrementRecursionDepthAndPopLimit(Limit limit) {
bool result = ConsumedEntireMessage();
PopLimit(limit);
GOOGLE_DCHECK_LT(recursion_budget_, recursion_limit_);
++recursion_budget_;
return result;
}
|
O0
|
cpp
|
google::protobuf::io::CodedInputStream::DecrementRecursionDepthAndPopLimit(int):
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x22140
movq 0x10(%rsp), %rdi
andb $0x1, %al
movb %al, 0x6b(%rsp)
movl 0x6c(%rsp), %esi
callq 0x1e710
xorl %eax, %eax
testb $0x1, %al
jne 0x1e82b
jmp 0x1e8ca
movq 0x10(%rsp), %rcx
movl 0x34(%rcx), %eax
movl 0x38(%rcx), %ecx
movb $0x0, 0x2f(%rsp)
cmpl %ecx, %eax
jge 0x1e841
jmp 0x1e88f
leaq 0x1cd33b(%rip), %rdx # 0x1ebb83
leaq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x3, %esi
movl $0xa2, %ecx
callq 0x237e0
movq (%rsp), %rdi
movb $0x1, 0x2f(%rsp)
leaq 0x1cd37f(%rip), %rsi # 0x1ebbef
callq 0x230a0
movq %rax, 0x8(%rsp)
jmp 0x1e87c
movq 0x8(%rsp), %rsi
leaq 0x1b(%rsp), %rdi
callq 0x23250
jmp 0x1e88d
jmp 0x1e88f
testb $0x1, 0x2f(%rsp)
jne 0x1e898
jmp 0x1e8a2
leaq 0x30(%rsp), %rdi
callq 0x23820
jmp 0x1e820
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
testb $0x1, 0x2f(%rsp)
jne 0x1e8be
jmp 0x1e8c8
leaq 0x30(%rsp), %rdi
callq 0x23820
jmp 0x1e8e3
movq 0x10(%rsp), %rax
movl 0x34(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x34(%rax)
movb 0x6b(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x13750
nopl (%rax)
|
_ZN6google8protobuf2io16CodedInputStream34DecrementRecursionDepthAndPopLimitEi:
sub rsp, 78h
mov [rsp+78h+var_8], rdi
mov [rsp+78h+var_C], esi
mov rdi, [rsp+78h+var_8]; this
mov [rsp+78h+var_68], rdi
call _ZN6google8protobuf2io16CodedInputStream21ConsumedEntireMessageEv; google::protobuf::io::CodedInputStream::ConsumedEntireMessage(void)
mov rdi, [rsp+78h+var_68]; this
and al, 1
mov [rsp+78h+var_D], al
mov esi, [rsp+78h+var_C]; int
call _ZN6google8protobuf2io16CodedInputStream8PopLimitEi; google::protobuf::io::CodedInputStream::PopLimit(int)
loc_1E820:
xor eax, eax
test al, 1
jnz short loc_1E82B
jmp loc_1E8CA
loc_1E82B:
mov rcx, [rsp+78h+var_68]
mov eax, [rcx+34h]
mov ecx, [rcx+38h]
mov [rsp+78h+var_49], 0
cmp eax, ecx
jge short loc_1E841
jmp short loc_1E88F
loc_1E841:
lea rdx, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+78h+var_48]
mov [rsp+78h+var_78], rdi
mov esi, 3
mov ecx, 0A2h
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+78h+var_78]
mov [rsp+78h+var_49], 1
lea rsi, aCheckFailedRec; "CHECK failed: (recursion_budget_) < (re"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+78h+var_70], rax
jmp short $+2
loc_1E87C:
mov rsi, [rsp+78h+var_70]
lea rdi, [rsp+78h+var_5D]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_1E88D:
jmp short $+2
loc_1E88F:
test [rsp+78h+var_49], 1
jnz short loc_1E898
jmp short loc_1E8A2
loc_1E898:
lea rdi, [rsp+78h+var_48]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_1E8A2:
jmp loc_1E820
mov rcx, rax
mov eax, edx
mov [rsp+arg_18], rcx
mov [rsp+arg_14], eax
test [rsp+arg_27], 1
jnz short loc_1E8BE
jmp short loc_1E8C8
loc_1E8BE:
lea rdi, [rsp+arg_28]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_1E8C8:
jmp short loc_1E8E3
loc_1E8CA:
mov rax, [rsp+78h+var_68]
mov ecx, [rax+34h]
add ecx, 1
mov [rax+34h], ecx
mov al, [rsp+78h+var_D]
and al, 1
add rsp, 78h
retn
loc_1E8E3:
mov rdi, [rsp+arg_18]
call __Unwind_Resume
|
char google::protobuf::io::CodedInputStream::DecrementRecursionDepthAndPopLimit(
google::protobuf::io::CodedInputStream *this,
int a2)
{
char v3; // [rsp+6Bh] [rbp-Dh]
int v4; // [rsp+6Ch] [rbp-Ch]
google::protobuf::io::CodedInputStream *v5; // [rsp+70h] [rbp-8h]
v5 = this;
v4 = a2;
v3 = google::protobuf::io::CodedInputStream::ConsumedEntireMessage(this) & 1;
google::protobuf::io::CodedInputStream::PopLimit(this, a2);
++*((_DWORD *)this + 13);
return v3 & 1;
}
|
DecrementRecursionDepthAndPopLimit:
SUB RSP,0x78
MOV qword ptr [RSP + 0x70],RDI
MOV dword ptr [RSP + 0x6c],ESI
MOV RDI,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x10],RDI
CALL 0x00122140
MOV RDI,qword ptr [RSP + 0x10]
AND AL,0x1
MOV byte ptr [RSP + 0x6b],AL
MOV ESI,dword ptr [RSP + 0x6c]
CALL 0x0011e710
LAB_0011e820:
XOR EAX,EAX
TEST AL,0x1
JNZ 0x0011e82b
JMP 0x0011e8ca
LAB_0011e82b:
MOV RCX,qword ptr [RSP + 0x10]
MOV EAX,dword ptr [RCX + 0x34]
MOV ECX,dword ptr [RCX + 0x38]
MOV byte ptr [RSP + 0x2f],0x0
CMP EAX,ECX
JGE 0x0011e841
JMP 0x0011e88f
LAB_0011e841:
LEA RDX,[0x2ebb83]
LEA RDI,[RSP + 0x30]
MOV qword ptr [RSP],RDI
MOV ESI,0x3
MOV ECX,0xa2
CALL 0x001237e0
MOV RDI,qword ptr [RSP]
MOV byte ptr [RSP + 0x2f],0x1
LAB_0011e869:
LEA RSI,[0x2ebbef]
CALL 0x001230a0
MOV qword ptr [RSP + 0x8],RAX
JMP 0x0011e87c
LAB_0011e87c:
MOV RSI,qword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x1b]
CALL 0x00123250
LAB_0011e88b:
JMP 0x0011e88d
LAB_0011e88d:
JMP 0x0011e88f
LAB_0011e88f:
TEST byte ptr [RSP + 0x2f],0x1
JNZ 0x0011e898
JMP 0x0011e8a2
LAB_0011e898:
LEA RDI,[RSP + 0x30]
CALL 0x00123820
LAB_0011e8a2:
JMP 0x0011e820
LAB_0011e8ca:
MOV RAX,qword ptr [RSP + 0x10]
MOV ECX,dword ptr [RAX + 0x34]
ADD ECX,0x1
MOV dword ptr [RAX + 0x34],ECX
MOV AL,byte ptr [RSP + 0x6b]
AND AL,0x1
ADD RSP,0x78
RET
|
/* WARNING: Removing unreachable block (ram,0x0011e82b) */
/* WARNING: Removing unreachable block (ram,0x0011e841) */
/* WARNING: Removing unreachable block (ram,0x0011e83f) */
/* WARNING: Removing unreachable block (ram,0x0011e88f) */
/* WARNING: Removing unreachable block (ram,0x0011e898) */
/* WARNING: Removing unreachable block (ram,0x0011e896) */
/* WARNING: Removing unreachable block (ram,0x0011e8a2) */
/* google::protobuf::io::CodedInputStream::DecrementRecursionDepthAndPopLimit(int) */
ulong __thiscall
google::protobuf::io::CodedInputStream::DecrementRecursionDepthAndPopLimit
(CodedInputStream *this,int param_1)
{
int1 uVar1;
uVar1 = ConsumedEntireMessage(this);
PopLimit(this,param_1);
*(int *)(this + 0x34) = *(int *)(this + 0x34) + 1;
return CONCAT71((int7)((ulong)this >> 8),uVar1) & 0xffffffffffffff01;
}
|
|
6,809 |
PFS_buffer_scalable_container<PFS_cond, 256, 256, PFS_buffer_default_array<PFS_cond>, PFS_buffer_default_allocator<PFS_cond>>::deallocate(PFS_cond*)
|
eloqsql/storage/perfschema/pfs_buffer_container.h
|
void deallocate(value_type *safe_pfs)
{
/* Find the containing page */
PFS_opaque_container_page *opaque_page= safe_pfs->m_page;
array_type *page= reinterpret_cast<array_type *> (opaque_page);
/* Mark the object free */
safe_pfs->m_lock.allocated_to_free();
/* Flag the containing page as not full. */
page->m_full= false;
/* Flag the overall container as not full. */
m_full= false;
}
|
O0
|
c
|
PFS_buffer_scalable_container<PFS_cond, 256, 256, PFS_buffer_default_array<PFS_cond>, PFS_buffer_default_allocator<PFS_cond>>::deallocate(PFS_cond*):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x158(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x37eb0
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rcx)
movb $0x0, 0x9(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
_ZN29PFS_buffer_scalable_containerI21PFS_table_share_indexLi8192ELi8192E24PFS_buffer_default_arrayIS0_E28PFS_buffer_default_allocatorIS0_EE10deallocateEPS0_:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov rax, [rax+158h]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov [rbp+var_20], rax
mov rdi, [rbp+var_10]; this
call _ZN8pfs_lock17allocated_to_freeEv; pfs_lock::allocated_to_free(void)
mov rax, [rbp+var_28]
mov rcx, [rbp+var_20]
mov byte ptr [rcx], 0
mov byte ptr [rax+9], 0
add rsp, 30h
pop rbp
retn
|
long long PFS_buffer_scalable_container<PFS_table_share_index,8192,8192,PFS_buffer_default_array<PFS_table_share_index>,PFS_buffer_default_allocator<PFS_table_share_index>>::deallocate(
long long a1,
pfs_lock *a2)
{
long long result; // rax
_BYTE *v3; // [rsp+10h] [rbp-20h]
v3 = (_BYTE *)*((_QWORD *)a2 + 43);
pfs_lock::allocated_to_free(a2);
result = a1;
*v3 = 0;
*(_BYTE *)(a1 + 9) = 0;
return result;
}
|
deallocate:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x158]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00137eb0
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x20]
MOV byte ptr [RCX],0x0
MOV byte ptr [RAX + 0x9],0x0
ADD RSP,0x30
POP RBP
RET
|
/* PFS_buffer_scalable_container<PFS_table_share_index, 8192, 8192,
PFS_buffer_default_array<PFS_table_share_index>,
PFS_buffer_default_allocator<PFS_table_share_index> >::deallocate(PFS_table_share_index*) */
void __thiscall
PFS_buffer_scalable_container<PFS_table_share_index,8192,8192,PFS_buffer_default_array<PFS_table_share_index>,PFS_buffer_default_allocator<PFS_table_share_index>>
::deallocate(PFS_buffer_scalable_container<PFS_table_share_index,8192,8192,PFS_buffer_default_array<PFS_table_share_index>,PFS_buffer_default_allocator<PFS_table_share_index>>
*this,PFS_table_share_index *param_1)
{
int1 *puVar1;
puVar1 = *(int1 **)(param_1 + 0x158);
pfs_lock::allocated_to_free((pfs_lock *)param_1);
*puVar1 = 0;
this[9] = (PFS_buffer_scalable_container<PFS_table_share_index,8192,8192,PFS_buffer_default_array<PFS_table_share_index>,PFS_buffer_default_allocator<PFS_table_share_index>>
)0x0;
return;
}
|
|
6,810 |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator=(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>)
|
monkey531[P]llama/common/./json.hpp
|
basic_json& operator=(basic_json other) noexcept (
std::is_nothrow_move_constructible<value_t>::value&&
std::is_nothrow_move_assignable<value_t>::value&&
std::is_nothrow_move_constructible<json_value>::value&&
std::is_nothrow_move_assignable<json_value>::value&&
std::is_nothrow_move_assignable<json_base_class_t>::value
)
{
// check that passed value is valid
other.assert_invariant();
using std::swap;
swap(m_data.m_type, other.m_data.m_type);
swap(m_data.m_value, other.m_data.m_value);
json_base_class_t::operator=(std::move(other));
set_parents();
assert_invariant();
return *this;
}
|
O0
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator=(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>):
subq $0x28, %rsp
movq %rsi, (%rsp)
movq %rdi, %rax
movq (%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq %rax, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x1, %esi
callq 0x9f9a0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0xc3610
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
addq $0x8, %rsi
callq 0xc3640
movq 0x10(%rsp), %rdi
callq 0x9faf0
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x9f9a0
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_:
sub rsp, 28h
mov [rsp+28h+var_28], rsi
mov rax, rdi
mov rdi, [rsp+28h+var_28]
mov [rsp+28h+var_20], rdi
mov [rsp+28h+var_8], rax
mov [rsp+28h+var_10], rdi
mov rax, [rsp+28h+var_8]
mov [rsp+28h+var_18], rax
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rsi, [rsp+28h+var_20]
mov rdi, [rsp+28h+var_18]
call _ZSt4swapIN8nlohmann16json_abi_v3_11_36detail7value_tEENSt9enable_ifIXsr6__and_ISt6__not_ISt15__is_tuple_likeIT_EESt21is_move_constructibleIS7_ESt18is_move_assignableIS7_EEE5valueEvE4typeERS7_SG_
mov rsi, [rsp+28h+var_20]
mov rdi, [rsp+28h+var_18]
add rdi, 8
add rsi, 8
call _ZSt4swapIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvE10json_valueEENSt9enable_ifIXsr6__and_ISt6__not_ISt15__is_tuple_likeIT_EESt21is_move_constructibleISJ_ESt18is_move_assignableISJ_EEE5valueEvE4typeERSJ_SS_
mov rdi, [rsp+28h+var_18]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE11set_parentsEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::set_parents(void)
mov rdi, [rsp+28h+var_18]
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rax, [rsp+28h+var_18]
add rsp, 28h
retn
|
long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
long long a1,
long long a2)
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(a2);
std::swap<nlohmann::json_abi_v3_11_3::detail::value_t>(a1, a2);
std::swap<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::json_value>(
a1 + 8,
a2 + 8);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::set_parents();
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(a1);
return a1;
}
|
pair:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV RDI,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x8]
MOV AL,byte ptr [RAX]
MOV byte ptr [RDI],AL
ADD RDI,0x8
MOV RSI,qword ptr [RSP + 0x8]
ADD RSI,0x8
CALL 0x001521a0
ADD RSP,0x18
RET
|
/* std::pair<char const, std::__cxx11::string >::pair(std::pair<char const, std::__cxx11::string >
const&) */
void __thiscall
std::pair<char_const,std::__cxx11::string>::pair
(pair<char_const,std::__cxx11::string> *this,pair *param_1)
{
*this = (pair<char_const,std::__cxx11::string>)*param_1;
std::__cxx11::string::string((string *)(this + 8),(string *)(param_1 + 8));
return;
}
|
|
6,811 |
ChunkAABB::contains(glm::vec<3, int, (glm::qualifier)0> const&) const
|
untodesu[P]voxelius/game/shared/chunk_aabb.cc
|
bool ChunkAABB::contains(const chunk_pos &point) const
{
if((point.x < min.x) || (point.x > max.x))
return false;
if((point.y < min.y) || (point.y > max.y))
return false;
if((point.z < min.z) || (point.z > max.z))
return false;
return true;
}
|
O0
|
cpp
|
ChunkAABB::contains(glm::vec<3, int, (glm::qualifier)0> const&) const:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl 0x8(%rcx), %eax
jl 0x91b3e
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl 0x14(%rcx), %eax
jle 0x91b44
movb $0x0, -0x1(%rbp)
jmp 0x91b94
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
cmpl 0xc(%rcx), %eax
jl 0x91b64
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
cmpl 0x18(%rcx), %eax
jle 0x91b6a
movb $0x0, -0x1(%rbp)
jmp 0x91b94
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
cmpl 0x10(%rcx), %eax
jl 0x91b8a
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
cmpl 0x1c(%rcx), %eax
jle 0x91b90
movb $0x0, -0x1(%rbp)
jmp 0x91b94
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
|
_ZNK9ChunkAABB8containsERKN3glm3vecILi3EiLNS0_9qualifierE0EEE:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rcx, [rbp+var_10]
mov [rbp+var_20], rcx
mov rax, [rbp+var_18]
mov eax, [rax]
cmp eax, [rcx+8]
jl short loc_91B3E
mov rcx, [rbp+var_20]
mov rax, [rbp+var_18]
mov eax, [rax]
cmp eax, [rcx+14h]
jle short loc_91B44
loc_91B3E:
mov [rbp+var_1], 0
jmp short loc_91B94
loc_91B44:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_18]
mov eax, [rax+4]
cmp eax, [rcx+0Ch]
jl short loc_91B64
mov rcx, [rbp+var_20]
mov rax, [rbp+var_18]
mov eax, [rax+4]
cmp eax, [rcx+18h]
jle short loc_91B6A
loc_91B64:
mov [rbp+var_1], 0
jmp short loc_91B94
loc_91B6A:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_18]
mov eax, [rax+8]
cmp eax, [rcx+10h]
jl short loc_91B8A
mov rcx, [rbp+var_20]
mov rax, [rbp+var_18]
mov eax, [rax+8]
cmp eax, [rcx+1Ch]
jle short loc_91B90
loc_91B8A:
mov [rbp+var_1], 0
jmp short loc_91B94
loc_91B90:
mov [rbp+var_1], 1
loc_91B94:
mov al, [rbp+var_1]
and al, 1
pop rbp
retn
|
bool ChunkAABB::contains(_DWORD *a1, _DWORD *a2)
{
if ( *a2 < a1[2] || *a2 > a1[5] )
return 0;
if ( a2[1] >= a1[3] && a2[1] <= a1[6] )
return a2[2] >= a1[4] && a2[2] <= a1[7];
return 0;
}
|
contains:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
CMP EAX,dword ptr [RCX + 0x8]
JL 0x00191b3e
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
CMP EAX,dword ptr [RCX + 0x14]
JLE 0x00191b44
LAB_00191b3e:
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00191b94
LAB_00191b44:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x4]
CMP EAX,dword ptr [RCX + 0xc]
JL 0x00191b64
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x4]
CMP EAX,dword ptr [RCX + 0x18]
JLE 0x00191b6a
LAB_00191b64:
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00191b94
LAB_00191b6a:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x8]
CMP EAX,dword ptr [RCX + 0x10]
JL 0x00191b8a
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x8]
CMP EAX,dword ptr [RCX + 0x1c]
JLE 0x00191b90
LAB_00191b8a:
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00191b94
LAB_00191b90:
MOV byte ptr [RBP + -0x1],0x1
LAB_00191b94:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
POP RBP
RET
|
/* ChunkAABB::contains(glm::vec<3, int, (glm::qualifier)0> const&) const */
int8 __thiscall ChunkAABB::contains(ChunkAABB *this,vec *param_1)
{
uint uVar1;
ulong uVar2;
int1 local_9;
uVar1 = *(uint *)param_1;
if (((int)uVar1 < *(int *)(this + 8)) ||
(uVar1 = *(uint *)param_1, *(int *)(this + 0x14) < (int)uVar1)) {
uVar2 = (ulong)uVar1;
local_9 = 0;
}
else {
uVar1 = *(uint *)(param_1 + 4);
if (((int)uVar1 < *(int *)(this + 0xc)) ||
(uVar1 = *(uint *)(param_1 + 4), *(int *)(this + 0x18) < (int)uVar1)) {
uVar2 = (ulong)uVar1;
local_9 = 0;
}
else {
uVar2 = (ulong)*(uint *)(param_1 + 8);
if (((int)*(uint *)(param_1 + 8) < *(int *)(this + 0x10)) ||
(uVar2 = (ulong)*(uint *)(param_1 + 8), *(int *)(this + 0x1c) < (int)*(uint *)(param_1 + 8)
)) {
local_9 = 0;
}
else {
local_9 = 1;
}
}
}
return CONCAT71((int7)(uVar2 >> 8),local_9);
}
|
|
6,812 |
ma_init_block_record_data
|
eloqsql/storage/maria/ma_blockrec.c
|
void _ma_init_block_record_data(void)
{
uint i;
bzero(total_header_size, sizeof(total_header_size));
total_header_size[0]= FLAG_SIZE; /* Flag uchar */
for (i= 1; i < array_elements(total_header_size); i++)
{
uint size= FLAG_SIZE, j, bit;
for (j= 0; (bit= (1 << j)) <= i; j++)
{
if (i & bit)
size+= header_sizes[j];
}
total_header_size[i]= size;
}
}
|
O3
|
c
|
ma_init_block_record_data:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
movaps %xmm0, 0x3bdf46(%rip) # 0x406d00
movb $0x1, 0x3bdf3f(%rip) # 0x406d00
movl $0x1, %eax
leaq 0x3bdf33(%rip), %rdx # 0x406d00
leaq 0x9e248(%rip), %rsi # 0xe701c
movb $0x1, %dil
xorl %ecx, %ecx
movl $0x1, %r8d
testl %eax, %r8d
je 0x48deb
movl %ecx, %r8d
addb (%r8,%rsi), %dil
incl %ecx
movl $0x1, %r8d
shll %cl, %r8d
cmpq %r8, %rax
jae 0x48ddf
movb %dil, (%rax,%rdx)
incq %rax
cmpq $0x10, %rax
jne 0x48dd4
popq %rbp
retq
|
_ma_init_block_record_data:
push rbp
mov rbp, rsp
xorps xmm0, xmm0
movaps cs:total_header_size, xmm0
mov byte ptr cs:total_header_size, 1
mov eax, 1
lea rdx, total_header_size
lea rsi, header_sizes
loc_48DD4:
mov dil, 1
xor ecx, ecx
mov r8d, 1
loc_48DDF:
test r8d, eax
jz short loc_48DEB
mov r8d, ecx
add dil, [r8+rsi]
loc_48DEB:
inc ecx
mov r8d, 1
shl r8d, cl
cmp rax, r8
jnb short loc_48DDF
mov [rax+rdx], dil
inc rax
cmp rax, 10h
jnz short loc_48DD4
pop rbp
retn
|
unsigned long long ma_init_block_record_data()
{
unsigned long long result; // rax
char v1; // di
int v2; // ecx
unsigned long long v3; // r8
total_header_size = 0LL;
LOBYTE(total_header_size) = 1;
for ( result = 1LL; result != 16; ++result )
{
v1 = 1;
v2 = 0;
LODWORD(v3) = 1;
do
{
if ( ((unsigned int)result & (unsigned int)v3) != 0 )
v1 += header_sizes[v2];
v3 = (unsigned int)(1 << ++v2);
}
while ( result >= v3 );
*((_BYTE *)&total_header_size + result) = v1;
}
return result;
}
|
_ma_init_block_record_data:
PUSH RBP
MOV RBP,RSP
XORPS XMM0,XMM0
MOVAPS xmmword ptr [0x00506d00],XMM0
MOV byte ptr [0x00506d00],0x1
MOV EAX,0x1
LEA RDX,[0x506d00]
LEA RSI,[0x1e701c]
LAB_00148dd4:
MOV DIL,0x1
XOR ECX,ECX
MOV R8D,0x1
LAB_00148ddf:
TEST R8D,EAX
JZ 0x00148deb
MOV R8D,ECX
ADD DIL,byte ptr [R8 + RSI*0x1]
LAB_00148deb:
INC ECX
MOV R8D,0x1
SHL R8D,CL
CMP RAX,R8
JNC 0x00148ddf
MOV byte ptr [RAX + RDX*0x1],DIL
INC RAX
CMP RAX,0x10
JNZ 0x00148dd4
POP RBP
RET
|
void _ma_init_block_record_data(void)
{
ulong uVar1;
uint uVar2;
ulong uVar3;
char cVar4;
ulong uVar5;
total_header_size._8_8_ = 0;
total_header_size._0_8_ = 1;
uVar1 = 1;
do {
cVar4 = '\x01';
uVar3 = 0;
uVar5 = 1;
do {
if (((uint)uVar5 & (uint)uVar1) != 0) {
cVar4 = cVar4 + (&header_sizes)[uVar3];
}
uVar2 = (int)uVar3 + 1;
uVar3 = (ulong)uVar2;
uVar5 = (ulong)(uint)(1 << ((byte)uVar2 & 0x1f));
} while (uVar5 <= uVar1);
total_header_size[uVar1] = cVar4;
uVar1 = uVar1 + 1;
} while (uVar1 != 0x10);
return;
}
|
|
6,813 |
getopt_ll_limit_value
|
eloqsql/mysys/my_getopt.c
|
longlong getopt_ll_limit_value(longlong num, const struct my_option *optp,
my_bool *fix)
{
longlong old= num;
my_bool adjusted= FALSE;
char buf1[255], buf2[255];
ulonglong block_size= (optp->block_size ? (ulonglong) optp->block_size : 1L);
DBUG_ENTER("getopt_ll_limit_value");
if (num > 0 && ((ulonglong) num > (ulonglong) optp->max_value) &&
optp->max_value) /* if max value is not set -> no upper limit */
{
num= (ulonglong) optp->max_value;
adjusted= TRUE;
}
switch ((optp->var_type & GET_TYPE_MASK)) {
case GET_INT:
if (num > (longlong) INT_MAX)
{
num= ((longlong) INT_MAX);
adjusted= TRUE;
}
break;
case GET_LONG:
#if SIZEOF_LONG < SIZEOF_LONG_LONG
if (num > (longlong) LONG_MAX)
{
num= ((longlong) LONG_MAX);
adjusted= TRUE;
}
#endif
break;
default:
DBUG_ASSERT((optp->var_type & GET_TYPE_MASK) == GET_LL);
break;
}
num= (num / block_size);
num= (longlong) (num * block_size);
if (num < optp->min_value)
{
num= optp->min_value;
if (old < optp->min_value)
adjusted= TRUE;
}
if (fix)
*fix= old != num;
else if (adjusted)
my_getopt_error_reporter(WARNING_LEVEL,
"option '%s': signed value %s adjusted to %s",
optp->name, llstr(old, buf1), llstr(num, buf2));
DBUG_RETURN(num);
}
|
O0
|
c
|
getopt_ll_limit_value:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp # imm = 0x270
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x218(%rbp)
movq %rsi, -0x220(%rbp)
movq %rdx, -0x228(%rbp)
movq -0x218(%rbp), %rax
movq %rax, -0x230(%rbp)
movb $0x0, -0x231(%rbp)
movq -0x220(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x2b664
movq -0x220(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x248(%rbp)
jmp 0x2b672
movl $0x1, %eax
movq %rax, -0x248(%rbp)
jmp 0x2b672
movq -0x248(%rbp), %rax
movq %rax, -0x240(%rbp)
cmpq $0x0, -0x218(%rbp)
jle 0x2b6c5
movq -0x218(%rbp), %rax
movq -0x220(%rbp), %rcx
cmpq 0x50(%rcx), %rax
jbe 0x2b6c5
movq -0x220(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x2b6c5
movq -0x220(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x218(%rbp)
movb $0x1, -0x231(%rbp)
movq -0x220(%rbp), %rax
movq 0x30(%rax), %rax
andl $0x3f, %eax
movq %rax, -0x250(%rbp)
subq $0x3, %rax
je 0x2b6f1
jmp 0x2b6e2
movq -0x250(%rbp), %rax
subq $0x5, %rax
je 0x2b712
jmp 0x2b714
cmpq $0x7fffffff, -0x218(%rbp) # imm = 0x7FFFFFFF
jle 0x2b710
movq $0x7fffffff, -0x218(%rbp) # imm = 0x7FFFFFFF
movb $0x1, -0x231(%rbp)
jmp 0x2b71a
jmp 0x2b71a
jmp 0x2b716
jmp 0x2b718
jmp 0x2b71a
movq -0x218(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x240(%rbp)
movq %rax, -0x218(%rbp)
movq -0x218(%rbp), %rax
imulq -0x240(%rbp), %rax
movq %rax, -0x218(%rbp)
movq -0x218(%rbp), %rax
movq -0x220(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jge 0x2b78c
movq -0x220(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x218(%rbp)
movq -0x230(%rbp), %rax
movq -0x220(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jge 0x2b78a
movb $0x1, -0x231(%rbp)
jmp 0x2b78c
cmpq $0x0, -0x228(%rbp)
je 0x2b7bc
movq -0x230(%rbp), %rax
cmpq -0x218(%rbp), %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movb %al, %cl
movq -0x228(%rbp), %rax
movb %cl, (%rax)
jmp 0x2b83f
cmpb $0x0, -0x231(%rbp)
je 0x2b83d
leaq 0x1ade64(%rip), %rax # 0x1d9630
movq (%rax), %rax
movq %rax, -0x258(%rbp)
movq -0x220(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x268(%rbp)
movq -0x230(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0x7ce10
movq %rax, -0x260(%rbp)
movq -0x218(%rbp), %rdi
leaq -0x210(%rbp), %rsi
callq 0x7ce10
movq -0x268(%rbp), %rdx
movq -0x260(%rbp), %rcx
movq -0x258(%rbp), %r9
movq %rax, %r8
movl $0x1, %edi
leaq 0x57790(%rip), %rsi # 0x82fc8
movb $0x0, %al
callq *%r9
jmp 0x2b83f
jmp 0x2b841
movq -0x218(%rbp), %rax
movq %rax, -0x270(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x2b871
movq -0x270(%rbp), %rax
addq $0x270, %rsp # imm = 0x270
popq %rbp
retq
callq 0x25390
nopw %cs:(%rax,%rax)
|
getopt_ll_limit_value:
push rbp
mov rbp, rsp
sub rsp, 270h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_218], rdi
mov [rbp+var_220], rsi
mov [rbp+var_228], rdx
mov rax, [rbp+var_218]
mov [rbp+var_230], rax
mov [rbp+var_231], 0
mov rax, [rbp+var_220]
cmp qword ptr [rax+60h], 0
jz short loc_2B664
mov rax, [rbp+var_220]
mov rax, [rax+60h]
mov [rbp+var_248], rax
jmp short loc_2B672
loc_2B664:
mov eax, 1
mov [rbp+var_248], rax
jmp short $+2
loc_2B672:
mov rax, [rbp+var_248]
mov [rbp+var_240], rax
cmp [rbp+var_218], 0
jle short loc_2B6C5
mov rax, [rbp+var_218]
mov rcx, [rbp+var_220]
cmp rax, [rcx+50h]
jbe short loc_2B6C5
mov rax, [rbp+var_220]
cmp qword ptr [rax+50h], 0
jz short loc_2B6C5
mov rax, [rbp+var_220]
mov rax, [rax+50h]
mov [rbp+var_218], rax
mov [rbp+var_231], 1
loc_2B6C5:
mov rax, [rbp+var_220]
mov rax, [rax+30h]
and eax, 3Fh
mov [rbp+var_250], rax
sub rax, 3
jz short loc_2B6F1
jmp short $+2
loc_2B6E2:
mov rax, [rbp+var_250]
sub rax, 5
jz short loc_2B712
jmp short loc_2B714
loc_2B6F1:
cmp [rbp+var_218], 7FFFFFFFh
jle short loc_2B710
mov [rbp+var_218], 7FFFFFFFh
mov [rbp+var_231], 1
loc_2B710:
jmp short loc_2B71A
loc_2B712:
jmp short loc_2B71A
loc_2B714:
jmp short $+2
loc_2B716:
jmp short $+2
loc_2B718:
jmp short $+2
loc_2B71A:
mov rax, [rbp+var_218]
xor ecx, ecx
mov edx, ecx
div [rbp+var_240]
mov [rbp+var_218], rax
mov rax, [rbp+var_218]
imul rax, [rbp+var_240]
mov [rbp+var_218], rax
mov rax, [rbp+var_218]
mov rcx, [rbp+var_220]
cmp rax, [rcx+48h]
jge short loc_2B78C
mov rax, [rbp+var_220]
mov rax, [rax+48h]
mov [rbp+var_218], rax
mov rax, [rbp+var_230]
mov rcx, [rbp+var_220]
cmp rax, [rcx+48h]
jge short loc_2B78A
mov [rbp+var_231], 1
loc_2B78A:
jmp short $+2
loc_2B78C:
cmp [rbp+var_228], 0
jz short loc_2B7BC
mov rax, [rbp+var_230]
cmp rax, [rbp+var_218]
setnz al
and al, 1
movzx eax, al
mov cl, al
mov rax, [rbp+var_228]
mov [rax], cl
jmp loc_2B83F
loc_2B7BC:
cmp [rbp+var_231], 0
jz short loc_2B83D
lea rax, my_getopt_error_reporter
mov rax, [rax]
mov [rbp+var_258], rax
mov rax, [rbp+var_220]
mov rax, [rax]
mov [rbp+var_268], rax
mov rdi, [rbp+var_230]
lea rsi, [rbp+var_110]
call llstr
mov [rbp+var_260], rax
mov rdi, [rbp+var_218]
lea rsi, [rbp+var_210]
call llstr
mov rdx, [rbp+var_268]
mov rcx, [rbp+var_260]
mov r9, [rbp+var_258]
mov r8, rax
mov edi, 1
lea rsi, aOptionSSignedV; "option '%s': signed value %s adjusted t"...
mov al, 0
call r9
loc_2B83D:
jmp short $+2
loc_2B83F:
jmp short $+2
loc_2B841:
mov rax, [rbp+var_218]
mov [rbp+var_270], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_2B871
mov rax, [rbp+var_270]
add rsp, 270h
pop rbp
retn
loc_2B871:
call ___stack_chk_fail
|
long long getopt_ll_limit_value(long long a1, long long a2, bool *a3)
{
unsigned long long v3; // rdx
long long v4; // rdx
const char *v5; // rax
const char *v7; // [rsp+8h] [rbp-268h]
const char *v8; // [rsp+10h] [rbp-260h]
long long (*v9)(int, long long, ...); // [rsp+18h] [rbp-258h]
unsigned long long v10; // [rsp+28h] [rbp-248h]
char v11; // [rsp+3Fh] [rbp-231h]
long long v13; // [rsp+58h] [rbp-218h]
long long v14; // [rsp+58h] [rbp-218h]
char v15[256]; // [rsp+60h] [rbp-210h] BYREF
char v16[264]; // [rsp+160h] [rbp-110h] BYREF
unsigned long long v17; // [rsp+268h] [rbp-8h]
v17 = __readfsqword(0x28u);
v13 = a1;
v11 = 0;
if ( *(_QWORD *)(a2 + 96) )
v10 = *(_QWORD *)(a2 + 96);
else
v10 = 1LL;
if ( a1 > 0 && (unsigned long long)a1 > *(_QWORD *)(a2 + 80) && *(_QWORD *)(a2 + 80) )
{
v13 = *(_QWORD *)(a2 + 80);
v11 = 1;
}
if ( (*(_QWORD *)(a2 + 48) & 0x3FLL) == 3 && v13 > 0x7FFFFFFF )
{
v13 = 0x7FFFFFFFLL;
v11 = 1;
}
v3 = v13 % v10;
v14 = v10 * (v13 / v10);
if ( v14 < *(_QWORD *)(a2 + 72) )
{
v14 = *(_QWORD *)(a2 + 72);
if ( a1 < v14 )
v11 = 1;
}
if ( a3 )
{
*a3 = a1 != v14;
}
else if ( v11 )
{
v9 = my_getopt_error_reporter;
v7 = *(const char **)a2;
v8 = (const char *)llstr(a1, v16, v3);
v5 = (const char *)llstr(v14, v15, v4);
v9(1, (long long)"option '%s': signed value %s adjusted to %s", v7, v8, v5);
}
return v14;
}
|
getopt_ll_limit_value:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x270
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x218],RDI
MOV qword ptr [RBP + -0x220],RSI
MOV qword ptr [RBP + -0x228],RDX
MOV RAX,qword ptr [RBP + -0x218]
MOV qword ptr [RBP + -0x230],RAX
MOV byte ptr [RBP + -0x231],0x0
MOV RAX,qword ptr [RBP + -0x220]
CMP qword ptr [RAX + 0x60],0x0
JZ 0x0012b664
MOV RAX,qword ptr [RBP + -0x220]
MOV RAX,qword ptr [RAX + 0x60]
MOV qword ptr [RBP + -0x248],RAX
JMP 0x0012b672
LAB_0012b664:
MOV EAX,0x1
MOV qword ptr [RBP + -0x248],RAX
JMP 0x0012b672
LAB_0012b672:
MOV RAX,qword ptr [RBP + -0x248]
MOV qword ptr [RBP + -0x240],RAX
CMP qword ptr [RBP + -0x218],0x0
JLE 0x0012b6c5
MOV RAX,qword ptr [RBP + -0x218]
MOV RCX,qword ptr [RBP + -0x220]
CMP RAX,qword ptr [RCX + 0x50]
JBE 0x0012b6c5
MOV RAX,qword ptr [RBP + -0x220]
CMP qword ptr [RAX + 0x50],0x0
JZ 0x0012b6c5
MOV RAX,qword ptr [RBP + -0x220]
MOV RAX,qword ptr [RAX + 0x50]
MOV qword ptr [RBP + -0x218],RAX
MOV byte ptr [RBP + -0x231],0x1
LAB_0012b6c5:
MOV RAX,qword ptr [RBP + -0x220]
MOV RAX,qword ptr [RAX + 0x30]
AND EAX,0x3f
MOV qword ptr [RBP + -0x250],RAX
SUB RAX,0x3
JZ 0x0012b6f1
JMP 0x0012b6e2
LAB_0012b6e2:
MOV RAX,qword ptr [RBP + -0x250]
SUB RAX,0x5
JZ 0x0012b712
JMP 0x0012b714
LAB_0012b6f1:
CMP qword ptr [RBP + -0x218],0x7fffffff
JLE 0x0012b710
MOV qword ptr [RBP + -0x218],0x7fffffff
MOV byte ptr [RBP + -0x231],0x1
LAB_0012b710:
JMP 0x0012b71a
LAB_0012b712:
JMP 0x0012b71a
LAB_0012b714:
JMP 0x0012b716
LAB_0012b716:
JMP 0x0012b718
LAB_0012b718:
JMP 0x0012b71a
LAB_0012b71a:
MOV RAX,qword ptr [RBP + -0x218]
XOR ECX,ECX
MOV EDX,ECX
DIV qword ptr [RBP + -0x240]
MOV qword ptr [RBP + -0x218],RAX
MOV RAX,qword ptr [RBP + -0x218]
IMUL RAX,qword ptr [RBP + -0x240]
MOV qword ptr [RBP + -0x218],RAX
MOV RAX,qword ptr [RBP + -0x218]
MOV RCX,qword ptr [RBP + -0x220]
CMP RAX,qword ptr [RCX + 0x48]
JGE 0x0012b78c
MOV RAX,qword ptr [RBP + -0x220]
MOV RAX,qword ptr [RAX + 0x48]
MOV qword ptr [RBP + -0x218],RAX
MOV RAX,qword ptr [RBP + -0x230]
MOV RCX,qword ptr [RBP + -0x220]
CMP RAX,qword ptr [RCX + 0x48]
JGE 0x0012b78a
MOV byte ptr [RBP + -0x231],0x1
LAB_0012b78a:
JMP 0x0012b78c
LAB_0012b78c:
CMP qword ptr [RBP + -0x228],0x0
JZ 0x0012b7bc
MOV RAX,qword ptr [RBP + -0x230]
CMP RAX,qword ptr [RBP + -0x218]
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x228]
MOV byte ptr [RAX],CL
JMP 0x0012b83f
LAB_0012b7bc:
CMP byte ptr [RBP + -0x231],0x0
JZ 0x0012b83d
LEA RAX,[0x2d9630]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x258],RAX
MOV RAX,qword ptr [RBP + -0x220]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x268],RAX
MOV RDI,qword ptr [RBP + -0x230]
LEA RSI,[RBP + -0x110]
CALL 0x0017ce10
MOV qword ptr [RBP + -0x260],RAX
MOV RDI,qword ptr [RBP + -0x218]
LEA RSI,[RBP + -0x210]
CALL 0x0017ce10
MOV RDX,qword ptr [RBP + -0x268]
MOV RCX,qword ptr [RBP + -0x260]
MOV R9,qword ptr [RBP + -0x258]
MOV R8,RAX
MOV EDI,0x1
LEA RSI,[0x182fc8]
MOV AL,0x0
CALL R9
LAB_0012b83d:
JMP 0x0012b83f
LAB_0012b83f:
JMP 0x0012b841
LAB_0012b841:
MOV RAX,qword ptr [RBP + -0x218]
MOV qword ptr [RBP + -0x270],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0012b871
MOV RAX,qword ptr [RBP + -0x270]
ADD RSP,0x270
POP RBP
RET
LAB_0012b871:
CALL 0x00125390
|
ulong getopt_ll_limit_value(ulong param_1,int8 *param_2,long param_3)
{
int8 uVar1;
bool bVar2;
int *puVar3;
int8 uVar4;
int8 uVar5;
ulong uVar6;
long in_FS_OFFSET;
ulong local_250;
ulong local_220;
int1 local_218 [256];
int1 local_118 [264];
long local_10;
puVar3 = my_getopt_error_reporter;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
bVar2 = false;
if (param_2[0xc] == 0) {
local_250 = 1;
}
else {
local_250 = param_2[0xc];
}
local_220 = param_1;
if (((0 < (long)param_1) && ((ulong)param_2[10] < param_1)) && (param_2[10] != 0)) {
local_220 = param_2[10];
bVar2 = true;
}
if ((((uint)param_2[6] & 0x3f) == 3) && (0x7fffffff < (long)local_220)) {
local_220 = 0x7fffffff;
bVar2 = true;
}
uVar6 = local_220 % local_250;
local_220 = (local_220 / local_250) * local_250;
if (((long)local_220 < (long)param_2[9]) &&
(local_220 = param_2[9], (long)param_1 < (long)param_2[9])) {
bVar2 = true;
}
if (param_3 == 0) {
if (bVar2) {
uVar1 = *param_2;
uVar4 = llstr(param_1,local_118,uVar6);
uVar5 = llstr(local_220,local_218);
(*(code *)puVar3)(1,"option \'%s\': signed value %s adjusted to %s",uVar1,uVar4,uVar5);
}
}
else {
*(bool *)param_3 = param_1 != local_220;
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_220;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
6,814 |
getopt_ll_limit_value
|
eloqsql/mysys/my_getopt.c
|
longlong getopt_ll_limit_value(longlong num, const struct my_option *optp,
my_bool *fix)
{
longlong old= num;
my_bool adjusted= FALSE;
char buf1[255], buf2[255];
ulonglong block_size= (optp->block_size ? (ulonglong) optp->block_size : 1L);
DBUG_ENTER("getopt_ll_limit_value");
if (num > 0 && ((ulonglong) num > (ulonglong) optp->max_value) &&
optp->max_value) /* if max value is not set -> no upper limit */
{
num= (ulonglong) optp->max_value;
adjusted= TRUE;
}
switch ((optp->var_type & GET_TYPE_MASK)) {
case GET_INT:
if (num > (longlong) INT_MAX)
{
num= ((longlong) INT_MAX);
adjusted= TRUE;
}
break;
case GET_LONG:
#if SIZEOF_LONG < SIZEOF_LONG_LONG
if (num > (longlong) LONG_MAX)
{
num= ((longlong) LONG_MAX);
adjusted= TRUE;
}
#endif
break;
default:
DBUG_ASSERT((optp->var_type & GET_TYPE_MASK) == GET_LL);
break;
}
num= (num / block_size);
num= (longlong) (num * block_size);
if (num < optp->min_value)
{
num= optp->min_value;
if (old < optp->min_value)
adjusted= TRUE;
}
if (fix)
*fix= old != num;
else if (adjusted)
my_getopt_error_reporter(WARNING_LEVEL,
"option '%s': signed value %s adjusted to %s",
optp->name, llstr(old, buf1), llstr(num, buf2));
DBUG_RETURN(num);
}
|
O3
|
c
|
getopt_ll_limit_value:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x210, %rsp # imm = 0x210
movq %rdx, %rcx
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
movq 0x60(%rsi), %r10
cmpq $0x1, %r10
adcq $0x0, %r10
testq %rdi, %rdi
jle 0x2948c
movq 0x50(%rsi), %rax
cmpq %rdi, %rax
setae %dl
testq %rax, %rax
sete %r9b
orb %dl, %r9b
cmovneq %rdi, %rax
jmp 0x29492
movb $0x1, %r9b
movq %rdi, %rax
movl 0x30(%rsi), %edx
andl $0x3f, %edx
cmpl $0x3, %edx
setne %dl
movl $0x80000000, %r8d # imm = 0x80000000
cmpq %r8, %rax
setl %r11b
orb %dl, %r11b
movl $0x7fffffff, %r8d # imm = 0x7FFFFFFF
cmovneq %rax, %r8
movq %r8, %rax
xorl %edx, %edx
divq %r10
subq %rdx, %r8
movq 0x48(%rsi), %rax
cmpq %rax, %r8
movq %rax, %rbx
cmovgq %r8, %rbx
testq %rcx, %rcx
je 0x294de
cmpq %rdi, %rbx
setne (%rcx)
jmp 0x29539
cmpq %rax, %r8
setge %cl
cmpq %rdi, %rax
setle %al
orb %cl, %al
andb %r11b, %al
testb %r9b, %al
jne 0x29539
leaq 0x2cd0e5(%rip), %rax # 0x2f65e0
movq (%rax), %r12
movq (%rsi), %r14
leaq -0x130(%rbp), %rsi
callq 0x5dc54
movq %rax, %r15
leaq -0x230(%rbp), %rsi
movq %rbx, %rdi
callq 0x5dc54
leaq 0x38a0f(%rip), %rsi # 0x61f35
movl $0x1, %edi
movq %r14, %rdx
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq *%r12
movq %fs:0x28, %rax
cmpq -0x28(%rbp), %rax
jne 0x2955b
movq %rbx, %rax
addq $0x210, %rsp # imm = 0x210
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x24400
|
getopt_ll_limit_value:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 210h
mov rcx, rdx
mov rax, fs:28h
mov [rbp+var_28], rax
mov r10, [rsi+60h]
cmp r10, 1
adc r10, 0
test rdi, rdi
jle short loc_2948C
mov rax, [rsi+50h]
cmp rax, rdi
setnb dl
test rax, rax
setz r9b
or r9b, dl
cmovnz rax, rdi
jmp short loc_29492
loc_2948C:
mov r9b, 1
mov rax, rdi
loc_29492:
mov edx, [rsi+30h]
and edx, 3Fh
cmp edx, 3
setnz dl
mov r8d, 80000000h
cmp rax, r8
setl r11b
or r11b, dl
mov r8d, 7FFFFFFFh
cmovnz r8, rax
mov rax, r8
xor edx, edx
div r10
sub r8, rdx
mov rax, [rsi+48h]
cmp r8, rax
mov rbx, rax
cmovg rbx, r8
test rcx, rcx
jz short loc_294DE
cmp rbx, rdi
setnz byte ptr [rcx]
jmp short loc_29539
loc_294DE:
cmp r8, rax
setnl cl
cmp rax, rdi
setle al
or al, cl
and al, r11b
test al, r9b
jnz short loc_29539
lea rax, my_getopt_error_reporter
mov r12, [rax]
mov r14, [rsi]
lea rsi, [rbp+var_130]
call llstr
mov r15, rax
lea rsi, [rbp+var_230]
mov rdi, rbx
call llstr
lea rsi, aOptionSSignedV; "option '%s': signed value %s adjusted t"...
mov edi, 1
mov rdx, r14
mov rcx, r15
mov r8, rax
xor eax, eax
call r12
loc_29539:
mov rax, fs:28h
cmp rax, [rbp+var_28]
jnz short loc_2955B
mov rax, rbx
add rsp, 210h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_2955B:
call ___stack_chk_fail
|
long long getopt_ll_limit_value(long long a1, long long a2, bool *a3)
{
long long v3; // rax
bool v4; // r9
bool v5; // r11
unsigned long long v6; // r8
signed long long v7; // r8
long long v8; // rax
long long v9; // rbx
long long (*v10)(int, const char *, ...); // r12
const char *v11; // r14
const char *v12; // r15
const char *v13; // rax
char v15[256]; // [rsp+0h] [rbp-230h] BYREF
char v16[264]; // [rsp+100h] [rbp-130h] BYREF
unsigned long long v17; // [rsp+208h] [rbp-28h]
v17 = __readfsqword(0x28u);
if ( a1 <= 0 )
{
v4 = 1;
v3 = a1;
}
else
{
v3 = *(_QWORD *)(a2 + 80);
v4 = v3 >= (unsigned long long)a1 || v3 == 0;
if ( v4 )
v3 = a1;
}
v5 = (*(_DWORD *)(a2 + 48) & 0x3F) != 3 || v3 < 0x80000000LL;
v6 = 0x7FFFFFFFLL;
if ( v5 )
v6 = v3;
v7 = v6 - v6 % ((unsigned long long)(*(_QWORD *)(a2 + 96) == 0LL) + *(_QWORD *)(a2 + 96));
v8 = *(_QWORD *)(a2 + 72);
v9 = v8;
if ( v7 > v8 )
v9 = v7;
if ( a3 )
{
*a3 = v9 != a1;
}
else if ( !v4 || !v5 || v7 < v8 && v8 > a1 )
{
v10 = my_getopt_error_reporter;
v11 = *(const char **)a2;
v12 = (const char *)llstr(a1, v16);
v13 = (const char *)llstr(v9, v15);
v10(1, "option '%s': signed value %s adjusted to %s", v11, v12, v13);
}
return v9;
}
|
getopt_ll_limit_value:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x210
MOV RCX,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV R10,qword ptr [RSI + 0x60]
CMP R10,0x1
ADC R10,0x0
TEST RDI,RDI
JLE 0x0012948c
MOV RAX,qword ptr [RSI + 0x50]
CMP RAX,RDI
SETNC DL
TEST RAX,RAX
SETZ R9B
OR R9B,DL
CMOVNZ RAX,RDI
JMP 0x00129492
LAB_0012948c:
MOV R9B,0x1
MOV RAX,RDI
LAB_00129492:
MOV EDX,dword ptr [RSI + 0x30]
AND EDX,0x3f
CMP EDX,0x3
SETNZ DL
MOV R8D,0x80000000
CMP RAX,R8
SETL R11B
OR R11B,DL
MOV R8D,0x7fffffff
CMOVNZ R8,RAX
MOV RAX,R8
XOR EDX,EDX
DIV R10
SUB R8,RDX
MOV RAX,qword ptr [RSI + 0x48]
CMP R8,RAX
MOV RBX,RAX
CMOVG RBX,R8
TEST RCX,RCX
JZ 0x001294de
CMP RBX,RDI
SETNZ byte ptr [RCX]
JMP 0x00129539
LAB_001294de:
CMP R8,RAX
SETGE CL
CMP RAX,RDI
SETLE AL
OR AL,CL
AND AL,R11B
TEST AL,R9B
JNZ 0x00129539
LEA RAX,[0x3f65e0]
MOV R12,qword ptr [RAX]
MOV R14,qword ptr [RSI]
LEA RSI,[RBP + -0x130]
CALL 0x0015dc54
MOV R15,RAX
LEA RSI,[RBP + -0x230]
MOV RDI,RBX
CALL 0x0015dc54
LEA RSI,[0x161f35]
MOV EDI,0x1
MOV RDX,R14
MOV RCX,R15
MOV R8,RAX
XOR EAX,EAX
CALL R12
LAB_00129539:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x28]
JNZ 0x0012955b
MOV RAX,RBX
ADD RSP,0x210
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0012955b:
CALL 0x00124400
|
ulong getopt_ll_limit_value(ulong param_1,int8 *param_2,long param_3)
{
ulong uVar1;
int8 uVar2;
int *puVar3;
ulong uVar4;
int8 uVar5;
int8 uVar6;
ulong uVar7;
ulong uVar8;
bool bVar9;
long in_FS_OFFSET;
bool bVar10;
int1 local_238 [256];
int1 local_138 [264];
long local_30;
puVar3 = my_getopt_error_reporter;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if ((long)param_1 < 1) {
bVar9 = true;
uVar4 = param_1;
}
else {
uVar4 = param_2[10];
bVar9 = uVar4 == 0 || param_1 <= uVar4;
if (uVar4 == 0 || param_1 <= uVar4) {
uVar4 = param_1;
}
}
bVar10 = (*(uint *)(param_2 + 6) & 0x3f) != 3;
uVar8 = 0x7fffffff;
if ((long)uVar4 < 0x80000000 || bVar10) {
uVar8 = uVar4;
}
uVar8 = uVar8 - uVar8 % (param_2[0xc] + (ulong)(param_2[0xc] == 0));
uVar1 = param_2[9];
uVar7 = uVar1;
if ((long)uVar1 < (long)uVar8) {
uVar7 = uVar8;
}
if (param_3 == 0) {
if (!(bool)((((long)uVar1 <= (long)param_1 || (long)uVar1 <= (long)uVar8) &&
((long)uVar4 < 0x80000000 || bVar10)) & bVar9)) {
uVar2 = *param_2;
uVar5 = llstr(param_1,local_138);
uVar6 = llstr(uVar7,local_238);
(*(code *)puVar3)(1,"option \'%s\': signed value %s adjusted to %s",uVar2,uVar5,uVar6);
}
}
else {
*(bool *)param_3 = uVar7 != param_1;
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_30) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar7;
}
|
|
6,815 |
minja::Value::set(minja::Value const&, minja::Value const&)
|
llama.cpp/common/minja/minja.hpp
|
void set(const Value& key, const Value& value) {
if (!object_) throw std::runtime_error("Value is not an object: " + dump());
if (!key.is_hashable()) throw std::runtime_error("Unashable type: " + dump());
(*object_)[key.primitive_] = value;
}
|
O3
|
cpp
|
minja::Value::set(minja::Value const&, minja::Value const&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0xc0a8b
cmpq $0x0, 0x10(%rsi)
jne 0xc0ae8
cmpq $0x0, 0x20(%rsi)
jne 0xc0ae8
cmpq $0x0, 0x30(%rsi)
jne 0xc0ae8
movq %rdx, %rbx
addq $0x40, %rsi
callq 0xc0bc4
movq %rax, %r14
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
leaq 0x18(%r14), %rdi
leaq 0x18(%rbx), %rsi
callq 0xbe446
movq 0x20(%rbx), %rax
movq %rax, 0x20(%r14)
leaq 0x28(%r14), %rdi
leaq 0x28(%rbx), %rsi
callq 0xbe446
movq 0x30(%rbx), %rax
movq %rax, 0x30(%r14)
leaq 0x38(%r14), %rdi
leaq 0x38(%rbx), %rsi
callq 0xbe446
addq $0x40, %rbx
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x89540
addq $0x40, %r14
leaq 0x20(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8745e
movq %rbx, %rdi
xorl %esi, %esi
callq 0x852f2
movq %rbx, %rdi
callq 0x89a0c
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x20650
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0xb6178
leaq 0x5ed77(%rip), %rsi # 0x11f828
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xafa18
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x20480
xorl %ebp, %ebp
movq 0xa14e9(%rip), %rsi # 0x161fc0
movq 0xa14a2(%rip), %rdx # 0x161f80
movq %rbx, %rdi
callq 0x20a50
jmp 0xc0b43
movl $0x10, %edi
callq 0x20650
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0xb6178
leaq 0x5ec90(%rip), %rsi # 0x11f79e
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xafa18
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x20480
xorl %ebp, %ebp
movq 0xa148c(%rip), %rsi # 0x161fc0
movq 0xa1445(%rip), %rdx # 0x161f80
movq %rbx, %rdi
callq 0x20a50
jmp 0xc0b47
jmp 0xc0b87
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc0b65
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x20180
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc0b80
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x20180
testb %bpl, %bpl
jne 0xc0bac
jmp 0xc0bb4
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc0bac
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x20180
jmp 0xc0bac
jmp 0xc0ba9
movq %rax, %r14
movq %rbx, %rdi
callq 0x20ef0
movq %r14, %rdi
callq 0x20af0
movq %rax, %rdi
callq 0x28709
|
_ZN5minja5Value3setERKS0_S2_:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rdi
mov rdi, [rdi+20h]
test rdi, rdi
jz loc_C0A8B
cmp qword ptr [rsi+10h], 0
jnz loc_C0AE8
cmp qword ptr [rsi+20h], 0
jnz loc_C0AE8
cmp qword ptr [rsi+30h], 0
jnz loc_C0AE8
mov rbx, rdx
add rsi, 40h ; '@'
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEEixERSJ_; nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>::operator[](nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov r14, rax
mov rax, [rbx+10h]
mov [r14+10h], rax
lea rdi, [r14+18h]
lea rsi, [rbx+18h]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EEaSERKS2_; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=(std::__shared_count<(__gnu_cxx::_Lock_policy)2> const&)
mov rax, [rbx+20h]
mov [r14+20h], rax
lea rdi, [r14+28h]
lea rsi, [rbx+28h]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EEaSERKS2_; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=(std::__shared_count<(__gnu_cxx::_Lock_policy)2> const&)
mov rax, [rbx+30h]
mov [r14+30h], rax
lea rdi, [r14+38h]
lea rsi, [rbx+38h]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EEaSERKS2_; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=(std::__shared_count<(__gnu_cxx::_Lock_policy)2> const&)
add rbx, 40h ; '@'
lea rdi, [rsp+58h+var_38]
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
add r14, 40h ; '@'
lea rbx, [rsp+58h+var_38]
mov rdi, r14
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
loc_C0A8B:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aValueIsNotAnOb; "Value is not an object: "
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_C0B43
loc_C0AE8:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aUnashableType; "Unashable type: "
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_C0B43:
jmp short loc_C0B47
jmp short loc_C0B87
loc_C0B47:
mov r14, rax
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C0B65
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C0B65:
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C0B80
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C0B80:
test bpl, bpl
jnz short loc_C0BAC
jmp short loc_C0BB4
loc_C0B87:
mov r14, rax
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C0BAC
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_C0BAC
jmp short $+2
loc_C0BA9:
mov r14, rax
loc_C0BAC:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_C0BB4:
mov rdi, r14
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
|
long long minja::Value::set(minja::Value *this, const minja::Value *a2, const minja::Value *a3)
{
long long v4; // rdi
long long v6; // r14
void *exception; // rbx
void *v9; // rbx
_BYTE v10[16]; // [rsp+0h] [rbp-58h] BYREF
_QWORD v11[2]; // [rsp+20h] [rbp-38h] BYREF
v4 = *((_QWORD *)this + 4);
if ( !v4 )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v10, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>(v11, (long long)"Value is not an object: ", (long long)v10);
std::runtime_error::runtime_error(exception, v11);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( *((_QWORD *)a2 + 2) || *((_QWORD *)a2 + 4) || *((_QWORD *)a2 + 6) )
{
v9 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v10, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>(v11, (long long)"Unashable type: ", (long long)v10);
std::runtime_error::runtime_error(v9, v11);
__cxa_throw(
v9,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v6 = nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::operator[](
v4,
(char *)a2 + 64);
*(_QWORD *)(v6 + 16) = *((_QWORD *)a3 + 2);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=(
(volatile signed __int32 **)(v6 + 24),
(volatile signed __int32 **)a3 + 3);
*(_QWORD *)(v6 + 32) = *((_QWORD *)a3 + 4);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=(
(volatile signed __int32 **)(v6 + 40),
(volatile signed __int32 **)a3 + 5);
*(_QWORD *)(v6 + 48) = *((_QWORD *)a3 + 6);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=(
(volatile signed __int32 **)(v6 + 56),
(volatile signed __int32 **)a3 + 7);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
(unsigned __int8 *)v11,
(unsigned __int8 *)a3 + 64);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
v6 + 64,
(long long)v11);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v11);
return nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v11);
}
|
set:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
MOV RDI,qword ptr [RDI + 0x20]
TEST RDI,RDI
JZ 0x001c0a8b
CMP qword ptr [RSI + 0x10],0x0
JNZ 0x001c0ae8
CMP qword ptr [RSI + 0x20],0x0
JNZ 0x001c0ae8
CMP qword ptr [RSI + 0x30],0x0
JNZ 0x001c0ae8
MOV RBX,RDX
ADD RSI,0x40
CALL 0x001c0bc4
MOV R14,RAX
MOV RAX,qword ptr [RBX + 0x10]
MOV qword ptr [R14 + 0x10],RAX
LEA RDI,[R14 + 0x18]
LEA RSI,[RBX + 0x18]
CALL 0x001be446
MOV RAX,qword ptr [RBX + 0x20]
MOV qword ptr [R14 + 0x20],RAX
LEA RDI,[R14 + 0x28]
LEA RSI,[RBX + 0x28]
CALL 0x001be446
MOV RAX,qword ptr [RBX + 0x30]
MOV qword ptr [R14 + 0x30],RAX
LEA RDI,[R14 + 0x38]
LEA RSI,[RBX + 0x38]
CALL 0x001be446
ADD RBX,0x40
LAB_001c0a4f:
LEA RDI,[RSP + 0x20]
MOV RSI,RBX
CALL 0x00189540
LAB_001c0a5c:
ADD R14,0x40
LEA RBX,[RSP + 0x20]
MOV RDI,R14
MOV RSI,RBX
CALL 0x0018745e
MOV RDI,RBX
XOR ESI,ESI
CALL 0x001852f2
MOV RDI,RBX
CALL 0x00189a0c
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
LAB_001c0a8b:
MOV EDI,0x10
CALL 0x00120650
MOV RBX,RAX
LAB_001c0a98:
MOV RDI,RSP
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001b6178
LAB_001c0aaa:
LEA RSI,[0x21f828]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x001afa18
MOV BPL,0x1
LAB_001c0ac1:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00120480
XOR EBP,EBP
MOV RSI,qword ptr [0x00261fc0]
MOV RDX,qword ptr [0x00261f80]
MOV RDI,RBX
CALL 0x00120a50
LAB_001c0ae8:
MOV EDI,0x10
CALL 0x00120650
MOV RBX,RAX
LAB_001c0af5:
MOV RDI,RSP
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001b6178
LAB_001c0b07:
LEA RSI,[0x21f79e]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x001afa18
MOV BPL,0x1
LAB_001c0b1e:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00120480
XOR EBP,EBP
MOV RSI,qword ptr [0x00261fc0]
MOV RDX,qword ptr [0x00261f80]
MOV RDI,RBX
CALL 0x00120a50
|
/* minja::Value::set(minja::Value const&, minja::Value const&) */
void __thiscall minja::Value::set(Value *this,Value *param_1,Value *param_2)
{
long lVar1;
runtime_error *prVar2;
int1 auStack_58 [32];
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>
local_38 [32];
if (*(ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
**)(this + 0x20) ==
(ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*)0x0) {
prVar2 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001c0a98 to 001c0aa9 has its CatchHandler @ 001c0ba9 */
dump_abi_cxx11_((int)auStack_58,SUB81(this,0));
/* try { // try from 001c0aaa to 001c0abd has its CatchHandler @ 001c0b87 */
std::operator+((char *)local_38,(string *)"Value is not an object: ");
/* try { // try from 001c0ac1 to 001c0ae5 has its CatchHandler @ 001c0b47 */
std::runtime_error::runtime_error(prVar2,(string *)local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar2,PTR_typeinfo_00261fc0,PTR__runtime_error_00261f80);
}
if (((*(long *)(param_1 + 0x10) == 0) && (*(long *)(param_1 + 0x20) == 0)) &&
(*(long *)(param_1 + 0x30) == 0)) {
lVar1 = nlohmann::json_abi_v3_11_3::
ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::operator[](*(ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
**)(this + 0x20),(basic_json *)(param_1 + 0x40));
*(int8 *)(lVar1 + 0x10) = *(int8 *)(param_2 + 0x10);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)(lVar1 + 0x18),
(__shared_count *)(param_2 + 0x18));
*(int8 *)(lVar1 + 0x20) = *(int8 *)(param_2 + 0x20);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)(lVar1 + 0x28),
(__shared_count *)(param_2 + 0x28));
*(int8 *)(lVar1 + 0x30) = *(int8 *)(param_2 + 0x30);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)(lVar1 + 0x38),
(__shared_count *)(param_2 + 0x38));
/* try { // try from 001c0a4f to 001c0a5b has its CatchHandler @ 001c0bbc */
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_38,(basic_json *)(param_2 + 0x40));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=((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>
*)(lVar1 + 0x40),(data *)local_38);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)local_38,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_38);
return;
}
prVar2 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001c0af5 to 001c0b06 has its CatchHandler @ 001c0ba7 */
dump_abi_cxx11_((int)auStack_58,SUB81(this,0));
/* try { // try from 001c0b07 to 001c0b1a has its CatchHandler @ 001c0b45 */
std::operator+((char *)local_38,(string *)"Unashable type: ");
/* try { // try from 001c0b1e to 001c0b42 has its CatchHandler @ 001c0b43 */
std::runtime_error::runtime_error(prVar2,(string *)local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar2,PTR_typeinfo_00261fc0,PTR__runtime_error_00261f80);
}
|
|
6,816 |
my_rw_rdlock
|
eloqsql/mysys/thr_rwlock.c
|
int my_rw_rdlock(my_rw_lock_t *rwp)
{
pthread_mutex_lock(&rwp->lock);
/* active or queued writers */
while (( rwp->state < 0 ) || rwp->waiters)
pthread_cond_wait( &rwp->readers, &rwp->lock);
rwp->state++;
pthread_mutex_unlock(&rwp->lock);
return(0);
}
|
O0
|
c
|
my_rw_rdlock:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x254c0
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x0, 0x88(%rcx)
movb %al, -0x9(%rbp)
jl 0x39f28
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8c(%rax)
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x39f31
jmp 0x39f44
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x8(%rbp), %rsi
callq 0x25560
jmp 0x39f05
movq -0x8(%rbp), %rax
movl 0x88(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x88(%rax)
movq -0x8(%rbp), %rdi
callq 0x25240
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
my_rw_rdlock:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
call _pthread_mutex_lock
loc_39F05:
mov rcx, [rbp+var_8]
mov al, 1
cmp dword ptr [rcx+88h], 0
mov [rbp+var_9], al
jl short loc_39F28
mov rax, [rbp+var_8]
cmp dword ptr [rax+8Ch], 0
setnz al
mov [rbp+var_9], al
loc_39F28:
mov al, [rbp+var_9]
test al, 1
jnz short loc_39F31
jmp short loc_39F44
loc_39F31:
mov rdi, [rbp+var_8]
add rdi, 28h ; '('
mov rsi, [rbp+var_8]
call _pthread_cond_wait
jmp short loc_39F05
loc_39F44:
mov rax, [rbp+var_8]
mov ecx, [rax+88h]
add ecx, 1
mov [rax+88h], ecx
mov rdi, [rbp+var_8]
call _pthread_mutex_unlock
xor eax, eax
add rsp, 10h
pop rbp
retn
|
long long my_rw_rdlock(long long a1)
{
bool v2; // [rsp+7h] [rbp-9h]
pthread_mutex_lock(a1);
while ( 1 )
{
v2 = 1;
if ( *(int *)(a1 + 136) >= 0 )
v2 = *(_DWORD *)(a1 + 140) != 0;
if ( !v2 )
break;
pthread_cond_wait(a1 + 40, a1);
}
++*(_DWORD *)(a1 + 136);
pthread_mutex_unlock(a1);
return 0LL;
}
|
my_rw_rdlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001254c0
LAB_00139f05:
MOV RCX,qword ptr [RBP + -0x8]
MOV AL,0x1
CMP dword ptr [RCX + 0x88],0x0
MOV byte ptr [RBP + -0x9],AL
JL 0x00139f28
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x8c],0x0
SETNZ AL
MOV byte ptr [RBP + -0x9],AL
LAB_00139f28:
MOV AL,byte ptr [RBP + -0x9]
TEST AL,0x1
JNZ 0x00139f31
JMP 0x00139f44
LAB_00139f31:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x28
MOV RSI,qword ptr [RBP + -0x8]
CALL 0x00125560
JMP 0x00139f05
LAB_00139f44:
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x88]
ADD ECX,0x1
MOV dword ptr [RAX + 0x88],ECX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00125240
XOR EAX,EAX
ADD RSP,0x10
POP RBP
RET
|
int8 my_rw_rdlock(pthread_mutex_t *param_1)
{
bool bVar1;
pthread_mutex_lock(param_1);
while( true ) {
bVar1 = true;
if (-1 < *(int *)((long)param_1 + 0x88)) {
bVar1 = *(int *)((long)param_1 + 0x8c) != 0;
}
if (!bVar1) break;
pthread_cond_wait((pthread_cond_t *)(param_1 + 1),param_1);
}
*(int *)((long)param_1 + 0x88) = *(int *)((long)param_1 + 0x88) + 1;
pthread_mutex_unlock(param_1);
return 0;
}
|
|
6,817 |
my_rw_rdlock
|
eloqsql/mysys/thr_rwlock.c
|
int my_rw_rdlock(my_rw_lock_t *rwp)
{
pthread_mutex_lock(&rwp->lock);
/* active or queued writers */
while (( rwp->state < 0 ) || rwp->waiters)
pthread_cond_wait( &rwp->readers, &rwp->lock);
rwp->state++;
pthread_mutex_unlock(&rwp->lock);
return(0);
}
|
O3
|
c
|
my_rw_rdlock:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x24510
leaq 0x28(%rbx), %r14
movl 0x88(%rbx), %eax
testl %eax, %eax
js 0x31f7e
cmpl $0x0, 0x8c(%rbx)
je 0x31f8b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x245b0
jmp 0x31f6b
incl %eax
movl %eax, 0x88(%rbx)
movq %rbx, %rdi
callq 0x24260
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
|
my_rw_rdlock:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
call _pthread_mutex_lock
lea r14, [rbx+28h]
loc_31F6B:
mov eax, [rbx+88h]
test eax, eax
js short loc_31F7E
cmp dword ptr [rbx+8Ch], 0
jz short loc_31F8B
loc_31F7E:
mov rdi, r14
mov rsi, rbx
call _pthread_cond_wait
jmp short loc_31F6B
loc_31F8B:
inc eax
mov [rbx+88h], eax
mov rdi, rbx
call _pthread_mutex_unlock
xor eax, eax
pop rbx
pop r14
pop rbp
retn
|
long long my_rw_rdlock(long long a1)
{
int v1; // eax
pthread_mutex_lock(a1);
while ( 1 )
{
v1 = *(_DWORD *)(a1 + 136);
if ( v1 >= 0 && !*(_DWORD *)(a1 + 140) )
break;
pthread_cond_wait(a1 + 40, a1);
}
*(_DWORD *)(a1 + 136) = v1 + 1;
pthread_mutex_unlock(a1);
return 0LL;
}
|
my_rw_rdlock:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
CALL 0x00124510
LEA R14,[RBX + 0x28]
LAB_00131f6b:
MOV EAX,dword ptr [RBX + 0x88]
TEST EAX,EAX
JS 0x00131f7e
CMP dword ptr [RBX + 0x8c],0x0
JZ 0x00131f8b
LAB_00131f7e:
MOV RDI,R14
MOV RSI,RBX
CALL 0x001245b0
JMP 0x00131f6b
LAB_00131f8b:
INC EAX
MOV dword ptr [RBX + 0x88],EAX
MOV RDI,RBX
CALL 0x00124260
XOR EAX,EAX
POP RBX
POP R14
POP RBP
RET
|
int8 my_rw_rdlock(pthread_mutex_t *param_1)
{
pthread_mutex_lock(param_1);
while ((*(int *)((long)param_1 + 0x88) < 0 || (*(int *)((long)param_1 + 0x8c) != 0))) {
pthread_cond_wait((pthread_cond_t *)(param_1 + 1),param_1);
}
*(int *)((long)param_1 + 0x88) = *(int *)((long)param_1 + 0x88) + 1;
pthread_mutex_unlock(param_1);
return 0;
}
|
|
6,818 |
ulp
|
eloqsql/strings/dtoa.c
|
static double ulp(U *x)
{
register Long L;
U u;
L= (word0(x) & Exp_mask) - (P - 1)*Exp_msk1;
word0(&u) = L;
word1(&u) = 0;
return dval(&u);
}
|
O0
|
c
|
ulp:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x7ff00000, %eax # imm = 0x7FF00000
subl $0x3400000, %eax # imm = 0x3400000
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
popq %rbp
retq
|
ulp:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov eax, [rax+4]
and eax, 7FF00000h
sub eax, 3400000h
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
mov dword ptr [rbp+var_18+4], eax
mov dword ptr [rbp+var_18], 0
movsd xmm0, [rbp+var_18]
pop rbp
retn
|
double ulp(long long a1)
{
double v2; // [rsp+0h] [rbp-18h]
HIDWORD(v2) = (*(_DWORD *)(a1 + 4) & 0x7FF00000) - 54525952;
LODWORD(v2) = 0;
return v2;
}
|
ulp:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x4]
AND EAX,0x7ff00000
SUB EAX,0x3400000
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x14],EAX
MOV dword ptr [RBP + -0x18],0x0
MOVSD XMM0,qword ptr [RBP + -0x18]
POP RBP
RET
|
long ulp(long param_1)
{
return (ulong)((*(uint *)(param_1 + 4) & 0x7ff00000) + 0xfcc00000) << 0x20;
}
|
|
6,819 |
psi_prlock_wrlock
|
eloqsql/mysys/my_thr_init.c
|
ATTRIBUTE_COLD
int psi_prlock_wrlock(mysql_prlock_t *that, const char *file, uint line)
{
PSI_rwlock_locker_state state;
PSI_rwlock_locker *locker= PSI_RWLOCK_CALL(start_rwlock_wrwait)
(&state, that->m_psi, PSI_RWLOCK_WRITELOCK, file, line);
int result= rw_pr_wrlock(&that->m_prlock);
if (locker)
PSI_RWLOCK_CALL(end_rwlock_wrwait)(locker, result);
return result;
}
|
O0
|
c
|
psi_prlock_wrlock:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x1c92ce(%rip), %rax # 0x2c1158
movq (%rax), %rax
movq 0x1b0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x68(%rcx), %rsi
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
leaq -0x48(%rbp), %rdi
movl $0x1, %edx
callq *%rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0xfb640
movl %eax, -0x54(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0xf7ee0
leaq 0x1c928b(%rip), %rax # 0x2c1158
movq (%rax), %rax
movq 0x1b8(%rax), %rax
movq -0x50(%rbp), %rdi
movl -0x54(%rbp), %esi
callq *%rax
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
|
psi_prlock_wrlock:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1B0h]
mov rcx, [rbp+var_8]
mov rsi, [rcx+68h]
mov rcx, [rbp+var_10]
mov r8d, [rbp+var_14]
lea rdi, [rbp+var_48]
mov edx, 1
call rax
mov [rbp+var_50], rax
mov rdi, [rbp+var_8]
call rw_pr_wrlock
mov [rbp+var_54], eax
cmp [rbp+var_50], 0
jz short loc_F7EE0
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1B8h]
mov rdi, [rbp+var_50]
mov esi, [rbp+var_54]
call rax
loc_F7EE0:
mov eax, [rbp+var_54]
add rsp, 60h
pop rbp
retn
|
long long psi_prlock_wrlock(long long a1, long long a2, unsigned int a3)
{
unsigned int v4; // [rsp+Ch] [rbp-54h]
long long v5; // [rsp+10h] [rbp-50h]
_BYTE v6[52]; // [rsp+18h] [rbp-48h] BYREF
unsigned int v7; // [rsp+4Ch] [rbp-14h]
long long v8; // [rsp+50h] [rbp-10h]
long long v9; // [rsp+58h] [rbp-8h]
v9 = a1;
v8 = a2;
v7 = a3;
v5 = ((long long ( *)(_BYTE *, _QWORD, long long, long long, _QWORD))PSI_server[54])(
v6,
*(_QWORD *)(a1 + 104),
1LL,
a2,
a3);
v4 = rw_pr_wrlock(v9);
if ( v5 )
((void ( *)(long long, _QWORD))PSI_server[55])(v5, v4);
return v4;
}
|
psi_prlock_wrlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
LEA RAX,[0x3c1158]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1b0]
MOV RCX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RCX + 0x68]
MOV RCX,qword ptr [RBP + -0x10]
MOV R8D,dword ptr [RBP + -0x14]
LEA RDI,[RBP + -0x48]
MOV EDX,0x1
CALL RAX
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001fb640
MOV dword ptr [RBP + -0x54],EAX
CMP qword ptr [RBP + -0x50],0x0
JZ 0x001f7ee0
LEA RAX,[0x3c1158]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1b8]
MOV RDI,qword ptr [RBP + -0x50]
MOV ESI,dword ptr [RBP + -0x54]
CALL RAX
LAB_001f7ee0:
MOV EAX,dword ptr [RBP + -0x54]
ADD RSP,0x60
POP RBP
RET
|
int4 psi_prlock_wrlock(long param_1,int8 param_2,int4 param_3)
{
int4 uVar1;
long lVar2;
int1 local_50 [52];
int4 local_1c;
int8 local_18;
long local_10;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
lVar2 = (**(code **)(PSI_server + 0x1b0))
(local_50,*(int8 *)(param_1 + 0x68),1,param_2,param_3);
uVar1 = rw_pr_wrlock(local_10);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x1b8))(lVar2,uVar1);
}
return uVar1;
}
|
|
6,820 |
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>>>>>::scan_string()
|
llama.cpp/common/json.hpp
|
token_type scan_string()
{
// reset token_buffer (ignore opening quote)
reset();
// we entered the function by reading an open quote
JSON_ASSERT(current == '\"');
while (true)
{
// get next character
switch (get())
{
// end of file while parsing string
case char_traits<char_type>::eof():
{
error_message = "invalid string: missing closing quote";
return token_type::parse_error;
}
// closing quote
case '\"':
{
return token_type::value_string;
}
// escapes
case '\\':
{
switch (get())
{
// quotation mark
case '\"':
add('\"');
break;
// reverse solidus
case '\\':
add('\\');
break;
// solidus
case '/':
add('/');
break;
// backspace
case 'b':
add('\b');
break;
// form feed
case 'f':
add('\f');
break;
// line feed
case 'n':
add('\n');
break;
// carriage return
case 'r':
add('\r');
break;
// tab
case 't':
add('\t');
break;
// unicode escapes
case 'u':
{
const int codepoint1 = get_codepoint();
int codepoint = codepoint1; // start with codepoint1
if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
{
error_message = "invalid string: '\\u' must be followed by 4 hex digits";
return token_type::parse_error;
}
// check if code point is a high surrogate
if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
{
// expect next \uxxxx entry
if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
{
const int codepoint2 = get_codepoint();
if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
{
error_message = "invalid string: '\\u' must be followed by 4 hex digits";
return token_type::parse_error;
}
// check if codepoint2 is a low surrogate
if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
{
// overwrite codepoint
codepoint = static_cast<int>(
// high surrogate occupies the most significant 22 bits
(static_cast<unsigned int>(codepoint1) << 10u)
// low surrogate occupies the least significant 15 bits
+ static_cast<unsigned int>(codepoint2)
// there is still the 0xD800, 0xDC00 and 0x10000 noise
// in the result, so we have to subtract with:
// (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
- 0x35FDC00u);
}
else
{
error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
return token_type::parse_error;
}
}
else
{
error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
return token_type::parse_error;
}
}
else
{
if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
{
error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
return token_type::parse_error;
}
}
// result of the above calculation yields a proper codepoint
JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
// translate codepoint into bytes
if (codepoint < 0x80)
{
// 1-byte characters: 0xxxxxxx (ASCII)
add(static_cast<char_int_type>(codepoint));
}
else if (codepoint <= 0x7FF)
{
// 2-byte characters: 110xxxxx 10xxxxxx
add(static_cast<char_int_type>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
}
else if (codepoint <= 0xFFFF)
{
// 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
add(static_cast<char_int_type>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
}
else
{
// 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
add(static_cast<char_int_type>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
}
break;
}
// other characters after escape
default:
error_message = "invalid string: forbidden character after backslash";
return token_type::parse_error;
}
break;
}
// invalid control characters
case 0x00:
{
error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
return token_type::parse_error;
}
case 0x01:
{
error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
return token_type::parse_error;
}
case 0x02:
{
error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
return token_type::parse_error;
}
case 0x03:
{
error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
return token_type::parse_error;
}
case 0x04:
{
error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
return token_type::parse_error;
}
case 0x05:
{
error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
return token_type::parse_error;
}
case 0x06:
{
error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
return token_type::parse_error;
}
case 0x07:
{
error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
return token_type::parse_error;
}
case 0x08:
{
error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
return token_type::parse_error;
}
case 0x09:
{
error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
return token_type::parse_error;
}
case 0x0A:
{
error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
return token_type::parse_error;
}
case 0x0B:
{
error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
return token_type::parse_error;
}
case 0x0C:
{
error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
return token_type::parse_error;
}
case 0x0D:
{
error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
return token_type::parse_error;
}
case 0x0E:
{
error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
return token_type::parse_error;
}
case 0x0F:
{
error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
return token_type::parse_error;
}
case 0x10:
{
error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
return token_type::parse_error;
}
case 0x11:
{
error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
return token_type::parse_error;
}
case 0x12:
{
error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
return token_type::parse_error;
}
case 0x13:
{
error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
return token_type::parse_error;
}
case 0x14:
{
error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
return token_type::parse_error;
}
case 0x15:
{
error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
return token_type::parse_error;
}
case 0x16:
{
error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
return token_type::parse_error;
}
case 0x17:
{
error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
return token_type::parse_error;
}
case 0x18:
{
error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
return token_type::parse_error;
}
case 0x19:
{
error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
return token_type::parse_error;
}
case 0x1A:
{
error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
return token_type::parse_error;
}
case 0x1B:
{
error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
return token_type::parse_error;
}
case 0x1C:
{
error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
return token_type::parse_error;
}
case 0x1D:
{
error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
return token_type::parse_error;
}
case 0x1E:
{
error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
return token_type::parse_error;
}
case 0x1F:
{
error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";
return token_type::parse_error;
}
// U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
case 0x20:
case 0x21:
case 0x23:
case 0x24:
case 0x25:
case 0x26:
case 0x27:
case 0x28:
case 0x29:
case 0x2A:
case 0x2B:
case 0x2C:
case 0x2D:
case 0x2E:
case 0x2F:
case 0x30:
case 0x31:
case 0x32:
case 0x33:
case 0x34:
case 0x35:
case 0x36:
case 0x37:
case 0x38:
case 0x39:
case 0x3A:
case 0x3B:
case 0x3C:
case 0x3D:
case 0x3E:
case 0x3F:
case 0x40:
case 0x41:
case 0x42:
case 0x43:
case 0x44:
case 0x45:
case 0x46:
case 0x47:
case 0x48:
case 0x49:
case 0x4A:
case 0x4B:
case 0x4C:
case 0x4D:
case 0x4E:
case 0x4F:
case 0x50:
case 0x51:
case 0x52:
case 0x53:
case 0x54:
case 0x55:
case 0x56:
case 0x57:
case 0x58:
case 0x59:
case 0x5A:
case 0x5B:
case 0x5D:
case 0x5E:
case 0x5F:
case 0x60:
case 0x61:
case 0x62:
case 0x63:
case 0x64:
case 0x65:
case 0x66:
case 0x67:
case 0x68:
case 0x69:
case 0x6A:
case 0x6B:
case 0x6C:
case 0x6D:
case 0x6E:
case 0x6F:
case 0x70:
case 0x71:
case 0x72:
case 0x73:
case 0x74:
case 0x75:
case 0x76:
case 0x77:
case 0x78:
case 0x79:
case 0x7A:
case 0x7B:
case 0x7C:
case 0x7D:
case 0x7E:
case 0x7F:
{
add(current);
break;
}
// U+0080..U+07FF: bytes C2..DF 80..BF
case 0xC2:
case 0xC3:
case 0xC4:
case 0xC5:
case 0xC6:
case 0xC7:
case 0xC8:
case 0xC9:
case 0xCA:
case 0xCB:
case 0xCC:
case 0xCD:
case 0xCE:
case 0xCF:
case 0xD0:
case 0xD1:
case 0xD2:
case 0xD3:
case 0xD4:
case 0xD5:
case 0xD6:
case 0xD7:
case 0xD8:
case 0xD9:
case 0xDA:
case 0xDB:
case 0xDC:
case 0xDD:
case 0xDE:
case 0xDF:
{
if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
{
return token_type::parse_error;
}
break;
}
// U+0800..U+0FFF: bytes E0 A0..BF 80..BF
case 0xE0:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
// U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
case 0xE1:
case 0xE2:
case 0xE3:
case 0xE4:
case 0xE5:
case 0xE6:
case 0xE7:
case 0xE8:
case 0xE9:
case 0xEA:
case 0xEB:
case 0xEC:
case 0xEE:
case 0xEF:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// U+D000..U+D7FF: bytes ED 80..9F 80..BF
case 0xED:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
case 0xF0:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
case 0xF1:
case 0xF2:
case 0xF3:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
case 0xF4:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// remaining bytes (80..C1 and F5..FF) are ill-formed
default:
{
error_message = "invalid string: ill-formed UTF-8 byte";
return token_type::parse_error;
}
}
}
}
|
O3
|
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>>>>>::scan_string():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x860e0
cmpl $0x22, 0x14(%rbx)
jne 0x85cd9
leaq 0x50(%rbx), %r14
leaq 0x9411b(%rip), %r12 # 0x1199ea
leaq 0x8d1ba(%rip), %r13 # 0x112a90
movq %rbx, %rdi
callq 0x21688
incl %eax
cmpl $0xf5, %eax
ja 0x85ca8
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movabsq $0xbf00000080, %rax # imm = 0xBF00000080
movq %rsp, %rsi
movq %rax, (%rsi)
movl $0x2, %edx
jmp 0x85976
movaps 0x8ca8d(%rip), %xmm0 # 0x1123a0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movl $0x4, %edx
jmp 0x85976
movb 0x14(%rbx), %r15b
movsbl %r15b, %esi
movq %r14, %rdi
callq 0x213a0
jmp 0x858d6
movups 0x9695f(%rip), %xmm0 # 0x11c298
jmp 0x8595d
movaps 0x8ca4e(%rip), %xmm0 # 0x112390
jmp 0x85913
movaps 0x8ca65(%rip), %xmm0 # 0x1123b0
jmp 0x85913
movups 0x9695c(%rip), %xmm0 # 0x11c2b0
jmp 0x8595d
movups 0x96923(%rip), %xmm0 # 0x11c280
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movabsq $0xbf00000080, %rax # imm = 0xBF00000080
movq %rax, 0x10(%rsi)
movl $0x6, %edx
movq %rbx, %rdi
callq 0x86164
testb %al, %al
jne 0x858d6
jmp 0x85cb3
movq %rbx, %rdi
callq 0x21688
leaq 0x93fd3(%rip), %rbp # 0x11996d
cmpl $0x61, %eax
jle 0x85ac5
leal -0x6e(%rax), %ecx
cmpl $0x7, %ecx
ja 0x85ae0
leaq 0x8d4b2(%rip), %rax # 0x112e68
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %rbx, %rdi
callq 0x8611e
leaq 0x93eae(%rip), %rbp # 0x11987c
cmpl $-0x1, %eax
je 0x85caf
movl %eax, %r15d
andl $0xfffffc00, %eax # imm = 0xFFFFFC00
cmpl $0xd800, %eax # imm = 0xD800
jne 0x85a90
movq %rbx, %rdi
callq 0x21688
cmpl $0x5c, %eax
jne 0x85cc7
movq %rbx, %rdi
callq 0x21688
cmpl $0x75, %eax
jne 0x85cc7
movq %rbx, %rdi
callq 0x8611e
cmpl $-0x1, %eax
je 0x85caf
movl %eax, %ecx
andl $0xfffffc00, %ecx # imm = 0xFFFFFC00
leaq 0x93e86(%rip), %rbp # 0x1198b2
cmpl $0xdc00, %ecx # imm = 0xDC00
jne 0x85caf
shll $0xa, %r15d
addl %eax, %r15d
addl $0xfca02400, %r15d # imm = 0xFCA02400
movl %r15d, %eax
shrl $0x12, %eax
orb $-0x10, %al
movsbl %al, %esi
movq %r14, %rdi
callq 0x213a0
movl %r15d, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %r14, %rdi
callq 0x213a0
movl %r15d, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %r14, %rdi
callq 0x213a0
andb $0x3f, %r15b
orb $-0x80, %r15b
jmp 0x85924
cmpl $0xdc00, %eax # imm = 0xDC00
je 0x85cd0
cmpl $0x110000, %r15d # imm = 0x110000
jae 0x85cf5
cmpl $0x7f, %r15d
jbe 0x85924
cmpl $0x7ff, %r15d # imm = 0x7FF
ja 0x85af6
movl %r15d, %eax
shrl $0x6, %eax
orb $-0x40, %al
jmp 0x85a78
cmpl $0x22, %eax
je 0x85b18
cmpl $0x2f, %eax
je 0x85b10
cmpl $0x5c, %eax
jne 0x85caf
movb $0x5c, %r15b
jmp 0x85924
cmpl $0x62, %eax
je 0x85b38
cmpl $0x66, %eax
jne 0x85caf
movb $0xc, %r15b
jmp 0x85924
cmpl $0xffff, %r15d # imm = 0xFFFF
ja 0x85a46
movl %r15d, %eax
shrl $0xc, %eax
orb $-0x20, %al
jmp 0x85a63
movb $0x2f, %r15b
jmp 0x85924
movb $0x22, %r15b
jmp 0x85924
movb $0x9, %r15b
jmp 0x85924
movb $0xa, %r15b
jmp 0x85924
movb $0xd, %r15b
jmp 0x85924
movb $0x8, %r15b
jmp 0x85924
movl $0x4, %eax
jmp 0x85cb8
leaq 0x94739(%rip), %rbp # 0x11a28a
jmp 0x85caf
leaq 0x9457b(%rip), %rbp # 0x11a0d8
jmp 0x85caf
leaq 0x946d9(%rip), %rbp # 0x11a242
jmp 0x85caf
leaq 0x941a6(%rip), %rbp # 0x119d1b
jmp 0x85caf
leaq 0x94631(%rip), %rbp # 0x11a1b2
jmp 0x85caf
leaq 0x94502(%rip), %rbp # 0x11a08f
jmp 0x85caf
leaq 0x93f2c(%rip), %rbp # 0x119ac5
jmp 0x85caf
leaq 0x94044(%rip), %rbp # 0x119be9
jmp 0x85caf
leaq 0x93ecb(%rip), %rbp # 0x119a7c
jmp 0x85caf
leaq 0x93f9a(%rip), %rbp # 0x119b57
jmp 0x85caf
leaq 0x93fd7(%rip), %rbp # 0x119ba0
jmp 0x85caf
movq %r12, %rbp
jmp 0x85caf
leaq 0x9426a(%rip), %rbp # 0x119e47
jmp 0x85caf
leaq 0x941ce(%rip), %rbp # 0x119db7
jmp 0x85caf
leaq 0x93c61(%rip), %rbp # 0x119856
jmp 0x85caf
leaq 0x93f0d(%rip), %rbp # 0x119b0e
jmp 0x85caf
leaq 0x94283(%rip), %rbp # 0x119e90
jmp 0x85caf
leaq 0x93d88(%rip), %rbp # 0x1199a1
jmp 0x85caf
leaq 0x93e0e(%rip), %rbp # 0x119a33
jmp 0x85caf
leaq 0x942f1(%rip), %rbp # 0x119f22
jmp 0x85caf
leaq 0x94331(%rip), %rbp # 0x119f6b
jmp 0x85caf
leaq 0x94526(%rip), %rbp # 0x11a169
jmp 0x85caf
leaq 0x93feb(%rip), %rbp # 0x119c37
jmp 0x85caf
leaq 0x9435f(%rip), %rbp # 0x119fb4
jmp 0x85caf
leaq 0x9410b(%rip), %rbp # 0x119d69
jmp 0x85caf
leaq 0x944b9(%rip), %rbp # 0x11a120
jmp 0x85caf
leaq 0x94015(%rip), %rbp # 0x119c85
jmp 0x85caf
leaq 0x9405a(%rip), %rbp # 0x119cd3
jmp 0x85caf
leaq 0x94257(%rip), %rbp # 0x119ed9
jmp 0x85caf
leaq 0x94174(%rip), %rbp # 0x119dff
jmp 0x85caf
leaq 0x94566(%rip), %rbp # 0x11a1fa
jmp 0x85caf
leaq 0x94360(%rip), %rbp # 0x119ffd
jmp 0x85caf
leaq 0x943a0(%rip), %rbp # 0x11a046
jmp 0x85caf
leaq 0x94623(%rip), %rbp # 0x11a2d2
movq %rbp, 0x70(%rbx)
movl $0xe, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x93be4(%rip), %rbp # 0x1198b2
jmp 0x85caf
leaq 0x93c27(%rip), %rbp # 0x1198fe
jmp 0x85caf
leaq 0x938f8(%rip), %rdi # 0x1195d8
leaq 0x9392c(%rip), %rdx # 0x119613
leaq 0x93b58(%rip), %rcx # 0x119846
movl $0x1dd1, %esi # imm = 0x1DD1
jmp 0x85d0f
leaq 0x938dc(%rip), %rdi # 0x1195d8
leaq 0x93910(%rip), %rdx # 0x119613
leaq 0x93c38(%rip), %rcx # 0x119942
movl $0x1e49, %esi # imm = 0x1E49
xorl %eax, %eax
callq 0x20e60
|
_ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE11scan_stringEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5resetEv; 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>>>::reset(void)
cmp dword ptr [rbx+14h], 22h ; '"'
jnz loc_85CD9
lea r14, [rbx+50h]
lea r12, aInvalidStringC; "invalid string: control character U+000"...
lea r13, jpt_858F3
loc_858D6:
mov rdi, rbx
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)
inc eax; switch 246 cases
cmp eax, 0F5h
ja def_858F3; jumptable 00000000000858F3 default case, cases 128-193
movsxd rax, ds:(jpt_858F3 - 112A90h)[r13+rax*4]
add rax, r13
jmp rax; switch jump
loc_858F5:
mov rax, 0BF00000080h; jumptable 00000000000858F3 cases 194-223
mov rsi, rsp
mov [rsi], rax
mov edx, 2
jmp short loc_85976
loc_8590C:
movaps xmm0, cs:xmmword_1123A0; jumptable 00000000000858F3 cases 225-236,238,239
loc_85913:
mov rsi, rsp
movaps xmmword ptr [rsi], xmm0
mov edx, 4
jmp short loc_85976
loc_85920:
mov r15b, [rbx+14h]; jumptable 00000000000858F3 cases 32,33,35-91,93-127
loc_85924:
movsx esi, r15b
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
jmp short loc_858D6
loc_85932:
movups xmm0, cs:xmmword_11C298; jumptable 00000000000858F3 cases 241-243
jmp short loc_8595D
loc_8593B:
movaps xmm0, cs:xmmword_112390; jumptable 00000000000858F3 case 237
jmp short loc_85913
loc_85944:
movaps xmm0, cs:xmmword_1123B0; jumptable 00000000000858F3 case 224
jmp short loc_85913
loc_8594D:
movups xmm0, cs:xmmword_11C2B0; jumptable 00000000000858F3 case 244
jmp short loc_8595D
loc_85956:
movups xmm0, cs:xmmword_11C280; jumptable 00000000000858F3 case 240
loc_8595D:
mov rsi, rsp
movaps xmmword ptr [rsi], xmm0
mov rax, 0BF00000080h
mov [rsi+10h], rax
mov edx, 6
loc_85976:
mov rdi, rbx
call _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; 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>>>::next_byte_in_range(std::initializer_list<int>)
test al, al
jnz loc_858D6
jmp loc_85CB3
loc_8598B:
mov rdi, rbx; jumptable 00000000000858F3 case 92
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)
lea rbp, aInvalidStringF; "invalid string: forbidden character aft"...
cmp eax, 61h ; 'a'
jle loc_85AC5
lea ecx, [rax-6Eh]; switch 8 cases
cmp ecx, 7
ja def_859BD; jumptable 00000000000859BD default case
lea rax, jpt_859BD
movsxd rcx, ds:(jpt_859BD - 112E68h)[rax+rcx*4]
add rcx, rax
jmp rcx; switch jump
loc_859BF:
mov rdi, rbx; jumptable 00000000000859BD case 117
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE13get_codepointEv; 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_codepoint(void)
lea rbp, aInvalidStringU; "invalid string: '\\u' must be followed "...
cmp eax, 0FFFFFFFFh
jz loc_85CAF; jumptable 00000000000859BD cases 111-113,115
mov r15d, eax
and eax, 0FFFFFC00h
cmp eax, 0D800h
jnz loc_85A90
mov rdi, rbx
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)
cmp eax, 5Ch ; '\'
jnz loc_85CC7
mov rdi, rbx
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)
cmp eax, 75h ; 'u'
jnz loc_85CC7
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE13get_codepointEv; 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_codepoint(void)
cmp eax, 0FFFFFFFFh
jz loc_85CAF; jumptable 00000000000859BD cases 111-113,115
mov ecx, eax
and ecx, 0FFFFFC00h
lea rbp, aInvalidStringS; "invalid string: surrogate U+D800..U+DBF"...
cmp ecx, 0DC00h
jnz loc_85CAF; jumptable 00000000000859BD cases 111-113,115
shl r15d, 0Ah
add r15d, eax
add r15d, 0FCA02400h
loc_85A46:
mov eax, r15d
shr eax, 12h
or al, 0F0h
movsx esi, al
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov eax, r15d
shr eax, 0Ch
and al, 3Fh
or al, 80h
loc_85A63:
movsx esi, al
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov eax, r15d
shr eax, 6
and al, 3Fh
or al, 80h
loc_85A78:
movsx esi, al
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
and r15b, 3Fh
or r15b, 80h
jmp loc_85924
loc_85A90:
cmp eax, 0DC00h
jz loc_85CD0
cmp r15d, 110000h
jnb loc_85CF5
cmp r15d, 7Fh
jbe loc_85924
cmp r15d, 7FFh
ja short loc_85AF6
mov eax, r15d
shr eax, 6
or al, 0C0h
jmp short loc_85A78
loc_85AC5:
cmp eax, 22h ; '"'
jz short loc_85B18
cmp eax, 2Fh ; '/'
jz short loc_85B10
cmp eax, 5Ch ; '\'
jnz loc_85CAF; jumptable 00000000000859BD cases 111-113,115
mov r15b, 5Ch ; '\'
jmp loc_85924
def_859BD:
cmp eax, 62h ; 'b'; jumptable 00000000000859BD default case
jz short loc_85B38
cmp eax, 66h ; 'f'
jnz loc_85CAF; jumptable 00000000000859BD cases 111-113,115
mov r15b, 0Ch
jmp loc_85924
loc_85AF6:
cmp r15d, 0FFFFh
ja loc_85A46
mov eax, r15d
shr eax, 0Ch
or al, 0E0h
jmp loc_85A63
loc_85B10:
mov r15b, 2Fh ; '/'
jmp loc_85924
loc_85B18:
mov r15b, 22h ; '"'
jmp loc_85924
loc_85B20:
mov r15b, 9; jumptable 00000000000859BD case 116
jmp loc_85924
loc_85B28:
mov r15b, 0Ah; jumptable 00000000000859BD case 110
jmp loc_85924
loc_85B30:
mov r15b, 0Dh; jumptable 00000000000859BD case 114
jmp loc_85924
loc_85B38:
mov r15b, 8
jmp loc_85924
loc_85B40:
mov eax, 4; jumptable 00000000000858F3 case 34
jmp loc_85CB8
loc_85B4A:
lea rbp, aInvalidStringC_0; jumptable 00000000000858F3 case 31
jmp loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85B56:
lea rbp, aInvalidStringC_1; jumptable 00000000000858F3 case 25
jmp loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85B62:
lea rbp, aInvalidStringC_2; jumptable 00000000000858F3 case 30
jmp loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85B6E:
lea rbp, aInvalidStringC_3; jumptable 00000000000858F3 case 12
jmp loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85B7A:
lea rbp, aInvalidStringC_4; jumptable 00000000000858F3 case 28
jmp loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85B86:
lea rbp, aInvalidStringC_5; jumptable 00000000000858F3 case 24
jmp loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85B92:
lea rbp, aInvalidStringC_6; jumptable 00000000000858F3 case 4
jmp loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85B9E:
lea rbp, aInvalidStringC_7; jumptable 00000000000858F3 case 8
jmp loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85BAA:
lea rbp, aInvalidStringC_8; jumptable 00000000000858F3 case 3
jmp loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85BB6:
lea rbp, aInvalidStringC_9; jumptable 00000000000858F3 case 6
jmp loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85BC2:
lea rbp, aInvalidStringC_10; jumptable 00000000000858F3 case 7
jmp loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85BCE:
mov rbp, r12; jumptable 00000000000858F3 case 1
jmp loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85BD6:
lea rbp, aInvalidStringC_11; jumptable 00000000000858F3 case 16
jmp loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85BE2:
lea rbp, aInvalidStringC_12; jumptable 00000000000858F3 case 14
jmp loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85BEE:
lea rbp, aInvalidStringM; jumptable 00000000000858F3 case -1
jmp loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85BFA:
lea rbp, aInvalidStringC_13; jumptable 00000000000858F3 case 5
jmp loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85C06:
lea rbp, aInvalidStringC_14; jumptable 00000000000858F3 case 17
jmp loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85C12:
lea rbp, aInvalidStringC_15; jumptable 00000000000858F3 case 0
jmp loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85C1E:
lea rbp, aInvalidStringC_16; jumptable 00000000000858F3 case 2
jmp loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85C2A:
lea rbp, aInvalidStringC_17; jumptable 00000000000858F3 case 19
jmp short loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85C33:
lea rbp, aInvalidStringC_18; jumptable 00000000000858F3 case 20
jmp short loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85C3C:
lea rbp, aInvalidStringC_19; jumptable 00000000000858F3 case 27
jmp short loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85C45:
lea rbp, aInvalidStringC_20; jumptable 00000000000858F3 case 9
jmp short loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85C4E:
lea rbp, aInvalidStringC_21; jumptable 00000000000858F3 case 21
jmp short loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85C57:
lea rbp, aInvalidStringC_22; jumptable 00000000000858F3 case 13
jmp short loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85C60:
lea rbp, aInvalidStringC_23; jumptable 00000000000858F3 case 26
jmp short loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85C69:
lea rbp, aInvalidStringC_24; jumptable 00000000000858F3 case 10
jmp short loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85C72:
lea rbp, aInvalidStringC_25; jumptable 00000000000858F3 case 11
jmp short loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85C7B:
lea rbp, aInvalidStringC_26; jumptable 00000000000858F3 case 18
jmp short loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85C84:
lea rbp, aInvalidStringC_27; jumptable 00000000000858F3 case 15
jmp short loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85C8D:
lea rbp, aInvalidStringC_28; jumptable 00000000000858F3 case 29
jmp short loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85C96:
lea rbp, aInvalidStringC_29; jumptable 00000000000858F3 case 22
jmp short loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85C9F:
lea rbp, aInvalidStringC_30; jumptable 00000000000858F3 case 23
jmp short loc_85CAF; jumptable 00000000000859BD cases 111-113,115
def_858F3:
lea rbp, aInvalidStringI; jumptable 00000000000858F3 default case, cases 128-193
loc_85CAF:
mov [rbx+70h], rbp; jumptable 00000000000859BD cases 111-113,115
loc_85CB3:
mov eax, 0Eh
loc_85CB8:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_85CC7:
lea rbp, aInvalidStringS; "invalid string: surrogate U+D800..U+DBF"...
jmp short loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85CD0:
lea rbp, aInvalidStringS_0; "invalid string: surrogate U+DC00..U+DFF"...
jmp short loc_85CAF; jumptable 00000000000859BD cases 111-113,115
loc_85CD9:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCurrent; "current == '\\\"'"
mov esi, 1DD1h
jmp short loc_85D0F
loc_85CF5:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, a0x00CodepointC; "0x00 <= codepoint && codepoint <= 0x10F"...
mov esi, 1E49h
loc_85D0F:
xor eax, eax
call _ggml_abort
|
long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::scan_string(
__m128i *a1)
{
long long v1; // rcx
long long v2; // r8
long long v3; // r9
long long v4; // rdx
__int128 v5; // xmm0
unsigned int v6; // r15d
__int128 v7; // xmm0
int v8; // eax
const char *v9; // rbp
unsigned int codepoint; // eax
unsigned int v11; // eax
int v12; // eax
char v13; // al
char v14; // al
__int128 v16; // [rsp+0h] [rbp-48h] BYREF
long long v17; // [rsp+10h] [rbp-38h]
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();
if ( a1[1].m128i_i32[1] != 34 )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
7633LL,
"GGML_ASSERT(%s) failed",
"current == '\\\"'");
return 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>>>::scan_number("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp");
}
while ( 2 )
{
while ( 2 )
{
switch ( (unsigned int)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) )
{
case 0xFFFFFFFF:
v9 = "invalid string: missing closing quote";
goto LABEL_83;
case 0u:
v9 = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
goto LABEL_83;
case 1u:
v9 = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
goto LABEL_83;
case 2u:
v9 = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
goto LABEL_83;
case 3u:
v9 = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
goto LABEL_83;
case 4u:
v9 = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
goto LABEL_83;
case 5u:
v9 = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
goto LABEL_83;
case 6u:
v9 = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
goto LABEL_83;
case 7u:
v9 = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
goto LABEL_83;
case 8u:
v9 = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
goto LABEL_83;
case 9u:
v9 = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
goto LABEL_83;
case 0xAu:
v9 = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
goto LABEL_83;
case 0xBu:
v9 = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
goto LABEL_83;
case 0xCu:
v9 = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
goto LABEL_83;
case 0xDu:
v9 = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
goto LABEL_83;
case 0xEu:
v9 = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
goto LABEL_83;
case 0xFu:
v9 = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
goto LABEL_83;
case 0x10u:
v9 = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
goto LABEL_83;
case 0x11u:
v9 = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
goto LABEL_83;
case 0x12u:
v9 = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
goto LABEL_83;
case 0x13u:
v9 = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
goto LABEL_83;
case 0x14u:
v9 = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
goto LABEL_83;
case 0x15u:
v9 = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
goto LABEL_83;
case 0x16u:
v9 = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
goto LABEL_83;
case 0x17u:
v9 = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
goto LABEL_83;
case 0x18u:
v9 = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
goto LABEL_83;
case 0x19u:
v9 = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
goto LABEL_83;
case 0x1Au:
v9 = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
goto LABEL_83;
case 0x1Bu:
v9 = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
goto LABEL_83;
case 0x1Cu:
v9 = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
goto LABEL_83;
case 0x1Du:
v9 = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
goto LABEL_83;
case 0x1Eu:
v9 = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
goto LABEL_83;
case 0x1Fu:
v9 = "invalid string: control character U+001F (US) must be escaped to \\u001F";
goto LABEL_83;
case 0x20u:
case 0x21u:
case 0x23u:
case 0x24u:
case 0x25u:
case 0x26u:
case 0x27u:
case 0x28u:
case 0x29u:
case 0x2Au:
case 0x2Bu:
case 0x2Cu:
case 0x2Du:
case 0x2Eu:
case 0x2Fu:
case 0x30u:
case 0x31u:
case 0x32u:
case 0x33u:
case 0x34u:
case 0x35u:
case 0x36u:
case 0x37u:
case 0x38u:
case 0x39u:
case 0x3Au:
case 0x3Bu:
case 0x3Cu:
case 0x3Du:
case 0x3Eu:
case 0x3Fu:
case 0x40u:
case 0x41u:
case 0x42u:
case 0x43u:
case 0x44u:
case 0x45u:
case 0x46u:
case 0x47u:
case 0x48u:
case 0x49u:
case 0x4Au:
case 0x4Bu:
case 0x4Cu:
case 0x4Du:
case 0x4Eu:
case 0x4Fu:
case 0x50u:
case 0x51u:
case 0x52u:
case 0x53u:
case 0x54u:
case 0x55u:
case 0x56u:
case 0x57u:
case 0x58u:
case 0x59u:
case 0x5Au:
case 0x5Bu:
case 0x5Du:
case 0x5Eu:
case 0x5Fu:
case 0x60u:
case 0x61u:
case 0x62u:
case 0x63u:
case 0x64u:
case 0x65u:
case 0x66u:
case 0x67u:
case 0x68u:
case 0x69u:
case 0x6Au:
case 0x6Bu:
case 0x6Cu:
case 0x6Du:
case 0x6Eu:
case 0x6Fu:
case 0x70u:
case 0x71u:
case 0x72u:
case 0x73u:
case 0x74u:
case 0x75u:
case 0x76u:
case 0x77u:
case 0x78u:
case 0x79u:
case 0x7Au:
case 0x7Bu:
case 0x7Cu:
case 0x7Du:
case 0x7Eu:
case 0x7Fu:
LOBYTE(v6) = a1[1].m128i_i8[4];
goto LABEL_7;
case 0x22u:
return 4LL;
case 0x5Cu:
v8 = 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);
v9 = "invalid string: forbidden character after backslash";
if ( v8 <= 97 )
{
switch ( v8 )
{
case '"':
LOBYTE(v6) = 34;
break;
case '/':
LOBYTE(v6) = 47;
break;
case '\\':
LOBYTE(v6) = 92;
break;
default:
goto LABEL_83;
}
goto LABEL_7;
}
break;
case 0xC2u:
case 0xC3u:
case 0xC4u:
case 0xC5u:
case 0xC6u:
case 0xC7u:
case 0xC8u:
case 0xC9u:
case 0xCAu:
case 0xCBu:
case 0xCCu:
case 0xCDu:
case 0xCEu:
case 0xCFu:
case 0xD0u:
case 0xD1u:
case 0xD2u:
case 0xD3u:
case 0xD4u:
case 0xD5u:
case 0xD6u:
case 0xD7u:
case 0xD8u:
case 0xD9u:
case 0xDAu:
case 0xDBu:
case 0xDCu:
case 0xDDu:
case 0xDEu:
case 0xDFu:
*(_QWORD *)&v16 = 0xBF00000080LL;
v4 = 2LL;
goto LABEL_14;
case 0xE0u:
v5 = xmmword_1123B0;
goto LABEL_5;
case 0xE1u:
case 0xE2u:
case 0xE3u:
case 0xE4u:
case 0xE5u:
case 0xE6u:
case 0xE7u:
case 0xE8u:
case 0xE9u:
case 0xEAu:
case 0xEBu:
case 0xECu:
case 0xEEu:
case 0xEFu:
v5 = xmmword_1123A0;
goto LABEL_5;
case 0xEDu:
v5 = xmmword_112390;
LABEL_5:
v16 = v5;
v4 = 4LL;
goto LABEL_14;
case 0xF0u:
v7 = xmmword_11C280;
goto LABEL_13;
case 0xF1u:
case 0xF2u:
case 0xF3u:
v7 = xmmword_11C298;
goto LABEL_13;
case 0xF4u:
v7 = xmmword_11C2B0;
LABEL_13:
v16 = v7;
v17 = 0xBF00000080LL;
v4 = 6LL;
LABEL_14:
if ( !(unsigned __int8)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(
a1,
&v16,
v4,
v1,
v2,
v3,
v16,
*((_QWORD *)&v16 + 1),
v17) )
return 14LL;
continue;
default:
v9 = "invalid string: ill-formed UTF-8 byte";
goto LABEL_83;
}
break;
}
switch ( v8 )
{
case 'n':
LOBYTE(v6) = 10;
goto LABEL_7;
case 'o':
case 'p':
case 'q':
case 's':
goto LABEL_83;
case 'r':
LOBYTE(v6) = 13;
goto LABEL_7;
case 't':
LOBYTE(v6) = 9;
goto LABEL_7;
case 'u':
codepoint = 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_codepoint(a1);
v9 = "invalid string: '\\u' must be followed by 4 hex digits";
if ( codepoint == -1 )
goto LABEL_83;
v6 = codepoint;
v11 = codepoint & 0xFFFFFC00;
if ( v11 == 55296 )
{
if ( (unsigned int)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) != 92
|| (unsigned int)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) != 117 )
{
v9 = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
LABEL_83:
a1[7].m128i_i64[0] = (long long)v9;
return 14LL;
}
v12 = 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_codepoint(a1);
if ( v12 == -1 )
goto LABEL_83;
v9 = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
if ( (v12 & 0xFFFFFC00) != 0xDC00 )
goto LABEL_83;
v6 = v12 + (v6 << 10) - 56613888;
goto LABEL_25;
}
if ( v11 == 56320 )
{
v9 = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
goto LABEL_83;
}
if ( v6 < 0x110000 )
{
if ( v6 > 0x7F )
{
if ( v6 <= 0x7FF )
{
v14 = (v6 >> 6) | 0xC0;
goto LABEL_27;
}
if ( v6 <= 0xFFFF )
{
v13 = (v6 >> 12) | 0xE0;
goto LABEL_26;
}
LABEL_25:
std::string::push_back(&a1[5], (unsigned int)(char)((v6 >> 18) | 0xF0));
v13 = (v6 >> 12) & 0x3F | 0x80;
LABEL_26:
std::string::push_back(&a1[5], (unsigned int)v13);
v14 = (v6 >> 6) & 0x3F | 0x80;
LABEL_27:
std::string::push_back(&a1[5], (unsigned int)v14);
LOBYTE(v6) = v6 & 0x3F | 0x80;
}
LABEL_7:
std::string::push_back(&a1[5], (unsigned int)(char)v6);
continue;
}
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
7753LL,
"GGML_ASSERT(%s) failed",
"0x00 <= codepoint && codepoint <= 0x10FFFF");
return 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>>>::scan_number("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp");
default:
if ( v8 == 98 )
{
LOBYTE(v6) = 8;
}
else
{
if ( v8 != 102 )
goto LABEL_83;
LOBYTE(v6) = 12;
}
goto LABEL_7;
}
}
}
|
scan_string:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
CALL 0x001860e0
CMP dword ptr [RBX + 0x14],0x22
JNZ 0x00185cd9
LEA R14,[RBX + 0x50]
LEA R12,[0x2199ea]
LEA R13,[0x212a90]
LAB_001858d6:
MOV RDI,RBX
CALL 0x00121688
INC EAX
CMP EAX,0xf5
JA 0x00185ca8
MOVSXD RAX,dword ptr [R13 + RAX*0x4]
ADD RAX,R13
switchD:
JMP RAX
caseD_c2:
MOV RAX,0xbf00000080
MOV RSI,RSP
MOV qword ptr [RSI],RAX
MOV EDX,0x2
JMP 0x00185976
caseD_e1:
MOVAPS XMM0,xmmword ptr [0x002123a0]
LAB_00185913:
MOV RSI,RSP
MOVAPS xmmword ptr [RSI],XMM0
MOV EDX,0x4
JMP 0x00185976
caseD_20:
MOV R15B,byte ptr [RBX + 0x14]
LAB_00185924:
MOVSX ESI,R15B
MOV RDI,R14
CALL 0x001213a0
JMP 0x001858d6
caseD_f1:
MOVUPS XMM0,xmmword ptr [0x0021c298]
JMP 0x0018595d
caseD_ed:
MOVAPS XMM0,xmmword ptr [0x00212390]
JMP 0x00185913
caseD_e0:
MOVAPS XMM0,xmmword ptr [0x002123b0]
JMP 0x00185913
caseD_f4:
MOVUPS XMM0,xmmword ptr [0x0021c2b0]
JMP 0x0018595d
caseD_f0:
MOVUPS XMM0,xmmword ptr [0x0021c280]
LAB_0018595d:
MOV RSI,RSP
MOVAPS xmmword ptr [RSI],XMM0
MOV RAX,0xbf00000080
MOV qword ptr [RSI + 0x10],RAX
MOV EDX,0x6
LAB_00185976:
MOV RDI,RBX
CALL 0x00186164
TEST AL,AL
JNZ 0x001858d6
JMP 0x00185cb3
caseD_5c:
MOV RDI,RBX
CALL 0x00121688
LEA RBP,[0x21996d]
CMP EAX,0x61
JLE 0x00185ac5
LEA ECX,[RAX + -0x6e]
CMP ECX,0x7
JA 0x00185ae0
LEA RAX,[0x212e68]
MOVSXD RCX,dword ptr [RAX + RCX*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_75:
MOV RDI,RBX
CALL 0x0018611e
LEA RBP,[0x21987c]
CMP EAX,-0x1
JZ 0x00185caf
MOV R15D,EAX
AND EAX,0xfffffc00
CMP EAX,0xd800
JNZ 0x00185a90
MOV RDI,RBX
CALL 0x00121688
CMP EAX,0x5c
JNZ 0x00185cc7
MOV RDI,RBX
CALL 0x00121688
CMP EAX,0x75
JNZ 0x00185cc7
MOV RDI,RBX
CALL 0x0018611e
CMP EAX,-0x1
JZ 0x00185caf
MOV ECX,EAX
AND ECX,0xfffffc00
LEA RBP,[0x2198b2]
CMP ECX,0xdc00
JNZ 0x00185caf
SHL R15D,0xa
ADD R15D,EAX
ADD R15D,0xfca02400
LAB_00185a46:
MOV EAX,R15D
SHR EAX,0x12
OR AL,0xf0
MOVSX ESI,AL
MOV RDI,R14
CALL 0x001213a0
MOV EAX,R15D
SHR EAX,0xc
AND AL,0x3f
OR AL,0x80
LAB_00185a63:
MOVSX ESI,AL
MOV RDI,R14
CALL 0x001213a0
MOV EAX,R15D
SHR EAX,0x6
AND AL,0x3f
OR AL,0x80
LAB_00185a78:
MOVSX ESI,AL
MOV RDI,R14
CALL 0x001213a0
AND R15B,0x3f
OR R15B,0x80
JMP 0x00185924
LAB_00185a90:
CMP EAX,0xdc00
JZ 0x00185cd0
CMP R15D,0x110000
JNC 0x00185cf5
CMP R15D,0x7f
JBE 0x00185924
CMP R15D,0x7ff
JA 0x00185af6
MOV EAX,R15D
SHR EAX,0x6
OR AL,0xc0
JMP 0x00185a78
LAB_00185ac5:
CMP EAX,0x22
JZ 0x00185b18
CMP EAX,0x2f
JZ 0x00185b10
CMP EAX,0x5c
JNZ 0x00185caf
MOV R15B,0x5c
JMP 0x00185924
default:
CMP EAX,0x62
JZ 0x00185b38
CMP EAX,0x66
JNZ 0x00185caf
MOV R15B,0xc
JMP 0x00185924
LAB_00185af6:
CMP R15D,0xffff
JA 0x00185a46
MOV EAX,R15D
SHR EAX,0xc
OR AL,0xe0
JMP 0x00185a63
LAB_00185b10:
MOV R15B,0x2f
JMP 0x00185924
LAB_00185b18:
MOV R15B,0x22
JMP 0x00185924
caseD_74:
MOV R15B,0x9
JMP 0x00185924
caseD_6e:
MOV R15B,0xa
JMP 0x00185924
caseD_72:
MOV R15B,0xd
JMP 0x00185924
LAB_00185b38:
MOV R15B,0x8
JMP 0x00185924
caseD_22:
MOV EAX,0x4
JMP 0x00185cb8
caseD_1f:
LEA RBP,[0x21a28a]
JMP 0x00185caf
caseD_19:
LEA RBP,[0x21a0d8]
JMP 0x00185caf
caseD_1e:
LEA RBP,[0x21a242]
JMP 0x00185caf
caseD_c:
LEA RBP,[0x219d1b]
JMP 0x00185caf
caseD_1c:
LEA RBP,[0x21a1b2]
JMP 0x00185caf
caseD_18:
LEA RBP,[0x21a08f]
JMP 0x00185caf
caseD_4:
LEA RBP,[0x219ac5]
JMP 0x00185caf
caseD_8:
LEA RBP,[0x219be9]
JMP 0x00185caf
caseD_3:
LEA RBP,[0x219a7c]
JMP 0x00185caf
caseD_6:
LEA RBP,[0x219b57]
JMP 0x00185caf
caseD_7:
LEA RBP,[0x219ba0]
JMP 0x00185caf
caseD_1:
MOV RBP,R12
JMP 0x00185caf
caseD_10:
LEA RBP,[0x219e47]
JMP 0x00185caf
caseD_e:
LEA RBP,[0x219db7]
JMP 0x00185caf
caseD_ffffffff:
LEA RBP,[0x219856]
JMP 0x00185caf
caseD_5:
LEA RBP,[0x219b0e]
JMP 0x00185caf
caseD_11:
LEA RBP,[0x219e90]
JMP 0x00185caf
caseD_0:
LEA RBP,[0x2199a1]
JMP 0x00185caf
caseD_2:
LEA RBP,[0x219a33]
JMP 0x00185caf
caseD_13:
LEA RBP,[0x219f22]
JMP 0x00185caf
caseD_14:
LEA RBP,[0x219f6b]
JMP 0x00185caf
caseD_1b:
LEA RBP,[0x21a169]
JMP 0x00185caf
caseD_9:
LEA RBP,[0x219c37]
JMP 0x00185caf
caseD_15:
LEA RBP,[0x219fb4]
JMP 0x00185caf
caseD_d:
LEA RBP,[0x219d69]
JMP 0x00185caf
caseD_1a:
LEA RBP,[0x21a120]
JMP 0x00185caf
caseD_a:
LEA RBP,[0x219c85]
JMP 0x00185caf
caseD_b:
LEA RBP,[0x219cd3]
JMP 0x00185caf
caseD_12:
LEA RBP,[0x219ed9]
JMP 0x00185caf
caseD_f:
LEA RBP,[0x219dff]
JMP 0x00185caf
caseD_1d:
LEA RBP,[0x21a1fa]
JMP 0x00185caf
caseD_16:
LEA RBP,[0x219ffd]
JMP 0x00185caf
caseD_17:
LEA RBP,[0x21a046]
JMP 0x00185caf
caseD_80:
LEA RBP,[0x21a2d2]
caseD_6f:
MOV qword ptr [RBX + 0x70],RBP
LAB_00185cb3:
MOV EAX,0xe
LAB_00185cb8:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00185cc7:
LEA RBP,[0x2198b2]
JMP 0x00185caf
LAB_00185cd0:
LEA RBP,[0x2198fe]
JMP 0x00185caf
LAB_00185cd9:
LEA RDI,[0x2195d8]
LEA RDX,[0x219613]
LEA RCX,[0x219846]
MOV ESI,0x1dd1
JMP 0x00185d0f
LAB_00185cf5:
LEA RDI,[0x2195d8]
LEA RDX,[0x219613]
LEA RCX,[0x219942]
MOV ESI,0x1e49
LAB_00185d0f:
XOR EAX,EAX
CALL 0x00120e60
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* 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 > > >::scan_string() */
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>>>
::scan_string(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)
{
char cVar1;
int4 uVar2;
int iVar3;
uint uVar4;
char *pcVar5;
int8 uVar6;
char cVar7;
int4 uVar8;
int8 local_48;
int4 uStack_40;
int4 uStack_3c;
int8 local_38;
reset(this);
if (*(int *)(this + 0x14) != 0x22) {
pcVar5 = "current == \'\\\"\'";
uVar6 = 0x1dd1;
LAB_00185d0f:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",uVar6,
"GGML_ASSERT(%s) failed",pcVar5);
}
cVar7 = (char)this + 'P';
LAB_001858d6:
uVar2 = get(this);
switch(uVar2) {
case 0:
pcVar5 = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
break;
case 1:
pcVar5 = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
break;
case 2:
pcVar5 = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
break;
case 3:
pcVar5 = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
break;
case 4:
pcVar5 = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
break;
case 5:
pcVar5 = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
break;
case 6:
pcVar5 = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
break;
case 7:
pcVar5 = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
break;
case 8:
pcVar5 = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
break;
case 9:
pcVar5 = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
break;
case 10:
pcVar5 = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
break;
case 0xb:
pcVar5 = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
break;
case 0xc:
pcVar5 = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
break;
case 0xd:
pcVar5 = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
break;
case 0xe:
pcVar5 = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
break;
case 0xf:
pcVar5 = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
break;
case 0x10:
pcVar5 = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
break;
case 0x11:
pcVar5 = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
break;
case 0x12:
pcVar5 = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
break;
case 0x13:
pcVar5 = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
break;
case 0x14:
pcVar5 = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
break;
case 0x15:
pcVar5 = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
break;
case 0x16:
pcVar5 = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
break;
case 0x17:
pcVar5 = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
break;
case 0x18:
pcVar5 = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
break;
case 0x19:
pcVar5 = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
break;
case 0x1a:
pcVar5 = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
break;
case 0x1b:
pcVar5 = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
break;
case 0x1c:
pcVar5 = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
break;
case 0x1d:
pcVar5 = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
break;
case 0x1e:
pcVar5 = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
break;
case 0x1f:
pcVar5 = "invalid string: control character U+001F (US) must be escaped to \\u001F";
break;
case 0x20:
case 0x21:
case 0x23:
case 0x24:
case 0x25:
case 0x26:
case 0x27:
case 0x28:
case 0x29:
case 0x2a:
case 0x2b:
case 0x2c:
case 0x2d:
case 0x2e:
case 0x2f:
case 0x30:
case 0x31:
case 0x32:
case 0x33:
case 0x34:
case 0x35:
case 0x36:
case 0x37:
case 0x38:
case 0x39:
case 0x3a:
case 0x3b:
case 0x3c:
case 0x3d:
case 0x3e:
case 0x3f:
case 0x40:
case 0x41:
case 0x42:
case 0x43:
case 0x44:
case 0x45:
case 0x46:
case 0x47:
case 0x48:
case 0x49:
case 0x4a:
case 0x4b:
case 0x4c:
case 0x4d:
case 0x4e:
case 0x4f:
case 0x50:
case 0x51:
case 0x52:
case 0x53:
case 0x54:
case 0x55:
case 0x56:
case 0x57:
case 0x58:
case 0x59:
case 0x5a:
case 0x5b:
case 0x5d:
case 0x5e:
case 0x5f:
case 0x60:
case 0x61:
case 0x62:
case 99:
case 100:
case 0x65:
case 0x66:
case 0x67:
case 0x68:
case 0x69:
case 0x6a:
case 0x6b:
case 0x6c:
case 0x6d:
case 0x6e:
case 0x6f:
case 0x70:
case 0x71:
case 0x72:
case 0x73:
case 0x74:
case 0x75:
case 0x76:
case 0x77:
case 0x78:
case 0x79:
case 0x7a:
case 0x7b:
case 0x7c:
case 0x7d:
case 0x7e:
case 0x7f:
goto LAB_00185924;
case 0x22:
return 4;
case 0x5c:
iVar3 = get(this);
pcVar5 = "invalid string: forbidden character after backslash";
if (iVar3 < 0x62) {
if (((iVar3 != 0x22) && (iVar3 != 0x2f)) && (iVar3 != 0x5c)) break;
}
else {
switch(iVar3) {
case 0x6e:
break;
case 0x6f:
case 0x70:
case 0x71:
case 0x73:
goto switchD_001859bd_caseD_6f;
case 0x72:
break;
case 0x74:
break;
case 0x75:
uVar4 = get_codepoint(this);
pcVar5 = "invalid string: \'\\u\' must be followed by 4 hex digits";
if (uVar4 == 0xffffffff) goto switchD_001859bd_caseD_6f;
if ((uVar4 & 0xfffffc00) == 0xd800) {
iVar3 = get(this);
if ((iVar3 != 0x5c) || (iVar3 = get(this), iVar3 != 0x75)) {
pcVar5 = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
goto switchD_001859bd_caseD_6f;
}
uVar4 = get_codepoint(this);
if ((uVar4 == 0xffffffff) ||
(pcVar5 = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF"
, (uVar4 & 0xfffffc00) != 0xdc00)) goto switchD_001859bd_caseD_6f;
LAB_00185a46:
std::__cxx11::string::push_back(cVar7);
LAB_00185a63:
std::__cxx11::string::push_back(cVar7);
}
else {
if ((uVar4 & 0xfffffc00) == 0xdc00) {
pcVar5 = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
goto switchD_001859bd_caseD_6f;
}
if (0x10ffff < uVar4) {
pcVar5 = "0x00 <= codepoint && codepoint <= 0x10FFFF";
uVar6 = 0x1e49;
goto LAB_00185d0f;
}
if (uVar4 < 0x80) break;
if (0x7ff < uVar4) {
if (0xffff < uVar4) goto LAB_00185a46;
goto LAB_00185a63;
}
}
std::__cxx11::string::push_back(cVar7);
break;
default:
if ((iVar3 != 0x62) && (iVar3 != 0x66)) goto switchD_001859bd_caseD_6f;
}
}
LAB_00185924:
std::__cxx11::string::push_back(cVar7);
goto LAB_001858d6;
default:
pcVar5 = "invalid string: ill-formed UTF-8 byte";
break;
case 0xc2:
case 0xc3:
case 0xc4:
case 0xc5:
case 0xc6:
case 199:
case 200:
case 0xc9:
case 0xca:
case 0xcb:
case 0xcc:
case 0xcd:
case 0xce:
case 0xcf:
case 0xd0:
case 0xd1:
case 0xd2:
case 0xd3:
case 0xd4:
case 0xd5:
case 0xd6:
case 0xd7:
case 0xd8:
case 0xd9:
case 0xda:
case 0xdb:
case 0xdc:
case 0xdd:
case 0xde:
case 0xdf:
local_48 = 0xbf00000080;
uVar6 = 2;
goto LAB_00185976;
case 0xe0:
uVar2 = _DAT_002123b0;
uVar8 = _UNK_002123b4;
uStack_40 = _UNK_002123b8;
uStack_3c = _UNK_002123bc;
goto LAB_00185913;
case 0xe1:
case 0xe2:
case 0xe3:
case 0xe4:
case 0xe5:
case 0xe6:
case 0xe7:
case 0xe8:
case 0xe9:
case 0xea:
case 0xeb:
case 0xec:
case 0xee:
case 0xef:
uVar2 = _DAT_002123a0;
uVar8 = _UNK_002123a4;
uStack_40 = _UNK_002123a8;
uStack_3c = _UNK_002123ac;
goto LAB_00185913;
case 0xed:
uVar2 = _DAT_00212390;
uVar8 = _UNK_00212394;
uStack_40 = _UNK_00212398;
uStack_3c = _UNK_0021239c;
LAB_00185913:
local_48 = CONCAT44(uVar8,uVar2);
uVar6 = 4;
LAB_00185976:
cVar1 = next_byte_in_range(this,&local_48,uVar6);
if (cVar1 == '\0') {
return 0xe;
}
goto LAB_001858d6;
case 0xf0:
uVar2 = _DAT_0021c280;
uVar8 = _UNK_0021c284;
uStack_40 = _UNK_0021c288;
uStack_3c = _UNK_0021c28c;
goto LAB_0018595d;
case 0xf1:
case 0xf2:
case 0xf3:
uVar2 = _DAT_0021c298;
uVar8 = _UNK_0021c29c;
uStack_40 = _UNK_0021c2a0;
uStack_3c = _UNK_0021c2a4;
goto LAB_0018595d;
case 0xf4:
uVar2 = _DAT_0021c2b0;
uVar8 = _UNK_0021c2b4;
uStack_40 = _UNK_0021c2b8;
uStack_3c = _UNK_0021c2bc;
LAB_0018595d:
local_48 = CONCAT44(uVar8,uVar2);
local_38 = 0xbf00000080;
uVar6 = 6;
goto LAB_00185976;
case 0xffffffff:
pcVar5 = "invalid string: missing closing quote";
}
switchD_001859bd_caseD_6f:
*(char **)(this + 0x70) = pcVar5;
return 0xe;
}
|
|
6,821 |
mysql_fetch_row_start
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
int STDCALL
mysql_fetch_row_start(MYSQL_ROW *ret, MYSQL_RES *result)
{
MK_ASYNC_START_BODY(
mysql_fetch_row,
result->handle,
{
WIN_SET_NONBLOCKING(result->handle)
parms.result= result;
},
NULL,
r_ptr,
/*
If we already fetched all rows from server (eg. mysql_store_result()),
then result->handle will be NULL and we cannot suspend. But that is fine,
since in this case mysql_fetch_row cannot block anyway. Just return
directly.
*/
if (!result->handle)
{
*ret= mysql_fetch_row(result);
return 0;
})
}
|
O3
|
c
|
mysql_fetch_row_start:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x78(%rsi), %rax
testq %rax, %rax
je 0x2b4be
movq 0x480(%rax), %rax
movq 0x28(%rax), %r15
leaq -0x20(%rbp), %rdx
movq %r14, (%rdx)
movb $0x1, 0x14(%r15)
leaq 0x38(%r15), %rdi
leaq 0xa1(%rip), %rsi # 0x2b545
callq 0x2fd64
movw $0x0, 0x14(%r15)
testl %eax, %eax
jle 0x2b4cb
movb $0x1, 0x15(%r15)
movl (%r15), %eax
jmp 0x2b53a
movq %r14, %rdi
callq 0x1db00
movq %rax, (%rbx)
jmp 0x2b538
js 0x2b4d3
movq 0x8(%r15), %r15
jmp 0x2b535
movq 0x78(%r14), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movl $0x297, %edi # imm = 0x297
addq 0x78(%r14), %rdi
leaq 0x2271f(%rip), %rax # 0x4dc10
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
movq 0x78(%r14), %rax
xorl %r15d, %r15d
movb %r15b, 0x29c(%rax)
movl $0x97, %edi
addq 0x78(%r14), %rdi
leaq 0x22704(%rip), %rax # 0x4dc20
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movq 0x78(%r14), %rax
movb %r15b, 0x296(%rax)
movq %r15, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
mysql_fetch_row_start:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rax, [rsi+78h]
test rax, rax
jz short loc_2B4BE
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_fetch_row_start_internal
call my_context_spawn
mov word ptr [r15+14h], 0
test eax, eax
jle short loc_2B4CB
mov byte ptr [r15+15h], 1
mov eax, [r15]
jmp short loc_2B53A
loc_2B4BE:
mov rdi, r14
call mysql_fetch_row
mov [rbx], rax
jmp short loc_2B538
loc_2B4CB:
js short loc_2B4D3
mov r15, [r15+8]
jmp short loc_2B535
loc_2B4D3:
mov rax, [r14+78h]
mov dword ptr [rax+90h], 7D8h
mov edi, 297h
add rdi, [r14+78h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [r14+78h]
xor r15d, r15d
mov [rax+29Ch], r15b
mov edi, 97h
add rdi, [r14+78h]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [r14+78h]
mov [rax+296h], r15b
loc_2B535:
mov [rbx], r15
loc_2B538:
xor eax, eax
loc_2B53A:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long mysql_fetch_row_start(long long *a1, long long a2)
{
long long v2; // rax
long long v3; // rax
unsigned int *v4; // r15
int v5; // eax
long long v7; // r15
long long v8[4]; // [rsp+0h] [rbp-20h] BYREF
v8[0] = v2;
v3 = *(_QWORD *)(a2 + 120);
if ( v3 )
{
v4 = *(unsigned int **)(*(_QWORD *)(v3 + 1152) + 40LL);
v8[0] = a2;
*((_BYTE *)v4 + 20) = 1;
v5 = my_context_spawn(v4 + 14, mysql_fetch_row_start_internal, v8);
*((_WORD *)v4 + 10) = 0;
if ( v5 > 0 )
{
*((_BYTE *)v4 + 21) = 1;
return *v4;
}
if ( v5 < 0 )
{
*(_DWORD *)(*(_QWORD *)(a2 + 120) + 144LL) = 2008;
strncpy(*(_QWORD *)(a2 + 120) + 663LL, SQLSTATE_UNKNOWN, 5LL);
v7 = 0LL;
*(_BYTE *)(*(_QWORD *)(a2 + 120) + 668LL) = 0;
strncpy(*(_QWORD *)(a2 + 120) + 151LL, client_errors[8], 511LL);
*(_BYTE *)(*(_QWORD *)(a2 + 120) + 662LL) = 0;
}
else
{
v7 = *((_QWORD *)v4 + 1);
}
*a1 = v7;
}
else
{
*a1 = mysql_fetch_row(a2);
}
return 0LL;
}
|
mysql_fetch_row_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 + 0x78]
TEST RAX,RAX
JZ 0x0012b4be
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,[0x12b545]
CALL 0x0012fd64
MOV word ptr [R15 + 0x14],0x0
TEST EAX,EAX
JLE 0x0012b4cb
MOV byte ptr [R15 + 0x15],0x1
MOV EAX,dword ptr [R15]
JMP 0x0012b53a
LAB_0012b4be:
MOV RDI,R14
CALL 0x0011db00
MOV qword ptr [RBX],RAX
JMP 0x0012b538
LAB_0012b4cb:
JS 0x0012b4d3
MOV R15,qword ptr [R15 + 0x8]
JMP 0x0012b535
LAB_0012b4d3:
MOV RAX,qword ptr [R14 + 0x78]
MOV dword ptr [RAX + 0x90],0x7d8
MOV EDI,0x297
ADD RDI,qword ptr [R14 + 0x78]
LEA RAX,[0x14dc10]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x78]
XOR R15D,R15D
MOV byte ptr [RAX + 0x29c],R15B
MOV EDI,0x97
ADD RDI,qword ptr [R14 + 0x78]
LEA RAX,[0x14dc20]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x78]
MOV byte ptr [RAX + 0x296],R15B
LAB_0012b535:
MOV qword ptr [RBX],R15
LAB_0012b538:
XOR EAX,EAX
LAB_0012b53a:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 mysql_fetch_row_start(int8 *param_1,long param_2)
{
int4 *puVar1;
int iVar2;
int8 uVar3;
if (*(long *)(param_2 + 0x78) == 0) {
uVar3 = mysql_fetch_row(param_2);
*param_1 = uVar3;
}
else {
puVar1 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x78) + 0x480) + 0x28);
*(int1 *)(puVar1 + 5) = 1;
iVar2 = my_context_spawn(puVar1 + 0xe,mysql_fetch_row_start_internal);
*(int2 *)(puVar1 + 5) = 0;
if (0 < iVar2) {
*(int1 *)((long)puVar1 + 0x15) = 1;
return *puVar1;
}
if (iVar2 < 0) {
*(int4 *)(*(long *)(param_2 + 0x78) + 0x90) = 0x7d8;
strncpy((char *)(*(long *)(param_2 + 0x78) + 0x297),SQLSTATE_UNKNOWN,5);
uVar3 = 0;
*(int1 *)(*(long *)(param_2 + 0x78) + 0x29c) = 0;
strncpy((char *)(*(long *)(param_2 + 0x78) + 0x97),PTR_s_Client_run_out_of_memory_0014dc60,
0x1ff);
*(int1 *)(*(long *)(param_2 + 0x78) + 0x296) = 0;
}
else {
uVar3 = *(int8 *)(puVar1 + 2);
}
*param_1 = uVar3;
}
return 0;
}
|
|
6,822 |
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;
}
|
O0
|
c
|
my_printv_error:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x214(%rbp)
movq %rsi, -0x220(%rbp)
movq %rdx, -0x228(%rbp)
movq %rcx, -0x230(%rbp)
jmp 0xf1195
leaq -0x210(%rbp), %rdi
movq -0x220(%rbp), %rdx
movq -0x230(%rbp), %rcx
movl $0x200, %esi # imm = 0x200
callq 0x14e670
leaq 0x1cfac5(%rip), %rax # 0x2c0c80
movq (%rax), %rax
movl -0x214(%rbp), %edi
leaq -0x210(%rbp), %rsi
movq -0x228(%rbp), %rdx
callq *%rax
jmp 0xf11d6
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xf11f1
addq $0x230, %rsp # imm = 0x230
popq %rbp
retq
callq 0x2a270
nopw %cs:(%rax,%rax)
|
my_printv_error:
push rbp
mov rbp, rsp
sub rsp, 230h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_214], edi
mov [rbp+var_220], rsi
mov [rbp+var_228], rdx
mov [rbp+var_230], rcx
jmp short $+2
loc_F1195:
lea rdi, [rbp+var_210]
mov rdx, [rbp+var_220]
mov rcx, [rbp+var_230]
mov esi, 200h
call my_vsnprintf
lea rax, error_handler_hook
mov rax, [rax]
mov edi, [rbp+var_214]
lea rsi, [rbp+var_210]
mov rdx, [rbp+var_228]
call rax
jmp short $+2
loc_F11D6:
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_F11F1
add rsp, 230h
pop rbp
retn
loc_F11F1:
call ___stack_chk_fail
|
unsigned long long my_printv_error(long long a1, long long a2, long long a3, long long a4)
{
_BYTE v5[520]; // [rsp+20h] [rbp-210h] BYREF
unsigned long long v6; // [rsp+228h] [rbp-8h]
v6 = __readfsqword(0x28u);
my_vsnprintf(v5, 512LL, a2, a4);
error_handler_hook();
return __readfsqword(0x28u);
}
|
my_printv_error:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x230
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x214],EDI
MOV qword ptr [RBP + -0x220],RSI
MOV qword ptr [RBP + -0x228],RDX
MOV qword ptr [RBP + -0x230],RCX
JMP 0x001f1195
LAB_001f1195:
LEA RDI,[RBP + -0x210]
MOV RDX,qword ptr [RBP + -0x220]
MOV RCX,qword ptr [RBP + -0x230]
MOV ESI,0x200
CALL 0x0024e670
LEA RAX,[0x3c0c80]
MOV RAX,qword ptr [RAX]
MOV EDI,dword ptr [RBP + -0x214]
LEA RSI,[RBP + -0x210]
MOV RDX,qword ptr [RBP + -0x228]
CALL RAX
JMP 0x001f11d6
LAB_001f11d6:
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001f11f1
ADD RSP,0x230
POP RBP
RET
LAB_001f11f1:
CALL 0x0012a270
|
void my_printv_error(int4 param_1,int8 param_2,int8 param_3,int8 param_4)
{
long in_FS_OFFSET;
int1 local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
my_vsnprintf(local_218,0x200,param_2,param_4);
(*(code *)error_handler_hook)(param_1,local_218,param_3);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
6,823 |
evmone::instr::core::extcodecopy(evmone::StackTop, long, evmone::ExecutionState&)
|
corpus-core[P]colibri-stateless/build_O2/_deps/evmone_external-src/lib/evmone/instructions.hpp
|
inline Result extcodecopy(StackTop stack, int64_t gas_left, ExecutionState& state) noexcept
{
const auto addr = intx::be::trunc<evmc::address>(stack.pop());
const auto& mem_index = stack.pop();
const auto& input_index = stack.pop();
const auto& size = stack.pop();
if (!check_memory(gas_left, state.memory, mem_index, size))
return {EVMC_OUT_OF_GAS, gas_left};
const auto s = static_cast<size_t>(size);
if (const auto cost = copy_cost(s); (gas_left -= cost) < 0)
return {EVMC_OUT_OF_GAS, gas_left};
if (state.rev >= EVMC_BERLIN && state.host.access_account(addr) == EVMC_ACCESS_COLD)
{
if ((gas_left -= instr::additional_cold_account_access_cost) < 0)
return {EVMC_OUT_OF_GAS, gas_left};
}
if (s > 0)
{
const auto src =
(max_buffer_size < input_index) ? max_buffer_size : static_cast<size_t>(input_index);
const auto dst = static_cast<size_t>(mem_index);
const auto num_bytes_copied = state.host.copy_code(addr, src, &state.memory[dst], s);
if (const auto num_bytes_to_clear = s - num_bytes_copied; num_bytes_to_clear > 0)
std::memset(&state.memory[dst + num_bytes_copied], 0, num_bytes_to_clear);
}
return {EVMC_SUCCESS, gas_left};
}
|
O2
|
cpp
|
evmone::instr::core::extcodecopy(evmone::StackTop, long, evmone::ExecutionState&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %r13
leaq 0x8(%rsp), %rbp
movq %rsi, (%rbp)
leaq -0x20(%rdi), %r12
leaq 0x14(%rsp), %rdi
movq %r13, %rsi
callq 0x3b4af
leaq -0x60(%r13), %r15
leaq 0x8(%r14), %rbx
movq %rbp, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x3b250
testb %al, %al
je 0x3b9f2
movq (%r15), %r15
leaq 0x1f(%r15), %rax
shrq $0x5, %rax
imulq $-0x3, %rax, %rdx
addq 0x8(%rsp), %rdx
movq %rdx, 0x8(%rsp)
pushq $0x3
popq %rbp
js 0x3b9fa
cmpl $0x8, 0x40(%r14)
jl 0x3b992
leaq 0x28(%r14), %rdi
leaq 0x14(%rsp), %rsi
callq 0x2f5c0
testl %eax, %eax
jne 0x3b992
movq 0x8(%rsp), %rax
leaq -0x9c4(%rax), %rdx
movq %rdx, 0x8(%rsp)
cmpq $0x9c4, %rax # imm = 0x9C4
jl 0x3b9fa
testq %r15, %r15
je 0x3b9ee
addq $-0x40, %r13
leaq 0x3b3ee(%rip), %rdi # 0x76d90
movq %r13, %rsi
callq 0x3ba0b
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
testb %al, %al
jne 0x3b9b7
movq (%r13), %rdx
movq (%r12), %r12
movq 0x8(%r14), %rcx
addq %r12, %rcx
addq $0x28, %r14
leaq 0x14(%rsp), %rsi
movq %r14, %rdi
movq %r15, %r8
callq 0x2f4f2
subq %rax, %r15
je 0x3b9ee
addq (%rbx), %r12
addq %rax, %r12
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x221a0
xorl %ebp, %ebp
jmp 0x3b9f5
pushq $0x3
popq %rbp
movq 0x8(%rsp), %rdx
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZN6evmone5instr4core11extcodecopyENS_8StackTopElRNS_14ExecutionStateE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rdx
mov r13, rdi
lea rbp, [rsp+58h+var_50]
mov [rbp+0], rsi
lea r12, [rdi-20h]
lea rdi, [rsp+58h+var_44]
mov rsi, r13
call _ZN4intx2be5truncIN4evmc7addressELj256EEET_RKNS_4uintIXT0_EEE; intx::be::trunc<evmc::address,256u>(intx::uint<256u> const&)
lea r15, [r13-60h]
lea rbx, [r14+8]
mov rdi, rbp
mov rsi, rbx
mov rdx, r12
mov rcx, r15
call _ZN6evmone12check_memoryERlRNS_6MemoryERKN4intx4uintILj256EEES7_; evmone::check_memory(long &,evmone::Memory &,intx::uint<256u> const&,intx::uint<256u> const&)
test al, al
jz loc_3B9F2
mov r15, [r15]
lea rax, [r15+1Fh]
shr rax, 5
imul rdx, rax, -3
add rdx, [rsp+58h+var_50]
mov [rsp+58h+var_50], rdx
push 3
pop rbp
js loc_3B9FA
cmp dword ptr [r14+40h], 8
jl short loc_3B992
lea rdi, [r14+28h]
lea rsi, [rsp+58h+var_44]
call _ZN4evmc11HostContext14access_accountERKNS_7addressE; evmc::HostContext::access_account(evmc::address const&)
test eax, eax
jnz short loc_3B992
mov rax, [rsp+58h+var_50]
lea rdx, [rax-9C4h]
mov [rsp+58h+var_50], rdx
cmp rax, 9C4h
jl short loc_3B9FA
loc_3B992:
test r15, r15
jz short loc_3B9EE
add r13, 0FFFFFFFFFFFFFFC0h
lea rdi, _ZN6evmoneL15max_buffer_sizeE; evmone::max_buffer_size
mov rsi, r13
call _ZN4intxltILj256EjvEEbRKT0_RKNS_4uintIXT_EEE; intx::operator<<256u,uint,void>(uint const&,intx::uint<256u> const&)
mov edx, 0FFFFFFFFh
test al, al
jnz short loc_3B9B7
mov rdx, [r13+0]
loc_3B9B7:
mov r12, [r12]
mov rcx, [r14+8]
add rcx, r12
add r14, 28h ; '('
lea rsi, [rsp+58h+var_44]
mov rdi, r14
mov r8, r15
call _ZNK4evmc11HostContext9copy_codeERKNS_7addressEmPhm; evmc::HostContext::copy_code(evmc::address const&,ulong,uchar *,ulong)
sub r15, rax
jz short loc_3B9EE
add r12, [rbx]
add r12, rax
mov rdi, r12
xor esi, esi
mov rdx, r15
call _memset
loc_3B9EE:
xor ebp, ebp
jmp short loc_3B9F5
loc_3B9F2:
push 3
pop rbp
loc_3B9F5:
mov rdx, [rsp+58h+var_50]
loc_3B9FA:
mov eax, ebp
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long evmone::instr::core::extcodecopy(long long a1, long long a2, long long a3)
{
long long v4; // r15
unsigned long long v5; // rax
bool v6; // sf
unsigned int v7; // ebp
long long v8; // rax
long long v9; // r12
long long v10; // rax
long long v11; // r15
long long v13; // [rsp+8h] [rbp-50h] BYREF
char v14[68]; // [rsp+14h] [rbp-44h] BYREF
v13 = a2;
intx::be::trunc<evmc::address,256u>((long long)v14);
if ( evmone::check_memory((long long)&v13, a3 + 8, a1 - 32, (_QWORD *)(a1 - 96)) )
{
v4 = *(_QWORD *)(a1 - 96);
v5 = (unsigned long long)(v4 + 31) >> 5;
v6 = (long long)(v13 - 3 * v5) < 0;
v13 -= 3 * v5;
v7 = 3;
if ( !v6 )
{
if ( *(int *)(a3 + 64) < 8
|| (unsigned int)evmc::HostContext::access_account(a3 + 40)
|| (v8 = v13, v13 -= 2500LL, v8 >= 2500) )
{
if ( v4 )
{
intx::operator<<256u,unsigned int,void>(&evmone::max_buffer_size, a1 - 64);
v9 = *(_QWORD *)(a1 - 32);
v10 = evmc::HostContext::copy_code(a3 + 40);
v11 = v4 - v10;
if ( v11 )
memset(v10 + *(_QWORD *)(a3 + 8) + v9, 0LL, v11);
}
return 0;
}
}
}
else
{
return 3;
}
return v7;
}
|
extcodecopy:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RDX
MOV R13,RDI
LEA RBP,[RSP + 0x8]
MOV qword ptr [RBP],RSI
LEA R12,[RDI + -0x20]
LEA RDI,[RSP + 0x14]
MOV RSI,R13
CALL 0x0013b4af
LEA R15,[R13 + -0x60]
LEA RBX,[R14 + 0x8]
MOV RDI,RBP
MOV RSI,RBX
MOV RDX,R12
MOV RCX,R15
CALL 0x0013b250
TEST AL,AL
JZ 0x0013b9f2
MOV R15,qword ptr [R15]
LEA RAX,[R15 + 0x1f]
SHR RAX,0x5
IMUL RDX,RAX,-0x3
ADD RDX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x8],RDX
PUSH 0x3
POP RBP
JS 0x0013b9fa
CMP dword ptr [R14 + 0x40],0x8
JL 0x0013b992
LEA RDI,[R14 + 0x28]
LEA RSI,[RSP + 0x14]
CALL 0x0012f5c0
TEST EAX,EAX
JNZ 0x0013b992
MOV RAX,qword ptr [RSP + 0x8]
LEA RDX,[RAX + -0x9c4]
MOV qword ptr [RSP + 0x8],RDX
CMP RAX,0x9c4
JL 0x0013b9fa
LAB_0013b992:
TEST R15,R15
JZ 0x0013b9ee
ADD R13,-0x40
LEA RDI,[0x176d90]
MOV RSI,R13
CALL 0x0013ba0b
MOV EDX,0xffffffff
TEST AL,AL
JNZ 0x0013b9b7
MOV RDX,qword ptr [R13]
LAB_0013b9b7:
MOV R12,qword ptr [R12]
MOV RCX,qword ptr [R14 + 0x8]
ADD RCX,R12
ADD R14,0x28
LEA RSI,[RSP + 0x14]
MOV RDI,R14
MOV R8,R15
CALL 0x0012f4f2
SUB R15,RAX
JZ 0x0013b9ee
ADD R12,qword ptr [RBX]
ADD R12,RAX
MOV RDI,R12
XOR ESI,ESI
MOV RDX,R15
CALL 0x001221a0
LAB_0013b9ee:
XOR EBP,EBP
JMP 0x0013b9f5
LAB_0013b9f2:
PUSH 0x3
POP RBP
LAB_0013b9f5:
MOV RDX,qword ptr [RSP + 0x8]
LAB_0013b9fa:
MOV EAX,EBP
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* evmone::instr::core::extcodecopy(evmone::StackTop, long, evmone::ExecutionState&) */
int1 [16] evmone::instr::core::extcodecopy(uint *param_1,long param_2,long param_3)
{
long lVar1;
long lVar2;
char cVar3;
bool bVar4;
int iVar5;
long lVar6;
uchar *puVar7;
int8 uVar8;
int1 auVar9 [16];
long local_50;
be local_44 [20];
local_50 = param_2;
intx::be::trunc<evmc::address,256u>(local_44,param_1);
cVar3 = check_memory(&local_50,(Memory *)(param_3 + 8),param_1 + -0x20,param_1 + -0x60);
if (cVar3 == '\0') {
uVar8 = 3;
}
else {
lVar2 = *(long *)(param_1 + -0x60);
local_50 = (lVar2 + 0x1fU >> 5) * -3 + local_50;
uVar8 = 3;
if ((-1 < local_50) &&
(((*(int *)(param_3 + 0x40) < 8 ||
(iVar5 = evmc::HostContext::access_account((address *)(param_3 + 0x28)), iVar5 != 0)) ||
(lVar1 = local_50 + -0x9c4, bVar4 = 0x9c3 < local_50, local_50 = lVar1, bVar4)))) {
if (lVar2 != 0) {
bVar4 = intx::operator<(&max_buffer_size,param_1 + -0x40);
puVar7 = (uchar *)0xffffffff;
if (!bVar4) {
puVar7 = *(uchar **)(param_1 + -0x40);
}
lVar1 = *(long *)(param_1 + -0x20);
lVar6 = evmc::HostContext::copy_code
((address *)(param_3 + 0x28),(ulong)local_44,puVar7,
*(long *)(param_3 + 8) + lVar1);
if (lVar2 - lVar6 != 0) {
memset((void *)(lVar1 + *(long *)(param_3 + 8) + lVar6),0,lVar2 - lVar6);
}
}
uVar8 = 0;
}
}
auVar9._8_8_ = local_50;
auVar9._0_8_ = uVar8;
return auVar9;
}
|
|
6,824 |
mi_make_key
|
eloqsql/storage/myisam/mi_key.c
|
uint _mi_make_key(register MI_INFO *info, uint keynr, uchar *key,
const uchar *record, my_off_t filepos)
{
uchar *pos;
uchar *start;
reg1 HA_KEYSEG *keyseg;
my_bool is_ft= info->s->keyinfo[keynr].flag & HA_FULLTEXT;
DBUG_ENTER("_mi_make_key");
if (info->s->keyinfo[keynr].flag & HA_SPATIAL)
{
/*
TODO: nulls processing
*/
#ifdef HAVE_SPATIAL
DBUG_RETURN(sp_make_key(info,keynr,key,record,filepos));
#else
DBUG_ASSERT(0); /* mi_open should check that this never happens*/
#endif
}
start=key;
for (keyseg=info->s->keyinfo[keynr].seg ; keyseg->type ;keyseg++)
{
enum ha_base_keytype type=(enum ha_base_keytype) keyseg->type;
size_t length=keyseg->length;
size_t char_length;
CHARSET_INFO *cs=keyseg->charset;
if (keyseg->null_bit)
{
if (record[keyseg->null_pos] & keyseg->null_bit)
{
*key++= 0; /* NULL in key */
continue;
}
*key++=1; /* Not NULL */
}
char_length= ((!is_ft && cs && cs->mbmaxlen > 1) ? length/cs->mbmaxlen :
length);
pos= (uchar*) record+keyseg->start;
if (type == HA_KEYTYPE_BIT)
{
if (keyseg->bit_length)
{
uchar bits= get_rec_bits((uchar*) record + keyseg->bit_pos,
keyseg->bit_start, keyseg->bit_length);
*key++= bits;
length--;
}
memcpy((uchar*) key, pos, length);
key+= length;
continue;
}
if (keyseg->flag & HA_SPACE_PACK)
{
if (type != HA_KEYTYPE_NUM)
{
length= my_ci_lengthsp(cs, (char*) pos, length);
}
else
{
uchar *end= pos + length;
while (pos < end && pos[0] == ' ')
pos++;
length=(size_t) (end-pos);
}
FIX_LENGTH(cs, pos, length, char_length);
store_key_length_inc(key,char_length);
memcpy(key, pos,char_length);
key+=char_length;
continue;
}
if (keyseg->flag & HA_VAR_LENGTH_PART)
{
uint pack_length= (keyseg->bit_start == 1 ? 1 : 2);
uint tmp_length= (pack_length == 1 ? (uint) *(uchar*) pos :
uint2korr(pos));
pos+= pack_length; /* Skip VARCHAR length */
set_if_smaller(length,tmp_length);
FIX_LENGTH(cs, pos, length, char_length);
store_key_length_inc(key,char_length);
memcpy(key, pos, char_length);
key+= char_length;
continue;
}
else if (keyseg->flag & HA_BLOB_PART)
{
uint tmp_length=_mi_calc_blob_length(keyseg->bit_start,pos);
memcpy(&pos,pos+keyseg->bit_start,sizeof(char*));
set_if_smaller(length,tmp_length);
FIX_LENGTH(cs, pos, length, char_length);
store_key_length_inc(key,char_length);
if (char_length)
{
memcpy(key, pos, char_length);
key+= char_length;
}
continue;
}
else if (keyseg->flag & HA_SWAP_KEY)
{ /* Numerical column */
if (type == HA_KEYTYPE_FLOAT)
{
float nr;
float4get(nr,pos);
if (isnan(nr))
{
/* Replace NAN with zero */
bzero(key,length);
key+=length;
continue;
}
}
else if (type == HA_KEYTYPE_DOUBLE)
{
double nr;
float8get(nr,pos);
if (isnan(nr))
{
bzero(key,length);
key+=length;
continue;
}
}
pos+=length;
while (length--)
{
*key++ = *--pos;
}
continue;
}
FIX_LENGTH(cs, pos, length, char_length);
memcpy((uchar*) key, pos, char_length);
if (length > char_length)
my_ci_fill(cs, (char*) key+char_length, length-char_length, ' ');
key+= length;
}
_mi_dpointer(info,key,filepos);
DBUG_PRINT("exit",("keynr: %d",keynr));
DBUG_DUMP("key",(uchar*) start,(uint) (key-start)+keyseg->length);
DBUG_EXECUTE("key",
_mi_print_key(DBUG_FILE,info->s->keyinfo[keynr].seg,start,
(uint) (key-start)););
DBUG_RETURN((uint) (key-start)); /* Return keylength */
}
|
O3
|
c
|
mi_make_key:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r9
movq (%rdi), %rax
movq 0x218(%rax), %rax
movl %esi, %ecx
imulq $0x70, %rcx, %rcx
movzwl 0xa(%rax,%rcx), %r10d
movl %r10d, -0x44(%rbp)
btl $0xa, %r10d
jb 0x7b37c
movq %rdi, -0x60(%rbp)
movq %r8, -0x68(%rbp)
addq %rcx, %rax
movq 0x28(%rax), %r15
movb 0x18(%r15), %cl
movq %rdx, -0x50(%rbp)
movq %rdx, %rdi
testb %cl, %cl
je 0x7b392
leaq -0x1(%r9), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movq %r9, -0x30(%rbp)
movzwl 0x14(%r15), %ebx
movq (%r15), %r13
movb 0x19(%r15), %dl
testb %dl, %dl
je 0x7afe1
movl 0xc(%r15), %esi
leaq 0x1(%rax), %rdi
testb %dl, (%r9,%rsi)
je 0x7afe6
movb $0x0, (%rax)
jmp 0x7b2e1
movq %rax, %rdi
jmp 0x7afe9
movb $0x1, (%rax)
cmpb $0x0, -0x44(%rbp)
setns %al
testq %r13, %r13
setne %dl
andb %al, %dl
movq %rbx, %r12
cmpb $0x1, %dl
jne 0x7b018
movl 0x9c(%r13), %esi
movq %rbx, %r12
cmpl $0x2, %esi
jb 0x7b018
movl %ebx, %eax
xorl %edx, %edx
divl %esi
movl %eax, %r12d
movl 0x8(%r15), %eax
leaq (%r9,%rax), %r14
cmpb $0x13, %cl
jne 0x7b08a
movzbl 0x1b(%r15), %eax
testl %eax, %eax
je 0x7b06e
movq %rdi, %r8
movzwl 0x10(%r15), %esi
movzbl 0x1a(%r15), %ecx
movzbl (%r9,%rsi), %edx
leal (%rcx,%rax), %edi
cmpl $0x9, %edi
jb 0x7b053
movzbl 0x1(%r9,%rsi), %esi
shll $0x8, %esi
orl %esi, %edx
movq %r8, %rdi
shrl %cl, %edx
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movl %eax, %ecx
shll %cl, %esi
notl %esi
andl %edx, %esi
movb %sil, (%r8)
incq %rdi
decq %rbx
movq %rbx, %r12
movq %rdi, %rbx
movq %r14, %rsi
movq %r12, %rdx
callq 0x29080
movq %rbx, %rdi
addq %r12, %rdi
jmp 0x7b2dd
movzwl 0x12(%r15), %edx
testb $0x1, %dl
jne 0x7b130
testb $0x8, %dl
jne 0x7b157
testb $0x20, %dl
jne 0x7b1e8
testb $0x40, %dl
jne 0x7b2f9
cmpl %ebx, %r12d
jae 0x7b0e0
leaq (%r14,%rbx), %rdx
movq 0xb8(%r13), %rax
movq %rbx, -0x40(%rbp)
movq %rdi, %rbx
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq *0x10(%rax)
movq %rbx, %rdi
movq -0x40(%rbp), %rbx
movq %rax, %r12
cmpq %rbx, %r12
movq %rbx, %rax
cmovbq %r12, %rbx
movq %rdi, -0x38(%rbp)
movq %r14, %rsi
movq %rax, %r14
movq %rbx, %rdx
callq 0x29080
cmpq %r14, %r12
movq -0x38(%rbp), %r12
jae 0x7b121
leaq (%r12,%rbx), %rsi
movq %r14, %rdx
subq %rbx, %rdx
movq 0xb8(%r13), %rax
movq %r13, %rdi
movl $0x20, %ecx
callq *0x78(%rax)
addq %r14, %r12
movq -0x30(%rbp), %r9
movq %r12, %rdi
jmp 0x7b2e1
cmpb $0x7, %cl
movq %rdi, -0x38(%rbp)
jne 0x7b170
movq %rbx, %rax
addq %r14, %rbx
testq %rax, %rax
je 0x7b152
cmpb $0x20, (%r14)
jne 0x7b152
incq %r14
cmpq %rbx, %r14
jb 0x7b144
subq %r14, %rbx
jmp 0x7b186
cmpb $0x1, 0x1a(%r15)
jne 0x7b25c
movzbl (%r14), %eax
movl $0x1, %ecx
jmp 0x7b265
movq 0xb8(%r13), %rax
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
movq %rax, %rbx
cmpq %r12, %rbx
jbe 0x7b1a5
leaq (%r14,%rbx), %rdx
movq 0xb8(%r13), %rax
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq *0x10(%rax)
movq %rax, %r12
movq -0x38(%rbp), %rcx
cmpq %rbx, %r12
cmovbq %r12, %rbx
cmpq $0xff, %rbx
jae 0x7b1c1
leaq 0x1(%rcx), %r12
movl %ebx, %eax
jmp 0x7b1cd
movb %bl, 0x2(%rcx)
movb %bh, 0x1(%rcx)
leaq 0x3(%rcx), %r12
movb $-0x1, %al
movb %al, (%rcx)
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x29080
addq %rbx, %r12
movq %r12, %rdi
jmp 0x7b2dd
movq %rdi, -0x38(%rbp)
movzbl 0x1a(%r15), %edi
movq %r14, %rsi
callq 0x78c5d
movzbl 0x1a(%r15), %ecx
movq (%r14,%rcx), %rsi
movl %eax, %eax
cmpq %rbx, %rax
cmovbq %rax, %rbx
cmpq %r12, %rbx
jbe 0x7b22d
leaq (%rsi,%rbx), %rdx
movq 0xb8(%r13), %rax
movq %r13, %rdi
movq %rsi, %r14
movq %r12, %rcx
callq *0x10(%rax)
movq %r14, %rsi
movq %rax, %r12
movq -0x30(%rbp), %r9
movq -0x38(%rbp), %rdi
cmpq %rbx, %r12
cmovbq %r12, %rbx
cmpq $0xff, %rbx
jae 0x7b32e
movb %bl, (%rdi)
incq %rdi
testq %rbx, %rbx
jne 0x7b33b
jmp 0x7b2e1
movzwl (%r14), %eax
movl $0x2, %ecx
addq %rcx, %r14
cmpq %rbx, %rax
cmovbq %rax, %rbx
cmpq %r12, %rbx
jbe 0x7b29c
leaq (%r14,%rbx), %rdx
movq 0xb8(%r13), %rax
movq %rbx, -0x40(%rbp)
movq %rdi, %rbx
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq *0x10(%rax)
movq %rbx, %rdi
movq -0x40(%rbp), %rbx
movq %rax, %r12
cmpq %rbx, %r12
cmovbq %r12, %rbx
cmpq $0xff, %rbx
jae 0x7b2b8
movq %rbx, %r12
leaq 0x1(%rdi), %rbx
movl %r12d, %eax
jmp 0x7b2c7
movb %bl, 0x2(%rdi)
movb %bh, 0x1(%rdi)
movq %rbx, %r12
leaq 0x3(%rdi), %rbx
movb $-0x1, %al
movb %al, (%rdi)
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x29080
addq %r12, %rbx
movq %rbx, %rdi
movq -0x30(%rbp), %r9
movb 0x38(%r15), %cl
addq $0x20, %r15
movq %rdi, %rax
testb %cl, %cl
jne 0x7afbb
jmp 0x7b392
cmpb $0x6, %cl
je 0x7b352
movzbl %cl, %ecx
cmpl $0x5, %ecx
jne 0x7b310
movss (%r14), %xmm0
ucomiss %xmm0, %xmm0
jp 0x7b35d
testl %ebx, %ebx
je 0x7b2e1
addq -0x58(%rbp), %rax
movq %rdi, %rcx
leaq 0x1(%rcx), %rdi
movb (%rax,%rbx), %dl
movb %dl, (%rcx)
movq %rdi, %rcx
decq %rbx
jne 0x7b31b
jmp 0x7b2e1
movb $-0x1, (%rdi)
movb %bl, 0x2(%rdi)
movb %bh, 0x1(%rdi)
addq $0x3, %rdi
movq %rdi, %r14
movq %rbx, %rdx
callq 0x29080
movq %r14, %rdi
movq -0x30(%rbp), %r9
addq %rbx, %rdi
jmp 0x7b2e1
movsd (%r14), %xmm0
ucomisd %xmm0, %xmm0
jnp 0x7b310
movq %rbx, %r14
movq %rdi, %rbx
xorl %esi, %esi
movq %r14, %rdx
callq 0x292b0
movq %rbx, %rdi
movq -0x30(%rbp), %r9
addq %r14, %rdi
jmp 0x7b2e1
movq %r9, %rcx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8eab4
movq %rdi, %rbx
movq -0x60(%rbp), %rdi
movq %rbx, %rsi
movq -0x68(%rbp), %rdx
callq 0x853c3
subl -0x50(%rbp), %ebx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_mi_make_key:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r9, rcx
mov rax, [rdi]
mov rax, [rax+218h]
mov ecx, esi
imul rcx, 70h ; 'p'
movzx r10d, word ptr [rax+rcx+0Ah]
mov [rbp+var_44], r10d
bt r10d, 0Ah
jb loc_7B37C
mov [rbp+var_60], rdi
mov [rbp+var_68], r8
add rax, rcx
mov r15, [rax+28h]
mov cl, [r15+18h]
mov [rbp+var_50], rdx
mov rdi, rdx
test cl, cl
jz loc_7B392
lea rax, [r9-1]
mov [rbp+var_58], rax
mov rax, [rbp+var_50]
mov [rbp+var_30], r9
loc_7AFBB:
movzx ebx, word ptr [r15+14h]
mov r13, [r15]
mov dl, [r15+19h]
test dl, dl
jz short loc_7AFE1
mov esi, [r15+0Ch]
lea rdi, [rax+1]
test [r9+rsi], dl
jz short loc_7AFE6
mov byte ptr [rax], 0
jmp loc_7B2E1
loc_7AFE1:
mov rdi, rax
jmp short loc_7AFE9
loc_7AFE6:
mov byte ptr [rax], 1
loc_7AFE9:
cmp byte ptr [rbp+var_44], 0
setns al
test r13, r13
setnz dl
and dl, al
mov r12, rbx
cmp dl, 1
jnz short loc_7B018
mov esi, [r13+9Ch]
mov r12, rbx
cmp esi, 2
jb short loc_7B018
mov eax, ebx
xor edx, edx
div esi
mov r12d, eax
loc_7B018:
mov eax, [r15+8]
lea r14, [r9+rax]
cmp cl, 13h
jnz short loc_7B08A
movzx eax, byte ptr [r15+1Bh]
test eax, eax
jz short loc_7B06E
mov r8, rdi
movzx esi, word ptr [r15+10h]
movzx ecx, byte ptr [r15+1Ah]
movzx edx, byte ptr [r9+rsi]
lea edi, [rcx+rax]
cmp edi, 9
jb short loc_7B053
movzx esi, byte ptr [r9+rsi+1]
shl esi, 8
or edx, esi
loc_7B053:
mov rdi, r8
shr edx, cl
mov esi, 0FFFFFFFFh
mov ecx, eax
shl esi, cl
not esi
and esi, edx
mov [r8], sil
inc rdi
dec rbx
loc_7B06E:
mov r12, rbx
mov rbx, rdi
mov rsi, r14
mov rdx, r12
call _memcpy
mov rdi, rbx
add rdi, r12
jmp loc_7B2DD
loc_7B08A:
movzx edx, word ptr [r15+12h]
test dl, 1
jnz loc_7B130
test dl, 8
jnz loc_7B157
test dl, 20h
jnz loc_7B1E8
test dl, 40h
jnz loc_7B2F9
cmp r12d, ebx
jnb short loc_7B0E0
lea rdx, [r14+rbx]
mov rax, [r13+0B8h]
mov [rbp+var_40], rbx
mov rbx, rdi
mov rdi, r13
mov rsi, r14
mov rcx, r12
call qword ptr [rax+10h]
mov rdi, rbx
mov rbx, [rbp+var_40]
mov r12, rax
loc_7B0E0:
cmp r12, rbx
mov rax, rbx
cmovb rbx, r12
mov [rbp+var_38], rdi
mov rsi, r14
mov r14, rax
mov rdx, rbx
call _memcpy
cmp r12, r14
mov r12, [rbp+var_38]
jnb short loc_7B121
lea rsi, [r12+rbx]
mov rdx, r14
sub rdx, rbx
mov rax, [r13+0B8h]
mov rdi, r13
mov ecx, 20h ; ' '
call qword ptr [rax+78h]
loc_7B121:
add r12, r14
mov r9, [rbp+var_30]
mov rdi, r12
jmp loc_7B2E1
loc_7B130:
cmp cl, 7
mov [rbp+var_38], rdi
jnz short loc_7B170
mov rax, rbx
add rbx, r14
test rax, rax
jz short loc_7B152
loc_7B144:
cmp byte ptr [r14], 20h ; ' '
jnz short loc_7B152
inc r14
cmp r14, rbx
jb short loc_7B144
loc_7B152:
sub rbx, r14
jmp short loc_7B186
loc_7B157:
cmp byte ptr [r15+1Ah], 1
jnz loc_7B25C
movzx eax, byte ptr [r14]
mov ecx, 1
jmp loc_7B265
loc_7B170:
mov rax, [r13+0B8h]
mov rdi, r13
mov rsi, r14
mov rdx, rbx
call qword ptr [rax+18h]
mov rbx, rax
loc_7B186:
cmp rbx, r12
jbe short loc_7B1A5
lea rdx, [r14+rbx]
mov rax, [r13+0B8h]
mov rdi, r13
mov rsi, r14
mov rcx, r12
call qword ptr [rax+10h]
mov r12, rax
loc_7B1A5:
mov rcx, [rbp+var_38]
cmp r12, rbx
cmovb rbx, r12
cmp rbx, 0FFh
jnb short loc_7B1C1
lea r12, [rcx+1]
mov eax, ebx
jmp short loc_7B1CD
loc_7B1C1:
mov [rcx+2], bl
mov [rcx+1], bh
lea r12, [rcx+3]
mov al, 0FFh
loc_7B1CD:
mov [rcx], al
mov rdi, r12
mov rsi, r14
mov rdx, rbx
call _memcpy
add r12, rbx
mov rdi, r12
jmp loc_7B2DD
loc_7B1E8:
mov [rbp+var_38], rdi
movzx edi, byte ptr [r15+1Ah]
mov rsi, r14
call _mi_calc_blob_length
movzx ecx, byte ptr [r15+1Ah]
mov rsi, [r14+rcx]
mov eax, eax
cmp rax, rbx
cmovb rbx, rax
cmp rbx, r12
jbe short loc_7B22D
lea rdx, [rsi+rbx]
mov rax, [r13+0B8h]
mov rdi, r13
mov r14, rsi
mov rcx, r12
call qword ptr [rax+10h]
mov rsi, r14
mov r12, rax
loc_7B22D:
mov r9, [rbp+var_30]
mov rdi, [rbp+var_38]
cmp r12, rbx
cmovb rbx, r12
cmp rbx, 0FFh
jnb loc_7B32E
mov [rdi], bl
inc rdi
test rbx, rbx
jnz loc_7B33B
jmp loc_7B2E1
loc_7B25C:
movzx eax, word ptr [r14]
mov ecx, 2
loc_7B265:
add r14, rcx
cmp rax, rbx
cmovb rbx, rax
cmp rbx, r12
jbe short loc_7B29C
lea rdx, [r14+rbx]
mov rax, [r13+0B8h]
mov [rbp+var_40], rbx
mov rbx, rdi
mov rdi, r13
mov rsi, r14
mov rcx, r12
call qword ptr [rax+10h]
mov rdi, rbx
mov rbx, [rbp+var_40]
mov r12, rax
loc_7B29C:
cmp r12, rbx
cmovb rbx, r12
cmp rbx, 0FFh
jnb short loc_7B2B8
mov r12, rbx
lea rbx, [rdi+1]
mov eax, r12d
jmp short loc_7B2C7
loc_7B2B8:
mov [rdi+2], bl
mov [rdi+1], bh
mov r12, rbx
lea rbx, [rdi+3]
mov al, 0FFh
loc_7B2C7:
mov [rdi], al
mov rdi, rbx
mov rsi, r14
mov rdx, r12
call _memcpy
add rbx, r12
mov rdi, rbx
loc_7B2DD:
mov r9, [rbp+var_30]
loc_7B2E1:
mov cl, [r15+38h]
add r15, 20h ; ' '
mov rax, rdi
test cl, cl
jnz loc_7AFBB
jmp loc_7B392
loc_7B2F9:
cmp cl, 6
jz short loc_7B352
movzx ecx, cl
cmp ecx, 5
jnz short loc_7B310
movss xmm0, dword ptr [r14]
ucomiss xmm0, xmm0
jp short loc_7B35D
loc_7B310:
test ebx, ebx
jz short loc_7B2E1
add rax, [rbp+var_58]
mov rcx, rdi
loc_7B31B:
lea rdi, [rcx+1]
mov dl, [rax+rbx]
mov [rcx], dl
mov rcx, rdi
dec rbx
jnz short loc_7B31B
jmp short loc_7B2E1
loc_7B32E:
mov byte ptr [rdi], 0FFh
mov [rdi+2], bl
mov [rdi+1], bh
add rdi, 3
loc_7B33B:
mov r14, rdi
mov rdx, rbx
call _memcpy
mov rdi, r14
mov r9, [rbp+var_30]
add rdi, rbx
jmp short loc_7B2E1
loc_7B352:
movsd xmm0, qword ptr [r14]
ucomisd xmm0, xmm0
jnp short loc_7B310
loc_7B35D:
mov r14, rbx
mov rbx, rdi
xor esi, esi
mov rdx, r14
call _memset
mov rdi, rbx
mov r9, [rbp+var_30]
add rdi, r14
jmp loc_7B2E1
loc_7B37C:
mov rcx, r9
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp sp_make_key
loc_7B392:
mov rbx, rdi
mov rdi, [rbp+var_60]
mov rsi, rbx
mov rdx, [rbp+var_68]
call _mi_dpointer
sub ebx, dword ptr [rbp+var_50]
mov eax, ebx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long mi_make_key(long long a1, long long a2, char *a3, long long a4, long long a5)
{
long long v6; // rax
long long v7; // rcx
long long *v8; // r15
char *v9; // rdi
char *v10; // rax
unsigned long long v11; // rbx
long long v12; // r13
unsigned __int8 v13; // dl
unsigned long long v14; // r12
unsigned int v15; // esi
long long v16; // rax
_BYTE *v17; // r14
int v18; // eax
long long v19; // rsi
int v20; // ecx
unsigned int v21; // edx
__int16 v22; // dx
unsigned long long v23; // rax
_BYTE *v24; // rsi
unsigned long long v25; // r14
unsigned long long v26; // rax
_BYTE *v27; // rbx
unsigned long long v28; // rbx
unsigned long long v29; // rax
long long v30; // rcx
_BYTE *v31; // r12
char v32; // al
unsigned int v33; // eax
long long v34; // rsi
_BYTE *v35; // r14
unsigned long long v36; // r12
_BYTE *v37; // rbx
char v38; // al
long long v39; // rax
long long v43; // [rsp+18h] [rbp-58h]
int v44; // [rsp+20h] [rbp-50h]
__int16 v45; // [rsp+2Ch] [rbp-44h]
long long v46; // [rsp+40h] [rbp-30h]
v6 = *(_QWORD *)(*(_QWORD *)a1 + 536LL);
v7 = 112LL * (unsigned int)a2;
v45 = *(_WORD *)(v6 + v7 + 10);
if ( (v45 & 0x400) != 0 )
return sp_make_key(a1, a2, a3, a4);
v8 = *(long long **)(v7 + v6 + 40);
LOBYTE(v7) = *((_BYTE *)v8 + 24);
v44 = (int)a3;
v9 = a3;
if ( (_BYTE)v7 )
{
v43 = a4 - 1;
v10 = a3;
v46 = a4;
do
{
v11 = *((unsigned __int16 *)v8 + 10);
v12 = *v8;
v13 = *((_BYTE *)v8 + 25);
if ( v13 )
{
v9 = v10 + 1;
if ( (v13 & *(_BYTE *)(a4 + *((unsigned int *)v8 + 3))) != 0 )
{
*v10 = 0;
goto LABEL_66;
}
*v10 = 1;
}
else
{
v9 = v10;
}
v14 = v11;
if ( (v45 & 0x80u) == 0 && v12 != 0 )
{
v15 = *(_DWORD *)(v12 + 156);
v14 = v11;
if ( v15 >= 2 )
v14 = (unsigned int)v11 / v15;
}
v16 = *((unsigned int *)v8 + 2);
v17 = (_BYTE *)(a4 + v16);
if ( (_BYTE)v7 == 19 )
{
v18 = *((unsigned __int8 *)v8 + 27);
if ( *((_BYTE *)v8 + 27) )
{
v19 = *((unsigned __int16 *)v8 + 8);
v20 = *((unsigned __int8 *)v8 + 26);
v21 = *(unsigned __int8 *)(a4 + v19);
if ( (unsigned int)(v20 + v18) >= 9 )
v21 = *(unsigned __int16 *)(a4 + v19);
*v9++ = (v21 >> v20) & ~(-1 << v18);
--v11;
}
memcpy(v9, v17, v11);
v9 += v11;
LABEL_65:
a4 = v46;
goto LABEL_66;
}
v22 = *((_WORD *)v8 + 9);
if ( (v22 & 1) != 0 )
{
if ( (_BYTE)v7 == 7 )
{
v26 = v11;
v27 = &v17[v11];
if ( v26 )
{
do
{
if ( *v17 != 32 )
break;
++v17;
}
while ( v17 < v27 );
}
v28 = v27 - v17;
}
else
{
v28 = (*(long long ( **)(long long, _BYTE *, unsigned long long))(*(_QWORD *)(v12 + 184) + 24LL))(
v12,
v17,
v11);
}
if ( v28 > v14 )
v14 = (*(long long ( **)(long long, _BYTE *, _BYTE *, unsigned long long))(*(_QWORD *)(v12 + 184) + 16LL))(
v12,
v17,
&v17[v28],
v14);
if ( v14 < v28 )
v28 = v14;
if ( v28 >= 0xFF )
{
v9[2] = v28;
v9[1] = BYTE1(v28);
v31 = v9 + 3;
v32 = -1;
}
else
{
v31 = v9 + 1;
v32 = v28;
}
*v9 = v32;
memcpy(v31, v17, v28);
v9 = &v31[v28];
goto LABEL_65;
}
if ( (v22 & 8) != 0 )
{
if ( *((_BYTE *)v8 + 26) == 1 )
{
v29 = (unsigned __int8)*v17;
v30 = 1LL;
}
else
{
v29 = *(unsigned __int16 *)v17;
v30 = 2LL;
}
v35 = &v17[v30];
if ( v29 < v11 )
v11 = v29;
if ( v11 > v14 )
v14 = (*(long long ( **)(long long, _BYTE *, _BYTE *, unsigned long long))(*(_QWORD *)(v12 + 184) + 16LL))(
v12,
v35,
&v35[v11],
v14);
if ( v14 < v11 )
v11 = v14;
if ( v11 >= 0xFF )
{
v9[2] = v11;
v9[1] = BYTE1(v11);
v36 = v11;
v37 = v9 + 3;
v38 = -1;
}
else
{
v36 = v11;
v37 = v9 + 1;
v38 = v36;
}
*v9 = v38;
memcpy(v37, v35, v36);
v9 = &v37[v36];
goto LABEL_65;
}
if ( (v22 & 0x20) == 0 )
{
if ( (v22 & 0x40) != 0 )
{
if ( (_BYTE)v7 != 6 )
v7 = (unsigned __int8)v7;
if ( (_DWORD)v11 )
{
v39 = v43 + v16;
v7 = (long long)v9;
do
{
v9 = (char *)(v7 + 1);
*(_BYTE *)v7++ = *(_BYTE *)(v39 + v11--);
}
while ( v11 );
}
}
else
{
if ( (unsigned int)v14 < (unsigned int)v11 )
v14 = (*(long long ( **)(long long, _BYTE *, _BYTE *, unsigned long long))(*(_QWORD *)(v12 + 184) + 16LL))(
v12,
v17,
&v17[v11],
v14);
v23 = v11;
if ( v14 < v11 )
v11 = v14;
v24 = v17;
v25 = v23;
memcpy(v9, v24, v11);
if ( v14 < v25 )
(*(void ( **)(long long, char *, unsigned long long, long long))(*(_QWORD *)(v12 + 184) + 120LL))(
v12,
&v9[v11],
v25 - v11,
32LL);
a4 = v46;
v9 += v25;
}
goto LABEL_66;
}
v33 = mi_calc_blob_length(*((unsigned __int8 *)v8 + 26), (unsigned __int8 *)(a4 + v16));
v7 = *((unsigned __int8 *)v8 + 26);
v34 = *(_QWORD *)&v17[v7];
if ( v33 < v11 )
v11 = v33;
if ( v11 > v14 )
v14 = (*(long long ( **)(long long, long long, unsigned long long, unsigned long long))(*(_QWORD *)(v12 + 184)
+ 16LL))(
v12,
v34,
v34 + v11,
v14);
a4 = v46;
if ( v14 < v11 )
v11 = v14;
if ( v11 >= 0xFF )
{
*v9 = -1;
v9[2] = v11;
v9[1] = BYTE1(v11);
v9 += 3;
}
else
{
*v9++ = v11;
if ( !v11 )
goto LABEL_66;
}
memcpy(v9, v34, v11);
a4 = v46;
v9 += v11;
LABEL_66:
LOBYTE(v7) = *((_BYTE *)v8 + 56);
v8 += 4;
v10 = v9;
}
while ( (_BYTE)v7 );
}
mi_dpointer(a1, v9, a5, v7, a5);
return (unsigned int)((_DWORD)v9 - v44);
}
|
_mi_make_key:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R9,RCX
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x218]
MOV ECX,ESI
IMUL RCX,RCX,0x70
MOVZX R10D,word ptr [RAX + RCX*0x1 + 0xa]
MOV dword ptr [RBP + -0x44],R10D
BT R10D,0xa
JC 0x0017b37c
MOV qword ptr [RBP + -0x60],RDI
MOV qword ptr [RBP + -0x68],R8
ADD RAX,RCX
MOV R15,qword ptr [RAX + 0x28]
MOV CL,byte ptr [R15 + 0x18]
MOV qword ptr [RBP + -0x50],RDX
MOV RDI,RDX
TEST CL,CL
JZ 0x0017b392
LEA RAX,[R9 + -0x1]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x30],R9
LAB_0017afbb:
MOVZX EBX,word ptr [R15 + 0x14]
MOV R13,qword ptr [R15]
MOV DL,byte ptr [R15 + 0x19]
TEST DL,DL
JZ 0x0017afe1
MOV ESI,dword ptr [R15 + 0xc]
LEA RDI,[RAX + 0x1]
TEST byte ptr [R9 + RSI*0x1],DL
JZ 0x0017afe6
MOV byte ptr [RAX],0x0
JMP 0x0017b2e1
LAB_0017afe1:
MOV RDI,RAX
JMP 0x0017afe9
LAB_0017afe6:
MOV byte ptr [RAX],0x1
LAB_0017afe9:
CMP byte ptr [RBP + -0x44],0x0
SETNS AL
TEST R13,R13
SETNZ DL
AND DL,AL
MOV R12,RBX
CMP DL,0x1
JNZ 0x0017b018
MOV ESI,dword ptr [R13 + 0x9c]
MOV R12,RBX
CMP ESI,0x2
JC 0x0017b018
MOV EAX,EBX
XOR EDX,EDX
DIV ESI
MOV R12D,EAX
LAB_0017b018:
MOV EAX,dword ptr [R15 + 0x8]
LEA R14,[R9 + RAX*0x1]
CMP CL,0x13
JNZ 0x0017b08a
MOVZX EAX,byte ptr [R15 + 0x1b]
TEST EAX,EAX
JZ 0x0017b06e
MOV R8,RDI
MOVZX ESI,word ptr [R15 + 0x10]
MOVZX ECX,byte ptr [R15 + 0x1a]
MOVZX EDX,byte ptr [R9 + RSI*0x1]
LEA EDI,[RCX + RAX*0x1]
CMP EDI,0x9
JC 0x0017b053
MOVZX ESI,byte ptr [R9 + RSI*0x1 + 0x1]
SHL ESI,0x8
OR EDX,ESI
LAB_0017b053:
MOV RDI,R8
SHR EDX,CL
MOV ESI,0xffffffff
MOV ECX,EAX
SHL ESI,CL
NOT ESI
AND ESI,EDX
MOV byte ptr [R8],SIL
INC RDI
DEC RBX
LAB_0017b06e:
MOV R12,RBX
MOV RBX,RDI
MOV RSI,R14
MOV RDX,R12
CALL 0x00129080
MOV RDI,RBX
ADD RDI,R12
JMP 0x0017b2dd
LAB_0017b08a:
MOVZX EDX,word ptr [R15 + 0x12]
TEST DL,0x1
JNZ 0x0017b130
TEST DL,0x8
JNZ 0x0017b157
TEST DL,0x20
JNZ 0x0017b1e8
TEST DL,0x40
JNZ 0x0017b2f9
CMP R12D,EBX
JNC 0x0017b0e0
LEA RDX,[R14 + RBX*0x1]
MOV RAX,qword ptr [R13 + 0xb8]
MOV qword ptr [RBP + -0x40],RBX
MOV RBX,RDI
MOV RDI,R13
MOV RSI,R14
MOV RCX,R12
CALL qword ptr [RAX + 0x10]
MOV RDI,RBX
MOV RBX,qword ptr [RBP + -0x40]
MOV R12,RAX
LAB_0017b0e0:
CMP R12,RBX
MOV RAX,RBX
CMOVC RBX,R12
MOV qword ptr [RBP + -0x38],RDI
MOV RSI,R14
MOV R14,RAX
MOV RDX,RBX
CALL 0x00129080
CMP R12,R14
MOV R12,qword ptr [RBP + -0x38]
JNC 0x0017b121
LEA RSI,[R12 + RBX*0x1]
MOV RDX,R14
SUB RDX,RBX
MOV RAX,qword ptr [R13 + 0xb8]
MOV RDI,R13
MOV ECX,0x20
CALL qword ptr [RAX + 0x78]
LAB_0017b121:
ADD R12,R14
MOV R9,qword ptr [RBP + -0x30]
MOV RDI,R12
JMP 0x0017b2e1
LAB_0017b130:
CMP CL,0x7
MOV qword ptr [RBP + -0x38],RDI
JNZ 0x0017b170
MOV RAX,RBX
ADD RBX,R14
TEST RAX,RAX
JZ 0x0017b152
LAB_0017b144:
CMP byte ptr [R14],0x20
JNZ 0x0017b152
INC R14
CMP R14,RBX
JC 0x0017b144
LAB_0017b152:
SUB RBX,R14
JMP 0x0017b186
LAB_0017b157:
CMP byte ptr [R15 + 0x1a],0x1
JNZ 0x0017b25c
MOVZX EAX,byte ptr [R14]
MOV ECX,0x1
JMP 0x0017b265
LAB_0017b170:
MOV RAX,qword ptr [R13 + 0xb8]
MOV RDI,R13
MOV RSI,R14
MOV RDX,RBX
CALL qword ptr [RAX + 0x18]
MOV RBX,RAX
LAB_0017b186:
CMP RBX,R12
JBE 0x0017b1a5
LEA RDX,[R14 + RBX*0x1]
MOV RAX,qword ptr [R13 + 0xb8]
MOV RDI,R13
MOV RSI,R14
MOV RCX,R12
CALL qword ptr [RAX + 0x10]
MOV R12,RAX
LAB_0017b1a5:
MOV RCX,qword ptr [RBP + -0x38]
CMP R12,RBX
CMOVC RBX,R12
CMP RBX,0xff
JNC 0x0017b1c1
LEA R12,[RCX + 0x1]
MOV EAX,EBX
JMP 0x0017b1cd
LAB_0017b1c1:
MOV byte ptr [RCX + 0x2],BL
MOV byte ptr [RCX + 0x1],BH
LEA R12,[RCX + 0x3]
MOV AL,0xff
LAB_0017b1cd:
MOV byte ptr [RCX],AL
MOV RDI,R12
MOV RSI,R14
MOV RDX,RBX
CALL 0x00129080
ADD R12,RBX
MOV RDI,R12
JMP 0x0017b2dd
LAB_0017b1e8:
MOV qword ptr [RBP + -0x38],RDI
MOVZX EDI,byte ptr [R15 + 0x1a]
MOV RSI,R14
CALL 0x00178c5d
MOVZX ECX,byte ptr [R15 + 0x1a]
MOV RSI,qword ptr [R14 + RCX*0x1]
MOV EAX,EAX
CMP RAX,RBX
CMOVC RBX,RAX
CMP RBX,R12
JBE 0x0017b22d
LEA RDX,[RSI + RBX*0x1]
MOV RAX,qword ptr [R13 + 0xb8]
MOV RDI,R13
MOV R14,RSI
MOV RCX,R12
CALL qword ptr [RAX + 0x10]
MOV RSI,R14
MOV R12,RAX
LAB_0017b22d:
MOV R9,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RBP + -0x38]
CMP R12,RBX
CMOVC RBX,R12
CMP RBX,0xff
JNC 0x0017b32e
MOV byte ptr [RDI],BL
INC RDI
TEST RBX,RBX
JNZ 0x0017b33b
JMP 0x0017b2e1
LAB_0017b25c:
MOVZX EAX,word ptr [R14]
MOV ECX,0x2
LAB_0017b265:
ADD R14,RCX
CMP RAX,RBX
CMOVC RBX,RAX
CMP RBX,R12
JBE 0x0017b29c
LEA RDX,[R14 + RBX*0x1]
MOV RAX,qword ptr [R13 + 0xb8]
MOV qword ptr [RBP + -0x40],RBX
MOV RBX,RDI
MOV RDI,R13
MOV RSI,R14
MOV RCX,R12
CALL qword ptr [RAX + 0x10]
MOV RDI,RBX
MOV RBX,qword ptr [RBP + -0x40]
MOV R12,RAX
LAB_0017b29c:
CMP R12,RBX
CMOVC RBX,R12
CMP RBX,0xff
JNC 0x0017b2b8
MOV R12,RBX
LEA RBX,[RDI + 0x1]
MOV EAX,R12D
JMP 0x0017b2c7
LAB_0017b2b8:
MOV byte ptr [RDI + 0x2],BL
MOV byte ptr [RDI + 0x1],BH
MOV R12,RBX
LEA RBX,[RDI + 0x3]
MOV AL,0xff
LAB_0017b2c7:
MOV byte ptr [RDI],AL
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R12
CALL 0x00129080
ADD RBX,R12
MOV RDI,RBX
LAB_0017b2dd:
MOV R9,qword ptr [RBP + -0x30]
LAB_0017b2e1:
MOV CL,byte ptr [R15 + 0x38]
ADD R15,0x20
MOV RAX,RDI
TEST CL,CL
JNZ 0x0017afbb
JMP 0x0017b392
LAB_0017b2f9:
CMP CL,0x6
JZ 0x0017b352
MOVZX ECX,CL
CMP ECX,0x5
JNZ 0x0017b310
MOVSS XMM0,dword ptr [R14]
UCOMISS XMM0,XMM0
JP 0x0017b35d
LAB_0017b310:
TEST EBX,EBX
JZ 0x0017b2e1
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,RDI
LAB_0017b31b:
LEA RDI,[RCX + 0x1]
MOV DL,byte ptr [RAX + RBX*0x1]
MOV byte ptr [RCX],DL
MOV RCX,RDI
DEC RBX
JNZ 0x0017b31b
JMP 0x0017b2e1
LAB_0017b32e:
MOV byte ptr [RDI],0xff
MOV byte ptr [RDI + 0x2],BL
MOV byte ptr [RDI + 0x1],BH
ADD RDI,0x3
LAB_0017b33b:
MOV R14,RDI
MOV RDX,RBX
CALL 0x00129080
MOV RDI,R14
MOV R9,qword ptr [RBP + -0x30]
ADD RDI,RBX
JMP 0x0017b2e1
LAB_0017b352:
MOVSD XMM0,qword ptr [R14]
UCOMISD XMM0,XMM0
JNP 0x0017b310
LAB_0017b35d:
MOV R14,RBX
MOV RBX,RDI
XOR ESI,ESI
MOV RDX,R14
CALL 0x001292b0
MOV RDI,RBX
MOV R9,qword ptr [RBP + -0x30]
ADD RDI,R14
JMP 0x0017b2e1
LAB_0017b37c:
MOV RCX,R9
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0018eab4
LAB_0017b392:
MOV RBX,RDI
MOV RDI,qword ptr [RBP + -0x60]
MOV RSI,RBX
MOV RDX,qword ptr [RBP + -0x68]
CALL 0x001853c3
SUB EBX,dword ptr [RBP + -0x50]
MOV EAX,EBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong _mi_make_key(long *param_1,ulong param_2,byte *param_3,long param_4,int8 param_5)
{
byte bVar1;
ushort uVar2;
ushort uVar3;
ushort uVar4;
byte bVar5;
ulong uVar6;
ulong uVar7;
char cVar8;
long lVar9;
long lVar10;
byte *pbVar11;
uint uVar12;
ulong uVar13;
double *pdVar14;
byte *__dest;
double *__src;
void *pvVar15;
long *plVar16;
int local_58;
char local_4c;
lVar9 = (param_2 & 0xffffffff) * 0x70;
uVar2 = *(ushort *)(*(long *)(*param_1 + 0x218) + 10 + lVar9);
if ((uVar2 >> 10 & 1) != 0) {
uVar13 = sp_make_key();
return uVar13;
}
plVar16 = *(long **)(*(long *)(*param_1 + 0x218) + lVar9 + 0x28);
cVar8 = (char)plVar16[3];
__dest = param_3;
if (cVar8 != '\0') {
do {
uVar3 = *(ushort *)((long)plVar16 + 0x14);
uVar13 = (ulong)uVar3;
lVar9 = *plVar16;
if (*(byte *)((long)plVar16 + 0x19) == 0) {
LAB_0017afe9:
local_4c = (char)uVar2;
uVar6 = uVar13;
if ((lVar9 != 0 && -1 < local_4c) && (1 < *(uint *)(lVar9 + 0x9c))) {
uVar6 = uVar13 / *(uint *)(lVar9 + 0x9c);
}
uVar12 = *(uint *)(plVar16 + 1);
__src = (double *)(param_4 + (ulong)uVar12);
if (cVar8 == '\x13') {
bVar5 = *(byte *)((long)plVar16 + 0x1b);
if (bVar5 != 0) {
bVar1 = *(byte *)(param_4 + (ulong)*(ushort *)(plVar16 + 2));
uVar12 = (uint)bVar1;
if (8 < (uint)*(byte *)((long)plVar16 + 0x1a) + (uint)bVar5) {
uVar12 = (uint)CONCAT11(*(int1 *)(param_4 + 1 + (ulong)*(ushort *)(plVar16 + 2))
,bVar1);
}
*__dest = ~(byte)(-1 << (bVar5 & 0x1f)) &
(byte)(uVar12 >> (*(byte *)((long)plVar16 + 0x1a) & 0x1f));
__dest = __dest + 1;
uVar13 = uVar13 - 1;
}
memcpy(__dest,__src,uVar13);
__dest = __dest + uVar13;
}
else {
uVar4 = *(ushort *)((long)plVar16 + 0x12);
if ((uVar4 & 1) == 0) {
if ((uVar4 & 8) == 0) {
if ((uVar4 & 0x20) == 0) {
if ((uVar4 & 0x40) == 0) {
if ((uint)uVar6 < (uint)uVar3) {
uVar6 = (**(code **)(*(long *)(lVar9 + 0xb8) + 0x10))
(lVar9,__src,(long)__src + uVar13,uVar6);
}
uVar7 = uVar13;
if (uVar6 < uVar13) {
uVar7 = uVar6;
}
memcpy(__dest,__src,uVar7);
if (uVar6 < uVar13) {
(**(code **)(*(long *)(lVar9 + 0xb8) + 0x78))
(lVar9,__dest + uVar7,uVar13 - uVar7,0x20);
}
__dest = __dest + uVar13;
}
else {
if (cVar8 == '\x06') {
if (NAN(*__src)) goto LAB_0017b35d;
}
else if ((cVar8 == '\x05') && (NAN(*(float *)__src))) {
LAB_0017b35d:
memset(__dest,0,uVar13);
__dest = __dest + uVar13;
goto LAB_0017b2e1;
}
if (uVar3 != 0) {
pbVar11 = __dest;
do {
__dest = pbVar11 + 1;
*pbVar11 = *(byte *)((ulong)uVar12 + param_4 + -1 + uVar13);
uVar13 = uVar13 - 1;
pbVar11 = __dest;
} while (uVar13 != 0);
}
}
}
else {
uVar12 = _mi_calc_blob_length(*(int1 *)((long)plVar16 + 0x1a),__src);
pvVar15 = *(void **)((long)__src + (ulong)*(byte *)((long)plVar16 + 0x1a));
if (uVar12 < uVar13) {
uVar13 = (ulong)uVar12;
}
if (uVar6 < uVar13) {
uVar6 = (**(code **)(*(long *)(lVar9 + 0xb8) + 0x10))
(lVar9,pvVar15,(long)pvVar15 + uVar13,uVar6);
}
if (uVar6 < uVar13) {
uVar13 = uVar6;
}
if (uVar13 < 0xff) {
*__dest = (byte)uVar13;
__dest = __dest + 1;
if (uVar13 == 0) goto LAB_0017b2e1;
}
else {
*__dest = 0xff;
__dest[2] = (byte)uVar13;
__dest[1] = (byte)(uVar13 >> 8);
__dest = __dest + 3;
}
memcpy(__dest,pvVar15,uVar13);
__dest = __dest + uVar13;
}
}
else {
if (*(char *)((long)plVar16 + 0x1a) == '\x01') {
uVar7 = (ulong)*(byte *)__src;
lVar10 = 1;
}
else {
uVar7 = (ulong)*(ushort *)__src;
lVar10 = 2;
}
pvVar15 = (void *)((long)__src + lVar10);
if (uVar7 < uVar13) {
uVar13 = uVar7;
}
if (uVar6 < uVar13) {
uVar6 = (**(code **)(*(long *)(lVar9 + 0xb8) + 0x10))
(lVar9,pvVar15,(long)pvVar15 + uVar13,uVar6);
}
if (uVar6 < uVar13) {
uVar13 = uVar6;
}
bVar5 = (byte)uVar13;
if (uVar13 < 0xff) {
pbVar11 = __dest + 1;
}
else {
__dest[2] = bVar5;
__dest[1] = (byte)(uVar13 >> 8);
pbVar11 = __dest + 3;
bVar5 = 0xff;
}
*__dest = bVar5;
memcpy(pbVar11,pvVar15,uVar13);
__dest = pbVar11 + uVar13;
}
}
else {
if (cVar8 == '\a') {
pdVar14 = (double *)(uVar13 + (long)__src);
if (uVar13 != 0) {
do {
if (*(char *)__src != ' ') break;
__src = (double *)((long)__src + 1);
} while (__src < pdVar14);
}
uVar13 = (long)pdVar14 - (long)__src;
}
else {
uVar13 = (**(code **)(*(long *)(lVar9 + 0xb8) + 0x18))(lVar9,__src,uVar13);
}
if (uVar6 < uVar13) {
uVar6 = (**(code **)(*(long *)(lVar9 + 0xb8) + 0x10))
(lVar9,__src,(long)__src + uVar13,uVar6);
}
if (uVar6 < uVar13) {
uVar13 = uVar6;
}
bVar5 = (byte)uVar13;
if (uVar13 < 0xff) {
pbVar11 = __dest + 1;
}
else {
__dest[2] = bVar5;
__dest[1] = (byte)(uVar13 >> 8);
pbVar11 = __dest + 3;
bVar5 = 0xff;
}
*__dest = bVar5;
memcpy(pbVar11,__src,uVar13);
__dest = pbVar11 + uVar13;
}
}
}
else {
if ((*(byte *)(param_4 + (ulong)*(uint *)((long)plVar16 + 0xc)) &
*(byte *)((long)plVar16 + 0x19)) == 0) {
*__dest = 1;
__dest = __dest + 1;
goto LAB_0017afe9;
}
*__dest = 0;
__dest = __dest + 1;
}
LAB_0017b2e1:
cVar8 = (char)plVar16[7];
plVar16 = plVar16 + 4;
} while (cVar8 != '\0');
}
_mi_dpointer(param_1,__dest,param_5);
local_58 = (int)param_3;
return (ulong)(uint)((int)__dest - local_58);
}
|
|
6,825 |
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::gatherIrregularPatchPoints(int, int*)
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/tmr/subdivisionPlanBuilder.cpp
|
void SubdivisionPlanBuilder::gatherIrregularPatchPoints(int levelIndex, Index* patchPoints) {
// Irregular patches have a unique set of 'local' patch points that are factorized from
// the regular patch points - we need to inject new rows in the stencil matrix for these
// 'local points' ; the number of rows is given by _irregularPatchSize (REGULAR_BASIS adds
// 16 points, GREGORY_BASIS 20, ...).
//
// By default these rows are located at the bottom of the stencil matrix, unless the rows
// are re-ordered to be placed right after the stencils of the regular points of a given
// level.
Index indexBase = _levelOffsets[levelIndex].irregularIndexBase;
unsigned int& indexOffset = _levelOffsets[_reorderStencilMatrix ? levelIndex : 0].irregularIndexOffset;
for (int i = 0; i < _irregularPatchSize; ++i)
patchPoints[i] = (indexBase + indexOffset++);
}
|
O0
|
cpp
|
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::gatherIrregularPatchPoints(int, int*):
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rax, %rcx
addq $0x118, %rcx # imm = 0x118
movslq -0xc(%rbp), %rdx
imulq $0x14, %rdx, %rdx
addq %rdx, %rcx
movl 0x4(%rcx), %ecx
movl %ecx, -0x1c(%rbp)
movq %rax, %rcx
addq $0x118, %rcx # imm = 0x118
movq %rcx, -0x38(%rbp)
testb $0x1, 0x269(%rax)
je 0x1d10a1
movl -0xc(%rbp), %eax
movl %eax, -0x44(%rbp)
jmp 0x1d10a8
xorl %eax, %eax
movl %eax, -0x44(%rbp)
jmp 0x1d10a8
movq -0x38(%rbp), %rax
movl -0x44(%rbp), %ecx
movslq %ecx, %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x40(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x274(%rcx), %eax
jge 0x1d10ff
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
movl (%rcx), %eax
movl %eax, %esi
addl $0x1, %esi
movl %esi, (%rcx)
addl %eax, %edx
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1d10c8
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ZN10OpenSubdiv6v3_6_03Tmr22SubdivisionPlanBuilder26gatherIrregularPatchPointsEiPi:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov [rbp+var_40], rax
mov rcx, rax
add rcx, 118h
movsxd rdx, [rbp+var_C]
imul rdx, 14h
add rcx, rdx
mov ecx, [rcx+4]
mov [rbp+var_1C], ecx
mov rcx, rax
add rcx, 118h
mov [rbp+var_38], rcx
test byte ptr [rax+269h], 1
jz short loc_1D10A1
mov eax, [rbp+var_C]
mov [rbp+var_44], eax
jmp short loc_1D10A8
loc_1D10A1:
xor eax, eax
mov [rbp+var_44], eax
jmp short $+2
loc_1D10A8:
mov rax, [rbp+var_38]
mov ecx, [rbp+var_44]
movsxd rcx, ecx
imul rcx, 14h
add rax, rcx
add rax, 8
mov [rbp+var_28], rax
mov [rbp+var_2C], 0
loc_1D10C8:
mov rcx, [rbp+var_40]
mov eax, [rbp+var_2C]
cmp eax, [rcx+274h]
jge short loc_1D10FF
mov edx, [rbp+var_1C]
mov rcx, [rbp+var_28]
mov eax, [rcx]
mov esi, eax
add esi, 1
mov [rcx], esi
add edx, eax
mov rax, [rbp+var_18]
movsxd rcx, [rbp+var_2C]
mov [rax+rcx*4], edx
mov eax, [rbp+var_2C]
add eax, 1
mov [rbp+var_2C], eax
jmp short loc_1D10C8
loc_1D10FF:
pop rbp
retn
|
long long OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::gatherIrregularPatchPoints(
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder *this,
int a2,
int *a3)
{
long long result; // rax
int v4; // eax
int v5; // [rsp+0h] [rbp-44h]
unsigned int i; // [rsp+18h] [rbp-2Ch]
_DWORD *v7; // [rsp+1Ch] [rbp-28h]
int v8; // [rsp+28h] [rbp-1Ch]
v8 = *((_DWORD *)this + 5 * a2 + 71);
if ( (*((_BYTE *)this + 617) & 1) != 0 )
v5 = a2;
else
v5 = 0;
v7 = (_DWORD *)((char *)this + 20 * v5 + 288);
for ( i = 0; ; ++i )
{
result = i;
if ( (signed int)i >= *((_DWORD *)this + 157) )
break;
v4 = (*v7)++;
a3[i] = v4 + v8;
}
return result;
}
| |||
6,826 |
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::gatherIrregularPatchPoints(int, int*)
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/tmr/subdivisionPlanBuilder.cpp
|
void SubdivisionPlanBuilder::gatherIrregularPatchPoints(int levelIndex, Index* patchPoints) {
// Irregular patches have a unique set of 'local' patch points that are factorized from
// the regular patch points - we need to inject new rows in the stencil matrix for these
// 'local points' ; the number of rows is given by _irregularPatchSize (REGULAR_BASIS adds
// 16 points, GREGORY_BASIS 20, ...).
//
// By default these rows are located at the bottom of the stencil matrix, unless the rows
// are re-ordered to be placed right after the stencils of the regular points of a given
// level.
Index indexBase = _levelOffsets[levelIndex].irregularIndexBase;
unsigned int& indexOffset = _levelOffsets[_reorderStencilMatrix ? levelIndex : 0].irregularIndexOffset;
for (int i = 0; i < _irregularPatchSize; ++i)
patchPoints[i] = (indexBase + indexOffset++);
}
|
O2
|
cpp
|
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::gatherIrregularPatchPoints(int, int*):
movslq %esi, %rsi
imulq $0x14, %rsi, %rax
movl 0x11c(%rdi,%rax), %eax
xorl %ecx, %ecx
cmpb $0x0, 0x269(%rdi)
cmoveq %rcx, %rsi
imulq $0x14, %rsi, %rsi
addq %rdi, %rsi
addq $0x120, %rsi # imm = 0x120
movslq 0x274(%rdi), %r8
cmpq %r8, %rcx
jge 0xb3521
movl (%rsi), %r8d
leal 0x1(%r8), %r9d
movl %r9d, (%rsi)
addl %eax, %r8d
movl %r8d, (%rdx,%rcx,4)
incq %rcx
jmp 0xb34ff
retq
|
_ZN10OpenSubdiv6v3_6_03Tmr22SubdivisionPlanBuilder26gatherIrregularPatchPointsEiPi:
movsxd rsi, esi
imul rax, rsi, 14h
mov eax, [rdi+rax+11Ch]
xor ecx, ecx
cmp byte ptr [rdi+269h], 0
cmovz rsi, rcx
imul rsi, 14h
add rsi, rdi
add rsi, 120h
loc_B34FF:
movsxd r8, dword ptr [rdi+274h]
cmp rcx, r8
jge short locret_B3521
mov r8d, [rsi]
lea r9d, [r8+1]
mov [rsi], r9d
add r8d, eax
mov [rdx+rcx*4], r8d
inc rcx
jmp short loc_B34FF
locret_B3521:
retn
|
long long OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::gatherIrregularPatchPoints(
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder *this,
long long a2,
int *a3)
{
long long result; // rax
long long v4; // rcx
_DWORD *v5; // rsi
int v6; // r8d
a2 = (int)a2;
result = *((unsigned int *)this + 5 * (int)a2 + 71);
v4 = 0LL;
if ( !*((_BYTE *)this + 617) )
a2 = 0LL;
v5 = (_DWORD *)((char *)this + 20 * a2 + 288);
while ( v4 < *((int *)this + 157) )
{
v6 = (*v5)++;
a3[v4++] = result + v6;
}
return result;
}
|
gatherIrregularPatchPoints:
MOVSXD RSI,ESI
IMUL RAX,RSI,0x14
MOV EAX,dword ptr [RDI + RAX*0x1 + 0x11c]
XOR ECX,ECX
CMP byte ptr [RDI + 0x269],0x0
CMOVZ RSI,RCX
IMUL RSI,RSI,0x14
ADD RSI,RDI
ADD RSI,0x120
LAB_001b34ff:
MOVSXD R8,dword ptr [RDI + 0x274]
CMP RCX,R8
JGE 0x001b3521
MOV R8D,dword ptr [RSI]
LEA R9D,[R8 + 0x1]
MOV dword ptr [RSI],R9D
ADD R8D,EAX
MOV dword ptr [RDX + RCX*0x4],R8D
INC RCX
JMP 0x001b34ff
LAB_001b3521:
RET
|
/* OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::gatherIrregularPatchPoints(int, int*) */
void __thiscall
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::gatherIrregularPatchPoints
(SubdivisionPlanBuilder *this,int param_1,int *param_2)
{
int iVar1;
int iVar2;
long lVar3;
long lVar4;
iVar1 = *(int *)(this + (long)param_1 * 0x14 + 0x11c);
lVar3 = 0;
lVar4 = (long)param_1;
if (this[0x269] == (SubdivisionPlanBuilder)0x0) {
lVar4 = lVar3;
}
for (; lVar3 < *(int *)(this + 0x274); lVar3 = lVar3 + 1) {
iVar2 = *(int *)(this + lVar4 * 0x14 + 0x120);
*(int *)(this + lVar4 * 0x14 + 0x120) = iVar2 + 1;
param_2[lVar3] = iVar2 + iVar1;
}
return;
}
|
|
6,827 |
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::gatherIrregularPatchPoints(int, int*)
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/tmr/subdivisionPlanBuilder.cpp
|
void SubdivisionPlanBuilder::gatherIrregularPatchPoints(int levelIndex, Index* patchPoints) {
// Irregular patches have a unique set of 'local' patch points that are factorized from
// the regular patch points - we need to inject new rows in the stencil matrix for these
// 'local points' ; the number of rows is given by _irregularPatchSize (REGULAR_BASIS adds
// 16 points, GREGORY_BASIS 20, ...).
//
// By default these rows are located at the bottom of the stencil matrix, unless the rows
// are re-ordered to be placed right after the stencils of the regular points of a given
// level.
Index indexBase = _levelOffsets[levelIndex].irregularIndexBase;
unsigned int& indexOffset = _levelOffsets[_reorderStencilMatrix ? levelIndex : 0].irregularIndexOffset;
for (int i = 0; i < _irregularPatchSize; ++i)
patchPoints[i] = (indexBase + indexOffset++);
}
|
O3
|
cpp
|
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::gatherIrregularPatchPoints(int, int*):
movslq %esi, %rax
xorl %ecx, %ecx
cmpb $0x0, 0x269(%rdi)
cmovneq %rax, %rcx
cmpl $0x0, 0x274(%rdi)
jle 0xaaefb
leaq (%rax,%rax,4), %rax
movl 0x11c(%rdi,%rax,4), %eax
leaq (%rcx,%rcx,4), %rcx
leaq (%rdi,%rcx,4), %rcx
addq $0x120, %rcx # imm = 0x120
xorl %esi, %esi
movl (%rcx), %r8d
leal 0x1(%r8), %r9d
movl %r9d, (%rcx)
addl %eax, %r8d
movl %r8d, (%rdx,%rsi,4)
incq %rsi
movslq 0x274(%rdi), %r8
cmpq %r8, %rsi
jl 0xaaedb
retq
|
_ZN10OpenSubdiv6v3_6_03Tmr22SubdivisionPlanBuilder26gatherIrregularPatchPointsEiPi:
movsxd rax, esi
xor ecx, ecx
cmp byte ptr [rdi+269h], 0
cmovnz rcx, rax
cmp dword ptr [rdi+274h], 0
jle short locret_AAEFB
lea rax, [rax+rax*4]
mov eax, [rdi+rax*4+11Ch]
lea rcx, [rcx+rcx*4]
lea rcx, [rdi+rcx*4]
add rcx, 120h
xor esi, esi
loc_AAEDB:
mov r8d, [rcx]
lea r9d, [r8+1]
mov [rcx], r9d
add r8d, eax
mov [rdx+rsi*4], r8d
inc rsi
movsxd r8, dword ptr [rdi+274h]
cmp rsi, r8
jl short loc_AAEDB
locret_AAEFB:
retn
|
long long OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::gatherIrregularPatchPoints(
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder *this,
int a2,
int *a3)
{
long long result; // rax
long long v4; // rcx
_DWORD *v5; // rcx
long long v6; // rsi
int v7; // r8d
result = a2;
v4 = 0LL;
if ( *((_BYTE *)this + 617) )
v4 = a2;
if ( *((int *)this + 157) > 0 )
{
result = *((unsigned int *)this + 5 * a2 + 71);
v5 = (_DWORD *)((char *)this + 20 * v4 + 288);
v6 = 0LL;
do
{
v7 = (*v5)++;
a3[v6++] = result + v7;
}
while ( v6 < *((int *)this + 157) );
}
return result;
}
|
gatherIrregularPatchPoints:
MOVSXD RAX,ESI
XOR ECX,ECX
CMP byte ptr [RDI + 0x269],0x0
CMOVNZ RCX,RAX
CMP dword ptr [RDI + 0x274],0x0
JLE 0x001aaefb
LEA RAX,[RAX + RAX*0x4]
MOV EAX,dword ptr [RDI + RAX*0x4 + 0x11c]
LEA RCX,[RCX + RCX*0x4]
LEA RCX,[RDI + RCX*0x4]
ADD RCX,0x120
XOR ESI,ESI
LAB_001aaedb:
MOV R8D,dword ptr [RCX]
LEA R9D,[R8 + 0x1]
MOV dword ptr [RCX],R9D
ADD R8D,EAX
MOV dword ptr [RDX + RSI*0x4],R8D
INC RSI
MOVSXD R8,dword ptr [RDI + 0x274]
CMP RSI,R8
JL 0x001aaedb
LAB_001aaefb:
RET
|
/* OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::gatherIrregularPatchPoints(int, int*) */
void __thiscall
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::gatherIrregularPatchPoints
(SubdivisionPlanBuilder *this,int param_1,int *param_2)
{
int iVar1;
int iVar2;
long lVar3;
long lVar4;
lVar3 = 0;
if (this[0x269] != (SubdivisionPlanBuilder)0x0) {
lVar3 = (long)param_1;
}
if (0 < *(int *)(this + 0x274)) {
iVar1 = *(int *)(this + (long)param_1 * 0x14 + 0x11c);
lVar4 = 0;
do {
iVar2 = *(int *)(this + lVar3 * 0x14 + 0x120);
*(int *)(this + lVar3 * 0x14 + 0x120) = iVar2 + 1;
param_2[lVar4] = iVar2 + iVar1;
lVar4 = lVar4 + 1;
} while (lVar4 < *(int *)(this + 0x274));
}
return;
}
|
|
6,828 |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
|
llama.cpp/common/json.hpp
|
reference operator[](typename object_t::key_type key)
{
// implicitly convert null value to an empty object
if (is_null())
{
m_data.m_type = value_t::object;
m_data.m_value.object = create<object_t>();
assert_invariant();
}
// operator[] only works for objects
if (JSON_HEDLEY_LIKELY(is_object()))
{
auto result = m_data.m_value.object->emplace(std::move(key), nullptr);
return set_parent(result.first->second);
}
JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb (%rdi), %al
testb %al, %al
jne 0xc8d94
movb $0x1, (%r14)
movl $0x20, %edi
callq 0x20210
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x84b96
movb (%r14), %al
cmpb $0x1, %al
jne 0xc8dfd
movq 0x8(%r14), %r14
movq %rsp, %r15
movb $0x0, (%r15)
movq $0x0, 0x8(%r15)
movq %r15, %rdi
movl $0x1, %esi
callq 0x84b96
movq %r15, %rdi
movl $0x1, %esi
callq 0x84b96
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x8a8a8
movq %rax, %rbx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x84b96
movq %r14, %rdi
callq 0x892b0
addq $0x20, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x20650
movq %rax, %rbx
movq %r14, %rdi
callq 0x8a248
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x56ab4(%rip), %rsi # 0x11f8d5
movq %rsp, %rdi
callq 0xbbe48
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x131, %esi # imm = 0x131
movq %r14, %rcx
callq 0x8a070
xorl %ebp, %ebp
leaq 0x971f8(%rip), %rsi # 0x160040
leaq -0x52d37(%rip), %rdx # 0x76118
movq %rbx, %rdi
callq 0x20a50
movq %rax, %r14
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x84b96
movq %rbx, %rdi
callq 0x892b0
jmp 0xc8ea1
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc8e8f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x20180
testb %bpl, %bpl
jne 0xc8e99
jmp 0xc8ea1
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f10
movq %r14, %rdi
callq 0x20af0
nop
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixES9_:
push rbp; void *
push r15; int
push r14; __int64
push rbx; int
sub rsp, 28h
mov rbx, rsi
mov r14, rdi
mov al, [rdi]
test al, al
jnz short loc_C8D94
mov byte ptr [r14], 1
mov edi, 20h ; ' '; unsigned __int64
call __Znwm; operator new(ulong)
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
mov [r14+8], rax
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov al, [r14]
loc_C8D94:
cmp al, 1
jnz short loc_C8DFD
mov r14, [r14+8]
mov r15, rsp
mov byte ptr [r15], 0
mov qword ptr [r15+8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
mov rsi, rbx
mov rdx, r15
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE7emplaceERSH_OSD_; nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::emplace(std::string const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&&)
mov rbx, rax
mov r14, rsp
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
add rbx, 20h ; ' '
mov rax, rbx
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_C8DFD:
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_28]
mov [rdx], rax
lea rsi, aCannotUseOpera_0; "cannot use operator[] with a string arg"...
mov rdi, rsp
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA51_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[51],char const*>(char const(&)[51],char const* &&)
mov bpl, 1
mov rdx, rsp
mov rdi, rbx; this
mov esi, 131h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
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
mov rbx, rsp
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_C8EA1
mov r14, rax
lea rax, [rsp+48h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C8E8F
mov rsi, [rsp+48h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C8E8F:
test bpl, bpl
jnz short loc_C8E99
jmp short loc_C8EA1
mov r14, rax
loc_C8E99:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_C8EA1:
mov rdi, r14
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[](
long long a1,
long long *a2)
{
char v2; // al
long long v3; // rax
_QWORD *v4; // r14
long long v5; // rbx
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
_QWORD v8[2]; // [rsp+0h] [rbp-48h] BYREF
const char *v9; // [rsp+20h] [rbp-28h] BYREF
v2 = *(_BYTE *)a1;
if ( !*(_BYTE *)a1 )
{
*(_BYTE *)a1 = 1;
v3 = operator new(0x20uLL);
*(_OWORD *)v3 = 0LL;
*(_QWORD *)(v3 + 16) = 0LL;
*(_QWORD *)(a1 + 8) = v3;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
v2 = *(_BYTE *)a1;
}
if ( v2 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v9 = 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(&)[51],char const*>(
(long long)v8,
(long long)"cannot use operator[] with a string argument with ",
&v9);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
305,
v8);
__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);
}
v4 = *(_QWORD **)(a1 + 8);
LOBYTE(v8[0]) = 0;
v8[1] = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v8);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v8);
v5 = nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::emplace(
v4,
a2,
(long long)v8);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v8);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v8);
return v5 + 32;
}
|
operator[]:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RSI
MOV R14,RDI
MOV AL,byte ptr [RDI]
TEST AL,AL
JNZ 0x001c8d94
MOV byte ptr [R14],0x1
MOV EDI,0x20
CALL 0x00120210
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
MOV qword ptr [R14 + 0x8],RAX
MOV RDI,R14
MOV ESI,0x1
CALL 0x00184b96
MOV AL,byte ptr [R14]
LAB_001c8d94:
CMP AL,0x1
JNZ 0x001c8dfd
MOV R14,qword ptr [R14 + 0x8]
MOV R15,RSP
MOV byte ptr [R15],0x0
MOV qword ptr [R15 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x00184b96
MOV RDI,R15
MOV ESI,0x1
CALL 0x00184b96
LAB_001c8dc5:
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R15
CALL 0x0018a8a8
LAB_001c8dd3:
MOV RBX,RAX
MOV R14,RSP
MOV RDI,R14
XOR ESI,ESI
CALL 0x00184b96
MOV RDI,R14
CALL 0x001892b0
ADD RBX,0x20
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001c8dfd:
MOV EDI,0x20
CALL 0x00120650
MOV RBX,RAX
MOV RDI,R14
CALL 0x0018a248
LEA RDX,[RSP + 0x20]
MOV qword ptr [RDX],RAX
LAB_001c8e1a:
LEA RSI,[0x21f8d5]
MOV RDI,RSP
CALL 0x001bbe48
MOV BPL,0x1
LAB_001c8e2c:
MOV RDX,RSP
MOV RDI,RBX
MOV ESI,0x131
MOV RCX,R14
CALL 0x0018a070
XOR EBP,EBP
LEA RSI,[0x260040]
LEA RDX,[0x176118]
MOV RDI,RBX
CALL 0x00120a50
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::operator[](std::__cxx11::string) */
long __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[](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,string *param_2)
{
ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*this_00;
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;
int8 *puVar2;
long lVar3;
int8 uVar4;
bool bVar5;
basic_json local_48 [8];
int8 local_40;
char *local_28;
bVar1 = *this;
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>
)0x0) {
*this = (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>
)0x1;
puVar2 = (int8 *)operator_new(0x20);
*puVar2 = 0;
puVar2[1] = 0;
puVar2[2] = 0;
*(int8 **)(this + 8) = puVar2;
assert_invariant(SUB81(this,0));
bVar1 = *this;
}
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>
)0x1) {
this_00 = *(ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)(this + 8);
local_48[0] = (basic_json)0x0;
local_40 = 0;
bVar5 = SUB81(local_48,0);
assert_invariant(bVar5);
assert_invariant(bVar5);
/* try { // try from 001c8dc5 to 001c8dd2 has its CatchHandler @ 001c8e57 */
lVar3 = ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::emplace(this_00,param_2,local_48);
assert_invariant(bVar5);
data::~data((data *)local_48);
return lVar3 + 0x20;
}
uVar4 = __cxa_allocate_exception(0x20);
local_28 = (char *)type_name(this);
/* try { // try from 001c8e1a to 001c8e28 has its CatchHandler @ 001c8e96 */
detail::concat<std::__cxx11::string,char_const(&)[51],char_const*>
((detail *)local_48,"cannot use operator[] with a string argument with ",&local_28);
/* try { // try from 001c8e2c to 001c8e56 has its CatchHandler @ 001c8e71 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar4,0x131,local_48,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&detail::type_error::typeinfo,detail::exception::~exception);
}
|
|
6,829 |
ma_get_length
|
eloqsql/storage/maria/ma_blockrec.c
|
static ulong ma_get_length(const uchar **packet)
{
reg1 const uchar *pos= *packet;
if (*pos < 251)
{
(*packet)++;
return (ulong) *pos;
}
if (*pos == 251)
{
(*packet)+= 2;
return (ulong) pos[1];
}
if (*pos == 252)
{
(*packet)+= 3;
return (ulong) uint2korr(pos+1);
}
if (*pos == 253)
{
(*packet)+= 4;
return (ulong) uint3korr(pos+1);
}
DBUG_ASSERT(*pos == 254);
(*packet)+= 5;
return (ulong) uint4korr(pos+1);
}
|
O0
|
c
|
ma_get_length:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xfb, %eax
jge 0x7c7cf
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movq %rax, -0x8(%rbp)
jmp 0x7c889
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xfb, %eax
jne 0x7c7fc
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
movq %rax, -0x8(%rbp)
jmp 0x7c889
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xfc, %eax
jne 0x7c826
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x3, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movzwl 0x1(%rax), %eax
movq %rax, -0x8(%rbp)
jmp 0x7c889
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xfd, %eax
jne 0x7c86c
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x18(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
movq %rax, -0x8(%rbp)
jmp 0x7c889
jmp 0x7c86e
jmp 0x7c870
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x5, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl 0x1(%rax), %eax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
|
ma_get_length:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
cmp eax, 0FBh
jge short loc_7C7CF
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 1
mov [rax], rcx
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
mov [rbp+var_8], rax
jmp loc_7C889
loc_7C7CF:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
cmp eax, 0FBh
jnz short loc_7C7FC
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 2
mov [rax], rcx
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
mov [rbp+var_8], rax
jmp loc_7C889
loc_7C7FC:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
cmp eax, 0FCh
jnz short loc_7C826
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 3
mov [rax], rcx
mov rax, [rbp+var_18]
movzx eax, word ptr [rax+1]
mov [rbp+var_8], rax
jmp short loc_7C889
loc_7C826:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
cmp eax, 0FDh
jnz short loc_7C86C
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+2]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+3]
shl ecx, 10h
or eax, ecx
mov eax, eax
mov [rbp+var_8], rax
jmp short loc_7C889
loc_7C86C:
jmp short $+2
loc_7C86E:
jmp short $+2
loc_7C870:
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 5
mov [rax], rcx
mov rax, [rbp+var_18]
mov eax, [rax+1]
mov [rbp+var_8], rax
loc_7C889:
mov rax, [rbp+var_8]
pop rbp
retn
|
long long ma_get_length(unsigned __int8 **a1)
{
unsigned __int8 *v2; // [rsp+0h] [rbp-18h]
v2 = *a1;
if ( **a1 >= 0xFBu )
{
switch ( *v2 )
{
case 0xFBu:
*a1 += 2;
return v2[1];
case 0xFCu:
*a1 += 3;
return *(unsigned __int16 *)(v2 + 1);
case 0xFDu:
*a1 += 4;
return (v2[3] << 16) | (unsigned int)*(unsigned __int16 *)(v2 + 1);
default:
*a1 += 5;
return *(unsigned int *)(v2 + 1);
}
}
else
{
++*a1;
return *v2;
}
}
|
ma_get_length:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xfb
JGE 0x0017c7cf
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017c889
LAB_0017c7cf:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xfb
JNZ 0x0017c7fc
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x2
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017c889
LAB_0017c7fc:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xfc
JNZ 0x0017c826
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x3
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX + 0x1]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017c889
LAB_0017c826:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xfd
JNZ 0x0017c86c
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x3]
SHL ECX,0x10
OR EAX,ECX
MOV EAX,EAX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017c889
LAB_0017c86c:
JMP 0x0017c86e
LAB_0017c86e:
JMP 0x0017c870
LAB_0017c870:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x5
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x1]
MOV qword ptr [RBP + -0x8],RAX
LAB_0017c889:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
uint ma_get_length(long *param_1)
{
byte *pbVar1;
uint uVar2;
pbVar1 = (byte *)*param_1;
if (*pbVar1 < 0xfb) {
*param_1 = *param_1 + 1;
uVar2 = (uint)*pbVar1;
}
else if (*pbVar1 == 0xfb) {
*param_1 = *param_1 + 2;
uVar2 = (uint)pbVar1[1];
}
else if (*pbVar1 == 0xfc) {
*param_1 = *param_1 + 3;
uVar2 = (uint)*(ushort *)(pbVar1 + 1);
}
else if (*pbVar1 == 0xfd) {
*param_1 = *param_1 + 4;
uVar2 = (uint)*(uint3 *)(pbVar1 + 1);
}
else {
*param_1 = *param_1 + 5;
uVar2 = *(uint *)(pbVar1 + 1);
}
return uVar2;
}
|
|
6,830 |
maria_ft_parse
|
eloqsql/storage/maria/ma_ft_parser.c
|
int maria_ft_parse(TREE *wtree, uchar *doc, int doclen,
struct st_mysql_ftparser *parser,
MYSQL_FTPARSER_PARAM *param, MEM_ROOT *mem_root)
{
MY_FT_PARSER_PARAM my_param;
DBUG_ENTER("maria_ft_parse");
DBUG_ASSERT(parser);
my_param.wtree= wtree;
my_param.mem_root= mem_root;
param->mysql_parse= maria_ft_parse_internal;
param->mysql_add_word= maria_ft_add_word;
param->mysql_ftparam= &my_param;
param->cs= wtree->custom_arg;
param->doc= (char*)doc;
param->length= doclen;
param->mode= MYSQL_FTPARSER_SIMPLE_MODE;
DBUG_RETURN(parser->parse(param));
}
|
O3
|
c
|
maria_ft_parse:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x10(%rbp), %rax
movq %rdi, (%rax)
movq %r9, 0x8(%rax)
leaq 0x39(%rip), %r9 # 0x5f6f5
movq %r9, (%r8)
leaq 0xa6(%rip), %r9 # 0x5f76c
movq %r9, 0x8(%r8)
movq %rax, 0x18(%r8)
movq 0x230(%rdi), %rax
movq %rax, 0x20(%r8)
movq %rsi, 0x28(%r8)
movl %edx, 0x30(%r8)
movl $0x0, 0x38(%r8)
movq %r8, %rdi
callq *0x8(%rcx)
addq $0x10, %rsp
popq %rbp
retq
|
maria_ft_parse:
push rbp
mov rbp, rsp
sub rsp, 10h
lea rax, [rbp+var_10]
mov [rax], rdi
mov [rax+8], r9
lea r9, maria_ft_parse_internal
mov [r8], r9
lea r9, maria_ft_add_word
mov [r8+8], r9
mov [r8+18h], rax
mov rax, [rdi+230h]
mov [r8+20h], rax
mov [r8+28h], rsi
mov [r8+30h], edx
mov dword ptr [r8+38h], 0
mov rdi, r8
call qword ptr [rcx+8]
add rsp, 10h
pop rbp
retn
|
long long maria_ft_parse(long long a1, long long a2, int a3, long long a4, long long a5, long long a6)
{
_QWORD v7[2]; // [rsp+0h] [rbp-10h] BYREF
v7[0] = a1;
v7[1] = a6;
*(_QWORD *)a5 = maria_ft_parse_internal;
*(_QWORD *)(a5 + 8) = maria_ft_add_word;
*(_QWORD *)(a5 + 24) = v7;
*(_QWORD *)(a5 + 32) = *(_QWORD *)(a1 + 560);
*(_QWORD *)(a5 + 40) = a2;
*(_DWORD *)(a5 + 48) = a3;
*(_DWORD *)(a5 + 56) = 0;
return (*(long long ( **)(long long))(a4 + 8))(a5);
}
|
maria_ft_parse:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
LEA RAX,[RBP + -0x10]
MOV qword ptr [RAX],RDI
MOV qword ptr [RAX + 0x8],R9
LEA R9,[0x15f6f5]
MOV qword ptr [R8],R9
LEA R9,[0x15f76c]
MOV qword ptr [R8 + 0x8],R9
MOV qword ptr [R8 + 0x18],RAX
MOV RAX,qword ptr [RDI + 0x230]
MOV qword ptr [R8 + 0x20],RAX
MOV qword ptr [R8 + 0x28],RSI
MOV dword ptr [R8 + 0x30],EDX
MOV dword ptr [R8 + 0x38],0x0
MOV RDI,R8
CALL qword ptr [RCX + 0x8]
ADD RSP,0x10
POP RBP
RET
|
void maria_ft_parse(long param_1,int8 param_2,int4 param_3,long param_4,
int8 *param_5,int8 param_6)
{
long local_18;
int8 local_10;
*param_5 = maria_ft_parse_internal;
param_5[1] = maria_ft_add_word;
param_5[3] = &local_18;
param_5[4] = *(int8 *)(param_1 + 0x230);
param_5[5] = param_2;
*(int4 *)(param_5 + 6) = param_3;
*(int4 *)(param_5 + 7) = 0;
local_18 = param_1;
local_10 = param_6;
(**(code **)(param_4 + 8))(param_5);
return;
}
|
|
6,831 |
action_e_gt
|
qoraal-tictactoe/build_O0/_deps/qoraal_engine-src/src/parts/engine.c
|
int32_t
action_e_gt (PENGINE_T instance, uint32_t parm, uint32_t flags)
{
int32_t value ;
if (flags & (PART_ACTION_FLAG_VALIDATE)) {
return parts_valadate_int (instance, parm, flags, INT_MIN, INT_MAX) ;
}
value = parts_get_int (instance, parm, flags, INT_MIN, INT_MAX) ;
int32_t acc ;
engine_get_variable (instance, ENGINE_VARIABLE_EVENT, &acc) ;
return acc > value ;
}
|
O0
|
c
|
action_e_gt:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x18(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x7b7c
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl $0x80000000, %ecx # imm = 0x80000000
movl $0x7fffffff, %r8d # imm = 0x7FFFFFFF
callq 0x91b0
movl %eax, -0x4(%rbp)
jmp 0x7bbc
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl $0x80000000, %ecx # imm = 0x80000000
movl $0x7fffffff, %r8d # imm = 0x7FFFFFFF
callq 0x92f0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
leaq -0x20(%rbp), %rdx
callq 0x13470
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
setg %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
action_e_gt:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov eax, [rbp+var_18]
and eax, 1
cmp eax, 0
jz short loc_7B7C
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
mov edx, [rbp+var_18]
mov ecx, 80000000h
mov r8d, 7FFFFFFFh
call parts_valadate_int
mov [rbp+var_4], eax
jmp short loc_7BBC
loc_7B7C:
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
mov edx, [rbp+var_18]
mov ecx, 80000000h
mov r8d, 7FFFFFFFh
call parts_get_int
mov [rbp+var_1C], eax
mov rdi, [rbp+var_10]
mov esi, 3
lea rdx, [rbp+var_20]
call engine_get_variable
mov eax, [rbp+var_20]
cmp eax, [rbp+var_1C]
setnle al
and al, 1
movzx eax, al
mov [rbp+var_4], eax
loc_7BBC:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
|
long long action_e_gt(long long a1, unsigned int a2, unsigned int a3)
{
int v4; // [rsp+0h] [rbp-20h] BYREF
int v5; // [rsp+4h] [rbp-1Ch]
unsigned int v6; // [rsp+8h] [rbp-18h]
unsigned int v7; // [rsp+Ch] [rbp-14h]
long long v8; // [rsp+10h] [rbp-10h]
v8 = a1;
v7 = a2;
v6 = a3;
if ( (a3 & 1) != 0 )
{
return (unsigned int)parts_valadate_int(v8, v7, v6, 0x80000000LL, 0x7FFFFFFFLL);
}
else
{
v5 = parts_get_int(v8, v7, v6, 0x80000000LL, 0x7FFFFFFFLL);
engine_get_variable(v8, 3LL, &v4);
return v4 > v5;
}
}
|
action_e_gt:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV EAX,dword ptr [RBP + -0x18]
AND EAX,0x1
CMP EAX,0x0
JZ 0x00107b7c
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
MOV EDX,dword ptr [RBP + -0x18]
MOV ECX,0x80000000
MOV R8D,0x7fffffff
CALL 0x001091b0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00107bbc
LAB_00107b7c:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
MOV EDX,dword ptr [RBP + -0x18]
MOV ECX,0x80000000
MOV R8D,0x7fffffff
CALL 0x001092f0
MOV dword ptr [RBP + -0x1c],EAX
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x3
LEA RDX,[RBP + -0x20]
CALL 0x00113470
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x1c]
SETG AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x4],EAX
LAB_00107bbc:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
uint action_e_gt(int8 param_1,int4 param_2,uint param_3)
{
int local_28;
int local_24;
uint local_20;
int4 local_1c;
int8 local_18;
uint local_c;
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
if ((param_3 & 1) == 0) {
local_24 = parts_get_int(param_1,param_2,param_3,0x80000000,0x7fffffff);
engine_get_variable(local_18,3,&local_28);
local_c = (uint)(local_24 < local_28);
}
else {
local_c = parts_valadate_int(param_1,param_2,param_3,0x80000000,0x7fffffff);
}
return local_c;
}
|
|
6,832 |
trnman_destroy
|
eloqsql/storage/maria/trnman.c
|
void trnman_destroy()
{
DBUG_ENTER("trnman_destroy");
if (short_trid_to_active_trn == NULL) /* trnman already destroyed */
DBUG_VOID_RETURN;
DBUG_ASSERT(trid_to_trn.count == 0);
DBUG_ASSERT(trnman_active_transactions == 0);
DBUG_ASSERT(trnman_committed_transactions == 0);
DBUG_ASSERT(active_list_max.prev == &active_list_min);
DBUG_ASSERT(active_list_min.next == &active_list_max);
DBUG_ASSERT(committed_list_max.prev == &committed_list_min);
DBUG_ASSERT(committed_list_min.next == &committed_list_max);
while (pool)
{
TRN *trn= pool;
pool= pool->next;
DBUG_ASSERT(trn->wt == NULL);
mysql_mutex_destroy(&trn->state_lock);
my_free(trn);
}
lf_hash_destroy(&trid_to_trn);
DBUG_PRINT("info", ("mysql_mutex_destroy LOCK_trn_list"));
mysql_mutex_destroy(&LOCK_trn_list);
my_free(short_trid_to_active_trn+1);
short_trid_to_active_trn= NULL;
DBUG_VOID_RETURN;
}
|
O3
|
c
|
trnman_destroy:
cmpq $0x0, 0x3b6803(%rip) # 0x3fd170
je 0x46a27
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x3b6ac7(%rip), %rbx # 0x3fd448
testq %rbx, %rbx
je 0x469cc
leaq 0x33f683(%rip), %r14 # 0x386010
movq 0x68(%rbx), %rax
movq %rax, 0x3b6ab0(%rip) # 0x3fd448
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x469af
movq (%r14), %rax
callq *0x48(%rax)
movq $0x0, 0x50(%rbx)
leaq 0x10(%rbx), %rdi
callq 0x290c0
movq %rbx, %rdi
callq 0x9ffb6
movq 0x3b6a81(%rip), %rbx # 0x3fd448
testq %rbx, %rbx
jne 0x4698d
leaq 0x3b6a85(%rip), %rdi # 0x3fd458
callq 0xa5cfe
movq 0x3b6b81(%rip), %rdi # 0x3fd560
testq %rdi, %rdi
je 0x469fc
leaq 0x33f625(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x48(%rax)
movq $0x0, 0x3b6b64(%rip) # 0x3fd560
leaq 0x3b6b1d(%rip), %rdi # 0x3fd520
callq 0x290c0
movq 0x3b6761(%rip), %rdi # 0x3fd170
addq $0x8, %rdi
callq 0x9ffb6
movq $0x0, 0x3b674d(%rip) # 0x3fd170
popq %rbx
popq %r14
popq %rbp
retq
|
trnman_destroy:
cmp cs:short_trid_to_active_trn, 0
jz locret_46A27
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, cs:pool
test rbx, rbx
jz short loc_469CC
lea r14, PSI_server
loc_4698D:
mov rax, [rbx+68h]
mov cs:pool, rax
mov rdi, [rbx+50h]
test rdi, rdi
jz short loc_469AF
mov rax, [r14]
call qword ptr [rax+48h]
mov qword ptr [rbx+50h], 0
loc_469AF:
lea rdi, [rbx+10h]
call _pthread_mutex_destroy
mov rdi, rbx
call my_free
mov rbx, cs:pool
test rbx, rbx
jnz short loc_4698D
loc_469CC:
lea rdi, trid_to_trn
call lf_hash_destroy
mov rdi, cs:qword_3FD560
test rdi, rdi
jz short loc_469FC
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+48h]
mov cs:qword_3FD560, 0
loc_469FC:
lea rdi, LOCK_trn_list
call _pthread_mutex_destroy
mov rdi, cs:short_trid_to_active_trn
add rdi, 8
call my_free
mov cs:short_trid_to_active_trn, 0
pop rbx
pop r14
pop rbp
locret_46A27:
retn
|
long long trnman_destroy()
{
long long i; // rbx
long long result; // rax
if ( short_trid_to_active_trn )
{
for ( i = pool; pool; i = pool )
{
pool = *(_QWORD *)(i + 104);
if ( *(_QWORD *)(i + 80) )
{
PSI_server[9]();
*(_QWORD *)(i + 80) = 0LL;
}
pthread_mutex_destroy(i + 16);
my_free(i);
}
lf_hash_destroy(&trid_to_trn);
if ( qword_3FD560 )
{
PSI_server[9]();
qword_3FD560 = 0LL;
}
pthread_mutex_destroy(&LOCK_trn_list);
result = my_free(short_trid_to_active_trn + 8);
short_trid_to_active_trn = 0LL;
}
return result;
}
|
trnman_destroy:
CMP qword ptr [0x004fd170],0x0
JZ 0x00146a27
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,qword ptr [0x004fd448]
TEST RBX,RBX
JZ 0x001469cc
LEA R14,[0x486010]
LAB_0014698d:
MOV RAX,qword ptr [RBX + 0x68]
MOV qword ptr [0x004fd448],RAX
MOV RDI,qword ptr [RBX + 0x50]
TEST RDI,RDI
JZ 0x001469af
MOV RAX,qword ptr [R14]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [RBX + 0x50],0x0
LAB_001469af:
LEA RDI,[RBX + 0x10]
CALL 0x001290c0
MOV RDI,RBX
CALL 0x0019ffb6
MOV RBX,qword ptr [0x004fd448]
TEST RBX,RBX
JNZ 0x0014698d
LAB_001469cc:
LEA RDI,[0x4fd458]
CALL 0x001a5cfe
MOV RDI,qword ptr [0x004fd560]
TEST RDI,RDI
JZ 0x001469fc
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [0x004fd560],0x0
LAB_001469fc:
LEA RDI,[0x4fd520]
CALL 0x001290c0
MOV RDI,qword ptr [0x004fd170]
ADD RDI,0x8
CALL 0x0019ffb6
MOV qword ptr [0x004fd170],0x0
POP RBX
POP R14
POP RBP
LAB_00146a27:
RET
|
void trnman_destroy(void)
{
long lVar1;
if (short_trid_to_active_trn != 0) {
lVar1 = pool;
if (pool != 0) {
do {
pool = *(long *)(lVar1 + 0x68);
if (*(long *)(lVar1 + 0x50) != 0) {
(**(code **)(PSI_server + 0x48))();
*(int8 *)(lVar1 + 0x50) = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)(lVar1 + 0x10));
my_free(lVar1);
lVar1 = pool;
} while (pool != 0);
}
lf_hash_destroy(trid_to_trn);
if (LOCK_trn_list._64_8_ != 0) {
(**(code **)(PSI_server + 0x48))();
LOCK_trn_list._64_8_ = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)LOCK_trn_list);
my_free(short_trid_to_active_trn + 8);
short_trid_to_active_trn = 0;
}
return;
}
|
|
6,833 |
mp_sub_mul1_dec
|
bluesky950520[P]quickjs/libbf.c
|
limb_t mp_sub_mul1_dec(limb_t *tabr, const limb_t *taba, mp_size_t n,
limb_t b)
{
limb_t base = BF_DEC_BASE;
mp_size_t i;
limb_t l, t0, t1, r, a, v, c;
/* XXX: optimize */
l = 0;
for(i = 0; i < n; i++) {
muldq(t1, t0, taba[i], b);
adddq(t1, t0, 0, l);
divdq_base(l, r, t1, t0);
v = tabr[i];
a = v - r;
c = a > v;
if (c)
a += base;
/* never bigger than base because r = 0 when l = base - 1 */
l += c;
tabr[i] = a;
}
return l;
}
|
O1
|
c
|
mp_sub_mul1_dec:
testq %rdx, %rdx
jle 0x8db93
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r8
movabsq $-0x7538dcfb76180000, %r14 # imm = 0x8AC7230489E80000
xorl %r15d, %r15d
movabsq $-0x13e1b582496a9e5b, %r12 # imm = 0xEC1E4A7DB69561A5
movabsq $0x158e460913d00000, %r13 # imm = 0x158E460913D00000
xorl %r9d, %r9d
movq %rcx, %rax
mulq (%rsi,%r15,8)
movq %rdx, %r10
movq %rax, %r11
addq %r9, %r11
adcq $0x0, %r10
movq %r10, %rax
shldq $0x1, %r11, %rax
mulq %r12
movq %rdx, %rbx
movq %rdx, %rax
mulq %r14
subq %rax, %r11
sbbq %rdx, %r10
subq %r13, %r11
movq $-0x1, %r9
sbbq $0x0, %r9
leaq (%r10,%r9), %rax
sarq %rax
leaq (%rbx,%rax), %rdx
addq $0x2, %rdx
andq %r14, %rax
addq %r11, %rax
adcq %r10, %r9
movq %r9, %r10
andq %r14, %r10
addq %r10, %rax
movq (%rdi,%r15,8), %r10
subq %rax, %r10
leaq (%r10,%r14), %rax
cmovaeq %r10, %rax
adcq %rdx, %r9
movq %rax, (%rdi,%r15,8)
incq %r15
cmpq %r15, %r8
jne 0x8db0d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x8db96
xorl %r9d, %r9d
movq %r9, %rax
retq
|
mp_sub_mul1_dec:
test rdx, rdx
jle loc_8DB93
push r15
push r14
push r13
push r12
push rbx
mov r8, rdx
mov r14, 8AC7230489E80000h
xor r15d, r15d
mov r12, 0EC1E4A7DB69561A5h
mov r13, 158E460913D00000h
xor r9d, r9d
loc_8DB0D:
mov rax, rcx
mul qword ptr [rsi+r15*8]
mov r10, rdx
mov r11, rax
add r11, r9
adc r10, 0
mov rax, r10
shld rax, r11, 1
mul r12
mov rbx, rdx
mov rax, rdx
mul r14
sub r11, rax
sbb r10, rdx
sub r11, r13
mov r9, 0FFFFFFFFFFFFFFFFh
sbb r9, 0
lea rax, [r10+r9]
sar rax, 1
lea rdx, [rbx+rax]
add rdx, 2
and rax, r14
add rax, r11
adc r9, r10
mov r10, r9
and r10, r14
add rax, r10
mov r10, [rdi+r15*8]
sub r10, rax
lea rax, [r10+r14]
cmovnb rax, r10
adc r9, rdx
mov [rdi+r15*8], rax
inc r15
cmp r8, r15
jnz short loc_8DB0D
pop rbx
pop r12
pop r13
pop r14
pop r15
jmp short loc_8DB96
loc_8DB93:
xor r9d, r9d
loc_8DB96:
mov rax, r9
retn
|
long long mp_sub_mul1_dec(long long a1, long long a2, long long a3, unsigned long long a4)
{
long long v5; // r15
long long v6; // r9
signed __int128 v7; // kr00_16
unsigned long long v8; // rbx
unsigned long long v9; // r10
unsigned __int128 v10; // kr20_16
long long v11; // rax
long long v12; // rdx
long long v13; // r9
unsigned long long v14; // rax
unsigned long long v15; // r10
bool v16; // cf
unsigned long long v17; // r10
unsigned long long v18; // rax
if ( a3 <= 0 )
return 0LL;
v5 = 0LL;
v6 = 0LL;
do
{
v7 = (unsigned long long)v6 + *(unsigned long long *)(a2 + 8 * v5) * (unsigned __int128)a4;
v8 = (0xEC1E4A7DB69561A5LL * (unsigned __int128)(unsigned long long)(v7 >> 63)) >> 64;
v9 = (v7 - 0x8AC7230489E80000LL * (unsigned __int128)v8) >> 64;
v10 = __PAIR128__(-1LL, (unsigned long long)v7 - 0x8AC7230489E80000LL * v8) - 0x158E460913D00000LL;
v11 = (long long)(v9 + *((_QWORD *)&v10 + 1)) >> 1;
v12 = v8 + v11 + 2;
v13 = (v10 + __PAIR128__(v9, v11 & 0x8AC7230489E80000LL)) >> 64;
v14 = (v13 & 0x8AC7230489E80000LL) + v10 + (v11 & 0x8AC7230489E80000LL);
v15 = *(_QWORD *)(a1 + 8 * v5);
v16 = v15 < v14;
v17 = v15 - v14;
v18 = v17 - 0x7538DCFB76180000LL;
if ( !v16 )
v18 = v17;
v6 = v12 + v16 + v13;
*(_QWORD *)(a1 + 8 * v5++) = v18;
}
while ( a3 != v5 );
return v6;
}
| |||
6,834 |
mp_sub_mul1_dec
|
bluesky950520[P]quickjs/libbf.c
|
limb_t mp_sub_mul1_dec(limb_t *tabr, const limb_t *taba, mp_size_t n,
limb_t b)
{
limb_t base = BF_DEC_BASE;
mp_size_t i;
limb_t l, t0, t1, r, a, v, c;
/* XXX: optimize */
l = 0;
for(i = 0; i < n; i++) {
muldq(t1, t0, taba[i], b);
adddq(t1, t0, 0, l);
divdq_base(l, r, t1, t0);
v = tabr[i];
a = v - r;
c = a > v;
if (c)
a += base;
/* never bigger than base because r = 0 when l = base - 1 */
l += c;
tabr[i] = a;
}
return l;
}
|
O2
|
c
|
mp_sub_mul1_dec:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r8
movabsq $-0x7538dcfb76180000, %rbx # imm = 0x8AC7230489E80000
xorl %r9d, %r9d
testq %rdx, %rdx
cmovleq %r9, %r8
movabsq $-0x13e1b582496a9e5b, %r14 # imm = 0xEC1E4A7DB69561A5
movabsq $0x158e460913d00000, %r15 # imm = 0x158E460913D00000
movabsq $-0x1, %r12
xorl %r13d, %r13d
cmpq %r13, %r8
je 0x76616
movq %rcx, %rax
mulq (%rsi,%r13,8)
movq %rdx, %r10
addq %rax, %r9
adcq $0x0, %r10
movq %r10, %rax
shldq $0x1, %r9, %rax
mulq %r14
movq %rdx, %r11
movq %rdx, %rax
mulq %rbx
subq %rax, %r9
sbbq %rdx, %r10
subq %r15, %r9
movq %r12, %rax
sbbq $0x0, %rax
leaq (%r10,%rax), %rdx
sarq %rdx
addq %rdx, %r11
addq $0x2, %r11
andq %rbx, %rdx
addq %r9, %rdx
adcq %r10, %rax
movq %rax, %r9
andq %rbx, %r9
addq %r9, %rdx
movq (%rdi,%r13,8), %r9
subq %rdx, %r9
leaq (%r9,%rbx), %rdx
cmovaeq %r9, %rdx
adcq %r11, %rax
movq %rdx, (%rdi,%r13,8)
incq %r13
movq %rax, %r9
jmp 0x7659e
movq %r9, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
mp_sub_mul1_dec:
push r15
push r14
push r13
push r12
push rbx
mov r8, rdx
mov rbx, 8AC7230489E80000h
xor r9d, r9d
test rdx, rdx
cmovle r8, r9
mov r14, 0EC1E4A7DB69561A5h
mov r15, 158E460913D00000h
mov r12, 0FFFFFFFFFFFFFFFFh
xor r13d, r13d
loc_7659E:
cmp r8, r13
jz short loc_76616
mov rax, rcx
mul qword ptr [rsi+r13*8]
mov r10, rdx
add r9, rax
adc r10, 0
mov rax, r10
shld rax, r9, 1
mul r14
mov r11, rdx
mov rax, rdx
mul rbx
sub r9, rax
sbb r10, rdx
sub r9, r15
mov rax, r12
sbb rax, 0
lea rdx, [r10+rax]
sar rdx, 1
add r11, rdx
add r11, 2
and rdx, rbx
add rdx, r9
adc rax, r10
mov r9, rax
and r9, rbx
add rdx, r9
mov r9, [rdi+r13*8]
sub r9, rdx
lea rdx, [r9+rbx]
cmovnb rdx, r9
adc rax, r11
mov [rdi+r13*8], rdx
inc r13
mov r9, rax
jmp short loc_7659E
loc_76616:
mov rax, r9
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
long long mp_sub_mul1_dec(long long a1, long long a2, long long a3, unsigned long long a4)
{
long long v4; // r8
long long v5; // r9
long long i; // r13
signed __int128 v7; // kr00_16
unsigned long long v8; // r11
unsigned long long v9; // r10
unsigned __int128 v10; // kr20_16
long long v11; // rdx
long long v12; // r11
long long v13; // rax
unsigned long long v14; // rdx
unsigned long long v15; // r9
bool v16; // cf
unsigned long long v17; // r9
unsigned long long v18; // rdx
v4 = a3;
v5 = 0LL;
if ( a3 <= 0 )
v4 = 0LL;
for ( i = 0LL; v4 != i; ++i )
{
v7 = *(unsigned long long *)(a2 + 8 * i) * (unsigned __int128)a4 + (unsigned long long)v5;
v8 = (0xEC1E4A7DB69561A5LL * (unsigned __int128)(unsigned long long)(v7 >> 63)) >> 64;
v9 = (v7 - 0x8AC7230489E80000LL * (unsigned __int128)v8) >> 64;
v10 = __PAIR128__(-1LL, (unsigned long long)v7 - 0x8AC7230489E80000LL * v8) - 0x158E460913D00000LL;
v11 = (long long)(v9 + *((_QWORD *)&v10 + 1)) >> 1;
v12 = v11 + v8 + 2;
v13 = (v10 + __PAIR128__(v9, v11 & 0x8AC7230489E80000LL)) >> 64;
v14 = (v13 & 0x8AC7230489E80000LL) + v10 + (v11 & 0x8AC7230489E80000LL);
v15 = *(_QWORD *)(a1 + 8 * i);
v16 = v15 < v14;
v17 = v15 - v14;
v18 = v17 - 0x7538DCFB76180000LL;
if ( !v16 )
v18 = v17;
*(_QWORD *)(a1 + 8 * i) = v18;
v5 = v12 + v16 + v13;
}
return v5;
}
|
mp_sub_mul1_dec:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R8,RDX
MOV RBX,-0x7538dcfb76180000
XOR R9D,R9D
TEST RDX,RDX
CMOVLE R8,R9
MOV R14,-0x13e1b582496a9e5b
MOV R15,0x158e460913d00000
MOV R12,-0x1
XOR R13D,R13D
LAB_0017659e:
CMP R8,R13
JZ 0x00176616
MOV RAX,RCX
MUL qword ptr [RSI + R13*0x8]
MOV R10,RDX
ADD R9,RAX
ADC R10,0x0
MOV RAX,R10
SHLD RAX,R9,0x1
MUL R14
MOV R11,RDX
MOV RAX,RDX
MUL RBX
SUB R9,RAX
SBB R10,RDX
SUB R9,R15
MOV RAX,R12
SBB RAX,0x0
LEA RDX,[R10 + RAX*0x1]
SAR RDX,0x1
ADD R11,RDX
ADD R11,0x2
AND RDX,RBX
ADD RDX,R9
ADC RAX,R10
MOV R9,RAX
AND R9,RBX
ADD RDX,R9
MOV R9,qword ptr [RDI + R13*0x8]
SUB R9,RDX
LEA RDX,[R9 + RBX*0x1]
CMOVNC RDX,R9
ADC RAX,R11
MOV qword ptr [RDI + R13*0x8],RDX
INC R13
MOV R9,RAX
JMP 0x0017659e
LAB_00176616:
MOV RAX,R9
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
ulong mp_sub_mul1_dec(long param_1,long param_2,ulong param_3,ulong param_4)
{
int1 auVar1 [16];
int1 auVar2 [16];
int1 auVar3 [16];
int1 auVar4 [16];
int1 auVar5 [16];
long lVar6;
ulong uVar7;
ulong uVar8;
ulong uVar9;
ulong uVar10;
ulong uVar11;
long lVar12;
ulong uVar13;
uVar10 = 0;
if ((long)param_3 < 1) {
param_3 = uVar10;
}
for (uVar13 = 0; auVar5._8_8_ = 0, auVar5._0_8_ = uVar10, param_3 != uVar13; uVar13 = uVar13 + 1)
{
auVar1._8_8_ = 0;
auVar1._0_8_ = param_4;
auVar4._8_8_ = 0;
auVar4._0_8_ = *(ulong *)(param_2 + uVar13 * 8);
auVar5 = auVar1 * auVar4 + auVar5;
auVar2._8_8_ = 0;
auVar2._0_8_ = auVar5._8_8_ << 1 | auVar5._0_8_ >> 0x3f;
uVar8 = SUB168(auVar2 * ZEXT816(0xec1e4a7db69561a5),8);
auVar3._8_8_ = 0;
auVar3._0_8_ = uVar8;
auVar5 = auVar5 - auVar3 * ZEXT816(10000000000000000000);
uVar10 = auVar5._0_8_;
lVar12 = auVar5._8_8_;
uVar11 = uVar10 + 0xea71b9f6ec300000;
lVar6 = -1 - (ulong)(uVar10 < 0x158e460913d00000);
uVar9 = lVar12 + lVar6 >> 1;
uVar10 = uVar9 & 10000000000000000000;
uVar7 = lVar6 + lVar12 + (ulong)CARRY8(uVar10,uVar11);
uVar11 = uVar10 + uVar11 + (uVar7 & 10000000000000000000);
uVar10 = *(ulong *)(param_1 + uVar13 * 8);
lVar6 = (uVar10 - uVar11) + -0x7538dcfb76180000;
if (uVar10 >= uVar11) {
lVar6 = uVar10 - uVar11;
}
uVar10 = uVar7 + uVar8 + uVar9 + 2 + (ulong)(uVar10 < uVar11);
*(long *)(param_1 + uVar13 * 8) = lVar6;
}
return uVar10;
}
|
|
6,835 |
nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
monkey531[P]llama/common/json.hpp
|
T& operator[](const key_type& key)
{
return emplace(key, T{}).first->second;
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movb $0x0, (%r15)
movq $0x0, 0x8(%r15)
movq %r15, %rdi
movl $0x1, %esi
callq 0x5c5ee
movq %r15, %rdi
movl $0x1, %esi
callq 0x5c5ee
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x630ca
movq %rax, %rbx
addq $0x20, %rbx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x5c5ee
movq %r14, %rdi
callq 0x61a6a
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x5c5ee
movq %r14, %rdi
callq 0x61a6a
movq %rbx, %rdi
callq 0x1c250
nop
|
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEEixERSH_:
push r15
push r14
push rbx
sub rsp, 10h
mov rbx, rsi
mov r14, rdi
mov r15, rsp
mov byte ptr [r15], 0
mov qword ptr [r15+8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
mov rsi, rbx
mov rdx, r15
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE7emplaceERSH_OSD_; nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::emplace(std::string const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&&)
mov rbx, rax
add rbx, 20h ; ' '
mov r14, rsp
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rax, rbx
add rsp, 10h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov r14, rsp
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, rbx
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator[](
long long a1,
long long a2)
{
long long v2; // rbx
char v4[8]; // [rsp+0h] [rbp-28h] BYREF
long long v5; // [rsp+8h] [rbp-20h]
v4[0] = 0;
v5 = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v4);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v4);
v2 = nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::emplace(
a1,
a2,
v4)
+ 32;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v4);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v4);
return v2;
}
|
operator[]:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RSI
MOV R14,RDI
MOV R15,RSP
MOV byte ptr [R15],0x0
MOV qword ptr [R15 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x0015c5ee
MOV RDI,R15
MOV ESI,0x1
CALL 0x0015c5ee
LAB_00163036:
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R15
CALL 0x001630ca
LAB_00163044:
MOV RBX,RAX
ADD RBX,0x20
MOV R14,RSP
MOV RDI,R14
XOR ESI,ESI
CALL 0x0015c5ee
MOV RDI,R14
CALL 0x00161a6a
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::string,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > > >::operator[](std::__cxx11::string const&) */
long __thiscall
nlohmann::json_abi_v3_11_3::
ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::operator[](ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*this,string *param_1)
{
long lVar1;
bool bVar2;
basic_json local_28 [8];
int8 local_20;
local_28[0] = (basic_json)0x0;
local_20 = 0;
bVar2 = SUB81(local_28,0);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar2);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar2);
/* try { // try from 00163036 to 00163043 has its CatchHandler @ 0016306d */
lVar1 = emplace(this,param_1,local_28);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar2);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_28);
return lVar1 + 0x20;
}
|
|
6,836 |
my_charset_get_by_name
|
eloqsql/mysys/charset.c
|
CHARSET_INFO *
my_charset_get_by_name(MY_CHARSET_LOADER *loader,
const char *cs_name, uint cs_flags, myf flags)
{
uint cs_number;
CHARSET_INFO *cs;
DBUG_ENTER("get_charset_by_csname");
DBUG_PRINT("enter",("name: '%s'", cs_name));
my_pthread_once(&charsets_initialized, init_available_charsets);
cs_number= get_charset_number(cs_name, cs_flags, flags);
cs= cs_number ? get_internal_charset(loader, cs_number, flags) : NULL;
if (!cs && (flags & MY_WME))
{
char index_file[FN_REFLEN + sizeof(MY_CHARSET_INDEX)];
strmov(get_charsets_dir(index_file),MY_CHARSET_INDEX);
my_error(EE_UNKNOWN_CHARSET, MYF(ME_BELL), cs_name, index_file);
}
DBUG_RETURN(cs);
}
|
O0
|
c
|
my_charset_get_by_name:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp # imm = 0x260
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x228(%rbp)
movq %rsi, -0x230(%rbp)
movl %edx, -0x234(%rbp)
movq %rcx, -0x240(%rbp)
jmp 0x6f9a5
leaq 0x383a28(%rip), %rdi # 0x3f33d4
leaq -0xae3(%rip), %rsi # 0x6eed0
callq 0x36280
movq -0x230(%rbp), %rdi
movl -0x234(%rbp), %esi
movq -0x240(%rbp), %rdx
callq 0x6f190
movl %eax, -0x244(%rbp)
cmpl $0x0, -0x244(%rbp)
je 0x6fa02
movq -0x228(%rbp), %rdi
movl -0x244(%rbp), %esi
movq -0x240(%rbp), %rdx
callq 0x6f520
movq %rax, -0x258(%rbp)
jmp 0x6fa0d
xorl %eax, %eax
movq %rax, -0x258(%rbp)
jmp 0x6fa0d
movq -0x258(%rbp), %rax
movq %rax, -0x250(%rbp)
cmpq $0x0, -0x250(%rbp)
jne 0x6fa70
movq -0x240(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0x6fa70
leaq -0x220(%rbp), %rdi
callq 0x6eb90
movq %rax, %rdi
leaq 0x5d635(%rip), %rsi # 0xcd081
callq 0x36970
movq -0x230(%rbp), %rdx
leaq -0x220(%rbp), %rcx
movl $0x16, %edi
movl $0x4, %esi
movb $0x0, %al
callq 0x77200
jmp 0x6fa72
movq -0x250(%rbp), %rax
movq %rax, -0x260(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x6faa2
movq -0x260(%rbp), %rax
addq $0x260, %rsp # imm = 0x260
popq %rbp
retq
callq 0x362a0
nopw (%rax,%rax)
|
my_charset_get_by_name:
push rbp
mov rbp, rsp
sub rsp, 260h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_228], rdi
mov [rbp+var_230], rsi
mov [rbp+var_234], edx
mov [rbp+var_240], rcx
jmp short $+2
loc_6F9A5:
lea rdi, charsets_initialized
lea rsi, init_available_charsets
call _pthread_once
mov rdi, [rbp+var_230]
mov esi, [rbp+var_234]
mov rdx, [rbp+var_240]
call get_charset_number
mov [rbp+var_244], eax
cmp [rbp+var_244], 0
jz short loc_6FA02
mov rdi, [rbp+var_228]
mov esi, [rbp+var_244]
mov rdx, [rbp+var_240]
call get_internal_charset
mov [rbp+var_258], rax
jmp short loc_6FA0D
loc_6FA02:
xor eax, eax
mov [rbp+var_258], rax
jmp short $+2
loc_6FA0D:
mov rax, [rbp+var_258]
mov [rbp+var_250], rax
cmp [rbp+var_250], 0
jnz short loc_6FA70
mov rax, [rbp+var_240]
and rax, 10h
cmp rax, 0
jz short loc_6FA70
lea rdi, [rbp+var_220]
call get_charsets_dir
mov rdi, rax
lea rsi, aIndexXml; "Index.xml"
call _stpcpy
mov rdx, [rbp+var_230]
lea rcx, [rbp+var_220]
mov edi, 16h
mov esi, 4
mov al, 0
call my_error
loc_6FA70:
jmp short $+2
loc_6FA72:
mov rax, [rbp+var_250]
mov [rbp+var_260], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_6FAA2
mov rax, [rbp+var_260]
add rsp, 260h
pop rbp
retn
loc_6FAA2:
call ___stack_chk_fail
|
long long my_charset_get_by_name(long long a1, long long a2, unsigned int a3, long long a4)
{
long long charsets_dir; // rax
int v5; // r8d
int v6; // r9d
long long internal_charset; // [rsp+8h] [rbp-258h]
unsigned int charset_number; // [rsp+1Ch] [rbp-244h]
_BYTE v12[536]; // [rsp+40h] [rbp-220h] BYREF
unsigned long long v13; // [rsp+258h] [rbp-8h]
v13 = __readfsqword(0x28u);
pthread_once(&charsets_initialized, init_available_charsets);
charset_number = get_charset_number(a2, a3, a4);
if ( charset_number )
internal_charset = get_internal_charset(a1, charset_number, a4);
else
internal_charset = 0LL;
if ( !internal_charset && (a4 & 0x10) != 0 )
{
charsets_dir = get_charsets_dir((long long)v12);
stpcpy(charsets_dir, "Index.xml");
my_error(22, 4, a2, (unsigned int)v12, v5, v6);
}
return internal_charset;
}
|
my_charset_get_by_name:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x260
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x228],RDI
MOV qword ptr [RBP + -0x230],RSI
MOV dword ptr [RBP + -0x234],EDX
MOV qword ptr [RBP + -0x240],RCX
JMP 0x0016f9a5
LAB_0016f9a5:
LEA RDI,[0x4f33d4]
LEA RSI,[0x16eed0]
CALL 0x00136280
MOV RDI,qword ptr [RBP + -0x230]
MOV ESI,dword ptr [RBP + -0x234]
MOV RDX,qword ptr [RBP + -0x240]
CALL 0x0016f190
MOV dword ptr [RBP + -0x244],EAX
CMP dword ptr [RBP + -0x244],0x0
JZ 0x0016fa02
MOV RDI,qword ptr [RBP + -0x228]
MOV ESI,dword ptr [RBP + -0x244]
MOV RDX,qword ptr [RBP + -0x240]
CALL 0x0016f520
MOV qword ptr [RBP + -0x258],RAX
JMP 0x0016fa0d
LAB_0016fa02:
XOR EAX,EAX
MOV qword ptr [RBP + -0x258],RAX
JMP 0x0016fa0d
LAB_0016fa0d:
MOV RAX,qword ptr [RBP + -0x258]
MOV qword ptr [RBP + -0x250],RAX
CMP qword ptr [RBP + -0x250],0x0
JNZ 0x0016fa70
MOV RAX,qword ptr [RBP + -0x240]
AND RAX,0x10
CMP RAX,0x0
JZ 0x0016fa70
LEA RDI,[RBP + -0x220]
CALL 0x0016eb90
MOV RDI,RAX
LEA RSI,[0x1cd081]
CALL 0x00136970
MOV RDX,qword ptr [RBP + -0x230]
LEA RCX,[RBP + -0x220]
MOV EDI,0x16
MOV ESI,0x4
MOV AL,0x0
CALL 0x00177200
LAB_0016fa70:
JMP 0x0016fa72
LAB_0016fa72:
MOV RAX,qword ptr [RBP + -0x250]
MOV qword ptr [RBP + -0x260],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0016faa2
MOV RAX,qword ptr [RBP + -0x260]
ADD RSP,0x260
POP RBP
RET
LAB_0016faa2:
CALL 0x001362a0
|
long my_charset_get_by_name(int8 param_1,int8 param_2,int4 param_3,ulong param_4)
{
int iVar1;
char *__dest;
long in_FS_OFFSET;
long local_260;
int1 local_228 [536];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pthread_once(&charsets_initialized,init_available_charsets);
iVar1 = get_charset_number(param_2,param_3,param_4);
if (iVar1 == 0) {
local_260 = 0;
}
else {
local_260 = get_internal_charset(param_1,iVar1,param_4);
}
if ((local_260 == 0) && ((param_4 & 0x10) != 0)) {
__dest = (char *)get_charsets_dir(local_228);
stpcpy(__dest,"Index.xml");
my_error(0x16,4,param_2,local_228);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_260;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
6,837 |
mi_read_mempack_record
|
eloqsql/storage/myisam/mi_packrec.c
|
static int _mi_read_mempack_record(MI_INFO *info, my_off_t filepos, uchar *buf)
{
MI_BLOCK_INFO block_info;
MYISAM_SHARE *share=info->s;
uchar *pos;
DBUG_ENTER("mi_read_mempack_record");
if (filepos == HA_OFFSET_ERROR)
DBUG_RETURN(-1); /* _search() didn't find record */
if (!(pos= (uchar*) _mi_mempack_get_block_info(info, &info->bit_buff,
&block_info, &info->rec_buff,
(uchar*) share->file_map+
filepos)))
DBUG_RETURN(-1);
/* No need to end-zero pos here for valgrind as data is memory mapped */
DBUG_RETURN(_mi_pack_rec_unpack(info, &info->bit_buff, buf,
pos, block_info.rec_len));
}
|
O3
|
c
|
mi_read_mempack_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
cmpq $-0x1, %rsi
je 0x88fa1
movq %rdx, %rbx
movq %rsi, %r8
movq %rdi, %r14
movq (%rdi), %rax
leaq 0x50(%rdi), %r15
leaq 0x120(%rdi), %rcx
addq 0x270(%rax), %r8
leaq -0x78(%rbp), %rdx
movq %r15, %rsi
callq 0x8a9ca
testq %rax, %rax
je 0x88fa1
movq -0x60(%rbp), %r8
movq %fs:0x28, %rcx
cmpq -0x20(%rbp), %rcx
jne 0x88fc0
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %rax, %rcx
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x88a23
movq %fs:0x28, %rax
cmpq -0x20(%rbp), %rax
jne 0x88fc0
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2a250
|
_mi_read_mempack_record:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 68h
mov rax, fs:28h
mov [rbp+var_20], rax
cmp rsi, 0FFFFFFFFFFFFFFFFh
jz short loc_88FA1
mov rbx, rdx
mov r8, rsi
mov r14, rdi
mov rax, [rdi]
lea r15, [rdi+50h]
lea rcx, [rdi+120h]
add r8, [rax+270h]
lea rdx, [rbp+var_78]
mov rsi, r15
call _mi_mempack_get_block_info
test rax, rax
jz short loc_88FA1
mov r8, [rbp+var_60]
mov rcx, fs:28h
cmp rcx, [rbp+var_20]
jnz short loc_88FC0
mov rdi, r14
mov rsi, r15
mov rdx, rbx
mov rcx, rax
add rsp, 68h
pop rbx
pop r14
pop r15
pop rbp
jmp _mi_pack_rec_unpack
loc_88FA1:
mov rax, fs:28h
cmp rax, [rbp+var_20]
jnz short loc_88FC0
mov eax, 0FFFFFFFFh
add rsp, 68h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_88FC0:
call ___stack_chk_fail
|
long long mi_read_mempack_record(_QWORD *a1, long long a2, long long a3)
{
long long block_info; // rax
_BYTE v6[24]; // [rsp+8h] [rbp-78h] BYREF
long long v7; // [rsp+20h] [rbp-60h]
unsigned long long v8; // [rsp+60h] [rbp-20h]
v8 = __readfsqword(0x28u);
if ( a2 == -1 )
return 0xFFFFFFFFLL;
block_info = mi_mempack_get_block_info(a1, a1 + 10, v6, a1 + 36, *(_QWORD *)(*a1 + 624LL) + a2);
if ( !block_info )
return 0xFFFFFFFFLL;
else
return mi_pack_rec_unpack(a1, (long long)(a1 + 10), a3, block_info, v7);
}
|
_mi_read_mempack_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
CMP RSI,-0x1
JZ 0x00188fa1
MOV RBX,RDX
MOV R8,RSI
MOV R14,RDI
MOV RAX,qword ptr [RDI]
LEA R15,[RDI + 0x50]
LEA RCX,[RDI + 0x120]
ADD R8,qword ptr [RAX + 0x270]
LEA RDX,[RBP + -0x78]
MOV RSI,R15
CALL 0x0018a9ca
TEST RAX,RAX
JZ 0x00188fa1
MOV R8,qword ptr [RBP + -0x60]
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x20]
JNZ 0x00188fc0
MOV RDI,R14
MOV RSI,R15
MOV RDX,RBX
MOV RCX,RAX
ADD RSP,0x68
POP RBX
POP R14
POP R15
POP RBP
JMP 0x00188a23
LAB_00188fa1:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x00188fc0
MOV EAX,0xffffffff
ADD RSP,0x68
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00188fc0:
CALL 0x0012a250
|
int8 _mi_read_mempack_record(long *param_1,long param_2,int8 param_3)
{
long lVar1;
int8 uVar2;
long in_FS_OFFSET;
int1 local_80 [24];
int8 local_68;
long local_28;
local_28 = *(long *)(in_FS_OFFSET + 0x28);
if (param_2 != -1) {
lVar1 = _mi_mempack_get_block_info
(param_1,param_1 + 10,local_80,param_1 + 0x24,
param_2 + *(long *)(*param_1 + 0x270));
if (lVar1 != 0) {
if (*(long *)(in_FS_OFFSET + 0x28) == local_28) {
uVar2 = _mi_pack_rec_unpack(param_1,param_1 + 10,param_3,lVar1,local_68);
return uVar2;
}
goto LAB_00188fc0;
}
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_28) {
return 0xffffffff;
}
LAB_00188fc0:
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
6,838 |
my_uca_context_weight_find
|
eloqsql/strings/ctype-uca.c
|
static inline const MY_CONTRACTION *
my_uca_context_weight_find(my_uca_scanner *scanner, my_wc_t *wc,
size_t max_char_length)
{
const MY_CONTRACTION *cnt;
DBUG_ASSERT(scanner->level->contractions.nitems);
/*
If we have scanned a character which can have previous context,
and there were some more characters already before,
then reconstruct codepoint of the previous character
from "page" and "code" into w[1], and verify that {wc[1], wc[0]}
together form a real previous context pair.
Note, we support only 2-character long sequences with previous
context at the moment. CLDR does not have longer sequences.
*/
if (my_uca_can_be_previous_context_tail(&scanner->level->contractions,
wc[0]) &&
scanner->wbeg != nochar && /* if not the very first character */
my_uca_can_be_previous_context_head(&scanner->level->contractions,
(wc[1]= ((scanner->page << 8) +
scanner->code))) &&
(cnt= my_uca_previous_context_find(scanner, wc[1], wc[0])))
{
scanner->page= scanner->code= 0; /* Clear for the next character */
return cnt;
}
else if (my_uca_can_be_contraction_head(&scanner->level->contractions,
wc[0]))
{
/* Check if w[0] starts a contraction */
if ((cnt= my_uca_scanner_contraction_find(scanner, wc, max_char_length)))
return cnt;
}
return NULL;
}
|
O3
|
c
|
my_uca_context_weight_find:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, -0x30(%rbp)
movq %rsi, %r14
movq 0x18(%rdi), %rcx
movq (%rsi), %rdx
movq 0x28(%rcx), %rsi
movl %edx, %eax
andl $0xfff, %eax # imm = 0xFFF
cmpb $0x0, (%rsi,%rax)
js 0xbead4
movq 0x28(%rcx), %rcx
testb $0x1, (%rcx,%rax)
je 0xbec20
movq %rdi, -0x40(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
cmpq $0x2, -0x30(%rbp)
jb 0xbec20
movq -0x40(%rbp), %r13
movq 0x8(%r13), %r12
movb $0x4, %r15b
movl $0x1, %edx
movl $0x8, %ebx
movq %rdx, -0x38(%rbp)
movq 0x10(%r13), %rcx
movq 0x30(%r13), %rdi
movq 0xb8(%rdi), %rax
leaq (%r14,%rbx), %rsi
movq %r12, %rdx
callq *0x28(%rax)
testl %eax, %eax
jle 0xbeb54
movl %eax, %eax
addq %rax, %r12
movq -0x38(%rbp), %rdx
movq %r12, -0x80(%rbp,%rdx,8)
movq 0x18(%r13), %rcx
movq (%r14,%rdx,8), %rax
movq 0x28(%rcx), %rsi
andl $0xfff, %eax # imm = 0xFFF
testb %r15b, (%rsi,%rax)
je 0xbeb70
incq %rdx
addb %r15b, %r15b
addq $0x8, %rbx
cmpq %rdx, -0x30(%rbp)
jne 0xbea6d
movq -0x30(%rbp), %rdx
jmp 0xbeb58
leaq 0x218c15(%rip), %rsi # 0x2d76f0
cmpq %rsi, (%rdi)
je 0xbea2c
movl 0x24(%rdi), %esi
shll $0x8, %esi
movslq 0x28(%rdi), %r8
movslq %esi, %rsi
addq %r8, %rsi
movq %rsi, 0x8(%r14)
movq 0x28(%rcx), %rcx
movl %esi, %r8d
andl $0xfff, %r8d # imm = 0xFFF
testb $0x40, (%rcx,%r8)
movq 0x18(%rdi), %rcx
je 0xbea2c
movq 0x18(%rcx), %r8
testq %r8, %r8
jle 0xbea2c
movq 0x20(%rcx), %r12
imulq $0x58, %r8, %r8
addq %r12, %r8
cmpb $0x0, 0x52(%r12)
je 0xbeb46
cmpq %rsi, (%r12)
jne 0xbeb46
cmpq %rdx, 0x8(%r12)
je 0xbec4c
addq $0x58, %r12
cmpq %r8, %r12
jb 0xbeb2d
jmp 0xbea2c
movq -0x38(%rbp), %rdx
cmpq $0x2, %rdx
jb 0xbec20
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rcx
movq 0x28(%rcx), %rsi
jmp 0xbeb73
incq %rdx
leaq (,%rdx,8), %rdi
movq %rsi, -0x48(%rbp)
movq %rdx, %r8
decq %rdx
movq -0x8(%r14,%r8,8), %rax
andl $0xfff, %eax # imm = 0xFFF
testb $0x2, (%rsi,%rax)
je 0xbec0e
movq 0x18(%rcx), %rax
testq %rax, %rax
jle 0xbec0e
movq 0x20(%rcx), %r12
imulq $0x58, %rax, %rax
addq %r12, %rax
leaq (,%r8,8), %rsi
movq %rsi, -0x50(%rbp)
movq %rdi, -0x38(%rbp)
movq %rax, -0x30(%rbp)
cmpq $0x5, %r8
ja 0xbebca
cmpq $0x0, (%r12,%rdi)
jne 0xbec05
cmpb $0x0, 0x52(%r12)
jne 0xbec05
movq %r12, %rdi
movq %r14, %rsi
movq %rdx, %r15
movq -0x50(%rbp), %rdx
movq %r14, %r13
movq %rcx, %rbx
movq %r8, %r14
callq 0x29560
movq %r14, %r8
movq -0x38(%rbp), %rdi
movq %rbx, %rcx
movq %r15, %rdx
movq %r13, %r14
testl %eax, %eax
movq -0x30(%rbp), %rax
je 0xbec35
addq $0x58, %r12
cmpq %rax, %r12
jb 0xbebbd
addq $-0x8, %rdi
cmpq $0x1, %rdx
movq -0x48(%rbp), %rsi
ja 0xbeb7f
xorl %r12d, %r12d
movq %r12, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x32(%r12), %rax
movq -0x40(%rbp), %rcx
movq %rax, (%rcx)
movq -0x80(%rbp,%rdx,8), %rax
movq %rax, 0x8(%rcx)
jmp 0xbec23
leaq 0x32(%r12), %rax
movq %rax, (%rdi)
movq $0x0, 0x24(%rdi)
jmp 0xbec23
|
my_uca_context_weight_find:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov [rbp+var_30], rdx
mov r14, rsi
mov rcx, [rdi+18h]
mov rdx, [rsi]
mov rsi, [rcx+28h]
mov eax, edx
and eax, 0FFFh
cmp byte ptr [rsi+rax], 0
js loc_BEAD4
loc_BEA2C:
mov rcx, [rcx+28h]
test byte ptr [rcx+rax], 1
jz loc_BEC20
mov [rbp+var_40], rdi
xorps xmm0, xmm0
movaps [rbp+var_60], xmm0
movaps [rbp+var_70], xmm0
movaps [rbp+var_80], xmm0
cmp [rbp+var_30], 2
jb loc_BEC20
mov r13, [rbp+var_40]
mov r12, [r13+8]
mov r15b, 4
mov edx, 1
mov ebx, 8
loc_BEA6D:
mov [rbp+var_38], rdx
mov rcx, [r13+10h]
mov rdi, [r13+30h]
mov rax, [rdi+0B8h]
lea rsi, [r14+rbx]
mov rdx, r12
call qword ptr [rax+28h]
test eax, eax
jle loc_BEB54
mov eax, eax
add r12, rax
mov rdx, [rbp+var_38]
mov qword ptr [rbp+rdx*8+var_80], r12
mov rcx, [r13+18h]
mov rax, [r14+rdx*8]
mov rsi, [rcx+28h]
and eax, 0FFFh
test [rsi+rax], r15b
jz loc_BEB70
inc rdx
add r15b, r15b
add rbx, 8
cmp [rbp+var_30], rdx
jnz short loc_BEA6D
mov rdx, [rbp+var_30]
jmp loc_BEB58
loc_BEAD4:
lea rsi, nochar
cmp [rdi], rsi
jz loc_BEA2C
mov esi, [rdi+24h]
shl esi, 8
movsxd r8, dword ptr [rdi+28h]
movsxd rsi, esi
add rsi, r8
mov [r14+8], rsi
mov rcx, [rcx+28h]
mov r8d, esi
and r8d, 0FFFh
test byte ptr [rcx+r8], 40h
mov rcx, [rdi+18h]
jz loc_BEA2C
mov r8, [rcx+18h]
test r8, r8
jle loc_BEA2C
mov r12, [rcx+20h]
imul r8, 58h ; 'X'
add r8, r12
loc_BEB2D:
cmp byte ptr [r12+52h], 0
jz short loc_BEB46
cmp [r12], rsi
jnz short loc_BEB46
cmp [r12+8], rdx
jz loc_BEC4C
loc_BEB46:
add r12, 58h ; 'X'
cmp r12, r8
jb short loc_BEB2D
jmp loc_BEA2C
loc_BEB54:
mov rdx, [rbp+var_38]
loc_BEB58:
cmp rdx, 2
jb loc_BEC20
mov rax, [rbp+var_40]
mov rcx, [rax+18h]
mov rsi, [rcx+28h]
jmp short loc_BEB73
loc_BEB70:
inc rdx
loc_BEB73:
lea rdi, ds:0[rdx*8]
mov [rbp+var_48], rsi
loc_BEB7F:
mov r8, rdx
dec rdx
mov rax, [r14+r8*8-8]
and eax, 0FFFh
test byte ptr [rsi+rax], 2
jz short loc_BEC0E
mov rax, [rcx+18h]
test rax, rax
jle short loc_BEC0E
mov r12, [rcx+20h]
imul rax, 58h ; 'X'
add rax, r12
lea rsi, ds:0[r8*8]
mov [rbp+var_50], rsi
mov [rbp+var_38], rdi
mov [rbp+var_30], rax
loc_BEBBD:
cmp r8, 5
ja short loc_BEBCA
cmp qword ptr [r12+rdi], 0
jnz short loc_BEC05
loc_BEBCA:
cmp byte ptr [r12+52h], 0
jnz short loc_BEC05
mov rdi, r12
mov rsi, r14
mov r15, rdx
mov rdx, [rbp+var_50]
mov r13, r14
mov rbx, rcx
mov r14, r8
call _bcmp
mov r8, r14
mov rdi, [rbp+var_38]
mov rcx, rbx
mov rdx, r15
mov r14, r13
test eax, eax
mov rax, [rbp+var_30]
jz short loc_BEC35
loc_BEC05:
add r12, 58h ; 'X'
cmp r12, rax
jb short loc_BEBBD
loc_BEC0E:
add rdi, 0FFFFFFFFFFFFFFF8h
cmp rdx, 1
mov rsi, [rbp+var_48]
ja loc_BEB7F
loc_BEC20:
xor r12d, r12d
loc_BEC23:
mov rax, r12
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_BEC35:
lea rax, [r12+32h]
mov rcx, [rbp+var_40]
mov [rcx], rax
mov rax, qword ptr [rbp+rdx*8+var_80]
mov [rcx+8], rax
jmp short loc_BEC23
loc_BEC4C:
lea rax, [r12+32h]
mov [rdi], rax
mov qword ptr [rdi+24h], 0
jmp short loc_BEC23
|
unsigned long long my_uca_context_weight_find(
long long a1,
_QWORD *a2,
unsigned long long a3,
long long a4,
long long a5,
long long a6)
{
_QWORD *v6; // r14
_QWORD *v7; // rcx
long long v8; // rdx
long long v9; // rax
_QWORD *v10; // r13
long long v11; // r12
char v12; // r15
long long v13; // rdx
long long v14; // rbx
int v15; // eax
long long v16; // rdx
_QWORD *v17; // rcx
long long v18; // rsi
unsigned long long v19; // rdx
long long v20; // rsi
bool v21; // zf
unsigned long long v22; // r12
long long v23; // rdi
unsigned long long v24; // r8
long long v25; // rax
unsigned long long v26; // rax
_QWORD *v27; // rsi
unsigned long long v28; // r15
_QWORD *v29; // r13
_QWORD *v30; // rbx
unsigned long long v31; // r14
int v32; // eax
_QWORD *v34; // rcx
__int128 v35; // [rsp+0h] [rbp-80h]
__int128 v36; // [rsp+10h] [rbp-70h]
__int128 v37; // [rsp+20h] [rbp-60h]
long long v38; // [rsp+30h] [rbp-50h]
long long v39; // [rsp+38h] [rbp-48h]
_QWORD *v40; // [rsp+40h] [rbp-40h]
long long v41; // [rsp+48h] [rbp-38h]
unsigned long long v42; // [rsp+50h] [rbp-30h]
v42 = a3;
v6 = a2;
v7 = *(_QWORD **)(a1 + 24);
v8 = *a2;
v9 = *a2 & 0xFFFLL;
if ( *(char *)(v7[5] + v9) >= 0
|| *(_UNKNOWN **)a1 == &nochar
|| (v20 = *(int *)(a1 + 40) + (long long)(int)(*(_DWORD *)(a1 + 36) << 8),
v6[1] = v20,
a5 = v20 & 0xFFF,
v21 = (*(_BYTE *)(v7[5] + a5) & 0x40) == 0,
v7 = *(_QWORD **)(a1 + 24),
v21)
|| (a5 = v7[3], a5 <= 0) )
{
LABEL_2:
if ( (*(_BYTE *)(v7[5] + v9) & 1) != 0 && (v40 = (_QWORD *)a1, v37 = 0LL, v36 = 0LL, v35 = 0LL, v42 >= 2) )
{
v10 = v40;
v11 = v40[1];
v12 = 4;
v13 = 1LL;
v14 = 1LL;
while ( 1 )
{
v41 = v13;
v15 = (*(long long ( **)(_QWORD, _QWORD *, long long, _QWORD, long long, long long, _QWORD, _QWORD, _QWORD, _QWORD, _QWORD, _QWORD))(*(_QWORD *)(v10[6] + 184LL) + 40LL))(
v10[6],
&v6[v14],
v11,
v10[2],
a5,
a6,
v35,
*((_QWORD *)&v35 + 1),
v36,
*((_QWORD *)&v36 + 1),
v37,
*((_QWORD *)&v37 + 1));
if ( v15 <= 0 )
break;
v11 += (unsigned int)v15;
v16 = v41;
*((_QWORD *)&v35 + v41) = v11;
v17 = (_QWORD *)v10[3];
v18 = v17[5];
if ( ((unsigned __int8)v12 & *(_BYTE *)(v18 + (v6[v16] & 0xFFFLL))) == 0 )
{
v19 = v16 + 1;
goto LABEL_22;
}
v13 = v16 + 1;
v12 *= 2;
++v14;
if ( v42 == v13 )
{
v19 = v42;
goto LABEL_19;
}
}
v19 = v41;
LABEL_19:
if ( v19 < 2 )
return 0LL;
v17 = (_QWORD *)v40[3];
v18 = v17[5];
LABEL_22:
v23 = 8 * v19;
v39 = v18;
while ( 1 )
{
v24 = v19--;
if ( (*(_BYTE *)(v18 + (v6[v24 - 1] & 0xFFFLL)) & 2) != 0 )
{
v25 = v17[3];
if ( v25 > 0 )
break;
}
LABEL_31:
v23 -= 8LL;
v18 = v39;
if ( v19 <= 1 )
return 0LL;
}
v22 = v17[4];
v26 = v22 + 88 * v25;
v38 = 8 * v24;
v41 = v23;
v42 = v26;
while ( 1 )
{
if ( (v24 > 5 || !*(_QWORD *)(v22 + v23)) && !*(_BYTE *)(v22 + 82) )
{
v27 = v6;
v28 = v19;
v29 = v6;
v30 = v17;
v31 = v24;
v32 = bcmp(v22, v27, v38);
v24 = v31;
v23 = v41;
v17 = v30;
v19 = v28;
v6 = v29;
v21 = v32 == 0;
v26 = v42;
if ( v21 )
break;
}
v22 += 88LL;
if ( v22 >= v26 )
goto LABEL_31;
}
v34 = v40;
*v40 = v22 + 50;
v34[1] = *((_QWORD *)&v35 + v28);
}
else
{
return 0LL;
}
}
else
{
v22 = v7[4];
a5 = v22 + 88 * a5;
while ( !*(_BYTE *)(v22 + 82) || *(_QWORD *)v22 != v20 || *(_QWORD *)(v22 + 8) != v8 )
{
v22 += 88LL;
if ( v22 >= a5 )
goto LABEL_2;
}
*(_QWORD *)a1 = v22 + 50;
*(_QWORD *)(a1 + 36) = 0LL;
}
return v22;
}
|
my_uca_context_weight_find:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x30],RDX
MOV R14,RSI
MOV RCX,qword ptr [RDI + 0x18]
MOV RDX,qword ptr [RSI]
MOV RSI,qword ptr [RCX + 0x28]
MOV EAX,EDX
AND EAX,0xfff
CMP byte ptr [RSI + RAX*0x1],0x0
JS 0x001bead4
LAB_001bea2c:
MOV RCX,qword ptr [RCX + 0x28]
TEST byte ptr [RCX + RAX*0x1],0x1
JZ 0x001bec20
MOV qword ptr [RBP + -0x40],RDI
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x60],XMM0
MOVAPS xmmword ptr [RBP + -0x70],XMM0
MOVAPS xmmword ptr [RBP + -0x80],XMM0
CMP qword ptr [RBP + -0x30],0x2
JC 0x001bec20
MOV R13,qword ptr [RBP + -0x40]
MOV R12,qword ptr [R13 + 0x8]
MOV R15B,0x4
MOV EDX,0x1
MOV EBX,0x8
LAB_001bea6d:
MOV qword ptr [RBP + -0x38],RDX
MOV RCX,qword ptr [R13 + 0x10]
MOV RDI,qword ptr [R13 + 0x30]
MOV RAX,qword ptr [RDI + 0xb8]
LEA RSI,[R14 + RBX*0x1]
MOV RDX,R12
CALL qword ptr [RAX + 0x28]
TEST EAX,EAX
JLE 0x001beb54
MOV EAX,EAX
ADD R12,RAX
MOV RDX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + RDX*0x8 + -0x80],R12
MOV RCX,qword ptr [R13 + 0x18]
MOV RAX,qword ptr [R14 + RDX*0x8]
MOV RSI,qword ptr [RCX + 0x28]
AND EAX,0xfff
TEST byte ptr [RSI + RAX*0x1],R15B
JZ 0x001beb70
INC RDX
ADD R15B,R15B
ADD RBX,0x8
CMP qword ptr [RBP + -0x30],RDX
JNZ 0x001bea6d
MOV RDX,qword ptr [RBP + -0x30]
JMP 0x001beb58
LAB_001bead4:
LEA RSI,[0x3d76f0]
CMP qword ptr [RDI],RSI
JZ 0x001bea2c
MOV ESI,dword ptr [RDI + 0x24]
SHL ESI,0x8
MOVSXD R8,dword ptr [RDI + 0x28]
MOVSXD RSI,ESI
ADD RSI,R8
MOV qword ptr [R14 + 0x8],RSI
MOV RCX,qword ptr [RCX + 0x28]
MOV R8D,ESI
AND R8D,0xfff
TEST byte ptr [RCX + R8*0x1],0x40
MOV RCX,qword ptr [RDI + 0x18]
JZ 0x001bea2c
MOV R8,qword ptr [RCX + 0x18]
TEST R8,R8
JLE 0x001bea2c
MOV R12,qword ptr [RCX + 0x20]
IMUL R8,R8,0x58
ADD R8,R12
LAB_001beb2d:
CMP byte ptr [R12 + 0x52],0x0
JZ 0x001beb46
CMP qword ptr [R12],RSI
JNZ 0x001beb46
CMP qword ptr [R12 + 0x8],RDX
JZ 0x001bec4c
LAB_001beb46:
ADD R12,0x58
CMP R12,R8
JC 0x001beb2d
JMP 0x001bea2c
LAB_001beb54:
MOV RDX,qword ptr [RBP + -0x38]
LAB_001beb58:
CMP RDX,0x2
JC 0x001bec20
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RAX + 0x18]
MOV RSI,qword ptr [RCX + 0x28]
JMP 0x001beb73
LAB_001beb70:
INC RDX
LAB_001beb73:
LEA RDI,[RDX*0x8]
MOV qword ptr [RBP + -0x48],RSI
LAB_001beb7f:
MOV R8,RDX
DEC RDX
MOV RAX,qword ptr [R14 + R8*0x8 + -0x8]
AND EAX,0xfff
TEST byte ptr [RSI + RAX*0x1],0x2
JZ 0x001bec0e
MOV RAX,qword ptr [RCX + 0x18]
TEST RAX,RAX
JLE 0x001bec0e
MOV R12,qword ptr [RCX + 0x20]
IMUL RAX,RAX,0x58
ADD RAX,R12
LEA RSI,[R8*0x8]
MOV qword ptr [RBP + -0x50],RSI
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x30],RAX
LAB_001bebbd:
CMP R8,0x5
JA 0x001bebca
CMP qword ptr [R12 + RDI*0x1],0x0
JNZ 0x001bec05
LAB_001bebca:
CMP byte ptr [R12 + 0x52],0x0
JNZ 0x001bec05
MOV RDI,R12
MOV RSI,R14
MOV R15,RDX
MOV RDX,qword ptr [RBP + -0x50]
MOV R13,R14
MOV RBX,RCX
MOV R14,R8
CALL 0x00129560
MOV R8,R14
MOV RDI,qword ptr [RBP + -0x38]
MOV RCX,RBX
MOV RDX,R15
MOV R14,R13
TEST EAX,EAX
MOV RAX,qword ptr [RBP + -0x30]
JZ 0x001bec35
LAB_001bec05:
ADD R12,0x58
CMP R12,RAX
JC 0x001bebbd
LAB_001bec0e:
ADD RDI,-0x8
CMP RDX,0x1
MOV RSI,qword ptr [RBP + -0x48]
JA 0x001beb7f
LAB_001bec20:
XOR R12D,R12D
LAB_001bec23:
MOV RAX,R12
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001bec35:
LEA RAX,[R12 + 0x32]
MOV RCX,qword ptr [RBP + -0x40]
MOV qword ptr [RCX],RAX
MOV RAX,qword ptr [RBP + RDX*0x8 + -0x80]
MOV qword ptr [RCX + 0x8],RAX
JMP 0x001bec23
LAB_001bec4c:
LEA RAX,[R12 + 0x32]
MOV qword ptr [RDI],RAX
MOV qword ptr [RDI + 0x24],0x0
JMP 0x001bec23
|
long * my_uca_context_weight_find(long *param_1,long *param_2,ulong param_3)
{
uint uVar1;
int iVar2;
long *plVar3;
long lVar4;
ulong uVar5;
ulong uVar6;
ulong uVar7;
long lVar8;
long lVar9;
long *plVar10;
byte bVar11;
long local_88 [7];
long local_50;
long *local_48;
ulong local_40;
long *local_38;
lVar9 = param_1[3];
uVar5 = (ulong)((uint)*param_2 & 0xfff);
if ((*(char *)(*(long *)(lVar9 + 0x28) + uVar5) < '\0') && ((int4 *)*param_1 != &nochar)) {
lVar8 = (long)(*(int *)((long)param_1 + 0x24) << 8) + (long)(int)param_1[5];
param_2[1] = lVar8;
plVar10 = (long *)(lVar9 + 0x28);
lVar9 = param_1[3];
if (((*(byte *)(*plVar10 + (ulong)((uint)lVar8 & 0xfff)) & 0x40) != 0) &&
(0 < *(long *)(lVar9 + 0x18))) {
plVar10 = *(long **)(lVar9 + 0x20);
plVar3 = plVar10 + *(long *)(lVar9 + 0x18) * 0xb;
do {
if (((*(char *)((long)plVar10 + 0x52) != '\0') && (*plVar10 == lVar8)) &&
(plVar10[1] == *param_2)) {
*param_1 = (long)plVar10 + 0x32;
*(int8 *)((long)param_1 + 0x24) = 0;
return plVar10;
}
plVar10 = plVar10 + 0xb;
} while (plVar10 < plVar3);
}
}
if ((*(byte *)(*(long *)(lVar9 + 0x28) + uVar5) & 1) != 0) {
local_88[4] = 0;
local_88[5] = 0;
local_88[2] = 0;
local_88[3] = 0;
local_88[0] = 0;
local_88[1] = 0;
if (1 < param_3) {
lVar9 = param_1[1];
bVar11 = 4;
uVar5 = 1;
lVar8 = 8;
local_48 = param_1;
local_38 = (long *)param_3;
do {
local_40 = uVar5;
uVar1 = (**(code **)(*(long *)(param_1[6] + 0xb8) + 0x28))
(param_1[6],(long)param_2 + lVar8,lVar9,param_1[2]);
if ((int)uVar1 < 1) break;
lVar9 = lVar9 + (ulong)uVar1;
local_88[local_40] = lVar9;
lVar4 = param_1[3];
local_50 = *(long *)(lVar4 + 0x28);
if ((*(byte *)(local_50 + (ulong)((uint)param_2[local_40] & 0xfff)) & bVar11) == 0) {
local_40 = local_40 + 1;
goto LAB_001beb73;
}
uVar5 = local_40 + 1;
bVar11 = bVar11 * '\x02';
lVar8 = lVar8 + 8;
local_40 = (ulong)local_38;
} while (local_38 != (long *)uVar5);
if (1 < local_40) {
lVar4 = local_48[3];
local_50 = *(long *)(lVar4 + 0x28);
LAB_001beb73:
uVar5 = local_40 * 8;
uVar6 = local_40;
do {
uVar7 = uVar6 - 1;
if (((*(byte *)(local_50 + (ulong)((uint)param_2[uVar6 - 1] & 0xfff)) & 2) != 0) &&
(0 < *(long *)(lVar4 + 0x18))) {
plVar10 = *(long **)(lVar4 + 0x20);
plVar3 = plVar10 + *(long *)(lVar4 + 0x18) * 0xb;
local_88[6] = uVar6 * 8;
local_40 = uVar5;
local_38 = plVar3;
do {
if (((5 < uVar6) || (*(long *)((long)plVar10 + uVar5) == 0)) &&
((*(char *)((long)plVar10 + 0x52) == '\0' &&
(iVar2 = bcmp(plVar10,param_2,local_88[6]), plVar3 = local_38, uVar5 = local_40,
iVar2 == 0)))) {
*local_48 = (long)plVar10 + 0x32;
local_48[1] = local_88[uVar7];
return plVar10;
}
plVar10 = plVar10 + 0xb;
} while (plVar10 < plVar3);
}
uVar5 = uVar5 + -8;
uVar6 = uVar7;
} while (1 < uVar7);
}
}
}
return (long *)0x0;
}
|
|
6,839 |
init_builtin_memory_class(PFS_builtin_memory_class*, char const*)
|
eloqsql/storage/perfschema/pfs_builtin_memory.cc
|
static void init_builtin_memory_class(PFS_builtin_memory_class *klass, const char* name)
{
klass->m_class.m_type= PFS_CLASS_MEMORY;
klass->m_class.m_enabled= true; /* Immutable */
klass->m_class.m_timed= false; /* Immutable */
klass->m_class.m_flags= PSI_FLAG_GLOBAL;
klass->m_class.m_event_name_index= 0;
my_snprintf(klass->m_class.m_name, sizeof(klass->m_class.m_name), "%.*s",
PFS_MAX_INFO_NAME_LENGTH - 1, name);
klass->m_class.m_name_length= static_cast<uint>(strlen(name));
DBUG_ASSERT(klass->m_class.m_name_length < sizeof(klass->m_class.m_name));
klass->m_class.m_timer= NULL;
klass->m_stat.reset();
}
|
O0
|
cpp
|
init_builtin_memory_class(PFS_builtin_memory_class*, char const*):
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0xd, (%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x4(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x5(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rdi
addq $0x14, %rdi
movq -0x10(%rbp), %r8
movl $0x80, %esi
leaq 0x84b30(%rip), %rdx # 0xb2d38
movl $0x7f, %ecx
movb $0x0, %al
callq 0xab040
movq -0x10(%rbp), %rdi
callq 0x26150
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x94(%rax)
jmp 0x2e22b
movq -0x8(%rbp), %rax
movq $0x0, 0x98(%rax)
movq -0x8(%rbp), %rdi
addq $0xc0, %rdi
callq 0x2d940
addq $0x10, %rsp
popq %rbp
retq
|
_ZL25init_builtin_memory_classP24PFS_builtin_memory_classPKc:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov dword ptr [rax], 0Dh
mov rax, [rbp+var_8]
mov byte ptr [rax+4], 1
mov rax, [rbp+var_8]
mov byte ptr [rax+5], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+8], 1
mov rax, [rbp+var_8]
mov dword ptr [rax+10h], 0
mov rdi, [rbp+var_8]
add rdi, 14h
mov r8, [rbp+var_10]
mov esi, 80h
lea rdx, aS+3; "%.*s"
mov ecx, 7Fh
mov al, 0
call my_snprintf
mov rdi, [rbp+var_10]
call _strlen
mov ecx, eax
mov rax, [rbp+var_8]
mov [rax+94h], ecx
jmp short $+2
loc_2E22B:
mov rax, [rbp+var_8]
mov qword ptr [rax+98h], 0
mov rdi, [rbp+var_8]
add rdi, 0C0h; this
call _ZN15PFS_memory_stat5resetEv; PFS_memory_stat::reset(void)
add rsp, 10h
pop rbp
retn
|
PFS_memory_stat * init_builtin_memory_class(
PFS_builtin_memory_class *a1,
const char *a2,
long long a3,
long long a4,
long long a5,
int a6)
{
long long v7; // [rsp+0h] [rbp-10h]
*(_DWORD *)a1 = 13;
*((_BYTE *)a1 + 4) = 1;
*((_BYTE *)a1 + 5) = 0;
*((_DWORD *)a1 + 2) = 1;
*((_DWORD *)a1 + 4) = 0;
my_snprintf((_DWORD)a1 + 20, 128, (unsigned int)"%.*s", 127, (_DWORD)a2, a6, (char)a2);
*((_DWORD *)a1 + 37) = strlen(v7);
*((_QWORD *)a1 + 19) = 0LL;
return PFS_memory_stat::reset((PFS_builtin_memory_class *)((char *)a1 + 192));
}
|
init_builtin_memory_class:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX],0xd
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x4],0x1
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x5],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x8],0x1
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x10],0x0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x14
MOV R8,qword ptr [RBP + -0x10]
MOV ESI,0x80
LEA RDX,[0x1b2d38]
MOV ECX,0x7f
MOV AL,0x0
CALL 0x001ab040
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00126150
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x94],ECX
JMP 0x0012e22b
LAB_0012e22b:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x98],0x0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc0
CALL 0x0012d940
ADD RSP,0x10
POP RBP
RET
|
/* init_builtin_memory_class(PFS_builtin_memory_class*, char const*) */
void init_builtin_memory_class(PFS_builtin_memory_class *param_1,char *param_2)
{
size_t sVar1;
*(int4 *)param_1 = 0xd;
param_1[4] = (PFS_builtin_memory_class)0x1;
param_1[5] = (PFS_builtin_memory_class)0x0;
*(int4 *)(param_1 + 8) = 1;
*(int4 *)(param_1 + 0x10) = 0;
my_snprintf(param_1 + 0x14,0x80,&DAT_001b2d38,0x7f,param_2);
sVar1 = strlen(param_2);
*(int *)(param_1 + 0x94) = (int)sVar1;
*(int8 *)(param_1 + 0x98) = 0;
PFS_memory_stat::reset((PFS_memory_stat *)(param_1 + 0xc0));
return;
}
|
|
6,840 |
httplib::Server::Get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::function<void (httplib::Request const&, httplib::Response&)>)
|
hkr04[P]cpp-mcp/common/httplib.h
|
inline Server &Server::Get(const std::string &pattern, Handler handler) {
get_handlers_.emplace_back(make_matcher(pattern), std::move(handler));
return *this;
}
|
O2
|
c
|
httplib::Server::Get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::function<void (httplib::Request const&, httplib::Response&)>):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x108(%rdi), %r15
movq %rsp, %r12
movq %r12, %rdi
callq 0x1a6f2
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1a6b0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x17553
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x17574
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xaac0
|
_ZN7httplib6Server3GetERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt8functionIFvRKNS_7RequestERNS_8ResponseEEE:
push r15
push r14
push r12
push rbx
push rax
mov r14, rdx
mov rbx, rdi
lea r15, [rdi+108h]
mov r12, rsp
mov rdi, r12
call _ZN7httplib6Server12make_matcherERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; httplib::Server::make_matcher(std::string const&)
mov rdi, r15
mov rsi, r12
mov rdx, r14
call _ZNSt6vectorISt4pairISt10unique_ptrIN7httplib6detail11MatcherBaseESt14default_deleteIS4_EESt8functionIFvRKNS2_7RequestERNS2_8ResponseEEEESaISG_EE12emplace_backIJS7_SF_EEERSG_DpOT_; std::vector<std::pair<std::unique_ptr<httplib::detail::MatcherBase>,std::function<void ()(httplib::Request const&,httplib::Response &)>>>::emplace_back<std::unique_ptr<httplib::detail::MatcherBase>,std::function<void ()(httplib::Request const&,httplib::Response &)>>(std::unique_ptr<httplib::detail::MatcherBase>,std::function<void ()(httplib::Request const&,httplib::Response &)> &&)
mov rdi, [rsp+28h+var_28]
test rdi, rdi
jz short loc_17553
mov rax, [rdi]
call qword ptr [rax+8]
loc_17553:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+0]
test rdi, rdi
jz short loc_17574
mov rax, [rdi]
call qword ptr [rax+8]
loc_17574:
mov rdi, rbx
call __Unwind_Resume
|
long long httplib::Server::Get(long long a1, long long a2, long long a3)
{
long long v3; // rax
_QWORD v6[5]; // [rsp+0h] [rbp-28h] BYREF
v6[0] = v3;
httplib::Server::make_matcher(v6);
std::vector<std::pair<std::unique_ptr<httplib::detail::MatcherBase>,std::function<void ()(httplib::Request const&,httplib::Response &)>>>::emplace_back<std::unique_ptr<httplib::detail::MatcherBase>,std::function<void ()(httplib::Request const&,httplib::Response &)>>(
a1 + 264,
v6,
a3);
if ( v6[0] )
(*(void ( **)(_QWORD))(*(_QWORD *)v6[0] + 8LL))(v6[0]);
return a1;
}
|
Get:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV RBX,RDI
LEA R15,[RDI + 0x108]
MOV R12,RSP
MOV RDI,R12
CALL 0x0011a6f2
LAB_00117536:
MOV RDI,R15
MOV RSI,R12
MOV RDX,R14
CALL 0x0011a6b0
LAB_00117544:
MOV RDI,qword ptr [RSP]
TEST RDI,RDI
JZ 0x00117553
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_00117553:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* httplib::Server::Get(std::__cxx11::string const&, std::function<void (httplib::Request const&,
httplib::Response&)>) */
Server * __thiscall httplib::Server::Get(Server *this,string *param_1,function *param_3)
{
long *in_RAX;
long *local_28;
local_28 = in_RAX;
make_matcher((Server *)&local_28,param_1);
/* try { // try from 00117536 to 00117543 has its CatchHandler @ 00117562 */
std::
vector<std::pair<std::unique_ptr<httplib::detail::MatcherBase,std::default_delete<httplib::detail::MatcherBase>>,std::function<void(httplib::Request_const&,httplib::Response&)>>,std::allocator<std::pair<std::unique_ptr<httplib::detail::MatcherBase,std::default_delete<httplib::detail::MatcherBase>>,std::function<void(httplib::Request_const&,httplib::Response&)>>>>
::
emplace_back<std::unique_ptr<httplib::detail::MatcherBase,std::default_delete<httplib::detail::MatcherBase>>,std::function<void(httplib::Request_const&,httplib::Response&)>>
((vector<std::pair<std::unique_ptr<httplib::detail::MatcherBase,std::default_delete<httplib::detail::MatcherBase>>,std::function<void(httplib::Request_const&,httplib::Response&)>>,std::allocator<std::pair<std::unique_ptr<httplib::detail::MatcherBase,std::default_delete<httplib::detail::MatcherBase>>,std::function<void(httplib::Request_const&,httplib::Response&)>>>>
*)(this + 0x108),(unique_ptr *)&local_28,param_3);
if (local_28 != (long *)0x0) {
(**(code **)(*local_28 + 8))();
}
return this;
}
|
|
6,841 |
my_rw_init
|
eloqsql/mysys/thr_rwlock.c
|
int my_rw_init(my_rw_lock_t *rwp)
{
pthread_condattr_t cond_attr;
pthread_mutex_init( &rwp->lock, MY_MUTEX_INIT_FAST);
pthread_condattr_init( &cond_attr );
pthread_cond_init( &rwp->readers, &cond_attr );
pthread_cond_init( &rwp->writers, &cond_attr );
pthread_condattr_destroy(&cond_attr);
rwp->state = 0;
rwp->waiters = 0;
#ifdef SAFE_MUTEX
rwp->write_thread = 0;
#endif
return(0);
}
|
O3
|
c
|
my_rw_init:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xb63a7b(%rip), %rsi # 0xc086b0
callq 0x29330
leaq -0x14(%rbp), %r14
movq %r14, %rdi
callq 0x296d0
leaq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0x29380
leaq 0x58(%rbx), %rdi
movq %r14, %rsi
callq 0x29380
movq %r14, %rdi
callq 0x296c0
movq $0x0, 0x88(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
my_rw_init:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 10h
mov rbx, rdi
lea rsi, my_fast_mutexattr
call _pthread_mutex_init
lea r14, [rbp+var_14]
mov rdi, r14
call _pthread_condattr_init
lea rdi, [rbx+28h]
mov rsi, r14
call _pthread_cond_init
lea rdi, [rbx+58h]
mov rsi, r14
call _pthread_cond_init
mov rdi, r14
call _pthread_condattr_destroy
mov qword ptr [rbx+88h], 0
xor eax, eax
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
|
long long my_rw_init(long long a1)
{
double v1; // xmm0_8
_BYTE v3[20]; // [rsp+Ch] [rbp-14h] BYREF
pthread_mutex_init(a1, &my_fast_mutexattr);
v1 = pthread_condattr_init(v3);
pthread_cond_init(a1 + 40, v3, v1);
pthread_cond_init(a1 + 88, v3, v1);
pthread_condattr_destroy(v3);
*(_QWORD *)(a1 + 136) = 0LL;
return 0LL;
}
|
my_rw_init:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
LEA RSI,[0xd086b0]
CALL 0x00129330
LEA R14,[RBP + -0x14]
MOV RDI,R14
CALL 0x001296d0
LEA RDI,[RBX + 0x28]
MOV RSI,R14
CALL 0x00129380
LEA RDI,[RBX + 0x58]
MOV RSI,R14
CALL 0x00129380
MOV RDI,R14
CALL 0x001296c0
MOV qword ptr [RBX + 0x88],0x0
XOR EAX,EAX
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
|
int8 my_rw_init(pthread_mutex_t *param_1)
{
pthread_condattr_t local_1c;
pthread_mutex_init(param_1,(pthread_mutexattr_t *)&my_fast_mutexattr);
pthread_condattr_init(&local_1c);
pthread_cond_init((pthread_cond_t *)(param_1 + 1),&local_1c);
pthread_cond_init((pthread_cond_t *)((long)param_1 + 0x58),&local_1c);
pthread_condattr_destroy(&local_1c);
*(int8 *)((long)param_1 + 0x88) = 0;
return 0;
}
|
|
6,842 |
my_strntoll_mb2_or_mb4
|
eloqsql/strings/ctype-ucs2.c
|
static longlong
my_strntoll_mb2_or_mb4(CHARSET_INFO *cs,
const char *nptr, size_t l, int base,
char **endptr, int *err)
{
int negative=0;
int overflow;
int cnv;
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
register ulonglong cutoff;
register unsigned int cutlim;
register ulonglong res;
register const uchar *s= (const uchar*) nptr;
register const uchar *e= (const uchar*) nptr+l;
const uchar *save;
*err= 0;
do
{
if ((cnv= mb_wc(cs, &wc, s, e)) > 0)
{
switch (wc)
{
case ' ' : break;
case '\t': break;
case '-' : negative= !negative; break;
case '+' : break;
default : goto bs;
}
}
else /* No more characters or bad multibyte sequence */
{
if (endptr !=NULL )
*endptr = (char*)s;
err[0] = (cnv==MY_CS_ILSEQ) ? EILSEQ : EDOM;
return 0;
}
s+=cnv;
} while (1);
bs:
overflow = 0;
res = 0;
save = s;
cutoff = (~(ulonglong) 0) / (unsigned long int) base;
cutlim = (uint) ((~(ulonglong) 0) % (unsigned long int) base);
do {
if ((cnv= mb_wc(cs, &wc, s, e)) > 0)
{
s+=cnv;
if ( wc>='0' && wc<='9')
wc -= '0';
else if ( wc>='A' && wc<='Z')
wc = wc - 'A' + 10;
else if ( wc>='a' && wc<='z')
wc = wc - 'a' + 10;
else
break;
if ((int)wc >= base)
break;
if (res > cutoff || (res == cutoff && wc > cutlim))
overflow = 1;
else
{
res *= (ulonglong) base;
res += wc;
}
}
else if (cnv==MY_CS_ILSEQ)
{
if (endptr !=NULL )
*endptr = (char*)s;
err[0]=EILSEQ;
return 0;
}
else
{
/* No more characters */
break;
}
} while(1);
if (endptr != NULL)
*endptr = (char *) s;
if (s == save)
{
err[0]=EDOM;
return 0L;
}
if (negative)
{
if (res > (ulonglong) LONGLONG_MIN)
overflow = 1;
}
else if (res > (ulonglong) LONGLONG_MAX)
overflow = 1;
if (overflow)
{
err[0]=ERANGE;
return negative ? LONGLONG_MIN : LONGLONG_MAX;
}
return (negative ? -((longlong)res) : (longlong)res);
}
|
O0
|
c
|
my_strntoll_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq -0x58(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x78(%rbp), %rdx
movq -0x80(%rbp), %rcx
leaq -0x50(%rbp), %rsi
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $0x0, %eax
jle 0x90c11
movq -0x50(%rbp), %rax
addq $-0x9, %rax
movq %rax, -0x90(%rbp)
subq $0x24, %rax
ja 0x90c0d
movq -0x90(%rbp), %rax
leaq 0x15812d(%rip), %rcx # 0x1e8d18
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x90c0f
jmp 0x90c0f
cmpl $0x0, -0x3c(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x3c(%rbp)
jmp 0x90c0f
jmp 0x90c0f
jmp 0x90c68
jmp 0x90c49
cmpq $0x0, -0x30(%rbp)
je 0x90c23
movq -0x78(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl -0x44(%rbp), %edx
movl $0x21, %ecx
movl $0x54, %eax
cmpl $0x0, %edx
cmovel %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x90ea1
movl -0x44(%rbp), %ecx
movq -0x78(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x78(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x90baa
jmp 0x90c66
jmp 0x90c68
movl $0x0, -0x40(%rbp)
movq $0x0, -0x70(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x88(%rbp)
movslq -0x24(%rbp), %rcx
movq $-0x1, %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x60(%rbp)
movslq -0x24(%rbp), %rcx
movq $-0x1, %rax
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x64(%rbp)
movq -0x58(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x78(%rbp), %rdx
movq -0x80(%rbp), %rcx
leaq -0x50(%rbp), %rsi
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $0x0, %eax
jle 0x90d95
movl -0x44(%rbp), %ecx
movq -0x78(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x78(%rbp)
cmpq $0x30, -0x50(%rbp)
jb 0x90cfa
cmpq $0x39, -0x50(%rbp)
ja 0x90cfa
movq -0x50(%rbp), %rax
subq $0x30, %rax
movq %rax, -0x50(%rbp)
jmp 0x90d43
cmpq $0x41, -0x50(%rbp)
jb 0x90d1a
cmpq $0x5a, -0x50(%rbp)
ja 0x90d1a
movq -0x50(%rbp), %rax
subq $0x41, %rax
addq $0xa, %rax
movq %rax, -0x50(%rbp)
jmp 0x90d41
cmpq $0x61, -0x50(%rbp)
jb 0x90d3a
cmpq $0x7a, -0x50(%rbp)
ja 0x90d3a
movq -0x50(%rbp), %rax
subq $0x61, %rax
addq $0xa, %rax
movq %rax, -0x50(%rbp)
jmp 0x90d3f
jmp 0x90dd4
jmp 0x90d41
jmp 0x90d43
movq -0x50(%rbp), %rax
cmpl -0x24(%rbp), %eax
jl 0x90d51
jmp 0x90dd4
movq -0x70(%rbp), %rax
cmpq -0x60(%rbp), %rax
ja 0x90d71
movq -0x70(%rbp), %rax
cmpq -0x60(%rbp), %rax
jne 0x90d7a
movq -0x50(%rbp), %rax
movl -0x64(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x90d7a
movl $0x1, -0x40(%rbp)
jmp 0x90d93
movslq -0x24(%rbp), %rax
imulq -0x70(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x50(%rbp), %rax
addq -0x70(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0x90dc6
cmpl $0x0, -0x44(%rbp)
jne 0x90dc4
cmpq $0x0, -0x30(%rbp)
je 0x90dad
movq -0x78(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movl $0x54, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x90ea1
jmp 0x90dd4
jmp 0x90dc8
movb $0x1, %al
testb $0x1, %al
jne 0x90cab
jmp 0x90dd4
cmpq $0x0, -0x30(%rbp)
je 0x90de6
movq -0x78(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x78(%rbp), %rax
cmpq -0x88(%rbp), %rax
jne 0x90e0a
movq -0x38(%rbp), %rax
movl $0x21, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x90ea1
cmpl $0x0, -0x3c(%rbp)
je 0x90e29
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rax, -0x70(%rbp)
jbe 0x90e27
movl $0x1, -0x40(%rbp)
jmp 0x90e42
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, -0x70(%rbp)
jbe 0x90e40
movl $0x1, -0x40(%rbp)
jmp 0x90e42
cmpl $0x0, -0x40(%rbp)
je 0x90e76
movq -0x38(%rbp), %rax
movl $0x22, (%rax)
movl -0x3c(%rbp), %edx
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x90ea1
cmpl $0x0, -0x3c(%rbp)
je 0x90e8b
xorl %eax, %eax
subq -0x70(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0x90e96
movq -0x70(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nop
|
my_strntoll_mb2_or_mb4:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov [rbp+var_3C], 0
mov rax, [rbp+var_10]
mov rax, [rax+0B8h]
mov rax, [rax+28h]
mov [rbp+var_58], rax
mov rax, [rbp+var_18]
mov [rbp+var_78], rax
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
mov [rbp+var_80], rax
mov rax, [rbp+var_38]
mov dword ptr [rax], 0
loc_90BAA:
mov rax, [rbp+var_58]
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_78]
mov rcx, [rbp+var_80]
lea rsi, [rbp+var_50]
call rax
mov [rbp+var_44], eax
cmp eax, 0
jle short loc_90C11
mov rax, [rbp+var_50]
add rax, 0FFFFFFFFFFFFFFF7h; switch 37 cases
mov [rbp+var_90], rax
sub rax, 24h
ja short def_90BF2; jumptable 0000000000090BF2 default case, cases 10-31,33-42,44
mov rax, [rbp+var_90]
lea rcx, jpt_90BF2
movsxd rax, ds:(jpt_90BF2 - 1E8D18h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_90BF4:
jmp short loc_90C0F; jumptable 0000000000090BF2 case 32
loc_90BF6:
jmp short loc_90C0F; jumptable 0000000000090BF2 case 9
loc_90BF8:
cmp [rbp+var_3C], 0; jumptable 0000000000090BF2 case 45
setnz al
xor al, 0FFh
and al, 1
movzx eax, al
mov [rbp+var_3C], eax
jmp short loc_90C0F
loc_90C0B:
jmp short loc_90C0F; jumptable 0000000000090BF2 case 43
def_90BF2:
jmp short loc_90C68; jumptable 0000000000090BF2 default case, cases 10-31,33-42,44
loc_90C0F:
jmp short loc_90C49
loc_90C11:
cmp [rbp+var_30], 0
jz short loc_90C23
mov rcx, [rbp+var_78]
mov rax, [rbp+var_30]
mov [rax], rcx
loc_90C23:
mov edx, [rbp+var_44]
mov ecx, 21h ; '!'
mov eax, 54h ; 'T'
cmp edx, 0
cmovz ecx, eax
mov rax, [rbp+var_38]
mov [rax], ecx
mov [rbp+var_8], 0
jmp loc_90EA1
loc_90C49:
mov ecx, [rbp+var_44]
mov rax, [rbp+var_78]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_78], rax
mov al, 1
test al, 1
jnz loc_90BAA
jmp short $+2
loc_90C66:
jmp short $+2
loc_90C68:
mov [rbp+var_40], 0
mov [rbp+var_70], 0
mov rax, [rbp+var_78]
mov [rbp+var_88], rax
movsxd rcx, [rbp+var_24]
mov rax, 0FFFFFFFFFFFFFFFFh
xor edx, edx
div rcx
mov [rbp+var_60], rax
movsxd rcx, [rbp+var_24]
mov rax, 0FFFFFFFFFFFFFFFFh
xor edx, edx
div rcx
mov eax, edx
mov [rbp+var_64], eax
loc_90CAB:
mov rax, [rbp+var_58]
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_78]
mov rcx, [rbp+var_80]
lea rsi, [rbp+var_50]
call rax
mov [rbp+var_44], eax
cmp eax, 0
jle loc_90D95
mov ecx, [rbp+var_44]
mov rax, [rbp+var_78]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_78], rax
cmp [rbp+var_50], 30h ; '0'
jb short loc_90CFA
cmp [rbp+var_50], 39h ; '9'
ja short loc_90CFA
mov rax, [rbp+var_50]
sub rax, 30h ; '0'
mov [rbp+var_50], rax
jmp short loc_90D43
loc_90CFA:
cmp [rbp+var_50], 41h ; 'A'
jb short loc_90D1A
cmp [rbp+var_50], 5Ah ; 'Z'
ja short loc_90D1A
mov rax, [rbp+var_50]
sub rax, 41h ; 'A'
add rax, 0Ah
mov [rbp+var_50], rax
jmp short loc_90D41
loc_90D1A:
cmp [rbp+var_50], 61h ; 'a'
jb short loc_90D3A
cmp [rbp+var_50], 7Ah ; 'z'
ja short loc_90D3A
mov rax, [rbp+var_50]
sub rax, 61h ; 'a'
add rax, 0Ah
mov [rbp+var_50], rax
jmp short loc_90D3F
loc_90D3A:
jmp loc_90DD4
loc_90D3F:
jmp short $+2
loc_90D41:
jmp short $+2
loc_90D43:
mov rax, [rbp+var_50]
cmp eax, [rbp+var_24]
jl short loc_90D51
jmp loc_90DD4
loc_90D51:
mov rax, [rbp+var_70]
cmp rax, [rbp+var_60]
ja short loc_90D71
mov rax, [rbp+var_70]
cmp rax, [rbp+var_60]
jnz short loc_90D7A
mov rax, [rbp+var_50]
mov ecx, [rbp+var_64]
cmp rax, rcx
jbe short loc_90D7A
loc_90D71:
mov [rbp+var_40], 1
jmp short loc_90D93
loc_90D7A:
movsxd rax, [rbp+var_24]
imul rax, [rbp+var_70]
mov [rbp+var_70], rax
mov rax, [rbp+var_50]
add rax, [rbp+var_70]
mov [rbp+var_70], rax
loc_90D93:
jmp short loc_90DC6
loc_90D95:
cmp [rbp+var_44], 0
jnz short loc_90DC4
cmp [rbp+var_30], 0
jz short loc_90DAD
mov rcx, [rbp+var_78]
mov rax, [rbp+var_30]
mov [rax], rcx
loc_90DAD:
mov rax, [rbp+var_38]
mov dword ptr [rax], 54h ; 'T'
mov [rbp+var_8], 0
jmp loc_90EA1
loc_90DC4:
jmp short loc_90DD4
loc_90DC6:
jmp short $+2
loc_90DC8:
mov al, 1
test al, 1
jnz loc_90CAB
jmp short $+2
loc_90DD4:
cmp [rbp+var_30], 0
jz short loc_90DE6
mov rcx, [rbp+var_78]
mov rax, [rbp+var_30]
mov [rax], rcx
loc_90DE6:
mov rax, [rbp+var_78]
cmp rax, [rbp+var_88]
jnz short loc_90E0A
mov rax, [rbp+var_38]
mov dword ptr [rax], 21h ; '!'
mov [rbp+var_8], 0
jmp loc_90EA1
loc_90E0A:
cmp [rbp+var_3C], 0
jz short loc_90E29
mov rax, 8000000000000000h
cmp [rbp+var_70], rax
jbe short loc_90E27
mov [rbp+var_40], 1
loc_90E27:
jmp short loc_90E42
loc_90E29:
mov rax, 7FFFFFFFFFFFFFFFh
cmp [rbp+var_70], rax
jbe short loc_90E40
mov [rbp+var_40], 1
loc_90E40:
jmp short $+2
loc_90E42:
cmp [rbp+var_40], 0
jz short loc_90E76
mov rax, [rbp+var_38]
mov dword ptr [rax], 22h ; '"'
mov edx, [rbp+var_3C]
mov rax, 7FFFFFFFFFFFFFFFh
mov rcx, 8000000000000000h
cmp edx, 0
cmovnz rax, rcx
mov [rbp+var_8], rax
jmp short loc_90EA1
loc_90E76:
cmp [rbp+var_3C], 0
jz short loc_90E8B
xor eax, eax
sub rax, [rbp+var_70]
mov [rbp+var_98], rax
jmp short loc_90E96
loc_90E8B:
mov rax, [rbp+var_70]
mov [rbp+var_98], rax
loc_90E96:
mov rax, [rbp+var_98]
mov [rbp+var_8], rax
loc_90EA1:
mov rax, [rbp+var_8]
add rsp, 0A0h
pop rbp
retn
|
unsigned long long my_strntoll_mb2_or_mb4(long long a1, long long a2, long long a3, int a4, _QWORD *a5, int *a6)
{
int v6; // ecx
long long v7; // rax
long long v10; // [rsp+18h] [rbp-88h]
long long v11; // [rsp+20h] [rbp-80h]
long long v12; // [rsp+28h] [rbp-78h]
unsigned long long v13; // [rsp+30h] [rbp-70h]
unsigned int v14; // [rsp+3Ch] [rbp-64h]
unsigned long long v15; // [rsp+40h] [rbp-60h]
long long ( *v16)(long long, unsigned long long *, long long, long long); // [rsp+48h] [rbp-58h]
unsigned long long v17; // [rsp+50h] [rbp-50h] BYREF
int v18; // [rsp+5Ch] [rbp-44h]
int v19; // [rsp+60h] [rbp-40h]
BOOL v20; // [rsp+64h] [rbp-3Ch]
int *v21; // [rsp+68h] [rbp-38h]
_QWORD *v22; // [rsp+70h] [rbp-30h]
int v23; // [rsp+7Ch] [rbp-24h]
long long v24; // [rsp+80h] [rbp-20h]
long long v25; // [rsp+88h] [rbp-18h]
long long v26; // [rsp+90h] [rbp-10h]
v26 = a1;
v25 = a2;
v24 = a3;
v23 = a4;
v22 = a5;
v21 = a6;
v20 = 0;
v16 = *(long long ( **)(long long, unsigned long long *, long long, long long))(*(_QWORD *)(a1 + 184) + 40LL);
v12 = a2;
v11 = a3 + a2;
*a6 = 0;
while ( 2 )
{
v18 = v16(v26, &v17, v12, v11);
if ( v18 <= 0 )
{
if ( v22 )
*v22 = v12;
v6 = 33;
if ( !v18 )
v6 = 84;
*v21 = v6;
return 0LL;
}
else
{
switch ( v17 )
{
case 9uLL:
case 0x20uLL:
case 0x2BuLL:
goto LABEL_10;
case 0x2DuLL:
v20 = !v20;
LABEL_10:
v12 += v18;
continue;
default:
v19 = 0;
v13 = 0LL;
v10 = v12;
v15 = 0xFFFFFFFFFFFFFFFFLL / v23;
v14 = 0xFFFFFFFFFFFFFFFFLL % v23;
break;
}
while ( 1 )
{
v18 = v16(v26, &v17, v12, v11);
if ( v18 <= 0 )
break;
v12 += v18;
if ( v17 < 0x30 || v17 > 0x39 )
{
if ( v17 < 0x41 || v17 > 0x5A )
{
if ( v17 < 0x61 || v17 > 0x7A )
goto LABEL_33;
v17 = v17 - 97 + 10;
}
else
{
v17 = v17 - 65 + 10;
}
}
else
{
v17 -= 48LL;
}
if ( (int)v17 >= v23 )
goto LABEL_33;
if ( v13 > v15 || v13 == v15 && v17 > v14 )
v19 = 1;
else
v13 = v13 * v23 + v17;
}
if ( v18 )
{
LABEL_33:
if ( v22 )
*v22 = v12;
if ( v12 == v10 )
{
*v21 = 33;
return 0LL;
}
else
{
if ( v20 )
{
if ( v13 > 0x8000000000000000LL )
v19 = 1;
}
else if ( v13 > 0x7FFFFFFFFFFFFFFFLL )
{
v19 = 1;
}
if ( v19 )
{
*v21 = 34;
v7 = 0x7FFFFFFFFFFFFFFFLL;
if ( v20 )
return 0x8000000000000000LL;
return v7;
}
else if ( v20 )
{
return -(long long)v13;
}
else
{
return v13;
}
}
}
if ( v22 )
*v22 = v12;
*v21 = 84;
return 0LL;
}
}
}
|
my_strntoll_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV dword ptr [RBP + -0x3c],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x0
LAB_00190baa:
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x80]
LEA RSI,[RBP + -0x50]
CALL RAX
MOV dword ptr [RBP + -0x44],EAX
CMP EAX,0x0
JLE 0x00190c11
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,-0x9
MOV qword ptr [RBP + -0x90],RAX
SUB RAX,0x24
JA 0x00190c0d
MOV RAX,qword ptr [RBP + -0x90]
LEA RCX,[0x2e8d18]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_20:
JMP 0x00190c0f
caseD_9:
JMP 0x00190c0f
caseD_2d:
CMP dword ptr [RBP + -0x3c],0x0
SETNZ AL
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x00190c0f
caseD_2b:
JMP 0x00190c0f
caseD_a:
JMP 0x00190c68
LAB_00190c0f:
JMP 0x00190c49
LAB_00190c11:
CMP qword ptr [RBP + -0x30],0x0
JZ 0x00190c23
MOV RCX,qword ptr [RBP + -0x78]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
LAB_00190c23:
MOV EDX,dword ptr [RBP + -0x44]
MOV ECX,0x21
MOV EAX,0x54
CMP EDX,0x0
CMOVZ ECX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],ECX
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00190ea1
LAB_00190c49:
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x78]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x78],RAX
MOV AL,0x1
TEST AL,0x1
JNZ 0x00190baa
JMP 0x00190c66
LAB_00190c66:
JMP 0x00190c68
LAB_00190c68:
MOV dword ptr [RBP + -0x40],0x0
MOV qword ptr [RBP + -0x70],0x0
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x88],RAX
MOVSXD RCX,dword ptr [RBP + -0x24]
MOV RAX,-0x1
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x60],RAX
MOVSXD RCX,dword ptr [RBP + -0x24]
MOV RAX,-0x1
XOR EDX,EDX
DIV RCX
MOV EAX,EDX
MOV dword ptr [RBP + -0x64],EAX
LAB_00190cab:
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x80]
LEA RSI,[RBP + -0x50]
CALL RAX
MOV dword ptr [RBP + -0x44],EAX
CMP EAX,0x0
JLE 0x00190d95
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x78]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x78],RAX
CMP qword ptr [RBP + -0x50],0x30
JC 0x00190cfa
CMP qword ptr [RBP + -0x50],0x39
JA 0x00190cfa
MOV RAX,qword ptr [RBP + -0x50]
SUB RAX,0x30
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00190d43
LAB_00190cfa:
CMP qword ptr [RBP + -0x50],0x41
JC 0x00190d1a
CMP qword ptr [RBP + -0x50],0x5a
JA 0x00190d1a
MOV RAX,qword ptr [RBP + -0x50]
SUB RAX,0x41
ADD RAX,0xa
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00190d41
LAB_00190d1a:
CMP qword ptr [RBP + -0x50],0x61
JC 0x00190d3a
CMP qword ptr [RBP + -0x50],0x7a
JA 0x00190d3a
MOV RAX,qword ptr [RBP + -0x50]
SUB RAX,0x61
ADD RAX,0xa
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00190d3f
LAB_00190d3a:
JMP 0x00190dd4
LAB_00190d3f:
JMP 0x00190d41
LAB_00190d41:
JMP 0x00190d43
LAB_00190d43:
MOV RAX,qword ptr [RBP + -0x50]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x00190d51
JMP 0x00190dd4
LAB_00190d51:
MOV RAX,qword ptr [RBP + -0x70]
CMP RAX,qword ptr [RBP + -0x60]
JA 0x00190d71
MOV RAX,qword ptr [RBP + -0x70]
CMP RAX,qword ptr [RBP + -0x60]
JNZ 0x00190d7a
MOV RAX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RBP + -0x64]
CMP RAX,RCX
JBE 0x00190d7a
LAB_00190d71:
MOV dword ptr [RBP + -0x40],0x1
JMP 0x00190d93
LAB_00190d7a:
MOVSXD RAX,dword ptr [RBP + -0x24]
IMUL RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x70],RAX
LAB_00190d93:
JMP 0x00190dc6
LAB_00190d95:
CMP dword ptr [RBP + -0x44],0x0
JNZ 0x00190dc4
CMP qword ptr [RBP + -0x30],0x0
JZ 0x00190dad
MOV RCX,qword ptr [RBP + -0x78]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
LAB_00190dad:
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x54
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00190ea1
LAB_00190dc4:
JMP 0x00190dd4
LAB_00190dc6:
JMP 0x00190dc8
LAB_00190dc8:
MOV AL,0x1
TEST AL,0x1
JNZ 0x00190cab
JMP 0x00190dd4
LAB_00190dd4:
CMP qword ptr [RBP + -0x30],0x0
JZ 0x00190de6
MOV RCX,qword ptr [RBP + -0x78]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
LAB_00190de6:
MOV RAX,qword ptr [RBP + -0x78]
CMP RAX,qword ptr [RBP + -0x88]
JNZ 0x00190e0a
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x21
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00190ea1
LAB_00190e0a:
CMP dword ptr [RBP + -0x3c],0x0
JZ 0x00190e29
MOV RAX,-0x8000000000000000
CMP qword ptr [RBP + -0x70],RAX
JBE 0x00190e27
MOV dword ptr [RBP + -0x40],0x1
LAB_00190e27:
JMP 0x00190e42
LAB_00190e29:
MOV RAX,0x7fffffffffffffff
CMP qword ptr [RBP + -0x70],RAX
JBE 0x00190e40
MOV dword ptr [RBP + -0x40],0x1
LAB_00190e40:
JMP 0x00190e42
LAB_00190e42:
CMP dword ptr [RBP + -0x40],0x0
JZ 0x00190e76
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x22
MOV EDX,dword ptr [RBP + -0x3c]
MOV RAX,0x7fffffffffffffff
MOV RCX,-0x8000000000000000
CMP EDX,0x0
CMOVNZ RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00190ea1
LAB_00190e76:
CMP dword ptr [RBP + -0x3c],0x0
JZ 0x00190e8b
XOR EAX,EAX
SUB RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x98],RAX
JMP 0x00190e96
LAB_00190e8b:
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x98],RAX
LAB_00190e96:
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x8],RAX
LAB_00190ea1:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0xa0
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x00190c64) */
/* WARNING: Removing unreachable block (ram,0x00190dd2) */
ulong my_strntoll_mb2_or_mb4
(long param_1,long param_2,long param_3,int param_4,long *param_5,
int4 *param_6)
{
code *pcVar1;
int1 auVar2 [16];
int1 auVar3 [16];
long lVar4;
ulong uVar5;
int4 uVar6;
ulong local_a0;
long local_80;
ulong local_78;
ulong local_58;
int local_4c;
int local_48;
uint local_44;
int4 *local_40;
long *local_38;
int local_2c;
long local_28;
long local_20;
long local_18;
ulong local_10;
local_44 = 0;
pcVar1 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
*param_6 = 0;
local_80 = param_2;
local_40 = param_6;
local_38 = param_5;
local_2c = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
do {
lVar4 = local_80;
local_4c = (*pcVar1)(local_18,&local_58,local_80,param_2 + param_3);
if (local_4c < 1) {
if (local_38 != (long *)0x0) {
*local_38 = local_80;
}
uVar6 = 0x21;
if (local_4c == 0) {
uVar6 = 0x54;
}
*local_40 = uVar6;
return 0;
}
switch(local_58) {
case 9:
break;
default:
local_48 = 0;
local_78 = 0;
auVar2._8_8_ = 0;
auVar2._0_8_ = (long)local_2c;
uVar5 = SUB168((ZEXT816(0) << 0x40 | ZEXT816(0xffffffffffffffff)) / auVar2,0);
auVar3._8_8_ = 0;
auVar3._0_8_ = (long)local_2c;
goto LAB_00190cab;
case 0x20:
break;
case 0x2b:
break;
case 0x2d:
local_44 = (uint)((local_44 != 0 ^ 0xffU) & 1);
}
local_80 = local_80 + local_4c;
} while( true );
LAB_00190cab:
local_4c = (*pcVar1)(local_18,&local_58,local_80,param_2 + param_3);
if (local_4c < 1) {
if (local_4c == 0) {
if (local_38 != (long *)0x0) {
*local_38 = local_80;
}
*local_40 = 0x54;
local_10 = 0;
}
else {
LAB_00190dd4:
if (local_38 != (long *)0x0) {
*local_38 = local_80;
}
if (local_80 == lVar4) {
*local_40 = 0x21;
local_10 = 0;
}
else {
if (local_44 == 0) {
if (0x7fffffffffffffff < local_78) {
local_48 = 1;
}
}
else if (0x8000000000000000 < local_78) {
local_48 = 1;
}
if (local_48 == 0) {
if (local_44 == 0) {
local_a0 = local_78;
}
else {
local_a0 = -local_78;
}
local_10 = local_a0;
}
else {
*local_40 = 0x22;
local_10 = 0x7fffffffffffffff;
if (local_44 != 0) {
local_10 = 0x8000000000000000;
}
}
}
}
return local_10;
}
local_80 = local_80 + local_4c;
if ((local_58 < 0x30) || (0x39 < local_58)) {
if ((local_58 < 0x41) || (0x5a < local_58)) {
if ((local_58 < 0x61) || (0x7a < local_58)) goto LAB_00190dd4;
local_58 = local_58 - 0x57;
}
else {
local_58 = local_58 - 0x37;
}
}
else {
local_58 = local_58 - 0x30;
}
if (local_2c <= (int)local_58) goto LAB_00190dd4;
if ((uVar5 < local_78) ||
((local_78 == uVar5 &&
(SUB164((ZEXT816(0) << 0x40 | ZEXT816(0xffffffffffffffff)) % auVar3,0) < local_58)))) {
local_48 = 1;
}
else {
local_78 = local_58 + (long)local_2c * local_78;
}
goto LAB_00190cab;
}
|
|
6,843 |
void testing::internal::PrintCharAndCodeTo<signed char>(signed char, std::ostream*)
|
giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest-printers.cc
|
void PrintCharAndCodeTo(Char c, ostream* os) {
// First, print c as a literal in the most readable form we can find.
*os << GetCharWidthPrefix(c) << "'";
const CharFormat format = PrintAsCharLiteralTo(c, os);
*os << "'";
// To aid user debugging, we also print c's code in decimal, unless
// it's 0 (in which case c was printed as '\\0', making the code
// obvious).
if (c == 0) return;
*os << " (" << static_cast<int>(c);
// For more convenience, we print c's code again in hexadecimal,
// unless c was already printed in the form '\x##' or the code is in
// [1, 9].
if (format == kHexEscape || (1 <= c && c <= 9)) {
// Do nothing.
} else {
*os << ", 0x" << String::FormatHexInt(static_cast<int>(c));
}
*os << ")";
}
|
O1
|
cpp
|
void testing::internal::PrintCharAndCodeTo<signed char>(signed char, std::ostream*):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x1093d(%rip), %rsi # 0x432de
movq %rbx, %rdi
xorl %edx, %edx
callq 0x85b0
leaq 0xff1b(%rip), %rsi # 0x428cd
movl $0x1, %edx
movq %rbx, %rdi
callq 0x85b0
cmpl $0xd, %ebp
ja 0x329df
movl %ebp, %eax
leaq 0xf4cb(%rip), %rcx # 0x41e98
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1032f(%rip), %rsi # 0x42d0c
jmp 0x32a58
cmpl $0x27, %ebp
je 0x32a51
cmpl $0x5c, %ebp
jne 0x329f2
leaq 0x11cb2(%rip), %rsi # 0x446a2
jmp 0x32a58
movzbl %bpl, %r14d
leal -0x20(%r14), %eax
cmpl $0x5e, %eax
ja 0x32b21
leaq 0x8(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
jmp 0x32a5d
leaq 0x11c8f(%rip), %rsi # 0x446a8
jmp 0x32a58
leaq 0x10c20(%rip), %rsi # 0x43642
jmp 0x32a58
leaq 0x10c1a(%rip), %rsi # 0x43645
jmp 0x32a58
leaq 0x11c71(%rip), %rsi # 0x446a5
jmp 0x32a58
leaq 0x10c02(%rip), %rsi # 0x4363f
jmp 0x32a58
leaq 0x10bf3(%rip), %rsi # 0x43639
jmp 0x32a58
leaq 0x10bed(%rip), %rsi # 0x4363c
jmp 0x32a58
leaq 0x11c47(%rip), %rsi # 0x4469f
movl $0x2, %edx
movq %rbx, %rdi
callq 0x85b0
xorl %r15d, %r15d
leaq 0xfe5e(%rip), %rsi # 0x428cd
movl $0x1, %edx
movq %rbx, %rdi
callq 0x85b0
testb %bpl, %bpl
je 0x32b16
movsbl %bpl, %r14d
leaq 0xdb42(%rip), %rsi # 0x405d2
movl $0x2, %edx
movq %rbx, %rdi
callq 0x85b0
movq %rbx, %rdi
movl %r14d, %esi
callq 0x8950
cmpb $0xa, %bpl
setb %al
orb %r15b, %al
jne 0x32b02
leaq 0x11bdf(%rip), %rsi # 0x4469a
movl $0x4, %edx
movq %rbx, %rdi
callq 0x85b0
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl %r14d, %esi
callq 0x1f4c0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x85b0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32b02
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84e0
leaq 0x10614(%rip), %rsi # 0x4311d
movl $0x1, %edx
movq %rbx, %rdi
callq 0x85b0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %r15d
leaq 0x11b77(%rip), %rsi # 0x446ab
movl $0x2, %edx
movq %rbx, %rdi
callq 0x85b0
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rbx,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
orl $0x4000, 0x18(%rbx,%rax) # imm = 0x4000
movq %rbx, %rdi
movl %r14d, %esi
callq 0x8950
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl %r15d, 0x18(%rbx,%rax)
movb $0x1, %r15b
jmp 0x32a68
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32b9f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84e0
movq %rbx, %rdi
callq 0x8990
|
_ZN7testing8internal18PrintCharAndCodeToIaEEvT_PSo:
push rbp
push r15
push r14
push rbx
sub rsp, 28h
mov rbx, rsi
mov ebp, edi
lea rsi, aSFromSSMsTotal+1Ah; ""
mov rdi, rbx
xor edx, edx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aUnknownTypePar+25h; "'"
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)
cmp ebp, 0Dh; switch 14 cases
ja short def_329D4; jumptable 00000000000329D4 default case
mov eax, ebp
lea rcx, jpt_329D4
movsxd rax, ds:(jpt_329D4 - 41E98h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_329D6:
lea rsi, a0; jumptable 00000000000329D4 case 0
jmp short loc_32A58
def_329D4:
cmp ebp, 27h ; '''; jumptable 00000000000329D4 default case
jz short loc_32A51
cmp ebp, 5Ch ; '\'
jnz short loc_329F2; jumptable 00000000000329D4 cases 1-6
lea rsi, asc_446A2; "\\\\"
jmp short loc_32A58
loc_329F2:
movzx r14d, bpl; jumptable 00000000000329D4 cases 1-6
lea eax, [r14-20h]
cmp eax, 5Eh ; '^'
ja loc_32B21
lea rsi, [rsp+48h+var_40]
mov [rsi], bpl
mov edx, 1
jmp short loc_32A5D
loc_32A12:
lea rsi, aV; jumptable 00000000000329D4 case 11
jmp short loc_32A58
loc_32A1B:
lea rsi, asc_43642; jumptable 00000000000329D4 case 12
jmp short loc_32A58
loc_32A24:
lea rsi, aR; jumptable 00000000000329D4 case 13
jmp short loc_32A58
loc_32A2D:
lea rsi, aA; jumptable 00000000000329D4 case 7
jmp short loc_32A58
loc_32A36:
lea rsi, aN; jumptable 00000000000329D4 case 10
jmp short loc_32A58
loc_32A3F:
lea rsi, aB; jumptable 00000000000329D4 case 8
jmp short loc_32A58
loc_32A48:
lea rsi, aT; jumptable 00000000000329D4 case 9
jmp short loc_32A58
loc_32A51:
lea rsi, asc_4469F; "\\'"
loc_32A58:
mov edx, 2
loc_32A5D:
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)
xor r15d, r15d
loc_32A68:
lea rsi, aUnknownTypePar+25h; "'"
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)
test bpl, bpl
jz loc_32B16
movsx r14d, bpl
lea rsi, aExpected+9; " ("
mov edx, 2
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, rbx
mov esi, r14d
call __ZNSolsEi; std::ostream::operator<<(int)
cmp bpl, 0Ah
setb al
or al, r15b
jnz short loc_32B02
lea rsi, a0x; ", 0x"
mov edx, 4
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)
lea r15, [rsp+48h+var_40]
mov rdi, r15
mov esi, r14d
call _ZN7testing8internal6String15FormatHexUInt32B5cxx11Ej; testing::internal::String::FormatHexUInt32(uint)
mov rsi, [r15]
mov rdx, [r15+8]
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)
lea rax, [rsp+48h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_32B02
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_32B02:
lea rsi, aTeardowntestsu+12h; ")"
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)
loc_32B16:
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_32B21:
mov rax, [rbx]
mov rax, [rax-18h]
mov r15d, [rbx+rax+18h]
lea rsi, asc_446AB; "\\x"
mov edx, 2
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 rax, [rbx]
mov rcx, [rax-18h]
mov edx, [rbx+rcx+18h]
and edx, 0FFFFFFB5h
or edx, 8
mov [rbx+rcx+18h], edx
mov rax, [rax-18h]
or dword ptr [rbx+rax+18h], 4000h
mov rdi, rbx
mov esi, r14d
call __ZNSolsEi; std::ostream::operator<<(int)
mov rax, [rbx]
mov rax, [rax-18h]
mov [rbx+rax+18h], r15d
mov r15b, 1
jmp loc_32A68
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_32B9F
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_32B9F:
mov rdi, rbx
call __Unwind_Resume
|
long long testing::internal::PrintCharAndCodeTo<signed char>(int a1, long long *a2)
{
const char *v3; // rsi
long long v4; // rdx
char v5; // r15
long long result; // rax
int v7; // r15d
long long v8; // rax
void *v9[2]; // [rsp+8h] [rbp-40h] BYREF
long long v10; // [rsp+18h] [rbp-30h] BYREF
std::__ostream_insert<char,std::char_traits<char>>(a2, "", 0LL);
std::__ostream_insert<char,std::char_traits<char>>(a2, "'", 1LL);
switch ( a1 )
{
case 0:
v3 = "\\0";
goto LABEL_16;
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
goto LABEL_6;
case 7:
v3 = "\\a";
goto LABEL_16;
case 8:
v3 = "\\b";
goto LABEL_16;
case 9:
v3 = "\\t";
goto LABEL_16;
case 10:
v3 = "\\n";
goto LABEL_16;
case 11:
v3 = "\\v";
goto LABEL_16;
case 12:
v3 = "\\f";
goto LABEL_16;
case 13:
v3 = "\\r";
goto LABEL_16;
default:
if ( a1 == 39 )
{
v3 = "\\'";
goto LABEL_16;
}
if ( a1 == 92 )
{
v3 = "\\\\";
LABEL_16:
v4 = 2LL;
goto LABEL_17;
}
LABEL_6:
if ( (unsigned int)(unsigned __int8)a1 - 32 <= 0x5E )
{
v3 = (const char *)v9;
LOBYTE(v9[0]) = a1;
v4 = 1LL;
LABEL_17:
std::__ostream_insert<char,std::char_traits<char>>(a2, v3, v4);
v5 = 0;
goto LABEL_18;
}
v7 = *(_DWORD *)((char *)a2 + *(_QWORD *)(*a2 - 24) + 24);
std::__ostream_insert<char,std::char_traits<char>>(a2, "\\x", 2LL);
v8 = *a2;
*(_DWORD *)((char *)a2 + *(_QWORD *)(*a2 - 24) + 24) = *(_DWORD *)((_BYTE *)a2 + *(_QWORD *)(*a2 - 24) + 24) & 0xFFFFFFB5 | 8;
*(_DWORD *)((char *)a2 + *(_QWORD *)(v8 - 24) + 24) |= 0x4000u;
std::ostream::operator<<(a2, (unsigned __int8)a1);
*(_DWORD *)((char *)a2 + *(_QWORD *)(*a2 - 24) + 24) = v7;
v5 = 1;
LABEL_18:
result = std::__ostream_insert<char,std::char_traits<char>>(a2, "'", 1LL);
if ( (_BYTE)a1 )
{
std::__ostream_insert<char,std::char_traits<char>>(a2, " (", 2LL);
std::ostream::operator<<(a2, (unsigned int)(char)a1);
if ( !((unsigned __int8)v5 | ((unsigned __int8)a1 < 0xAu)) )
{
std::__ostream_insert<char,std::char_traits<char>>(a2, ", 0x", 4LL);
testing::internal::String::FormatHexUInt32[abi:cxx11]((long long)v9, (char)a1);
std::__ostream_insert<char,std::char_traits<char>>(a2, v9[0], v9[1]);
if ( v9[0] != &v10 )
operator delete(v9[0], v10 + 1);
}
return std::__ostream_insert<char,std::char_traits<char>>(a2, ")", 1LL);
}
return result;
}
}
|
PrintCharAndCodeTo<signed_char>:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RSI
MOV EBP,EDI
LEA RSI,[0x1432de]
MOV RDI,RBX
XOR EDX,EDX
CALL 0x001085b0
LEA RSI,[0x1428cd]
MOV EDX,0x1
MOV RDI,RBX
CALL 0x001085b0
CMP EBP,0xd
JA 0x001329df
MOV EAX,EBP
LEA RCX,[0x141e98]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
LEA RSI,[0x142d0c]
JMP 0x00132a58
default:
CMP EBP,0x27
JZ 0x00132a51
CMP EBP,0x5c
JNZ 0x001329f2
LEA RSI,[0x1446a2]
JMP 0x00132a58
caseD_1:
MOVZX R14D,BPL
LEA EAX,[R14 + -0x20]
CMP EAX,0x5e
JA 0x00132b21
LEA RSI,[RSP + 0x8]
MOV byte ptr [RSI],BPL
MOV EDX,0x1
JMP 0x00132a5d
caseD_b:
LEA RSI,[0x1446a8]
JMP 0x00132a58
caseD_c:
LEA RSI,[0x143642]
JMP 0x00132a58
caseD_d:
LEA RSI,[0x143645]
JMP 0x00132a58
caseD_7:
LEA RSI,[0x1446a5]
JMP 0x00132a58
caseD_a:
LEA RSI,[0x14363f]
JMP 0x00132a58
caseD_8:
LEA RSI,[0x143639]
JMP 0x00132a58
caseD_9:
LEA RSI,[0x14363c]
JMP 0x00132a58
LAB_00132a51:
LEA RSI,[0x14469f]
LAB_00132a58:
MOV EDX,0x2
LAB_00132a5d:
MOV RDI,RBX
CALL 0x001085b0
XOR R15D,R15D
LAB_00132a68:
LEA RSI,[0x1428cd]
MOV EDX,0x1
MOV RDI,RBX
CALL 0x001085b0
TEST BPL,BPL
JZ 0x00132b16
MOVSX R14D,BPL
LEA RSI,[0x1405d2]
MOV EDX,0x2
MOV RDI,RBX
CALL 0x001085b0
MOV RDI,RBX
MOV ESI,R14D
CALL 0x00108950
CMP BPL,0xa
SETC AL
OR AL,R15B
JNZ 0x00132b02
LEA RSI,[0x14469a]
MOV EDX,0x4
MOV RDI,RBX
CALL 0x001085b0
LEA R15,[RSP + 0x8]
MOV RDI,R15
MOV ESI,R14D
CALL 0x0011f4c0
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
LAB_00132adf:
MOV RDI,RBX
CALL 0x001085b0
LAB_00132ae7:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00132b02
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001084e0
LAB_00132b02:
LEA RSI,[0x14311d]
MOV EDX,0x1
MOV RDI,RBX
CALL 0x001085b0
LAB_00132b16:
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00132b21:
MOV RAX,qword ptr [RBX]
MOV RAX,qword ptr [RAX + -0x18]
MOV R15D,dword ptr [RBX + RAX*0x1 + 0x18]
LEA RSI,[0x1446ab]
MOV EDX,0x2
MOV RDI,RBX
CALL 0x001085b0
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [RAX + -0x18]
MOV EDX,dword ptr [RBX + RCX*0x1 + 0x18]
AND EDX,0xffffffb5
OR EDX,0x8
MOV dword ptr [RBX + RCX*0x1 + 0x18],EDX
MOV RAX,qword ptr [RAX + -0x18]
OR dword ptr [RBX + RAX*0x1 + 0x18],0x4000
MOV RDI,RBX
MOV ESI,R14D
CALL 0x00108950
MOV RAX,qword ptr [RBX]
MOV RAX,qword ptr [RAX + -0x18]
MOV dword ptr [RBX + RAX*0x1 + 0x18],R15D
MOV R15B,0x1
JMP 0x00132a68
|
/* void testing::internal::PrintCharAndCodeTo<signed char>(signed char, std::ostream*) */
void testing::internal::PrintCharAndCodeTo<signed_char>(uint param_1,ostream *param_2)
{
int4 uVar1;
long lVar2;
bool bVar3;
long lVar4;
byte bVar5;
byte *pbVar6;
byte local_40;
int7 uStack_3f;
long local_38;
long local_30 [2];
std::__ostream_insert<char,std::char_traits<char>>(param_2,"",0);
std::__ostream_insert<char,std::char_traits<char>>(param_2,"\'",1);
bVar5 = (byte)param_1;
switch(param_1) {
case 0:
pbVar6 = &DAT_00142d0c;
break;
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
switchD_001329d4_caseD_1:
if (0x5e < (param_1 & 0xff) - 0x20) {
uVar1 = *(int4 *)(param_2 + *(long *)(*(long *)param_2 + -0x18) + 0x18);
std::__ostream_insert<char,std::char_traits<char>>(param_2,"\\x",2);
lVar4 = *(long *)param_2;
lVar2 = *(long *)(lVar4 + -0x18);
*(uint *)(param_2 + lVar2 + 0x18) = *(uint *)(param_2 + lVar2 + 0x18) & 0xffffffb5 | 8;
*(uint *)(param_2 + *(long *)(lVar4 + -0x18) + 0x18) =
*(uint *)(param_2 + *(long *)(lVar4 + -0x18) + 0x18) | 0x4000;
std::ostream::operator<<(param_2,param_1 & 0xff);
*(int4 *)(param_2 + *(long *)(*(long *)param_2 + -0x18) + 0x18) = uVar1;
bVar3 = true;
goto LAB_00132a68;
}
pbVar6 = &local_40;
lVar4 = 1;
local_40 = bVar5;
goto LAB_00132a5d;
case 7:
pbVar6 = &DAT_001446a5;
break;
case 8:
pbVar6 = &DAT_00143639;
break;
case 9:
pbVar6 = &DAT_0014363c;
break;
case 10:
pbVar6 = &DAT_0014363f;
break;
case 0xb:
pbVar6 = &DAT_001446a8;
break;
case 0xc:
pbVar6 = &DAT_00143642;
break;
case 0xd:
pbVar6 = &DAT_00143645;
break;
default:
if (param_1 == 0x27) {
pbVar6 = &DAT_0014469f;
}
else {
if (param_1 != 0x5c) goto switchD_001329d4_caseD_1;
pbVar6 = &DAT_001446a2;
}
}
lVar4 = 2;
LAB_00132a5d:
std::__ostream_insert<char,std::char_traits<char>>(param_2,(char *)pbVar6,lVar4);
bVar3 = false;
LAB_00132a68:
std::__ostream_insert<char,std::char_traits<char>>(param_2,"\'",1);
if (bVar5 != 0) {
std::__ostream_insert<char,std::char_traits<char>>(param_2," (",2);
std::ostream::operator<<(param_2,(int)(char)bVar5);
if (9 < bVar5 && !bVar3) {
std::__ostream_insert<char,std::char_traits<char>>(param_2,", 0x",4);
String::FormatHexUInt32_abi_cxx11_((uint)&local_40);
/* try { // try from 00132adf to 00132ae6 has its CatchHandler @ 00132b81 */
std::__ostream_insert<char,std::char_traits<char>>
(param_2,(char *)CONCAT71(uStack_3f,local_40),local_38);
if ((long *)CONCAT71(uStack_3f,local_40) != local_30) {
operator_delete((long *)CONCAT71(uStack_3f,local_40),local_30[0] + 1);
}
}
std::__ostream_insert<char,std::char_traits<char>>(param_2,")",1);
}
return;
}
|
|
6,844 |
mpvio_info
|
eloqsql/libmariadb/plugins/auth/my_auth.c
|
void mpvio_info(MARIADB_PVIO *pvio, MYSQL_PLUGIN_VIO_INFO *info)
{
memset(info, 0, sizeof(*info));
switch (pvio->type) {
case PVIO_TYPE_SOCKET:
info->protocol= MYSQL_VIO_TCP;
ma_pvio_get_handle(pvio, &info->socket);
return;
case PVIO_TYPE_UNIXSOCKET:
info->protocol= MYSQL_VIO_SOCKET;
ma_pvio_get_handle(pvio, &info->socket);
return;
/*
case VIO_TYPE_SSL:
{
struct sockaddr addr;
SOCKET_SIZE_TYPE addrlen= sizeof(addr);
if (getsockname(vio->sd, &addr, &addrlen))
return;
info->protocol= addr.sa_family == AF_UNIX ?
MYSQL_VIO_SOCKET : MYSQL_VIO_TCP;
info->socket= vio->sd;
return;
}
*/
#ifdef _WIN32
/*
case VIO_TYPE_NAMEDPIPE:
info->protocol= MYSQL_VIO_PIPE;
info->handle= vio->hPipe;
return;
*/
/* not supported yet
case VIO_TYPE_SHARED_MEMORY:
info->protocol= MYSQL_VIO_MEMORY;
info->handle= vio->handle_file_map;
return;
*/
#endif
default: DBUG_ASSERT(0);
}
}
|
O0
|
c
|
mpvio_info:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x5a052
jmp 0x5a02b
movl -0x14(%rbp), %eax
subl $0x1, %eax
jne 0x5a06f
jmp 0x5a035
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
callq 0x3e400
jmp 0x5a071
movq -0x10(%rbp), %rax
movl $0x2, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
callq 0x3e400
jmp 0x5a071
jmp 0x5a071
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
mpvio_info:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov qword ptr [rax], 0
mov rax, [rbp+var_8]
mov eax, [rax+20h]
mov [rbp+var_14], eax
test eax, eax
jz short loc_5A052
jmp short $+2
loc_5A02B:
mov eax, [rbp+var_14]
sub eax, 1
jnz short loc_5A06F
jmp short $+2
loc_5A035:
mov rax, [rbp+var_10]
mov dword ptr [rax], 1
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
add rsi, 4
call ma_pvio_get_handle
jmp short loc_5A071
loc_5A052:
mov rax, [rbp+var_10]
mov dword ptr [rax], 2
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
add rsi, 4
call ma_pvio_get_handle
jmp short loc_5A071
loc_5A06F:
jmp short $+2
loc_5A071:
add rsp, 20h
pop rbp
retn
|
char mpvio_info(long long a1, _QWORD *a2)
{
char result; // al
int v3; // [rsp+Ch] [rbp-14h]
*a2 = 0LL;
v3 = *(_DWORD *)(a1 + 32);
if ( v3 )
{
result = v3 - 1;
if ( v3 == 1 )
{
*(_DWORD *)a2 = 1;
return ma_pvio_get_handle(a1, (long long)a2 + 4);
}
}
else
{
*(_DWORD *)a2 = 2;
return ma_pvio_get_handle(a1, (long long)a2 + 4);
}
return result;
}
|
mpvio_info:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x20]
MOV dword ptr [RBP + -0x14],EAX
TEST EAX,EAX
JZ 0x0015a052
JMP 0x0015a02b
LAB_0015a02b:
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x1
JNZ 0x0015a06f
JMP 0x0015a035
LAB_0015a035:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x1
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x4
CALL 0x0013e400
JMP 0x0015a071
LAB_0015a052:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x2
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x4
CALL 0x0013e400
JMP 0x0015a071
LAB_0015a06f:
JMP 0x0015a071
LAB_0015a071:
ADD RSP,0x20
POP RBP
RET
|
void mpvio_info(long param_1,int8 *param_2)
{
*param_2 = 0;
if (*(int *)(param_1 + 0x20) == 0) {
*(int4 *)param_2 = 2;
ma_pvio_get_handle(param_1,(long)param_2 + 4);
}
else if (*(int *)(param_1 + 0x20) == 1) {
*(int4 *)param_2 = 1;
ma_pvio_get_handle(param_1,(long)param_2 + 4);
}
return;
}
|
|
6,845 |
int rapidcsv::Document::GetCell<int>(unsigned long, unsigned long) const
|
Andrewchistyakov[P]flashcards_lyc/src/rapidcsv.h
|
T GetCell(const size_t pColumnIdx, const size_t pRowIdx) const
{
const size_t dataColumnIdx = GetDataColumnIndex(pColumnIdx);
const size_t dataRowIdx = GetDataRowIndex(pRowIdx);
T val;
Converter<T> converter(mConverterParams);
converter.ToVal(mData.at(dataRowIdx).at(dataColumnIdx), val);
return val;
}
|
O1
|
c
|
int rapidcsv::Document::GetCell<int>(unsigned long, unsigned long) const:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rax
movl 0x20(%rdi), %r8d
movl 0x24(%rdi), %ecx
leal 0x1(%rcx), %esi
xorl %r9d, %r9d
cmpl $-0x1, %ecx
cmovll %r9d, %esi
leal 0x1(%r8), %ecx
cmpl $-0x1, %r8d
cmovll %r9d, %ecx
addq %rdx, %rcx
leaq 0x30(%rdi), %rdx
movq %rdx, (%rsp)
movq 0x68(%rdi), %r8
movq 0x70(%rdi), %rdi
subq %r8, %rdi
sarq $0x3, %rdi
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdi, %rdx
cmpq %rcx, %rdx
jbe 0x1fcab
addq %rax, %rsi
leaq (%rcx,%rcx,2), %rcx
movq (%r8,%rcx,8), %rax
movq 0x8(%r8,%rcx,8), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %rsi, %rdx
jbe 0x1fcb7
shlq $0x5, %rsi
addq %rsi, %rax
movq %rsp, %rdi
leaq 0xc(%rsp), %rbx
movq %rax, %rsi
movq %rbx, %rdx
callq 0x1f98e
movl (%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x1dedb(%rip), %rdi # 0x3db8d
movq %rcx, %rsi
jmp 0x1fcbe
leaq 0x1decf(%rip), %rdi # 0x3db8d
xorl %eax, %eax
callq 0xb650
nop
|
_ZNK8rapidcsv8Document7GetCellIiEET_mm:
push rbx
sub rsp, 10h
mov rax, rsi
mov r8d, [rdi+20h]
mov ecx, [rdi+24h]
lea esi, [rcx+1]
xor r9d, r9d
cmp ecx, 0FFFFFFFFh
cmovl esi, r9d
lea ecx, [r8+1]
cmp r8d, 0FFFFFFFFh
cmovl ecx, r9d
add rcx, rdx
lea rdx, [rdi+30h]
mov [rsp+18h+var_18], rdx
mov r8, [rdi+68h]
mov rdi, [rdi+70h]
sub rdi, r8
sar rdi, 3
mov rdx, 0AAAAAAAAAAAAAAABh
imul rdx, rdi
cmp rdx, rcx
jbe short loc_1FCAB
add rsi, rax
lea rcx, [rcx+rcx*2]
mov rax, [r8+rcx*8]
mov rdx, [r8+rcx*8+8]
sub rdx, rax
sar rdx, 5
cmp rdx, rsi
jbe short loc_1FCB7
shl rsi, 5
add rax, rsi
mov rdi, rsp
lea rbx, [rsp+18h+var_C]
mov rsi, rax
mov rdx, rbx
call _ZNK8rapidcsv9ConverterIiE5ToValERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERi; rapidcsv::Converter<int>::ToVal(std::string const&,int &)
mov eax, [rbx]
add rsp, 10h
pop rbx
retn
loc_1FCAB:
lea rdi, aVectorMRangeCh; "vector::_M_range_check: __n (which is %"...
mov rsi, rcx
jmp short loc_1FCBE
loc_1FCB7:
lea rdi, aVectorMRangeCh; "vector::_M_range_check: __n (which is %"...
loc_1FCBE:
xor eax, eax
call __ZSt24__throw_out_of_range_fmtPKcz; std::__throw_out_of_range_fmt(char const*,...)
|
long long rapidcsv::Document::GetCell<int>(long long a1, long long a2, long long a3)
{
int v4; // r8d
int v5; // ecx
long long v6; // rsi
long long v7; // rcx
unsigned long long v8; // rcx
long long v9; // r8
unsigned long long v10; // rsi
long long v11; // rcx
long long v12; // rax
long long v14; // [rsp+0h] [rbp-18h] BYREF
_DWORD v15[3]; // [rsp+Ch] [rbp-Ch] BYREF
v4 = *(_DWORD *)(a1 + 32);
v5 = *(_DWORD *)(a1 + 36);
v6 = (unsigned int)(v5 + 1);
if ( v5 < -1 )
v6 = 0LL;
v7 = (unsigned int)(v4 + 1);
if ( v4 < -1 )
v7 = 0LL;
v8 = a3 + v7;
v14 = a1 + 48;
v9 = *(_QWORD *)(a1 + 104);
if ( 0xAAAAAAAAAAAAAAABLL * ((*(_QWORD *)(a1 + 112) - v9) >> 3) <= v8 )
std::__throw_out_of_range_fmt("vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)", v8);
v10 = a2 + v6;
v11 = 3 * v8;
v12 = *(_QWORD *)(v9 + 8 * v11);
if ( (*(_QWORD *)(v9 + 8 * v11 + 8) - v12) >> 5 <= v10 )
std::__throw_out_of_range_fmt("vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)", v10);
rapidcsv::Converter<int>::ToVal((long long)&v14, (long long *)(32 * v10 + v12), v15);
return v15[0];
}
|
GetCell<int>:
PUSH RBX
SUB RSP,0x10
MOV RAX,RSI
MOV R8D,dword ptr [RDI + 0x20]
MOV ECX,dword ptr [RDI + 0x24]
LEA ESI,[RCX + 0x1]
XOR R9D,R9D
CMP ECX,-0x1
CMOVL ESI,R9D
LEA ECX,[R8 + 0x1]
CMP R8D,-0x1
CMOVL ECX,R9D
ADD RCX,RDX
LEA RDX,[RDI + 0x30]
MOV qword ptr [RSP],RDX
MOV R8,qword ptr [RDI + 0x68]
MOV RDI,qword ptr [RDI + 0x70]
SUB RDI,R8
SAR RDI,0x3
MOV RDX,-0x5555555555555555
IMUL RDX,RDI
CMP RDX,RCX
JBE 0x0011fcab
ADD RSI,RAX
LEA RCX,[RCX + RCX*0x2]
MOV RAX,qword ptr [R8 + RCX*0x8]
MOV RDX,qword ptr [R8 + RCX*0x8 + 0x8]
SUB RDX,RAX
SAR RDX,0x5
CMP RDX,RSI
JBE 0x0011fcb7
SHL RSI,0x5
ADD RAX,RSI
MOV RDI,RSP
LEA RBX,[RSP + 0xc]
MOV RSI,RAX
MOV RDX,RBX
CALL 0x0011f98e
MOV EAX,dword ptr [RBX]
ADD RSP,0x10
POP RBX
RET
LAB_0011fcab:
LEA RDI,[0x13db8d]
MOV RSI,RCX
JMP 0x0011fcbe
LAB_0011fcb7:
LEA RDI,[0x13db8d]
LAB_0011fcbe:
XOR EAX,EAX
CALL 0x0010b650
NOP
|
/* int rapidcsv::Document::GetCell<int>(unsigned long, unsigned long) const */
int __thiscall rapidcsv::Document::GetCell<int>(Document *this,ulong param_1,ulong param_2)
{
string *psVar1;
long lVar2;
long lVar3;
int8 uVar4;
ulong uVar5;
ulong uVar6;
long extraout_RDX;
ulong uVar7;
ulong uVar8;
char *pcVar9;
ulong uVar10;
Document *local_18;
int local_c;
uVar7 = (ulong)(*(int *)(this + 0x24) + 1);
if (*(int *)(this + 0x24) < -1) {
uVar7 = 0;
}
uVar5 = (ulong)(*(int *)(this + 0x20) + 1);
if (*(int *)(this + 0x20) < -1) {
uVar5 = 0;
}
uVar5 = uVar5 + param_2;
local_18 = this + 0x30;
lVar2 = *(long *)(this + 0x68);
uVar6 = (*(long *)(this + 0x70) - lVar2 >> 3) * -0x5555555555555555;
uVar10 = uVar5;
uVar8 = uVar5;
if (uVar5 <= uVar6 && uVar6 - uVar5 != 0) {
uVar8 = uVar7 + param_1;
uVar10 = uVar5 * 3;
lVar3 = *(long *)(lVar2 + uVar5 * 0x18);
if (uVar8 < (ulong)(*(long *)(lVar2 + 8 + uVar5 * 0x18) - lVar3 >> 5)) {
Converter<int>::ToVal((Converter<int> *)&local_18,(string *)(lVar3 + uVar8 * 0x20),&local_c);
return local_c;
}
}
pcVar9 = "vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)";
std::__throw_out_of_range_fmt
("vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)");
uVar7 = (ulong)(*(int *)(uVar8 + 0x24) + 1);
if (*(int *)(uVar8 + 0x24) < -1) {
uVar7 = 0;
}
uVar5 = (ulong)(*(int *)(uVar8 + 0x20) + 1);
if (*(int *)(uVar8 + 0x20) < -1) {
uVar5 = 0;
}
uVar5 = uVar5 + uVar10;
psVar1 = (string *)pcVar9 + 0x10;
*(string **)pcVar9 = psVar1;
*(int8 *)((string *)pcVar9 + 8) = 0;
((string *)pcVar9)[0x10] = (string)0x0;
lVar2 = *(long *)(uVar8 + 0x68);
uVar8 = (*(long *)(uVar8 + 0x70) - lVar2 >> 3) * -0x5555555555555555;
uVar10 = uVar5;
if (uVar5 <= uVar8 && uVar8 - uVar5 != 0) {
uVar10 = uVar7 + extraout_RDX;
uVar8 = *(long *)(lVar2 + 8 + uVar5 * 0x18) - *(long *)(lVar2 + uVar5 * 0x18) >> 5;
if (uVar10 < uVar8) {
std::__cxx11::string::_M_assign((string *)pcVar9);
return (int)pcVar9;
}
}
uVar4 = std::__throw_out_of_range_fmt
("vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)",
uVar10,uVar8);
if (*(string **)pcVar9 != psVar1) {
operator_delete(*(string **)pcVar9,*(long *)psVar1 + 1);
}
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar4);
}
|
|
6,846 |
int rapidcsv::Document::GetCell<int>(unsigned long, unsigned long) const
|
Andrewchistyakov[P]flashcards_lyc/src/rapidcsv.h
|
T GetCell(const size_t pColumnIdx, const size_t pRowIdx) const
{
const size_t dataColumnIdx = GetDataColumnIndex(pColumnIdx);
const size_t dataRowIdx = GetDataRowIndex(pRowIdx);
T val;
Converter<T> converter(mConverterParams);
converter.ToVal(mData.at(dataRowIdx).at(dataColumnIdx), val);
return val;
}
|
O2
|
c
|
int rapidcsv::Document::GetCell<int>(unsigned long, unsigned long) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x20(%rsi), %edi
movl 0x24(%rsi), %r12d
leal 0x1(%rdi), %eax
xorl %r14d, %r14d
cmpl $-0x1, %edi
cmovll %r14d, %eax
leaq 0x10(%rbx), %rdi
movq %rdi, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rdx, %r15
addq %rcx, %rax
movb $0x0, 0x10(%rbx)
leaq 0x68(%rsi), %rdi
movq %rax, %rsi
callq 0x1b23a
leal 0x1(%r12), %ecx
cmpl $-0x1, %r12d
cmovgel %ecx, %r14d
addq %r15, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x1aa28
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc240
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xc8c8
movq %r14, %rdi
callq 0xc7f0
nop
|
_ZNK8rapidcsv8Document7GetCellINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_mm:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rdi
mov edi, [rsi+20h]
mov r12d, [rsi+24h]
lea eax, [rdi+1]
xor r14d, r14d
cmp edi, 0FFFFFFFFh
cmovl eax, r14d
lea rdi, [rbx+10h]
mov [rbx], rdi
and qword ptr [rbx+8], 0
mov r15, rdx
add rax, rcx
mov byte ptr [rbx+10h], 0
lea rdi, [rsi+68h]
mov rsi, rax
call _ZNKSt6vectorIS_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EESaIS7_EE2atEm; std::vector<std::vector<std::string>>::at(ulong)
lea ecx, [r12+1]
cmp r12d, 0FFFFFFFFh
cmovge r14d, ecx
add r14, r15
mov rdi, rax
mov rsi, r14
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE2atEm; std::vector<std::string>::at(ulong)
mov rdi, rbx
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
mov r14, rax
mov rdi, rbx; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14
call __Unwind_Resume
|
long long rapidcsv::Document::GetCell<std::string>(long long a1, long long a2, long long a3, long long a4)
{
int v5; // edi
int v6; // r12d
long long v7; // rax
long long v8; // r14
_QWORD *v10; // rax
long long v11; // rax
v5 = *(_DWORD *)(a2 + 32);
v6 = *(_DWORD *)(a2 + 36);
v7 = (unsigned int)(v5 + 1);
v8 = 0LL;
if ( v5 < -1 )
v7 = 0LL;
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v10 = (_QWORD *)std::vector<std::vector<std::string>>::at((_QWORD *)(a2 + 104), a4 + v7);
if ( v6 >= -1 )
v8 = (unsigned int)(v6 + 1);
v11 = std::vector<std::string>::at(v10, a3 + v8);
std::string::_M_assign(a1, v11);
return a1;
}
|
GetCell<std::__cxx11::string>:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV EDI,dword ptr [RSI + 0x20]
MOV R12D,dword ptr [RSI + 0x24]
LEA EAX,[RDI + 0x1]
XOR R14D,R14D
CMP EDI,-0x1
CMOVL EAX,R14D
LEA RDI,[RBX + 0x10]
MOV qword ptr [RBX],RDI
AND qword ptr [RBX + 0x8],0x0
MOV R15,RDX
ADD RAX,RCX
MOV byte ptr [RBX + 0x10],0x0
LEA RDI,[RSI + 0x68]
LAB_0011b2b9:
MOV RSI,RAX
CALL 0x0011b23a
LEA ECX,[R12 + 0x1]
CMP R12D,-0x1
CMOVGE R14D,ECX
ADD R14,R15
MOV RDI,RAX
MOV RSI,R14
CALL 0x0011aa28
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0010c240
LAB_0011b2e7:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* std::__cxx11::string rapidcsv::Document::GetCell<std::__cxx11::string >(unsigned long, unsigned
long) const */
ulong rapidcsv::Document::GetCell<std::__cxx11::string>(ulong param_1,ulong param_2)
{
int iVar1;
ulong uVar2;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *this;
long in_RCX;
long in_RDX;
ulong uVar3;
iVar1 = *(int *)(param_2 + 0x24);
uVar3 = 0;
uVar2 = (ulong)(*(int *)(param_2 + 0x20) + 1);
if (*(int *)(param_2 + 0x20) < -1) {
uVar2 = uVar3;
}
*(ulong *)param_1 = param_1 + 0x10;
*(int8 *)(param_1 + 8) = 0;
*(int1 *)(param_1 + 0x10) = 0;
/* try { // try from 0011b2b9 to 0011b2e6 has its CatchHandler @ 0011b2f6 */
this = (vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
std::
vector<std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>,std::allocator<std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>>
::at((vector<std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>,std::allocator<std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>>
*)(param_2 + 0x68),uVar2 + in_RCX);
if (-2 < iVar1) {
uVar3 = (ulong)(iVar1 + 1);
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::at(this,uVar3 + in_RDX);
std::__cxx11::string::_M_assign((string *)param_1);
return param_1;
}
|
|
6,847 |
int rapidcsv::Document::GetCell<int>(unsigned long, unsigned long) const
|
Andrewchistyakov[P]flashcards_lyc/src/rapidcsv.h
|
T GetCell(const size_t pColumnIdx, const size_t pRowIdx) const
{
const size_t dataColumnIdx = GetDataColumnIndex(pColumnIdx);
const size_t dataRowIdx = GetDataRowIndex(pRowIdx);
T val;
Converter<T> converter(mConverterParams);
converter.ToVal(mData.at(dataRowIdx).at(dataColumnIdx), val);
return val;
}
|
O3
|
c
|
int rapidcsv::Document::GetCell<int>(unsigned long, unsigned long) const:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movl 0x20(%rsi), %r8d
movl 0x24(%rsi), %esi
leal 0x1(%rsi), %edi
xorl %r9d, %r9d
cmpl $-0x1, %esi
cmovll %r9d, %edi
leal 0x1(%r8), %esi
cmpl $-0x1, %r8d
cmovll %r9d, %esi
addq %rcx, %rsi
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq 0x68(%rax), %rcx
movq 0x70(%rax), %r8
subq %rcx, %r8
sarq $0x3, %r8
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %r8, %rax
cmpq %rsi, %rax
jbe 0x1fc50
addq %rdx, %rdi
leaq (%rsi,%rsi,2), %rax
movq (%rcx,%rax,8), %rsi
movq 0x8(%rcx,%rax,8), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %rdi, %rax
jbe 0x1fc4d
shlq $0x5, %rdi
addq %rdi, %rsi
movq %rbx, %rdi
callq 0xb1f0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rdi, %rsi
leaq 0x1cf66(%rip), %rdi # 0x3cbbd
movq %rax, %rdx
xorl %eax, %eax
callq 0xb650
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1fc77
movq (%r15), %rsi
incq %rsi
callq 0xb400
movq %r14, %rdi
callq 0xb780
nop
|
_ZNK8rapidcsv8Document7GetCellINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_mm:
push r15
push r14
push rbx
mov rax, rsi
mov rbx, rdi
mov r8d, [rsi+20h]
mov esi, [rsi+24h]
lea edi, [rsi+1]
xor r9d, r9d
cmp esi, 0FFFFFFFFh
cmovl edi, r9d
lea esi, [r8+1]
cmp r8d, 0FFFFFFFFh
cmovl esi, r9d
add rsi, rcx
lea r15, [rbx+10h]
mov [rbx], r15
mov qword ptr [rbx+8], 0
mov byte ptr [rbx+10h], 0
mov rcx, [rax+68h]
mov r8, [rax+70h]
sub r8, rcx
sar r8, 3
mov rax, 0AAAAAAAAAAAAAAABh
imul rax, r8
cmp rax, rsi
jbe short loc_1FC50
add rdi, rdx
lea rax, [rsi+rsi*2]
mov rsi, [rcx+rax*8]
mov rax, [rcx+rax*8+8]
sub rax, rsi
sar rax, 5
cmp rax, rdi
jbe short loc_1FC4D
shl rdi, 5
add rsi, rdi
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
mov rax, rbx
pop rbx
pop r14
pop r15
retn
loc_1FC4D:
mov rsi, rdi
loc_1FC50:
lea rdi, aVectorMRangeCh; "vector::_M_range_check: __n (which is %"...
mov rdx, rax
xor eax, eax
call __ZSt24__throw_out_of_range_fmtPKcz; std::__throw_out_of_range_fmt(char const*,...)
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, r15
jz short loc_1FC77
mov rsi, [r15]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1FC77:
mov rdi, r14
call __Unwind_Resume
|
long long rapidcsv::Document::GetCell<std::string>(long long a1, long long a2, long long a3, long long a4)
{
int v6; // r8d
int v7; // esi
long long v8; // rdi
long long v9; // rsi
unsigned long long v10; // rsi
long long v11; // rcx
unsigned long long v12; // rax
unsigned long long v13; // rdi
long long v14; // rax
long long v15; // rsi
v6 = *(_DWORD *)(a2 + 32);
v7 = *(_DWORD *)(a2 + 36);
v8 = (unsigned int)(v7 + 1);
if ( v7 < -1 )
v8 = 0LL;
v9 = (unsigned int)(v6 + 1);
if ( v6 < -1 )
v9 = 0LL;
v10 = a4 + v9;
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v11 = *(_QWORD *)(a2 + 104);
v12 = 0xAAAAAAAAAAAAAAABLL * ((*(_QWORD *)(a2 + 112) - v11) >> 3);
if ( v12 <= v10 )
LABEL_9:
std::__throw_out_of_range_fmt("vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)", v10, v12);
v13 = a3 + v8;
v14 = 3 * v10;
v15 = *(_QWORD *)(v11 + 24 * v10);
v12 = (*(_QWORD *)(v11 + 8 * v14 + 8) - v15) >> 5;
if ( v12 <= v13 )
{
v10 = v13;
goto LABEL_9;
}
std::string::_M_assign(a1, 32 * v13 + v15);
return a1;
}
|
GetCell<std::__cxx11::string>:
PUSH R15
PUSH R14
PUSH RBX
MOV RAX,RSI
MOV RBX,RDI
MOV R8D,dword ptr [RSI + 0x20]
MOV ESI,dword ptr [RSI + 0x24]
LEA EDI,[RSI + 0x1]
XOR R9D,R9D
CMP ESI,-0x1
CMOVL EDI,R9D
LEA ESI,[R8 + 0x1]
CMP R8D,-0x1
CMOVL ESI,R9D
ADD RSI,RCX
LEA R15,[RBX + 0x10]
MOV qword ptr [RBX],R15
MOV qword ptr [RBX + 0x8],0x0
MOV byte ptr [RBX + 0x10],0x0
MOV RCX,qword ptr [RAX + 0x68]
MOV R8,qword ptr [RAX + 0x70]
SUB R8,RCX
SAR R8,0x3
MOV RAX,-0x5555555555555555
IMUL RAX,R8
CMP RAX,RSI
JBE 0x0011fc50
ADD RDI,RDX
LEA RAX,[RSI + RSI*0x2]
MOV RSI,qword ptr [RCX + RAX*0x8]
MOV RAX,qword ptr [RCX + RAX*0x8 + 0x8]
SUB RAX,RSI
SAR RAX,0x5
CMP RAX,RDI
JBE 0x0011fc4d
SHL RDI,0x5
ADD RSI,RDI
LAB_0011fc3c:
MOV RDI,RBX
CALL 0x0010b1f0
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
LAB_0011fc4d:
MOV RSI,RDI
LAB_0011fc50:
LEA RDI,[0x13cbbd]
MOV RDX,RAX
XOR EAX,EAX
CALL 0x0010b650
LAB_0011fc61:
MOV R14,RAX
MOV RDI,qword ptr [RBX]
CMP RDI,R15
JZ 0x0011fc77
MOV RSI,qword ptr [R15]
INC RSI
CALL 0x0010b400
LAB_0011fc77:
MOV RDI,R14
CALL 0x0010b780
|
/* std::__cxx11::string rapidcsv::Document::GetCell<std::__cxx11::string >(unsigned long, unsigned
long) const */
ulong rapidcsv::Document::GetCell<std::__cxx11::string>(ulong param_1,ulong param_2)
{
long *plVar1;
long lVar2;
ulong uVar3;
int8 uVar4;
long in_RCX;
long in_RDX;
ulong uVar5;
ulong uVar6;
ulong uVar7;
uVar6 = (ulong)(*(int *)(param_2 + 0x24) + 1);
if (*(int *)(param_2 + 0x24) < -1) {
uVar6 = 0;
}
uVar5 = (ulong)(*(int *)(param_2 + 0x20) + 1);
if (*(int *)(param_2 + 0x20) < -1) {
uVar5 = 0;
}
uVar5 = uVar5 + in_RCX;
plVar1 = (long *)(param_1 + 0x10);
*(long **)param_1 = plVar1;
*(int8 *)(param_1 + 8) = 0;
*(int1 *)(param_1 + 0x10) = 0;
lVar2 = *(long *)(param_2 + 0x68);
uVar3 = (*(long *)(param_2 + 0x70) - lVar2 >> 3) * -0x5555555555555555;
uVar7 = uVar5;
if (uVar5 <= uVar3 && uVar3 - uVar5 != 0) {
uVar7 = uVar6 + in_RDX;
uVar3 = *(long *)(lVar2 + 8 + uVar5 * 0x18) - *(long *)(lVar2 + uVar5 * 0x18) >> 5;
if (uVar7 < uVar3) {
/* try { // try from 0011fc3c to 0011fc60 has its CatchHandler @ 0011fc61 */
std::__cxx11::string::_M_assign((string *)param_1);
return param_1;
}
}
uVar4 = std::__throw_out_of_range_fmt
("vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)",
uVar7,uVar3);
/* catch() { ... } // from try @ 0011fc3c with catch @ 0011fc61 */
if (*(long **)param_1 != plVar1) {
operator_delete(*(long **)param_1,*plVar1 + 1);
}
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar4);
}
|
|
6,848 |
my_mb_wc_eucjpms
|
eloqsql/strings/ctype-eucjpms.c
|
static int
my_mb_wc_eucjpms(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e)
{
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
if ((hi= s[0]) < 0x80) /* ASCII code set: [00..7F] -> [U+0000..U+007F] */
{
*pwc= hi;
return 1;
}
if (hi >= 0xA1 && hi <= 0xFE) /* JIS X 0208 code set: [A1..FE][A1..FE] */
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
return (*pwc= jisx0208_eucjpms_to_unicode[(hi << 8) + s[1]]) ? 2 :
(s[1] < 0xA1 || s[1] > 0xFE) ? MY_CS_ILSEQ : -2;
}
/* JIS-X-0201 HALF WIDTH KATAKANA: [8E][A1..DF] -> [U+FF61..U+FF9F] */
if (hi == 0x8E)
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
if (s[1] < 0xA1 || s[1] > 0xDF)
return MY_CS_ILSEQ;
*pwc= 0xFEC0 + s[1]; /* 0xFFC0 = 0xFF61 - 0xA1 */
return 2;
}
if (hi == 0x8F) /* JIS X 0212 code set: [8F][A1..FE][A1..FE] */
{
if (s + 3 > e)
return MY_CS_TOOSMALL3;
return (*pwc= jisx0212_eucjpms_to_unicode[(((int) s[1]) << 8) + s[2]]) ?
3 :
(s[1] < 0xA1 || s[1] > 0xFE || s[2] < 0xA1 || s[2] > 0xFE) ?
MY_CS_ILSEQ : -3;
}
return MY_CS_ILSEQ;
}
|
O3
|
c
|
my_mb_wc_eucjpms:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x32996
movzbl (%rdx), %edi
testb %dil, %dil
js 0x32998
movq %rdi, (%rsi)
movl $0x1, %eax
popq %rbp
retq
leal 0x5f(%rdi), %eax
cmpb $0x5d, %al
ja 0x329e4
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0x32996
movzbl 0x1(%rdx), %eax
shll $0x9, %edi
leal (%rdi,%rax,2), %eax
leaq 0xa6bc2(%rip), %rcx # 0xd9580
movzwl (%rax,%rcx), %ecx
movq %rcx, (%rsi)
movl $0x2, %eax
testq %rcx, %rcx
jne 0x32996
movb 0x1(%rdx), %al
incb %al
xorl %ecx, %ecx
cmpb $-0x5e, %al
setb %cl
leal -0x2(,%rcx,2), %eax
jmp 0x32996
cmpq $0x8f, %rdi
je 0x32a28
cmpl $0x8e, %edi
jne 0x32a6a
leaq 0x2(%rdx), %rdi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rdi
ja 0x32996
movzbl 0x1(%rdx), %ecx
leal 0x20(%rcx), %edx
movl $0x0, %eax
cmpb $-0x3f, %dl
jb 0x32996
addq $0xfec0, %rcx # imm = 0xFEC0
movq %rcx, (%rsi)
movl $0x2, %eax
jmp 0x32996
leaq 0x3(%rdx), %rdi
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rcx, %rdi
ja 0x32996
movzwl 0x1(%rdx), %eax
rolw $0x8, %ax
movzwl %ax, %eax
leaq 0xc6b34(%rip), %rcx # 0xf9580
movzwl (%rcx,%rax,2), %ecx
movq %rcx, (%rsi)
movl $0x3, %eax
testq %rcx, %rcx
jne 0x32996
movb 0x1(%rdx), %al
incb %al
cmpb $-0x5e, %al
jae 0x32a71
xorl %eax, %eax
jmp 0x32996
movb 0x2(%rdx), %cl
movl $0x0, %eax
cmpb $-0x5f, %cl
jb 0x32996
xorl %eax, %eax
cmpb $-0x1, %cl
sete %al
leal (%rax,%rax,2), %eax
addl $-0x3, %eax
jmp 0x32996
|
my_mb_wc_eucjpms:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_32996
movzx edi, byte ptr [rdx]
test dil, dil
js short loc_32998
mov [rsi], rdi
mov eax, 1
loc_32996:
pop rbp
retn
loc_32998:
lea eax, [rdi+5Fh]
cmp al, 5Dh ; ']'
ja short loc_329E4
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short loc_32996
movzx eax, byte ptr [rdx+1]
shl edi, 9
lea eax, [rdi+rax*2]
lea rcx, jisx0208_eucjpms_to_unicode
movzx ecx, word ptr [rax+rcx]
mov [rsi], rcx
mov eax, 2
test rcx, rcx
jnz short loc_32996
mov al, [rdx+1]
inc al
xor ecx, ecx
cmp al, 0A2h
setb cl
lea eax, ds:0FFFFFFFFFFFFFFFEh[rcx*2]
jmp short loc_32996
loc_329E4:
cmp rdi, 8Fh
jz short loc_32A28
cmp edi, 8Eh
jnz short loc_32A6A
lea rdi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rdi, rcx
ja short loc_32996
movzx ecx, byte ptr [rdx+1]
lea edx, [rcx+20h]
mov eax, 0
cmp dl, 0C1h
jb short loc_32996
add rcx, 0FEC0h
mov [rsi], rcx
mov eax, 2
jmp loc_32996
loc_32A28:
lea rdi, [rdx+3]
mov eax, 0FFFFFF99h
cmp rdi, rcx
ja loc_32996
movzx eax, word ptr [rdx+1]
rol ax, 8
movzx eax, ax
lea rcx, jisx0212_eucjpms_to_unicode
movzx ecx, word ptr [rcx+rax*2]
mov [rsi], rcx
mov eax, 3
test rcx, rcx
jnz loc_32996
mov al, [rdx+1]
inc al
cmp al, 0A2h
jnb short loc_32A71
loc_32A6A:
xor eax, eax
jmp loc_32996
loc_32A71:
mov cl, [rdx+2]
mov eax, 0
cmp cl, 0A1h
jb loc_32996
xor eax, eax
cmp cl, 0FFh
setz al
lea eax, [rax+rax*2]
add eax, 0FFFFFFFDh
jmp loc_32996
|
long long my_mb_wc_eucjpms(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rdi
long long v6; // rcx
long long v7; // rcx
long long v8; // rcx
unsigned __int8 v9; // cl
result = 4294967195LL;
if ( (unsigned long long)a3 >= a4 )
return result;
v5 = *a3;
if ( (v5 & 0x80u) == 0LL )
{
*a2 = v5;
return 1LL;
}
if ( (unsigned __int8)(v5 + 95) <= 0x5Du )
{
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v6 = jisx0208_eucjpms_to_unicode[256 * (_DWORD)v5 + a3[1]];
*a2 = v6;
result = 2LL;
if ( !v6 )
return 2 * (unsigned int)((unsigned __int8)(a3[1] + 1) < 0xA2u) - 2;
}
return result;
}
if ( v5 != 143 )
{
if ( (_DWORD)v5 == 142 )
{
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v7 = a3[1];
result = 0LL;
if ( (unsigned __int8)(v7 + 32) >= 0xC1u )
{
*a2 = v7 + 65216;
return 2LL;
}
}
return result;
}
return 0LL;
}
result = 4294967193LL;
if ( (unsigned long long)(a3 + 3) > a4 )
return result;
v8 = jisx0212_eucjpms_to_unicode[(unsigned __int16)__ROL2__(*(_WORD *)(a3 + 1), 8)];
*a2 = v8;
result = 3LL;
if ( v8 )
return result;
if ( (unsigned __int8)(a3[1] + 1) < 0xA2u )
return 0LL;
v9 = a3[2];
result = 0LL;
if ( v9 >= 0xA1u )
return 3 * (unsigned int)(v9 == 0xFF) - 3;
return result;
}
|
my_mb_wc_eucjpms:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x00132996
MOVZX EDI,byte ptr [RDX]
TEST DIL,DIL
JS 0x00132998
MOV qword ptr [RSI],RDI
MOV EAX,0x1
LAB_00132996:
POP RBP
RET
LAB_00132998:
LEA EAX,[RDI + 0x5f]
CMP AL,0x5d
JA 0x001329e4
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x00132996
MOVZX EAX,byte ptr [RDX + 0x1]
SHL EDI,0x9
LEA EAX,[RDI + RAX*0x2]
LEA RCX,[0x1d9580]
MOVZX ECX,word ptr [RAX + RCX*0x1]
MOV qword ptr [RSI],RCX
MOV EAX,0x2
TEST RCX,RCX
JNZ 0x00132996
MOV AL,byte ptr [RDX + 0x1]
INC AL
XOR ECX,ECX
CMP AL,0xa2
SETC CL
LEA EAX,[-0x2 + RCX*0x2]
JMP 0x00132996
LAB_001329e4:
CMP RDI,0x8f
JZ 0x00132a28
CMP EDI,0x8e
JNZ 0x00132a6a
LEA RDI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RDI,RCX
JA 0x00132996
MOVZX ECX,byte ptr [RDX + 0x1]
LEA EDX,[RCX + 0x20]
MOV EAX,0x0
CMP DL,0xc1
JC 0x00132996
ADD RCX,0xfec0
MOV qword ptr [RSI],RCX
MOV EAX,0x2
JMP 0x00132996
LAB_00132a28:
LEA RDI,[RDX + 0x3]
MOV EAX,0xffffff99
CMP RDI,RCX
JA 0x00132996
MOVZX EAX,word ptr [RDX + 0x1]
ROL AX,0x8
MOVZX EAX,AX
LEA RCX,[0x1f9580]
MOVZX ECX,word ptr [RCX + RAX*0x2]
MOV qword ptr [RSI],RCX
MOV EAX,0x3
TEST RCX,RCX
JNZ 0x00132996
MOV AL,byte ptr [RDX + 0x1]
INC AL
CMP AL,0xa2
JNC 0x00132a71
LAB_00132a6a:
XOR EAX,EAX
JMP 0x00132996
LAB_00132a71:
MOV CL,byte ptr [RDX + 0x2]
MOV EAX,0x0
CMP CL,0xa1
JC 0x00132996
XOR EAX,EAX
CMP CL,0xff
SETZ AL
LEA EAX,[RAX + RAX*0x2]
ADD EAX,-0x3
JMP 0x00132996
|
int my_mb_wc_eucjpms(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
ushort uVar2;
int iVar3;
iVar3 = -0x65;
if (param_3 < param_4) {
bVar1 = *param_3;
if ((char)bVar1 < '\0') {
if ((byte)(bVar1 + 0x5f) < 0x5e) {
iVar3 = -0x66;
if (param_3 + 2 <= param_4) {
uVar2 = *(ushort *)
(jisx0208_eucjpms_to_unicode + ((uint)bVar1 * 0x200 + (uint)param_3[1] * 2));
*param_2 = (ulong)uVar2;
iVar3 = 2;
if ((ulong)uVar2 == 0) {
iVar3 = (uint)((byte)(param_3[1] + 1) < 0xa2) * 2 + -2;
}
}
}
else {
if ((ulong)bVar1 == 0x8f) {
if (param_4 < param_3 + 3) {
return -0x67;
}
uVar2 = *(ushort *)
(&jisx0212_eucjpms_to_unicode +
(ulong)(ushort)(*(ushort *)(param_3 + 1) << 8 | *(ushort *)(param_3 + 1) >> 8) *
2);
*param_2 = (ulong)uVar2;
if ((ulong)uVar2 != 0) {
return 3;
}
if (0xa1 < (byte)(param_3[1] + 1)) {
if (param_3[2] < 0xa1) {
return 0;
}
return (uint)(param_3[2] == 0xff) * 3 + -3;
}
}
else if (bVar1 == 0x8e) {
if (param_4 < param_3 + 2) {
return -0x66;
}
if ((byte)(param_3[1] + 0x20) < 0xc1) {
return 0;
}
*param_2 = (ulong)param_3[1] + 0xfec0;
return 2;
}
iVar3 = 0;
}
}
else {
*param_2 = (ulong)bVar1;
iVar3 = 1;
}
}
return iVar3;
}
|
|
6,849 |
minja::Parser::parseIdentifier()
|
monkey531[P]llama/common/minja.hpp
|
std::shared_ptr<VariableExpr> parseIdentifier() {
static std::regex ident_regex(R"((?!(?:not|is|and|or|del)\b)[a-zA-Z_]\w*)");
auto location = get_location();
auto ident = consumeToken(ident_regex);
if (ident.empty())
return nullptr;
return std::make_shared<VariableExpr>(location, ident);
}
|
O3
|
cpp
|
minja::Parser::parseIdentifier():
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa9376(%rip), %rax # 0x12d1f8
movb (%rax), %al
testb %al, %al
je 0x83f44
movq (%r14), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x83eb7
movq 0xa80df(%rip), %rcx # 0x12bf88
cmpb $0x0, (%rcx)
je 0x83eb3
incl 0x8(%rax)
jmp 0x83eb7
lock
incl 0x8(%rax)
movq 0x20(%r14), %rax
subq 0x10(%r14), %rax
movq %rax, 0x20(%rsp)
leaq 0xa930d(%rip), %rdx # 0x12d1d8
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x83816
cmpq $0x0, 0x30(%rsp)
je 0x83f09
movq $0x0, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0xf(%rsp), %rdx
leaq 0x10(%rsp), %rcx
leaq 0x28(%rsp), %r8
movq %rbx, %rsi
callq 0x982e4
jmp 0x83f0f
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x83f2a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a8d0
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x83f39
callq 0x6d59a
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
leaq 0xa92ad(%rip), %rdi # 0x12d1f8
callq 0x1b020
testl %eax, %eax
je 0x83e8c
leaq 0xa9279(%rip), %rdi # 0x12d1d8
leaq 0x6ca80(%rip), %rsi # 0xf09e6
movl $0x10, %edx
callq 0x62528
leaq -0x2174b(%rip), %rdi # 0x6282c
leaq 0xa925a(%rip), %rsi # 0x12d1d8
leaq 0xa8953(%rip), %rdx # 0x12c8d8
callq 0x1a7a0
leaq 0xa9267(%rip), %rdi # 0x12d1f8
callq 0x1a5d0
jmp 0x83e8c
movq %rax, %rbx
leaq 0xa9253(%rip), %rdi # 0x12d1f8
callq 0x1a5c0
jmp 0x83fde
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x83fcf
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a8d0
jmp 0x83fcf
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x83fde
callq 0x6d59a
movq %rbx, %rdi
callq 0x1afc0
|
_ZN5minja6Parser15parseIdentifierEv:
push r14
push rbx
sub rsp, 48h
mov r14, rsi
mov rbx, rdi
lea rax, _ZGVZN5minja6Parser15parseIdentifierEvE11ident_regexB5cxx11; `guard variable for'minja::Parser::parseIdentifier(void)::ident_regex
mov al, [rax]
test al, al
jz loc_83F44
loc_83E8C:
mov rax, [r14]
mov [rsp+58h+var_48], rax
mov rax, [r14+8]
mov [rsp+58h+var_40], rax
test rax, rax
jz short loc_83EB7
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_83EB3
inc dword ptr [rax+8]
jmp short loc_83EB7
loc_83EB3:
lock inc dword ptr [rax+8]
loc_83EB7:
mov rax, [r14+20h]
sub rax, [r14+10h]
mov [rsp+58h+var_38], rax
lea rdx, _ZZN5minja6Parser15parseIdentifierEvE11ident_regexB5cxx11; minja::Parser::parseIdentifier(void)::ident_regex
lea rdi, [rsp+58h+var_30]
mov rsi, r14
mov ecx, 1
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
cmp [rsp+58h+var_28], 0
jz short loc_83F09
mov qword ptr [rbx], 0
lea rdi, [rbx+8]
lea rdx, [rsp+58h+var_49]
lea rcx, [rsp+58h+var_48]
lea r8, [rsp+58h+var_30]
mov rsi, rbx
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EEC2IN5minja12VariableExprESaIS5_EJRNS4_8LocationERNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEERPT_St20_Sp_alloc_shared_tagIT0_EDpOT1_; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<minja::VariableExpr,std::allocator<minja::VariableExpr>,minja::Location &,std::string &>(minja::VariableExpr *&,std::_Sp_alloc_shared_tag<std::allocator<minja::VariableExpr>>,minja::Location &,std::string &)
jmp short loc_83F0F
loc_83F09:
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
loc_83F0F:
lea rax, [rsp+58h+var_20]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_83F2A
mov rsi, [rsp+58h+var_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_83F2A:
mov rdi, [rsp+58h+var_40]
test rdi, rdi
jz short loc_83F39
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_83F39:
mov rax, rbx
add rsp, 48h
pop rbx
pop r14
retn
loc_83F44:
lea rdi, _ZGVZN5minja6Parser15parseIdentifierEvE11ident_regexB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_83E8C
lea rdi, _ZZN5minja6Parser15parseIdentifierEvE11ident_regexB5cxx11; minja::Parser::parseIdentifier(void)::ident_regex
lea rsi, aNotIsAndOrDelB; "(?!(?:not|is|and|or|del)\\b)[a-zA-Z_]\\"...
mov edx, 10h
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser15parseIdentifierEvE11ident_regexB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser15parseIdentifierEvE11ident_regexB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_83E8C
mov rbx, rax
lea rdi, _ZGVZN5minja6Parser15parseIdentifierEvE11ident_regexB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_83FDE
mov rbx, rax
lea rax, [rsp+arg_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_83FCF
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_83FCF
mov rbx, rax
loc_83FCF:
mov rdi, [rsp+arg_10]
test rdi, rdi
jz short loc_83FDE
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_83FDE:
mov rdi, rbx
call __Unwind_Resume
|
minja::Parser * minja::Parser::parseIdentifier(minja::Parser *this, long long *a2)
{
volatile signed __int32 *v2; // rax
char v4; // [rsp+Fh] [rbp-49h] BYREF
long long v5; // [rsp+10h] [rbp-48h] BYREF
volatile signed __int32 *v6; // [rsp+18h] [rbp-40h]
long long v7; // [rsp+20h] [rbp-38h]
void *v8[2]; // [rsp+28h] [rbp-30h] BYREF
long long v9; // [rsp+38h] [rbp-20h] BYREF
if ( !(_BYTE)`guard variable for'minja::Parser::parseIdentifier(void)::ident_regex[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseIdentifier(void)::ident_regex[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseIdentifier(void)::ident_regex[abi:cxx11],
(long long)"(?!(?:not|is|and|or|del)\\b)[a-zA-Z_]\\w*",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseIdentifier(void)::ident_regex[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseIdentifier(void)::ident_regex[abi:cxx11]);
}
v5 = *a2;
v2 = (volatile signed __int32 *)a2[1];
v6 = v2;
if ( v2 )
{
if ( _libc_single_threaded )
++*((_DWORD *)v2 + 2);
else
_InterlockedIncrement(v2 + 2);
}
v7 = a2[4] - a2[2];
minja::Parser::consumeToken(
(long long)v8,
(long long)a2,
(long long)&minja::Parser::parseIdentifier(void)::ident_regex[abi:cxx11],
1u);
if ( v8[1] )
{
*(_QWORD *)this = 0LL;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<minja::VariableExpr,std::allocator<minja::VariableExpr>,minja::Location &,std::string &>(
(char *)this + 8,
this,
&v4,
&v5,
v8);
}
else
{
*(_OWORD *)this = 0LL;
}
if ( v8[0] != &v9 )
operator delete(v8[0], v9 + 1);
if ( v6 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v6);
return this;
}
|
parseIdentifier:
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV R14,RSI
MOV RBX,RDI
LEA RAX,[0x22d1f8]
MOV AL,byte ptr [RAX]
TEST AL,AL
JZ 0x00183f44
LAB_00183e8c:
MOV RAX,qword ptr [R14]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [R14 + 0x8]
MOV qword ptr [RSP + 0x18],RAX
TEST RAX,RAX
JZ 0x00183eb7
MOV RCX,qword ptr [0x0022bf88]
CMP byte ptr [RCX],0x0
JZ 0x00183eb3
INC dword ptr [RAX + 0x8]
JMP 0x00183eb7
LAB_00183eb3:
INC.LOCK dword ptr [RAX + 0x8]
LAB_00183eb7:
MOV RAX,qword ptr [R14 + 0x20]
SUB RAX,qword ptr [R14 + 0x10]
MOV qword ptr [RSP + 0x20],RAX
LAB_00183ec4:
LEA RDX,[0x22d1d8]
LEA RDI,[RSP + 0x28]
MOV RSI,R14
MOV ECX,0x1
CALL 0x00183816
CMP qword ptr [RSP + 0x30],0x0
JZ 0x00183f09
MOV qword ptr [RBX],0x0
LEA RDI,[RBX + 0x8]
LAB_00183ef0:
LEA RDX,[RSP + 0xf]
LEA RCX,[RSP + 0x10]
LEA R8,[RSP + 0x28]
MOV RSI,RBX
CALL 0x001982e4
JMP 0x00183f0f
LAB_00183f09:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
LAB_00183f0f:
LEA RAX,[RSP + 0x38]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00183f2a
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0011a8d0
LAB_00183f2a:
MOV RDI,qword ptr [RSP + 0x18]
TEST RDI,RDI
JZ 0x00183f39
CALL 0x0016d59a
LAB_00183f39:
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R14
RET
LAB_00183f44:
LEA RDI,[0x22d1f8]
CALL 0x0011b020
TEST EAX,EAX
JZ 0x00183e8c
LAB_00183f58:
LEA RDI,[0x22d1d8]
LEA RSI,[0x1f09e6]
MOV EDX,0x10
CALL 0x00162528
LAB_00183f70:
LEA RDI,[0x16282c]
LEA RSI,[0x22d1d8]
LEA RDX,[0x22c8d8]
CALL 0x0011a7a0
LEA RDI,[0x22d1f8]
CALL 0x0011a5d0
JMP 0x00183e8c
|
/* minja::Parser::parseIdentifier() */
void minja::Parser::parseIdentifier(void)
{
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *this;
int iVar1;
long in_RSI;
int8 *in_RDI;
long *local_30;
long local_28;
long local_20 [2];
if (parseIdentifier()::ident_regex_abi_cxx11_ == '\0') {
iVar1 = __cxa_guard_acquire(&parseIdentifier()::ident_regex_abi_cxx11_);
if (iVar1 != 0) {
/* try { // try from 00183f58 to 00183f6f has its CatchHandler @ 00183f9b */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseIdentifier()::ident_regex_abi_cxx11_,
"(?!(?:not|is|and|or|del)\\b)[a-zA-Z_]\\w*",0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseIdentifier()::ident_regex_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseIdentifier()::ident_regex_abi_cxx11_);
}
}
this = *(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(in_RSI + 8);
if (this != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
if (*PTR___libc_single_threaded_0022bf88 == '\0') {
LOCK();
*(int *)(this + 8) = *(int *)(this + 8) + 1;
UNLOCK();
}
else {
*(int *)(this + 8) = *(int *)(this + 8) + 1;
}
}
/* try { // try from 00183ec4 to 00183edc has its CatchHandler @ 00183fcc */
consumeToken(&local_30);
if (local_28 == 0) {
*in_RDI = 0;
in_RDI[1] = 0;
}
else {
*in_RDI = 0;
/* try { // try from 00183ef0 to 00183f06 has its CatchHandler @ 00183fac */
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::
__shared_count<minja::VariableExpr,std::allocator<minja::VariableExpr>,minja::Location&,std::__cxx11::string&>
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)(in_RDI + 1));
}
if (local_30 != local_20) {
operator_delete(local_30,local_20[0] + 1);
}
if (this != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(this);
}
return;
}
|
|
6,850 |
lunasvg::SVGTextElement::SVGTextElement(lunasvg::Document*)
|
dmazzella[P]pylunasvg/lunasvg/source/svgtextelement.cpp
|
SVGTextElement::SVGTextElement(Document* document)
: SVGTextPositioningElement(document, ElementID::Text)
{
}
|
O1
|
cpp
|
lunasvg::SVGTextElement::SVGTextElement(lunasvg::Document*):
pushq %rbx
movq %rdi, %rbx
movl $0x16, %edx
callq 0x21d96
leaq 0x38ee5(%rip), %rax # 0x5b1a8
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1c8(%rbx)
xorl %eax, %eax
movq %rax, 0x1d8(%rbx)
leaq 0x1f0(%rbx), %rcx
movq %rcx, 0x1e0(%rbx)
movq %rax, 0x1e8(%rbx)
movl $0x0, 0x1f0(%rbx)
popq %rbx
retq
|
_ZN7lunasvg14SVGTextElementC2EPNS_8DocumentE:
push rbx
mov rbx, rdi
mov edx, 16h
call _ZN7lunasvg25SVGTextPositioningElementC2EPNS_8DocumentENS_9ElementIDE; lunasvg::SVGTextPositioningElement::SVGTextPositioningElement(lunasvg::Document *,lunasvg::ElementID)
lea rax, off_5B1A8
mov [rbx], rax
xorps xmm0, xmm0
movups xmmword ptr [rbx+1C8h], xmm0
xor eax, eax
mov [rbx+1D8h], rax
lea rcx, [rbx+1F0h]
mov [rbx+1E0h], rcx
mov [rbx+1E8h], rax
mov dword ptr [rbx+1F0h], 0
pop rbx
retn
|
long long lunasvg::SVGTextElement::SVGTextElement(lunasvg::SVGTextElement *this, lunasvg::Document *a2)
{
long long result; // rax
lunasvg::SVGTextPositioningElement::SVGTextPositioningElement(this, (long long)a2, 22);
*(_QWORD *)this = off_5B1A8;
*(_OWORD *)((char *)this + 456) = 0LL;
result = 0LL;
*((_QWORD *)this + 59) = 0LL;
*((_QWORD *)this + 60) = (char *)this + 496;
*((_QWORD *)this + 61) = 0LL;
*((_DWORD *)this + 124) = 0;
return result;
}
|
SVGTextElement:
PUSH RBX
MOV RBX,RDI
MOV EDX,0x16
CALL 0x00121d96
LEA RAX,[0x15b1a8]
MOV qword ptr [RBX],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x1c8],XMM0
XOR EAX,EAX
MOV qword ptr [RBX + 0x1d8],RAX
LEA RCX,[RBX + 0x1f0]
MOV qword ptr [RBX + 0x1e0],RCX
MOV qword ptr [RBX + 0x1e8],RAX
MOV dword ptr [RBX + 0x1f0],0x0
POP RBX
RET
|
/* lunasvg::SVGTextElement::SVGTextElement(lunasvg::Document*) */
void __thiscall lunasvg::SVGTextElement::SVGTextElement(SVGTextElement *this,Document *param_1)
{
SVGTextPositioningElement::SVGTextPositioningElement
((SVGTextPositioningElement *)this,param_1,0x16);
*(int ***)this = &PTR__SVGTextElement_0015b1a8;
*(int8 *)(this + 0x1c8) = 0;
*(int8 *)(this + 0x1d0) = 0;
*(int8 *)(this + 0x1d8) = 0;
*(SVGTextElement **)(this + 0x1e0) = this + 0x1f0;
*(int8 *)(this + 0x1e8) = 0;
*(int4 *)(this + 0x1f0) = 0;
return;
}
|
|
6,851 |
lunasvg::SVGTextElement::SVGTextElement(lunasvg::Document*)
|
dmazzella[P]pylunasvg/lunasvg/source/svgtextelement.cpp
|
SVGTextElement::SVGTextElement(Document* document)
: SVGTextPositioningElement(document, ElementID::Text)
{
}
|
O3
|
cpp
|
lunasvg::SVGTextElement::SVGTextElement(lunasvg::Document*):
pushq %rbx
movq %rdi, %rbx
movl $0x16, %edx
callq 0x21dba
leaq 0x38ee7(%rip), %rax # 0x5b1a8
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1c8(%rbx)
xorl %eax, %eax
movq %rax, 0x1d8(%rbx)
leaq 0x1f0(%rbx), %rcx
movq %rcx, 0x1e0(%rbx)
movq %rax, 0x1e8(%rbx)
movl $0x0, 0x1f0(%rbx)
popq %rbx
retq
|
_ZN7lunasvg14SVGTextElementC2EPNS_8DocumentE:
push rbx
mov rbx, rdi
mov edx, 16h
call _ZN7lunasvg25SVGTextPositioningElementC2EPNS_8DocumentENS_9ElementIDE; lunasvg::SVGTextPositioningElement::SVGTextPositioningElement(lunasvg::Document *,lunasvg::ElementID)
lea rax, off_5B1A8
mov [rbx], rax
xorps xmm0, xmm0
movups xmmword ptr [rbx+1C8h], xmm0
xor eax, eax
mov [rbx+1D8h], rax
lea rcx, [rbx+1F0h]
mov [rbx+1E0h], rcx
mov [rbx+1E8h], rax
mov dword ptr [rbx+1F0h], 0
pop rbx
retn
|
long long lunasvg::SVGTextElement::SVGTextElement(lunasvg::SVGTextElement *this, lunasvg::Document *a2)
{
long long result; // rax
lunasvg::SVGTextPositioningElement::SVGTextPositioningElement(this, (long long)a2, 22);
*(_QWORD *)this = off_5B1A8;
*(_OWORD *)((char *)this + 456) = 0LL;
result = 0LL;
*((_QWORD *)this + 59) = 0LL;
*((_QWORD *)this + 60) = (char *)this + 496;
*((_QWORD *)this + 61) = 0LL;
*((_DWORD *)this + 124) = 0;
return result;
}
|
SVGTextElement:
PUSH RBX
MOV RBX,RDI
MOV EDX,0x16
CALL 0x00121dba
LEA RAX,[0x15b1a8]
MOV qword ptr [RBX],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x1c8],XMM0
XOR EAX,EAX
MOV qword ptr [RBX + 0x1d8],RAX
LEA RCX,[RBX + 0x1f0]
MOV qword ptr [RBX + 0x1e0],RCX
MOV qword ptr [RBX + 0x1e8],RAX
MOV dword ptr [RBX + 0x1f0],0x0
POP RBX
RET
|
/* lunasvg::SVGTextElement::SVGTextElement(lunasvg::Document*) */
void __thiscall lunasvg::SVGTextElement::SVGTextElement(SVGTextElement *this,Document *param_1)
{
SVGTextPositioningElement::SVGTextPositioningElement
((SVGTextPositioningElement *)this,param_1,0x16);
*(int ***)this = &PTR__SVGTextElement_0015b1a8;
*(int8 *)(this + 0x1c8) = 0;
*(int8 *)(this + 0x1d0) = 0;
*(int8 *)(this + 0x1d8) = 0;
*(SVGTextElement **)(this + 0x1e0) = this + 0x1f0;
*(int8 *)(this + 0x1e8) = 0;
*(int4 *)(this + 0x1f0) = 0;
return;
}
|
|
6,852 |
my_xml_scan
|
eloqsql/strings/xml.c
|
static int my_xml_scan(MY_XML_PARSER *p,MY_XML_ATTR *a)
{
int lex;
for (; ( p->cur < p->end) && my_xml_is_space(p->cur[0]) ; p->cur++);
if (p->cur >= p->end)
{
a->beg=p->end;
a->end=p->end;
lex=MY_XML_EOF;
goto ret;
}
a->beg=p->cur;
a->end=p->cur;
if (!my_xml_parser_prefix_cmp(p, C_STRING_WITH_LEN("<!--")))
{
for (; p->cur < p->end; p->cur++)
{
if (!my_xml_parser_prefix_cmp(p, C_STRING_WITH_LEN("-->")))
{
p->cur+= 3;
break;
}
}
a->end=p->cur;
lex=MY_XML_COMMENT;
}
else if (!my_xml_parser_prefix_cmp(p, C_STRING_WITH_LEN("<![CDATA[")))
{
p->cur+= 9;
for (; p->cur < p->end - 2 ; p->cur++)
{
if (p->cur[0] == ']' && p->cur[1] == ']' && p->cur[2] == '>')
{
p->cur+= 3;
a->end= p->cur;
break;
}
}
lex= MY_XML_CDATA;
}
else if (strchr("?=/<>!",p->cur[0]))
{
p->cur++;
a->end=p->cur;
lex=a->beg[0];
}
else if ( (p->cur[0] == '"') || (p->cur[0] == '\'') )
{
/*
"string" or 'string' found.
Scan until the closing quote/doublequote, or until the END-OF-INPUT.
*/
p->cur++;
for (; ( p->cur < p->end ) && (p->cur[0] != a->beg[0]); p->cur++)
{}
a->end=p->cur;
if (p->cur < p->end) /* Closing quote or doublequote has been found */
p->cur++;
a->beg++;
if (!(p->flags & MY_XML_FLAG_SKIP_TEXT_NORMALIZATION))
my_xml_norm_text(a);
lex=MY_XML_STRING;
}
else if (my_xml_is_id0(p->cur[0]))
{
p->cur++;
while (p->cur < p->end && my_xml_is_id1(p->cur[0]))
p->cur++;
a->end=p->cur;
my_xml_norm_text(a);
lex=MY_XML_IDENT;
}
else
lex= MY_XML_UNKNOWN;
#if 0
printf("LEX=%s[%d]\n",lex2str(lex),a->end-a->beg);
#endif
ret:
return lex;
}
|
O3
|
c
|
my_xml_scan:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x130(%rdi), %rax
movq 0x138(%rdi), %rcx
cmpq %rcx, %rax
jae 0x5e552
leaq 0x27ebe6(%rip), %rbx # 0x2dd120
movzbl (%rax), %edx
testb $0x8, (%rdx,%rbx)
je 0x5e578
incq %rax
movq %rax, 0x130(%r14)
cmpq %rcx, %rax
jne 0x5e53a
movq %rcx, (%rsi)
movq 0x138(%r14), %rax
movq %rax, 0x8(%rsi)
movl $0x45, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, (%rsi)
movq 0x130(%r14), %r13
movq %r13, 0x8(%rsi)
movq 0x138(%r14), %r12
leaq 0x4(%r13), %rax
cmpq %r12, %rax
ja 0x5e5a0
cmpl $0x2d2d213c, (%r13) # imm = 0x2D2D213C
je 0x5e609
leaq 0x9(%r13), %rax
cmpq %r12, %rax
ja 0x5e5c9
movabsq $0x41544144435b213c, %rcx # imm = 0x41544144435B213C
xorq (%r13), %rcx
movzbl 0x8(%r13), %edx
xorq $0x5b, %rdx
orq %rcx, %rdx
je 0x5e6b6
movq %rsi, -0x30(%rbp)
movsbl (%r13), %r15d
leaq 0x614b(%rip), %rdi # 0x64724
movl $0x7, %edx
movl %r15d, %esi
callq 0x24360
testq %rax, %rax
je 0x5e645
incq %r13
movq %r13, 0x130(%r14)
movq -0x30(%rbp), %rax
movq %r13, 0x8(%rax)
movq (%rax), %rax
movsbl (%rax), %r15d
jmp 0x5e566
leaq 0x3(%r13), %rax
cmpq %r12, %rax
ja 0x5e62e
movzwl (%r13), %ecx
xorl $0x2d2d, %ecx # imm = 0x2D2D
movzbl 0x2(%r13), %edx
xorl $0x3e, %edx
orw %cx, %dx
je 0x5e74c
incq %r13
movq %r13, 0x130(%r14)
cmpq %r12, %r13
jne 0x5e609
movq %r12, %rax
jmp 0x5e753
movzbl %r15b, %eax
cmpq $0x27, %rax
movq -0x30(%rbp), %rdi
je 0x5e65c
cmpl $0x22, %eax
jne 0x5e709
incq %r13
movq %r13, %rax
movq %r13, 0x130(%r14)
cmpq %r12, %r13
jae 0x5e67b
movb (%rax), %cl
movq (%rdi), %rdx
leaq 0x1(%rax), %r13
cmpb (%rdx), %cl
jne 0x5e65f
movq %rax, 0x8(%rdi)
movq 0x130(%r14), %rax
cmpq 0x138(%r14), %rax
jae 0x5e699
incq %rax
movq %rax, 0x130(%r14)
incq (%rdi)
movl $0x53, %r15d
testb $0x2, (%r14)
jne 0x5e566
callq 0x5eb47
jmp 0x5e566
leaq -0x2(%r12), %rcx
movq %rax, 0x130(%r14)
movl $0x44, %r15d
cmpq %rcx, %rax
jae 0x5e566
subq %r13, %r12
addq $0xc, %r13
addq $-0xb, %r12
cmpb $0x5d, -0x3(%r13)
jne 0x5e6f1
cmpb $0x5d, -0x2(%r13)
jne 0x5e6f1
cmpb $0x3e, -0x1(%r13)
je 0x5e762
leaq -0x2(%r13), %rax
movq %rax, 0x130(%r14)
incq %r13
decq %r12
jne 0x5e6dc
jmp 0x5e566
movl $0x55, %r15d
testb $0x1, (%rax,%rbx)
je 0x5e566
incq %r13
movq %r13, %rax
movq %r13, 0x130(%r14)
cmpq %r12, %r13
jae 0x5e738
movzbl (%rax), %ecx
leaq 0x1(%rax), %r13
testb $0x2, (%rcx,%rbx)
jne 0x5e71c
movq %rax, 0x8(%rdi)
callq 0x5eb47
movl $0x49, %r15d
jmp 0x5e566
movq %rax, 0x130(%r14)
movq %rax, 0x8(%rsi)
movl $0x43, %r15d
jmp 0x5e566
movq %r13, 0x130(%r14)
movq %r13, 0x8(%rsi)
jmp 0x5e566
|
my_xml_scan:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdi
mov rax, [rdi+130h]
mov rcx, [rdi+138h]
cmp rax, rcx
jnb short loc_5E552
lea rbx, my_xml_ctype
loc_5E53A:
movzx edx, byte ptr [rax]
test byte ptr [rdx+rbx], 8
jz short loc_5E578
inc rax
mov [r14+130h], rax
cmp rax, rcx
jnz short loc_5E53A
loc_5E552:
mov [rsi], rcx
mov rax, [r14+138h]
mov [rsi+8], rax
mov r15d, 45h ; 'E'
loc_5E566:
mov eax, r15d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_5E578:
mov [rsi], rax
mov r13, [r14+130h]
mov [rsi+8], r13
mov r12, [r14+138h]
lea rax, [r13+4]
cmp rax, r12
ja short loc_5E5A0
cmp dword ptr [r13+0], 2D2D213Ch
jz short loc_5E609
loc_5E5A0:
lea rax, [r13+9]
cmp rax, r12
ja short loc_5E5C9
mov rcx, 41544144435B213Ch
xor rcx, [r13+0]
movzx edx, byte ptr [r13+8]
xor rdx, 5Bh
or rdx, rcx
jz loc_5E6B6
loc_5E5C9:
mov [rbp+var_30], rsi
movsx r15d, byte ptr [r13+0]
lea rdi, asc_64724; "?=/<>!"
mov edx, 7
mov esi, r15d
call _memchr
test rax, rax
jz short loc_5E645
inc r13
mov [r14+130h], r13
mov rax, [rbp+var_30]
mov [rax+8], r13
mov rax, [rax]
movsx r15d, byte ptr [rax]
jmp loc_5E566
loc_5E609:
lea rax, [r13+3]
cmp rax, r12
ja short loc_5E62E
movzx ecx, word ptr [r13+0]
xor ecx, 2D2Dh
movzx edx, byte ptr [r13+2]
xor edx, 3Eh
or dx, cx
jz loc_5E74C
loc_5E62E:
inc r13
mov [r14+130h], r13
cmp r13, r12
jnz short loc_5E609
mov rax, r12
jmp loc_5E753
loc_5E645:
movzx eax, r15b
cmp rax, 27h ; '''
mov rdi, [rbp+var_30]
jz short loc_5E65C
cmp eax, 22h ; '"'
jnz loc_5E709
loc_5E65C:
inc r13
loc_5E65F:
mov rax, r13
mov [r14+130h], r13
cmp r13, r12
jnb short loc_5E67B
mov cl, [rax]
mov rdx, [rdi]
lea r13, [rax+1]
cmp cl, [rdx]
jnz short loc_5E65F
loc_5E67B:
mov [rdi+8], rax
mov rax, [r14+130h]
cmp rax, [r14+138h]
jnb short loc_5E699
inc rax
mov [r14+130h], rax
loc_5E699:
inc qword ptr [rdi]
mov r15d, 53h ; 'S'
test byte ptr [r14], 2
jnz loc_5E566
call my_xml_norm_text
jmp loc_5E566
loc_5E6B6:
lea rcx, [r12-2]
mov [r14+130h], rax
mov r15d, 44h ; 'D'
cmp rax, rcx
jnb loc_5E566
sub r12, r13
add r13, 0Ch
add r12, 0FFFFFFFFFFFFFFF5h
loc_5E6DC:
cmp byte ptr [r13-3], 5Dh ; ']'
jnz short loc_5E6F1
cmp byte ptr [r13-2], 5Dh ; ']'
jnz short loc_5E6F1
cmp byte ptr [r13-1], 3Eh ; '>'
jz short loc_5E762
loc_5E6F1:
lea rax, [r13-2]
mov [r14+130h], rax
inc r13
dec r12
jnz short loc_5E6DC
jmp loc_5E566
loc_5E709:
mov r15d, 55h ; 'U'
test byte ptr [rax+rbx], 1
jz loc_5E566
inc r13
loc_5E71C:
mov rax, r13
mov [r14+130h], r13
cmp r13, r12
jnb short loc_5E738
movzx ecx, byte ptr [rax]
lea r13, [rax+1]
test byte ptr [rcx+rbx], 2
jnz short loc_5E71C
loc_5E738:
mov [rdi+8], rax
call my_xml_norm_text
mov r15d, 49h ; 'I'
jmp loc_5E566
loc_5E74C:
mov [r14+130h], rax
loc_5E753:
mov [rsi+8], rax
mov r15d, 43h ; 'C'
jmp loc_5E566
loc_5E762:
mov [r14+130h], r13
mov [rsi+8], r13
jmp loc_5E566
|
long long my_xml_scan(long long a1, unsigned __int8 **a2)
{
unsigned __int8 *v2; // rax
unsigned __int8 *v3; // rcx
unsigned int v4; // r15d
char *v6; // r13
unsigned long long v7; // r12
unsigned long long v8; // rax
unsigned __int8 v9; // r15
char *v10; // r13
char *v11; // rax
long long v12; // rax
char *v13; // r13
char *v14; // rax
unsigned long long v15; // rax
unsigned long long v16; // r12
char *v17; // r13
unsigned long long v18; // r12
char *v19; // r13
char *v20; // rax
long long v21; // rcx
v2 = *(unsigned __int8 **)(a1 + 304);
v3 = *(unsigned __int8 **)(a1 + 312);
if ( v2 >= v3 )
{
LABEL_4:
*a2 = v3;
a2[1] = *(unsigned __int8 **)(a1 + 312);
return 69;
}
else
{
while ( (my_xml_ctype[*v2] & 8) != 0 )
{
*(_QWORD *)(a1 + 304) = ++v2;
if ( v2 == v3 )
goto LABEL_4;
}
*a2 = v2;
v6 = *(char **)(a1 + 304);
a2[1] = (unsigned __int8 *)v6;
v7 = *(_QWORD *)(a1 + 312);
if ( (unsigned long long)(v6 + 4) <= v7 && *(_DWORD *)v6 == 757932348 )
{
while ( 1 )
{
v11 = v6 + 3;
if ( (unsigned long long)(v6 + 3) <= v7 && !(*(_WORD *)v6 ^ 0x2D2D | (unsigned __int8)v6[2] ^ 0x3E) )
break;
*(_QWORD *)(a1 + 304) = ++v6;
if ( v6 == (char *)v7 )
{
v11 = (char *)v7;
goto LABEL_38;
}
}
*(_QWORD *)(a1 + 304) = v11;
LABEL_38:
a2[1] = (unsigned __int8 *)v11;
return 67;
}
else
{
v8 = (unsigned long long)(v6 + 9);
if ( (unsigned long long)(v6 + 9) > v7 || *(_QWORD *)v6 ^ 0x41544144435B213CLL | (unsigned __int8)v6[8] ^ 0x5BLL )
{
v9 = *v6;
if ( memchr("?=/<>!", (unsigned int)*v6, 7LL) )
{
v10 = v6 + 1;
*(_QWORD *)(a1 + 304) = v10;
a2[1] = (unsigned __int8 *)v10;
return (unsigned int)(char)**a2;
}
else
{
v12 = v9;
if ( v9 == 39LL || v9 == 34 )
{
v13 = v6 + 1;
do
{
v14 = v13;
*(_QWORD *)(a1 + 304) = v13;
if ( (unsigned long long)v13 >= v7 )
break;
++v13;
}
while ( *v14 != **a2 );
a2[1] = (unsigned __int8 *)v14;
v15 = *(_QWORD *)(a1 + 304);
if ( v15 < *(_QWORD *)(a1 + 312) )
*(_QWORD *)(a1 + 304) = v15 + 1;
++*a2;
v4 = 83;
if ( (*(_BYTE *)a1 & 2) == 0 )
my_xml_norm_text(a2);
}
else
{
v4 = 85;
if ( (my_xml_ctype[v12] & 1) != 0 )
{
v19 = v6 + 1;
do
{
v20 = v19;
*(_QWORD *)(a1 + 304) = v19;
if ( (unsigned long long)v19 >= v7 )
break;
v21 = (unsigned __int8)*v19++;
}
while ( (my_xml_ctype[v21] & 2) != 0 );
a2[1] = (unsigned __int8 *)v20;
my_xml_norm_text(a2);
return 73;
}
}
}
}
else
{
*(_QWORD *)(a1 + 304) = v8;
v4 = 68;
if ( v8 < v7 - 2 )
{
v16 = v7 - (_QWORD)v6;
v17 = v6 + 12;
v18 = v16 - 11;
while ( *(v17 - 3) != 93 || *(v17 - 2) != 93 || *(v17 - 1) != 62 )
{
*(_QWORD *)(a1 + 304) = v17 - 2;
++v17;
if ( !--v18 )
return v4;
}
*(_QWORD *)(a1 + 304) = v17;
a2[1] = (unsigned __int8 *)v17;
}
}
}
}
return v4;
}
|
my_xml_scan:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDI
MOV RAX,qword ptr [RDI + 0x130]
MOV RCX,qword ptr [RDI + 0x138]
CMP RAX,RCX
JNC 0x0015e552
LEA RBX,[0x3dd120]
LAB_0015e53a:
MOVZX EDX,byte ptr [RAX]
TEST byte ptr [RDX + RBX*0x1],0x8
JZ 0x0015e578
INC RAX
MOV qword ptr [R14 + 0x130],RAX
CMP RAX,RCX
JNZ 0x0015e53a
LAB_0015e552:
MOV qword ptr [RSI],RCX
MOV RAX,qword ptr [R14 + 0x138]
MOV qword ptr [RSI + 0x8],RAX
MOV R15D,0x45
LAB_0015e566:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0015e578:
MOV qword ptr [RSI],RAX
MOV R13,qword ptr [R14 + 0x130]
MOV qword ptr [RSI + 0x8],R13
MOV R12,qword ptr [R14 + 0x138]
LEA RAX,[R13 + 0x4]
CMP RAX,R12
JA 0x0015e5a0
CMP dword ptr [R13],0x2d2d213c
JZ 0x0015e609
LAB_0015e5a0:
LEA RAX,[R13 + 0x9]
CMP RAX,R12
JA 0x0015e5c9
MOV RCX,0x41544144435b213c
XOR RCX,qword ptr [R13]
MOVZX EDX,byte ptr [R13 + 0x8]
XOR RDX,0x5b
OR RDX,RCX
JZ 0x0015e6b6
LAB_0015e5c9:
MOV qword ptr [RBP + -0x30],RSI
MOVSX R15D,byte ptr [R13]
LEA RDI,[0x164724]
MOV EDX,0x7
MOV ESI,R15D
CALL 0x00124360
TEST RAX,RAX
JZ 0x0015e645
INC R13
MOV qword ptr [R14 + 0x130],R13
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x8],R13
MOV RAX,qword ptr [RAX]
MOVSX R15D,byte ptr [RAX]
JMP 0x0015e566
LAB_0015e609:
LEA RAX,[R13 + 0x3]
CMP RAX,R12
JA 0x0015e62e
MOVZX ECX,word ptr [R13]
XOR ECX,0x2d2d
MOVZX EDX,byte ptr [R13 + 0x2]
XOR EDX,0x3e
OR DX,CX
JZ 0x0015e74c
LAB_0015e62e:
INC R13
MOV qword ptr [R14 + 0x130],R13
CMP R13,R12
JNZ 0x0015e609
MOV RAX,R12
JMP 0x0015e753
LAB_0015e645:
MOVZX EAX,R15B
CMP RAX,0x27
MOV RDI,qword ptr [RBP + -0x30]
JZ 0x0015e65c
CMP EAX,0x22
JNZ 0x0015e709
LAB_0015e65c:
INC R13
LAB_0015e65f:
MOV RAX,R13
MOV qword ptr [R14 + 0x130],R13
CMP R13,R12
JNC 0x0015e67b
MOV CL,byte ptr [RAX]
MOV RDX,qword ptr [RDI]
LEA R13,[RAX + 0x1]
CMP CL,byte ptr [RDX]
JNZ 0x0015e65f
LAB_0015e67b:
MOV qword ptr [RDI + 0x8],RAX
MOV RAX,qword ptr [R14 + 0x130]
CMP RAX,qword ptr [R14 + 0x138]
JNC 0x0015e699
INC RAX
MOV qword ptr [R14 + 0x130],RAX
LAB_0015e699:
INC qword ptr [RDI]
MOV R15D,0x53
TEST byte ptr [R14],0x2
JNZ 0x0015e566
CALL 0x0015eb47
JMP 0x0015e566
LAB_0015e6b6:
LEA RCX,[R12 + -0x2]
MOV qword ptr [R14 + 0x130],RAX
MOV R15D,0x44
CMP RAX,RCX
JNC 0x0015e566
SUB R12,R13
ADD R13,0xc
ADD R12,-0xb
LAB_0015e6dc:
CMP byte ptr [R13 + -0x3],0x5d
JNZ 0x0015e6f1
CMP byte ptr [R13 + -0x2],0x5d
JNZ 0x0015e6f1
CMP byte ptr [R13 + -0x1],0x3e
JZ 0x0015e762
LAB_0015e6f1:
LEA RAX,[R13 + -0x2]
MOV qword ptr [R14 + 0x130],RAX
INC R13
DEC R12
JNZ 0x0015e6dc
JMP 0x0015e566
LAB_0015e709:
MOV R15D,0x55
TEST byte ptr [RAX + RBX*0x1],0x1
JZ 0x0015e566
INC R13
LAB_0015e71c:
MOV RAX,R13
MOV qword ptr [R14 + 0x130],R13
CMP R13,R12
JNC 0x0015e738
MOVZX ECX,byte ptr [RAX]
LEA R13,[RAX + 0x1]
TEST byte ptr [RCX + RBX*0x1],0x2
JNZ 0x0015e71c
LAB_0015e738:
MOV qword ptr [RDI + 0x8],RAX
CALL 0x0015eb47
MOV R15D,0x49
JMP 0x0015e566
LAB_0015e74c:
MOV qword ptr [R14 + 0x130],RAX
LAB_0015e753:
MOV qword ptr [RSI + 0x8],RAX
MOV R15D,0x43
JMP 0x0015e566
LAB_0015e762:
MOV qword ptr [R14 + 0x130],R13
MOV qword ptr [RSI + 0x8],R13
JMP 0x0015e566
|
int my_xml_scan(byte *param_1,long *param_2)
{
byte bVar1;
uint uVar2;
byte *pbVar3;
void *pvVar4;
byte *pbVar5;
byte *pbVar6;
pbVar3 = *(byte **)(param_1 + 0x130);
pbVar5 = *(byte **)(param_1 + 0x138);
if (pbVar3 < pbVar5) {
do {
if ((my_xml_ctype[*pbVar3] & 8) == 0) {
*param_2 = (long)pbVar3;
pbVar3 = *(byte **)(param_1 + 0x130);
param_2[1] = (long)pbVar3;
pbVar5 = *(byte **)(param_1 + 0x138);
if ((pbVar3 + 4 <= pbVar5) && (*(int *)pbVar3 == 0x2d2d213c)) goto LAB_0015e609;
pbVar6 = pbVar3 + 9;
if ((pbVar6 <= pbVar5) && (pbVar3[8] == 0x5b && *(long *)pbVar3 == 0x41544144435b213c)) {
*(byte **)(param_1 + 0x130) = pbVar6;
if (pbVar5 + -2 <= pbVar6) {
return 0x44;
}
pbVar6 = pbVar3 + 0xc;
pbVar5 = pbVar5 + (-0xb - (long)pbVar3);
while (((pbVar6[-3] != 0x5d || (pbVar6[-2] != 0x5d)) || (pbVar6[-1] != 0x3e))) {
*(byte **)(param_1 + 0x130) = pbVar6 + -2;
pbVar6 = pbVar6 + 1;
pbVar5 = pbVar5 + -1;
if (pbVar5 == (byte *)0x0) {
return 0x44;
}
}
*(byte **)(param_1 + 0x130) = pbVar6;
param_2[1] = (long)pbVar6;
return 0x44;
}
bVar1 = *pbVar3;
pvVar4 = memchr("?=/<>!",(int)(char)bVar1,7);
if (pvVar4 != (void *)0x0) {
*(byte **)(param_1 + 0x130) = pbVar3 + 1;
param_2[1] = (long)(pbVar3 + 1);
return (int)*(char *)*param_2;
}
uVar2 = (uint)bVar1;
if (((ulong)uVar2 == 0x27) || (uVar2 == 0x22)) goto LAB_0015e65f;
if ((my_xml_ctype[uVar2] & 1) == 0) {
return 0x55;
}
goto LAB_0015e71c;
}
pbVar3 = pbVar3 + 1;
*(byte **)(param_1 + 0x130) = pbVar3;
} while (pbVar3 != pbVar5);
}
*param_2 = (long)pbVar5;
param_2[1] = *(long *)(param_1 + 0x138);
return 0x45;
LAB_0015e609:
pbVar6 = pbVar3 + 3;
if ((pbVar6 <= pbVar5) && (pbVar3[2] == 0x3e && *(short *)pbVar3 == 0x2d2d)) {
*(byte **)(param_1 + 0x130) = pbVar6;
pbVar5 = pbVar6;
goto LAB_0015e753;
}
pbVar3 = pbVar3 + 1;
*(byte **)(param_1 + 0x130) = pbVar3;
if (pbVar3 == pbVar5) {
LAB_0015e753:
param_2[1] = (long)pbVar5;
return 0x43;
}
goto LAB_0015e609;
while (*pbVar3 != *(byte *)*param_2) {
LAB_0015e65f:
pbVar3 = pbVar3 + 1;
*(byte **)(param_1 + 0x130) = pbVar3;
if (pbVar5 <= pbVar3) break;
}
param_2[1] = (long)pbVar3;
if (*(ulong *)(param_1 + 0x130) < *(ulong *)(param_1 + 0x138)) {
*(ulong *)(param_1 + 0x130) = *(ulong *)(param_1 + 0x130) + 1;
}
*param_2 = *param_2 + 1;
if ((*param_1 & 2) != 0) {
return 0x53;
}
my_xml_norm_text();
return 0x53;
while ((my_xml_ctype[*pbVar3] & 2) != 0) {
LAB_0015e71c:
pbVar3 = pbVar3 + 1;
*(byte **)(param_1 + 0x130) = pbVar3;
if (pbVar5 <= pbVar3) break;
}
param_2[1] = (long)pbVar3;
my_xml_norm_text();
return 0x49;
}
|
|
6,853 |
my_context_spawn
|
eloqsql/libmariadb/libmariadb/ma_context.c
|
int
my_context_spawn(struct my_context *c, void (*f)(void *), void *d)
{
int err;
union pass_void_ptr_as_2_int u;
err= getcontext(&c->spawned_context);
if (err)
return -1;
c->spawned_context.uc_stack.ss_sp= c->stack;
c->spawned_context.uc_stack.ss_size= c->stack_size;
c->spawned_context.uc_link= NULL;
c->user_func= f;
c->user_data= d;
c->active= 1;
u.p= c;
makecontext(&c->spawned_context, my_context_spawn_internal, 2,
u.a[0], u.a[1]);
return my_context_continue(c);
}
|
O3
|
c
|
my_context_spawn:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq %rdx, %rdi
movq %rsp, (%rbx)
movq %rax, %rsp
movq %rbp, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %r12, 0x18(%rbx)
movq %r13, 0x20(%rbx)
movq %r14, 0x28(%rbx)
movq %r15, 0x30(%rbx)
leaq 0x14(%rip), %rax # 0x31288
leaq 0x14(%rip), %rcx # 0x3128f
movq %rax, 0x38(%rbx)
movq %rcx, 0x40(%rbx)
callq *%rsi
jmpq *0x38(%rbx)
movq (%rbx), %rsp
xorl %eax, %eax
jmp 0x31294
movl $0x1, %eax
popq %rbx
popq %rbp
retq
|
my_context_spawn:
push rbp
mov rbp, rsp
push rbx
mov rbx, rdi
mov rax, [rdi+48h]
mov rdi, rdx
mov [rbx], rsp
mov rsp, rax
mov [rbx+8], rbp
mov [rbx+10h], rbx
mov [rbx+18h], r12
mov [rbx+20h], r13
mov [rbx+28h], r14
mov [rbx+30h], r15
lea rax, sub_31288
lea rcx, loc_3128F
mov [rbx+38h], rax
mov [rbx+40h], rcx
call rsi
jmp qword ptr [rbx+38h]
|
long long my_context_spawn(_QWORD *a1, void ( *a2)(long long), long long a3)
{
long long v3; // r12
long long v4; // r13
long long v5; // r14
long long v6; // r15
long long v8; // [rsp+0h] [rbp-8h] BYREF
long long savedregs; // [rsp+8h] [rbp+0h] BYREF
*a1 = &v8;
a1[1] = &savedregs;
a1[2] = a1;
a1[3] = v3;
a1[4] = v4;
a1[5] = v5;
a1[6] = v6;
a1[7] = sub_31288;
a1[8] = &loc_3128F;
a2(a3);
return ((long long (*)(void))a1[7])();
}
|
my_context_spawn:
PUSH RBP
MOV RBP,RSP
PUSH RBX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x48]
MOV RDI,RDX
MOV qword ptr [RBX],RSP
MOV RSP,RAX
MOV qword ptr [RBX + 0x8],RBP
MOV qword ptr [RBX + 0x10],RBX
MOV qword ptr [RBX + 0x18],R12
MOV qword ptr [RBX + 0x20],R13
MOV qword ptr [RBX + 0x28],R14
MOV qword ptr [RBX + 0x30],R15
LEA RAX,[0x131288]
LEA RCX,[0x13128f]
MOV qword ptr [RBX + 0x38],RAX
MOV qword ptr [RBX + 0x40],RCX
CALL RSI
JMP qword ptr [RBX + 0x38]
|
void my_context_spawn(long param_1,code *param_2,int8 param_3)
{
int8 unaff_R12;
int8 unaff_R13;
int8 unaff_R14;
int8 unaff_R15;
*(int1 **)param_1 = &stack0xfffffffffffffff0;
*(int1 **)(param_1 + 8) = &stack0xfffffffffffffff8;
*(long *)(param_1 + 0x10) = param_1;
*(int8 *)(param_1 + 0x18) = unaff_R12;
*(int8 *)(param_1 + 0x20) = unaff_R13;
*(int8 *)(param_1 + 0x28) = unaff_R14;
*(int8 *)(param_1 + 0x30) = unaff_R15;
*(int1 **)(param_1 + 0x38) = &LAB_00131288;
*(int **)(param_1 + 0x40) = &DAT_0013128f;
*(int8 *)(*(long *)(param_1 + 0x48) + -8) = 0x131285;
(*param_2)(param_3);
/* WARNING: Could not recover jumptable at 0x00131285. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(param_1 + 0x38))();
return;
}
|
|
6,854 |
my_strntol_8bit
|
eloqsql/strings/ctype-simple.c
|
long my_strntol_8bit(CHARSET_INFO *cs,
const char *nptr, size_t l, int base,
char **endptr, int *err)
{
int negative;
register uint32 cutoff;
register uint cutlim;
register uint32 i;
register const char *s;
register uchar c;
const char *save, *e;
int overflow;
*err= 0; /* Initialize error indicator */
s = nptr;
e = nptr+l;
for ( ; s<e && my_isspace(cs, *s) ; s++);
if (s == e)
{
goto noconv;
}
/* Check for a sign. */
if (*s == '-')
{
negative = 1;
++s;
}
else if (*s == '+')
{
negative = 0;
++s;
}
else
negative = 0;
save = s;
cutoff = ((uint32)~0L) / (uint32) base;
cutlim = (uint) (((uint32)~0L) % (uint32) base);
overflow = 0;
i = 0;
for (c = *s; s != e; c = *++s)
{
if (c>='0' && c<='9')
c -= '0';
else if (c>='A' && c<='Z')
c = c - 'A' + 10;
else if (c>='a' && c<='z')
c = c - 'a' + 10;
else
break;
if (c >= base)
break;
if (i > cutoff || (i == cutoff && c > cutlim))
overflow = 1;
else
{
i *= (uint32) base;
i += c;
}
}
if (s == save)
goto noconv;
if (endptr != NULL)
*endptr = (char *) s;
if (negative)
{
if (i > (uint32) INT_MIN32)
overflow = 1;
}
else if (i > INT_MAX32)
overflow = 1;
if (overflow)
{
err[0]= ERANGE;
return negative ? INT_MIN32 : INT_MAX32;
}
return (negative ? -((long) i) : (long) i);
noconv:
err[0]= EDOM;
if (endptr != NULL)
*endptr = (char *) nptr;
return 0L;
}
|
O0
|
c
|
my_strntol_8bit:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rcx
xorl %eax, %eax
cmpq -0x68(%rbp), %rcx
movb %al, -0x6d(%rbp)
jae 0x43aa8
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x50(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x6d(%rbp)
movb -0x6d(%rbp), %al
testb $0x1, %al
jne 0x43ab1
jmp 0x43ac1
jmp 0x43ab3
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x43a79
movq -0x50(%rbp), %rax
cmpq -0x68(%rbp), %rax
jne 0x43ad0
jmp 0x43cc5
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x43af1
movl $0x1, -0x3c(%rbp)
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x43b1b
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x43b12
movl $0x0, -0x3c(%rbp)
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x43b19
movl $0x0, -0x3c(%rbp)
jmp 0x43b1b
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
xorl %edx, %edx
divl -0x24(%rbp)
movl %eax, -0x40(%rbp)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
xorl %edx, %edx
divl -0x24(%rbp)
movl %edx, -0x44(%rbp)
movl $0x0, -0x6c(%rbp)
movl $0x0, -0x48(%rbp)
movq -0x50(%rbp), %rax
movb (%rax), %al
movb %al, -0x51(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x68(%rbp), %rax
je 0x43c25
movzbl -0x51(%rbp), %eax
cmpl $0x30, %eax
jl 0x43b80
movzbl -0x51(%rbp), %eax
cmpl $0x39, %eax
jg 0x43b80
movzbl -0x51(%rbp), %eax
subl $0x30, %eax
movb %al, -0x51(%rbp)
jmp 0x43bc8
movzbl -0x51(%rbp), %eax
cmpl $0x41, %eax
jl 0x43ba1
movzbl -0x51(%rbp), %eax
cmpl $0x5a, %eax
jg 0x43ba1
movzbl -0x51(%rbp), %eax
subl $0x41, %eax
addl $0xa, %eax
movb %al, -0x51(%rbp)
jmp 0x43bc6
movzbl -0x51(%rbp), %eax
cmpl $0x61, %eax
jl 0x43bc2
movzbl -0x51(%rbp), %eax
cmpl $0x7a, %eax
jg 0x43bc2
movzbl -0x51(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movb %al, -0x51(%rbp)
jmp 0x43bc4
jmp 0x43c25
jmp 0x43bc6
jmp 0x43bc8
movzbl -0x51(%rbp), %eax
cmpl -0x24(%rbp), %eax
jl 0x43bd3
jmp 0x43c25
movl -0x48(%rbp), %eax
cmpl -0x40(%rbp), %eax
ja 0x43bec
movl -0x48(%rbp), %eax
cmpl -0x40(%rbp), %eax
jne 0x43bf5
movzbl -0x51(%rbp), %eax
cmpl -0x44(%rbp), %eax
jbe 0x43bf5
movl $0x1, -0x6c(%rbp)
jmp 0x43c09
movl -0x24(%rbp), %eax
imull -0x48(%rbp), %eax
movl %eax, -0x48(%rbp)
movzbl -0x51(%rbp), %eax
addl -0x48(%rbp), %eax
movl %eax, -0x48(%rbp)
jmp 0x43c0b
movq -0x50(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x50(%rbp)
movb 0x1(%rax), %al
movb %al, -0x51(%rbp)
jmp 0x43b54
movq -0x50(%rbp), %rax
cmpq -0x60(%rbp), %rax
jne 0x43c34
jmp 0x43cc5
cmpq $0x0, -0x30(%rbp)
je 0x43c46
movq -0x50(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
cmpl $0x0, -0x3c(%rbp)
je 0x43c5e
cmpl $0x80000000, -0x48(%rbp) # imm = 0x80000000
jbe 0x43c5c
movl $0x1, -0x6c(%rbp)
jmp 0x43c72
movl -0x48(%rbp), %eax
cmpq $0x7fffffff, %rax # imm = 0x7FFFFFFF
jle 0x43c70
movl $0x1, -0x6c(%rbp)
jmp 0x43c72
cmpl $0x0, -0x6c(%rbp)
je 0x43c9e
movq -0x38(%rbp), %rax
movl $0x22, (%rax)
movl -0x3c(%rbp), %edx
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movq $-0x80000000, %rcx # imm = 0x80000000
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x43ce9
cmpl $0x0, -0x3c(%rbp)
je 0x43cb4
movl -0x48(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0x78(%rbp)
jmp 0x43cbb
movl -0x48(%rbp), %eax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x43ce9
movq -0x38(%rbp), %rax
movl $0x21, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x43ce1
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
|
my_strntol_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 [rbp+var_30], r8
mov [rbp+var_38], r9
mov rax, [rbp+var_38]
mov dword ptr [rax], 0
mov rax, [rbp+var_18]
mov [rbp+var_50], rax
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
mov [rbp+var_68], rax
loc_43A79:
mov rcx, [rbp+var_50]
xor eax, eax
cmp rcx, [rbp+var_68]
mov [rbp+var_6D], al
jnb short loc_43AA8
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rcx, [rbp+var_50]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx+1]
and eax, 8
cmp eax, 0
setnz al
mov [rbp+var_6D], al
loc_43AA8:
mov al, [rbp+var_6D]
test al, 1
jnz short loc_43AB1
jmp short loc_43AC1
loc_43AB1:
jmp short $+2
loc_43AB3:
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_50], rax
jmp short loc_43A79
loc_43AC1:
mov rax, [rbp+var_50]
cmp rax, [rbp+var_68]
jnz short loc_43AD0
jmp loc_43CC5
loc_43AD0:
mov rax, [rbp+var_50]
movsx eax, byte ptr [rax]
cmp eax, 2Dh ; '-'
jnz short loc_43AF1
mov [rbp+var_3C], 1
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_50], rax
jmp short loc_43B1B
loc_43AF1:
mov rax, [rbp+var_50]
movsx eax, byte ptr [rax]
cmp eax, 2Bh ; '+'
jnz short loc_43B12
mov [rbp+var_3C], 0
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_50], rax
jmp short loc_43B19
loc_43B12:
mov [rbp+var_3C], 0
loc_43B19:
jmp short $+2
loc_43B1B:
mov rax, [rbp+var_50]
mov [rbp+var_60], rax
mov eax, 0FFFFFFFFh
xor edx, edx
div [rbp+var_24]
mov [rbp+var_40], eax
mov eax, 0FFFFFFFFh
xor edx, edx
div [rbp+var_24]
mov [rbp+var_44], edx
mov [rbp+var_6C], 0
mov [rbp+var_48], 0
mov rax, [rbp+var_50]
mov al, [rax]
mov [rbp+var_51], al
loc_43B54:
mov rax, [rbp+var_50]
cmp rax, [rbp+var_68]
jz loc_43C25
movzx eax, [rbp+var_51]
cmp eax, 30h ; '0'
jl short loc_43B80
movzx eax, [rbp+var_51]
cmp eax, 39h ; '9'
jg short loc_43B80
movzx eax, [rbp+var_51]
sub eax, 30h ; '0'
mov [rbp+var_51], al
jmp short loc_43BC8
loc_43B80:
movzx eax, [rbp+var_51]
cmp eax, 41h ; 'A'
jl short loc_43BA1
movzx eax, [rbp+var_51]
cmp eax, 5Ah ; 'Z'
jg short loc_43BA1
movzx eax, [rbp+var_51]
sub eax, 41h ; 'A'
add eax, 0Ah
mov [rbp+var_51], al
jmp short loc_43BC6
loc_43BA1:
movzx eax, [rbp+var_51]
cmp eax, 61h ; 'a'
jl short loc_43BC2
movzx eax, [rbp+var_51]
cmp eax, 7Ah ; 'z'
jg short loc_43BC2
movzx eax, [rbp+var_51]
sub eax, 61h ; 'a'
add eax, 0Ah
mov [rbp+var_51], al
jmp short loc_43BC4
loc_43BC2:
jmp short loc_43C25
loc_43BC4:
jmp short $+2
loc_43BC6:
jmp short $+2
loc_43BC8:
movzx eax, [rbp+var_51]
cmp eax, [rbp+var_24]
jl short loc_43BD3
jmp short loc_43C25
loc_43BD3:
mov eax, [rbp+var_48]
cmp eax, [rbp+var_40]
ja short loc_43BEC
mov eax, [rbp+var_48]
cmp eax, [rbp+var_40]
jnz short loc_43BF5
movzx eax, [rbp+var_51]
cmp eax, [rbp+var_44]
jbe short loc_43BF5
loc_43BEC:
mov [rbp+var_6C], 1
jmp short loc_43C09
loc_43BF5:
mov eax, [rbp+var_24]
imul eax, [rbp+var_48]
mov [rbp+var_48], eax
movzx eax, [rbp+var_51]
add eax, [rbp+var_48]
mov [rbp+var_48], eax
loc_43C09:
jmp short $+2
loc_43C0B:
mov rax, [rbp+var_50]
mov rcx, rax
add rcx, 1
mov [rbp+var_50], rcx
mov al, [rax+1]
mov [rbp+var_51], al
jmp loc_43B54
loc_43C25:
mov rax, [rbp+var_50]
cmp rax, [rbp+var_60]
jnz short loc_43C34
jmp loc_43CC5
loc_43C34:
cmp [rbp+var_30], 0
jz short loc_43C46
mov rcx, [rbp+var_50]
mov rax, [rbp+var_30]
mov [rax], rcx
loc_43C46:
cmp [rbp+var_3C], 0
jz short loc_43C5E
cmp [rbp+var_48], 80000000h
jbe short loc_43C5C
mov [rbp+var_6C], 1
loc_43C5C:
jmp short loc_43C72
loc_43C5E:
mov eax, [rbp+var_48]
cmp rax, 7FFFFFFFh
jle short loc_43C70
mov [rbp+var_6C], 1
loc_43C70:
jmp short $+2
loc_43C72:
cmp [rbp+var_6C], 0
jz short loc_43C9E
mov rax, [rbp+var_38]
mov dword ptr [rax], 22h ; '"'
mov edx, [rbp+var_3C]
mov eax, 7FFFFFFFh
mov rcx, 0FFFFFFFF80000000h
cmp edx, 0
cmovnz rax, rcx
mov [rbp+var_8], rax
jmp short loc_43CE9
loc_43C9E:
cmp [rbp+var_3C], 0
jz short loc_43CB4
mov eax, [rbp+var_48]
mov ecx, eax
xor eax, eax
sub rax, rcx
mov [rbp+var_78], rax
jmp short loc_43CBB
loc_43CB4:
mov eax, [rbp+var_48]
mov [rbp+var_78], rax
loc_43CBB:
mov rax, [rbp+var_78]
mov [rbp+var_8], rax
jmp short loc_43CE9
loc_43CC5:
mov rax, [rbp+var_38]
mov dword ptr [rax], 21h ; '!'
cmp [rbp+var_30], 0
jz short loc_43CE1
mov rcx, [rbp+var_18]
mov rax, [rbp+var_30]
mov [rax], rcx
loc_43CE1:
mov [rbp+var_8], 0
loc_43CE9:
mov rax, [rbp+var_8]
pop rbp
retn
|
long long my_strntol_8bit(long long a1, _BYTE *a2, long long a3, int a4, _QWORD *a5, _DWORD *a6)
{
_BYTE *v6; // rax
long long v7; // rax
bool v10; // [rsp+Bh] [rbp-6Dh]
int v11; // [rsp+Ch] [rbp-6Ch]
_BYTE *v12; // [rsp+10h] [rbp-68h]
_BYTE *v13; // [rsp+18h] [rbp-60h]
unsigned __int8 v14; // [rsp+27h] [rbp-51h]
unsigned __int8 v15; // [rsp+27h] [rbp-51h]
_BYTE *v16; // [rsp+28h] [rbp-50h]
unsigned int v17; // [rsp+30h] [rbp-48h]
unsigned long long v18; // [rsp+34h] [rbp-44h]
int v19; // [rsp+3Ch] [rbp-3Ch]
*a6 = 0;
v16 = a2;
v12 = &a2[a3];
while ( 1 )
{
v10 = 0;
if ( v16 < v12 )
v10 = (*(_BYTE *)(*(_QWORD *)(a1 + 64) + (unsigned __int8)*v16 + 1LL) & 8) != 0;
if ( !v10 )
break;
++v16;
}
if ( v16 == v12 )
goto LABEL_45;
if ( *v16 == 45 )
{
v19 = 1;
++v16;
}
else
{
v19 = 0;
if ( *v16 == 43 )
++v16;
}
v13 = v16;
v11 = 0;
v17 = 0;
v14 = *v16;
while ( v16 != v12 )
{
if ( v14 < 0x30u || v14 > 0x39u )
{
if ( v14 < 0x41u || v14 > 0x5Au )
{
if ( v14 < 0x61u || v14 > 0x7Au )
break;
v15 = v14 - 97 + 10;
}
else
{
v15 = v14 - 65 + 10;
}
}
else
{
v15 = v14 - 48;
}
if ( v15 >= a4 )
break;
LODWORD(v18) = 0xFFFFFFFF % a4;
HIDWORD(v18) = 0xFFFFFFFF / a4;
if ( __PAIR64__(v17, v15) <= v18 )
v17 = v17 * a4 + v15;
else
v11 = 1;
v6 = v16++;
v14 = v6[1];
}
if ( v16 == v13 )
{
LABEL_45:
*a6 = 33;
if ( a5 )
*a5 = a2;
return 0LL;
}
else
{
if ( a5 )
*a5 = v16;
if ( v19 )
{
if ( v17 > 0x80000000 )
v11 = 1;
}
else if ( v17 > 0x7FFFFFFFuLL )
{
v11 = 1;
}
if ( v11 )
{
*a6 = 34;
v7 = 0x7FFFFFFFLL;
if ( v19 )
return 0xFFFFFFFF80000000LL;
return v7;
}
else if ( v19 )
{
return -(long long)v17;
}
else
{
return v17;
}
}
}
|
my_strntol_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 qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x68],RAX
LAB_00143a79:
MOV RCX,qword ptr [RBP + -0x50]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x68]
MOV byte ptr [RBP + -0x6d],AL
JNC 0x00143aa8
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x50]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x8
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x6d],AL
LAB_00143aa8:
MOV AL,byte ptr [RBP + -0x6d]
TEST AL,0x1
JNZ 0x00143ab1
JMP 0x00143ac1
LAB_00143ab1:
JMP 0x00143ab3
LAB_00143ab3:
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00143a79
LAB_00143ac1:
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x68]
JNZ 0x00143ad0
JMP 0x00143cc5
LAB_00143ad0:
MOV RAX,qword ptr [RBP + -0x50]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2d
JNZ 0x00143af1
MOV dword ptr [RBP + -0x3c],0x1
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00143b1b
LAB_00143af1:
MOV RAX,qword ptr [RBP + -0x50]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2b
JNZ 0x00143b12
MOV dword ptr [RBP + -0x3c],0x0
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00143b19
LAB_00143b12:
MOV dword ptr [RBP + -0x3c],0x0
LAB_00143b19:
JMP 0x00143b1b
LAB_00143b1b:
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x60],RAX
MOV EAX,0xffffffff
XOR EDX,EDX
DIV dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x40],EAX
MOV EAX,0xffffffff
XOR EDX,EDX
DIV dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x44],EDX
MOV dword ptr [RBP + -0x6c],0x0
MOV dword ptr [RBP + -0x48],0x0
MOV RAX,qword ptr [RBP + -0x50]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x51],AL
LAB_00143b54:
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x68]
JZ 0x00143c25
MOVZX EAX,byte ptr [RBP + -0x51]
CMP EAX,0x30
JL 0x00143b80
MOVZX EAX,byte ptr [RBP + -0x51]
CMP EAX,0x39
JG 0x00143b80
MOVZX EAX,byte ptr [RBP + -0x51]
SUB EAX,0x30
MOV byte ptr [RBP + -0x51],AL
JMP 0x00143bc8
LAB_00143b80:
MOVZX EAX,byte ptr [RBP + -0x51]
CMP EAX,0x41
JL 0x00143ba1
MOVZX EAX,byte ptr [RBP + -0x51]
CMP EAX,0x5a
JG 0x00143ba1
MOVZX EAX,byte ptr [RBP + -0x51]
SUB EAX,0x41
ADD EAX,0xa
MOV byte ptr [RBP + -0x51],AL
JMP 0x00143bc6
LAB_00143ba1:
MOVZX EAX,byte ptr [RBP + -0x51]
CMP EAX,0x61
JL 0x00143bc2
MOVZX EAX,byte ptr [RBP + -0x51]
CMP EAX,0x7a
JG 0x00143bc2
MOVZX EAX,byte ptr [RBP + -0x51]
SUB EAX,0x61
ADD EAX,0xa
MOV byte ptr [RBP + -0x51],AL
JMP 0x00143bc4
LAB_00143bc2:
JMP 0x00143c25
LAB_00143bc4:
JMP 0x00143bc6
LAB_00143bc6:
JMP 0x00143bc8
LAB_00143bc8:
MOVZX EAX,byte ptr [RBP + -0x51]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x00143bd3
JMP 0x00143c25
LAB_00143bd3:
MOV EAX,dword ptr [RBP + -0x48]
CMP EAX,dword ptr [RBP + -0x40]
JA 0x00143bec
MOV EAX,dword ptr [RBP + -0x48]
CMP EAX,dword ptr [RBP + -0x40]
JNZ 0x00143bf5
MOVZX EAX,byte ptr [RBP + -0x51]
CMP EAX,dword ptr [RBP + -0x44]
JBE 0x00143bf5
LAB_00143bec:
MOV dword ptr [RBP + -0x6c],0x1
JMP 0x00143c09
LAB_00143bf5:
MOV EAX,dword ptr [RBP + -0x24]
IMUL EAX,dword ptr [RBP + -0x48]
MOV dword ptr [RBP + -0x48],EAX
MOVZX EAX,byte ptr [RBP + -0x51]
ADD EAX,dword ptr [RBP + -0x48]
MOV dword ptr [RBP + -0x48],EAX
LAB_00143c09:
JMP 0x00143c0b
LAB_00143c0b:
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x50],RCX
MOV AL,byte ptr [RAX + 0x1]
MOV byte ptr [RBP + -0x51],AL
JMP 0x00143b54
LAB_00143c25:
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x60]
JNZ 0x00143c34
JMP 0x00143cc5
LAB_00143c34:
CMP qword ptr [RBP + -0x30],0x0
JZ 0x00143c46
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
LAB_00143c46:
CMP dword ptr [RBP + -0x3c],0x0
JZ 0x00143c5e
CMP dword ptr [RBP + -0x48],0x80000000
JBE 0x00143c5c
MOV dword ptr [RBP + -0x6c],0x1
LAB_00143c5c:
JMP 0x00143c72
LAB_00143c5e:
MOV EAX,dword ptr [RBP + -0x48]
CMP RAX,0x7fffffff
JLE 0x00143c70
MOV dword ptr [RBP + -0x6c],0x1
LAB_00143c70:
JMP 0x00143c72
LAB_00143c72:
CMP dword ptr [RBP + -0x6c],0x0
JZ 0x00143c9e
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x22
MOV EDX,dword ptr [RBP + -0x3c]
MOV EAX,0x7fffffff
MOV RCX,-0x80000000
CMP EDX,0x0
CMOVNZ RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00143ce9
LAB_00143c9e:
CMP dword ptr [RBP + -0x3c],0x0
JZ 0x00143cb4
MOV EAX,dword ptr [RBP + -0x48]
MOV ECX,EAX
XOR EAX,EAX
SUB RAX,RCX
MOV qword ptr [RBP + -0x78],RAX
JMP 0x00143cbb
LAB_00143cb4:
MOV EAX,dword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x78],RAX
LAB_00143cbb:
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00143ce9
LAB_00143cc5:
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x21
CMP qword ptr [RBP + -0x30],0x0
JZ 0x00143ce1
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
LAB_00143ce1:
MOV qword ptr [RBP + -0x8],0x0
LAB_00143ce9:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
ulong my_strntol_8bit(long param_1,byte *param_2,long param_3,uint param_4,int8 *param_5,
int4 *param_6)
{
bool bVar1;
byte *pbVar2;
uint uVar3;
byte *pbVar4;
bool bVar5;
ulong local_80;
byte local_59;
byte *local_58;
uint local_50;
*param_6 = 0;
pbVar4 = param_2 + param_3;
local_58 = param_2;
while( true ) {
bVar5 = false;
if (local_58 < pbVar4) {
bVar5 = (*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*local_58) & 8) != 0;
}
if (!bVar5) break;
local_58 = local_58 + 1;
}
if (local_58 != pbVar4) {
if (*local_58 == 0x2d) {
bVar5 = true;
local_58 = local_58 + 1;
}
else {
if (*local_58 == 0x2b) {
local_58 = local_58 + 1;
}
bVar5 = false;
}
pbVar2 = local_58;
uVar3 = (uint)(0xffffffff / (ulong)param_4);
bVar1 = false;
local_50 = 0;
local_59 = *local_58;
for (; local_58 != pbVar4; local_58 = local_58 + 1) {
if ((local_59 < 0x30) || (0x39 < local_59)) {
if ((local_59 < 0x41) || (0x5a < local_59)) {
if ((local_59 < 0x61) || (0x7a < local_59)) break;
local_59 = local_59 + 0xa9;
}
else {
local_59 = local_59 - 0x37;
}
}
else {
local_59 = local_59 - 0x30;
}
if ((int)param_4 <= (int)(uint)local_59) break;
if ((uVar3 < local_50) ||
((local_50 == uVar3 && ((uint)(0xffffffff % (ulong)param_4) < (uint)local_59)))) {
bVar1 = true;
}
else {
local_50 = (uint)local_59 + param_4 * local_50;
}
local_59 = local_58[1];
}
if (local_58 != pbVar2) {
if (param_5 != (int8 *)0x0) {
*param_5 = local_58;
}
if (bVar5) {
if (0x80000000 < local_50) {
bVar1 = true;
}
}
else if (0x7fffffff < local_50) {
bVar1 = true;
}
if (bVar1) {
*param_6 = 0x22;
if (!bVar5) {
return 0x7fffffff;
}
return 0xffffffff80000000;
}
if (bVar5) {
local_80 = -(ulong)local_50;
}
else {
local_80 = (ulong)local_50;
}
return local_80;
}
}
*param_6 = 0x21;
if (param_5 != (int8 *)0x0) {
*param_5 = param_2;
}
return 0;
}
|
|
6,855 |
ma_hashtbl_init
|
eloqsql/libmariadb/libmariadb/ma_hashtbl.c
|
my_bool _ma_hashtbl_init(MA_HASHTBL *hash,uint size,uint key_offset,uint key_length,
hash_get_key get_key,
void (*free_element)(void*),uint flags CALLER_INFO_PROTO)
{
hash->records=0;
if (ma_init_dynamic_array_ci(&hash->array,sizeof(MA_HASHTBL_LINK),size,0))
{
hash->free=0; /* Allow call to hash_free */
return(TRUE);
}
hash->key_offset=key_offset;
hash->key_length=key_length;
hash->blength=1;
hash->current_record= NO_RECORD; /* For the future */
hash->get_key=get_key;
hash->free=free_element;
hash->flags=flags;
if (flags & MA_HASHTBL_CASE_INSENSITIVE)
hash->calc_hashnr=calc_hashnr_caseup;
else
hash->calc_hashnr=calc_hashnr;
return(0);
}
|
O0
|
c
|
ma_hashtbl_init:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movl -0x14(%rbp), %edx
movl $0x10, %esi
xorl %ecx, %ecx
callq 0x47020
cmpb $0x0, %al
je 0x48f08
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x48f82
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0xc(%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movl 0x10(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movl 0x10(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x48f6f
movq -0x10(%rbp), %rax
leaq 0x27(%rip), %rcx # 0x48f90
movq %rcx, 0x40(%rax)
jmp 0x48f7e
movq -0x10(%rbp), %rax
leaq 0x96(%rip), %rcx # 0x49010
movq %rcx, 0x40(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
_ma_hashtbl_init:
push rbp
mov rbp, rsp
sub rsp, 30h
mov eax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_10]
mov dword ptr [rax+8], 0
mov rdi, [rbp+var_10]
add rdi, 18h
mov edx, [rbp+var_14]
mov esi, 10h
xor ecx, ecx
call ma_init_dynamic_array
cmp al, 0
jz short loc_48F08
mov rax, [rbp+var_10]
mov qword ptr [rax+38h], 0
mov [rbp+var_1], 1
jmp short loc_48F82
loc_48F08:
mov ecx, [rbp+var_18]
mov rax, [rbp+var_10]
mov [rax], ecx
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_10]
mov [rax+4], ecx
mov rax, [rbp+var_10]
mov dword ptr [rax+0Ch], 1
mov rax, [rbp+var_10]
mov dword ptr [rax+10h], 0FFFFFFFFh
mov rcx, [rbp+var_28]
mov rax, [rbp+var_10]
mov [rax+30h], rcx
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax+38h], rcx
mov ecx, [rbp+arg_0]
mov rax, [rbp+var_10]
mov [rax+14h], ecx
mov eax, [rbp+arg_0]
and eax, 1
cmp eax, 0
jz short loc_48F6F
mov rax, [rbp+var_10]
lea rcx, calc_hashnr_caseup
mov [rax+40h], rcx
jmp short loc_48F7E
loc_48F6F:
mov rax, [rbp+var_10]
lea rcx, calc_hashnr
mov [rax+40h], rcx
loc_48F7E:
mov [rbp+var_1], 0
loc_48F82:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
|
char ma_hashtbl_init(long long a1, unsigned int a2, int a3, int a4, long long a5, long long a6, int a7)
{
*(_DWORD *)(a1 + 8) = 0;
if ( ma_init_dynamic_array(a1 + 24, 0x10u, a2, 0) )
{
*(_QWORD *)(a1 + 56) = 0LL;
return 1;
}
else
{
*(_DWORD *)a1 = a3;
*(_DWORD *)(a1 + 4) = a4;
*(_DWORD *)(a1 + 12) = 1;
*(_DWORD *)(a1 + 16) = -1;
*(_QWORD *)(a1 + 48) = a5;
*(_QWORD *)(a1 + 56) = a6;
*(_DWORD *)(a1 + 20) = a7;
if ( (a7 & 1) != 0 )
*(_QWORD *)(a1 + 64) = calc_hashnr_caseup;
else
*(_QWORD *)(a1 + 64) = calc_hashnr;
return 0;
}
}
|
_ma_hashtbl_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x8],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x18
MOV EDX,dword ptr [RBP + -0x14]
MOV ESI,0x10
XOR ECX,ECX
CALL 0x00147020
CMP AL,0x0
JZ 0x00148f08
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x38],0x0
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00148f82
LAB_00148f08:
MOV ECX,dword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x4],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xc],0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x10],0xffffffff
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x30],RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x38],RCX
MOV ECX,dword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x14],ECX
MOV EAX,dword ptr [RBP + 0x10]
AND EAX,0x1
CMP EAX,0x0
JZ 0x00148f6f
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x148f90]
MOV qword ptr [RAX + 0x40],RCX
JMP 0x00148f7e
LAB_00148f6f:
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x149010]
MOV qword ptr [RAX + 0x40],RCX
LAB_00148f7e:
MOV byte ptr [RBP + -0x1],0x0
LAB_00148f82:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1
_ma_hashtbl_init(int4 *param_1,int4 param_2,int4 param_3,int4 param_4,
int8 param_5,int8 param_6,uint param_7)
{
char cVar1;
int1 local_9;
param_1[2] = 0;
cVar1 = ma_init_dynamic_array(param_1 + 6,0x10,param_2,0);
if (cVar1 == '\0') {
*param_1 = param_3;
param_1[1] = param_4;
param_1[3] = 1;
param_1[4] = 0xffffffff;
*(int8 *)(param_1 + 0xc) = param_5;
*(int8 *)(param_1 + 0xe) = param_6;
param_1[5] = param_7;
if ((param_7 & 1) == 0) {
*(code **)(param_1 + 0x10) = calc_hashnr;
}
else {
*(code **)(param_1 + 0x10) = calc_hashnr_caseup;
}
local_9 = 0;
}
else {
*(int8 *)(param_1 + 0xe) = 0;
local_9 = 1;
}
return local_9;
}
|
|
6,856 |
stbi__pnm_skip_whitespace(stbi__context*, char*)
|
monkey531[P]llama/examples/llava/../../common/stb_image.h
|
static void stbi__pnm_skip_whitespace(stbi__context *s, char *c)
{
for (;;) {
while (!stbi__at_eof(s) && stbi__pnm_isspace(*c))
*c = (char) stbi__get8(s);
if (stbi__at_eof(s) || *c != '#')
break;
while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' )
*c = (char) stbi__get8(s);
}
}
|
O2
|
c
|
stbi__pnm_skip_whitespace(stbi__context*, char*):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0x100003e00, %r15 # imm = 0x100003E00
movq %r14, %rdi
callq 0x3f350
testl %eax, %eax
je 0x41509
movq %r14, %rdi
callq 0x3f350
testl %eax, %eax
jne 0x41524
cmpb $0x23, (%rbx)
jne 0x41524
movq %r14, %rdi
callq 0x3f350
testl %eax, %eax
jne 0x414c7
movzbl (%rbx), %eax
cmpl $0xa, %eax
je 0x414c7
cmpl $0xd, %eax
je 0x414c7
movq %r14, %rdi
callq 0x3c760
movb %al, (%rbx)
jmp 0x414e4
movzbl (%rbx), %eax
cmpq $0x20, %rax
ja 0x414d3
btq %rax, %r15
jae 0x414d3
movq %r14, %rdi
callq 0x3c760
movb %al, (%rbx)
jmp 0x414c7
popq %rbx
popq %r14
popq %r15
retq
|
_ZL25stbi__pnm_skip_whitespaceP13stbi__contextPc:
push r15
push r14
push rbx
mov rbx, rsi
mov r14, rdi
mov r15, 100003E00h
loc_414C7:
mov rdi, r14
call _ZL12stbi__at_eofP13stbi__context; stbi__at_eof(stbi__context *)
test eax, eax
jz short loc_41509
loc_414D3:
mov rdi, r14
call _ZL12stbi__at_eofP13stbi__context; stbi__at_eof(stbi__context *)
test eax, eax
jnz short loc_41524
cmp byte ptr [rbx], 23h ; '#'
jnz short loc_41524
loc_414E4:
mov rdi, r14
call _ZL12stbi__at_eofP13stbi__context; stbi__at_eof(stbi__context *)
test eax, eax
jnz short loc_414C7
movzx eax, byte ptr [rbx]
cmp eax, 0Ah
jz short loc_414C7
cmp eax, 0Dh
jz short loc_414C7
mov rdi, r14
call _ZL10stbi__get8P13stbi__context; stbi__get8(stbi__context *)
mov [rbx], al
jmp short loc_414E4
loc_41509:
movzx eax, byte ptr [rbx]
cmp rax, 20h ; ' '
ja short loc_414D3
bt r15, rax
jnb short loc_414D3
mov rdi, r14
call _ZL10stbi__get8P13stbi__context; stbi__get8(stbi__context *)
mov [rbx], al
jmp short loc_414C7
loc_41524:
pop rbx
pop r14
pop r15
retn
|
long long stbi__pnm_skip_whitespace(long long a1, char *a2)
{
long long v2; // r15
long long result; // rax
int v4; // eax
unsigned long long v5; // rax
v2 = 0x100003E00LL;
while ( 1 )
{
while ( !(unsigned int)stbi__at_eof(a1) )
{
v5 = (unsigned __int8)*a2;
if ( v5 > 0x20 || !_bittest64(&v2, v5) )
break;
*a2 = stbi__get8(a1);
}
result = stbi__at_eof(a1);
if ( (_DWORD)result || *a2 != 35 )
break;
while ( !(unsigned int)stbi__at_eof(a1) )
{
v4 = (unsigned __int8)*a2;
if ( v4 == 10 || v4 == 13 )
break;
*a2 = stbi__get8(a1);
}
}
return result;
}
|
stbi__pnm_skip_whitespace:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
MOV R15,0x100003e00
LAB_001414c7:
MOV RDI,R14
CALL 0x0013f350
TEST EAX,EAX
JZ 0x00141509
LAB_001414d3:
MOV RDI,R14
CALL 0x0013f350
TEST EAX,EAX
JNZ 0x00141524
CMP byte ptr [RBX],0x23
JNZ 0x00141524
LAB_001414e4:
MOV RDI,R14
CALL 0x0013f350
TEST EAX,EAX
JNZ 0x001414c7
MOVZX EAX,byte ptr [RBX]
CMP EAX,0xa
JZ 0x001414c7
CMP EAX,0xd
JZ 0x001414c7
MOV RDI,R14
CALL 0x0013c760
MOV byte ptr [RBX],AL
JMP 0x001414e4
LAB_00141509:
MOVZX EAX,byte ptr [RBX]
CMP RAX,0x20
JA 0x001414d3
BT R15,RAX
JNC 0x001414d3
MOV RDI,R14
CALL 0x0013c760
MOV byte ptr [RBX],AL
JMP 0x001414c7
LAB_00141524:
POP RBX
POP R14
POP R15
RET
|
/* stbi__pnm_skip_whitespace(stbi__context*, char*) */
void stbi__pnm_skip_whitespace(stbi__context *param_1,char *param_2)
{
char cVar1;
int iVar2;
while( true ) {
while( true ) {
iVar2 = stbi__at_eof(param_1);
if (((iVar2 != 0) || (0x20 < (ulong)(byte)*param_2)) ||
((0x100003e00U >> ((ulong)(byte)*param_2 & 0x3f) & 1) == 0)) break;
cVar1 = stbi__get8(param_1);
*param_2 = cVar1;
}
iVar2 = stbi__at_eof(param_1);
if ((iVar2 != 0) || (*param_2 != '#')) break;
while( true ) {
iVar2 = stbi__at_eof(param_1);
if (((iVar2 != 0) || (*param_2 == '\n')) || (*param_2 == '\r')) break;
cVar1 = stbi__get8(param_1);
*param_2 = cVar1;
}
}
return;
}
|
|
6,857 |
operator new(unsigned long)
|
ng-log[P]ng-log/src/googletest.h
|
void* operator new(size_t size) NGLOG_GLOG_THROW_BAD_ALLOC {
void* p = ::operator new(size, std::nothrow);
if (p == nullptr) {
throw std::bad_alloc{};
}
return p;
}
|
O1
|
c
|
operator new(unsigned long):
pushq %rax
movq 0x28f38(%rip), %rsi # 0x31f00
callq 0x8f9d
testq %rax, %rax
je 0x8fd4
popq %rcx
retq
movl $0x8, %edi
callq 0x7220
movq 0x28f63(%rip), %rcx # 0x31f48
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x28f95(%rip), %rsi # 0x31f88
movq 0x28f26(%rip), %rdx # 0x31f20
movq %rax, %rdi
callq 0x7900
|
_Znwm:
push rax
mov rsi, cs:_ZSt7nothrow_ptr; std::nothrow_t *
call _ZnwmRKSt9nothrow_t; operator new(ulong,std::nothrow_t const&)
test rax, rax
jz short loc_8FD4
pop rcx
retn
loc_8FD4:
mov edi, 8; thrown_size
call ___cxa_allocate_exception
mov rcx, cs:_ZTVSt9bad_alloc_ptr
add rcx, 10h
mov [rax], rcx
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt9bad_allocD1Ev_ptr; void (*)(void *)
mov rdi, rax; void *
call ___cxa_throw
|
long long operator new(long long a1)
{
long long result; // rax
_QWORD *exception; // rax
result = operator new(a1, (const std::nothrow_t *)&std::nothrow);
if ( !result )
{
exception = __cxa_allocate_exception(8uLL);
*exception = (char *)&`vtable for'std::bad_alloc + 16;
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::bad_alloc,
(void (*)(void *))&std::bad_alloc::~bad_alloc);
}
return result;
}
|
operator.new:
PUSH RAX
MOV RSI,qword ptr [0x00131f00]
CALL 0x00108f9d
TEST RAX,RAX
JZ 0x00108fd4
POP RCX
RET
LAB_00108fd4:
MOV EDI,0x8
CALL 0x00107220
MOV RCX,qword ptr [0x00131f48]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
MOV RSI,qword ptr [0x00131f88]
MOV RDX,qword ptr [0x00131f20]
MOV RDI,RAX
CALL 0x00107900
|
/* operator new(unsigned long) */
void * operator_new(ulong param_1)
{
void *pvVar1;
int8 *puVar2;
pvVar1 = operator_new(param_1,(nothrow_t *)PTR_nothrow_00131f00);
if (pvVar1 != (void *)0x0) {
return pvVar1;
}
puVar2 = (int8 *)__cxa_allocate_exception(8);
*puVar2 = PTR_vtable_00131f48 + 0x10;
/* WARNING: Subroutine does not return */
__cxa_throw(puVar2,PTR_typeinfo_00131f88,PTR__bad_alloc_00131f20);
}
|
|
6,858 |
flux::parser::Parser::declaration()
|
kvthweatt[P]FluxLang/src/parser/parser.cpp
|
std::unique_ptr<Decl> Parser::declaration() {
try {
// Save current token for potential backtracking
lexer::Token savedToken = current_;
// Handle keyword-based declarations first
if (match(lexer::TokenType::KEYWORD_NAMESPACE)) return namespaceDeclaration();
if (match(lexer::TokenType::KEYWORD_OBJECT)) return objectDeclaration();
if (match(lexer::TokenType::KEYWORD_CLASS)) return classDeclaration();
if (match(lexer::TokenType::KEYWORD_STRUCT)) return structDeclaration();
if (match(lexer::TokenType::KEYWORD_DEF)) return functionDeclaration();
if (match(lexer::TokenType::KEYWORD_CONST)) return variableDeclaration(true);
if (match(lexer::TokenType::KEYWORD_IMPORT)) return importDeclaration();
if (match(lexer::TokenType::KEYWORD_USING)) return usingDeclaration();
if (match(lexer::TokenType::KEYWORD_OPERATOR)) return operatorDeclaration();
if (match(lexer::TokenType::KEYWORD_TEMPLATE)) return templateDeclaration();
if (match(lexer::TokenType::KEYWORD_ENUM)) return enumDeclaration();
if (match(lexer::TokenType::KEYWORD_TYPE)) return typeDeclaration();
if (match({lexer::TokenType::KEYWORD_DATA,
lexer::TokenType::KEYWORD_SIGNED,
lexer::TokenType::KEYWORD_UNSIGNED})) return dataDeclaration();
if (match(lexer::TokenType::KEYWORD_ASM)) return asmDeclaration();
if (check(lexer::TokenType::IDENTIFIER)) return identifierDeclaration();
// Not a declaration
return nullptr;
} catch (const std::exception& e) {
std::cerr << "Error in declaration parsing: " << e.what() << std::endl;
synchronize();
return nullptr;
}
}
|
O0
|
cpp
|
flux::parser::Parser::declaration():
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
addq $0x8, %rsi
leaq -0x70(%rbp), %rdi
callq 0x15420
jmp 0x41f6e
movq -0xb0(%rbp), %rdi
movl $0x19, %esi
callq 0x43060
movb %al, -0xc1(%rbp)
jmp 0x41f87
movb -0xc1(%rbp), %al
testb $0x1, %al
jne 0x41f96
jmp 0x42082
movq -0xb0(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0x43670
jmp 0x41fab
movl $0x1, -0x80(%rbp)
jmp 0x424ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x41fda
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xa300
movl -0x7c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x424dc
movq -0x78(%rbp), %rdi
callq 0x7100
movq %rax, -0xa8(%rbp)
movq 0x53fef(%rip), %rdi # 0x95ff0
leaq 0x21982(%rip), %rsi # 0x6398a
callq 0x7330
movq %rax, -0xd0(%rbp)
jmp 0x42016
movq -0xa8(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0xd0(%rbp), %rdi
movq %rax, %rsi
callq 0x7330
movq %rax, -0xd8(%rbp)
jmp 0x4203e
movq -0xd8(%rbp), %rdi
movq 0x53f34(%rip), %rsi # 0x95f80
callq 0x7360
jmp 0x42053
movq -0xb0(%rbp), %rdi
callq 0x42bf0
jmp 0x42061
movq -0xc0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x58f80
movl $0x1, -0x80(%rbp)
callq 0x7540
jmp 0x424cc
movq -0xb0(%rbp), %rdi
movl $0x1b, %esi
callq 0x43060
movb %al, -0xd9(%rbp)
jmp 0x4209b
movb -0xd9(%rbp), %al
testb $0x1, %al
jne 0x420a7
jmp 0x420c8
movq -0xb0(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0x43a80
jmp 0x420bc
movl $0x1, -0x80(%rbp)
jmp 0x424ac
movq -0xb0(%rbp), %rdi
movl $0xb, %esi
callq 0x43060
movb %al, -0xda(%rbp)
jmp 0x420e1
movb -0xda(%rbp), %al
testb $0x1, %al
jne 0x420ed
jmp 0x4210e
movq -0xb0(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0x44840
jmp 0x42102
movl $0x1, -0x80(%rbp)
jmp 0x424ac
movq -0xb0(%rbp), %rdi
movl $0x22, %esi
callq 0x43060
movb %al, -0xdb(%rbp)
jmp 0x42127
movb -0xdb(%rbp), %al
testb $0x1, %al
jne 0x42133
jmp 0x42154
movq -0xb0(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0x45b00
jmp 0x42148
movl $0x1, -0x80(%rbp)
jmp 0x424ac
movq -0xb0(%rbp), %rdi
movl $0xf, %esi
callq 0x43060
movb %al, -0xdc(%rbp)
jmp 0x4216d
movb -0xdc(%rbp), %al
testb $0x1, %al
jne 0x42179
jmp 0x4219a
movq -0xb0(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0x45d50
jmp 0x4218e
movl $0x1, -0x80(%rbp)
jmp 0x424ac
movq -0xb0(%rbp), %rdi
movl $0xc, %esi
callq 0x43060
movb %al, -0xdd(%rbp)
jmp 0x421b3
movb -0xdd(%rbp), %al
testb $0x1, %al
jne 0x421bf
jmp 0x421e5
movq -0xb0(%rbp), %rsi
movq -0xc0(%rbp), %rdi
movl $0x1, %edx
callq 0x471a0
jmp 0x421d9
movl $0x1, -0x80(%rbp)
jmp 0x424ac
movq -0xb0(%rbp), %rdi
movl $0x17, %esi
callq 0x43060
movb %al, -0xde(%rbp)
jmp 0x421fe
movb -0xde(%rbp), %al
testb $0x1, %al
jne 0x4220a
jmp 0x4222b
movq -0xb0(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0x47650
jmp 0x4221f
movl $0x1, -0x80(%rbp)
jmp 0x424ac
movq -0xb0(%rbp), %rdi
movl $0x2d, %esi
callq 0x43060
movb %al, -0xdf(%rbp)
jmp 0x42244
movb -0xdf(%rbp), %al
testb $0x1, %al
jne 0x42250
jmp 0x42271
movq -0xb0(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0x47970
jmp 0x42265
movl $0x1, -0x80(%rbp)
jmp 0x424ac
movq -0xb0(%rbp), %rdi
movl $0x1d, %esi
callq 0x43060
movb %al, -0xe0(%rbp)
jmp 0x4228a
movb -0xe0(%rbp), %al
testb $0x1, %al
jne 0x42296
jmp 0x422b7
movq -0xb0(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0x47c30
jmp 0x422ab
movl $0x1, -0x80(%rbp)
jmp 0x424ac
movq -0xb0(%rbp), %rdi
movl $0x25, %esi
callq 0x43060
movb %al, -0xe1(%rbp)
jmp 0x422d0
movb -0xe1(%rbp), %al
testb $0x1, %al
jne 0x422dc
jmp 0x422fd
movq -0xb0(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0x48d80
jmp 0x422f1
movl $0x1, -0x80(%rbp)
jmp 0x424ac
movq -0xb0(%rbp), %rdi
movl $0x13, %esi
callq 0x43060
movb %al, -0xe2(%rbp)
jmp 0x42316
movb -0xe2(%rbp), %al
testb $0x1, %al
jne 0x42322
jmp 0x42343
movq -0xb0(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0x49cf0
jmp 0x42337
movl $0x1, -0x80(%rbp)
jmp 0x424ac
movq -0xb0(%rbp), %rdi
movl $0x2a, %esi
callq 0x43060
movb %al, -0xe3(%rbp)
jmp 0x4235c
movb -0xe3(%rbp), %al
testb $0x1, %al
jne 0x42368
jmp 0x42389
movq -0xb0(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0x4a220
jmp 0x4237d
movl $0x1, -0x80(%rbp)
jmp 0x424ac
movq -0xb0(%rbp), %rdi
movl $0xe, -0x9c(%rbp)
movl $0x20, -0x98(%rbp)
movl $0x2c, -0x94(%rbp)
leaq -0x9c(%rbp), %rax
movq %rax, -0x90(%rbp)
movq $0x3, -0x88(%rbp)
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
callq 0x430c0
movb %al, -0xe4(%rbp)
jmp 0x423e2
movb -0xe4(%rbp), %al
testb $0x1, %al
jne 0x423ee
jmp 0x4240f
movq -0xb0(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0x4a450
jmp 0x42403
movl $0x1, -0x80(%rbp)
jmp 0x424ac
movq -0xb0(%rbp), %rdi
movl $0x6, %esi
callq 0x43060
movb %al, -0xe5(%rbp)
jmp 0x42428
movb -0xe5(%rbp), %al
testb $0x1, %al
jne 0x42434
jmp 0x42452
movq -0xb0(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0x4aab0
jmp 0x42449
movl $0x1, -0x80(%rbp)
jmp 0x424ac
movq -0xb0(%rbp), %rdi
movl $0x5, %esi
callq 0x417c0
movb %al, -0xe6(%rbp)
jmp 0x4246b
movb -0xe6(%rbp), %al
testb $0x1, %al
jne 0x42477
jmp 0x42495
movq -0xb0(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0x4aed0
jmp 0x4248c
movl $0x1, -0x80(%rbp)
jmp 0x424ac
movq -0xc0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x58f80
movl $0x1, -0x80(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xa300
jmp 0x424cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x7540
jmp 0x424ca
jmp 0x424dc
movq -0xb8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x75a0
movq %rax, %rdi
callq 0x9430
nopl (%rax)
|
_ZN4flux6parser6Parser11declarationEv:
push rbp
mov rbp, rsp
sub rsp, 0F0h
mov [rbp+var_C0], rdi
mov rax, rdi
mov [rbp+var_B8], rax
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rsi, [rbp+var_10]
mov [rbp+var_B0], rsi
add rsi, 8; flux::lexer::Token *
lea rdi, [rbp+var_70]; this
call _ZN4flux5lexer5TokenC2ERKS1_; flux::lexer::Token::Token(flux::lexer::Token const&)
jmp short $+2
loc_41F6E:
mov rdi, [rbp+var_B0]
mov esi, 19h
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
mov [rbp+var_C1], al
jmp short $+2
loc_41F87:
mov al, [rbp+var_C1]
test al, 1
jnz short loc_41F96
jmp loc_42082
loc_41F96:
mov rsi, [rbp+var_B0]
mov rdi, [rbp+var_C0]; this
call _ZN4flux6parser6Parser20namespaceDeclarationEv; flux::parser::Parser::namespaceDeclaration(void)
jmp short $+2
loc_41FAB:
mov [rbp+var_80], 1
jmp loc_424AC
mov rcx, rax
mov eax, edx
mov [rbp+var_78], rcx
mov [rbp+var_7C], eax
jmp short loc_41FDA
mov rcx, rax
mov eax, edx
mov [rbp+var_78], rcx
mov [rbp+var_7C], eax
lea rdi, [rbp+var_70]; this
call _ZN4flux5lexer5TokenD2Ev; flux::lexer::Token::~Token()
loc_41FDA:
mov eax, [rbp+var_7C]
mov ecx, 1
cmp eax, ecx
jnz loc_424DC
mov rdi, [rbp+var_78]; void *
call ___cxa_begin_catch
mov [rbp+var_A8], rax
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, aErrorInDeclara; "Error in declaration parsing: "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rbp+var_D0], rax
jmp short $+2
loc_42016:
mov rdi, [rbp+var_A8]
mov rax, [rdi]
mov rax, [rax+10h]
call rax
mov rdi, [rbp+var_D0]
mov rsi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rbp+var_D8], rax
jmp short $+2
loc_4203E:
mov rdi, [rbp+var_D8]
mov rsi, cs:_ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6__ptr
call __ZNSolsEPFRSoS_E; std::ostream::operator<<(std::ostream & (*)(std::ostream &))
jmp short $+2
loc_42053:
mov rdi, [rbp+var_B0]; this
call _ZN4flux6parser6Parser11synchronizeEv; flux::parser::Parser::synchronize(void)
jmp short $+2
loc_42061:
mov rdi, [rbp+var_C0]
xor eax, eax
mov esi, eax
call _ZNSt10unique_ptrIN4flux6parser4DeclESt14default_deleteIS2_EEC2IS4_vEEDn; std::unique_ptr<flux::parser::Decl>::unique_ptr<std::default_delete<flux::parser::Decl>,void>(decltype(nullptr))
mov [rbp+var_80], 1
call ___cxa_end_catch
jmp loc_424CC
loc_42082:
mov rdi, [rbp+var_B0]
mov esi, 1Bh
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
mov [rbp+var_D9], al
jmp short $+2
loc_4209B:
mov al, [rbp+var_D9]
test al, 1
jnz short loc_420A7
jmp short loc_420C8
loc_420A7:
mov rsi, [rbp+var_B0]
mov rdi, [rbp+var_C0]; this
call _ZN4flux6parser6Parser17objectDeclarationEv; flux::parser::Parser::objectDeclaration(void)
jmp short $+2
loc_420BC:
mov [rbp+var_80], 1
jmp loc_424AC
loc_420C8:
mov rdi, [rbp+var_B0]
mov esi, 0Bh
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
mov [rbp+var_DA], al
jmp short $+2
loc_420E1:
mov al, [rbp+var_DA]
test al, 1
jnz short loc_420ED
jmp short loc_4210E
loc_420ED:
mov rsi, [rbp+var_B0]
mov rdi, [rbp+var_C0]; this
call _ZN4flux6parser6Parser16classDeclarationEv; flux::parser::Parser::classDeclaration(void)
jmp short $+2
loc_42102:
mov [rbp+var_80], 1
jmp loc_424AC
loc_4210E:
mov rdi, [rbp+var_B0]
mov esi, 22h ; '"'
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
mov [rbp+var_DB], al
jmp short $+2
loc_42127:
mov al, [rbp+var_DB]
test al, 1
jnz short loc_42133
jmp short loc_42154
loc_42133:
mov rsi, [rbp+var_B0]
mov rdi, [rbp+var_C0]; this
call _ZN4flux6parser6Parser17structDeclarationEv; flux::parser::Parser::structDeclaration(void)
jmp short $+2
loc_42148:
mov [rbp+var_80], 1
jmp loc_424AC
loc_42154:
mov rdi, [rbp+var_B0]
mov esi, 0Fh
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
mov [rbp+var_DC], al
jmp short $+2
loc_4216D:
mov al, [rbp+var_DC]
test al, 1
jnz short loc_42179
jmp short loc_4219A
loc_42179:
mov rsi, [rbp+var_B0]
mov rdi, [rbp+var_C0]; this
call _ZN4flux6parser6Parser19functionDeclarationEv; flux::parser::Parser::functionDeclaration(void)
jmp short $+2
loc_4218E:
mov [rbp+var_80], 1
jmp loc_424AC
loc_4219A:
mov rdi, [rbp+var_B0]
mov esi, 0Ch
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
mov [rbp+var_DD], al
jmp short $+2
loc_421B3:
mov al, [rbp+var_DD]
test al, 1
jnz short loc_421BF
jmp short loc_421E5
loc_421BF:
mov rsi, [rbp+var_B0]; bool
mov rdi, [rbp+var_C0]; this
mov edx, 1
call _ZN4flux6parser6Parser19variableDeclarationEb; flux::parser::Parser::variableDeclaration(bool)
jmp short $+2
loc_421D9:
mov [rbp+var_80], 1
jmp loc_424AC
loc_421E5:
mov rdi, [rbp+var_B0]
mov esi, 17h
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
mov [rbp+var_DE], al
jmp short $+2
loc_421FE:
mov al, [rbp+var_DE]
test al, 1
jnz short loc_4220A
jmp short loc_4222B
loc_4220A:
mov rsi, [rbp+var_B0]
mov rdi, [rbp+var_C0]; this
call _ZN4flux6parser6Parser17importDeclarationEv; flux::parser::Parser::importDeclaration(void)
jmp short $+2
loc_4221F:
mov [rbp+var_80], 1
jmp loc_424AC
loc_4222B:
mov rdi, [rbp+var_B0]
mov esi, 2Dh ; '-'
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
mov [rbp+var_DF], al
jmp short $+2
loc_42244:
mov al, [rbp+var_DF]
test al, 1
jnz short loc_42250
jmp short loc_42271
loc_42250:
mov rsi, [rbp+var_B0]
mov rdi, [rbp+var_C0]; this
call _ZN4flux6parser6Parser16usingDeclarationEv; flux::parser::Parser::usingDeclaration(void)
jmp short $+2
loc_42265:
mov [rbp+var_80], 1
jmp loc_424AC
loc_42271:
mov rdi, [rbp+var_B0]
mov esi, 1Dh
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
mov [rbp+var_E0], al
jmp short $+2
loc_4228A:
mov al, [rbp+var_E0]
test al, 1
jnz short loc_42296
jmp short loc_422B7
loc_42296:
mov rsi, [rbp+var_B0]
mov rdi, [rbp+var_C0]; this
call _ZN4flux6parser6Parser19operatorDeclarationEv; flux::parser::Parser::operatorDeclaration(void)
jmp short $+2
loc_422AB:
mov [rbp+var_80], 1
jmp loc_424AC
loc_422B7:
mov rdi, [rbp+var_B0]
mov esi, 25h ; '%'
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
mov [rbp+var_E1], al
jmp short $+2
loc_422D0:
mov al, [rbp+var_E1]
test al, 1
jnz short loc_422DC
jmp short loc_422FD
loc_422DC:
mov rsi, [rbp+var_B0]
mov rdi, [rbp+var_C0]; this
call _ZN4flux6parser6Parser19templateDeclarationEv; flux::parser::Parser::templateDeclaration(void)
jmp short $+2
loc_422F1:
mov [rbp+var_80], 1
jmp loc_424AC
loc_422FD:
mov rdi, [rbp+var_B0]
mov esi, 13h
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
mov [rbp+var_E2], al
jmp short $+2
loc_42316:
mov al, [rbp+var_E2]
test al, 1
jnz short loc_42322
jmp short loc_42343
loc_42322:
mov rsi, [rbp+var_B0]
mov rdi, [rbp+var_C0]; this
call _ZN4flux6parser6Parser15enumDeclarationEv; flux::parser::Parser::enumDeclaration(void)
jmp short $+2
loc_42337:
mov [rbp+var_80], 1
jmp loc_424AC
loc_42343:
mov rdi, [rbp+var_B0]
mov esi, 2Ah ; '*'
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
mov [rbp+var_E3], al
jmp short $+2
loc_4235C:
mov al, [rbp+var_E3]
test al, 1
jnz short loc_42368
jmp short loc_42389
loc_42368:
mov rsi, [rbp+var_B0]
mov rdi, [rbp+var_C0]; this
call _ZN4flux6parser6Parser15typeDeclarationEv; flux::parser::Parser::typeDeclaration(void)
jmp short $+2
loc_4237D:
mov [rbp+var_80], 1
jmp loc_424AC
loc_42389:
mov rdi, [rbp+var_B0]
mov [rbp+var_9C], 0Eh
mov [rbp+var_98], 20h ; ' '
mov [rbp+var_94], 2Ch ; ','
lea rax, [rbp+var_9C]
mov [rbp+var_90], rax
mov [rbp+var_88], 3
mov rsi, [rbp+var_90]
mov rdx, [rbp+var_88]
call _ZN4flux6parser6Parser5matchESt16initializer_listINS_5lexer9TokenTypeEE; flux::parser::Parser::match(std::initializer_list<flux::lexer::TokenType>)
mov [rbp+var_E4], al
jmp short $+2
loc_423E2:
mov al, [rbp+var_E4]
test al, 1
jnz short loc_423EE
jmp short loc_4240F
loc_423EE:
mov rsi, [rbp+var_B0]
mov rdi, [rbp+var_C0]; this
call _ZN4flux6parser6Parser15dataDeclarationEv; flux::parser::Parser::dataDeclaration(void)
jmp short $+2
loc_42403:
mov [rbp+var_80], 1
jmp loc_424AC
loc_4240F:
mov rdi, [rbp+var_B0]
mov esi, 6
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
mov [rbp+var_E5], al
jmp short $+2
loc_42428:
mov al, [rbp+var_E5]
test al, 1
jnz short loc_42434
jmp short loc_42452
loc_42434:
mov rsi, [rbp+var_B0]
mov rdi, [rbp+var_C0]; this
call _ZN4flux6parser6Parser14asmDeclarationEv; flux::parser::Parser::asmDeclaration(void)
jmp short $+2
loc_42449:
mov [rbp+var_80], 1
jmp short loc_424AC
loc_42452:
mov rdi, [rbp+var_B0]
mov esi, 5
call _ZNK4flux6parser6Parser5checkENS_5lexer9TokenTypeE; flux::parser::Parser::check(flux::lexer::TokenType)
mov [rbp+var_E6], al
jmp short $+2
loc_4246B:
mov al, [rbp+var_E6]
test al, 1
jnz short loc_42477
jmp short loc_42495
loc_42477:
mov rsi, [rbp+var_B0]
mov rdi, [rbp+var_C0]; this
call _ZN4flux6parser6Parser21identifierDeclarationEv; flux::parser::Parser::identifierDeclaration(void)
jmp short $+2
loc_4248C:
mov [rbp+var_80], 1
jmp short loc_424AC
loc_42495:
mov rdi, [rbp+var_C0]
xor eax, eax
mov esi, eax
call _ZNSt10unique_ptrIN4flux6parser4DeclESt14default_deleteIS2_EEC2IS4_vEEDn; std::unique_ptr<flux::parser::Decl>::unique_ptr<std::default_delete<flux::parser::Decl>,void>(decltype(nullptr))
mov [rbp+var_80], 1
loc_424AC:
lea rdi, [rbp+var_70]; this
call _ZN4flux5lexer5TokenD2Ev; flux::lexer::Token::~Token()
jmp short loc_424CC
mov rcx, rax
mov eax, edx
mov [rbp+var_78], rcx
mov [rbp+var_7C], eax
call ___cxa_end_catch
jmp short $+2
loc_424CA:
jmp short loc_424DC
loc_424CC:
mov rax, [rbp+var_B8]
add rsp, 0F0h
pop rbp
retn
loc_424DC:
mov rdi, [rbp+var_78]
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
|
flux::parser::Parser * flux::parser::Parser::declaration(flux::parser::Parser *this, long long a2)
{
_DWORD v3[3]; // [rsp+54h] [rbp-9Ch] BYREF
_DWORD *v4; // [rsp+60h] [rbp-90h]
long long v5; // [rsp+68h] [rbp-88h]
int v6; // [rsp+70h] [rbp-80h]
_BYTE v7[96]; // [rsp+80h] [rbp-70h] BYREF
long long v8; // [rsp+E0h] [rbp-10h]
flux::parser::Parser *v9; // [rsp+E8h] [rbp-8h]
v9 = this;
v8 = a2;
flux::lexer::Token::Token((flux::lexer::Token *)v7, (const flux::lexer::Token *)(a2 + 8));
if ( (flux::parser::Parser::match(a2, 25LL) & 1) != 0 )
{
flux::parser::Parser::namespaceDeclaration(this);
v6 = 1;
}
else if ( (flux::parser::Parser::match(a2, 27LL) & 1) != 0 )
{
flux::parser::Parser::objectDeclaration(this);
v6 = 1;
}
else if ( (flux::parser::Parser::match(a2, 11LL) & 1) != 0 )
{
flux::parser::Parser::classDeclaration(this);
v6 = 1;
}
else if ( (flux::parser::Parser::match(a2, 34LL) & 1) != 0 )
{
flux::parser::Parser::structDeclaration(this);
v6 = 1;
}
else if ( (flux::parser::Parser::match(a2, 15LL) & 1) != 0 )
{
flux::parser::Parser::functionDeclaration(this);
v6 = 1;
}
else if ( (flux::parser::Parser::match(a2, 12LL) & 1) != 0 )
{
flux::parser::Parser::variableDeclaration(this, a2);
v6 = 1;
}
else if ( (flux::parser::Parser::match(a2, 23LL) & 1) != 0 )
{
flux::parser::Parser::importDeclaration(this);
v6 = 1;
}
else if ( (flux::parser::Parser::match(a2, 45LL) & 1) != 0 )
{
flux::parser::Parser::usingDeclaration(this);
v6 = 1;
}
else if ( (flux::parser::Parser::match(a2, 29LL) & 1) != 0 )
{
flux::parser::Parser::operatorDeclaration(this);
v6 = 1;
}
else if ( (flux::parser::Parser::match(a2, 37LL) & 1) != 0 )
{
flux::parser::Parser::templateDeclaration(this);
v6 = 1;
}
else if ( (flux::parser::Parser::match(a2, 19LL) & 1) != 0 )
{
flux::parser::Parser::enumDeclaration(this);
v6 = 1;
}
else if ( (flux::parser::Parser::match(a2, 42LL) & 1) != 0 )
{
flux::parser::Parser::typeDeclaration(this);
v6 = 1;
}
else
{
v3[0] = 14;
v3[1] = 32;
v3[2] = 44;
v4 = v3;
v5 = 3LL;
if ( (flux::parser::Parser::match(a2, v3, 3LL) & 1) != 0 )
{
flux::parser::Parser::dataDeclaration(this);
v6 = 1;
}
else if ( (flux::parser::Parser::match(a2, 6LL) & 1) != 0 )
{
flux::parser::Parser::asmDeclaration(this);
v6 = 1;
}
else
{
if ( flux::parser::Parser::check(a2, 5) )
flux::parser::Parser::identifierDeclaration(this);
else
std::unique_ptr<flux::parser::Decl>::unique_ptr<std::default_delete<flux::parser::Decl>,void>(this, 0LL);
v6 = 1;
}
}
flux::lexer::Token::~Token((flux::lexer::Token *)v7);
return this;
}
|
declaration:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xf0
MOV qword ptr [RBP + -0xc0],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0xb8],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RSI,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0xb0],RSI
ADD RSI,0x8
LAB_00141f63:
LEA RDI,[RBP + -0x70]
CALL 0x00115420
JMP 0x00141f6e
LAB_00141f6e:
MOV RDI,qword ptr [RBP + -0xb0]
MOV ESI,0x19
CALL 0x00143060
MOV byte ptr [RBP + -0xc1],AL
JMP 0x00141f87
LAB_00141f87:
MOV AL,byte ptr [RBP + -0xc1]
TEST AL,0x1
JNZ 0x00141f96
JMP 0x00142082
LAB_00141f96:
MOV RSI,qword ptr [RBP + -0xb0]
MOV RDI,qword ptr [RBP + -0xc0]
CALL 0x00143670
LAB_00141fa9:
JMP 0x00141fab
LAB_00141fab:
MOV dword ptr [RBP + -0x80],0x1
JMP 0x001424ac
LAB_00142082:
MOV RDI,qword ptr [RBP + -0xb0]
MOV ESI,0x1b
CALL 0x00143060
MOV byte ptr [RBP + -0xd9],AL
JMP 0x0014209b
LAB_0014209b:
MOV AL,byte ptr [RBP + -0xd9]
TEST AL,0x1
JNZ 0x001420a7
JMP 0x001420c8
LAB_001420a7:
MOV RSI,qword ptr [RBP + -0xb0]
MOV RDI,qword ptr [RBP + -0xc0]
CALL 0x00143a80
JMP 0x001420bc
LAB_001420bc:
MOV dword ptr [RBP + -0x80],0x1
JMP 0x001424ac
LAB_001420c8:
MOV RDI,qword ptr [RBP + -0xb0]
MOV ESI,0xb
CALL 0x00143060
MOV byte ptr [RBP + -0xda],AL
JMP 0x001420e1
LAB_001420e1:
MOV AL,byte ptr [RBP + -0xda]
TEST AL,0x1
JNZ 0x001420ed
JMP 0x0014210e
LAB_001420ed:
MOV RSI,qword ptr [RBP + -0xb0]
MOV RDI,qword ptr [RBP + -0xc0]
CALL 0x00144840
JMP 0x00142102
LAB_00142102:
MOV dword ptr [RBP + -0x80],0x1
JMP 0x001424ac
LAB_0014210e:
MOV RDI,qword ptr [RBP + -0xb0]
MOV ESI,0x22
CALL 0x00143060
MOV byte ptr [RBP + -0xdb],AL
JMP 0x00142127
LAB_00142127:
MOV AL,byte ptr [RBP + -0xdb]
TEST AL,0x1
JNZ 0x00142133
JMP 0x00142154
LAB_00142133:
MOV RSI,qword ptr [RBP + -0xb0]
MOV RDI,qword ptr [RBP + -0xc0]
CALL 0x00145b00
JMP 0x00142148
LAB_00142148:
MOV dword ptr [RBP + -0x80],0x1
JMP 0x001424ac
LAB_00142154:
MOV RDI,qword ptr [RBP + -0xb0]
MOV ESI,0xf
CALL 0x00143060
MOV byte ptr [RBP + -0xdc],AL
JMP 0x0014216d
LAB_0014216d:
MOV AL,byte ptr [RBP + -0xdc]
TEST AL,0x1
JNZ 0x00142179
JMP 0x0014219a
LAB_00142179:
MOV RSI,qword ptr [RBP + -0xb0]
MOV RDI,qword ptr [RBP + -0xc0]
CALL 0x00145d50
JMP 0x0014218e
LAB_0014218e:
MOV dword ptr [RBP + -0x80],0x1
JMP 0x001424ac
LAB_0014219a:
MOV RDI,qword ptr [RBP + -0xb0]
MOV ESI,0xc
CALL 0x00143060
MOV byte ptr [RBP + -0xdd],AL
JMP 0x001421b3
LAB_001421b3:
MOV AL,byte ptr [RBP + -0xdd]
TEST AL,0x1
JNZ 0x001421bf
JMP 0x001421e5
LAB_001421bf:
MOV RSI,qword ptr [RBP + -0xb0]
MOV RDI,qword ptr [RBP + -0xc0]
MOV EDX,0x1
CALL 0x001471a0
JMP 0x001421d9
LAB_001421d9:
MOV dword ptr [RBP + -0x80],0x1
JMP 0x001424ac
LAB_001421e5:
MOV RDI,qword ptr [RBP + -0xb0]
MOV ESI,0x17
CALL 0x00143060
MOV byte ptr [RBP + -0xde],AL
JMP 0x001421fe
LAB_001421fe:
MOV AL,byte ptr [RBP + -0xde]
TEST AL,0x1
JNZ 0x0014220a
JMP 0x0014222b
LAB_0014220a:
MOV RSI,qword ptr [RBP + -0xb0]
MOV RDI,qword ptr [RBP + -0xc0]
CALL 0x00147650
JMP 0x0014221f
LAB_0014221f:
MOV dword ptr [RBP + -0x80],0x1
JMP 0x001424ac
LAB_0014222b:
MOV RDI,qword ptr [RBP + -0xb0]
MOV ESI,0x2d
CALL 0x00143060
MOV byte ptr [RBP + -0xdf],AL
JMP 0x00142244
LAB_00142244:
MOV AL,byte ptr [RBP + -0xdf]
TEST AL,0x1
JNZ 0x00142250
JMP 0x00142271
LAB_00142250:
MOV RSI,qword ptr [RBP + -0xb0]
MOV RDI,qword ptr [RBP + -0xc0]
CALL 0x00147970
JMP 0x00142265
LAB_00142265:
MOV dword ptr [RBP + -0x80],0x1
JMP 0x001424ac
LAB_00142271:
MOV RDI,qword ptr [RBP + -0xb0]
MOV ESI,0x1d
CALL 0x00143060
MOV byte ptr [RBP + -0xe0],AL
JMP 0x0014228a
LAB_0014228a:
MOV AL,byte ptr [RBP + -0xe0]
TEST AL,0x1
JNZ 0x00142296
JMP 0x001422b7
LAB_00142296:
MOV RSI,qword ptr [RBP + -0xb0]
MOV RDI,qword ptr [RBP + -0xc0]
CALL 0x00147c30
JMP 0x001422ab
LAB_001422ab:
MOV dword ptr [RBP + -0x80],0x1
JMP 0x001424ac
LAB_001422b7:
MOV RDI,qword ptr [RBP + -0xb0]
MOV ESI,0x25
CALL 0x00143060
MOV byte ptr [RBP + -0xe1],AL
JMP 0x001422d0
LAB_001422d0:
MOV AL,byte ptr [RBP + -0xe1]
TEST AL,0x1
JNZ 0x001422dc
JMP 0x001422fd
LAB_001422dc:
MOV RSI,qword ptr [RBP + -0xb0]
MOV RDI,qword ptr [RBP + -0xc0]
CALL 0x00148d80
JMP 0x001422f1
LAB_001422f1:
MOV dword ptr [RBP + -0x80],0x1
JMP 0x001424ac
LAB_001422fd:
MOV RDI,qword ptr [RBP + -0xb0]
MOV ESI,0x13
CALL 0x00143060
MOV byte ptr [RBP + -0xe2],AL
JMP 0x00142316
LAB_00142316:
MOV AL,byte ptr [RBP + -0xe2]
TEST AL,0x1
JNZ 0x00142322
JMP 0x00142343
LAB_00142322:
MOV RSI,qword ptr [RBP + -0xb0]
MOV RDI,qword ptr [RBP + -0xc0]
CALL 0x00149cf0
JMP 0x00142337
LAB_00142337:
MOV dword ptr [RBP + -0x80],0x1
JMP 0x001424ac
LAB_00142343:
MOV RDI,qword ptr [RBP + -0xb0]
MOV ESI,0x2a
CALL 0x00143060
MOV byte ptr [RBP + -0xe3],AL
JMP 0x0014235c
LAB_0014235c:
MOV AL,byte ptr [RBP + -0xe3]
TEST AL,0x1
JNZ 0x00142368
JMP 0x00142389
LAB_00142368:
MOV RSI,qword ptr [RBP + -0xb0]
MOV RDI,qword ptr [RBP + -0xc0]
CALL 0x0014a220
JMP 0x0014237d
LAB_0014237d:
MOV dword ptr [RBP + -0x80],0x1
JMP 0x001424ac
LAB_00142389:
MOV RDI,qword ptr [RBP + -0xb0]
MOV dword ptr [RBP + -0x9c],0xe
MOV dword ptr [RBP + -0x98],0x20
MOV dword ptr [RBP + -0x94],0x2c
LEA RAX,[RBP + -0x9c]
MOV qword ptr [RBP + -0x90],RAX
MOV qword ptr [RBP + -0x88],0x3
MOV RSI,qword ptr [RBP + -0x90]
MOV RDX,qword ptr [RBP + -0x88]
CALL 0x001430c0
MOV byte ptr [RBP + -0xe4],AL
JMP 0x001423e2
LAB_001423e2:
MOV AL,byte ptr [RBP + -0xe4]
TEST AL,0x1
JNZ 0x001423ee
JMP 0x0014240f
LAB_001423ee:
MOV RSI,qword ptr [RBP + -0xb0]
MOV RDI,qword ptr [RBP + -0xc0]
CALL 0x0014a450
JMP 0x00142403
LAB_00142403:
MOV dword ptr [RBP + -0x80],0x1
JMP 0x001424ac
LAB_0014240f:
MOV RDI,qword ptr [RBP + -0xb0]
MOV ESI,0x6
CALL 0x00143060
MOV byte ptr [RBP + -0xe5],AL
JMP 0x00142428
LAB_00142428:
MOV AL,byte ptr [RBP + -0xe5]
TEST AL,0x1
JNZ 0x00142434
JMP 0x00142452
LAB_00142434:
MOV RSI,qword ptr [RBP + -0xb0]
MOV RDI,qword ptr [RBP + -0xc0]
CALL 0x0014aab0
JMP 0x00142449
LAB_00142449:
MOV dword ptr [RBP + -0x80],0x1
JMP 0x001424ac
LAB_00142452:
MOV RDI,qword ptr [RBP + -0xb0]
MOV ESI,0x5
CALL 0x001417c0
MOV byte ptr [RBP + -0xe6],AL
JMP 0x0014246b
LAB_0014246b:
MOV AL,byte ptr [RBP + -0xe6]
TEST AL,0x1
JNZ 0x00142477
JMP 0x00142495
LAB_00142477:
MOV RSI,qword ptr [RBP + -0xb0]
MOV RDI,qword ptr [RBP + -0xc0]
CALL 0x0014aed0
JMP 0x0014248c
LAB_0014248c:
MOV dword ptr [RBP + -0x80],0x1
JMP 0x001424ac
LAB_00142495:
MOV RDI,qword ptr [RBP + -0xc0]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x00158f80
MOV dword ptr [RBP + -0x80],0x1
LAB_001424ac:
LEA RDI,[RBP + -0x70]
CALL 0x0010a300
JMP 0x001424cc
LAB_001424cc:
MOV RAX,qword ptr [RBP + -0xb8]
ADD RSP,0xf0
POP RBP
RET
|
/* flux::parser::Parser::declaration() */
_func_decltype_nullptr * flux::parser::Parser::declaration(void)
{
byte bVar1;
Parser *in_RSI;
_func_decltype_nullptr *in_RDI;
int4 local_a4;
int4 local_a0;
int4 local_9c;
int4 *local_98;
int8 local_90;
int4 local_88;
Token local_78 [112];
/* try { // try from 00141f63 to 00141f6b has its CatchHandler @ 00141fb7 */
lexer::Token::Token(local_78,(Token *)(in_RSI + 8));
/* try { // try from 00141f6e to 00141fa8 has its CatchHandler @ 00141fc5 */
bVar1 = match(in_RSI,0x19);
if ((bVar1 & 1) == 0) {
/* try { // try from 00142082 to 00142489 has its CatchHandler @ 00141fc5 */
bVar1 = match(in_RSI,0x1b);
if ((bVar1 & 1) == 0) {
bVar1 = match(in_RSI,0xb);
if ((bVar1 & 1) == 0) {
bVar1 = match(in_RSI,0x22);
if ((bVar1 & 1) == 0) {
bVar1 = match(in_RSI,0xf);
if ((bVar1 & 1) == 0) {
bVar1 = match(in_RSI,0xc);
if ((bVar1 & 1) == 0) {
bVar1 = match(in_RSI,0x17);
if ((bVar1 & 1) == 0) {
bVar1 = match(in_RSI,0x2d);
if ((bVar1 & 1) == 0) {
bVar1 = match(in_RSI,0x1d);
if ((bVar1 & 1) == 0) {
bVar1 = match(in_RSI,0x25);
if ((bVar1 & 1) == 0) {
bVar1 = match(in_RSI,0x13);
if ((bVar1 & 1) == 0) {
bVar1 = match(in_RSI,0x2a);
if ((bVar1 & 1) == 0) {
local_a4 = 0xe;
local_a0 = 0x20;
local_9c = 0x2c;
local_98 = &local_a4;
local_90 = 3;
bVar1 = match(in_RSI,local_98,3);
if ((bVar1 & 1) == 0) {
bVar1 = match(in_RSI,6);
if ((bVar1 & 1) == 0) {
bVar1 = check(in_RSI,5);
if ((bVar1 & 1) == 0) {
std::
unique_ptr<flux::parser::Decl,std::default_delete<flux::parser::Decl>>
::unique_ptr<std::default_delete<flux::parser::Decl>,void>(in_RDI);
}
else {
identifierDeclaration();
}
}
else {
asmDeclaration();
}
}
else {
dataDeclaration();
}
}
else {
typeDeclaration();
}
}
else {
enumDeclaration();
}
}
else {
templateDeclaration();
}
}
else {
operatorDeclaration();
}
}
else {
usingDeclaration();
}
}
else {
importDeclaration();
}
}
else {
variableDeclaration(SUB81(in_RDI,0));
}
}
else {
functionDeclaration();
}
}
else {
structDeclaration();
}
}
else {
classDeclaration();
}
}
else {
objectDeclaration();
}
}
else {
namespaceDeclaration();
}
local_88 = 1;
lexer::Token::~Token(local_78);
return in_RDI;
}
|
|
6,859 |
flux::parser::Parser::declaration()
|
kvthweatt[P]FluxLang/src/parser/parser.cpp
|
std::unique_ptr<Decl> Parser::declaration() {
try {
// Save current token for potential backtracking
lexer::Token savedToken = current_;
// Handle keyword-based declarations first
if (match(lexer::TokenType::KEYWORD_NAMESPACE)) return namespaceDeclaration();
if (match(lexer::TokenType::KEYWORD_OBJECT)) return objectDeclaration();
if (match(lexer::TokenType::KEYWORD_CLASS)) return classDeclaration();
if (match(lexer::TokenType::KEYWORD_STRUCT)) return structDeclaration();
if (match(lexer::TokenType::KEYWORD_DEF)) return functionDeclaration();
if (match(lexer::TokenType::KEYWORD_CONST)) return variableDeclaration(true);
if (match(lexer::TokenType::KEYWORD_IMPORT)) return importDeclaration();
if (match(lexer::TokenType::KEYWORD_USING)) return usingDeclaration();
if (match(lexer::TokenType::KEYWORD_OPERATOR)) return operatorDeclaration();
if (match(lexer::TokenType::KEYWORD_TEMPLATE)) return templateDeclaration();
if (match(lexer::TokenType::KEYWORD_ENUM)) return enumDeclaration();
if (match(lexer::TokenType::KEYWORD_TYPE)) return typeDeclaration();
if (match({lexer::TokenType::KEYWORD_DATA,
lexer::TokenType::KEYWORD_SIGNED,
lexer::TokenType::KEYWORD_UNSIGNED})) return dataDeclaration();
if (match(lexer::TokenType::KEYWORD_ASM)) return asmDeclaration();
if (check(lexer::TokenType::IDENTIFIER)) return identifierDeclaration();
// Not a declaration
return nullptr;
} catch (const std::exception& e) {
std::cerr << "Error in declaration parsing: " << e.what() << std::endl;
synchronize();
return nullptr;
}
}
|
O1
|
cpp
|
flux::parser::Parser::declaration():
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movups 0x8(%rsi), %xmm0
movups 0x18(%rsi), %xmm1
movups 0x28(%rsi), %xmm2
movups 0x38(%rsi), %xmm3
leaq 0x50(%rsp), %rdi
movaps %xmm3, -0x10(%rdi)
movaps %xmm2, -0x20(%rdi)
movaps %xmm1, -0x30(%rdi)
movaps %xmm0, -0x40(%rdi)
leaq 0x60(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x48(%rsi), %rsi
movq 0x50(%r14), %rdx
addq %rsi, %rdx
callq 0x9160
movq %r14, %rdi
movl $0x19, %esi
callq 0x14e88
testb %al, %al
je 0x1448a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1517a
jmp 0x14669
movq %r14, %rdi
movl $0x1b, %esi
callq 0x14e88
testb %al, %al
je 0x144ab
movq %rbx, %rdi
movq %r14, %rsi
callq 0x154aa
jmp 0x14669
movq %r14, %rdi
movl $0xb, %esi
callq 0x14e88
testb %al, %al
je 0x144cc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x162a2
jmp 0x14669
movq %r14, %rdi
movl $0x22, %esi
callq 0x14e88
testb %al, %al
je 0x144ed
movq %rbx, %rdi
movq %r14, %rsi
callq 0x173ec
jmp 0x14669
movq %r14, %rdi
movl $0xf, %esi
callq 0x14e88
testb %al, %al
je 0x1450e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17644
jmp 0x14669
movq %r14, %rdi
movl $0xc, %esi
callq 0x14e88
testb %al, %al
je 0x14534
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x189e4
jmp 0x14669
movq %r14, %rdi
movl $0x17, %esi
callq 0x14e88
testb %al, %al
je 0x14555
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18e8a
jmp 0x14669
movq %r14, %rdi
movl $0x2d, %esi
callq 0x14e88
testb %al, %al
je 0x14576
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1908e
jmp 0x14669
movq %r14, %rdi
movl $0x1d, %esi
callq 0x14e88
testb %al, %al
je 0x14597
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1931c
jmp 0x14669
movq %r14, %rdi
movl $0x25, %esi
callq 0x14e88
testb %al, %al
je 0x145b8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a42a
jmp 0x14669
movq %r14, %rdi
movl $0x13, %esi
callq 0x14e88
testb %al, %al
je 0x145d9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b2e6
jmp 0x14669
movq %r14, %rdi
movl $0x2a, %esi
callq 0x14e88
testb %al, %al
je 0x145f7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b6b6
jmp 0x14669
movabsq $0x200000000e, %rax # imm = 0x200000000E
leaq 0x4(%rsp), %rsi
movq %rax, (%rsi)
movl $0x2c, 0x8(%rsi)
movl $0x3, %edx
movq %r14, %rdi
callq 0x14ed0
testb %al, %al
je 0x1462e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b862
jmp 0x14669
movq %r14, %rdi
movl $0x6, %esi
callq 0x14e88
testb %al, %al
je 0x1464c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1bd2a
jmp 0x14669
leaq 0x8(%r14), %rax
cmpl $0x5, (%rax)
jne 0x14662
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c092
jmp 0x14669
movq $0x0, (%rbx)
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x14680
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x6280
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1469b
movq %rdx, %r12
movq %rax, %r15
jmp 0x146b8
movq %rdx, %r12
movq %rax, %r15
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x146b8
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x6280
cmpl $0x1, %r12d
jne 0x14722
movq %r15, %rdi
callq 0x60f0
movq %rax, %r15
movq 0x26920(%rip), %rdi # 0x3aff0
leaq 0x184f3(%rip), %rsi # 0x2cbca
movl $0x1e, %edx
callq 0x62c0
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq 0x268ff(%rip), %rdi # 0x3aff0
movq %rax, %rsi
callq 0x6260
movq %rax, %rdi
callq 0x6110
movq %r14, %rdi
callq 0x14b8c
movq $0x0, (%rbx)
callq 0x63f0
jmp 0x14680
movq %rax, %r15
callq 0x63f0
movq %r15, %rdi
callq 0x6440
movq %rax, %rdi
callq 0x8025
|
_ZN4flux6parser6Parser11declarationEv:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 70h
mov r14, rsi
mov rbx, rdi
movups xmm0, xmmword ptr [rsi+8]
movups xmm1, xmmword ptr [rsi+18h]
movups xmm2, xmmword ptr [rsi+28h]
movups xmm3, xmmword ptr [rsi+38h]
lea rdi, [rsp+98h+var_48]
movaps xmmword ptr [rdi-10h], xmm3
movaps xmmword ptr [rdi-20h], xmm2
movaps xmmword ptr [rdi-30h], xmm1
movaps xmmword ptr [rdi-40h], xmm0
lea r13, [rsp+98h+var_38]
mov [r13-10h], r13
mov rsi, [rsi+48h]
mov rdx, [r14+50h]
add rdx, rsi
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov rdi, r14
mov esi, 19h
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
test al, al
jz short loc_1448A
mov rdi, rbx; this
mov rsi, r14
call _ZN4flux6parser6Parser20namespaceDeclarationEv; flux::parser::Parser::namespaceDeclaration(void)
jmp loc_14669
loc_1448A:
mov rdi, r14
mov esi, 1Bh
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
test al, al
jz short loc_144AB
mov rdi, rbx; this
mov rsi, r14
call _ZN4flux6parser6Parser17objectDeclarationEv; flux::parser::Parser::objectDeclaration(void)
jmp loc_14669
loc_144AB:
mov rdi, r14
mov esi, 0Bh
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
test al, al
jz short loc_144CC
mov rdi, rbx; this
mov rsi, r14
call _ZN4flux6parser6Parser16classDeclarationEv; flux::parser::Parser::classDeclaration(void)
jmp loc_14669
loc_144CC:
mov rdi, r14
mov esi, 22h ; '"'
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
test al, al
jz short loc_144ED
mov rdi, rbx; this
mov rsi, r14
call _ZN4flux6parser6Parser17structDeclarationEv; flux::parser::Parser::structDeclaration(void)
jmp loc_14669
loc_144ED:
mov rdi, r14
mov esi, 0Fh
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
test al, al
jz short loc_1450E
mov rdi, rbx; this
mov rsi, r14
call _ZN4flux6parser6Parser19functionDeclarationEv; flux::parser::Parser::functionDeclaration(void)
jmp loc_14669
loc_1450E:
mov rdi, r14
mov esi, 0Ch
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
test al, al
jz short loc_14534
mov rdi, rbx; this
mov rsi, r14; bool
mov edx, 1
call _ZN4flux6parser6Parser19variableDeclarationEb; flux::parser::Parser::variableDeclaration(bool)
jmp loc_14669
loc_14534:
mov rdi, r14
mov esi, 17h
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
test al, al
jz short loc_14555
mov rdi, rbx; this
mov rsi, r14
call _ZN4flux6parser6Parser17importDeclarationEv; flux::parser::Parser::importDeclaration(void)
jmp loc_14669
loc_14555:
mov rdi, r14
mov esi, 2Dh ; '-'
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
test al, al
jz short loc_14576
mov rdi, rbx; this
mov rsi, r14
call _ZN4flux6parser6Parser16usingDeclarationEv; flux::parser::Parser::usingDeclaration(void)
jmp loc_14669
loc_14576:
mov rdi, r14
mov esi, 1Dh
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
test al, al
jz short loc_14597
mov rdi, rbx; this
mov rsi, r14
call _ZN4flux6parser6Parser19operatorDeclarationEv; flux::parser::Parser::operatorDeclaration(void)
jmp loc_14669
loc_14597:
mov rdi, r14
mov esi, 25h ; '%'
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
test al, al
jz short loc_145B8
mov rdi, rbx; this
mov rsi, r14
call _ZN4flux6parser6Parser19templateDeclarationEv; flux::parser::Parser::templateDeclaration(void)
jmp loc_14669
loc_145B8:
mov rdi, r14
mov esi, 13h
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
test al, al
jz short loc_145D9
mov rdi, rbx; this
mov rsi, r14
call _ZN4flux6parser6Parser15enumDeclarationEv; flux::parser::Parser::enumDeclaration(void)
jmp loc_14669
loc_145D9:
mov rdi, r14
mov esi, 2Ah ; '*'
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
test al, al
jz short loc_145F7
mov rdi, rbx; this
mov rsi, r14
call _ZN4flux6parser6Parser15typeDeclarationEv; flux::parser::Parser::typeDeclaration(void)
jmp short loc_14669
loc_145F7:
mov rax, 200000000Eh
lea rsi, [rsp+98h+var_94]
mov [rsi], rax
mov dword ptr [rsi+8], 2Ch ; ','
mov edx, 3
mov rdi, r14
call _ZN4flux6parser6Parser5matchESt16initializer_listINS_5lexer9TokenTypeEE; flux::parser::Parser::match(std::initializer_list<flux::lexer::TokenType>)
test al, al
jz short loc_1462E
mov rdi, rbx; this
mov rsi, r14
call _ZN4flux6parser6Parser15dataDeclarationEv; flux::parser::Parser::dataDeclaration(void)
jmp short loc_14669
loc_1462E:
mov rdi, r14
mov esi, 6
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
test al, al
jz short loc_1464C
mov rdi, rbx; this
mov rsi, r14
call _ZN4flux6parser6Parser14asmDeclarationEv; flux::parser::Parser::asmDeclaration(void)
jmp short loc_14669
loc_1464C:
lea rax, [r14+8]
cmp dword ptr [rax], 5
jnz short loc_14662
mov rdi, rbx; this
mov rsi, r14
call _ZN4flux6parser6Parser21identifierDeclarationEv; flux::parser::Parser::identifierDeclaration(void)
jmp short loc_14669
loc_14662:
mov qword ptr [rbx], 0
loc_14669:
mov rdi, [rsp+98h+var_48]; void *
cmp rdi, r13
jz short loc_14680
mov rsi, [rsp+98h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_14680:
mov rax, rbx
add rsp, 70h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
jmp short loc_1469B
mov r12, rdx
mov r15, rax
jmp short loc_146B8
loc_1469B:
mov r12, rdx
mov r15, rax
mov rdi, [rsp+98h+var_48]; void *
cmp rdi, r13
jz short loc_146B8
mov rsi, [rsp+98h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_146B8:
cmp r12d, 1
jnz short loc_14722
mov rdi, r15; void *
call ___cxa_begin_catch
mov r15, rax
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, aErrorInDeclara; "Error in declaration parsing: "
mov edx, 1Eh
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rax, [r15]
mov rdi, r15
call qword ptr [rax+10h]
mov rdi, cs:_ZSt4cerr_ptr
mov rsi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
call __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_; std::endl<char,std::char_traits<char>>(std::ostream &)
mov rdi, r14; this
call _ZN4flux6parser6Parser11synchronizeEv; flux::parser::Parser::synchronize(void)
mov qword ptr [rbx], 0
call ___cxa_end_catch
jmp loc_14680
mov r15, rax
call ___cxa_end_catch
loc_14722:
mov rdi, r15
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
|
flux::parser::Parser * flux::parser::Parser::declaration(flux::parser::Parser *this, long long a2)
{
__int128 v2; // xmm0
__int128 v3; // xmm1
__int128 v4; // xmm2
long long v6; // [rsp+4h] [rbp-94h] BYREF
int v7; // [rsp+Ch] [rbp-8Ch]
__int128 v8; // [rsp+10h] [rbp-88h]
__int128 v9; // [rsp+20h] [rbp-78h]
__int128 v10; // [rsp+30h] [rbp-68h]
__int128 v11; // [rsp+40h] [rbp-58h]
void *v12; // [rsp+50h] [rbp-48h] BYREF
_QWORD v13[7]; // [rsp+60h] [rbp-38h] BYREF
v2 = *(_OWORD *)(a2 + 8);
v3 = *(_OWORD *)(a2 + 24);
v4 = *(_OWORD *)(a2 + 40);
v11 = *(_OWORD *)(a2 + 56);
v10 = v4;
v9 = v3;
v8 = v2;
v12 = v13;
std::string::_M_construct<char *>(&v12, *(_BYTE **)(a2 + 72), *(_QWORD *)(a2 + 72) + *(_QWORD *)(a2 + 80));
if ( (unsigned __int8)flux::parser::Parser::match(a2, 25LL) )
{
flux::parser::Parser::namespaceDeclaration(this);
}
else if ( (unsigned __int8)flux::parser::Parser::match(a2, 27LL) )
{
flux::parser::Parser::objectDeclaration(this);
}
else if ( (unsigned __int8)flux::parser::Parser::match(a2, 11LL) )
{
flux::parser::Parser::classDeclaration(this);
}
else if ( (unsigned __int8)flux::parser::Parser::match(a2, 34LL) )
{
flux::parser::Parser::structDeclaration(this);
}
else if ( (unsigned __int8)flux::parser::Parser::match(a2, 15LL) )
{
flux::parser::Parser::functionDeclaration(this);
}
else if ( (unsigned __int8)flux::parser::Parser::match(a2, 12LL) )
{
flux::parser::Parser::variableDeclaration(this, a2);
}
else if ( (unsigned __int8)flux::parser::Parser::match(a2, 23LL) )
{
flux::parser::Parser::importDeclaration(this);
}
else if ( (unsigned __int8)flux::parser::Parser::match(a2, 45LL) )
{
flux::parser::Parser::usingDeclaration(this);
}
else if ( (unsigned __int8)flux::parser::Parser::match(a2, 29LL) )
{
flux::parser::Parser::operatorDeclaration(this);
}
else if ( (unsigned __int8)flux::parser::Parser::match(a2, 37LL) )
{
flux::parser::Parser::templateDeclaration(this);
}
else if ( (unsigned __int8)flux::parser::Parser::match(a2, 19LL) )
{
flux::parser::Parser::enumDeclaration(this);
}
else if ( (unsigned __int8)flux::parser::Parser::match(a2, 42LL) )
{
flux::parser::Parser::typeDeclaration(this);
}
else
{
v6 = 0x200000000ELL;
v7 = 44;
if ( (unsigned __int8)flux::parser::Parser::match(a2, &v6, 3LL) )
{
flux::parser::Parser::dataDeclaration(this);
}
else if ( (unsigned __int8)flux::parser::Parser::match(a2, 6LL) )
{
flux::parser::Parser::asmDeclaration(this);
}
else if ( *(_DWORD *)(a2 + 8) == 5 )
{
flux::parser::Parser::identifierDeclaration(this);
}
else
{
*(_QWORD *)this = 0LL;
}
}
if ( v12 != v13 )
operator delete(v12, v13[0] + 1LL);
return this;
}
|
declaration:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x70
MOV R14,RSI
MOV RBX,RDI
MOVUPS XMM0,xmmword ptr [RSI + 0x8]
MOVUPS XMM1,xmmword ptr [RSI + 0x18]
MOVUPS XMM2,xmmword ptr [RSI + 0x28]
MOVUPS XMM3,xmmword ptr [RSI + 0x38]
LEA RDI,[RSP + 0x50]
MOVAPS xmmword ptr [RDI + -0x10],XMM3
MOVAPS xmmword ptr [RDI + -0x20],XMM2
MOVAPS xmmword ptr [RDI + -0x30],XMM1
MOVAPS xmmword ptr [RDI + -0x40],XMM0
LEA R13,[RSP + 0x60]
MOV qword ptr [R13 + -0x10],R13
MOV RSI,qword ptr [RSI + 0x48]
MOV RDX,qword ptr [R14 + 0x50]
ADD RDX,RSI
LAB_00114464:
CALL 0x00109160
LAB_00114469:
MOV RDI,R14
MOV ESI,0x19
CALL 0x00114e88
TEST AL,AL
JZ 0x0011448a
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011517a
JMP 0x00114669
LAB_0011448a:
MOV RDI,R14
MOV ESI,0x1b
CALL 0x00114e88
TEST AL,AL
JZ 0x001144ab
MOV RDI,RBX
MOV RSI,R14
CALL 0x001154aa
JMP 0x00114669
LAB_001144ab:
MOV RDI,R14
MOV ESI,0xb
CALL 0x00114e88
TEST AL,AL
JZ 0x001144cc
MOV RDI,RBX
MOV RSI,R14
CALL 0x001162a2
JMP 0x00114669
LAB_001144cc:
MOV RDI,R14
MOV ESI,0x22
CALL 0x00114e88
TEST AL,AL
JZ 0x001144ed
MOV RDI,RBX
MOV RSI,R14
CALL 0x001173ec
JMP 0x00114669
LAB_001144ed:
MOV RDI,R14
MOV ESI,0xf
CALL 0x00114e88
TEST AL,AL
JZ 0x0011450e
MOV RDI,RBX
MOV RSI,R14
CALL 0x00117644
JMP 0x00114669
LAB_0011450e:
MOV RDI,R14
MOV ESI,0xc
CALL 0x00114e88
TEST AL,AL
JZ 0x00114534
MOV RDI,RBX
MOV RSI,R14
MOV EDX,0x1
CALL 0x001189e4
JMP 0x00114669
LAB_00114534:
MOV RDI,R14
MOV ESI,0x17
CALL 0x00114e88
TEST AL,AL
JZ 0x00114555
MOV RDI,RBX
MOV RSI,R14
CALL 0x00118e8a
JMP 0x00114669
LAB_00114555:
MOV RDI,R14
MOV ESI,0x2d
CALL 0x00114e88
TEST AL,AL
JZ 0x00114576
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011908e
JMP 0x00114669
LAB_00114576:
MOV RDI,R14
MOV ESI,0x1d
CALL 0x00114e88
TEST AL,AL
JZ 0x00114597
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011931c
JMP 0x00114669
LAB_00114597:
MOV RDI,R14
MOV ESI,0x25
CALL 0x00114e88
TEST AL,AL
JZ 0x001145b8
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011a42a
JMP 0x00114669
LAB_001145b8:
MOV RDI,R14
MOV ESI,0x13
CALL 0x00114e88
TEST AL,AL
JZ 0x001145d9
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011b2e6
JMP 0x00114669
LAB_001145d9:
MOV RDI,R14
MOV ESI,0x2a
CALL 0x00114e88
TEST AL,AL
JZ 0x001145f7
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011b6b6
JMP 0x00114669
LAB_001145f7:
MOV RAX,0x200000000e
LEA RSI,[RSP + 0x4]
MOV qword ptr [RSI],RAX
MOV dword ptr [RSI + 0x8],0x2c
LAB_00114610:
MOV EDX,0x3
MOV RDI,R14
CALL 0x00114ed0
TEST AL,AL
JZ 0x0011462e
LAB_00114621:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011b862
JMP 0x00114669
LAB_0011462e:
MOV RDI,R14
MOV ESI,0x6
CALL 0x00114e88
TEST AL,AL
JZ 0x0011464c
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011bd2a
JMP 0x00114669
LAB_0011464c:
LEA RAX,[R14 + 0x8]
CMP dword ptr [RAX],0x5
JNZ 0x00114662
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011c092
LAB_00114660:
JMP 0x00114669
LAB_00114662:
MOV qword ptr [RBX],0x0
LAB_00114669:
MOV RDI,qword ptr [RSP + 0x50]
CMP RDI,R13
JZ 0x00114680
MOV RSI,qword ptr [RSP + 0x60]
INC RSI
CALL 0x00106280
LAB_00114680:
MOV RAX,RBX
ADD RSP,0x70
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* flux::parser::Parser::declaration() */
void flux::parser::Parser::declaration(void)
{
char cVar1;
long in_RSI;
int8 *in_RDI;
long *local_48 [2];
long local_38 [2];
local_48[0] = local_38;
/* try { // try from 00114464 to 00114468 has its CatchHandler @ 00114693 */
std::__cxx11::string::_M_construct<char*>
(local_48,*(long *)(in_RSI + 0x48),*(long *)(in_RSI + 0x50) + *(long *)(in_RSI + 0x48));
/* try { // try from 00114469 to 001145f4 has its CatchHandler @ 0011469b */
cVar1 = match();
if (cVar1 == '\0') {
cVar1 = match();
if (cVar1 == '\0') {
cVar1 = match();
if (cVar1 == '\0') {
cVar1 = match();
if (cVar1 == '\0') {
cVar1 = match();
if (cVar1 == '\0') {
cVar1 = match();
if (cVar1 == '\0') {
cVar1 = match();
if (cVar1 == '\0') {
cVar1 = match();
if (cVar1 == '\0') {
cVar1 = match();
if (cVar1 == '\0') {
cVar1 = match();
if (cVar1 == '\0') {
cVar1 = match();
if (cVar1 == '\0') {
cVar1 = match();
if (cVar1 == '\0') {
/* try { // try from 00114610 to 0011461c has its CatchHandler @ 00114691 */
cVar1 = match();
if (cVar1 == '\0') {
cVar1 = match();
if (cVar1 == '\0') {
if (*(int *)(in_RSI + 8) == 5) {
identifierDeclaration();
}
else {
*in_RDI = 0;
}
}
else {
asmDeclaration();
}
}
else {
/* try { // try from 00114621 to 0011465f has its CatchHandler @ 0011469b */
dataDeclaration();
}
}
else {
typeDeclaration();
}
}
else {
enumDeclaration();
}
}
else {
templateDeclaration();
}
}
else {
operatorDeclaration();
}
}
else {
usingDeclaration();
}
}
else {
importDeclaration();
}
}
else {
variableDeclaration(SUB81(in_RDI,0));
}
}
else {
functionDeclaration();
}
}
else {
structDeclaration();
}
}
else {
classDeclaration();
}
}
else {
objectDeclaration();
}
}
else {
namespaceDeclaration();
}
if (local_48[0] != local_38) {
operator_delete(local_48[0],local_38[0] + 1);
}
return;
}
|
|
6,860 |
ft_parse_internal
|
eloqsql/storage/myisam/ft_parser.c
|
static int ft_parse_internal(MYSQL_FTPARSER_PARAM *param,
const char *doc_arg, int doc_len)
{
uchar *doc= (uchar*) doc_arg;
uchar *end= doc + doc_len;
MY_FT_PARSER_PARAM *ft_param=param->mysql_ftparam;
TREE *wtree= ft_param->wtree;
FT_WORD w;
DBUG_ENTER("ft_parse_internal");
while (ft_simple_get_word(wtree->custom_arg, &doc, end, &w, TRUE))
if (param->mysql_add_word(param, (char*) w.pos, (int)w.len, 0))
DBUG_RETURN(1);
DBUG_RETURN(0);
}
|
O0
|
c
|
ft_parse_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x230(%rax), %rdi
movq -0x30(%rbp), %rdx
leaq -0x28(%rbp), %rsi
leaq -0x58(%rbp), %rcx
movl $0x1, %r8d
callq 0xa2280
cmpb $0x0, %al
je 0xa2683
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x48(%rbp), %rcx
movl %ecx, %edx
xorl %ecx, %ecx
callq *%rax
cmpl $0x0, %eax
je 0xa2681
jmp 0xa2678
movl $0x1, -0x4(%rbp)
jmp 0xa268c
jmp 0xa2631
jmp 0xa2685
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ft_parse_internal:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov rax, [rbp+var_18]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
movsxd rcx, [rbp+var_1C]
add rax, rcx
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov rax, [rax+18h]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov rax, [rax]
mov [rbp+var_40], rax
loc_A2631:
mov rax, [rbp+var_40]
mov rdi, [rax+230h]
mov rdx, [rbp+var_30]
lea rsi, [rbp+var_28]
lea rcx, [rbp+var_58]
mov r8d, 1
call ft_simple_get_word
cmp al, 0
jz short loc_A2683
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_58]
mov rcx, [rbp+var_48]
mov edx, ecx
xor ecx, ecx
call rax
cmp eax, 0
jz short loc_A2681
jmp short $+2
loc_A2678:
mov [rbp+var_4], 1
jmp short loc_A268C
loc_A2681:
jmp short loc_A2631
loc_A2683:
jmp short $+2
loc_A2685:
mov [rbp+var_4], 0
loc_A268C:
mov eax, [rbp+var_4]
add rsp, 60h
pop rbp
retn
|
long long ft_parse_internal(long long a1, _BYTE *a2, int a3)
{
long long v4; // [rsp+8h] [rbp-58h] BYREF
long long v5; // [rsp+18h] [rbp-48h]
long long v6; // [rsp+20h] [rbp-40h]
long long *v7; // [rsp+28h] [rbp-38h]
_BYTE *v8; // [rsp+30h] [rbp-30h]
_BYTE *v9; // [rsp+38h] [rbp-28h] BYREF
int v10; // [rsp+44h] [rbp-1Ch]
_BYTE *v11; // [rsp+48h] [rbp-18h]
long long v12; // [rsp+50h] [rbp-10h]
v12 = a1;
v11 = a2;
v10 = a3;
v9 = a2;
v8 = &a2[a3];
v7 = *(long long **)(a1 + 24);
v6 = *v7;
while ( ft_simple_get_word(*(_QWORD *)(v6 + 560), &v9, (unsigned long long)v8, &v4, 1) )
{
if ( (*(unsigned int ( **)(long long, long long, _QWORD, _QWORD))(v12 + 8))(v12, v4, (unsigned int)v5, 0LL) )
return 1;
}
return 0;
}
|
ft_parse_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,dword ptr [RBP + -0x1c]
ADD RAX,RCX
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 + -0x38]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
LAB_001a2631:
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RAX + 0x230]
MOV RDX,qword ptr [RBP + -0x30]
LEA RSI,[RBP + -0x28]
LEA RCX,[RBP + -0x58]
MOV R8D,0x1
CALL 0x001a2280
CMP AL,0x0
JZ 0x001a2683
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x48]
MOV EDX,ECX
XOR ECX,ECX
CALL RAX
CMP EAX,0x0
JZ 0x001a2681
JMP 0x001a2678
LAB_001a2678:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001a268c
LAB_001a2681:
JMP 0x001a2631
LAB_001a2683:
JMP 0x001a2685
LAB_001a2685:
MOV dword ptr [RBP + -0x4],0x0
LAB_001a268c:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x60
POP RBP
RET
|
int4 ft_parse_internal(long param_1,long param_2,int param_3)
{
char cVar1;
int iVar2;
int8 local_60 [2];
ulong local_50;
long local_48;
long *local_40;
long local_38;
long local_30;
int local_24;
long local_20;
long local_18;
local_38 = param_2 + param_3;
local_40 = *(long **)(param_1 + 0x18);
local_48 = *local_40;
local_30 = param_2;
local_24 = param_3;
local_20 = param_2;
local_18 = param_1;
do {
cVar1 = ft_simple_get_word(*(int8 *)(local_48 + 0x230),&local_30,local_38,local_60,1);
if (cVar1 == '\0') {
return 0;
}
iVar2 = (**(code **)(local_18 + 8))(local_18,local_60[0],local_50 & 0xffffffff,0);
} while (iVar2 == 0);
return 1;
}
|
|
6,861 |
my_convert_using_func
|
eloqsql/strings/ctype.c
|
uint32
my_convert_using_func(char *to, size_t to_length,
CHARSET_INFO *to_cs, my_charset_conv_wc_mb wc_mb,
const char *from, size_t from_length,
CHARSET_INFO *from_cs, my_charset_conv_mb_wc mb_wc,
uint *errors)
{
int cnvres;
my_wc_t wc;
const uchar *from_end= (const uchar*) from + from_length;
char *to_start= to;
uchar *to_end= (uchar*) to + to_length;
uint error_count= 0;
while (1)
{
if ((cnvres= (*mb_wc)(from_cs, &wc, (uchar*) from, from_end)) > 0)
from+= cnvres;
else if (cnvres == MY_CS_ILSEQ)
{
error_count++;
from++;
wc= '?';
}
else if (cnvres > MY_CS_TOOSMALL)
{
/*
A correct multibyte sequence detected
But it doesn't have Unicode mapping.
*/
error_count++;
from+= (-cnvres);
wc= '?';
}
else
{
if ((uchar *) from >= from_end)
break; /* End of line */
/* Incomplete byte sequence */
error_count++;
from++;
wc= '?';
}
outp:
if ((cnvres= (*wc_mb)(to_cs, wc, (uchar*) to, to_end)) > 0)
to+= cnvres;
else if (cnvres == MY_CS_ILUNI && wc != '?')
{
error_count++;
wc= '?';
goto outp;
}
else
break;
}
*errors= error_count;
return (uint32) (to - to_start);
}
|
O0
|
c
|
my_convert_using_func:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
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 -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x0, -0x5c(%rbp)
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x48(%rbp), %rcx
leaq -0x40(%rbp), %rsi
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jle 0x7db24
movl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x7dba2
cmpl $0x0, -0x34(%rbp)
jne 0x7db49
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq $0x3f, -0x40(%rbp)
jmp 0x7dba0
cmpl $-0x65, -0x34(%rbp)
jle 0x7db75
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
xorl %ecx, %ecx
subl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq $0x3f, -0x40(%rbp)
jmp 0x7db9e
movq -0x28(%rbp), %rax
cmpq -0x48(%rbp), %rax
jb 0x7db81
jmp 0x7dbfc
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq $0x3f, -0x40(%rbp)
jmp 0x7dba0
jmp 0x7dba2
jmp 0x7dba4
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x58(%rbp), %rcx
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jle 0x7dbd5
movl -0x34(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x7dbf7
cmpl $0x0, -0x34(%rbp)
jne 0x7dbf5
cmpq $0x3f, -0x40(%rbp)
je 0x7dbf5
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
movq $0x3f, -0x40(%rbp)
jmp 0x7dba4
jmp 0x7dbfc
jmp 0x7daf3
movl -0x5c(%rbp), %ecx
movq 0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq -0x50(%rbp), %rcx
subq %rcx, %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_convert_using_func:
push rbp
mov rbp, rsp
sub rsp, 60h
mov rax, [rbp+arg_10]
mov rax, [rbp+arg_8]
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_28]
add rax, [rbp+var_30]
mov [rbp+var_48], rax
mov rax, [rbp+var_8]
mov [rbp+var_50], rax
mov rax, [rbp+var_8]
add rax, [rbp+var_10]
mov [rbp+var_58], rax
mov [rbp+var_5C], 0
loc_7DAF3:
mov rax, [rbp+arg_8]
mov rdi, [rbp+arg_0]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_48]
lea rsi, [rbp+var_40]
call rax
mov [rbp+var_34], eax
cmp eax, 0
jle short loc_7DB24
mov ecx, [rbp+var_34]
mov rax, [rbp+var_28]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_28], rax
jmp short loc_7DBA2
loc_7DB24:
cmp [rbp+var_34], 0
jnz short loc_7DB49
mov eax, [rbp+var_5C]
add eax, 1
mov [rbp+var_5C], eax
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
mov [rbp+var_40], 3Fh ; '?'
jmp short loc_7DBA0
loc_7DB49:
cmp [rbp+var_34], 0FFFFFF9Bh
jle short loc_7DB75
mov eax, [rbp+var_5C]
add eax, 1
mov [rbp+var_5C], eax
xor ecx, ecx
sub ecx, [rbp+var_34]
mov rax, [rbp+var_28]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_28], rax
mov [rbp+var_40], 3Fh ; '?'
jmp short loc_7DB9E
loc_7DB75:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_48]
jb short loc_7DB81
jmp short loc_7DBFC
loc_7DB81:
mov eax, [rbp+var_5C]
add eax, 1
mov [rbp+var_5C], eax
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
mov [rbp+var_40], 3Fh ; '?'
loc_7DB9E:
jmp short $+2
loc_7DBA0:
jmp short $+2
loc_7DBA2:
jmp short $+2
loc_7DBA4:
mov rax, [rbp+var_20]
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_8]
mov rcx, [rbp+var_58]
call rax
mov [rbp+var_34], eax
cmp eax, 0
jle short loc_7DBD5
mov ecx, [rbp+var_34]
mov rax, [rbp+var_8]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_8], rax
jmp short loc_7DBF7
loc_7DBD5:
cmp [rbp+var_34], 0
jnz short loc_7DBF5
cmp [rbp+var_40], 3Fh ; '?'
jz short loc_7DBF5
mov eax, [rbp+var_5C]
add eax, 1
mov [rbp+var_5C], eax
mov [rbp+var_40], 3Fh ; '?'
jmp short loc_7DBA4
loc_7DBF5:
jmp short loc_7DBFC
loc_7DBF7:
jmp loc_7DAF3
loc_7DBFC:
mov ecx, [rbp+var_5C]
mov rax, [rbp+arg_10]
mov [rax], ecx
mov rax, [rbp+var_8]
mov rcx, [rbp+var_50]
sub rax, rcx
add rsp, 60h
pop rbp
retn
|
long long my_convert_using_func(
long long a1,
long long a2,
long long a3,
long long ( *a4)(long long, long long, long long, long long),
unsigned long long a5,
long long a6,
long long a7,
long long ( *a8)(long long, long long *, unsigned long long, unsigned long long),
_DWORD *a9)
{
int v10; // [rsp+4h] [rbp-5Ch]
unsigned long long v11; // [rsp+18h] [rbp-48h]
long long v12; // [rsp+20h] [rbp-40h] BYREF
int v13; // [rsp+2Ch] [rbp-34h]
long long v14; // [rsp+30h] [rbp-30h]
unsigned long long v15; // [rsp+38h] [rbp-28h]
long long ( *v16)(long long, long long, long long, long long); // [rsp+40h] [rbp-20h]
long long v17; // [rsp+48h] [rbp-18h]
long long v18; // [rsp+50h] [rbp-10h]
long long v19; // [rsp+58h] [rbp-8h]
v19 = a1;
v18 = a2;
v17 = a3;
v16 = a4;
v15 = a5;
v14 = a6;
v11 = a6 + a5;
v10 = 0;
while ( 1 )
{
v13 = a8(a7, &v12, v15, v11);
if ( v13 > 0 )
{
v15 += v13;
goto LABEL_10;
}
if ( !v13 )
{
++v10;
++v15;
v12 = 63LL;
goto LABEL_10;
}
if ( v13 > -101 )
{
++v10;
v15 += -v13;
v12 = 63LL;
goto LABEL_10;
}
if ( v15 >= v11 )
break;
++v10;
++v15;
v12 = 63LL;
LABEL_10:
while ( 1 )
{
v13 = v16(v17, v12, v19, a2 + a1);
if ( v13 > 0 )
break;
if ( v13 || v12 == 63 )
goto LABEL_15;
++v10;
v12 = 63LL;
}
v19 += v13;
}
LABEL_15:
*a9 = v10;
return v19 - a1;
}
|
my_convert_using_func:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV RAX,qword ptr [RBP + 0x20]
MOV RAX,qword ptr [RBP + 0x18]
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 + -0x28]
ADD RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x58],RAX
MOV dword ptr [RBP + -0x5c],0x0
LAB_0017daf3:
MOV RAX,qword ptr [RBP + 0x18]
MOV RDI,qword ptr [RBP + 0x10]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x48]
LEA RSI,[RBP + -0x40]
CALL RAX
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
JLE 0x0017db24
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0017dba2
LAB_0017db24:
CMP dword ptr [RBP + -0x34],0x0
JNZ 0x0017db49
MOV EAX,dword ptr [RBP + -0x5c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x5c],EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOV qword ptr [RBP + -0x40],0x3f
JMP 0x0017dba0
LAB_0017db49:
CMP dword ptr [RBP + -0x34],-0x65
JLE 0x0017db75
MOV EAX,dword ptr [RBP + -0x5c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x5c],EAX
XOR ECX,ECX
SUB ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV qword ptr [RBP + -0x40],0x3f
JMP 0x0017db9e
LAB_0017db75:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x48]
JC 0x0017db81
JMP 0x0017dbfc
LAB_0017db81:
MOV EAX,dword ptr [RBP + -0x5c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x5c],EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOV qword ptr [RBP + -0x40],0x3f
LAB_0017db9e:
JMP 0x0017dba0
LAB_0017dba0:
JMP 0x0017dba2
LAB_0017dba2:
JMP 0x0017dba4
LAB_0017dba4:
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x58]
CALL RAX
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
JLE 0x0017dbd5
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017dbf7
LAB_0017dbd5:
CMP dword ptr [RBP + -0x34],0x0
JNZ 0x0017dbf5
CMP qword ptr [RBP + -0x40],0x3f
JZ 0x0017dbf5
MOV EAX,dword ptr [RBP + -0x5c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x5c],EAX
MOV qword ptr [RBP + -0x40],0x3f
JMP 0x0017dba4
LAB_0017dbf5:
JMP 0x0017dbfc
LAB_0017dbf7:
JMP 0x0017daf3
LAB_0017dbfc:
MOV ECX,dword ptr [RBP + -0x5c]
MOV RAX,qword ptr [RBP + 0x20]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x50]
SUB RAX,RCX
ADD RSP,0x60
POP RBP
RET
|
long my_convert_using_func
(long param_1,long param_2,int8 param_3,code *param_4,ulong param_5,
long param_6,int8 param_7,code *param_8,int *param_9)
{
int local_64;
long local_48;
int local_3c;
long local_38;
ulong local_30;
code *local_28;
int8 local_20;
long local_18;
long local_10;
local_64 = 0;
local_38 = param_6;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
do {
local_3c = (*param_8)(param_7,&local_48,local_30);
if (local_3c < 1) {
if (local_3c == 0) {
local_30 = local_30 + 1;
}
else if (local_3c < -100) {
if (param_5 + param_6 <= local_30) {
LAB_0017dbfc:
*param_9 = local_64;
return local_10 - param_1;
}
local_30 = local_30 + 1;
}
else {
local_30 = local_30 + (long)-local_3c;
}
local_64 = local_64 + 1;
local_48 = 0x3f;
}
else {
local_30 = local_30 + (long)local_3c;
}
while (local_3c = (*local_28)(local_20,local_48,local_10,param_1 + param_2), local_3c < 1) {
if ((local_3c != 0) || (local_48 == 0x3f)) goto LAB_0017dbfc;
local_64 = local_64 + 1;
local_48 = 0x3f;
local_3c = 0;
}
local_10 = local_10 + local_3c;
} while( true );
}
|
|
6,862 |
num_keys_cmp
|
bluesky950520[P]quickjs/quickjs.c
|
static int num_keys_cmp(const void *p1, const void *p2, void *opaque)
{
JSContext *ctx = opaque;
JSAtom atom1 = ((const JSPropertyEnum *)p1)->atom;
JSAtom atom2 = ((const JSPropertyEnum *)p2)->atom;
uint32_t v1, v2;
BOOL atom1_is_integer, atom2_is_integer;
atom1_is_integer = JS_AtomIsArrayIndex(ctx, &v1, atom1);
atom2_is_integer = JS_AtomIsArrayIndex(ctx, &v2, atom2);
assert(atom1_is_integer && atom2_is_integer);
if (v1 < v2)
return -1;
else if (v1 == v2)
return 0;
else
return 1;
}
|
O1
|
c
|
num_keys_cmp:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl 0x4(%rdi), %edx
movl 0x4(%rsi), %ebp
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3d7ed
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x3d7ed
movl (%r14), %eax
xorl %ecx, %ecx
cmpl (%r15), %eax
setne %cl
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovael %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
num_keys_cmp:
push rbp
push r15
push r14
push rbx
push rax
mov rbx, rdx
mov edx, [rdi+4]
mov ebp, [rsi+4]
lea r14, [rsp+28h+var_24]
mov rdi, rbx
mov rsi, r14
call JS_AtomIsArrayIndex
mov r15, rsp
mov rdi, rbx
mov rsi, r15
mov edx, ebp
call JS_AtomIsArrayIndex
mov eax, [r14]
xor ecx, ecx
cmp eax, [r15]
setnz cl
mov eax, 0FFFFFFFFh
cmovnb eax, ecx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long num_keys_cmp(long long a1, long long a2, long long a3)
{
long long v3; // rax
int v5; // ebp
long long result; // rax
_QWORD v7[5]; // [rsp-4h] [rbp-28h] BYREF
v7[0] = v3;
v5 = *(_DWORD *)(a2 + 4);
JS_AtomIsArrayIndex(a3, (_DWORD *)v7 + 1, *(_DWORD *)(a1 + 4));
JS_AtomIsArrayIndex(a3, v7, v5);
result = 0xFFFFFFFFLL;
if ( HIDWORD(v7[0]) >= LODWORD(v7[0]) )
return HIDWORD(v7[0]) != LODWORD(v7[0]);
return result;
}
|
num_keys_cmp:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV EDX,dword ptr [RDI + 0x4]
MOV EBP,dword ptr [RSI + 0x4]
LEA R14,[RSP + 0x4]
MOV RDI,RBX
MOV RSI,R14
CALL 0x0013d7ed
MOV R15,RSP
MOV RDI,RBX
MOV RSI,R15
MOV EDX,EBP
CALL 0x0013d7ed
MOV EAX,dword ptr [R14]
XOR ECX,ECX
CMP EAX,dword ptr [R15]
SETNZ CL
MOV EAX,0xffffffff
CMOVNC EAX,ECX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
ulong num_keys_cmp(long param_1,long param_2,int8 param_3)
{
int4 uVar1;
int8 in_RAX;
ulong uVar2;
int8 local_28;
uVar1 = *(int4 *)(param_2 + 4);
local_28 = in_RAX;
JS_AtomIsArrayIndex(param_3,(long)&local_28 + 4,*(int4 *)(param_1 + 4));
JS_AtomIsArrayIndex(param_3,&local_28,uVar1);
uVar2 = 0xffffffff;
if ((uint)local_28 <= local_28._4_4_) {
uVar2 = (ulong)(local_28._4_4_ != (uint)local_28);
}
return uVar2;
}
|
|
6,863 |
num_keys_cmp
|
bluesky950520[P]quickjs/quickjs.c
|
static int num_keys_cmp(const void *p1, const void *p2, void *opaque)
{
JSContext *ctx = opaque;
JSAtom atom1 = ((const JSPropertyEnum *)p1)->atom;
JSAtom atom2 = ((const JSPropertyEnum *)p2)->atom;
uint32_t v1, v2;
BOOL atom1_is_integer, atom2_is_integer;
atom1_is_integer = JS_AtomIsArrayIndex(ctx, &v1, atom1);
atom2_is_integer = JS_AtomIsArrayIndex(ctx, &v2, atom2);
assert(atom1_is_integer && atom2_is_integer);
if (v1 < v2)
return -1;
else if (v1 == v2)
return 0;
else
return 1;
}
|
O2
|
c
|
num_keys_cmp:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl 0x4(%rdi), %edx
movl 0x4(%rsi), %ebp
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x36088
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x36088
movl (%r14), %eax
xorl %ecx, %ecx
cmpl (%r15), %eax
setne %cl
pushq $-0x1
popq %rax
cmovael %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
num_keys_cmp:
push rbp
push r15
push r14
push rbx
push rax
mov rbx, rdx
mov edx, [rdi+4]
mov ebp, [rsi+4]
lea r14, [rsp+28h+var_24]
mov rdi, rbx
mov rsi, r14
call JS_AtomIsArrayIndex
mov r15, rsp
mov rdi, rbx
mov rsi, r15
mov edx, ebp
call JS_AtomIsArrayIndex
mov eax, [r14]
xor ecx, ecx
cmp eax, [r15]
setnz cl
push 0FFFFFFFFFFFFFFFFh
pop rax
cmovnb eax, ecx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long num_keys_cmp(long long a1, long long a2, long long a3)
{
long long v3; // rax
int v5; // ebp
long long result; // rax
_QWORD v7[5]; // [rsp-4h] [rbp-28h] BYREF
v7[0] = v3;
v5 = *(_DWORD *)(a2 + 4);
JS_AtomIsArrayIndex(a3, (int *)v7 + 1, *(_DWORD *)(a1 + 4));
JS_AtomIsArrayIndex(a3, (int *)v7, v5);
result = -1LL;
if ( HIDWORD(v7[0]) >= LODWORD(v7[0]) )
return HIDWORD(v7[0]) != LODWORD(v7[0]);
return result;
}
|
num_keys_cmp:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV EDX,dword ptr [RDI + 0x4]
MOV EBP,dword ptr [RSI + 0x4]
LEA R14,[RSP + 0x4]
MOV RDI,RBX
MOV RSI,R14
CALL 0x00136088
MOV R15,RSP
MOV RDI,RBX
MOV RSI,R15
MOV EDX,EBP
CALL 0x00136088
MOV EAX,dword ptr [R14]
XOR ECX,ECX
CMP EAX,dword ptr [R15]
SETNZ CL
PUSH -0x1
POP RAX
CMOVNC EAX,ECX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
ulong num_keys_cmp(long param_1,long param_2,int8 param_3)
{
int4 uVar1;
int8 in_RAX;
ulong uVar2;
int8 local_28;
uVar1 = *(int4 *)(param_2 + 4);
local_28 = in_RAX;
JS_AtomIsArrayIndex(param_3,(long)&local_28 + 4,*(int4 *)(param_1 + 4));
JS_AtomIsArrayIndex(param_3,&local_28,uVar1);
uVar2 = 0xffffffff;
if ((uint)local_28 <= local_28._4_4_) {
uVar2 = (ulong)(local_28._4_4_ != (uint)local_28);
}
return uVar2;
}
|
|
6,864 |
pack_dirname
|
eloqsql/mysys/mf_pack.c
|
void pack_dirname(char * to, const char *from)
{
int cwd_err;
size_t d_length,length,UNINIT_VAR(buff_length);
char * start;
char buff[FN_REFLEN + 1];
DBUG_ENTER("pack_dirname");
(void) intern_filename(to,from); /* Change to intern name */
#ifdef FN_DEVCHAR
if ((start=strrchr(to,FN_DEVCHAR)) != 0) /* Skip device part */
start++;
else
#endif
start=to;
if (!(cwd_err= my_getwd(buff,FN_REFLEN,MYF(0))))
{
buff_length= strlen(buff);
d_length= (size_t) (start-to);
if ((start == to ||
(buff_length == d_length && !memcmp(buff,start,d_length))) &&
*start != FN_LIBCHAR && *start)
{ /* Put current dir before */
bchange((uchar*) to, d_length, (uchar*) buff, buff_length, strlen(to)+1);
}
}
if ((d_length= cleanup_dirname(to,to)) != 0)
{
length=0;
if (home_dir)
{
length= strlen(home_dir);
if (home_dir[length-1] == FN_LIBCHAR)
length--; /* Don't test last '/' */
}
if (length > 1 && length < d_length)
{ /* test if /xx/yy -> ~/yy */
if (memcmp(to,home_dir,length) == 0 && to[length] == FN_LIBCHAR)
{
to[0]=FN_HOMELIB; /* Filename begins with ~ */
(void) strmov_overlapp(to+1,to+length);
}
}
if (! cwd_err)
{ /* Test if cwd is ~/... */
if (length > 1 && length < buff_length)
{
if (memcmp(buff,home_dir,length) == 0 && buff[length] == FN_LIBCHAR)
{
buff[0]=FN_HOMELIB;
(void) strmov_overlapp(buff+1,buff+length);
}
}
if (is_prefix(to,buff))
{
length= strlen(buff);
if (to[length])
(void) strmov_overlapp(to,to+length); /* Remove everything before */
else
{
to[0]= FN_CURLIB; /* Put ./ instead of cwd */
to[1]= FN_LIBCHAR;
to[2]= '\0';
}
}
}
}
DBUG_PRINT("exit",("to: '%s'",to));
DBUG_VOID_RETURN;
}
|
O0
|
c
|
pack_dirname:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp # imm = 0x270
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x218(%rbp)
movq %rsi, -0x220(%rbp)
movq -0x240(%rbp), %rax
movq %rax, -0x240(%rbp)
movq -0x218(%rbp), %rdi
movq -0x220(%rbp), %rsi
callq 0xf0800
movq -0x218(%rbp), %rax
movq %rax, -0x248(%rbp)
leaq -0x210(%rbp), %rdi
movl $0x200, %esi # imm = 0x200
xorl %eax, %eax
movl %eax, %edx
callq 0xf7cc0
movl %eax, -0x224(%rbp)
cmpl $0x0, %eax
jne 0xf05c7
leaq -0x210(%rbp), %rdi
callq 0x29320
movq %rax, -0x240(%rbp)
movq -0x248(%rbp), %rax
movq -0x218(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x230(%rbp)
movq -0x248(%rbp), %rax
cmpq -0x218(%rbp), %rax
je 0xf053b
movq -0x240(%rbp), %rax
cmpq -0x230(%rbp), %rax
jne 0xf05c5
leaq -0x210(%rbp), %rdi
movq -0x248(%rbp), %rsi
movq -0x230(%rbp), %rdx
callq 0x297d0
cmpl $0x0, %eax
jne 0xf05c5
movq -0x248(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0xf05c5
movq -0x248(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xf05c5
movq -0x218(%rbp), %rax
movq %rax, -0x268(%rbp)
movq -0x230(%rbp), %rax
movq %rax, -0x260(%rbp)
leaq -0x210(%rbp), %rax
movq %rax, -0x258(%rbp)
movq -0x240(%rbp), %rax
movq %rax, -0x250(%rbp)
movq -0x218(%rbp), %rdi
callq 0x29320
movq -0x268(%rbp), %rdi
movq -0x260(%rbp), %rsi
movq -0x258(%rbp), %rdx
movq -0x250(%rbp), %rcx
movq %rax, %r8
addq $0x1, %r8
callq 0x112820
jmp 0xf05c7
movq -0x218(%rbp), %rdi
movq -0x218(%rbp), %rsi
callq 0xf08f0
movq %rax, -0x230(%rbp)
cmpq $0x0, %rax
je 0xf07cd
movq $0x0, -0x238(%rbp)
leaq 0xb9d53b(%rip), %rax # 0xc8db38
cmpq $0x0, (%rax)
je 0xf064b
leaq 0xb9d52e(%rip), %rax # 0xc8db38
movq (%rax), %rdi
callq 0x29320
movq %rax, -0x238(%rbp)
leaq 0xb9d518(%rip), %rax # 0xc8db38
movq (%rax), %rax
movq -0x238(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0xf0649
movq -0x238(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x238(%rbp)
jmp 0xf064b
cmpq $0x1, -0x238(%rbp)
jbe 0xf06c8
movq -0x238(%rbp), %rax
cmpq -0x230(%rbp), %rax
jae 0xf06c8
movq -0x218(%rbp), %rdi
leaq 0xb9d4c5(%rip), %rax # 0xc8db38
movq (%rax), %rsi
movq -0x238(%rbp), %rdx
callq 0x297d0
cmpl $0x0, %eax
jne 0xf06c6
movq -0x218(%rbp), %rax
movq -0x238(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0xf06c6
movq -0x218(%rbp), %rax
movb $0x7e, (%rax)
movq -0x218(%rbp), %rdi
addq $0x1, %rdi
movq -0x218(%rbp), %rsi
addq -0x238(%rbp), %rsi
callq 0x157180
jmp 0xf06c8
cmpl $0x0, -0x224(%rbp)
jne 0xf07cb
cmpq $0x1, -0x238(%rbp)
jbe 0xf074c
movq -0x238(%rbp), %rax
cmpq -0x240(%rbp), %rax
jae 0xf074c
leaq -0x210(%rbp), %rdi
leaq 0xb9d43b(%rip), %rax # 0xc8db38
movq (%rax), %rsi
movq -0x238(%rbp), %rdx
callq 0x297d0
cmpl $0x0, %eax
jne 0xf074a
movq -0x238(%rbp), %rax
movsbl -0x210(%rbp,%rax), %eax
cmpl $0x2f, %eax
jne 0xf074a
movb $0x7e, -0x210(%rbp)
leaq -0x210(%rbp), %rdi
addq $0x1, %rdi
leaq -0x210(%rbp), %rsi
addq -0x238(%rbp), %rsi
callq 0x157180
jmp 0xf074c
movq -0x218(%rbp), %rdi
leaq -0x210(%rbp), %rsi
callq 0x1520a0
cmpl $0x0, %eax
je 0xf07c9
leaq -0x210(%rbp), %rdi
callq 0x29320
movq %rax, -0x238(%rbp)
movq -0x218(%rbp), %rax
movq -0x238(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xf07a7
movq -0x218(%rbp), %rdi
movq -0x218(%rbp), %rsi
addq -0x238(%rbp), %rsi
callq 0x157180
jmp 0xf07c7
movq -0x218(%rbp), %rax
movb $0x2e, (%rax)
movq -0x218(%rbp), %rax
movb $0x2f, 0x1(%rax)
movq -0x218(%rbp), %rax
movb $0x0, 0x2(%rax)
jmp 0xf07c9
jmp 0xf07cb
jmp 0xf07cd
jmp 0xf07cf
jmp 0xf07d1
jmp 0xf07d3
jmp 0xf07d5
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xf07f0
addq $0x270, %rsp # imm = 0x270
popq %rbp
retq
callq 0x29230
nopw %cs:(%rax,%rax)
|
pack_dirname:
push rbp
mov rbp, rsp
sub rsp, 270h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_218], rdi
mov [rbp+var_220], rsi
mov rax, [rbp+var_240]
mov [rbp+var_240], rax
mov rdi, [rbp+var_218]
mov rsi, [rbp+var_220]
call intern_filename
mov rax, [rbp+var_218]
mov [rbp+var_248], rax
lea rdi, [rbp+var_210]
mov esi, 200h
xor eax, eax
mov edx, eax
call my_getwd
mov [rbp+var_224], eax
cmp eax, 0
jnz loc_F05C7
lea rdi, [rbp+var_210]
call _strlen
mov [rbp+var_240], rax
mov rax, [rbp+var_248]
mov rcx, [rbp+var_218]
sub rax, rcx
mov [rbp+var_230], rax
mov rax, [rbp+var_248]
cmp rax, [rbp+var_218]
jz short loc_F053B
mov rax, [rbp+var_240]
cmp rax, [rbp+var_230]
jnz loc_F05C5
lea rdi, [rbp+var_210]
mov rsi, [rbp+var_248]
mov rdx, [rbp+var_230]
call _memcmp
cmp eax, 0
jnz loc_F05C5
loc_F053B:
mov rax, [rbp+var_248]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jz short loc_F05C5
mov rax, [rbp+var_248]
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_F05C5
mov rax, [rbp+var_218]
mov [rbp+var_268], rax
mov rax, [rbp+var_230]
mov [rbp+var_260], rax
lea rax, [rbp+var_210]
mov [rbp+var_258], rax
mov rax, [rbp+var_240]
mov [rbp+var_250], rax
mov rdi, [rbp+var_218]
call _strlen
mov rdi, [rbp+var_268]
mov rsi, [rbp+var_260]
mov rdx, [rbp+var_258]
mov rcx, [rbp+var_250]
mov r8, rax
add r8, 1
call bchange
loc_F05C5:
jmp short $+2
loc_F05C7:
mov rdi, [rbp+var_218]
mov rsi, [rbp+var_218]
call cleanup_dirname
mov [rbp+var_230], rax
cmp rax, 0
jz loc_F07CD
mov [rbp+var_238], 0
lea rax, home_dir
cmp qword ptr [rax], 0
jz short loc_F064B
lea rax, home_dir
mov rdi, [rax]
call _strlen
mov [rbp+var_238], rax
lea rax, home_dir
mov rax, [rax]
mov rcx, [rbp+var_238]
sub rcx, 1
movsx eax, byte ptr [rax+rcx]
cmp eax, 2Fh ; '/'
jnz short loc_F0649
mov rax, [rbp+var_238]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_238], rax
loc_F0649:
jmp short $+2
loc_F064B:
cmp [rbp+var_238], 1
jbe short loc_F06C8
mov rax, [rbp+var_238]
cmp rax, [rbp+var_230]
jnb short loc_F06C8
mov rdi, [rbp+var_218]
lea rax, home_dir
mov rsi, [rax]
mov rdx, [rbp+var_238]
call _memcmp
cmp eax, 0
jnz short loc_F06C6
mov rax, [rbp+var_218]
mov rcx, [rbp+var_238]
movsx eax, byte ptr [rax+rcx]
cmp eax, 2Fh ; '/'
jnz short loc_F06C6
mov rax, [rbp+var_218]
mov byte ptr [rax], 7Eh ; '~'
mov rdi, [rbp+var_218]
add rdi, 1
mov rsi, [rbp+var_218]
add rsi, [rbp+var_238]
call strmov_overlapp
loc_F06C6:
jmp short $+2
loc_F06C8:
cmp [rbp+var_224], 0
jnz loc_F07CB
cmp [rbp+var_238], 1
jbe short loc_F074C
mov rax, [rbp+var_238]
cmp rax, [rbp+var_240]
jnb short loc_F074C
lea rdi, [rbp+var_210]
lea rax, home_dir
mov rsi, [rax]
mov rdx, [rbp+var_238]
call _memcmp
cmp eax, 0
jnz short loc_F074A
mov rax, [rbp+var_238]
movsx eax, [rbp+rax+var_210]
cmp eax, 2Fh ; '/'
jnz short loc_F074A
mov [rbp+var_210], 7Eh ; '~'
lea rdi, [rbp+var_210]
add rdi, 1
lea rsi, [rbp+var_210]
add rsi, [rbp+var_238]
call strmov_overlapp
loc_F074A:
jmp short $+2
loc_F074C:
mov rdi, [rbp+var_218]
lea rsi, [rbp+var_210]
call is_prefix
cmp eax, 0
jz short loc_F07C9
lea rdi, [rbp+var_210]
call _strlen
mov [rbp+var_238], rax
mov rax, [rbp+var_218]
mov rcx, [rbp+var_238]
cmp byte ptr [rax+rcx], 0
jz short loc_F07A7
mov rdi, [rbp+var_218]
mov rsi, [rbp+var_218]
add rsi, [rbp+var_238]
call strmov_overlapp
jmp short loc_F07C7
loc_F07A7:
mov rax, [rbp+var_218]
mov byte ptr [rax], 2Eh ; '.'
mov rax, [rbp+var_218]
mov byte ptr [rax+1], 2Fh ; '/'
mov rax, [rbp+var_218]
mov byte ptr [rax+2], 0
loc_F07C7:
jmp short $+2
loc_F07C9:
jmp short $+2
loc_F07CB:
jmp short $+2
loc_F07CD:
jmp short $+2
loc_F07CF:
jmp short $+2
loc_F07D1:
jmp short $+2
loc_F07D3:
jmp short $+2
loc_F07D5:
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_F07F0
add rsp, 270h
pop rbp
retn
loc_F07F0:
call ___stack_chk_fail
|
unsigned long long pack_dirname(_BYTE *a1, long long a2)
{
long long v2; // rax
unsigned long long v4; // [rsp+30h] [rbp-240h]
unsigned long long v5; // [rsp+38h] [rbp-238h]
long long v6; // [rsp+38h] [rbp-238h]
long long v7; // [rsp+40h] [rbp-230h]
unsigned long long v8; // [rsp+40h] [rbp-230h]
int v9; // [rsp+4Ch] [rbp-224h]
_BYTE *v10; // [rsp+58h] [rbp-218h]
char v11; // [rsp+60h] [rbp-210h] BYREF
_BYTE v12[527]; // [rsp+61h] [rbp-20Fh] BYREF
*(_QWORD *)&v12[519] = __readfsqword(0x28u);
v10 = a1;
intern_filename(a1, a2);
v9 = my_getwd(&v11, 512LL, 0LL);
if ( !v9 )
{
v4 = strlen(&v11);
v7 = a1 - v10;
if ( (a1 == v10 || v4 == v7 && !(unsigned int)memcmp(&v11, a1, v7)) && *a1 != 47 && *a1 )
{
v2 = strlen(v10);
bchange(v10, v7, &v11, v4, v2 + 1);
}
}
v8 = cleanup_dirname(v10, v10);
if ( v8 )
{
v5 = 0LL;
if ( home_dir )
{
v5 = strlen(home_dir);
if ( *(_BYTE *)(home_dir + v5 - 1) == 47 )
--v5;
}
if ( v5 > 1 && v5 < v8 && !(unsigned int)memcmp(v10, home_dir, v5) && v10[v5] == 47 )
{
*v10 = 126;
strmov_overlapp(v10 + 1, &v10[v5]);
}
if ( !v9 )
{
if ( v5 > 1 && v5 < v4 && !(unsigned int)memcmp(&v11, home_dir, v5) && v12[v5 - 1] == 47 )
{
v11 = 126;
strmov_overlapp(v12, &v12[v5 - 1]);
}
if ( (unsigned int)is_prefix(v10, &v11) )
{
v6 = strlen(&v11);
if ( v10[v6] )
{
strmov_overlapp(v10, &v10[v6]);
}
else
{
*v10 = 46;
v10[1] = 47;
v10[2] = 0;
}
}
}
}
return __readfsqword(0x28u);
}
|
pack_dirname:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x270
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x218],RDI
MOV qword ptr [RBP + -0x220],RSI
MOV RAX,qword ptr [RBP + -0x240]
MOV qword ptr [RBP + -0x240],RAX
MOV RDI,qword ptr [RBP + -0x218]
MOV RSI,qword ptr [RBP + -0x220]
CALL 0x001f0800
MOV RAX,qword ptr [RBP + -0x218]
MOV qword ptr [RBP + -0x248],RAX
LEA RDI,[RBP + -0x210]
MOV ESI,0x200
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001f7cc0
MOV dword ptr [RBP + -0x224],EAX
CMP EAX,0x0
JNZ 0x001f05c7
LEA RDI,[RBP + -0x210]
CALL 0x00129320
MOV qword ptr [RBP + -0x240],RAX
MOV RAX,qword ptr [RBP + -0x248]
MOV RCX,qword ptr [RBP + -0x218]
SUB RAX,RCX
MOV qword ptr [RBP + -0x230],RAX
MOV RAX,qword ptr [RBP + -0x248]
CMP RAX,qword ptr [RBP + -0x218]
JZ 0x001f053b
MOV RAX,qword ptr [RBP + -0x240]
CMP RAX,qword ptr [RBP + -0x230]
JNZ 0x001f05c5
LEA RDI,[RBP + -0x210]
MOV RSI,qword ptr [RBP + -0x248]
MOV RDX,qword ptr [RBP + -0x230]
CALL 0x001297d0
CMP EAX,0x0
JNZ 0x001f05c5
LAB_001f053b:
MOV RAX,qword ptr [RBP + -0x248]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JZ 0x001f05c5
MOV RAX,qword ptr [RBP + -0x248]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x001f05c5
MOV RAX,qword ptr [RBP + -0x218]
MOV qword ptr [RBP + -0x268],RAX
MOV RAX,qword ptr [RBP + -0x230]
MOV qword ptr [RBP + -0x260],RAX
LEA RAX,[RBP + -0x210]
MOV qword ptr [RBP + -0x258],RAX
MOV RAX,qword ptr [RBP + -0x240]
MOV qword ptr [RBP + -0x250],RAX
MOV RDI,qword ptr [RBP + -0x218]
CALL 0x00129320
MOV RDI,qword ptr [RBP + -0x268]
MOV RSI,qword ptr [RBP + -0x260]
MOV RDX,qword ptr [RBP + -0x258]
MOV RCX,qword ptr [RBP + -0x250]
MOV R8,RAX
ADD R8,0x1
CALL 0x00212820
LAB_001f05c5:
JMP 0x001f05c7
LAB_001f05c7:
MOV RDI,qword ptr [RBP + -0x218]
MOV RSI,qword ptr [RBP + -0x218]
CALL 0x001f08f0
MOV qword ptr [RBP + -0x230],RAX
CMP RAX,0x0
JZ 0x001f07cd
MOV qword ptr [RBP + -0x238],0x0
LEA RAX,[0xd8db38]
CMP qword ptr [RAX],0x0
JZ 0x001f064b
LEA RAX,[0xd8db38]
MOV RDI,qword ptr [RAX]
CALL 0x00129320
MOV qword ptr [RBP + -0x238],RAX
LEA RAX,[0xd8db38]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x238]
SUB RCX,0x1
MOVSX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x2f
JNZ 0x001f0649
MOV RAX,qword ptr [RBP + -0x238]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x238],RAX
LAB_001f0649:
JMP 0x001f064b
LAB_001f064b:
CMP qword ptr [RBP + -0x238],0x1
JBE 0x001f06c8
MOV RAX,qword ptr [RBP + -0x238]
CMP RAX,qword ptr [RBP + -0x230]
JNC 0x001f06c8
MOV RDI,qword ptr [RBP + -0x218]
LEA RAX,[0xd8db38]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x238]
CALL 0x001297d0
CMP EAX,0x0
JNZ 0x001f06c6
MOV RAX,qword ptr [RBP + -0x218]
MOV RCX,qword ptr [RBP + -0x238]
MOVSX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x2f
JNZ 0x001f06c6
MOV RAX,qword ptr [RBP + -0x218]
MOV byte ptr [RAX],0x7e
MOV RDI,qword ptr [RBP + -0x218]
ADD RDI,0x1
MOV RSI,qword ptr [RBP + -0x218]
ADD RSI,qword ptr [RBP + -0x238]
CALL 0x00257180
LAB_001f06c6:
JMP 0x001f06c8
LAB_001f06c8:
CMP dword ptr [RBP + -0x224],0x0
JNZ 0x001f07cb
CMP qword ptr [RBP + -0x238],0x1
JBE 0x001f074c
MOV RAX,qword ptr [RBP + -0x238]
CMP RAX,qword ptr [RBP + -0x240]
JNC 0x001f074c
LEA RDI,[RBP + -0x210]
LEA RAX,[0xd8db38]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x238]
CALL 0x001297d0
CMP EAX,0x0
JNZ 0x001f074a
MOV RAX,qword ptr [RBP + -0x238]
MOVSX EAX,byte ptr [RBP + RAX*0x1 + -0x210]
CMP EAX,0x2f
JNZ 0x001f074a
MOV byte ptr [RBP + -0x210],0x7e
LEA RDI,[RBP + -0x210]
ADD RDI,0x1
LEA RSI,[RBP + -0x210]
ADD RSI,qword ptr [RBP + -0x238]
CALL 0x00257180
LAB_001f074a:
JMP 0x001f074c
LAB_001f074c:
MOV RDI,qword ptr [RBP + -0x218]
LEA RSI,[RBP + -0x210]
CALL 0x002520a0
CMP EAX,0x0
JZ 0x001f07c9
LEA RDI,[RBP + -0x210]
CALL 0x00129320
MOV qword ptr [RBP + -0x238],RAX
MOV RAX,qword ptr [RBP + -0x218]
MOV RCX,qword ptr [RBP + -0x238]
CMP byte ptr [RAX + RCX*0x1],0x0
JZ 0x001f07a7
MOV RDI,qword ptr [RBP + -0x218]
MOV RSI,qword ptr [RBP + -0x218]
ADD RSI,qword ptr [RBP + -0x238]
CALL 0x00257180
JMP 0x001f07c7
LAB_001f07a7:
MOV RAX,qword ptr [RBP + -0x218]
MOV byte ptr [RAX],0x2e
MOV RAX,qword ptr [RBP + -0x218]
MOV byte ptr [RAX + 0x1],0x2f
MOV RAX,qword ptr [RBP + -0x218]
MOV byte ptr [RAX + 0x2],0x0
LAB_001f07c7:
JMP 0x001f07c9
LAB_001f07c9:
JMP 0x001f07cb
LAB_001f07cb:
JMP 0x001f07cd
LAB_001f07cd:
JMP 0x001f07cf
LAB_001f07cf:
JMP 0x001f07d1
LAB_001f07d1:
JMP 0x001f07d3
LAB_001f07d3:
JMP 0x001f07d5
LAB_001f07d5:
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001f07f0
ADD RSP,0x270
POP RBP
RET
LAB_001f07f0:
CALL 0x00129230
|
/* WARNING: Removing unreachable block (ram,0x001f0504) */
/* WARNING: Removing unreachable block (ram,0x001f0518) */
void pack_dirname(char *param_1,int8 param_2)
{
int iVar1;
int iVar2;
size_t sVar3;
ulong uVar4;
long in_FS_OFFSET;
ulong local_248;
ulong local_240;
char local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
intern_filename(param_1,param_2);
iVar1 = my_getwd(local_218,0x200,0);
if (((iVar1 == 0) && (local_248 = strlen(local_218), *param_1 != '/')) && (*param_1 != '\0')) {
sVar3 = strlen(param_1);
bchange(param_1,0,local_218,local_248,sVar3 + 1);
}
uVar4 = cleanup_dirname(param_1,param_1);
if (uVar4 != 0) {
local_240 = 0;
if ((home_dir != (char *)0x0) && (local_240 = strlen(home_dir), home_dir[local_240 - 1] == '/'))
{
local_240 = local_240 - 1;
}
if (((1 < local_240) && (local_240 < uVar4)) &&
((iVar2 = memcmp(param_1,home_dir,local_240), iVar2 == 0 && (param_1[local_240] == '/')))) {
*param_1 = '~';
strmov_overlapp(param_1 + 1,param_1 + local_240);
}
if (iVar1 == 0) {
if ((((1 < local_240) && (local_240 < local_248)) &&
(iVar1 = memcmp(local_218,home_dir,local_240), iVar1 == 0)) &&
(local_218[local_240] == '/')) {
local_218[0] = '~';
strmov_overlapp(local_218 + 1,local_218 + local_240);
}
iVar1 = is_prefix(param_1,local_218);
if (iVar1 != 0) {
sVar3 = strlen(local_218);
if (param_1[sVar3] == '\0') {
*param_1 = '.';
param_1[1] = '/';
param_1[2] = '\0';
}
else {
strmov_overlapp(param_1,param_1 + sVar3);
}
}
}
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
6,865 |
key_cache_write
|
eloqsql/mysys/mf_keycache.c
|
int key_cache_write(KEY_CACHE *keycache,
File file, void *file_extra,
my_off_t filepos, int level,
uchar *buff, uint length,
uint block_length, int force_write)
{
if (keycache->can_be_used)
return keycache->interface_funcs->write(keycache->keycache_cb,
file, file_extra,
filepos, level,
buff, length,
block_length, force_write);
/* We can't use mutex here as the key cache may not be initialized */
if (my_pwrite(file, buff, length, filepos, MYF(MY_NABP | MY_WAIT_IF_FULL)))
return 1;
return 0;
}
|
O0
|
c
|
key_cache_write:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movl %r8d, -0x34(%rbp)
movq %r9, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x49(%rax)
je 0xe6019
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl -0x34(%rbp), %r8d
movq -0x40(%rbp), %r9
movl 0x10(%rbp), %ebx
movl 0x18(%rbp), %r11d
movl 0x20(%rbp), %r10d
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
callq *%rax
movl %eax, -0xc(%rbp)
jmp 0xe604a
movl -0x1c(%rbp), %edi
movq -0x40(%rbp), %rsi
movl 0x10(%rbp), %eax
movl %eax, %edx
movq -0x30(%rbp), %rcx
movl $0x24, %r8d
callq 0xf5c10
cmpq $0x0, %rax
je 0xe6043
movl $0x1, -0xc(%rbp)
jmp 0xe604a
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
key_cache_write:
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov eax, [rbp+arg_10]
mov eax, [rbp+arg_8]
mov eax, [rbp+arg_0]
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_30], rcx
mov [rbp+var_34], r8d
mov [rbp+var_40], r9
mov rax, [rbp+var_18]
cmp byte ptr [rax+49h], 0
jz short loc_E6019
mov rax, [rbp+var_18]
mov rax, [rax+10h]
mov rax, [rax+28h]
mov rcx, [rbp+var_18]
mov rdi, [rcx+8]
mov esi, [rbp+var_1C]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
mov r8d, [rbp+var_34]
mov r9, [rbp+var_40]
mov ebx, [rbp+arg_0]
mov r11d, [rbp+arg_8]
mov r10d, [rbp+arg_10]
mov [rsp+60h+var_60], ebx
mov [rsp+60h+var_58], r11d
mov [rsp+60h+var_50], r10d
call rax
mov [rbp+var_C], eax
jmp short loc_E604A
loc_E6019:
mov edi, [rbp+var_1C]
mov rsi, [rbp+var_40]
mov eax, [rbp+arg_0]
mov edx, eax
mov rcx, [rbp+var_30]
mov r8d, 24h ; '$'
call my_pwrite
cmp rax, 0
jz short loc_E6043
mov [rbp+var_C], 1
jmp short loc_E604A
loc_E6043:
mov [rbp+var_C], 0
loc_E604A:
mov eax, [rbp+var_C]
add rsp, 58h
pop rbx
pop rbp
retn
|
long long key_cache_write(
long long a1,
unsigned int a2,
long long a3,
long long a4,
unsigned int a5,
long long a6,
unsigned int a7,
int a8,
int a9)
{
if ( *(_BYTE *)(a1 + 73) )
return (unsigned int)(*(long long ( **)(_QWORD, _QWORD, long long, long long, _QWORD, long long, unsigned int, int, int))(*(_QWORD *)(a1 + 16) + 40LL))(
*(_QWORD *)(a1 + 8),
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9);
else
return my_pwrite(a2, a6, a7, a4, 36LL) != 0;
}
|
key_cache_write:
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV EAX,dword ptr [RBP + 0x20]
MOV EAX,dword ptr [RBP + 0x18]
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV qword ptr [RBP + -0x30],RCX
MOV dword ptr [RBP + -0x34],R8D
MOV qword ptr [RBP + -0x40],R9
MOV RAX,qword ptr [RBP + -0x18]
CMP byte ptr [RAX + 0x49],0x0
JZ 0x001e6019
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RAX + 0x28]
MOV RCX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RCX + 0x8]
MOV ESI,dword ptr [RBP + -0x1c]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
MOV R8D,dword ptr [RBP + -0x34]
MOV R9,qword ptr [RBP + -0x40]
MOV EBX,dword ptr [RBP + 0x10]
MOV R11D,dword ptr [RBP + 0x18]
MOV R10D,dword ptr [RBP + 0x20]
MOV dword ptr [RSP],EBX
MOV dword ptr [RSP + 0x8],R11D
MOV dword ptr [RSP + 0x10],R10D
CALL RAX
MOV dword ptr [RBP + -0xc],EAX
JMP 0x001e604a
LAB_001e6019:
MOV EDI,dword ptr [RBP + -0x1c]
MOV RSI,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + 0x10]
MOV EDX,EAX
MOV RCX,qword ptr [RBP + -0x30]
MOV R8D,0x24
CALL 0x001f5c10
CMP RAX,0x0
JZ 0x001e6043
MOV dword ptr [RBP + -0xc],0x1
JMP 0x001e604a
LAB_001e6043:
MOV dword ptr [RBP + -0xc],0x0
LAB_001e604a:
MOV EAX,dword ptr [RBP + -0xc]
ADD RSP,0x58
POP RBX
POP RBP
RET
|
int4
key_cache_write(long param_1,int4 param_2,int8 param_3,int8 param_4,
int4 param_5,int8 param_6,int4 param_7,int4 param_8,
int4 param_9)
{
long lVar1;
int4 local_14;
if (*(char *)(param_1 + 0x49) == '\0') {
lVar1 = my_pwrite(param_2,param_6,param_7,param_4,0x24);
if (lVar1 == 0) {
local_14 = 0;
}
else {
local_14 = 1;
}
}
else {
local_14 = (**(code **)(*(long *)(param_1 + 0x10) + 0x28))
(*(int8 *)(param_1 + 8),param_2,param_3,param_4,param_5,param_6,
param_7,param_8,param_9);
}
return local_14;
}
|
|
6,866 |
fill_uint16
|
eloqsql/strings/ctype.c
|
static int fill_uint16(uint16 *a,uint size,const char *str, size_t len)
{
uint i= 0;
const char *s, *b, *e=str+len;
for (s=str ; s < e ; i++)
{
for ( ; (s < e) && strchr(" \t\r\n",s[0]); s++) ;
b=s;
for ( ; (s < e) && !strchr(" \t\r\n",s[0]); s++) ;
if (s == b || i > size)
break;
a[i]= (uint16) strtol(b,NULL,16);
}
return 0;
}
|
O0
|
c
|
fill_uint16:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x748a8
jmp 0x747d2
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x41(%rbp)
jae 0x747fe
movq -0x30(%rbp), %rax
movsbl (%rax), %esi
leaq 0x10316(%rip), %rdi # 0x84b05
callq 0x24100
cmpq $0x0, %rax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x74807
jmp 0x74817
jmp 0x74809
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x747d2
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x42(%rbp)
jae 0x7484d
movq -0x30(%rbp), %rax
movsbl (%rax), %esi
leaq 0x102c9(%rip), %rdi # 0x84b05
callq 0x24100
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0x74856
jmp 0x74866
jmp 0x74858
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x7481f
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x74878
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jbe 0x7487a
jmp 0x748a8
movq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %edx
callq 0x24610
movw %ax, %dx
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movw %dx, (%rax,%rcx,2)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x747c2
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
|
fill_uint16:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_24], 0
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
loc_747C2:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_40]
jnb loc_748A8
jmp short $+2
loc_747D2:
mov rcx, [rbp+var_30]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_41], al
jnb short loc_747FE
mov rax, [rbp+var_30]
movsx esi, byte ptr [rax]
lea rdi, asc_84B05; " \t\r\n"
call _strchr
cmp rax, 0
setnz al
mov [rbp+var_41], al
loc_747FE:
mov al, [rbp+var_41]
test al, 1
jnz short loc_74807
jmp short loc_74817
loc_74807:
jmp short $+2
loc_74809:
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
jmp short loc_747D2
loc_74817:
mov rax, [rbp+var_30]
mov [rbp+var_38], rax
loc_7481F:
mov rcx, [rbp+var_30]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_42], al
jnb short loc_7484D
mov rax, [rbp+var_30]
movsx esi, byte ptr [rax]
lea rdi, asc_84B05; " \t\r\n"
call _strchr
cmp rax, 0
setnz al
xor al, 0FFh
mov [rbp+var_42], al
loc_7484D:
mov al, [rbp+var_42]
test al, 1
jnz short loc_74856
jmp short loc_74866
loc_74856:
jmp short $+2
loc_74858:
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
jmp short loc_7481F
loc_74866:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_38]
jz short loc_74878
mov eax, [rbp+var_24]
cmp eax, [rbp+var_C]
jbe short loc_7487A
loc_74878:
jmp short loc_748A8
loc_7487A:
mov rdi, [rbp+var_38]
xor eax, eax
mov esi, eax
mov edx, 10h
call ___isoc23_strtol
mov dx, ax
mov rax, [rbp+var_8]
mov ecx, [rbp+var_24]
mov [rax+rcx*2], dx
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp loc_747C2
loc_748A8:
xor eax, eax
add rsp, 50h
pop rbp
retn
|
long long fill_uint16(long long a1, unsigned int a2, char *a3, long long a4)
{
char v5; // [rsp+Eh] [rbp-42h]
bool v6; // [rsp+Fh] [rbp-41h]
unsigned long long v7; // [rsp+10h] [rbp-40h]
char *v8; // [rsp+18h] [rbp-38h]
char *v9; // [rsp+20h] [rbp-30h]
unsigned int v10; // [rsp+2Ch] [rbp-24h]
v10 = 0;
v7 = (unsigned long long)&a3[a4];
v9 = a3;
while ( (unsigned long long)v9 < v7 )
{
while ( 1 )
{
v6 = 0;
if ( (unsigned long long)v9 < v7 )
v6 = strchr(" \t\r\n", (unsigned int)*v9) != 0;
if ( !v6 )
break;
++v9;
}
v8 = v9;
while ( 1 )
{
v5 = 0;
if ( (unsigned long long)v9 < v7 )
v5 = ~(strchr(" \t\r\n", (unsigned int)*v9) != 0);
if ( (v5 & 1) == 0 )
break;
++v9;
}
if ( v9 == v8 || v10 > a2 )
break;
*(_WORD *)(a1 + 2LL * v10++) = __isoc23_strtol(v8, 0LL, 16LL);
}
return 0LL;
}
|
fill_uint16:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV dword ptr [RBP + -0x24],0x0
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
LAB_001747c2:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x001748a8
JMP 0x001747d2
LAB_001747d2:
MOV RCX,qword ptr [RBP + -0x30]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x41],AL
JNC 0x001747fe
MOV RAX,qword ptr [RBP + -0x30]
MOVSX ESI,byte ptr [RAX]
LEA RDI,[0x184b05]
CALL 0x00124100
CMP RAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x41],AL
LAB_001747fe:
MOV AL,byte ptr [RBP + -0x41]
TEST AL,0x1
JNZ 0x00174807
JMP 0x00174817
LAB_00174807:
JMP 0x00174809
LAB_00174809:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001747d2
LAB_00174817:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x38],RAX
LAB_0017481f:
MOV RCX,qword ptr [RBP + -0x30]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x42],AL
JNC 0x0017484d
MOV RAX,qword ptr [RBP + -0x30]
MOVSX ESI,byte ptr [RAX]
LEA RDI,[0x184b05]
CALL 0x00124100
CMP RAX,0x0
SETNZ AL
XOR AL,0xff
MOV byte ptr [RBP + -0x42],AL
LAB_0017484d:
MOV AL,byte ptr [RBP + -0x42]
TEST AL,0x1
JNZ 0x00174856
JMP 0x00174866
LAB_00174856:
JMP 0x00174858
LAB_00174858:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0017481f
LAB_00174866:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x38]
JZ 0x00174878
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0xc]
JBE 0x0017487a
LAB_00174878:
JMP 0x001748a8
LAB_0017487a:
MOV RDI,qword ptr [RBP + -0x38]
XOR EAX,EAX
MOV ESI,EAX
MOV EDX,0x10
CALL 0x00124610
MOV DX,AX
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0x24]
MOV word ptr [RAX + RCX*0x2],DX
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
JMP 0x001747c2
LAB_001748a8:
XOR EAX,EAX
ADD RSP,0x50
POP RBP
RET
|
int8 fill_uint16(long param_1,uint param_2,char *param_3,long param_4)
{
char *pcVar1;
int2 uVar2;
char *pcVar3;
char *pcVar4;
bool bVar5;
char *local_38;
uint local_2c;
local_2c = 0;
pcVar3 = param_3 + param_4;
local_38 = param_3;
while( true ) {
if (pcVar3 <= local_38) {
return 0;
}
while( true ) {
pcVar1 = local_38;
bVar5 = false;
if (local_38 < pcVar3) {
pcVar4 = strchr(" \t\r\n",(int)*local_38);
bVar5 = pcVar4 != (char *)0x0;
}
if (!bVar5) break;
local_38 = local_38 + 1;
}
while( true ) {
bVar5 = false;
if (local_38 < pcVar3) {
pcVar4 = strchr(" \t\r\n",(int)*local_38);
bVar5 = pcVar4 == (char *)0x0;
}
if (!bVar5) break;
local_38 = local_38 + 1;
}
if (local_38 == pcVar1) break;
if (param_2 < local_2c) {
return 0;
}
uVar2 = __isoc23_strtol(pcVar1,0,0x10);
*(int2 *)(param_1 + (ulong)local_2c * 2) = uVar2;
local_2c = local_2c + 1;
}
return 0;
}
|
|
6,867 |
js_string_isWellFormed
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_string_isWellFormed(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue str;
JSValue ret;
JSString *p;
uint32_t c, i, n;
ret = JS_TRUE;
str = JS_ToStringCheckObject(ctx, this_val);
if (JS_IsException(str))
return JS_EXCEPTION;
p = JS_VALUE_GET_STRING(str);
if (!p->is_wide_char || p->len == 0)
goto done; // by definition well-formed
for (i = 0, n = p->len; i < n; i++) {
c = p->u.str16[i];
if (!is_surrogate(c))
continue;
if (is_lo_surrogate(c) || i + 1 == n)
break;
c = p->u.str16[++i];
if (!is_lo_surrogate(c))
break;
}
if (i < n)
ret = JS_FALSE;
done:
JS_FreeValue(ctx, str);
return ret;
}
|
O0
|
c
|
js_string_isWellFormed:
subq $0xa8, %rsp
movq %rsi, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
movq %rdi, 0x80(%rsp)
movl %ecx, 0x7c(%rsp)
movq %r8, 0x70(%rsp)
movl $0x1, 0x28(%rsp)
movq $0x1, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x80(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
callq 0x707d0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0xd3678
movl $0x0, 0x98(%rsp)
movq $0x6, 0xa0(%rsp)
jmp 0xd37b3
movq 0x60(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq 0x4(%rax), %rax
shrq $0x1f, %rax
andq $0x1, %rax
cmpb $0x0, %al
je 0xd36ab
movq 0x48(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
cmpl $0x0, %eax
jne 0xd36b0
jmp 0xd3782
movl $0x0, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
movl %eax, 0x3c(%rsp)
movl 0x40(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jae 0xd3751
movq 0x48(%rsp), %rax
movl 0x40(%rsp), %ecx
movzwl 0x18(%rax,%rcx,2), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %edi
callq 0x860c0
cmpl $0x0, %eax
jne 0xd36f7
jmp 0xd3741
movl 0x44(%rsp), %edi
callq 0x29e00
cmpl $0x0, %eax
jne 0xd3712
movl 0x40(%rsp), %eax
addl $0x1, %eax
cmpl 0x3c(%rsp), %eax
jne 0xd3714
jmp 0xd3751
movq 0x48(%rsp), %rax
movl 0x40(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, 0x40(%rsp)
movl %ecx, %ecx
movzwl 0x18(%rax,%rcx,2), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %edi
callq 0x29e00
cmpl $0x0, %eax
jne 0xd373f
jmp 0xd3751
jmp 0xd3741
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0xd36cb
movl 0x40(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jae 0xd3780
movl $0x0, 0x8(%rsp)
movq $0x1, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x58(%rsp)
jmp 0xd3782
movq 0x80(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
callq 0x23c90
movq 0x50(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0x98(%rsp), %rax
movq 0xa0(%rsp), %rdx
addq $0xa8, %rsp
retq
nopl (%rax,%rax)
|
js_string_isWellFormed:
sub rsp, 0A8h
mov [rsp+0A8h+var_20], rsi
mov [rsp+0A8h+var_18], rdx
mov [rsp+0A8h+var_28], rdi
mov [rsp+0A8h+var_2C], ecx
mov [rsp+0A8h+var_38], r8
mov dword ptr [rsp+0A8h+var_80], 1
mov [rsp+0A8h+var_78], 1
mov rax, [rsp+0A8h+var_80]
mov [rsp+0A8h+var_58], rax
mov rax, [rsp+0A8h+var_78]
mov [rsp+0A8h+var_50], rax
mov rdi, [rsp+0A8h+var_28]
mov rsi, [rsp+0A8h+var_20]
mov rdx, [rsp+0A8h+var_18]
call JS_ToStringCheckObject
mov [rsp+0A8h+var_90], rax
mov [rsp+0A8h+var_88], rdx
mov rax, [rsp+0A8h+var_90]
mov [rsp+0A8h+var_48], rax
mov rax, [rsp+0A8h+var_88]
mov [rsp+0A8h+var_40], rax
mov rdi, [rsp+0A8h+var_48]
mov rsi, [rsp+0A8h+var_40]
call JS_IsException_1
cmp eax, 0
jz short loc_D3678
mov dword ptr [rsp+0A8h+var_10], 0
mov [rsp+0A8h+var_8], 6
jmp loc_D37B3
loc_D3678:
mov rax, [rsp+0A8h+var_48]
mov [rsp+0A8h+var_60], rax
mov rax, [rsp+0A8h+var_60]
mov rax, [rax+4]
shr rax, 1Fh
and rax, 1
cmp al, 0
jz short loc_D36AB
mov rax, [rsp+0A8h+var_60]
mov rax, [rax+4]
and rax, 7FFFFFFFh
cmp eax, 0
jnz short loc_D36B0
loc_D36AB:
jmp loc_D3782
loc_D36B0:
mov [rsp+0A8h+var_68], 0
mov rax, [rsp+0A8h+var_60]
mov rax, [rax+4]
and rax, 7FFFFFFFh
mov [rsp+0A8h+var_6C], eax
loc_D36CB:
mov eax, [rsp+0A8h+var_68]
cmp eax, [rsp+0A8h+var_6C]
jnb short loc_D3751
mov rax, [rsp+0A8h+var_60]
mov ecx, [rsp+0A8h+var_68]
movzx eax, word ptr [rax+rcx*2+18h]
mov [rsp+0A8h+var_64], eax
mov edi, [rsp+0A8h+var_64]
call is_surrogate
cmp eax, 0
jnz short loc_D36F7
jmp short loc_D3741
loc_D36F7:
mov edi, [rsp+0A8h+var_64]
call is_lo_surrogate_0
cmp eax, 0
jnz short loc_D3712
mov eax, [rsp+0A8h+var_68]
add eax, 1
cmp eax, [rsp+0A8h+var_6C]
jnz short loc_D3714
loc_D3712:
jmp short loc_D3751
loc_D3714:
mov rax, [rsp+0A8h+var_60]
mov ecx, [rsp+0A8h+var_68]
add ecx, 1
mov [rsp+0A8h+var_68], ecx
mov ecx, ecx
movzx eax, word ptr [rax+rcx*2+18h]
mov [rsp+0A8h+var_64], eax
mov edi, [rsp+0A8h+var_64]
call is_lo_surrogate_0
cmp eax, 0
jnz short loc_D373F
jmp short loc_D3751
loc_D373F:
jmp short $+2
loc_D3741:
mov eax, [rsp+0A8h+var_68]
add eax, 1
mov [rsp+0A8h+var_68], eax
jmp loc_D36CB
loc_D3751:
mov eax, [rsp+0A8h+var_68]
cmp eax, [rsp+0A8h+var_6C]
jnb short loc_D3780
mov dword ptr [rsp+0A8h+var_A0], 0
mov [rsp+0A8h+var_98], 1
mov rax, [rsp+0A8h+var_A0]
mov [rsp+0A8h+var_58], rax
mov rax, [rsp+0A8h+var_98]
mov [rsp+0A8h+var_50], rax
loc_D3780:
jmp short $+2
loc_D3782:
mov rdi, [rsp+0A8h+var_28]
mov rsi, [rsp+0A8h+var_48]
mov rdx, [rsp+0A8h+var_40]
call JS_FreeValue
mov rax, [rsp+0A8h+var_58]
mov [rsp+0A8h+var_10], rax
mov rax, [rsp+0A8h+var_50]
mov [rsp+0A8h+var_8], rax
loc_D37B3:
mov rax, [rsp+0A8h+var_10]
mov rdx, [rsp+0A8h+var_8]
add rsp, 0A8h
retn
|
long long js_string_isWellFormed(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v14; // rdx
long long v16; // [rsp+8h] [rbp-A0h]
long long v17; // [rsp+18h] [rbp-90h]
long long v18; // [rsp+28h] [rbp-80h]
unsigned int v19; // [rsp+3Ch] [rbp-6Ch]
unsigned int v20; // [rsp+40h] [rbp-68h]
unsigned int v21; // [rsp+44h] [rbp-64h]
long long v22; // [rsp+50h] [rbp-58h]
long long v23; // [rsp+68h] [rbp-40h]
long long v24; // [rsp+98h] [rbp-10h]
LODWORD(v18) = 1;
v22 = v18;
v17 = JS_ToStringCheckObject(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v23 = v14;
if ( JS_IsException_1(v17, v14) )
{
LODWORD(v24) = 0;
}
else
{
if ( (*(_QWORD *)(v17 + 4) & 0x80000000LL) != 0 && (*(_DWORD *)(v17 + 4) & 0x7FFFFFFF) != 0 )
{
v20 = 0;
v19 = *(_DWORD *)(v17 + 4) & 0x7FFFFFFF;
while ( v20 < v19 )
{
v21 = *(unsigned __int16 *)(v17 + 2LL * v20 + 24);
if ( is_surrogate(v21) )
{
if ( is_lo_surrogate_0(v21) )
break;
if ( v20 + 1 == v19 )
break;
if ( !is_lo_surrogate_0(*(unsigned __int16 *)(v17 + 2LL * ++v20 + 24)) )
break;
}
++v20;
}
if ( v20 < v19 )
{
LODWORD(v16) = 0;
v22 = v16;
}
}
JS_FreeValue(a1, v17, v23);
return v22;
}
return v24;
}
|
js_string_isWellFormed:
SUB RSP,0xa8
MOV qword ptr [RSP + 0x88],RSI
MOV qword ptr [RSP + 0x90],RDX
MOV qword ptr [RSP + 0x80],RDI
MOV dword ptr [RSP + 0x7c],ECX
MOV qword ptr [RSP + 0x70],R8
MOV dword ptr [RSP + 0x28],0x1
MOV qword ptr [RSP + 0x30],0x1
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x50],RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x58],RAX
MOV RDI,qword ptr [RSP + 0x80]
MOV RSI,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x90]
CALL 0x001707d0
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x68],RAX
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x68]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x001d3678
MOV dword ptr [RSP + 0x98],0x0
MOV qword ptr [RSP + 0xa0],0x6
JMP 0x001d37b3
LAB_001d3678:
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x48],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RAX + 0x4]
SHR RAX,0x1f
AND RAX,0x1
CMP AL,0x0
JZ 0x001d36ab
MOV RAX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
CMP EAX,0x0
JNZ 0x001d36b0
LAB_001d36ab:
JMP 0x001d3782
LAB_001d36b0:
MOV dword ptr [RSP + 0x40],0x0
MOV RAX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
MOV dword ptr [RSP + 0x3c],EAX
LAB_001d36cb:
MOV EAX,dword ptr [RSP + 0x40]
CMP EAX,dword ptr [RSP + 0x3c]
JNC 0x001d3751
MOV RAX,qword ptr [RSP + 0x48]
MOV ECX,dword ptr [RSP + 0x40]
MOVZX EAX,word ptr [RAX + RCX*0x2 + 0x18]
MOV dword ptr [RSP + 0x44],EAX
MOV EDI,dword ptr [RSP + 0x44]
CALL 0x001860c0
CMP EAX,0x0
JNZ 0x001d36f7
JMP 0x001d3741
LAB_001d36f7:
MOV EDI,dword ptr [RSP + 0x44]
CALL 0x00129e00
CMP EAX,0x0
JNZ 0x001d3712
MOV EAX,dword ptr [RSP + 0x40]
ADD EAX,0x1
CMP EAX,dword ptr [RSP + 0x3c]
JNZ 0x001d3714
LAB_001d3712:
JMP 0x001d3751
LAB_001d3714:
MOV RAX,qword ptr [RSP + 0x48]
MOV ECX,dword ptr [RSP + 0x40]
ADD ECX,0x1
MOV dword ptr [RSP + 0x40],ECX
MOV ECX,ECX
MOVZX EAX,word ptr [RAX + RCX*0x2 + 0x18]
MOV dword ptr [RSP + 0x44],EAX
MOV EDI,dword ptr [RSP + 0x44]
CALL 0x00129e00
CMP EAX,0x0
JNZ 0x001d373f
JMP 0x001d3751
LAB_001d373f:
JMP 0x001d3741
LAB_001d3741:
MOV EAX,dword ptr [RSP + 0x40]
ADD EAX,0x1
MOV dword ptr [RSP + 0x40],EAX
JMP 0x001d36cb
LAB_001d3751:
MOV EAX,dword ptr [RSP + 0x40]
CMP EAX,dword ptr [RSP + 0x3c]
JNC 0x001d3780
MOV dword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],0x1
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x50],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x58],RAX
LAB_001d3780:
JMP 0x001d3782
LAB_001d3782:
MOV RDI,qword ptr [RSP + 0x80]
MOV RSI,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x68]
CALL 0x00123c90
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x98],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0xa0],RAX
LAB_001d37b3:
MOV RAX,qword ptr [RSP + 0x98]
MOV RDX,qword ptr [RSP + 0xa0]
ADD RSP,0xa8
RET
|
int1 [16] js_string_isWellFormed(int8 param_1,int8 param_2,int8 param_3)
{
int2 uVar1;
int iVar2;
uint uVar3;
int1 auVar5 [16];
int4 uStack_9c;
int4 uStack_7c;
uint local_68;
uint local_58;
int4 uStack_54;
uint local_10;
int4 uStack_c;
int8 local_8;
long lVar4;
local_58 = 1;
uStack_54 = uStack_7c;
auVar5 = JS_ToStringCheckObject(param_1,param_2,param_3);
lVar4 = auVar5._0_8_;
iVar2 = JS_IsException(lVar4,auVar5._8_8_);
if (iVar2 == 0) {
if (((*(ulong *)(lVar4 + 4) >> 0x1f & 1) != 0) && ((*(ulong *)(lVar4 + 4) & 0x7fffffff) != 0)) {
local_68 = 0;
uVar3 = (uint)*(int8 *)(lVar4 + 4) & 0x7fffffff;
for (; local_68 < uVar3; local_68 = local_68 + 1) {
uVar1 = *(int2 *)(lVar4 + 0x18 + (ulong)local_68 * 2);
iVar2 = is_surrogate(uVar1);
if (iVar2 != 0) {
iVar2 = is_lo_surrogate(uVar1);
if ((iVar2 != 0) || (local_68 + 1 == uVar3)) break;
local_68 = local_68 + 1;
iVar2 = is_lo_surrogate(*(int2 *)(lVar4 + 0x18 + (ulong)local_68 * 2));
if (iVar2 == 0) break;
}
}
if (local_68 < uVar3) {
uStack_54 = uStack_9c;
}
local_58 = (uint)(local_68 >= uVar3);
}
JS_FreeValue(param_1,lVar4,auVar5._8_8_);
local_10 = local_58;
uStack_c = uStack_54;
local_8 = 1;
}
else {
local_10 = 0;
local_8 = 6;
}
auVar5._4_4_ = uStack_c;
auVar5._0_4_ = local_10;
auVar5._8_8_ = local_8;
return auVar5;
}
|
|
6,868 |
js_string_isWellFormed
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_string_isWellFormed(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue str;
JSValue ret;
JSString *p;
uint32_t c, i, n;
ret = JS_TRUE;
str = JS_ToStringCheckObject(ctx, this_val);
if (JS_IsException(str))
return JS_EXCEPTION;
p = JS_VALUE_GET_STRING(str);
if (!p->is_wide_char || p->len == 0)
goto done; // by definition well-formed
for (i = 0, n = p->len; i < n; i++) {
c = p->u.str16[i];
if (!is_surrogate(c))
continue;
if (is_lo_surrogate(c) || i + 1 == n)
break;
c = p->u.str16[++i];
if (!is_lo_surrogate(c))
break;
}
if (i < n)
ret = JS_FALSE;
done:
JS_FreeValue(ctx, str);
return ret;
}
|
O1
|
c
|
js_string_isWellFormed:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
callq 0x425ff
movq %rax, 0x8(%rsp)
cmpl $0x6, %edx
jne 0x7b230
movl $0x6, %ebx
xorl %r15d, %r15d
jmp 0x7b2b9
movq 0x8(%rsp), %rcx
movq 0x4(%rcx), %rax
movl $0x1, %ebx
movl $0x1, %r15d
testl %eax, %eax
jns 0x7b2ab
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
je 0x7b2ab
xorl %esi, %esi
movl %esi, %edi
movzwl 0x18(%rcx,%rdi,2), %edi
movl %edi, %r8d
andl $0xf800, %r8d # imm = 0xF800
cmpl $0xd800, %r8d # imm = 0xD800
jne 0x7b298
notl %edi
testl $0xdc00, %edi # imm = 0xDC00
je 0x7b2a2
leal 0x1(%rsi), %edi
cmpl %eax, %edi
je 0x7b2a2
movl %edi, %esi
movzwl 0x18(%rcx,%rsi,2), %r8d
andl $0xfc00, %r8d # imm = 0xFC00
movl %edi, %esi
cmpl $0xdc00, %r8d # imm = 0xDC00
je 0x7b29a
jmp 0x7b2a2
movl %esi, %edi
incl %edi
movl %edi, %esi
cmpl %eax, %edi
jb 0x7b251
xorl %r15d, %r15d
cmpl %eax, %esi
setae %r15b
movq 0x8(%rsp), %rsi
movq 0x18(%r14), %rdi
callq 0x1d8c6
movq %r15, %rax
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
js_string_isWellFormed:
push r15
push r14
push rbx
sub rsp, 10h
mov r14, rdi
call JS_ToStringCheckObject
mov [rsp+28h+var_20], rax
cmp edx, 6
jnz short loc_7B230
mov ebx, 6
xor r15d, r15d
jmp loc_7B2B9
loc_7B230:
mov rcx, [rsp+28h+var_20]
mov rax, [rcx+4]
mov ebx, 1
mov r15d, 1
test eax, eax
jns short loc_7B2AB
and eax, 7FFFFFFFh
jz short loc_7B2AB
xor esi, esi
loc_7B251:
mov edi, esi
movzx edi, word ptr [rcx+rdi*2+18h]
mov r8d, edi
and r8d, 0F800h
cmp r8d, 0D800h
jnz short loc_7B298
not edi
test edi, 0DC00h
jz short loc_7B2A2
lea edi, [rsi+1]
cmp edi, eax
jz short loc_7B2A2
mov esi, edi
movzx r8d, word ptr [rcx+rsi*2+18h]
and r8d, 0FC00h
mov esi, edi
cmp r8d, 0DC00h
jz short loc_7B29A
jmp short loc_7B2A2
loc_7B298:
mov edi, esi
loc_7B29A:
inc edi
mov esi, edi
cmp edi, eax
jb short loc_7B251
loc_7B2A2:
xor r15d, r15d
cmp esi, eax
setnb r15b
loc_7B2AB:
mov rsi, [rsp+28h+var_20]
mov rdi, [r14+18h]
call JS_FreeValueRT
loc_7B2B9:
mov rax, r15
mov rdx, rbx
add rsp, 10h
pop rbx
pop r14
pop r15
retn
|
_BOOL8 js_string_isWellFormed(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v15; // rdx
_BOOL8 v16; // r15
long long v17; // rax
unsigned int v18; // eax
unsigned int v19; // esi
unsigned int v20; // edi
unsigned long long v22; // [rsp+8h] [rbp-20h]
v22 = JS_ToStringCheckObject(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
if ( (_DWORD)v15 == 6 )
return 0LL;
v17 = *(_QWORD *)(v22 + 4);
v16 = 1LL;
if ( (int)v17 < 0 )
{
v18 = v17 & 0x7FFFFFFF;
if ( v18 )
{
v19 = 0;
while ( 1 )
{
if ( (*(_WORD *)(v22 + 2LL * v19 + 24) & 0xF800) == 0xD800 )
{
if ( (~*(_WORD *)(v22 + 2LL * v19 + 24) & 0xDC00) == 0
|| (v20 = v19 + 1, v19 + 1 == v18)
|| (++v19, (*(_WORD *)(v22 + 2LL * v20 + 24) & 0xFC00) != 0xDC00) )
{
LABEL_13:
v16 = v19 >= v18;
break;
}
}
else
{
v20 = v19;
}
v19 = v20 + 1;
if ( v20 + 1 >= v18 )
goto LABEL_13;
}
}
}
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)v22, v15);
return v16;
}
|
js_string_isWellFormed:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV R14,RDI
CALL 0x001425ff
MOV qword ptr [RSP + 0x8],RAX
CMP EDX,0x6
JNZ 0x0017b230
MOV EBX,0x6
XOR R15D,R15D
JMP 0x0017b2b9
LAB_0017b230:
MOV RCX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RCX + 0x4]
MOV EBX,0x1
MOV R15D,0x1
TEST EAX,EAX
JNS 0x0017b2ab
AND EAX,0x7fffffff
JZ 0x0017b2ab
XOR ESI,ESI
LAB_0017b251:
MOV EDI,ESI
MOVZX EDI,word ptr [RCX + RDI*0x2 + 0x18]
MOV R8D,EDI
AND R8D,0xf800
CMP R8D,0xd800
JNZ 0x0017b298
NOT EDI
TEST EDI,0xdc00
JZ 0x0017b2a2
LEA EDI,[RSI + 0x1]
CMP EDI,EAX
JZ 0x0017b2a2
MOV ESI,EDI
MOVZX R8D,word ptr [RCX + RSI*0x2 + 0x18]
AND R8D,0xfc00
MOV ESI,EDI
CMP R8D,0xdc00
JZ 0x0017b29a
JMP 0x0017b2a2
LAB_0017b298:
MOV EDI,ESI
LAB_0017b29a:
INC EDI
MOV ESI,EDI
CMP EDI,EAX
JC 0x0017b251
LAB_0017b2a2:
XOR R15D,R15D
CMP ESI,EAX
SETNC R15B
LAB_0017b2ab:
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [R14 + 0x18]
CALL 0x0011d8c6
LAB_0017b2b9:
MOV RAX,R15
MOV RDX,RBX
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
bool js_string_isWellFormed(long param_1)
{
uint uVar1;
ushort uVar2;
uint uVar3;
long lVar4;
uint uVar5;
bool bVar6;
int1 auVar7 [12];
auVar7 = JS_ToStringCheckObject();
lVar4 = auVar7._0_8_;
if (auVar7._8_4_ == 6) {
bVar6 = false;
}
else {
bVar6 = true;
uVar3 = (uint)*(ulong *)(lVar4 + 4);
if (((int)uVar3 < 0) && (uVar3 = uVar3 & 0x7fffffff, (*(ulong *)(lVar4 + 4) & 0x7fffffff) != 0))
{
uVar5 = 0;
do {
uVar2 = *(ushort *)(lVar4 + 0x18 + (ulong)uVar5 * 2);
if (((uVar2 & 0xf800) == 0xd800) &&
((((~uVar2 & 0xdc00) == 0 || (uVar1 = uVar5 + 1, uVar1 == uVar3)) ||
(uVar5 = uVar1, (*(ushort *)(lVar4 + 0x18 + (ulong)uVar1 * 2) & 0xfc00) != 0xdc00))))
break;
uVar5 = uVar5 + 1;
} while (uVar5 < uVar3);
bVar6 = uVar3 <= uVar5;
}
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),lVar4);
}
return bVar6;
}
|
|
6,869 |
nlohmann::json_abi_v3_11_3::detail::binary_reader<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>>>>, parse_json(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&)::json_error_locator>::get_cbor_array(unsigned long, nlohmann::json_abi_v3_11_3::detail::cbor_tag_handler_t)
|
monkey531[P]llama/common/./json.hpp
|
bool get_cbor_array(const std::size_t len,
const cbor_tag_handler_t tag_handler)
{
if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
{
return false;
}
if (len != static_cast<std::size_t>(-1))
{
for (std::size_t i = 0; i < len; ++i)
{
if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
{
return false;
}
}
}
else
{
while (get() != 0xFF)
{
if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler)))
{
return false;
}
}
}
return sax->end_array();
}
|
O0
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::binary_reader<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>>>>, parse_json(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&)::json_error_locator>::get_cbor_array(unsigned long, nlohmann::json_abi_v3_11_3::detail::cbor_tag_handler_t):
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rax), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0x50(%rax)
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x18e317
jmp 0x18e321
movb $0x0, 0x37(%rsp)
jmp 0x18e3c7
cmpq $-0x1, 0x20(%rsp)
je 0x18e378
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x18e376
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl $0x1, %esi
callq 0x1892f0
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x18e35d
jmp 0x18e364
movb $0x0, 0x37(%rsp)
jmp 0x18e3c7
jmp 0x18e366
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x18e332
jmp 0x18e3b2
jmp 0x18e37a
movq 0x8(%rsp), %rdi
callq 0x18b910
cmpl $0xff, %eax
je 0x18e3b0
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %edx
xorl %esi, %esi
callq 0x1892f0
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x18e3a7
jmp 0x18e3ae
movb $0x0, 0x37(%rsp)
jmp 0x18e3c7
jmp 0x18e37a
jmp 0x18e3b2
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
|
_ZN8nlohmann16json_abi_v3_11_36detail13binary_readerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEZL10parse_jsonRSL_RKSL_RSF_E18json_error_locatorE14get_cbor_arrayEmNS1_18cbor_tag_handler_tE:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_18], rsi
mov [rsp+38h+var_1C], edx
mov rax, [rsp+38h+var_10]
mov [rsp+38h+var_30], rax
mov rdi, [rax+28h]
mov rsi, [rsp+38h+var_18]
mov rax, [rdi]
call qword ptr [rax+50h]
xor al, 0FFh
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_18E317
jmp short loc_18E321
loc_18E317:
mov [rsp+38h+var_1], 0
jmp loc_18E3C7
loc_18E321:
cmp [rsp+38h+var_18], 0FFFFFFFFFFFFFFFFh
jz short loc_18E378
mov [rsp+38h+var_28], 0
loc_18E332:
mov rax, [rsp+38h+var_28]
cmp rax, [rsp+38h+var_18]
jnb short loc_18E376
mov rdi, [rsp+38h+var_30]
mov edx, [rsp+38h+var_1C]
mov esi, 1
call _ZN8nlohmann16json_abi_v3_11_36detail13binary_readerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEZL10parse_jsonRSL_RKSL_RSF_E18json_error_locatorE19parse_cbor_internalEbNS1_18cbor_tag_handler_tE; nlohmann::json_abi_v3_11_3::detail::binary_reader<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>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,std::string> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)::json_error_locator>::parse_cbor_internal(bool,nlohmann::json_abi_v3_11_3::detail::cbor_tag_handler_t)
xor al, 0FFh
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_18E35D
jmp short loc_18E364
loc_18E35D:
mov [rsp+38h+var_1], 0
jmp short loc_18E3C7
loc_18E364:
jmp short $+2
loc_18E366:
mov rax, [rsp+38h+var_28]
add rax, 1
mov [rsp+38h+var_28], rax
jmp short loc_18E332
loc_18E376:
jmp short loc_18E3B2
loc_18E378:
jmp short $+2
loc_18E37A:
mov rdi, [rsp+38h+var_30]
call _ZN8nlohmann16json_abi_v3_11_36detail13binary_readerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEZL10parse_jsonRSL_RKSL_RSF_E18json_error_locatorE3getEv; nlohmann::json_abi_v3_11_3::detail::binary_reader<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>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,std::string> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)::json_error_locator>::get(void)
cmp eax, 0FFh
jz short loc_18E3B0
mov rdi, [rsp+38h+var_30]
mov edx, [rsp+38h+var_1C]
xor esi, esi
call _ZN8nlohmann16json_abi_v3_11_36detail13binary_readerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEZL10parse_jsonRSL_RKSL_RSF_E18json_error_locatorE19parse_cbor_internalEbNS1_18cbor_tag_handler_tE; nlohmann::json_abi_v3_11_3::detail::binary_reader<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>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,std::string> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)::json_error_locator>::parse_cbor_internal(bool,nlohmann::json_abi_v3_11_3::detail::cbor_tag_handler_t)
xor al, 0FFh
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_18E3A7
jmp short loc_18E3AE
loc_18E3A7:
mov [rsp+38h+var_1], 0
jmp short loc_18E3C7
loc_18E3AE:
jmp short loc_18E37A
loc_18E3B0:
jmp short $+2
loc_18E3B2:
mov rax, [rsp+38h+var_30]
mov rdi, [rax+28h]
mov rax, [rdi]
call qword ptr [rax+58h]
and al, 1
mov [rsp+38h+var_1], al
loc_18E3C7:
mov al, [rsp+38h+var_1]
and al, 1
add rsp, 38h
retn
|
char nlohmann::json_abi_v3_11_3::detail::binary_reader<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>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,std::string> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>&)::json_error_locator>::get_cbor_array(
long long a1,
unsigned long long a2,
unsigned int a3)
{
long long v3; // rcx
int v4; // r8d
int v5; // r9d
long long v6; // rcx
int v7; // r8d
int v8; // r9d
unsigned long long i; // [rsp+10h] [rbp-28h]
if ( ((*(long long ( **)(_QWORD, unsigned long long))(**(_QWORD **)(a1 + 40) + 80LL))(*(_QWORD *)(a1 + 40), a2) & 1) == 0 )
return 0;
if ( a2 == -1LL )
{
while ( (unsigned int)nlohmann::json_abi_v3_11_3::detail::binary_reader<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>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,std::string> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>&)::json_error_locator>::get(a1) != 255 )
{
if ( (nlohmann::json_abi_v3_11_3::detail::binary_reader<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>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,std::string> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>&)::json_error_locator>::parse_cbor_internal(
a1,
0,
a3,
v6,
v7,
v8) & 1) == 0 )
return 0;
}
}
else
{
for ( i = 0LL; i < a2; ++i )
{
if ( (nlohmann::json_abi_v3_11_3::detail::binary_reader<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>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,std::string> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>&)::json_error_locator>::parse_cbor_internal(
a1,
1,
a3,
v3,
v4,
v5) & 1) == 0 )
return 0;
}
}
return (*(long long ( **)(_QWORD))(**(_QWORD **)(a1 + 40) + 88LL))(*(_QWORD *)(a1 + 40)) & 1;
}
|
~pair:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RDI
ADD RDI,0x20
CALL 0x001510c0
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001510c0
ADD RSP,0x18
RET
|
/* std::pair<std::__cxx11::string, std::__cxx11::string >::~pair() */
void __thiscall
std::pair<std::__cxx11::string,std::__cxx11::string>::~pair
(pair<std::__cxx11::string,std::__cxx11::string> *this)
{
std::__cxx11::string::~string((string *)(this + 0x20));
std::__cxx11::string::~string((string *)this);
return;
}
|
|
6,870 |
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::vector<char, std::allocator<char>>>>>::get_token_string() const
|
monkey531[P]llama/common/./json.hpp
|
std::string get_token_string() const
{
// escape control characters
std::string result;
for (const auto c : token_string)
{
if (static_cast<unsigned char>(c) <= '\x1F')
{
// escape control characters
std::array<char, 9> cs{{}};
static_cast<void>((std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
result += cs.data();
}
else
{
// add character as is
result.push_back(static_cast<std::string::value_type>(c));
}
}
return result;
}
|
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::vector<char, std::allocator<char>>>>>::get_token_string() const:
subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0x67(%rsp)
callq 0x5a5f0
movq 0x20(%rsp), %rax
addq $0x38, %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0xa73e0
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0xa7410
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xbbc20
testb $0x1, %al
jne 0x204a13
jmp 0x204acb
leaq 0x50(%rsp), %rdi
callq 0xbbc60
movb (%rax), %al
movb %al, 0x47(%rsp)
movzbl 0x47(%rsp), %eax
cmpl $0x1f, %eax
jg 0x204aa7
movb $0x0, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xbbc70
movq 0x8(%rsp), %rdi
movq %rax, (%rsp)
callq 0xbbc80
movq (%rsp), %rdi
movq %rax, %rsi
movzbl 0x47(%rsp), %ecx
leaq 0xb210(%rip), %rdx # 0x20fc7b
xorl %eax, %eax
callq 0x5a900
movq 0x8(%rsp), %rdi
callq 0xbbc70
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x5a230
jmp 0x204a8b
jmp 0x204aba
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x5b568
jmp 0x204aeb
movq 0x10(%rsp), %rdi
movsbl 0x47(%rsp), %esi
callq 0x5b450
jmp 0x204ab8
jmp 0x204aba
jmp 0x204abc
leaq 0x50(%rsp), %rdi
callq 0xbbc90
jmp 0x2049fb
movb $0x1, 0x67(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x204ae1
movq 0x10(%rsp), %rdi
callq 0x5b568
movq 0x18(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x5abc0
nopw %cs:(%rax,%rax)
nop
|
_ZNK8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcS5_IcSA_EEEEEE16get_token_stringEv:
sub rsp, 78h
mov [rsp+78h+var_68], rdi
mov rax, rdi
mov [rsp+78h+var_60], rax
mov [rsp+78h+var_8], rdi
mov [rsp+78h+var_10], rsi
mov rax, [rsp+78h+var_10]
mov [rsp+78h+var_58], rax
mov [rsp+78h+var_11], 0
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov rax, [rsp+78h+var_58]
add rax, 38h ; '8'
mov [rsp+78h+var_20], rax
mov rdi, [rsp+78h+var_20]
call _ZNKSt6vectorIcSaIcEE5beginEv; std::vector<char>::begin(void)
mov [rsp+78h+var_28], rax
mov rdi, [rsp+78h+var_20]
call _ZNKSt6vectorIcSaIcEE3endEv; std::vector<char>::end(void)
mov [rsp+78h+var_30], rax
loc_2049FB:
lea rdi, [rsp+78h+var_28]
lea rsi, [rsp+78h+var_30]
call _ZN9__gnu_cxxneIPKcSt6vectorIcSaIcEEEEbRKNS_17__normal_iteratorIT_T0_EESB_; __gnu_cxx::operator!=<char const*,std::vector<char>>(__gnu_cxx::__normal_iterator<char const*,std::vector<char>> const&,__gnu_cxx::__normal_iterator<char const*,std::vector<char>> const&)
test al, 1
jnz short loc_204A13
jmp loc_204ACB
loc_204A13:
lea rdi, [rsp+78h+var_28]
call _ZNK9__gnu_cxx17__normal_iteratorIPKcSt6vectorIcSaIcEEEdeEv; __gnu_cxx::__normal_iterator<char const*,std::vector<char>>::operator*(void)
mov al, [rax]
mov [rsp+78h+var_31], al
movzx eax, [rsp+78h+var_31]
cmp eax, 1Fh
jg short loc_204AA7
mov [rsp+78h+var_38], 0
mov [rsp+78h+var_40], 0
lea rdi, [rsp+78h+var_40]
mov [rsp+78h+var_70], rdi
call _ZNSt5arrayIcLm9EE4dataEv; std::array<char,9ul>::data(void)
mov rdi, [rsp+78h+var_70]
mov [rsp+78h+var_78], rax
call _ZNKSt5arrayIcLm9EE4sizeEv; std::array<char,9ul>::size(void)
mov rdi, [rsp+78h+var_78]
mov rsi, rax
movzx ecx, [rsp+78h+var_31]
lea rdx, aU4x; "<U+%.4X>"
xor eax, eax
call _snprintf
mov rdi, [rsp+78h+var_70]
call _ZNSt5arrayIcLm9EE4dataEv; std::array<char,9ul>::data(void)
mov rdi, [rsp+78h+var_68]
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEpLEPKc; std::string::operator+=(char const*)
jmp short $+2
loc_204A8B:
jmp short loc_204ABA
mov rdi, [rsp+arg_8]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_204AEB
loc_204AA7:
mov rdi, [rsp+78h+var_68]
movsx esi, [rsp+78h+var_31]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
jmp short $+2
loc_204AB8:
jmp short $+2
loc_204ABA:
jmp short $+2
loc_204ABC:
lea rdi, [rsp+78h+var_28]
call _ZN9__gnu_cxx17__normal_iteratorIPKcSt6vectorIcSaIcEEEppEv; __gnu_cxx::__normal_iterator<char const*,std::vector<char>>::operator++(void)
jmp loc_2049FB
loc_204ACB:
mov [rsp+78h+var_11], 1
test [rsp+78h+var_11], 1
jnz short loc_204AE1
mov rdi, [rsp+78h+var_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_204AE1:
mov rax, [rsp+78h+var_60]
add rsp, 78h
retn
loc_204AEB:
mov rdi, [rsp+arg_28]
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::vector<char>>>>::get_token_string(
long long a1,
long long a2)
{
long long v2; // rax
long long v3; // rax
long long v5; // [rsp+0h] [rbp-78h]
long long v6; // [rsp+38h] [rbp-40h] BYREF
char v7; // [rsp+40h] [rbp-38h]
unsigned __int8 v8; // [rsp+47h] [rbp-31h]
long long v9; // [rsp+48h] [rbp-30h] BYREF
_QWORD v10[2]; // [rsp+50h] [rbp-28h] BYREF
char v11; // [rsp+67h] [rbp-11h]
long long v12; // [rsp+68h] [rbp-10h]
long long v13; // [rsp+70h] [rbp-8h]
v13 = a1;
v12 = a2;
v11 = 0;
std::string::basic_string(a1);
v10[1] = a2 + 56;
v10[0] = std::vector<char>::begin(a2 + 56);
v9 = std::vector<char>::end(a2 + 56);
while ( __gnu_cxx::operator!=<char const*,std::vector<char>>((long long)v10, (long long)&v9) )
{
v8 = *(_BYTE *)__gnu_cxx::__normal_iterator<char const*,std::vector<char>>::operator*((long long)v10);
if ( v8 > 0x1Fu )
{
std::string::push_back(a1, (unsigned int)(char)v8);
}
else
{
v7 = 0;
v6 = 0LL;
v5 = std::array<char,9ul>::data((long long)&v6);
v2 = std::array<char,9ul>::size();
snprintf(v5, v2, "<U+%.4X>", v8);
v3 = std::array<char,9ul>::data((long long)&v6);
std::string::operator+=(a1, v3);
}
__gnu_cxx::__normal_iterator<char const*,std::vector<char>>::operator++(v10);
}
return a1;
}
|
_Vector_impl:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x002049d0
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x002049e0
ADD RSP,0x18
RET
|
/* std::_Vector_base<std::unique_ptr<llama_adapter_lora, llama_adapter_lora_deleter>,
std::allocator<std::unique_ptr<llama_adapter_lora, llama_adapter_lora_deleter> >
>::_Vector_impl::_Vector_impl() */
void __thiscall
std::
_Vector_base<std::unique_ptr<llama_adapter_lora,llama_adapter_lora_deleter>,std::allocator<std::unique_ptr<llama_adapter_lora,llama_adapter_lora_deleter>>>
::_Vector_impl::_Vector_impl(_Vector_impl *this)
{
allocator<std::unique_ptr<llama_adapter_lora,llama_adapter_lora_deleter>>::allocator
((allocator<std::unique_ptr<llama_adapter_lora,llama_adapter_lora_deleter>> *)this);
_Vector_base<std::unique_ptr<llama_adapter_lora,llama_adapter_lora_deleter>,std::allocator<std::unique_ptr<llama_adapter_lora,llama_adapter_lora_deleter>>>
::_Vector_impl_data::_Vector_impl_data((_Vector_impl_data *)this);
return;
}
|
|
6,871 |
ps_fetch_from_1_to_8_bytes
|
eloqsql/libmariadb/libmariadb/ma_stmt_codec.c
|
void ps_fetch_from_1_to_8_bytes(MYSQL_BIND *r_param, const MYSQL_FIELD * const field,
unsigned char **row, unsigned int byte_count)
{
my_bool is_unsigned= test(field->flags & UNSIGNED_FLAG);
r_param->buffer_length= byte_count;
switch (byte_count) {
case 1:
*(uchar *)r_param->buffer= **row;
*r_param->error= is_unsigned != r_param->is_unsigned && *(uchar *)r_param->buffer > INT_MAX8;
break;
case 2:
shortstore(r_param->buffer, ((ushort) sint2korr(*row)));
*r_param->error= is_unsigned != r_param->is_unsigned && *(ushort *)r_param->buffer > INT_MAX16;
break;
case 4:
{
longstore(r_param->buffer, ((uint32)sint4korr(*row)));
*r_param->error= is_unsigned != r_param->is_unsigned && *(uint32 *)r_param->buffer > INT_MAX32;
}
break;
case 8:
{
ulonglong val= (ulonglong)sint8korr(*row);
longlongstore(r_param->buffer, val);
*r_param->error= is_unsigned != r_param->is_unsigned && val > LONGLONG_MAX ;
}
break;
default:
r_param->buffer_length= 0;
break;
}
(*row)+= byte_count;
}
|
O0
|
c
|
ps_fetch_from_1_to_8_bytes:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x64(%rax), %eax
andl $0x20, %eax
shrl $0x5, %eax
movb %al, -0x1d(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movl -0x1c(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x38(%rbp)
subl $0x7, %eax
ja 0x51d71
movq -0x38(%rbp), %rax
leaq 0x80401(%rip), %rcx # 0xd1e40
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movq (%rax), %rax
movb (%rax), %cl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movb %cl, (%rax)
movsbl -0x1d(%rbp), %ecx
movq -0x8(%rbp), %rax
movsbl 0x65(%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x39(%rbp)
je 0x51a84
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x7f, %eax
setg %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movb %cl, (%rax)
jmp 0x51d7d
jmp 0x51a9f
movq -0x18(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
cwtl
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x1(%rcx), %ecx
movswl %cx, %ecx
shll $0x8, %ecx
addl %ecx, %eax
movzwl %ax, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movb %cl, (%rax)
movl -0x24(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movb %cl, 0x1(%rax)
movsbl -0x1d(%rbp), %ecx
movq -0x8(%rbp), %rax
movsbl 0x65(%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x3a(%rbp)
je 0x51b10
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movzwl (%rax), %eax
cmpl $0x7fff, %eax # imm = 0x7FFF
setg %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movb %cl, (%rax)
jmp 0x51d7d
jmp 0x51b2b
movq -0x18(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
addl %ecx, %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x3(%rcx), %ecx
movswl %cx, %ecx
shll $0x18, %ecx
addl %ecx, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
addl %ecx, %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x3(%rcx), %ecx
movswl %cx, %ecx
shll $0x18, %ecx
addl %ecx, %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movb %cl, 0x1(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
addl %ecx, %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x3(%rcx), %ecx
movswl %cx, %ecx
shll $0x18, %ecx
addl %ecx, %eax
shrl $0x10, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movb %cl, 0x2(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
addl %ecx, %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x3(%rcx), %ecx
movswl %cx, %ecx
shll $0x18, %ecx
addl %ecx, %eax
shrl $0x18, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movb %cl, 0x3(%rax)
movsbl -0x1d(%rbp), %ecx
movq -0x8(%rbp), %rax
movsbl 0x65(%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x3b(%rbp)
je 0x51c86
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %eax
cmpq $0x7fffffff, %rax # imm = 0x7FFFFFFF
setg %al
movb %al, -0x3b(%rbp)
movb -0x3b(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movb %cl, (%rax)
jmp 0x51d7d
movq -0x18(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
addl %ecx, %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x3(%rcx), %ecx
shll $0x18, %ecx
addl %ecx, %eax
movl %eax, %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x4(%rcx), %ecx
movq -0x18(%rbp), %rdx
movq (%rdx), %rdx
movzbl 0x5(%rdx), %edx
shll $0x8, %edx
addl %edx, %ecx
movq -0x18(%rbp), %rdx
movq (%rdx), %rdx
movzbl 0x6(%rdx), %edx
shll $0x10, %edx
addl %edx, %ecx
movq -0x18(%rbp), %rdx
movq (%rdx), %rdx
movzbl 0x7(%rdx), %edx
shll $0x18, %edx
addl %edx, %ecx
movl %ecx, %ecx
shlq $0x20, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movsbl -0x1d(%rbp), %ecx
movq -0x8(%rbp), %rax
movsbl 0x65(%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x3c(%rbp)
je 0x51d5b
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, -0x30(%rbp)
seta %al
movb %al, -0x3c(%rbp)
movb -0x3c(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movb %cl, (%rax)
jmp 0x51d7d
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ps_fetch_from_1_to_8_bytes:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov rax, [rbp+var_10]
mov eax, [rax+64h]
and eax, 20h
shr eax, 5
mov [rbp+var_1D], al
mov eax, [rbp+var_1C]
mov ecx, eax
mov rax, [rbp+var_8]
mov [rax+40h], rcx
mov eax, [rbp+var_1C]
dec eax; switch 8 cases
mov ecx, eax
mov [rbp+var_38], rcx
sub eax, 7
ja def_51A46; jumptable 0000000000051A46 default case, cases 3,5-7
mov rax, [rbp+var_38]
lea rcx, jpt_51A46
movsxd rax, ds:(jpt_51A46 - 0D1E40h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_51A48:
mov rax, [rbp+var_18]; jumptable 0000000000051A46 case 1
mov rax, [rax]
mov cl, [rax]
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov [rax], cl
movsx ecx, [rbp+var_1D]
mov rax, [rbp+var_8]
movsx edx, byte ptr [rax+65h]
xor eax, eax
cmp ecx, edx
mov [rbp+var_39], al
jz short loc_51A84
mov rax, [rbp+var_8]
mov rax, [rax+10h]
movzx eax, byte ptr [rax]
cmp eax, 7Fh
setnle al
mov [rbp+var_39], al
loc_51A84:
mov al, [rbp+var_39]
and al, 1
movzx eax, al
mov cl, al
mov rax, [rbp+var_8]
mov rax, [rax+18h]
mov [rax], cl
jmp loc_51D7D
loc_51A9D:
jmp short $+2; jumptable 0000000000051A46 case 2
loc_51A9F:
mov rax, [rbp+var_18]
mov rax, [rax]
movzx eax, byte ptr [rax]
cwde
mov rcx, [rbp+var_18]
mov rcx, [rcx]
movzx ecx, byte ptr [rcx+1]
movsx ecx, cx
shl ecx, 8
add eax, ecx
movzx eax, ax
mov [rbp+var_24], eax
mov eax, [rbp+var_24]
mov cl, al
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov [rax], cl
mov eax, [rbp+var_24]
shr eax, 8
mov cl, al
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov [rax+1], cl
movsx ecx, [rbp+var_1D]
mov rax, [rbp+var_8]
movsx edx, byte ptr [rax+65h]
xor eax, eax
cmp ecx, edx
mov [rbp+var_3A], al
jz short loc_51B10
mov rax, [rbp+var_8]
mov rax, [rax+10h]
movzx eax, word ptr [rax]
cmp eax, 7FFFh
setnle al
mov [rbp+var_3A], al
loc_51B10:
mov al, [rbp+var_3A]
and al, 1
movzx eax, al
mov cl, al
mov rax, [rbp+var_8]
mov rax, [rax+18h]
mov [rax], cl
jmp loc_51D7D
loc_51B29:
jmp short $+2; jumptable 0000000000051A46 case 4
loc_51B2B:
mov rax, [rbp+var_18]
mov rax, [rax]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_18]
mov rcx, [rcx]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
add eax, ecx
mov rcx, [rbp+var_18]
mov rcx, [rcx]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
add eax, ecx
mov rcx, [rbp+var_18]
mov rcx, [rcx]
movzx ecx, byte ptr [rcx+3]
movsx ecx, cx
shl ecx, 18h
add eax, ecx
mov cl, al
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov [rax], cl
mov rax, [rbp+var_18]
mov rax, [rax]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_18]
mov rcx, [rcx]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
add eax, ecx
mov rcx, [rbp+var_18]
mov rcx, [rcx]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
add eax, ecx
mov rcx, [rbp+var_18]
mov rcx, [rcx]
movzx ecx, byte ptr [rcx+3]
movsx ecx, cx
shl ecx, 18h
add eax, ecx
shr eax, 8
mov cl, al
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov [rax+1], cl
mov rax, [rbp+var_18]
mov rax, [rax]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_18]
mov rcx, [rcx]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
add eax, ecx
mov rcx, [rbp+var_18]
mov rcx, [rcx]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
add eax, ecx
mov rcx, [rbp+var_18]
mov rcx, [rcx]
movzx ecx, byte ptr [rcx+3]
movsx ecx, cx
shl ecx, 18h
add eax, ecx
shr eax, 10h
mov cl, al
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov [rax+2], cl
mov rax, [rbp+var_18]
mov rax, [rax]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_18]
mov rcx, [rcx]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
add eax, ecx
mov rcx, [rbp+var_18]
mov rcx, [rcx]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
add eax, ecx
mov rcx, [rbp+var_18]
mov rcx, [rcx]
movzx ecx, byte ptr [rcx+3]
movsx ecx, cx
shl ecx, 18h
add eax, ecx
shr eax, 18h
mov cl, al
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov [rax+3], cl
movsx ecx, [rbp+var_1D]
mov rax, [rbp+var_8]
movsx edx, byte ptr [rax+65h]
xor eax, eax
cmp ecx, edx
mov [rbp+var_3B], al
jz short loc_51C86
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov eax, [rax]
cmp rax, 7FFFFFFFh
setnle al
mov [rbp+var_3B], al
loc_51C86:
mov al, [rbp+var_3B]
and al, 1
movzx eax, al
mov cl, al
mov rax, [rbp+var_8]
mov rax, [rax+18h]
mov [rax], cl
jmp loc_51D7D
loc_51C9F:
mov rax, [rbp+var_18]; jumptable 0000000000051A46 case 8
mov rax, [rax]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_18]
mov rcx, [rcx]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
add eax, ecx
mov rcx, [rbp+var_18]
mov rcx, [rcx]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
add eax, ecx
mov rcx, [rbp+var_18]
mov rcx, [rcx]
movzx ecx, byte ptr [rcx+3]
shl ecx, 18h
add eax, ecx
mov eax, eax
mov rcx, [rbp+var_18]
mov rcx, [rcx]
movzx ecx, byte ptr [rcx+4]
mov rdx, [rbp+var_18]
mov rdx, [rdx]
movzx edx, byte ptr [rdx+5]
shl edx, 8
add ecx, edx
mov rdx, [rbp+var_18]
mov rdx, [rdx]
movzx edx, byte ptr [rdx+6]
shl edx, 10h
add ecx, edx
mov rdx, [rbp+var_18]
mov rdx, [rdx]
movzx edx, byte ptr [rdx+7]
shl edx, 18h
add ecx, edx
mov ecx, ecx
shl rcx, 20h
add rax, rcx
mov [rbp+var_30], rax
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov rcx, [rbp+var_30]
mov [rax], rcx
movsx ecx, [rbp+var_1D]
mov rax, [rbp+var_8]
movsx edx, byte ptr [rax+65h]
xor eax, eax
cmp ecx, edx
mov [rbp+var_3C], al
jz short loc_51D5B
mov rax, 7FFFFFFFFFFFFFFFh
cmp [rbp+var_30], rax
setnbe al
mov [rbp+var_3C], al
loc_51D5B:
mov al, [rbp+var_3C]
and al, 1
movzx eax, al
mov cl, al
mov rax, [rbp+var_8]
mov rax, [rax+18h]
mov [rax], cl
jmp short loc_51D7D
def_51A46:
mov rax, [rbp+var_8]; jumptable 0000000000051A46 default case, cases 3,5-7
mov qword ptr [rax+40h], 0
loc_51D7D:
mov edx, [rbp+var_1C]
mov rax, [rbp+var_18]
mov rcx, [rax]
mov edx, edx
add rcx, rdx
mov [rax], rcx
pop rbp
retn
|
_BYTE ** ps_fetch_from_1_to_8_bytes(long long a1, long long a2, _BYTE **a3, unsigned int a4)
{
_BYTE **result; // rax
bool v5; // [rsp+0h] [rbp-3Ch]
bool v6; // [rsp+1h] [rbp-3Bh]
bool v7; // [rsp+2h] [rbp-3Ah]
bool v8; // [rsp+3h] [rbp-39h]
unsigned long long v9; // [rsp+Ch] [rbp-30h]
char v10; // [rsp+1Fh] [rbp-1Dh]
v10 = (*(_DWORD *)(a2 + 100) & 0x20u) >> 5;
*(_QWORD *)(a1 + 64) = a4;
switch ( a4 )
{
case 1u:
**(_BYTE **)(a1 + 16) = **a3;
v8 = 0;
if ( v10 != *(char *)(a1 + 101) )
v8 = **(unsigned __int8 **)(a1 + 16) > 0x7Fu;
**(_BYTE **)(a1 + 24) = v8;
break;
case 2u:
**(_WORD **)(a1 + 16) = ((unsigned __int8)(*a3)[1] << 8) + (unsigned __int8)**a3;
v7 = 0;
if ( v10 != *(char *)(a1 + 101) )
v7 = **(unsigned __int16 **)(a1 + 16) > 0x7FFFu;
**(_BYTE **)(a1 + 24) = v7;
break;
case 4u:
**(_BYTE **)(a1 + 16) = **a3;
*(_BYTE *)(*(_QWORD *)(a1 + 16) + 1LL) = (unsigned __int16)(((unsigned __int8)(*a3)[1] << 8)
+ (unsigned __int8)**a3) >> 8;
*(_BYTE *)(*(_QWORD *)(a1 + 16) + 2LL) = (((unsigned __int8)(*a3)[3] << 24)
+ ((unsigned __int8)(*a3)[2] << 16)
+ ((unsigned __int8)(*a3)[1] << 8)
+ (unsigned int)(unsigned __int8)**a3) >> 16;
*(_BYTE *)(*(_QWORD *)(a1 + 16) + 3LL) = (((unsigned __int8)(*a3)[3] << 24)
+ ((unsigned __int8)(*a3)[2] << 16)
+ ((unsigned __int8)(*a3)[1] << 8)
+ (unsigned int)(unsigned __int8)**a3) >> 24;
v6 = 0;
if ( v10 != *(char *)(a1 + 101) )
v6 = **(unsigned int **)(a1 + 16) > 0x7FFFFFFFuLL;
**(_BYTE **)(a1 + 24) = v6;
break;
case 8u:
v9 = ((unsigned long long)(((unsigned __int8)(*a3)[7] << 24)
+ ((unsigned __int8)(*a3)[6] << 16)
+ ((unsigned __int8)(*a3)[5] << 8)
+ (unsigned int)(unsigned __int8)(*a3)[4]) << 32)
+ ((unsigned __int8)(*a3)[3] << 24)
+ ((unsigned __int8)(*a3)[2] << 16)
+ ((unsigned __int8)(*a3)[1] << 8)
+ (unsigned int)(unsigned __int8)**a3;
**(_QWORD **)(a1 + 16) = v9;
v5 = 0;
if ( v10 != *(char *)(a1 + 101) )
v5 = v9 > 0x7FFFFFFFFFFFFFFFLL;
**(_BYTE **)(a1 + 24) = v5;
break;
default:
*(_QWORD *)(a1 + 64) = 0LL;
break;
}
result = a3;
*a3 += a4;
return result;
}
|
ps_fetch_from_1_to_8_bytes:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x64]
AND EAX,0x20
SHR EAX,0x5
MOV byte ptr [RBP + -0x1d],AL
MOV EAX,dword ptr [RBP + -0x1c]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x40],RCX
MOV EAX,dword ptr [RBP + -0x1c]
DEC EAX
MOV ECX,EAX
MOV qword ptr [RBP + -0x38],RCX
SUB EAX,0x7
JA 0x00151d71
MOV RAX,qword ptr [RBP + -0x38]
LEA RCX,[0x1d1e40]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV byte ptr [RAX],CL
MOVSX ECX,byte ptr [RBP + -0x1d]
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EDX,byte ptr [RAX + 0x65]
XOR EAX,EAX
CMP ECX,EDX
MOV byte ptr [RBP + -0x39],AL
JZ 0x00151a84
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x7f
SETG AL
MOV byte ptr [RBP + -0x39],AL
LAB_00151a84:
MOV AL,byte ptr [RBP + -0x39]
AND AL,0x1
MOVZX EAX,AL
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x18]
MOV byte ptr [RAX],CL
JMP 0x00151d7d
caseD_2:
JMP 0x00151a9f
LAB_00151a9f:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOVZX EAX,byte ptr [RAX]
CWDE
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOVZX ECX,byte ptr [RCX + 0x1]
MOVSX ECX,CX
SHL ECX,0x8
ADD EAX,ECX
MOVZX EAX,AX
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x24]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x24]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV byte ptr [RAX + 0x1],CL
MOVSX ECX,byte ptr [RBP + -0x1d]
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EDX,byte ptr [RAX + 0x65]
XOR EAX,EAX
CMP ECX,EDX
MOV byte ptr [RBP + -0x3a],AL
JZ 0x00151b10
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOVZX EAX,word ptr [RAX]
CMP EAX,0x7fff
SETG AL
MOV byte ptr [RBP + -0x3a],AL
LAB_00151b10:
MOV AL,byte ptr [RBP + -0x3a]
AND AL,0x1
MOVZX EAX,AL
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x18]
MOV byte ptr [RAX],CL
JMP 0x00151d7d
caseD_4:
JMP 0x00151b2b
LAB_00151b2b:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
ADD EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
ADD EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOVZX ECX,byte ptr [RCX + 0x3]
MOVSX ECX,CX
SHL ECX,0x18
ADD EAX,ECX
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
ADD EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
ADD EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOVZX ECX,byte ptr [RCX + 0x3]
MOVSX ECX,CX
SHL ECX,0x18
ADD EAX,ECX
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
ADD EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
ADD EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOVZX ECX,byte ptr [RCX + 0x3]
MOVSX ECX,CX
SHL ECX,0x18
ADD EAX,ECX
SHR EAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
ADD EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
ADD EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOVZX ECX,byte ptr [RCX + 0x3]
MOVSX ECX,CX
SHL ECX,0x18
ADD EAX,ECX
SHR EAX,0x18
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV byte ptr [RAX + 0x3],CL
MOVSX ECX,byte ptr [RBP + -0x1d]
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EDX,byte ptr [RAX + 0x65]
XOR EAX,EAX
CMP ECX,EDX
MOV byte ptr [RBP + -0x3b],AL
JZ 0x00151c86
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV EAX,dword ptr [RAX]
CMP RAX,0x7fffffff
SETG AL
MOV byte ptr [RBP + -0x3b],AL
LAB_00151c86:
MOV AL,byte ptr [RBP + -0x3b]
AND AL,0x1
MOVZX EAX,AL
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x18]
MOV byte ptr [RAX],CL
JMP 0x00151d7d
caseD_8:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
ADD EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
ADD EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOVZX ECX,byte ptr [RCX + 0x3]
SHL ECX,0x18
ADD EAX,ECX
MOV EAX,EAX
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOVZX ECX,byte ptr [RCX + 0x4]
MOV RDX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RDX]
MOVZX EDX,byte ptr [RDX + 0x5]
SHL EDX,0x8
ADD ECX,EDX
MOV RDX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RDX]
MOVZX EDX,byte ptr [RDX + 0x6]
SHL EDX,0x10
ADD ECX,EDX
MOV RDX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RDX]
MOVZX EDX,byte ptr [RDX + 0x7]
SHL EDX,0x18
ADD ECX,EDX
MOV ECX,ECX
SHL RCX,0x20
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
MOVSX ECX,byte ptr [RBP + -0x1d]
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EDX,byte ptr [RAX + 0x65]
XOR EAX,EAX
CMP ECX,EDX
MOV byte ptr [RBP + -0x3c],AL
JZ 0x00151d5b
MOV RAX,0x7fffffffffffffff
CMP qword ptr [RBP + -0x30],RAX
SETA AL
MOV byte ptr [RBP + -0x3c],AL
LAB_00151d5b:
MOV AL,byte ptr [RBP + -0x3c]
AND AL,0x1
MOVZX EAX,AL
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x18]
MOV byte ptr [RAX],CL
JMP 0x00151d7d
caseD_3:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x40],0x0
LAB_00151d7d:
MOV EDX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX]
MOV EDX,EDX
ADD RCX,RDX
MOV qword ptr [RAX],RCX
POP RBP
RET
|
void ps_fetch_from_1_to_8_bytes(long param_1,long param_2,long *param_3,uint param_4)
{
char cVar1;
uint uVar2;
ulong uVar3;
bool local_44;
bool local_43;
bool local_42;
bool local_41;
cVar1 = (char)((*(uint *)(param_2 + 100) & 0x20) >> 5);
*(ulong *)(param_1 + 0x40) = (ulong)param_4;
switch(param_4) {
case 1:
**(int1 **)(param_1 + 0x10) = *(int1 *)*param_3;
local_41 = false;
if (cVar1 != *(char *)(param_1 + 0x65)) {
local_41 = 0x7f < **(byte **)(param_1 + 0x10);
}
*(bool *)*(int8 *)(param_1 + 0x18) = local_41;
break;
case 2:
uVar2 = (int)(short)(ushort)*(byte *)*param_3 + (short)(ushort)*(byte *)(*param_3 + 1) * 0x100 &
0xffff;
**(int1 **)(param_1 + 0x10) = (char)uVar2;
*(char *)(*(long *)(param_1 + 0x10) + 1) = (char)(uVar2 >> 8);
local_42 = false;
if (cVar1 != *(char *)(param_1 + 0x65)) {
local_42 = 0x7fff < **(ushort **)(param_1 + 0x10);
}
*(bool *)*(int8 *)(param_1 + 0x18) = local_42;
break;
default:
*(int8 *)(param_1 + 0x40) = 0;
break;
case 4:
**(int1 **)(param_1 + 0x10) = *(int1 *)*param_3;
*(char *)(*(long *)(param_1 + 0x10) + 1) =
(char)((uint)*(byte *)*param_3 + (uint)*(byte *)(*param_3 + 1) * 0x100 >> 8);
*(char *)(*(long *)(param_1 + 0x10) + 2) =
(char)((uint)*(byte *)*param_3 + (uint)*(byte *)(*param_3 + 1) * 0x100 +
(uint)*(byte *)(*param_3 + 2) * 0x10000 >> 0x10);
*(char *)(*(long *)(param_1 + 0x10) + 3) =
(char)((uint)*(byte *)*param_3 + (uint)*(byte *)(*param_3 + 1) * 0x100 +
(uint)*(byte *)(*param_3 + 2) * 0x10000 +
(short)(ushort)*(byte *)(*param_3 + 3) * 0x1000000 >> 0x18);
local_43 = false;
if (cVar1 != *(char *)(param_1 + 0x65)) {
local_43 = 0x7fffffff < **(uint **)(param_1 + 0x10);
}
*(bool *)*(int8 *)(param_1 + 0x18) = local_43;
break;
case 8:
uVar3 = CONCAT44((uint)*(byte *)(*param_3 + 4) + (uint)*(byte *)(*param_3 + 5) * 0x100 +
(uint)*(byte *)(*param_3 + 6) * 0x10000 +
(uint)*(byte *)(*param_3 + 7) * 0x1000000,
(uint)*(byte *)*param_3 + (uint)*(byte *)(*param_3 + 1) * 0x100 +
(uint)*(byte *)(*param_3 + 2) * 0x10000 +
(uint)*(byte *)(*param_3 + 3) * 0x1000000);
**(ulong **)(param_1 + 0x10) = uVar3;
local_44 = cVar1 != *(char *)(param_1 + 0x65) && 0x7fffffffffffffff < uVar3;
*(bool *)*(int8 *)(param_1 + 0x18) = local_44;
}
*param_3 = *param_3 + (ulong)param_4;
return;
}
|
|
6,872 |
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::key() const
|
llama.cpp/common/json.hpp
|
const typename object_t::key_type& key() const
{
JSON_ASSERT(m_object != nullptr);
if (JSON_HEDLEY_LIKELY(m_object->is_object()))
{
return m_it.object_iterator->first;
}
JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", m_object));
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::key() const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0xc6431
movq %rdi, %r14
cmpb $0x1, (%rax)
jne 0xc63d3
movq 0x8(%r14), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x21700
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x580b8(%rip), %rsi # 0x11e4a8
leaq 0x580da(%rip), %rdx # 0x11e4d1
leaq 0x8(%rsp), %rdi
callq 0x2c720
movq (%r14), %rcx
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xcf, %esi
callq 0x8d98a
xorl %ebp, %ebp
leaq 0x9dbce(%rip), %rsi # 0x163ff0
leaq -0x4c49b(%rip), %rdx # 0x79f8e
movq %rbx, %rdi
callq 0x21b50
leaq 0x567e0(%rip), %rdi # 0x11cc18
leaq 0x4efa8(%rip), %rdx # 0x1153e7
leaq 0x5ca32(%rip), %rcx # 0x122e78
movl $0x3519, %esi # imm = 0x3519
xorl %eax, %eax
callq 0x21fe0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xc646c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x211a0
testb %bpl, %bpl
jne 0xc6476
jmp 0xc647e
movq %rax, %r14
movq %rbx, %rdi
callq 0x220a0
movq %r14, %rdi
callq 0x21c10
|
_ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE3keyEv:
push rbp; void *
push r15; int
push r14; __int64
push rbx; int
sub rsp, 28h
mov rax, [rdi]
test rax, rax
jz short loc_C6431
mov r14, rdi
cmp byte ptr [rax], 1
jnz short loc_C63D3
mov rax, [r14+8]
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_C63D3:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+48h+var_30]
mov [r15-10h], r15
lea rsi, aCannotUseKeyFo; "cannot use key() for non-object iterato"...
lea rdx, aCannotUseKeyFo+29h; ""
lea rdi, [rsp+48h+var_40]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rcx, [r14]
mov bpl, 1
lea rdx, [rsp+48h+var_40]
mov rdi, rbx; this
mov esi, 0CFh; int
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_C6431:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAnchorMObjectN+7; "m_object != nullptr"
mov esi, 3519h
xor eax, eax
call _ggml_abort
mov r14, rax
mov rdi, [rsp+48h+var_40]; void *
cmp rdi, r15
jz short loc_C646C
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C646C:
test bpl, bpl
jnz short loc_C6476
jmp short loc_C647E
mov r14, rax
loc_C6476:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_C647E:
mov rdi, r14
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::key(
_QWORD *a1)
{
void *v1; // rbx
char v2; // bp
void *v3; // r15
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
long long v6; // rax
long long v7; // r14
void *v8[2]; // [rsp+8h] [rbp-40h] BYREF
long long v9; // [rsp+18h] [rbp-30h] BYREF
if ( !*a1 )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
13593LL,
"GGML_ASSERT(%s) failed",
"m_object != nullptr");
v7 = v6;
if ( v8[0] != v3 )
operator delete(v8[0], v9 + 1);
if ( v2 )
__cxa_free_exception(v1);
_Unwind_Resume(v7);
}
if ( *(_BYTE *)*a1 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v8[0] = &v9;
std::string::_M_construct<char const*>((long long)v8, "cannot use key() for non-object iterators", (long long)"");
ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
207,
v8);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::invalid_iterator,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return a1[1];
}
|
key:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x001c6431
MOV R14,RDI
CMP byte ptr [RAX],0x1
JNZ 0x001c63d3
MOV RAX,qword ptr [R14 + 0x8]
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001c63d3:
MOV EDI,0x20
CALL 0x00121700
MOV RBX,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_001c63e9:
LEA RSI,[0x21e4a8]
LEA RDX,[0x21e4d1]
LEA RDI,[RSP + 0x8]
CALL 0x0012c720
MOV RCX,qword ptr [R14]
MOV BPL,0x1
LAB_001c6407:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0xcf
CALL 0x0018d98a
XOR EBP,EBP
LEA RSI,[0x263ff0]
LEA RDX,[0x179f8e]
MOV RDI,RBX
CALL 0x00121b50
LAB_001c6431:
LEA RDI,[0x21cc18]
LEA RDX,[0x2153e7]
LEA RCX,[0x222e78]
MOV ESI,0x3519
XOR EAX,EAX
CALL 0x00121fe0
|
/* nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::key() const */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::key(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this)
{
int8 uVar1;
int1 *local_40 [2];
int1 local_30 [16];
if (*(char **)this == (char *)0x0) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",0x3519,
"GGML_ASSERT(%s) failed","m_object != nullptr");
}
if (**(char **)this == '\x01') {
return *(int8 *)(this + 8);
}
uVar1 = __cxa_allocate_exception(0x20);
local_40[0] = local_30;
/* try { // try from 001c63e9 to 001c6400 has its CatchHandler @ 001c6473 */
std::__cxx11::string::_M_construct<char_const*>
(local_40,"cannot use key() for non-object iterators","");
/* try { // try from 001c6407 to 001c6430 has its CatchHandler @ 001c6452 */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0xcf,local_40,*(int8 *)this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&invalid_iterator::typeinfo,exception::~exception);
}
|
|
6,873 |
llava_init_context(common_params*, llama_model*)
|
monkey531[P]llama/examples/llava/qwen2vl-cli.cpp
|
static struct llava_context * llava_init_context(common_params * params, llama_model * model) {
const char * clip_path = params->mmproj.c_str();
auto prompt = params->prompt;
if (prompt.empty()) {
prompt = "describe the image in detail.";
}
auto ctx_clip = clip_model_load(clip_path, /*verbosity=*/ 1);
llama_context_params ctx_params = common_context_params_to_llama(*params);
ctx_params.n_ctx = params->n_ctx < 2048 ? 2048 : params->n_ctx; // we need a longer context size to process image embeddings
llama_context * ctx_llama = llama_init_from_model(model, ctx_params);
if (ctx_llama == NULL) {
LOG_ERR("%s: failed to create the llama_context\n" , __func__);
return NULL;
}
auto * ctx_llava = (struct llava_context *)malloc(sizeof(llava_context));
ctx_llava->ctx_llama = ctx_llama;
ctx_llava->ctx_clip = ctx_clip;
ctx_llava->model = model;
return ctx_llava;
}
|
O3
|
cpp
|
llava_init_context(common_params*, llama_model*):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1000(%rdi), %r15
leaq 0x88(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0xe18(%rdi), %rsi
movq 0xe20(%rdi), %rdx
addq %rsi, %rdx
leaq 0x78(%rsp), %r12
movq %r12, %rdi
callq 0x26600
cmpq $0x0, 0x8(%r12)
jne 0x22f16
leaq 0xe64a9(%rip), %rcx # 0x1093ab
leaq 0x78(%rsp), %rdi
movl $0x1d, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x1e320
movq %r15, %rdi
movl $0x1, %esi
callq 0x2af66
movq %rax, %r15
leaq 0x98(%rsp), %rdi
movq %r14, %rsi
callq 0x98e09
movl 0x4(%r14), %eax
cmpl $0x801, %eax # imm = 0x801
movl $0x800, %ecx # imm = 0x800
cmovgel %eax, %ecx
leaq 0x98(%rsp), %rsi
movl %ecx, (%rsi)
movl $0xf, %ecx
movq %rsp, %rdi
rep movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
callq 0x1d7e0
movq %rax, %r12
testq %rax, %rax
je 0x22f86
movl $0x18, %edi
callq 0x1e010
movq %rax, %r14
movq %r12, 0x8(%rax)
movq %r15, (%rax)
movq %rbx, 0x10(%rax)
jmp 0x22fbc
leaq 0x13491b(%rip), %rax # 0x1578a8
cmpl $0x0, (%rax)
js 0x22fb9
callq 0xefaeb
xorl %r14d, %r14d
leaq 0xe6428(%rip), %rdx # 0x1093c9
leaq 0xe6449(%rip), %rcx # 0x1093f1
movq %rax, %rdi
movl $0x4, %esi
xorl %eax, %eax
callq 0xefb88
jmp 0x22fbc
xorl %r14d, %r14d
movq 0x78(%rsp), %rdi
cmpq %r13, %rdi
je 0x22fd6
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x1dc50
movq %r14, %rax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x22ff0
jmp 0x22ff0
jmp 0x22ff0
movq %rax, %rbx
movq 0x78(%rsp), %rdi
cmpq %r13, %rdi
je 0x2300d
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x1dc50
movq %rbx, %rdi
callq 0x1e660
|
_ZL18llava_init_contextP13common_paramsP11llama_model:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 110h
mov rbx, rsi
mov r14, rdi
mov r15, [rdi+1000h]
lea r13, [rsp+138h+var_B0]
mov [r13-10h], r13
mov rsi, [rdi+0E18h]
mov rdx, [rdi+0E20h]
add rdx, rsi
lea r12, [rsp+138h+var_C0]
mov rdi, r12
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
cmp qword ptr [r12+8], 0
jnz short loc_22F16
lea rcx, aDescribeTheIma; "describe the image in detail."
lea rdi, [rsp+138h+var_C0]
mov r8d, 1Dh
xor esi, esi
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
loc_22F16:
mov rdi, r15
mov esi, 1
call clip_model_load
mov r15, rax
lea rdi, [rsp+138h+var_A0]
mov rsi, r14
call _Z30common_context_params_to_llamaRK13common_params; common_context_params_to_llama(common_params const&)
mov eax, [r14+4]
cmp eax, 801h
mov ecx, 800h
cmovge ecx, eax
lea rsi, [rsp+138h+var_A0]
mov [rsi], ecx
mov ecx, 0Fh
mov rdi, rsp
rep movsq
mov rdi, rbx
call _llama_init_from_model
mov r12, rax
test rax, rax
jz short loc_22F86
mov edi, 18h
call _malloc
mov r14, rax
mov [rax+8], r12
mov [rax], r15
mov [rax+10h], rbx
jmp short loc_22FBC
loc_22F86:
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_22FB9
call _Z15common_log_mainv; common_log_main(void)
xor r14d, r14d
lea rdx, aSFailedToCreat; "%s: failed to create the llama_context"...
lea rcx, aLlavaInitConte; "llava_init_context"
mov rdi, rax
mov esi, 4
xor eax, eax
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
jmp short loc_22FBC
loc_22FB9:
xor r14d, r14d
loc_22FBC:
mov rdi, [rsp+138h+var_C0]; void *
cmp rdi, r13
jz short loc_22FD6
mov rsi, [rsp+138h+var_B0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_22FD6:
mov rax, r14
add rsp, 110h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
jmp short loc_22FF0
jmp short loc_22FF0
jmp short $+2
loc_22FF0:
mov rbx, rax
mov rdi, [rsp+arg_70]; void *
cmp rdi, r13
jz short loc_2300D
mov rsi, [rsp+arg_80]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2300D:
mov rdi, rbx
call __Unwind_Resume
|
long long * llava_init_context(long long a1, long long a2)
{
long long v2; // r15
long long v3; // r15
int v4; // ecx
long long v5; // r12
long long *v6; // r14
int v7; // eax
int v8; // r8d
int v9; // r9d
char v11[120]; // [rsp+0h] [rbp-138h] BYREF
void *v12[2]; // [rsp+78h] [rbp-C0h] BYREF
_QWORD v13[2]; // [rsp+88h] [rbp-B0h] BYREF
_DWORD v14[40]; // [rsp+98h] [rbp-A0h] BYREF
v2 = *(_QWORD *)(a1 + 4096);
v12[0] = v13;
std::string::_M_construct<char *>(v12, *(_QWORD *)(a1 + 3608), *(_QWORD *)(a1 + 3608) + *(_QWORD *)(a1 + 3616));
if ( !v12[1] )
std::string::_M_replace(v12, 0LL, 0LL, "describe the image in detail.", 29LL);
v3 = clip_model_load(v2, 1LL);
common_context_params_to_llama((const common_params *)v14);
v4 = 2048;
if ( *(int *)(a1 + 4) >= 2049 )
v4 = *(_DWORD *)(a1 + 4);
v14[0] = v4;
qmemcpy(v11, v14, sizeof(v11));
v5 = llama_init_from_model(a2);
if ( v5 )
{
v6 = (long long *)malloc(24LL);
v6[1] = v5;
*v6 = v3;
v6[2] = a2;
}
else if ( common_log_verbosity_thold < 0 )
{
v6 = 0LL;
}
else
{
v7 = common_log_main();
v6 = 0LL;
common_log_add(
v7,
4,
(unsigned int)"%s: failed to create the llama_context\n",
(unsigned int)"llava_init_context",
v8,
v9,
v11[0]);
}
if ( v12[0] != v13 )
operator delete(v12[0], v13[0] + 1LL);
return v6;
}
|
llava_init_context:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x110
MOV RBX,RSI
MOV R14,RDI
MOV R15,qword ptr [RDI + 0x1000]
LEA R13,[RSP + 0x88]
MOV qword ptr [R13 + -0x10],R13
MOV RSI,qword ptr [RDI + 0xe18]
MOV RDX,qword ptr [RDI + 0xe20]
ADD RDX,RSI
LEA R12,[RSP + 0x78]
MOV RDI,R12
CALL 0x00126600
CMP qword ptr [R12 + 0x8],0x0
JNZ 0x00122f16
LAB_00122efb:
LEA RCX,[0x2093ab]
LEA RDI,[RSP + 0x78]
MOV R8D,0x1d
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0011e320
LAB_00122f16:
MOV RDI,R15
MOV ESI,0x1
CALL 0x0012af66
LAB_00122f23:
MOV R15,RAX
LEA RDI,[RSP + 0x98]
MOV RSI,R14
CALL 0x00198e09
MOV EAX,dword ptr [R14 + 0x4]
CMP EAX,0x801
MOV ECX,0x800
CMOVGE ECX,EAX
LEA RSI,[RSP + 0x98]
MOV dword ptr [RSI],ECX
LAB_00122f51:
MOV ECX,0xf
MOV RDI,RSP
MOVSQ.REP RDI,RSI
MOV RDI,RBX
CALL 0x0011d7e0
MOV R12,RAX
TEST RAX,RAX
JZ 0x00122f86
MOV EDI,0x18
CALL 0x0011e010
MOV R14,RAX
MOV qword ptr [RAX + 0x8],R12
MOV qword ptr [RAX],R15
MOV qword ptr [RAX + 0x10],RBX
JMP 0x00122fbc
LAB_00122f86:
LEA RAX,[0x2578a8]
CMP dword ptr [RAX],0x0
JS 0x00122fb9
CALL 0x001efaeb
XOR R14D,R14D
LEA RDX,[0x2093c9]
LEA RCX,[0x2093f1]
MOV RDI,RAX
MOV ESI,0x4
XOR EAX,EAX
CALL 0x001efb88
LAB_00122fb7:
JMP 0x00122fbc
LAB_00122fb9:
XOR R14D,R14D
LAB_00122fbc:
MOV RDI,qword ptr [RSP + 0x78]
CMP RDI,R13
JZ 0x00122fd6
MOV RSI,qword ptr [RSP + 0x88]
INC RSI
CALL 0x0011dc50
LAB_00122fd6:
MOV RAX,R14
ADD RSP,0x110
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* llava_init_context(common_params*, llama_model*) */
int8 * llava_init_context(common_params *param_1,llama_model *param_2)
{
int8 uVar1;
int8 *puVar2;
long lVar3;
int *piVar4;
byte bVar5;
int8 auStack_138 [15];
long *local_c0;
long local_b8;
long local_b0 [2];
int local_a0 [30];
bVar5 = 0;
uVar1 = *(int8 *)(param_1 + 0x1000);
local_c0 = local_b0;
std::__cxx11::string::_M_construct<char*>
(&local_c0,*(long *)(param_1 + 0xe18),
*(long *)(param_1 + 0xe20) + *(long *)(param_1 + 0xe18));
if (local_b8 == 0) {
/* try { // try from 00122efb to 00122f15 has its CatchHandler @ 00122fea */
std::__cxx11::string::_M_replace((ulong)&local_c0,0,(char *)0x0,0x2093ab);
}
/* try { // try from 00122f16 to 00122f22 has its CatchHandler @ 00122fee */
uVar1 = clip_model_load(uVar1,1);
/* try { // try from 00122f23 to 00122f35 has its CatchHandler @ 00122fec */
common_context_params_to_llama((common_params *)local_a0);
local_a0[0] = 0x800;
if (0x800 < *(int *)(param_1 + 4)) {
local_a0[0] = *(int *)(param_1 + 4);
}
piVar4 = local_a0;
puVar2 = auStack_138;
/* try { // try from 00122f51 to 00122fb6 has its CatchHandler @ 00122ff0 */
for (lVar3 = 0xf; lVar3 != 0; lVar3 = lVar3 + -1) {
*puVar2 = *(int8 *)piVar4;
piVar4 = piVar4 + ((ulong)bVar5 * -2 + 1) * 2;
puVar2 = puVar2 + (ulong)bVar5 * -2 + 1;
}
lVar3 = llama_init_from_model(param_2);
if (lVar3 == 0) {
if (common_log_verbosity_thold < 0) {
puVar2 = (int8 *)0x0;
}
else {
uVar1 = common_log_main();
puVar2 = (int8 *)0x0;
common_log_add(uVar1,4,"%s: failed to create the llama_context\n","llava_init_context");
}
}
else {
puVar2 = (int8 *)malloc(0x18);
puVar2[1] = lVar3;
*puVar2 = uVar1;
puVar2[2] = param_2;
}
if (local_c0 != local_b0) {
operator_delete(local_c0,local_b0[0] + 1);
}
return puVar2;
}
|
|
6,874 |
PFS_buffer_scalable_container<PFS_table_share_index, 8192, 8192, PFS_buffer_default_array<PFS_table_share_index>, PFS_buffer_default_allocator<PFS_table_share_index>>::allocate(pfs_dirty_state*)
|
eloqsql/storage/perfschema/pfs_buffer_container.h
|
value_type *allocate(pfs_dirty_state *dirty_state)
{
if (m_full)
{
m_lost++;
return NULL;
}
uint index;
uint monotonic;
uint monotonic_max;
uint current_page_count;
value_type *pfs;
array_type *array;
void *addr;
void * volatile * typed_addr;
void *ptr;
/*
1: Try to find an available record within the existing pages
*/
current_page_count= PFS_atomic::load_u32(& m_max_page_index.m_u32);
if (current_page_count != 0)
{
monotonic= PFS_atomic::load_u32(& m_monotonic.m_u32);
monotonic_max= monotonic + current_page_count;
while (monotonic < monotonic_max)
{
/*
Scan in the [0 .. current_page_count - 1] range,
in parallel with m_monotonic (see below)
*/
index= monotonic % current_page_count;
/* Atomic Load, array= m_pages[index] */
addr= & m_pages[index];
typed_addr= static_cast<void * volatile *>(addr);
ptr= my_atomic_loadptr(typed_addr);
array= static_cast<array_type *>(ptr);
if (array != NULL)
{
pfs= array->allocate(dirty_state);
if (pfs != NULL)
{
/* Keep a pointer to the parent page, for deallocate(). */
pfs->m_page= reinterpret_cast<PFS_opaque_container_page *> (array);
return pfs;
}
}
/*
Parallel scans collaborate to increase
the common monotonic scan counter.
Note that when all the existing page are full,
one thread will eventually add a new page,
and cause m_max_page_index to increase,
which fools all the modulo logic for scans already in progress,
because the monotonic counter is not folded to the same place
(sometime modulo N, sometime modulo N+1).
This is actually ok: since all the pages are full anyway,
there is nothing to miss, so better increase the monotonic
counter faster and then move on to the detection of new pages,
in part 2: below.
*/
monotonic= PFS_atomic::add_u32(& m_monotonic.m_u32, 1);
};
}
/*
2: Try to add a new page, beyond the m_max_page_index limit
*/
while (current_page_count < m_max_page_count)
{
/* Peek for pages added by collaborating threads */
/* (2-a) Atomic Load, array= m_pages[current_page_count] */
addr= & m_pages[current_page_count];
typed_addr= static_cast<void * volatile *>(addr);
ptr= my_atomic_loadptr(typed_addr);
array= static_cast<array_type *>(ptr);
if (array == NULL)
{
// ==================================================================
// BEGIN CRITICAL SECTION -- buffer expand
// ==================================================================
/*
On a fresh started server, buffers are typically empty.
When a sudden load spike is seen by the server,
multiple threads may want to expand the buffer at the same time.
Using a compare and swap to allow multiple pages to be added,
possibly freeing duplicate pages on collisions,
does not work well because the amount of code involved
when creating a new page can be significant (PFS_thread),
causing MANY collisions between (2-b) and (2-d).
A huge number of collisions (which can happen when thousands
of new connections hits the server after a restart)
leads to a huge memory consumption, and to OOM.
To mitigate this, we use here a mutex,
to enforce that only ONE page is added at a time,
so that scaling the buffer happens in a predictable
and controlled manner.
*/
pthread_mutex_lock(& m_critical_section);
/*
Peek again for pages added by collaborating threads,
this time as the only thread allowed to expand the buffer
*/
/* (2-b) Atomic Load, array= m_pages[current_page_count] */
ptr= my_atomic_loadptr(typed_addr);
array= static_cast<array_type *>(ptr);
if (array == NULL)
{
/* (2-c) Found no page, allocate a new one */
array= new array_type();
builtin_memory_scalable_buffer.count_alloc(sizeof (array_type));
array->m_max= get_page_logical_size(current_page_count);
int rc= m_allocator->alloc_array(array);
if (rc != 0)
{
m_allocator->free_array(array);
delete array;
builtin_memory_scalable_buffer.count_free(sizeof (array_type));
m_lost++;
pthread_mutex_unlock(& m_critical_section);
return NULL;
}
/* Keep a pointer to this container, for static_deallocate(). */
array->m_container= reinterpret_cast<PFS_opaque_container *> (this);
/* (2-d) Atomic STORE, m_pages[current_page_count] = array */
ptr= array;
my_atomic_storeptr(typed_addr, ptr);
/* Advertise the new page */
PFS_atomic::add_u32(& m_max_page_index.m_u32, 1);
}
pthread_mutex_unlock(& m_critical_section);
// ==================================================================
// END CRITICAL SECTION -- buffer expand
// ==================================================================
}
assert(array != NULL);
pfs= array->allocate(dirty_state);
if (pfs != NULL)
{
/* Keep a pointer to the parent page, for deallocate(). */
pfs->m_page= reinterpret_cast<PFS_opaque_container_page *> (array);
return pfs;
}
current_page_count++;
}
m_lost++;
m_full= true;
return NULL;
}
|
O0
|
c
|
PFS_buffer_scalable_container<PFS_table_share_index, 8192, 8192, PFS_buffer_default_array<PFS_table_share_index>, PFS_buffer_default_allocator<PFS_table_share_index>>::allocate(pfs_dirty_state*):
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
testb $0x1, 0x9(%rax)
je 0x565d2
movq -0x88(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x56922
movq -0x88(%rbp), %rdi
addq $0x58, %rdi
callq 0x324e0
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x566b6
movq -0x88(%rbp), %rdi
addq $0x18, %rdi
callq 0x324e0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x566b4
movl -0x20(%rbp), %eax
movl -0x28(%rbp), %ecx
xorl %edx, %edx
divl %ecx
movq -0x88(%rbp), %rax
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
leaq 0xa8(%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x56697
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x56a20
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x56695
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x56922
jmp 0x56697
movq -0x88(%rbp), %rdi
addq $0x18, %rdi
movl $0x1, %esi
callq 0x31670
movl %eax, -0x20(%rbp)
jmp 0x5660b
jmp 0x566b6
jmp 0x566b8
movq -0x88(%rbp), %rcx
movl -0x28(%rbp), %eax
cmpq 0x98(%rcx), %rax
jae 0x56905
movq -0x88(%rbp), %rax
movl -0x28(%rbp), %ecx
leaq 0xa8(%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x568c9
movq -0x88(%rbp), %rdi
addq $0x20b0, %rdi # imm = 0x20B0
callq 0x264c0
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x568b6
movl $0x60, %edi
callq 0x26310
movq %rax, %rdi
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rdi)
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x56af0
jmp 0x5678b
movq -0x90(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x3b7023(%rip), %rdi # 0x40d7c0
movl $0x60, %esi
callq 0x325f0
movq -0x88(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x56b10
movl %eax, %ecx
movq -0x88(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq -0x38(%rbp), %rcx
movq %rdx, 0x50(%rcx)
movq 0x20a8(%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x56b50
movl %eax, -0x78(%rbp)
cmpl $0x0, -0x78(%rbp)
je 0x5687e
movq -0x88(%rbp), %rax
movq 0x20a8(%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x56990
movq -0x38(%rbp), %rax
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
je 0x56821
movq -0xa0(%rbp), %rdi
movl $0x60, %esi
callq 0x26320
leaq 0x3b6f98(%rip), %rdi # 0x40d7c0
movl $0x60, %esi
callq 0x32750
movq -0x88(%rbp), %rdi
movq (%rdi), %rax
addq $0x1, %rax
movq %rax, (%rdi)
addq $0x20b0, %rdi # imm = 0x20B0
callq 0x26260
movq $0x0, -0x8(%rbp)
jmp 0x56922
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
movl $0x60, %esi
callq 0x26320
jmp 0x5692f
movq -0x88(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rdi, 0x58(%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rcx
movq -0x50(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
xchgq %rax, (%rcx)
addq $0x58, %rdi
movl $0x1, %esi
callq 0x31670
movq -0x88(%rbp), %rdi
addq $0x20b0, %rdi # imm = 0x20B0
callq 0x26260
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x56a20
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x568f7
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x56922
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x566b8
movq -0x88(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movb $0x1, 0x9(%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x265f0
nopl (%rax,%rax)
|
_ZN29PFS_buffer_scalable_containerI17PFS_prepared_stmtLi1024ELi1024E24PFS_buffer_default_arrayIS0_E28PFS_buffer_default_allocatorIS0_EE8allocateEP15pfs_dirty_state:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov [rbp+var_88], rax
test byte ptr [rax+9], 1
jz short loc_565D2
mov rax, [rbp+var_88]
mov rcx, [rax]
add rcx, 1
mov [rax], rcx
mov [rbp+var_8], 0
jmp loc_56922
loc_565D2:
mov rdi, [rbp+var_88]
add rdi, 58h ; 'X'; this
call _ZN10PFS_atomic8load_u32EPj; PFS_atomic::load_u32(uint *)
mov [rbp+var_28], eax
cmp [rbp+var_28], 0
jz loc_566B6
mov rdi, [rbp+var_88]
add rdi, 18h; this
call _ZN10PFS_atomic8load_u32EPj; PFS_atomic::load_u32(uint *)
mov [rbp+var_20], eax
mov eax, [rbp+var_20]
add eax, [rbp+var_28]
mov [rbp+var_24], eax
loc_5660B:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_24]
jnb loc_566B4
mov eax, [rbp+var_20]
mov ecx, [rbp+var_28]
xor edx, edx; unsigned int
div ecx
mov rax, [rbp+var_88]
mov [rbp+var_1C], edx
mov ecx, [rbp+var_1C]
lea rax, [rax+rcx*8+0A8h]
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov [rbp+var_48], rax
mov rax, [rbp+var_48]
mov rax, [rax]
mov [rbp+var_58], rax
mov rax, [rbp+var_58]
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
mov [rbp+var_38], rax
cmp [rbp+var_38], 0
jz short loc_56697
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_18]
call _ZN24PFS_buffer_default_arrayI17PFS_prepared_stmtE8allocateEP15pfs_dirty_state; PFS_buffer_default_array<PFS_prepared_stmt>::allocate(pfs_dirty_state *)
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
jz short loc_56695
mov rcx, [rbp+var_38]
mov rax, [rbp+var_30]
mov [rax+8], rcx
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
jmp loc_56922
loc_56695:
jmp short $+2
loc_56697:
mov rdi, [rbp+var_88]
add rdi, 18h; this
mov esi, (offset dword_0+1); unsigned int *
call _ZN10PFS_atomic7add_u32EPjj; PFS_atomic::add_u32(uint *,uint)
mov [rbp+var_20], eax
jmp loc_5660B
loc_566B4:
jmp short $+2
loc_566B6:
jmp short $+2
loc_566B8:
mov rcx, [rbp+var_88]
mov eax, [rbp+var_28]
cmp rax, [rcx+98h]
jnb loc_56905
mov rax, [rbp+var_88]
mov ecx, [rbp+var_28]
lea rax, [rax+rcx*8+0A8h]
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov [rbp+var_48], rax
mov rax, [rbp+var_48]
mov rax, [rax]
mov [rbp+var_60], rax
mov rax, [rbp+var_60]
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
mov [rbp+var_38], rax
cmp [rbp+var_38], 0
jnz loc_568C9
mov rdi, [rbp+var_88]
add rdi, 20B0h
call _pthread_mutex_lock
mov rax, [rbp+var_48]
mov rax, [rax]
mov [rbp+var_68], rax
mov rax, [rbp+var_68]
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
mov [rbp+var_38], rax
cmp [rbp+var_38], 0
jnz loc_568B6
mov edi, 60h ; '`'; unsigned __int64
call __Znwm; operator new(ulong)
mov rdi, rax
mov [rbp+var_98], rdi
mov rax, rdi
mov [rbp+var_90], rax
xorps xmm0, xmm0
movaps xmmword ptr [rdi+50h], xmm0
movaps xmmword ptr [rdi+40h], xmm0
movaps xmmword ptr [rdi+30h], xmm0
movaps xmmword ptr [rdi+20h], xmm0
movaps xmmword ptr [rdi+10h], xmm0
movaps xmmword ptr [rdi], xmm0
call _ZN24PFS_buffer_default_arrayI17PFS_prepared_stmtEC2Ev; PFS_buffer_default_array<PFS_prepared_stmt>::PFS_buffer_default_array(void)
jmp short $+2
loc_5678B:
mov rax, [rbp+var_90]
mov [rbp+var_38], rax
lea rdi, builtin_memory_scalable_buffer; this
mov esi, 60h ; '`'; unsigned __int64
call _ZN24PFS_builtin_memory_class11count_allocEm; PFS_builtin_memory_class::count_alloc(ulong)
mov rdi, [rbp+var_88]
mov esi, [rbp+var_28]
call _ZN29PFS_buffer_scalable_containerI17PFS_prepared_stmtLi1024ELi1024E24PFS_buffer_default_arrayIS0_E28PFS_buffer_default_allocatorIS0_EE21get_page_logical_sizeEj; PFS_buffer_scalable_container<PFS_prepared_stmt,1024,1024,PFS_buffer_default_array<PFS_prepared_stmt>,PFS_buffer_default_allocator<PFS_prepared_stmt>>::get_page_logical_size(uint)
mov ecx, eax
mov rax, [rbp+var_88]
mov ecx, ecx
mov edx, ecx
mov rcx, [rbp+var_38]
mov [rcx+50h], rdx
mov rdi, [rax+20A8h]
mov rsi, [rbp+var_38]
call _ZN28PFS_buffer_default_allocatorI17PFS_prepared_stmtE11alloc_arrayEP24PFS_buffer_default_arrayIS0_E; PFS_buffer_default_allocator<PFS_prepared_stmt>::alloc_array(PFS_buffer_default_array<PFS_prepared_stmt> *)
mov [rbp+var_78], eax
cmp [rbp+var_78], 0
jz loc_5687E
mov rax, [rbp+var_88]
mov rdi, [rax+20A8h]
mov rsi, [rbp+var_38]
call _ZN28PFS_buffer_default_allocatorI17PFS_prepared_stmtE10free_arrayEP24PFS_buffer_default_arrayIS0_E; PFS_buffer_default_allocator<PFS_prepared_stmt>::free_array(PFS_buffer_default_array<PFS_prepared_stmt> *)
mov rax, [rbp+var_38]
mov [rbp+var_A0], rax
cmp rax, 0
jz short loc_56821
mov rdi, [rbp+var_A0]; void *
mov esi, 60h ; '`'; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_56821:
lea rdi, builtin_memory_scalable_buffer; this
mov esi, 60h ; '`'; unsigned __int64
call _ZN24PFS_builtin_memory_class10count_freeEm; PFS_builtin_memory_class::count_free(ulong)
mov rdi, [rbp+var_88]
mov rax, [rdi]
add rax, 1
mov [rdi], rax
add rdi, 20B0h
call _pthread_mutex_unlock
mov [rbp+var_8], 0
jmp loc_56922
mov rdi, [rbp+var_90]; void *
mov rcx, rax
mov eax, edx
mov [rbp+var_70], rcx
mov [rbp+var_74], eax
mov esi, 60h ; '`'; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp loc_5692F
loc_5687E:
mov rdi, [rbp+var_88]
mov rax, [rbp+var_38]
mov [rax+58h], rdi
mov rax, [rbp+var_38]
mov [rbp+var_50], rax
mov rcx, [rbp+var_48]
mov rax, [rbp+var_50]
mov [rbp+var_80], rax
mov rax, [rbp+var_80]
xchg rax, [rcx]
add rdi, 58h ; 'X'; this
mov esi, (offset dword_0+1); unsigned int *
call _ZN10PFS_atomic7add_u32EPjj; PFS_atomic::add_u32(uint *,uint)
loc_568B6:
mov rdi, [rbp+var_88]
add rdi, 20B0h
call _pthread_mutex_unlock
loc_568C9:
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_18]
call _ZN24PFS_buffer_default_arrayI17PFS_prepared_stmtE8allocateEP15pfs_dirty_state; PFS_buffer_default_array<PFS_prepared_stmt>::allocate(pfs_dirty_state *)
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
jz short loc_568F7
mov rcx, [rbp+var_38]
mov rax, [rbp+var_30]
mov [rax+8], rcx
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
jmp short loc_56922
loc_568F7:
mov eax, [rbp+var_28]
add eax, 1
mov [rbp+var_28], eax
jmp loc_566B8
loc_56905:
mov rax, [rbp+var_88]
mov rcx, [rax]
add rcx, 1
mov [rax], rcx
mov byte ptr [rax+9], 1
mov [rbp+var_8], 0
loc_56922:
mov rax, [rbp+var_8]
add rsp, 0A0h
pop rbp
retn
loc_5692F:
mov rdi, [rbp+var_70]
call __Unwind_Resume
|
long long PFS_buffer_scalable_container<PFS_prepared_stmt,1024,1024,PFS_buffer_default_array<PFS_prepared_stmt>,PFS_buffer_default_allocator<PFS_prepared_stmt>>::allocate(
long long a1,
unsigned int *a2)
{
_OWORD *v3; // [rsp+10h] [rbp-90h]
volatile long long *v4; // [rsp+58h] [rbp-48h]
long long v5; // [rsp+68h] [rbp-38h]
volatile long long v6; // [rsp+68h] [rbp-38h]
long long v7; // [rsp+70h] [rbp-30h]
long long v8; // [rsp+70h] [rbp-30h]
unsigned int u32; // [rsp+78h] [rbp-28h]
unsigned int v10; // [rsp+7Ch] [rbp-24h]
unsigned int v11; // [rsp+80h] [rbp-20h]
if ( (*(_BYTE *)(a1 + 9) & 1) != 0 )
{
++*(_QWORD *)a1;
return 0LL;
}
u32 = PFS_atomic::load_u32((PFS_atomic *)(a1 + 88), a2);
if ( !u32 )
goto LABEL_10;
v11 = PFS_atomic::load_u32((PFS_atomic *)(a1 + 24), a2);
v10 = u32 + v11;
while ( v11 < v10 )
{
v5 = *(_QWORD *)(a1 + 8LL * (v11 % u32) + 168);
if ( v5 )
{
v7 = PFS_buffer_default_array<PFS_prepared_stmt>::allocate(v5, a2);
if ( v7 )
{
*(_QWORD *)(v7 + 8) = v5;
return v7;
}
}
v11 = PFS_atomic::add_u32((PFS_atomic *)(a1 + 24), (unsigned int *)((char *)&dword_0 + 1));
}
while ( 1 )
{
LABEL_10:
if ( (unsigned long long)u32 >= *(_QWORD *)(a1 + 152) )
{
++*(_QWORD *)a1;
*(_BYTE *)(a1 + 9) = 1;
return 0LL;
}
v4 = (volatile long long *)(a1 + 8LL * u32 + 168);
v6 = *v4;
if ( !*v4 )
break;
LABEL_19:
v8 = PFS_buffer_default_array<PFS_prepared_stmt>::allocate(v6, a2);
if ( v8 )
{
*(_QWORD *)(v8 + 8) = v6;
return v8;
}
++u32;
}
pthread_mutex_lock(a1 + 8368);
v6 = *v4;
if ( *v4 )
{
LABEL_18:
pthread_mutex_unlock(a1 + 8368);
goto LABEL_19;
}
v3 = (_OWORD *)operator new(0x60uLL);
v3[5] = 0LL;
v3[4] = 0LL;
v3[3] = 0LL;
v3[2] = 0LL;
v3[1] = 0LL;
*v3 = 0LL;
PFS_buffer_default_array<PFS_prepared_stmt>::PFS_buffer_default_array();
v6 = (volatile long long)v3;
PFS_builtin_memory_class::count_alloc((PFS_builtin_memory_class *)&builtin_memory_scalable_buffer, 0x60uLL);
*((_QWORD *)v3 + 10) = (unsigned int)PFS_buffer_scalable_container<PFS_prepared_stmt,1024,1024,PFS_buffer_default_array<PFS_prepared_stmt>,PFS_buffer_default_allocator<PFS_prepared_stmt>>::get_page_logical_size(
a1,
u32);
if ( !(unsigned int)PFS_buffer_default_allocator<PFS_prepared_stmt>::alloc_array(*(_QWORD *)(a1 + 8360), v3) )
{
*((_QWORD *)v3 + 11) = a1;
_InterlockedExchange64(v4, (long long)v3);
PFS_atomic::add_u32((PFS_atomic *)(a1 + 88), (unsigned int *)((char *)&dword_0 + 1));
goto LABEL_18;
}
PFS_buffer_default_allocator<PFS_prepared_stmt>::free_array(*(_QWORD *)(a1 + 8360), v3);
if ( v3 )
operator delete(v3, 0x60uLL);
PFS_builtin_memory_class::count_free((PFS_builtin_memory_class *)&builtin_memory_scalable_buffer, 0x60uLL);
++*(_QWORD *)a1;
pthread_mutex_unlock(a1 + 8368);
return 0LL;
}
|
allocate:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x88],RAX
TEST byte ptr [RAX + 0x9],0x1
JZ 0x001565d2
MOV RAX,qword ptr [RBP + -0x88]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
MOV qword ptr [RAX],RCX
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00156922
LAB_001565d2:
MOV RDI,qword ptr [RBP + -0x88]
ADD RDI,0x58
CALL 0x001324e0
MOV dword ptr [RBP + -0x28],EAX
CMP dword ptr [RBP + -0x28],0x0
JZ 0x001566b6
MOV RDI,qword ptr [RBP + -0x88]
ADD RDI,0x18
CALL 0x001324e0
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x24],EAX
LAB_0015660b:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x24]
JNC 0x001566b4
MOV EAX,dword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x28]
XOR EDX,EDX
DIV ECX
MOV RAX,qword ptr [RBP + -0x88]
MOV dword ptr [RBP + -0x1c],EDX
MOV ECX,dword ptr [RBP + -0x1c]
LEA RAX,[RAX + RCX*0x8 + 0xa8]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],0x0
JZ 0x00156697
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00156a20
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
JZ 0x00156695
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00156922
LAB_00156695:
JMP 0x00156697
LAB_00156697:
MOV RDI,qword ptr [RBP + -0x88]
ADD RDI,0x18
MOV ESI,0x1
CALL 0x00131670
MOV dword ptr [RBP + -0x20],EAX
JMP 0x0015660b
LAB_001566b4:
JMP 0x001566b6
LAB_001566b6:
JMP 0x001566b8
LAB_001566b8:
MOV RCX,qword ptr [RBP + -0x88]
MOV EAX,dword ptr [RBP + -0x28]
CMP RAX,qword ptr [RCX + 0x98]
JNC 0x00156905
MOV RAX,qword ptr [RBP + -0x88]
MOV ECX,dword ptr [RBP + -0x28]
LEA RAX,[RAX + RCX*0x8 + 0xa8]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x001568c9
MOV RDI,qword ptr [RBP + -0x88]
ADD RDI,0x20b0
CALL 0x001264c0
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x001568b6
MOV EDI,0x60
CALL 0x00126310
MOV RDI,RAX
MOV qword ptr [RBP + -0x98],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0x90],RAX
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RDI + 0x50],XMM0
MOVAPS xmmword ptr [RDI + 0x40],XMM0
MOVAPS xmmword ptr [RDI + 0x30],XMM0
MOVAPS xmmword ptr [RDI + 0x20],XMM0
MOVAPS xmmword ptr [RDI + 0x10],XMM0
MOVAPS xmmword ptr [RDI],XMM0
LAB_00156784:
CALL 0x00156af0
LAB_00156789:
JMP 0x0015678b
LAB_0015678b:
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x38],RAX
LEA RDI,[0x50d7c0]
MOV ESI,0x60
CALL 0x001325f0
MOV RDI,qword ptr [RBP + -0x88]
MOV ESI,dword ptr [RBP + -0x28]
CALL 0x00156b10
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x88]
MOV ECX,ECX
MOV EDX,ECX
MOV RCX,qword ptr [RBP + -0x38]
MOV qword ptr [RCX + 0x50],RDX
MOV RDI,qword ptr [RAX + 0x20a8]
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x00156b50
MOV dword ptr [RBP + -0x78],EAX
CMP dword ptr [RBP + -0x78],0x0
JZ 0x0015687e
MOV RAX,qword ptr [RBP + -0x88]
MOV RDI,qword ptr [RAX + 0x20a8]
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x00156990
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0xa0],RAX
CMP RAX,0x0
JZ 0x00156821
MOV RDI,qword ptr [RBP + -0xa0]
MOV ESI,0x60
CALL 0x00126320
LAB_00156821:
LEA RDI,[0x50d7c0]
MOV ESI,0x60
CALL 0x00132750
MOV RDI,qword ptr [RBP + -0x88]
MOV RAX,qword ptr [RDI]
ADD RAX,0x1
MOV qword ptr [RDI],RAX
ADD RDI,0x20b0
CALL 0x00126260
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00156922
LAB_0015687e:
MOV RDI,qword ptr [RBP + -0x88]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x58],RDI
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x50],RAX
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x80]
XCHG qword ptr [RCX],RAX
ADD RDI,0x58
MOV ESI,0x1
CALL 0x00131670
LAB_001568b6:
MOV RDI,qword ptr [RBP + -0x88]
ADD RDI,0x20b0
CALL 0x00126260
LAB_001568c9:
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00156a20
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
JZ 0x001568f7
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00156922
LAB_001568f7:
MOV EAX,dword ptr [RBP + -0x28]
ADD EAX,0x1
MOV dword ptr [RBP + -0x28],EAX
JMP 0x001566b8
LAB_00156905:
MOV RAX,qword ptr [RBP + -0x88]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
MOV qword ptr [RAX],RCX
MOV byte ptr [RAX + 0x9],0x1
MOV qword ptr [RBP + -0x8],0x0
LAB_00156922:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0xa0
POP RBP
RET
|
/* PFS_buffer_scalable_container<PFS_prepared_stmt, 1024, 1024,
PFS_buffer_default_array<PFS_prepared_stmt>, PFS_buffer_default_allocator<PFS_prepared_stmt>
>::allocate(pfs_dirty_state*) */
long __thiscall
PFS_buffer_scalable_container<PFS_prepared_stmt,1024,1024,PFS_buffer_default_array<PFS_prepared_stmt>,PFS_buffer_default_allocator<PFS_prepared_stmt>>
::allocate(PFS_buffer_scalable_container<PFS_prepared_stmt,1024,1024,PFS_buffer_default_array<PFS_prepared_stmt>,PFS_buffer_default_allocator<PFS_prepared_stmt>>
*this,pfs_dirty_state *param_1)
{
PFS_buffer_scalable_container<PFS_prepared_stmt,1024,1024,PFS_buffer_default_array<PFS_prepared_stmt>,PFS_buffer_default_allocator<PFS_prepared_stmt>>
*pPVar1;
PFS_buffer_default_array<PFS_prepared_stmt> *this_00;
uint uVar2;
int iVar3;
long lVar4;
PFS_buffer_default_array<PFS_prepared_stmt> *local_40;
uint local_30;
uint local_28;
if (((byte)this[9] & 1) == 0) {
local_30 = PFS_atomic::load_u32((uint *)(this + 0x58));
if (local_30 != 0) {
local_28 = PFS_atomic::load_u32((uint *)(this + 0x18));
uVar2 = local_28 + local_30;
while (local_28 < uVar2) {
this_00 = *(PFS_buffer_default_array<PFS_prepared_stmt> **)
(this + (ulong)(local_28 % local_30) * 8 + 0xa8);
if ((this_00 != (PFS_buffer_default_array<PFS_prepared_stmt> *)0x0) &&
(lVar4 = PFS_buffer_default_array<PFS_prepared_stmt>::allocate(this_00,param_1),
lVar4 != 0)) {
*(PFS_buffer_default_array<PFS_prepared_stmt> **)(lVar4 + 8) = this_00;
return lVar4;
}
local_28 = PFS_atomic::add_u32((uint *)(this + 0x18),1);
}
}
for (; (ulong)local_30 < *(ulong *)(this + 0x98); local_30 = local_30 + 1) {
pPVar1 = this + (ulong)local_30 * 8 + 0xa8;
local_40 = *(PFS_buffer_default_array<PFS_prepared_stmt> **)pPVar1;
if (local_40 == (PFS_buffer_default_array<PFS_prepared_stmt> *)0x0) {
pthread_mutex_lock((pthread_mutex_t *)(this + 0x20b0));
local_40 = *(PFS_buffer_default_array<PFS_prepared_stmt> **)pPVar1;
if (local_40 == (PFS_buffer_default_array<PFS_prepared_stmt> *)0x0) {
local_40 = (PFS_buffer_default_array<PFS_prepared_stmt> *)operator_new(0x60);
*(int8 *)(local_40 + 0x50) = 0;
*(int8 *)(local_40 + 0x58) = 0;
*(int8 *)(local_40 + 0x40) = 0;
*(int8 *)(local_40 + 0x48) = 0;
*(int8 *)(local_40 + 0x30) = 0;
*(int8 *)(local_40 + 0x38) = 0;
*(int8 *)(local_40 + 0x20) = 0;
*(int8 *)(local_40 + 0x28) = 0;
*(int8 *)(local_40 + 0x10) = 0;
*(int8 *)(local_40 + 0x18) = 0;
*(int8 *)local_40 = 0;
*(int8 *)(local_40 + 8) = 0;
/* try { // try from 00156784 to 00156788 has its CatchHandler @ 0015685c */
PFS_buffer_default_array<PFS_prepared_stmt>::PFS_buffer_default_array(local_40);
PFS_builtin_memory_class::count_alloc
((PFS_builtin_memory_class *)builtin_memory_scalable_buffer,0x60);
uVar2 = get_page_logical_size(this,local_30);
*(ulong *)(local_40 + 0x50) = (ulong)uVar2;
iVar3 = PFS_buffer_default_allocator<PFS_prepared_stmt>::alloc_array
(*(PFS_buffer_default_allocator<PFS_prepared_stmt> **)(this + 0x20a8),
(PFS_buffer_default_array *)local_40);
if (iVar3 != 0) {
PFS_buffer_default_allocator<PFS_prepared_stmt>::free_array
(*(PFS_buffer_default_allocator<PFS_prepared_stmt> **)(this + 0x20a8),
(PFS_buffer_default_array *)local_40);
if (local_40 != (PFS_buffer_default_array<PFS_prepared_stmt> *)0x0) {
operator_delete(local_40,0x60);
}
PFS_builtin_memory_class::count_free
((PFS_builtin_memory_class *)builtin_memory_scalable_buffer,0x60);
*(long *)this = *(long *)this + 1;
pthread_mutex_unlock((pthread_mutex_t *)(this + 0x20b0));
return 0;
}
*(PFS_buffer_scalable_container<PFS_prepared_stmt,1024,1024,PFS_buffer_default_array<PFS_prepared_stmt>,PFS_buffer_default_allocator<PFS_prepared_stmt>>
**)(local_40 + 0x58) = this;
LOCK();
*(PFS_buffer_default_array<PFS_prepared_stmt> **)pPVar1 = local_40;
UNLOCK();
PFS_atomic::add_u32((uint *)(this + 0x58),1);
}
pthread_mutex_unlock((pthread_mutex_t *)(this + 0x20b0));
}
lVar4 = PFS_buffer_default_array<PFS_prepared_stmt>::allocate(local_40,param_1);
if (lVar4 != 0) {
*(PFS_buffer_default_array<PFS_prepared_stmt> **)(lVar4 + 8) = local_40;
return lVar4;
}
}
*(long *)this = *(long *)this + 1;
this[9] = (PFS_buffer_scalable_container<PFS_prepared_stmt,1024,1024,PFS_buffer_default_array<PFS_prepared_stmt>,PFS_buffer_default_allocator<PFS_prepared_stmt>>
)0x1;
}
else {
*(long *)this = *(long *)this + 1;
}
return 0;
}
|
|
6,875 |
PFS_buffer_scalable_container<PFS_table_share_index, 8192, 8192, PFS_buffer_default_array<PFS_table_share_index>, PFS_buffer_default_allocator<PFS_table_share_index>>::allocate(pfs_dirty_state*)
|
eloqsql/storage/perfschema/pfs_buffer_container.h
|
value_type *allocate(pfs_dirty_state *dirty_state)
{
if (m_full)
{
m_lost++;
return NULL;
}
uint index;
uint monotonic;
uint monotonic_max;
uint current_page_count;
value_type *pfs;
array_type *array;
void *addr;
void * volatile * typed_addr;
void *ptr;
/*
1: Try to find an available record within the existing pages
*/
current_page_count= PFS_atomic::load_u32(& m_max_page_index.m_u32);
if (current_page_count != 0)
{
monotonic= PFS_atomic::load_u32(& m_monotonic.m_u32);
monotonic_max= monotonic + current_page_count;
while (monotonic < monotonic_max)
{
/*
Scan in the [0 .. current_page_count - 1] range,
in parallel with m_monotonic (see below)
*/
index= monotonic % current_page_count;
/* Atomic Load, array= m_pages[index] */
addr= & m_pages[index];
typed_addr= static_cast<void * volatile *>(addr);
ptr= my_atomic_loadptr(typed_addr);
array= static_cast<array_type *>(ptr);
if (array != NULL)
{
pfs= array->allocate(dirty_state);
if (pfs != NULL)
{
/* Keep a pointer to the parent page, for deallocate(). */
pfs->m_page= reinterpret_cast<PFS_opaque_container_page *> (array);
return pfs;
}
}
/*
Parallel scans collaborate to increase
the common monotonic scan counter.
Note that when all the existing page are full,
one thread will eventually add a new page,
and cause m_max_page_index to increase,
which fools all the modulo logic for scans already in progress,
because the monotonic counter is not folded to the same place
(sometime modulo N, sometime modulo N+1).
This is actually ok: since all the pages are full anyway,
there is nothing to miss, so better increase the monotonic
counter faster and then move on to the detection of new pages,
in part 2: below.
*/
monotonic= PFS_atomic::add_u32(& m_monotonic.m_u32, 1);
};
}
/*
2: Try to add a new page, beyond the m_max_page_index limit
*/
while (current_page_count < m_max_page_count)
{
/* Peek for pages added by collaborating threads */
/* (2-a) Atomic Load, array= m_pages[current_page_count] */
addr= & m_pages[current_page_count];
typed_addr= static_cast<void * volatile *>(addr);
ptr= my_atomic_loadptr(typed_addr);
array= static_cast<array_type *>(ptr);
if (array == NULL)
{
// ==================================================================
// BEGIN CRITICAL SECTION -- buffer expand
// ==================================================================
/*
On a fresh started server, buffers are typically empty.
When a sudden load spike is seen by the server,
multiple threads may want to expand the buffer at the same time.
Using a compare and swap to allow multiple pages to be added,
possibly freeing duplicate pages on collisions,
does not work well because the amount of code involved
when creating a new page can be significant (PFS_thread),
causing MANY collisions between (2-b) and (2-d).
A huge number of collisions (which can happen when thousands
of new connections hits the server after a restart)
leads to a huge memory consumption, and to OOM.
To mitigate this, we use here a mutex,
to enforce that only ONE page is added at a time,
so that scaling the buffer happens in a predictable
and controlled manner.
*/
pthread_mutex_lock(& m_critical_section);
/*
Peek again for pages added by collaborating threads,
this time as the only thread allowed to expand the buffer
*/
/* (2-b) Atomic Load, array= m_pages[current_page_count] */
ptr= my_atomic_loadptr(typed_addr);
array= static_cast<array_type *>(ptr);
if (array == NULL)
{
/* (2-c) Found no page, allocate a new one */
array= new array_type();
builtin_memory_scalable_buffer.count_alloc(sizeof (array_type));
array->m_max= get_page_logical_size(current_page_count);
int rc= m_allocator->alloc_array(array);
if (rc != 0)
{
m_allocator->free_array(array);
delete array;
builtin_memory_scalable_buffer.count_free(sizeof (array_type));
m_lost++;
pthread_mutex_unlock(& m_critical_section);
return NULL;
}
/* Keep a pointer to this container, for static_deallocate(). */
array->m_container= reinterpret_cast<PFS_opaque_container *> (this);
/* (2-d) Atomic STORE, m_pages[current_page_count] = array */
ptr= array;
my_atomic_storeptr(typed_addr, ptr);
/* Advertise the new page */
PFS_atomic::add_u32(& m_max_page_index.m_u32, 1);
}
pthread_mutex_unlock(& m_critical_section);
// ==================================================================
// END CRITICAL SECTION -- buffer expand
// ==================================================================
}
assert(array != NULL);
pfs= array->allocate(dirty_state);
if (pfs != NULL)
{
/* Keep a pointer to the parent page, for deallocate(). */
pfs->m_page= reinterpret_cast<PFS_opaque_container_page *> (array);
return pfs;
}
current_page_count++;
}
m_lost++;
m_full= true;
return NULL;
}
|
O3
|
c
|
PFS_buffer_scalable_container<PFS_table_share_index, 8192, 8192, PFS_buffer_default_array<PFS_table_share_index>, PFS_buffer_default_allocator<PFS_table_share_index>>::allocate(pfs_dirty_state*):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %rbx
cmpb $0x1, 0x9(%rdi)
jne 0x3a852
incq (%rbx)
jmp 0x3a9ac
movl 0x58(%rbx), %r12d
testl %r12d, %r12d
je 0x3a89a
movl 0x18(%rbx), %eax
leal (%rax,%r12), %r14d
cmpl %r14d, %eax
jae 0x3a89a
xorl %edx, %edx
divl %r12d
movq 0xa8(%rbx,%rdx,8), %r15
testq %r15, %r15
je 0x3a88e
movq %r15, %rdi
movq -0x38(%rbp), %rsi
callq 0x3b7b6
testq %rax, %rax
jne 0x3a9c6
movl $0x1, %eax
lock
xaddl %eax, 0x18(%rbx)
jmp 0x3a862
cmpq %r12, 0x98(%rbx)
jbe 0x3a9a5
leaq 0x20b0(%rbx), %r14
leal 0x1(%r12), %r15d
movl $0xc0, %eax
addq 0x2df701(%rip), %rax # 0x319fc0
movq %rax, -0x48(%rbp)
movq %r14, -0x30(%rbp)
movq 0xa8(%rbx,%r12,8), %r13
movl %r15d, %eax
movq %rax, -0x40(%rbp)
testq %r13, %r13
jne 0x3a979
movq %r14, %rdi
callq 0x264e0
movq 0xa8(%rbx,%r12,8), %r13
testq %r13, %r13
jne 0x3a971
movl $0x60, %edi
callq 0x26330
movq %rax, %r13
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movl $0x60, %esi
movq -0x48(%rbp), %rdi
callq 0x33126
movq -0x40(%rbp), %rax
cmpq %rax, 0x98(%rbx)
movl 0xa0(%rbx), %eax
movl $0x400, %ecx # imm = 0x400
cmovaq %rcx, %rax
movq %rax, 0x50(%r13)
movq 0x20a8(%rbx), %rdi
movq %r13, %rsi
callq 0x3b81e
testl %eax, %eax
jne 0x3a9cf
movq %rbx, 0x58(%r13)
movq %r13, %rax
xchgq %rax, 0xa8(%rbx,%r12,8)
lock
incl 0x58(%rbx)
movq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x26250
movq %r13, %rdi
movq -0x38(%rbp), %rsi
callq 0x3b7b6
testq %rax, %rax
jne 0x3a9bd
incl %r15d
movq -0x40(%rbp), %rax
movq %rax, %r12
cmpq %rax, 0x98(%rbx)
movq -0x30(%rbp), %r14
ja 0x3a8c7
incq (%rbx)
movb $0x1, 0x9(%rbx)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, 0x2420(%rax)
jmp 0x3a9ae
movq %r15, 0x2420(%rax)
jmp 0x3a9ae
movq 0x20a8(%rbx), %rax
movq (%rax), %rdi
movq 0x48(%r13), %rcx
movq 0x50(%r13), %rsi
movl $0x2440, %edx # imm = 0x2440
callq 0x3628b
movl $0x60, %esi
movq %r13, %rdi
callq 0x26340
movl $0xc0, %edi
addq 0x2df5bc(%rip), %rdi # 0x319fc0
movl $0x60, %esi
callq 0x3315c
incq (%rbx)
movq -0x30(%rbp), %rdi
callq 0x26250
jmp 0x3a9ac
|
_ZN29PFS_buffer_scalable_containerI9PFS_tableLi1024ELi1024E24PFS_buffer_default_arrayIS0_E28PFS_buffer_default_allocatorIS0_EE8allocateEP15pfs_dirty_state:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rbp+var_38], rsi
mov rbx, rdi
cmp byte ptr [rdi+9], 1
jnz short loc_3A852
inc qword ptr [rbx]
jmp loc_3A9AC
loc_3A852:
mov r12d, [rbx+58h]
test r12d, r12d
jz short loc_3A89A
mov eax, [rbx+18h]
lea r14d, [rax+r12]
loc_3A862:
cmp eax, r14d
jnb short loc_3A89A
xor edx, edx
div r12d
mov r15, [rbx+rdx*8+0A8h]
test r15, r15
jz short loc_3A88E
mov rdi, r15
mov rsi, [rbp+var_38]
call _ZN24PFS_buffer_default_arrayI9PFS_tableE8allocateEP15pfs_dirty_state; PFS_buffer_default_array<PFS_table>::allocate(pfs_dirty_state *)
test rax, rax
jnz loc_3A9C6
loc_3A88E:
mov eax, 1
lock xadd [rbx+18h], eax
jmp short loc_3A862
loc_3A89A:
cmp [rbx+98h], r12
jbe loc_3A9A5
lea r14, [rbx+20B0h]
lea r15d, [r12+1]
mov eax, 0C0h
add rax, cs:builtin_memory_scalable_buffer_ptr
mov [rbp+var_48], rax
mov [rbp+var_30], r14
loc_3A8C7:
mov r13, [rbx+r12*8+0A8h]
mov eax, r15d
mov [rbp+var_40], rax
test r13, r13
jnz loc_3A979
mov rdi, r14
call _pthread_mutex_lock
mov r13, [rbx+r12*8+0A8h]
test r13, r13
jnz short loc_3A971
mov edi, 60h ; '`'; unsigned __int64
call __Znwm; operator new(ulong)
mov r13, rax
xorps xmm0, xmm0
movaps xmmword ptr [rax], xmm0
movaps xmmword ptr [rax+10h], xmm0
movaps xmmword ptr [rax+20h], xmm0
movaps xmmword ptr [rax+30h], xmm0
movaps xmmword ptr [rax+40h], xmm0
movaps xmmword ptr [rax+50h], xmm0
mov esi, 60h ; '`'; unsigned __int64
mov rdi, [rbp+var_48]; this
call _ZN15PFS_memory_stat19count_builtin_allocEm; PFS_memory_stat::count_builtin_alloc(ulong)
mov rax, [rbp+var_40]
cmp [rbx+98h], rax
mov eax, [rbx+0A0h]
mov ecx, 400h
cmova rax, rcx
mov [r13+50h], rax
mov rdi, [rbx+20A8h]
mov rsi, r13
call _ZN28PFS_buffer_default_allocatorI9PFS_tableE11alloc_arrayEP24PFS_buffer_default_arrayIS0_E; PFS_buffer_default_allocator<PFS_table>::alloc_array(PFS_buffer_default_array<PFS_table> *)
test eax, eax
jnz short loc_3A9CF
mov [r13+58h], rbx
mov rax, r13
xchg rax, [rbx+r12*8+0A8h]
lock inc dword ptr [rbx+58h]
mov r14, [rbp+var_30]
loc_3A971:
mov rdi, r14
call _pthread_mutex_unlock
loc_3A979:
mov rdi, r13
mov rsi, [rbp+var_38]
call _ZN24PFS_buffer_default_arrayI9PFS_tableE8allocateEP15pfs_dirty_state; PFS_buffer_default_array<PFS_table>::allocate(pfs_dirty_state *)
test rax, rax
jnz short loc_3A9BD
inc r15d
mov rax, [rbp+var_40]
mov r12, rax
cmp [rbx+98h], rax
mov r14, [rbp+var_30]
ja loc_3A8C7
loc_3A9A5:
inc qword ptr [rbx]
mov byte ptr [rbx+9], 1
loc_3A9AC:
xor eax, eax
loc_3A9AE:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3A9BD:
mov [rax+2420h], r13
jmp short loc_3A9AE
loc_3A9C6:
mov [rax+2420h], r15
jmp short loc_3A9AE
loc_3A9CF:
mov rax, [rbx+20A8h]
mov rdi, [rax]
mov rcx, [r13+48h]
mov rsi, [r13+50h]
mov edx, 2440h
call _Z14pfs_free_arrayP24PFS_builtin_memory_classmmPv; pfs_free_array(PFS_builtin_memory_class *,ulong,ulong,void *)
mov esi, 60h ; '`'; unsigned __int64
mov rdi, r13; void *
call __ZdlPvm; operator delete(void *,ulong)
mov edi, 0C0h
add rdi, cs:builtin_memory_scalable_buffer_ptr; this
mov esi, 60h ; '`'; unsigned __int64
call _ZN15PFS_memory_stat18count_builtin_freeEm; PFS_memory_stat::count_builtin_free(ulong)
inc qword ptr [rbx]
mov rdi, [rbp+var_30]
call _pthread_mutex_unlock
jmp short loc_3A9AC
|
long long PFS_buffer_scalable_container<PFS_table,1024,1024,PFS_buffer_default_array<PFS_table>,PFS_buffer_default_allocator<PFS_table>>::allocate(
long long a1,
long long a2)
{
unsigned long long v2; // r12
unsigned __int32 v3; // eax
unsigned __int32 v4; // r14d
long long v5; // rdx
long long v6; // r15
long long result; // rax
long long v8; // r14
unsigned int v9; // r15d
long long v10; // r13
long long v11; // rax
unsigned long long v12; // [rsp+10h] [rbp-40h]
if ( *(_BYTE *)(a1 + 9) == 1 )
{
++*(_QWORD *)a1;
return 0LL;
}
v2 = *(unsigned int *)(a1 + 88);
if ( (_DWORD)v2 )
{
v3 = *(_DWORD *)(a1 + 24);
v4 = v3 + v2;
while ( v3 < v4 )
{
v5 = v3 % (unsigned int)v2;
v6 = *(_QWORD *)(a1 + 8 * v5 + 168);
if ( v6 )
{
result = PFS_buffer_default_array<PFS_table>::allocate(*(_QWORD *)(a1 + 8 * v5 + 168), a2);
if ( result )
{
*(_QWORD *)(result + 9248) = v6;
return result;
}
}
v3 = _InterlockedExchangeAdd((volatile signed __int32 *)(a1 + 24), 1u);
}
}
if ( *(_QWORD *)(a1 + 152) <= v2 )
{
LABEL_20:
++*(_QWORD *)a1;
*(_BYTE *)(a1 + 9) = 1;
return 0LL;
}
v8 = a1 + 8368;
v9 = v2 + 1;
while ( 1 )
{
v10 = *(_QWORD *)(a1 + 8 * v2 + 168);
v12 = v9;
if ( v10 )
goto LABEL_18;
pthread_mutex_lock(v8);
v10 = *(_QWORD *)(a1 + 8 * v2 + 168);
if ( !v10 )
break;
LABEL_17:
pthread_mutex_unlock(v8);
LABEL_18:
result = PFS_buffer_default_array<PFS_table>::allocate(v10, a2);
if ( result )
{
*(_QWORD *)(result + 9248) = v10;
return result;
}
++v9;
v2 = v12;
v8 = a1 + 8368;
if ( *(_QWORD *)(a1 + 152) <= v12 )
goto LABEL_20;
}
v10 = operator new(0x60uLL);
*(_OWORD *)v10 = 0LL;
*(_OWORD *)(v10 + 16) = 0LL;
*(_OWORD *)(v10 + 32) = 0LL;
*(_OWORD *)(v10 + 48) = 0LL;
*(_OWORD *)(v10 + 64) = 0LL;
*(_OWORD *)(v10 + 80) = 0LL;
PFS_memory_stat::count_builtin_alloc((PFS_memory_stat *)&builtin_memory_scalable_buffer[12], 0x60uLL);
v11 = *(unsigned int *)(a1 + 160);
if ( *(_QWORD *)(a1 + 152) > (unsigned long long)v9 )
v11 = 1024LL;
*(_QWORD *)(v10 + 80) = v11;
if ( !(unsigned int)PFS_buffer_default_allocator<PFS_table>::alloc_array(*(_QWORD *)(a1 + 8360), v10) )
{
*(_QWORD *)(v10 + 88) = a1;
_InterlockedExchange64((volatile long long *)(a1 + 8 * v2 + 168), v10);
_InterlockedIncrement((volatile signed __int32 *)(a1 + 88));
v8 = a1 + 8368;
goto LABEL_17;
}
pfs_free_array(**(__m128i ***)(a1 + 8360), *(_QWORD *)(v10 + 80), 9280LL, *(_QWORD *)(v10 + 72));
operator delete((void *)v10, 0x60uLL);
PFS_memory_stat::count_builtin_free(&builtin_memory_scalable_buffer[12], 0x60uLL);
++*(_QWORD *)a1;
pthread_mutex_unlock(a1 + 8368);
return 0LL;
}
|
allocate:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x38],RSI
MOV RBX,RDI
CMP byte ptr [RDI + 0x9],0x1
JNZ 0x0013a852
INC qword ptr [RBX]
JMP 0x0013a9ac
LAB_0013a852:
MOV R12D,dword ptr [RBX + 0x58]
TEST R12D,R12D
JZ 0x0013a89a
MOV EAX,dword ptr [RBX + 0x18]
LEA R14D,[RAX + R12*0x1]
LAB_0013a862:
CMP EAX,R14D
JNC 0x0013a89a
XOR EDX,EDX
DIV R12D
MOV R15,qword ptr [RBX + RDX*0x8 + 0xa8]
TEST R15,R15
JZ 0x0013a88e
MOV RDI,R15
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x0013b7b6
TEST RAX,RAX
JNZ 0x0013a9c6
LAB_0013a88e:
MOV EAX,0x1
XADD.LOCK dword ptr [RBX + 0x18],EAX
JMP 0x0013a862
LAB_0013a89a:
CMP qword ptr [RBX + 0x98],R12
JBE 0x0013a9a5
LEA R14,[RBX + 0x20b0]
LEA R15D,[R12 + 0x1]
MOV EAX,0xc0
ADD RAX,qword ptr [0x00419fc0]
MOV qword ptr [RBP + -0x48],RAX
MOV qword ptr [RBP + -0x30],R14
LAB_0013a8c7:
MOV R13,qword ptr [RBX + R12*0x8 + 0xa8]
MOV EAX,R15D
MOV qword ptr [RBP + -0x40],RAX
TEST R13,R13
JNZ 0x0013a979
MOV RDI,R14
CALL 0x001264e0
MOV R13,qword ptr [RBX + R12*0x8 + 0xa8]
TEST R13,R13
JNZ 0x0013a971
MOV EDI,0x60
CALL 0x00126330
MOV R13,RAX
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RAX],XMM0
MOVAPS xmmword ptr [RAX + 0x10],XMM0
MOVAPS xmmword ptr [RAX + 0x20],XMM0
MOVAPS xmmword ptr [RAX + 0x30],XMM0
MOVAPS xmmword ptr [RAX + 0x40],XMM0
MOVAPS xmmword ptr [RAX + 0x50],XMM0
MOV ESI,0x60
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x00133126
MOV RAX,qword ptr [RBP + -0x40]
CMP qword ptr [RBX + 0x98],RAX
MOV EAX,dword ptr [RBX + 0xa0]
MOV ECX,0x400
CMOVA RAX,RCX
MOV qword ptr [R13 + 0x50],RAX
MOV RDI,qword ptr [RBX + 0x20a8]
MOV RSI,R13
CALL 0x0013b81e
TEST EAX,EAX
JNZ 0x0013a9cf
MOV qword ptr [R13 + 0x58],RBX
MOV RAX,R13
XCHG qword ptr [RBX + R12*0x8 + 0xa8],RAX
INC.LOCK dword ptr [RBX + 0x58]
MOV R14,qword ptr [RBP + -0x30]
LAB_0013a971:
MOV RDI,R14
CALL 0x00126250
LAB_0013a979:
MOV RDI,R13
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x0013b7b6
TEST RAX,RAX
JNZ 0x0013a9bd
INC R15D
MOV RAX,qword ptr [RBP + -0x40]
MOV R12,RAX
CMP qword ptr [RBX + 0x98],RAX
MOV R14,qword ptr [RBP + -0x30]
JA 0x0013a8c7
LAB_0013a9a5:
INC qword ptr [RBX]
MOV byte ptr [RBX + 0x9],0x1
LAB_0013a9ac:
XOR EAX,EAX
LAB_0013a9ae:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013a9bd:
MOV qword ptr [RAX + 0x2420],R13
JMP 0x0013a9ae
LAB_0013a9c6:
MOV qword ptr [RAX + 0x2420],R15
JMP 0x0013a9ae
LAB_0013a9cf:
MOV RAX,qword ptr [RBX + 0x20a8]
MOV RDI,qword ptr [RAX]
MOV RCX,qword ptr [R13 + 0x48]
MOV RSI,qword ptr [R13 + 0x50]
MOV EDX,0x2440
CALL 0x0013628b
MOV ESI,0x60
MOV RDI,R13
CALL 0x00126340
MOV EDI,0xc0
ADD RDI,qword ptr [0x00419fc0]
MOV ESI,0x60
CALL 0x0013315c
INC qword ptr [RBX]
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00126250
JMP 0x0013a9ac
|
/* PFS_buffer_scalable_container<PFS_table, 1024, 1024, PFS_buffer_default_array<PFS_table>,
PFS_buffer_default_allocator<PFS_table> >::allocate(pfs_dirty_state*) */
long __thiscall
PFS_buffer_scalable_container<PFS_table,1024,1024,PFS_buffer_default_array<PFS_table>,PFS_buffer_default_allocator<PFS_table>>
::allocate(PFS_buffer_scalable_container<PFS_table,1024,1024,PFS_buffer_default_array<PFS_table>,PFS_buffer_default_allocator<PFS_table>>
*this,pfs_dirty_state *param_1)
{
PFS_buffer_scalable_container<PFS_table,1024,1024,PFS_buffer_default_array<PFS_table>,PFS_buffer_default_allocator<PFS_table>>
*pPVar1;
pthread_mutex_t *__mutex;
uint uVar2;
int iVar3;
long lVar4;
PFS_memory_stat *this_00;
ulong uVar5;
PFS_buffer_default_array<PFS_table> *pPVar6;
ulong uVar7;
ulong uVar8;
uint uVar9;
uint uVar10;
if (this[9] ==
(PFS_buffer_scalable_container<PFS_table,1024,1024,PFS_buffer_default_array<PFS_table>,PFS_buffer_default_allocator<PFS_table>>
)0x1) {
*(long *)this = *(long *)this + 1;
}
else {
uVar10 = *(uint *)(this + 0x58);
uVar8 = (ulong)uVar10;
if (uVar10 != 0) {
uVar2 = *(uint *)(this + 0x18);
uVar9 = uVar2 + uVar10;
while (uVar2 < uVar9) {
pPVar6 = *(PFS_buffer_default_array<PFS_table> **)(this + ((ulong)uVar2 % uVar8) * 8 + 0xa8)
;
if ((pPVar6 != (PFS_buffer_default_array<PFS_table> *)0x0) &&
(lVar4 = PFS_buffer_default_array<PFS_table>::allocate(pPVar6,param_1), lVar4 != 0)) {
*(PFS_buffer_default_array<PFS_table> **)(lVar4 + 0x2420) = pPVar6;
return lVar4;
}
LOCK();
pPVar1 = this + 0x18;
uVar2 = *(uint *)pPVar1;
*(uint *)pPVar1 = *(uint *)pPVar1 + 1;
UNLOCK();
}
}
if (uVar8 < *(ulong *)(this + 0x98)) {
__mutex = (pthread_mutex_t *)(this + 0x20b0);
this_00 = (PFS_memory_stat *)(PTR_builtin_memory_scalable_buffer_00419fc0 + 0xc0);
do {
uVar10 = uVar10 + 1;
pPVar6 = *(PFS_buffer_default_array<PFS_table> **)(this + uVar8 * 8 + 0xa8);
uVar5 = (ulong)uVar10;
if (pPVar6 == (PFS_buffer_default_array<PFS_table> *)0x0) {
pthread_mutex_lock(__mutex);
pPVar6 = *(PFS_buffer_default_array<PFS_table> **)(this + uVar8 * 8 + 0xa8);
if (pPVar6 == (PFS_buffer_default_array<PFS_table> *)0x0) {
pPVar6 = (PFS_buffer_default_array<PFS_table> *)operator_new(0x60);
*(int8 *)pPVar6 = 0;
*(int8 *)((PFS_buffer_default_array *)pPVar6 + 8) = 0;
*(int8 *)((PFS_buffer_default_array *)pPVar6 + 0x10) = 0;
*(int8 *)((PFS_buffer_default_array *)pPVar6 + 0x18) = 0;
*(int8 *)((PFS_buffer_default_array *)pPVar6 + 0x20) = 0;
*(int8 *)((PFS_buffer_default_array *)pPVar6 + 0x28) = 0;
*(int8 *)((PFS_buffer_default_array *)pPVar6 + 0x30) = 0;
*(int8 *)((PFS_buffer_default_array *)pPVar6 + 0x38) = 0;
*(int8 *)((PFS_buffer_default_array *)pPVar6 + 0x40) = 0;
*(int8 *)((PFS_buffer_default_array *)pPVar6 + 0x48) = 0;
*(int8 *)((PFS_buffer_default_array *)pPVar6 + 0x50) = 0;
*(int8 *)((PFS_buffer_default_array *)pPVar6 + 0x58) = 0;
PFS_memory_stat::count_builtin_alloc(this_00,0x60);
uVar7 = (ulong)*(uint *)(this + 0xa0);
if (uVar5 < *(ulong *)(this + 0x98)) {
uVar7 = 0x400;
}
*(ulong *)((PFS_buffer_default_array *)pPVar6 + 0x50) = uVar7;
iVar3 = PFS_buffer_default_allocator<PFS_table>::alloc_array
(*(PFS_buffer_default_allocator<PFS_table> **)(this + 0x20a8),
(PFS_buffer_default_array *)pPVar6);
if (iVar3 != 0) {
pfs_free_array((PFS_builtin_memory_class *)**(int8 **)(this + 0x20a8),
*(ulong *)((PFS_buffer_default_array *)pPVar6 + 0x50),0x2440,
*(void **)((PFS_buffer_default_array *)pPVar6 + 0x48));
operator_delete(pPVar6,0x60);
PFS_memory_stat::count_builtin_free
((PFS_memory_stat *)(PTR_builtin_memory_scalable_buffer_00419fc0 + 0xc0),
0x60);
*(long *)this = *(long *)this + 1;
pthread_mutex_unlock(__mutex);
return 0;
}
*(PFS_buffer_scalable_container<PFS_table,1024,1024,PFS_buffer_default_array<PFS_table>,PFS_buffer_default_allocator<PFS_table>>
**)((PFS_buffer_default_array *)pPVar6 + 0x58) = this;
LOCK();
*(PFS_buffer_default_array<PFS_table> **)(this + uVar8 * 8 + 0xa8) = pPVar6;
UNLOCK();
LOCK();
*(int *)(this + 0x58) = *(int *)(this + 0x58) + 1;
UNLOCK();
}
pthread_mutex_unlock(__mutex);
}
lVar4 = PFS_buffer_default_array<PFS_table>::allocate(pPVar6,param_1);
if (lVar4 != 0) {
*(PFS_buffer_default_array<PFS_table> **)(lVar4 + 0x2420) = pPVar6;
return lVar4;
}
uVar8 = uVar5;
} while (uVar5 < *(ulong *)(this + 0x98));
}
*(long *)this = *(long *)this + 1;
this[9] = (PFS_buffer_scalable_container<PFS_table,1024,1024,PFS_buffer_default_array<PFS_table>,PFS_buffer_default_allocator<PFS_table>>
)0x1;
}
return 0;
}
|
|
6,876 |
ftb_climb_the_tree
|
eloqsql/storage/myisam/ft_boolean_search.c
|
static int _ftb_climb_the_tree(FTB *ftb, FTB_WORD *ftbw, FT_SEG_ITERATOR *ftsi_orig)
{
FT_SEG_ITERATOR ftsi;
FTB_EXPR *ftbe;
float weight=ftbw->weight;
int yn_flag= ftbw->flags, ythresh, mode=(ftsi_orig != 0);
my_off_t curdoc=ftbw->docid[mode];
struct st_mysql_ftparser *parser= ftb->keynr == NO_SUCH_KEY ?
&ft_default_parser :
ftb->info->s->keyinfo[ftb->keynr].parser;
for (ftbe=ftbw->up; ftbe; ftbe=ftbe->up)
{
ythresh = ftbe->ythresh - (mode ? 0 : ftbe->yweaks);
if (ftbe->docid[mode] != curdoc)
{
ftbe->cur_weight=0;
ftbe->yesses=ftbe->nos=0;
ftbe->docid[mode]=curdoc;
}
if (ftbe->nos)
break;
if (yn_flag & FTB_FLAG_YES)
{
weight /= ftbe->ythresh;
ftbe->cur_weight += weight;
if ((int) ++ftbe->yesses == ythresh)
{
yn_flag=ftbe->flags;
weight=ftbe->cur_weight*ftbe->weight;
if (mode && ftbe->phrase)
{
int found= 0;
memcpy(&ftsi, ftsi_orig, sizeof(ftsi));
while (_mi_ft_segiterator(&ftsi) && !found)
{
if (!ftsi.pos)
continue;
found= _ftb_check_phrase(ftb, ftsi.pos, ftsi.len, ftbe, parser);
if (unlikely(found < 0))
return 1;
}
if (!found)
break;
} /* ftbe->quot */
}
else
break;
}
else
if (yn_flag & FTB_FLAG_NO)
{
/*
NOTE: special sort function of queue assures that all
(yn_flag & FTB_FLAG_NO) != 0
events for every particular subexpression will
"auto-magically" happen BEFORE all the
(yn_flag & FTB_FLAG_YES) != 0 events. So no
already matched expression can become not-matched again.
*/
++ftbe->nos;
break;
}
else
{
if (ftbe->ythresh)
weight/=3;
ftbe->cur_weight += weight;
if ((int) ftbe->yesses < ythresh)
break;
if (!(yn_flag & FTB_FLAG_WONLY))
yn_flag= ((int) ftbe->yesses++ == ythresh) ? ftbe->flags : FTB_FLAG_WONLY ;
weight*= ftbe->weight;
}
}
return 0;
}
|
O0
|
c
|
ftb_climb_the_tree:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movss 0x40(%rax), %xmm0
movss %xmm0, -0x4c(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x50(%rbp)
cmpq $0x0, -0x20(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movslq -0x58(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x340(%rax)
jne 0x9ecba
leaq 0x2204cc(%rip), %rax # 0x2bf180
movq %rax, -0x78(%rbp)
jmp 0x9ece5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x218(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x340(%rcx), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq 0x38(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x9efa3
movq -0x48(%rbp), %rax
movl 0x48(%rax), %eax
movl %eax, -0x7c(%rbp)
cmpl $0x0, -0x58(%rbp)
je 0x9ed1a
xorl %eax, %eax
movl %eax, -0x80(%rbp)
jmp 0x9ed24
movq -0x48(%rbp), %rax
movl 0x4c(%rax), %eax
movl %eax, -0x80(%rbp)
movl -0x7c(%rbp), %eax
movl -0x80(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x54(%rbp)
movq -0x48(%rbp), %rax
movslq -0x58(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rax
cmpq -0x60(%rbp), %rax
je 0x9ed75
movq -0x48(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x2c(%rax)
movq -0x48(%rbp), %rax
movl $0x0, 0x44(%rax)
movq -0x48(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x60(%rbp), %rdx
movq -0x48(%rbp), %rax
movslq -0x58(%rbp), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
movq -0x48(%rbp), %rax
cmpl $0x0, 0x44(%rax)
je 0x9ed84
jmp 0x9efa3
movl -0x50(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x9eeda
movq -0x48(%rbp), %rax
movl 0x48(%rax), %eax
cvtsi2ss %rax, %xmm1
movss -0x4c(%rbp), %xmm0
divss %xmm1, %xmm0
movss %xmm0, -0x4c(%rbp)
movss -0x4c(%rbp), %xmm0
movq -0x48(%rbp), %rax
addss 0x2c(%rax), %xmm0
movss %xmm0, 0x2c(%rax)
movq -0x48(%rbp), %rcx
movl 0x40(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x40(%rcx)
cmpl -0x54(%rbp), %eax
jne 0x9eed0
movq -0x48(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movss 0x2c(%rax), %xmm0
movq -0x48(%rbp), %rax
mulss 0x28(%rax), %xmm0
movss %xmm0, -0x4c(%rbp)
cmpl $0x0, -0x58(%rbp)
je 0x9eece
movq -0x48(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x9eece
movl $0x0, -0x6c(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xa2bd0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x81(%rbp)
je 0x9ee61
cmpl $0x0, -0x6c(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0x81(%rbp)
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x9ee6d
jmp 0x9eec1
cmpq $0x0, -0x28(%rbp)
jne 0x9ee76
jmp 0x9ee3a
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x3c(%rbp), %edx
movq -0x48(%rbp), %rcx
movq -0x68(%rbp), %r8
callq 0x9fef0
movl %eax, -0x6c(%rbp)
cmpl $0x0, -0x6c(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x9eebc
movl $0x1, -0x4(%rbp)
jmp 0x9efaa
jmp 0x9ee3a
cmpl $0x0, -0x6c(%rbp)
jne 0x9eecc
jmp 0x9efa3
jmp 0x9eece
jmp 0x9eed5
jmp 0x9efa3
jmp 0x9ef91
movl -0x50(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x9eef7
movq -0x48(%rbp), %rax
movl 0x44(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x44(%rax)
jmp 0x9efa3
movq -0x48(%rbp), %rax
cmpl $0x0, 0x48(%rax)
je 0x9ef17
movss -0x4c(%rbp), %xmm0
movss 0xb20fe(%rip), %xmm1 # 0x15100c
divss %xmm1, %xmm0
movss %xmm0, -0x4c(%rbp)
movss -0x4c(%rbp), %xmm0
movq -0x48(%rbp), %rax
addss 0x2c(%rax), %xmm0
movss %xmm0, 0x2c(%rax)
movq -0x48(%rbp), %rax
movl 0x40(%rax), %eax
cmpl -0x54(%rbp), %eax
jge 0x9ef38
jmp 0x9efa3
movl -0x50(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x9ef7c
movq -0x48(%rbp), %rcx
movl 0x40(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x40(%rcx)
cmpl -0x54(%rbp), %eax
jne 0x9ef66
movq -0x48(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x88(%rbp)
jmp 0x9ef73
movl $0x8, %eax
movl %eax, -0x88(%rbp)
jmp 0x9ef73
movl -0x88(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movss 0x28(%rax), %xmm0
mulss -0x4c(%rbp), %xmm0
movss %xmm0, -0x4c(%rbp)
jmp 0x9ef91
jmp 0x9ef93
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x9ecf8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ftb_climb_the_tree:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_18]
movss xmm0, dword ptr [rax+40h]
movss [rbp+var_4C], xmm0
mov rax, [rbp+var_18]
mov eax, [rax+8]
mov [rbp+var_50], eax
cmp [rbp+var_20], 0
setnz al
and al, 1
movzx eax, al
mov [rbp+var_58], eax
mov rax, [rbp+var_18]
movsxd rcx, [rbp+var_58]
mov rax, [rax+rcx*8+10h]
mov [rbp+var_60], rax
mov rax, [rbp+var_10]
cmp dword ptr [rax+340h], 0FFFFFFFFh
jnz short loc_9ECBA
lea rax, ft_default_parser
mov [rbp+var_78], rax
jmp short loc_9ECE5
loc_9ECBA:
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov rax, [rax]
mov rax, [rax+218h]
mov rcx, [rbp+var_10]
mov ecx, [rcx+340h]
imul rcx, 70h ; 'p'
add rax, rcx
mov rax, [rax+38h]
mov [rbp+var_78], rax
loc_9ECE5:
mov rax, [rbp+var_78]
mov [rbp+var_68], rax
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_48], rax
loc_9ECF8:
cmp [rbp+var_48], 0
jz loc_9EFA3
mov rax, [rbp+var_48]
mov eax, [rax+48h]
mov [rbp+var_7C], eax
cmp [rbp+var_58], 0
jz short loc_9ED1A
xor eax, eax
mov [rbp+var_80], eax
jmp short loc_9ED24
loc_9ED1A:
mov rax, [rbp+var_48]
mov eax, [rax+4Ch]
mov [rbp+var_80], eax
loc_9ED24:
mov eax, [rbp+var_7C]
mov ecx, [rbp+var_80]
sub eax, ecx
mov [rbp+var_54], eax
mov rax, [rbp+var_48]
movsxd rcx, [rbp+var_58]
mov rax, [rax+rcx*8+10h]
cmp rax, [rbp+var_60]
jz short loc_9ED75
mov rax, [rbp+var_48]
xorps xmm0, xmm0
movss dword ptr [rax+2Ch], xmm0
mov rax, [rbp+var_48]
mov dword ptr [rax+44h], 0
mov rax, [rbp+var_48]
mov dword ptr [rax+40h], 0
mov rdx, [rbp+var_60]
mov rax, [rbp+var_48]
movsxd rcx, [rbp+var_58]
mov [rax+rcx*8+10h], rdx
loc_9ED75:
mov rax, [rbp+var_48]
cmp dword ptr [rax+44h], 0
jz short loc_9ED84
jmp loc_9EFA3
loc_9ED84:
mov eax, [rbp+var_50]
and eax, 2
cmp eax, 0
jz loc_9EEDA
mov rax, [rbp+var_48]
mov eax, [rax+48h]
cvtsi2ss xmm1, rax
movss xmm0, [rbp+var_4C]
divss xmm0, xmm1
movss [rbp+var_4C], xmm0
movss xmm0, [rbp+var_4C]
mov rax, [rbp+var_48]
addss xmm0, dword ptr [rax+2Ch]
movss dword ptr [rax+2Ch], xmm0
mov rcx, [rbp+var_48]
mov eax, [rcx+40h]
add eax, 1
mov [rcx+40h], eax
cmp eax, [rbp+var_54]
jnz loc_9EED0
mov rax, [rbp+var_48]
mov eax, [rax+8]
mov [rbp+var_50], eax
mov rax, [rbp+var_48]
movss xmm0, dword ptr [rax+2Ch]
mov rax, [rbp+var_48]
mulss xmm0, dword ptr [rax+28h]
movss [rbp+var_4C], xmm0
cmp [rbp+var_58], 0
jz loc_9EECE
mov rax, [rbp+var_48]
cmp qword ptr [rax+30h], 0
jz loc_9EECE
mov [rbp+var_6C], 0
mov rax, [rbp+var_20]
mov rcx, [rax]
mov [rbp+var_40], rcx
mov rcx, [rax+8]
mov [rbp+var_38], rcx
mov rcx, [rax+10h]
mov [rbp+var_30], rcx
mov rax, [rax+18h]
mov [rbp+var_28], rax
loc_9EE3A:
lea rdi, [rbp+var_40]
call _mi_ft_segiterator
mov ecx, eax
xor eax, eax
cmp ecx, 0
mov [rbp+var_81], al
jz short loc_9EE61
cmp [rbp+var_6C], 0
setnz al
xor al, 0FFh
mov [rbp+var_81], al
loc_9EE61:
mov al, [rbp+var_81]
test al, 1
jnz short loc_9EE6D
jmp short loc_9EEC1
loc_9EE6D:
cmp [rbp+var_28], 0
jnz short loc_9EE76
jmp short loc_9EE3A
loc_9EE76:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov edx, dword ptr [rbp+var_40+4]
mov rcx, [rbp+var_48]
mov r8, [rbp+var_68]
call _ftb_check_phrase
mov [rbp+var_6C], eax
cmp [rbp+var_6C], 0
setl 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_9EEBC
mov [rbp+var_4], 1
jmp loc_9EFAA
loc_9EEBC:
jmp loc_9EE3A
loc_9EEC1:
cmp [rbp+var_6C], 0
jnz short loc_9EECC
jmp loc_9EFA3
loc_9EECC:
jmp short $+2
loc_9EECE:
jmp short loc_9EED5
loc_9EED0:
jmp loc_9EFA3
loc_9EED5:
jmp loc_9EF91
loc_9EEDA:
mov eax, [rbp+var_50]
and eax, 4
cmp eax, 0
jz short loc_9EEF7
mov rax, [rbp+var_48]
mov ecx, [rax+44h]
add ecx, 1
mov [rax+44h], ecx
jmp loc_9EFA3
loc_9EEF7:
mov rax, [rbp+var_48]
cmp dword ptr [rax+48h], 0
jz short loc_9EF17
movss xmm0, [rbp+var_4C]
movss xmm1, cs:dword_15100C
divss xmm0, xmm1
movss [rbp+var_4C], xmm0
loc_9EF17:
movss xmm0, [rbp+var_4C]
mov rax, [rbp+var_48]
addss xmm0, dword ptr [rax+2Ch]
movss dword ptr [rax+2Ch], xmm0
mov rax, [rbp+var_48]
mov eax, [rax+40h]
cmp eax, [rbp+var_54]
jge short loc_9EF38
jmp short loc_9EFA3
loc_9EF38:
mov eax, [rbp+var_50]
and eax, 8
cmp eax, 0
jnz short loc_9EF7C
mov rcx, [rbp+var_48]
mov eax, [rcx+40h]
mov edx, eax
add edx, 1
mov [rcx+40h], edx
cmp eax, [rbp+var_54]
jnz short loc_9EF66
mov rax, [rbp+var_48]
mov eax, [rax+8]
mov [rbp+var_88], eax
jmp short loc_9EF73
loc_9EF66:
mov eax, 8
mov [rbp+var_88], eax
jmp short $+2
loc_9EF73:
mov eax, [rbp+var_88]
mov [rbp+var_50], eax
loc_9EF7C:
mov rax, [rbp+var_48]
movss xmm0, dword ptr [rax+28h]
mulss xmm0, [rbp+var_4C]
movss [rbp+var_4C], xmm0
jmp short $+2
loc_9EF91:
jmp short $+2
loc_9EF93:
mov rax, [rbp+var_48]
mov rax, [rax]
mov [rbp+var_48], rax
jmp loc_9ECF8
loc_9EFA3:
mov [rbp+var_4], 0
loc_9EFAA:
mov eax, [rbp+var_4]
add rsp, 90h
pop rbp
retn
|
long long ftb_climb_the_tree(long long a1, long long a2, _QWORD *a3)
{
int v3; // eax
int v4; // eax
int v6; // [rsp+8h] [rbp-88h]
char v7; // [rsp+Fh] [rbp-81h]
int v8; // [rsp+10h] [rbp-80h]
void *v9; // [rsp+18h] [rbp-78h]
int v10; // [rsp+24h] [rbp-6Ch]
long long v11; // [rsp+30h] [rbp-60h]
BOOL v12; // [rsp+38h] [rbp-58h]
int v13; // [rsp+3Ch] [rbp-54h]
int v14; // [rsp+40h] [rbp-50h]
float v15; // [rsp+44h] [rbp-4Ch]
long long *i; // [rsp+48h] [rbp-48h]
_QWORD v17[3]; // [rsp+50h] [rbp-40h] BYREF
long long v18; // [rsp+68h] [rbp-28h]
_QWORD *v19; // [rsp+70h] [rbp-20h]
long long **v20; // [rsp+78h] [rbp-18h]
long long v21; // [rsp+80h] [rbp-10h]
v21 = a1;
v20 = (long long **)a2;
v19 = a3;
v15 = *(float *)(a2 + 64);
v14 = *(_DWORD *)(a2 + 8);
v12 = a3 != 0LL;
v11 = *(_QWORD *)(a2 + 8LL * (a3 != 0LL) + 16);
if ( *(_DWORD *)(a1 + 832) == -1 )
v9 = &ft_default_parser;
else
v9 = *(void **)(112LL * *(unsigned int *)(v21 + 832) + *(_QWORD *)(**(_QWORD **)(v21 + 8) + 536LL) + 56);
for ( i = *v20; i; i = (long long *)*i )
{
if ( v12 )
v8 = 0;
else
v8 = *((_DWORD *)i + 19);
v13 = *((_DWORD *)i + 18) - v8;
if ( i[v12 + 2] != v11 )
{
*((_DWORD *)i + 11) = 0;
*((_DWORD *)i + 17) = 0;
*((_DWORD *)i + 16) = 0;
i[v12 + 2] = v11;
}
if ( *((_DWORD *)i + 17) )
break;
if ( (v14 & 2) != 0 )
{
*((float *)i + 11) = (float)(v15 / (float)*((int *)i + 18)) + *((float *)i + 11);
v3 = *((_DWORD *)i + 16) + 1;
*((_DWORD *)i + 16) = v3;
if ( v3 != v13 )
break;
v14 = *((_DWORD *)i + 2);
v15 = *((float *)i + 11) * *((float *)i + 10);
if ( v12 )
{
if ( i[6] )
{
v10 = 0;
v17[0] = *v19;
v17[1] = v19[1];
v17[2] = v19[2];
v18 = v19[3];
while ( 1 )
{
v7 = 0;
if ( (unsigned int)mi_ft_segiterator(v17) )
v7 = ~(v10 != 0);
if ( (v7 & 1) == 0 )
break;
if ( v18 )
{
v10 = ftb_check_phrase(v21, v18, HIDWORD(v17[0]), i, v9);
if ( v10 < 0 )
return 1;
}
}
if ( !v10 )
break;
}
}
}
else
{
if ( (v14 & 4) != 0 )
{
++*((_DWORD *)i + 17);
break;
}
if ( *((_DWORD *)i + 18) )
v15 = v15 / 3.0;
*((float *)i + 11) = v15 + *((float *)i + 11);
if ( *((_DWORD *)i + 16) < v13 )
break;
if ( (v14 & 8) == 0 )
{
v4 = *((_DWORD *)i + 16);
*((_DWORD *)i + 16) = v4 + 1;
if ( v4 == v13 )
v6 = *((_DWORD *)i + 2);
else
LOBYTE(v6) = 8;
LOBYTE(v14) = v6;
}
v15 = *((float *)i + 10) * v15;
}
}
return 0;
}
|
_ftb_climb_the_tree:
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 RAX,qword ptr [RBP + -0x18]
MOVSS XMM0,dword ptr [RAX + 0x40]
MOVSS dword ptr [RBP + -0x4c],XMM0
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x50],EAX
CMP qword ptr [RBP + -0x20],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x58],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,dword ptr [RBP + -0x58]
MOV RAX,qword ptr [RAX + RCX*0x8 + 0x10]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x340],-0x1
JNZ 0x0019ecba
LEA RAX,[0x3bf180]
MOV qword ptr [RBP + -0x78],RAX
JMP 0x0019ece5
LAB_0019ecba:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x340]
IMUL RCX,RCX,0x70
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x38]
MOV qword ptr [RBP + -0x78],RAX
LAB_0019ece5:
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x48],RAX
LAB_0019ecf8:
CMP qword ptr [RBP + -0x48],0x0
JZ 0x0019efa3
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX + 0x48]
MOV dword ptr [RBP + -0x7c],EAX
CMP dword ptr [RBP + -0x58],0x0
JZ 0x0019ed1a
XOR EAX,EAX
MOV dword ptr [RBP + -0x80],EAX
JMP 0x0019ed24
LAB_0019ed1a:
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX + 0x4c]
MOV dword ptr [RBP + -0x80],EAX
LAB_0019ed24:
MOV EAX,dword ptr [RBP + -0x7c]
MOV ECX,dword ptr [RBP + -0x80]
SUB EAX,ECX
MOV dword ptr [RBP + -0x54],EAX
MOV RAX,qword ptr [RBP + -0x48]
MOVSXD RCX,dword ptr [RBP + -0x58]
MOV RAX,qword ptr [RAX + RCX*0x8 + 0x10]
CMP RAX,qword ptr [RBP + -0x60]
JZ 0x0019ed75
MOV RAX,qword ptr [RBP + -0x48]
XORPS XMM0,XMM0
MOVSS dword ptr [RAX + 0x2c],XMM0
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RAX + 0x44],0x0
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RAX + 0x40],0x0
MOV RDX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x48]
MOVSXD RCX,dword ptr [RBP + -0x58]
MOV qword ptr [RAX + RCX*0x8 + 0x10],RDX
LAB_0019ed75:
MOV RAX,qword ptr [RBP + -0x48]
CMP dword ptr [RAX + 0x44],0x0
JZ 0x0019ed84
JMP 0x0019efa3
LAB_0019ed84:
MOV EAX,dword ptr [RBP + -0x50]
AND EAX,0x2
CMP EAX,0x0
JZ 0x0019eeda
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX + 0x48]
CVTSI2SS XMM1,RAX
MOVSS XMM0,dword ptr [RBP + -0x4c]
DIVSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x4c],XMM0
MOVSS XMM0,dword ptr [RBP + -0x4c]
MOV RAX,qword ptr [RBP + -0x48]
ADDSS XMM0,dword ptr [RAX + 0x2c]
MOVSS dword ptr [RAX + 0x2c],XMM0
MOV RCX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RCX + 0x40]
ADD EAX,0x1
MOV dword ptr [RCX + 0x40],EAX
CMP EAX,dword ptr [RBP + -0x54]
JNZ 0x0019eed0
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x50],EAX
MOV RAX,qword ptr [RBP + -0x48]
MOVSS XMM0,dword ptr [RAX + 0x2c]
MOV RAX,qword ptr [RBP + -0x48]
MULSS XMM0,dword ptr [RAX + 0x28]
MOVSS dword ptr [RBP + -0x4c],XMM0
CMP dword ptr [RBP + -0x58],0x0
JZ 0x0019eece
MOV RAX,qword ptr [RBP + -0x48]
CMP qword ptr [RAX + 0x30],0x0
JZ 0x0019eece
MOV dword ptr [RBP + -0x6c],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x38],RCX
MOV RCX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x30],RCX
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x28],RAX
LAB_0019ee3a:
LEA RDI,[RBP + -0x40]
CALL 0x001a2bd0
MOV ECX,EAX
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x81],AL
JZ 0x0019ee61
CMP dword ptr [RBP + -0x6c],0x0
SETNZ AL
XOR AL,0xff
MOV byte ptr [RBP + -0x81],AL
LAB_0019ee61:
MOV AL,byte ptr [RBP + -0x81]
TEST AL,0x1
JNZ 0x0019ee6d
JMP 0x0019eec1
LAB_0019ee6d:
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x0019ee76
JMP 0x0019ee3a
LAB_0019ee76:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0x3c]
MOV RCX,qword ptr [RBP + -0x48]
MOV R8,qword ptr [RBP + -0x68]
CALL 0x0019fef0
MOV dword ptr [RBP + -0x6c],EAX
CMP dword ptr [RBP + -0x6c],0x0
SETL AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0019eebc
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0019efaa
LAB_0019eebc:
JMP 0x0019ee3a
LAB_0019eec1:
CMP dword ptr [RBP + -0x6c],0x0
JNZ 0x0019eecc
JMP 0x0019efa3
LAB_0019eecc:
JMP 0x0019eece
LAB_0019eece:
JMP 0x0019eed5
LAB_0019eed0:
JMP 0x0019efa3
LAB_0019eed5:
JMP 0x0019ef91
LAB_0019eeda:
MOV EAX,dword ptr [RBP + -0x50]
AND EAX,0x4
CMP EAX,0x0
JZ 0x0019eef7
MOV RAX,qword ptr [RBP + -0x48]
MOV ECX,dword ptr [RAX + 0x44]
ADD ECX,0x1
MOV dword ptr [RAX + 0x44],ECX
JMP 0x0019efa3
LAB_0019eef7:
MOV RAX,qword ptr [RBP + -0x48]
CMP dword ptr [RAX + 0x48],0x0
JZ 0x0019ef17
MOVSS XMM0,dword ptr [RBP + -0x4c]
MOVSS XMM1,dword ptr [0x0025100c]
DIVSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x4c],XMM0
LAB_0019ef17:
MOVSS XMM0,dword ptr [RBP + -0x4c]
MOV RAX,qword ptr [RBP + -0x48]
ADDSS XMM0,dword ptr [RAX + 0x2c]
MOVSS dword ptr [RAX + 0x2c],XMM0
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX + 0x40]
CMP EAX,dword ptr [RBP + -0x54]
JGE 0x0019ef38
JMP 0x0019efa3
LAB_0019ef38:
MOV EAX,dword ptr [RBP + -0x50]
AND EAX,0x8
CMP EAX,0x0
JNZ 0x0019ef7c
MOV RCX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RCX + 0x40]
MOV EDX,EAX
ADD EDX,0x1
MOV dword ptr [RCX + 0x40],EDX
CMP EAX,dword ptr [RBP + -0x54]
JNZ 0x0019ef66
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x88],EAX
JMP 0x0019ef73
LAB_0019ef66:
MOV EAX,0x8
MOV dword ptr [RBP + -0x88],EAX
JMP 0x0019ef73
LAB_0019ef73:
MOV EAX,dword ptr [RBP + -0x88]
MOV dword ptr [RBP + -0x50],EAX
LAB_0019ef7c:
MOV RAX,qword ptr [RBP + -0x48]
MOVSS XMM0,dword ptr [RAX + 0x28]
MULSS XMM0,dword ptr [RBP + -0x4c]
MOVSS dword ptr [RBP + -0x4c],XMM0
JMP 0x0019ef91
LAB_0019ef91:
JMP 0x0019ef93
LAB_0019ef93:
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x0019ecf8
LAB_0019efa3:
MOV dword ptr [RBP + -0x4],0x0
LAB_0019efaa:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x90
POP RBP
RET
|
int4 _ftb_climb_the_tree(long param_1,int8 *param_2,int8 *param_3)
{
long lVar1;
uint uVar2;
int iVar3;
uint local_90;
int local_88;
int1 *local_80;
int local_74;
uint local_58;
float local_54;
int8 *local_50;
int8 local_48;
int8 local_40;
int8 local_38;
long local_30;
int8 *local_28;
int8 *local_20;
long local_18;
local_54 = *(float *)(param_2 + 8);
local_58 = *(uint *)(param_2 + 1);
uVar2 = (uint)(param_3 != (int8 *)0x0);
lVar1 = param_2[(long)(int)uVar2 + 2];
if (*(int *)(param_1 + 0x340) == -1) {
local_80 = ft_default_parser;
}
else {
local_80 = *(int1 **)
(*(long *)(**(long **)(param_1 + 8) + 0x218) +
(ulong)*(uint *)(param_1 + 0x340) * 0x70 + 0x38);
}
local_50 = (int8 *)*param_2;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
do {
if (local_50 == (int8 *)0x0) {
return 0;
}
if (uVar2 == 0) {
local_88 = *(int *)((long)local_50 + 0x4c);
}
else {
local_88 = 0;
}
local_88 = *(int *)(local_50 + 9) - local_88;
if (local_50[(long)(int)uVar2 + 2] != lVar1) {
*(int4 *)((long)local_50 + 0x2c) = 0;
*(int4 *)((long)local_50 + 0x44) = 0;
*(int4 *)(local_50 + 8) = 0;
local_50[(long)(int)uVar2 + 2] = lVar1;
}
if (*(int *)((long)local_50 + 0x44) != 0) {
return 0;
}
if ((local_58 & 2) == 0) {
if ((local_58 & 4) != 0) {
*(int *)((long)local_50 + 0x44) = *(int *)((long)local_50 + 0x44) + 1;
return 0;
}
if (*(int *)(local_50 + 9) != 0) {
local_54 = local_54 / DAT_0025100c;
}
*(float *)((long)local_50 + 0x2c) = local_54 + *(float *)((long)local_50 + 0x2c);
if (*(int *)(local_50 + 8) < local_88) {
return 0;
}
if ((local_58 & 8) == 0) {
iVar3 = *(int *)(local_50 + 8);
*(int *)(local_50 + 8) = iVar3 + 1;
if (iVar3 == local_88) {
local_90 = *(uint *)(local_50 + 1);
}
else {
local_90 = 8;
}
local_58 = local_90;
}
local_54 = *(float *)(local_50 + 5) * local_54;
}
else {
*(float *)((long)local_50 + 0x2c) =
local_54 / (float)*(uint *)(local_50 + 9) + *(float *)((long)local_50 + 0x2c);
iVar3 = *(int *)(local_50 + 8);
*(int *)(local_50 + 8) = iVar3 + 1;
if (iVar3 + 1 != local_88) {
return 0;
}
local_58 = *(uint *)(local_50 + 1);
local_54 = *(float *)((long)local_50 + 0x2c) * *(float *)(local_50 + 5);
if ((uVar2 != 0) && (local_50[6] != 0)) {
local_74 = 0;
local_48 = *local_28;
local_40 = local_28[1];
local_38 = local_28[2];
local_30 = local_28[3];
while (iVar3 = _mi_ft_segiterator(&local_48), iVar3 != 0 && local_74 == 0) {
if (local_30 != 0) {
local_74 = _ftb_check_phrase(local_18,local_30,local_48._4_4_,local_50,local_80);
if (local_74 < 0) {
return 1;
}
}
}
if (local_74 == 0) {
return 0;
}
}
}
local_50 = (int8 *)*local_50;
} while( true );
}
|
|
6,877 |
JS_SetConstructorBit
|
bluesky950520[P]quickjs/quickjs.c
|
BOOL JS_SetConstructorBit(JSContext *ctx, JSValue func_obj, BOOL val)
{
JSObject *p;
if (JS_VALUE_GET_TAG(func_obj) != JS_TAG_OBJECT)
return FALSE;
p = JS_VALUE_GET_OBJ(func_obj);
p->is_constructor = val;
return TRUE;
}
|
O0
|
c
|
JS_SetConstructorBit:
movq %rsi, -0x18(%rsp)
movq %rdx, -0x10(%rsp)
movq %rdi, -0x20(%rsp)
movl %ecx, -0x24(%rsp)
movq -0x10(%rsp), %rax
cmpl $-0x1, %eax
je 0x36ea7
movl $0x0, -0x4(%rsp)
jmp 0x36ed5
movq -0x18(%rsp), %rax
movq %rax, -0x30(%rsp)
movl -0x24(%rsp), %eax
movb %al, %dl
movq -0x30(%rsp), %rax
movb 0x5(%rax), %cl
andb $0x1, %dl
shlb $0x4, %dl
andb $-0x11, %cl
orb %dl, %cl
movb %cl, 0x5(%rax)
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
|
JS_SetConstructorBit:
mov [rsp+var_18], rsi
mov [rsp+var_10], rdx
mov [rsp+var_20], rdi
mov [rsp+var_24], ecx
mov rax, [rsp+var_10]
cmp eax, 0FFFFFFFFh
jz short loc_36EA7
mov [rsp+var_4], 0
jmp short loc_36ED5
loc_36EA7:
mov rax, [rsp+var_18]
mov [rsp+var_30], rax
mov eax, [rsp+var_24]
mov dl, al
mov rax, [rsp+var_30]
mov cl, [rax+5]
and dl, 1
shl dl, 4
and cl, 0EFh
or cl, dl
mov [rax+5], cl
mov [rsp+var_4], 1
loc_36ED5:
mov eax, [rsp+var_4]
retn
|
long long JS_SetConstructorBit(long long a1, long long a2, int a3, char a4)
{
if ( a3 == -1 )
{
*(_BYTE *)(a2 + 5) = (16 * (a4 & 1)) | *(_BYTE *)(a2 + 5) & 0xEF;
return 1;
}
else
{
return 0;
}
}
|
JS_SetConstructorBit:
MOV qword ptr [RSP + -0x18],RSI
MOV qword ptr [RSP + -0x10],RDX
MOV qword ptr [RSP + -0x20],RDI
MOV dword ptr [RSP + -0x24],ECX
MOV RAX,qword ptr [RSP + -0x10]
CMP EAX,-0x1
JZ 0x00136ea7
MOV dword ptr [RSP + -0x4],0x0
JMP 0x00136ed5
LAB_00136ea7:
MOV RAX,qword ptr [RSP + -0x18]
MOV qword ptr [RSP + -0x30],RAX
MOV EAX,dword ptr [RSP + -0x24]
MOV DL,AL
MOV RAX,qword ptr [RSP + -0x30]
MOV CL,byte ptr [RAX + 0x5]
AND DL,0x1
SHL DL,0x4
AND CL,0xef
OR CL,DL
MOV byte ptr [RAX + 0x5],CL
MOV dword ptr [RSP + -0x4],0x1
LAB_00136ed5:
MOV EAX,dword ptr [RSP + -0x4]
RET
|
bool JS_SetConstructorBit(int8 param_1,long param_2,int param_3,byte param_4)
{
if (param_3 == -1) {
*(byte *)(param_2 + 5) = *(byte *)(param_2 + 5) & 0xef | (param_4 & 1) << 4;
}
return param_3 == -1;
}
|
|
6,878 |
JS_SetConstructorBit
|
bluesky950520[P]quickjs/quickjs.c
|
BOOL JS_SetConstructorBit(JSContext *ctx, JSValue func_obj, BOOL val)
{
JSObject *p;
if (JS_VALUE_GET_TAG(func_obj) != JS_TAG_OBJECT)
return FALSE;
p = JS_VALUE_GET_OBJ(func_obj);
p->is_constructor = val;
return TRUE;
}
|
O1
|
c
|
JS_SetConstructorBit:
movq %rsi, -0x8(%rsp)
xorl %eax, %eax
cmpl $-0x1, %edx
jne 0x268ca
movq -0x8(%rsp), %rax
movb 0x5(%rax), %dl
shlb $0x4, %cl
andb $0x10, %cl
andb $-0x11, %dl
orb %cl, %dl
movb %dl, 0x5(%rax)
movl $0x1, %eax
retq
|
JS_SetConstructorBit:
mov [rsp+var_8], rsi
xor eax, eax
cmp edx, 0FFFFFFFFh
jnz short locret_268CA
mov rax, [rsp+var_8]
mov dl, [rax+5]
shl cl, 4
and cl, 10h
and dl, 0EFh
or dl, cl
mov [rax+5], dl
mov eax, 1
locret_268CA:
retn
|
long long JS_SetConstructorBit(long long a1, long long a2, int a3, char a4)
{
long long result; // rax
result = 0LL;
if ( a3 == -1 )
{
*(_BYTE *)(a2 + 5) = (16 * a4) & 0x10 | *(_BYTE *)(a2 + 5) & 0xEF;
return 1LL;
}
return result;
}
|
JS_SetConstructorBit:
MOV qword ptr [RSP + -0x8],RSI
XOR EAX,EAX
CMP EDX,-0x1
JNZ 0x001268ca
MOV RAX,qword ptr [RSP + -0x8]
MOV DL,byte ptr [RAX + 0x5]
SHL CL,0x4
AND CL,0x10
AND DL,0xef
OR DL,CL
MOV byte ptr [RAX + 0x5],DL
MOV EAX,0x1
LAB_001268ca:
RET
|
bool JS_SetConstructorBit(int8 param_1,long param_2,int param_3,byte param_4)
{
if (param_3 == -1) {
*(byte *)(param_2 + 5) = *(byte *)(param_2 + 5) & 0xef | (param_4 & 1) << 4;
}
return param_3 == -1;
}
|
|
6,879 |
ma_find_writepos
|
eloqsql/storage/maria/ma_dynrec.c
|
static int _ma_find_writepos(MARIA_HA *info,
ulong reclength, /* record length */
my_off_t *filepos, /* Return file pos */
ulong *length) /* length of block at filepos */
{
MARIA_BLOCK_INFO block_info;
ulong tmp;
DBUG_ENTER("_ma_find_writepos");
if (info->s->state.dellink != HA_OFFSET_ERROR &&
!info->append_insert_at_end)
{
/* Deleted blocks exists; Get last used block */
*filepos=info->s->state.dellink;
block_info.second_read=0;
info->rec_cache.seek_not_done=1;
if (!(_ma_get_block_info(info, &block_info, info->dfile.file,
info->s->state.dellink) &
BLOCK_DELETED))
{
DBUG_PRINT("error",("Delete link crashed"));
_ma_set_fatal_error_with_share(info->s, HA_ERR_WRONG_IN_RECORD);
DBUG_RETURN(-1);
}
info->s->state.dellink=block_info.next_filepos;
info->state->del--;
info->state->empty-= block_info.block_len;
*length= block_info.block_len;
}
else
{
/* No deleted blocks; Allocate a new block */
*filepos=info->state->data_file_length;
if ((tmp= reclength + 3 + MY_TEST(reclength >= (65520 - 3))) <
info->s->base.min_block_length)
tmp= info->s->base.min_block_length;
else
tmp= ((tmp+MARIA_DYN_ALIGN_SIZE-1) &
(~ (ulong) (MARIA_DYN_ALIGN_SIZE-1)));
if (info->state->data_file_length >
(info->s->base.max_data_file_length - tmp))
{
my_errno=HA_ERR_RECORD_FILE_FULL;
DBUG_RETURN(-1);
}
if (tmp > MARIA_MAX_BLOCK_LENGTH)
tmp=MARIA_MAX_BLOCK_LENGTH;
*length= tmp;
info->state->data_file_length+= tmp;
info->s->state.split++;
info->update|=HA_STATE_WRITE_AT_END;
}
DBUG_RETURN(0);
}
|
O3
|
c
|
ma_find_writepos:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
movq (%rdi), %rax
movq 0xc8(%rax), %rax
cmpq $-0x1, %rax
je 0x3f1ac
cmpb $0x0, 0x681(%rbx)
je 0x3f22a
movq 0x20(%rbx), %rax
movq 0x28(%rax), %rax
movq %rax, (%rdx)
cmpq $0xffed, %rsi # imm = 0xFFED
sbbq $-0x1, %rsi
leaq 0x3(%rsi), %rax
movq (%rbx), %rcx
movq 0x20(%rbx), %rdx
movq 0x3b8(%rcx), %rdi
addq $0x6, %rsi
andq $-0x4, %rsi
cmpq %rdi, %rax
cmovbq %rdi, %rsi
movq 0x368(%rcx), %rax
subq %rsi, %rax
cmpq %rax, 0x28(%rdx)
jbe 0x3f200
callq 0xa16ee
movl $0x87, (%rax)
jmp 0x3f26b
movl $0xfffffc, %eax # imm = 0xFFFFFC
cmpq %rax, %rsi
cmovbq %rsi, %rax
movq %rax, (%r14)
movq 0x20(%rbx), %rcx
addq %rax, 0x28(%rcx)
movq (%rbx), %rax
incq 0xc0(%rax)
orb $0x1, 0x625(%rbx)
jmp 0x3f29b
movq %rax, (%rdx)
leaq -0x70(%rbp), %rsi
movl $0x0, 0x50(%rsi)
movl $0x1, 0x598(%rbx)
movl 0x480(%rbx), %edx
movq (%rbx), %rax
movq 0xc8(%rax), %rcx
movq %rbx, %rdi
callq 0x3d5dc
testb $0x4, %al
jne 0x3f272
movq (%rbx), %rdi
movl $0x7f, %esi
callq 0x3664e
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x3f29d
movq -0x30(%rbp), %rax
movq (%rbx), %rcx
movq %rax, 0xc8(%rcx)
movq 0x20(%rbx), %rax
decq 0x8(%rax)
movq -0x48(%rbp), %rax
movq 0x20(%rbx), %rcx
subq %rax, 0x10(%rcx)
movq -0x48(%rbp), %rax
movq %rax, (%r14)
xorl %eax, %eax
movq %fs:0x28, %rcx
cmpq -0x18(%rbp), %rcx
jne 0x3f2b5
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x29270
nop
|
_ma_find_writepos:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 60h
mov r14, rcx
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_18], rax
mov rax, [rdi]
mov rax, [rax+0C8h]
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_3F1AC
cmp byte ptr [rbx+681h], 0
jz short loc_3F22A
loc_3F1AC:
mov rax, [rbx+20h]
mov rax, [rax+28h]
mov [rdx], rax
cmp rsi, 0FFEDh
sbb rsi, 0FFFFFFFFFFFFFFFFh
lea rax, [rsi+3]
mov rcx, [rbx]
mov rdx, [rbx+20h]
mov rdi, [rcx+3B8h]
add rsi, 6
and rsi, 0FFFFFFFFFFFFFFFCh
cmp rax, rdi
cmovb rsi, rdi
mov rax, [rcx+368h]
sub rax, rsi
cmp [rdx+28h], rax
jbe short loc_3F200
call _my_thread_var
mov dword ptr [rax], 87h
jmp short loc_3F26B
loc_3F200:
mov eax, 0FFFFFCh
cmp rsi, rax
cmovb rax, rsi
mov [r14], rax
mov rcx, [rbx+20h]
add [rcx+28h], rax
mov rax, [rbx]
inc qword ptr [rax+0C0h]
or byte ptr [rbx+625h], 1
jmp short loc_3F29B
loc_3F22A:
mov [rdx], rax
lea rsi, [rbp+var_70]
mov dword ptr [rsi+50h], 0
mov dword ptr [rbx+598h], 1
mov edx, [rbx+480h]
mov rax, [rbx]
mov rcx, [rax+0C8h]
mov rdi, rbx
call _ma_get_block_info
test al, 4
jnz short loc_3F272
mov rdi, [rbx]
mov esi, 7Fh
call _ma_set_fatal_error_with_share
loc_3F26B:
mov eax, 0FFFFFFFFh
jmp short loc_3F29D
loc_3F272:
mov rax, [rbp+var_30]
mov rcx, [rbx]
mov [rcx+0C8h], rax
mov rax, [rbx+20h]
dec qword ptr [rax+8]
mov rax, [rbp+var_48]
mov rcx, [rbx+20h]
sub [rcx+10h], rax
mov rax, [rbp+var_48]
mov [r14], rax
loc_3F29B:
xor eax, eax
loc_3F29D:
mov rcx, fs:28h
cmp rcx, [rbp+var_18]
jnz short loc_3F2B5
add rsp, 60h
pop rbx
pop r14
pop rbp
retn
loc_3F2B5:
call ___stack_chk_fail
|
long long ma_find_writepos(_QWORD *a1, unsigned long long a2, _QWORD *a3, long long *a4, long long a5, int a6)
{
long long v8; // rax
unsigned long long v9; // rsi
unsigned long long v10; // rax
long long v11; // rcx
long long v12; // rdx
unsigned long long v13; // rdi
unsigned long long v14; // rsi
long long v15; // rax
long long v16; // rdx
long long v17; // rcx
long long v18; // r8
int v19; // r9d
unsigned __int8 v21[40]; // [rsp+0h] [rbp-70h] BYREF
long long v22; // [rsp+28h] [rbp-48h]
long long v23; // [rsp+40h] [rbp-30h]
int v24; // [rsp+50h] [rbp-20h]
unsigned long long v25; // [rsp+58h] [rbp-18h]
v25 = __readfsqword(0x28u);
v8 = *(_QWORD *)(*a1 + 200LL);
if ( v8 == -1 || *((_BYTE *)a1 + 1665) )
{
*a3 = *(_QWORD *)(a1[4] + 40LL);
v9 = a2 - ((a2 < 0xFFED) - 1LL);
v10 = v9 + 3;
v11 = *a1;
v12 = a1[4];
v13 = *(_QWORD *)(*a1 + 952LL);
v14 = (v9 + 6) & 0xFFFFFFFFFFFFFFFCLL;
if ( v10 < v13 )
v14 = *(_QWORD *)(*a1 + 952LL);
if ( *(_QWORD *)(v12 + 40) > *(_QWORD *)(v11 + 872) - v14 )
{
*(_DWORD *)my_thread_var(v13, v14, v12, v11, a5) = 135;
return 0xFFFFFFFFLL;
}
v15 = 16777212LL;
if ( v14 < 0xFFFFFC )
v15 = v14;
*a4 = v15;
*(_QWORD *)(a1[4] + 40LL) += v15;
++*(_QWORD *)(*a1 + 192LL);
*((_BYTE *)a1 + 1573) |= 1u;
}
else
{
*a3 = v8;
v24 = 0;
*((_DWORD *)a1 + 358) = 1;
if ( (ma_get_block_info((long long)a1, v21, *((unsigned int *)a1 + 288), *(_QWORD *)(*a1 + 200LL), a5, a6) & 4) == 0 )
{
ma_set_fatal_error_with_share(*a1, 127, v16, v17, v18, v19);
return 0xFFFFFFFFLL;
}
*(_QWORD *)(*a1 + 200LL) = v23;
--*(_QWORD *)(a1[4] + 8LL);
*(_QWORD *)(a1[4] + 16LL) -= v22;
*a4 = v22;
}
return 0LL;
}
|
_ma_find_writepos:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x60
MOV R14,RCX
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0xc8]
CMP RAX,-0x1
JZ 0x0013f1ac
CMP byte ptr [RBX + 0x681],0x0
JZ 0x0013f22a
LAB_0013f1ac:
MOV RAX,qword ptr [RBX + 0x20]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RDX],RAX
CMP RSI,0xffed
SBB RSI,-0x1
LEA RAX,[RSI + 0x3]
MOV RCX,qword ptr [RBX]
MOV RDX,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RCX + 0x3b8]
ADD RSI,0x6
AND RSI,-0x4
CMP RAX,RDI
CMOVC RSI,RDI
MOV RAX,qword ptr [RCX + 0x368]
SUB RAX,RSI
CMP qword ptr [RDX + 0x28],RAX
JBE 0x0013f200
CALL 0x001a16ee
MOV dword ptr [RAX],0x87
JMP 0x0013f26b
LAB_0013f200:
MOV EAX,0xfffffc
CMP RSI,RAX
CMOVC RAX,RSI
MOV qword ptr [R14],RAX
MOV RCX,qword ptr [RBX + 0x20]
ADD qword ptr [RCX + 0x28],RAX
MOV RAX,qword ptr [RBX]
INC qword ptr [RAX + 0xc0]
OR byte ptr [RBX + 0x625],0x1
JMP 0x0013f29b
LAB_0013f22a:
MOV qword ptr [RDX],RAX
LEA RSI,[RBP + -0x70]
MOV dword ptr [RSI + 0x50],0x0
MOV dword ptr [RBX + 0x598],0x1
MOV EDX,dword ptr [RBX + 0x480]
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [RAX + 0xc8]
MOV RDI,RBX
CALL 0x0013d5dc
TEST AL,0x4
JNZ 0x0013f272
MOV RDI,qword ptr [RBX]
MOV ESI,0x7f
CALL 0x0013664e
LAB_0013f26b:
MOV EAX,0xffffffff
JMP 0x0013f29d
LAB_0013f272:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBX]
MOV qword ptr [RCX + 0xc8],RAX
MOV RAX,qword ptr [RBX + 0x20]
DEC qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBX + 0x20]
SUB qword ptr [RCX + 0x10],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [R14],RAX
LAB_0013f29b:
XOR EAX,EAX
LAB_0013f29d:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x18]
JNZ 0x0013f2b5
ADD RSP,0x60
POP RBX
POP R14
POP RBP
RET
LAB_0013f2b5:
CALL 0x00129270
|
int8 _ma_find_writepos(long *param_1,ulong param_2,long *param_3,ulong *param_4)
{
int4 *puVar1;
ulong uVar2;
int8 uVar3;
long lVar4;
ulong uVar5;
long in_FS_OFFSET;
int1 local_78 [40];
ulong local_50;
int8 local_38;
int4 local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if ((*(long *)(*param_1 + 200) == -1) || (*(char *)((long)param_1 + 0x681) != '\0')) {
*param_3 = *(long *)(param_1[4] + 0x28);
lVar4 = (param_2 + 1) - (ulong)(param_2 < 0xffed);
uVar2 = *(ulong *)(*param_1 + 0x3b8);
uVar5 = lVar4 + 6U & 0xfffffffffffffffc;
if (lVar4 + 3U < uVar2) {
uVar5 = uVar2;
}
if (*(ulong *)(param_1[4] + 0x28) <= *(long *)(*param_1 + 0x368) - uVar5) {
uVar2 = 0xfffffc;
if (uVar5 < 0xfffffc) {
uVar2 = uVar5;
}
*param_4 = uVar2;
*(long *)(param_1[4] + 0x28) = *(long *)(param_1[4] + 0x28) + uVar2;
*(long *)(*param_1 + 0xc0) = *(long *)(*param_1 + 0xc0) + 1;
*(byte *)((long)param_1 + 0x625) = *(byte *)((long)param_1 + 0x625) | 1;
LAB_0013f29b:
uVar3 = 0;
goto LAB_0013f29d;
}
puVar1 = (int4 *)_my_thread_var();
*puVar1 = 0x87;
}
else {
*param_3 = *(long *)(*param_1 + 200);
local_28 = 0;
*(int4 *)(param_1 + 0xb3) = 1;
uVar2 = _ma_get_block_info(param_1,local_78,(int)param_1[0x90],*(int8 *)(*param_1 + 200));
if ((uVar2 & 4) != 0) {
*(int8 *)(*param_1 + 200) = local_38;
*(long *)(param_1[4] + 8) = *(long *)(param_1[4] + 8) + -1;
*(long *)(param_1[4] + 0x10) = *(long *)(param_1[4] + 0x10) - local_50;
*param_4 = local_50;
goto LAB_0013f29b;
}
_ma_set_fatal_error_with_share(*param_1,0x7f);
}
uVar3 = 0xffffffff;
LAB_0013f29d:
if (*(long *)(in_FS_OFFSET + 0x28) == local_20) {
return uVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
6,880 |
mthd_my_read_one_row
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
int mthd_my_read_one_row(MYSQL *mysql,uint fields,MYSQL_ROW row, ulong *lengths)
{
uint field;
ulong pkt_len,len;
uchar *pos,*prev_pos, *end_pos;
if ((pkt_len=(uint) ma_net_safe_read(mysql)) == packet_error)
return -1;
if (pkt_len <= 8 && mysql->net.read_pos[0] == 254)
{
mysql->warning_count= uint2korr(mysql->net.read_pos + 1);
mysql->server_status= uint2korr(mysql->net.read_pos + 3);
return 1; /* End of data */
}
prev_pos= 0; /* allowed to write at packet[-1] */
pos=mysql->net.read_pos;
end_pos=pos+pkt_len;
for (field=0 ; field < fields ; field++)
{
if ((len=(ulong) net_field_length(&pos)) == NULL_LENGTH)
{ /* null field */
row[field] = 0;
*lengths++=0;
}
else
{
if (len > (ulong) (end_pos - pos) || pos > end_pos)
{
mysql->net.last_errno=CR_UNKNOWN_ERROR;
strncpy(mysql->net.last_error,ER(mysql->net.last_errno),
MYSQL_ERRMSG_SIZE - 1);
return -1;
}
row[field] = (char*) pos;
pos+=len;
*lengths++=len;
}
if (prev_pos)
*prev_pos=0; /* Terminate prev field */
prev_pos=pos;
}
row[field]=(char*) prev_pos+1; /* End of last field */
*prev_pos=0; /* Terminate last field */
return 0;
}
|
O3
|
c
|
mthd_my_read_one_row:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %rbx
movl %esi, %r13d
movq %rdi, %r15
callq 0x26beb
movl %eax, %eax
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmpq %rcx, %rax
je 0x29903
movq 0x20(%r15), %rcx
cmpl $0x8, %eax
ja 0x29811
cmpb $-0x2, (%rcx)
jne 0x29811
movzwl 0x1(%rcx), %eax
movl %eax, 0x388(%r15)
movzwl 0x3(%rcx), %eax
movl %eax, 0x380(%r15)
movl $0x1, %r14d
jmp 0x29903
xorl %edx, %edx
testl %r13d, %r13d
je 0x298c8
addq %rcx, %rax
movl %r13d, %edx
xorl %esi, %esi
xorl %edi, %edi
movzbl (%rcx), %r8d
cmpq $0xfa, %r8
ja 0x2986e
incq %rcx
movq %rax, %r9
subq %rcx, %r9
cmpq %r9, %r8
ja 0x298da
cmpq %rax, %rcx
ja 0x298da
movq %rcx, (%rbx,%rsi,8)
addq %r8, %rcx
movq %r8, (%r12,%rsi,8)
testq %rdi, %rdi
je 0x29861
movb $0x0, (%rdi)
incq %rsi
movq %rcx, %rdi
cmpq %rsi, %rdx
jne 0x29826
jmp 0x298ca
cmpq $0xfb, %r8
je 0x298ab
cmpl $0xfd, %r8d
je 0x29894
cmpl $0xfc, %r8d
jne 0x298bb
movzwl 0x1(%rcx), %r8d
addq $0x3, %rcx
jmp 0x29836
movzwl 0x1(%rcx), %r9d
movzbl 0x3(%rcx), %r8d
addq $0x4, %rcx
shll $0x10, %r8d
orq %r9, %r8
jmp 0x29836
incq %rcx
movq $0x0, (%rbx,%rsi,8)
xorl %r8d, %r8d
jmp 0x29855
movl 0x1(%rcx), %r8d
addq $0x9, %rcx
jmp 0x29836
xorl %ecx, %ecx
leaq 0x1(%rcx), %rax
movq %rax, (%rbx,%rdx,8)
movb $0x0, (%rcx)
xorl %r14d, %r14d
jmp 0x29903
movl $0x7d0, 0x90(%r15) # imm = 0x7D0
addq $0x97, %r15
leaq 0x3910d(%rip), %rax # 0x62a00
movq (%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
movq %r15, %rdi
callq 0x14230
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
mthd_my_read_one_row:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12, rcx
mov rbx, rdx
mov r13d, esi
mov r15, rdi
call ma_net_safe_read
mov eax, eax
mov r14d, 0FFFFFFFFh
mov ecx, 0FFFFFFFFh
cmp rax, rcx
jz loc_29903
mov rcx, [r15+20h]
cmp eax, 8
ja short loc_29811
cmp byte ptr [rcx], 0FEh
jnz short loc_29811
movzx eax, word ptr [rcx+1]
mov [r15+388h], eax
movzx eax, word ptr [rcx+3]
mov [r15+380h], eax
mov r14d, 1
jmp loc_29903
loc_29811:
xor edx, edx
test r13d, r13d
jz loc_298C8
add rax, rcx
mov edx, r13d
xor esi, esi
xor edi, edi
loc_29826:
movzx r8d, byte ptr [rcx]
cmp r8, 0FAh
ja short loc_2986E
inc rcx
loc_29836:
mov r9, rax
sub r9, rcx
cmp r8, r9
ja loc_298DA
cmp rcx, rax
ja loc_298DA
mov [rbx+rsi*8], rcx
add rcx, r8
loc_29855:
mov [r12+rsi*8], r8
test rdi, rdi
jz short loc_29861
mov byte ptr [rdi], 0
loc_29861:
inc rsi
mov rdi, rcx
cmp rdx, rsi
jnz short loc_29826
jmp short loc_298CA
loc_2986E:
cmp r8, 0FBh
jz short loc_298AB
cmp r8d, 0FDh
jz short loc_29894
cmp r8d, 0FCh
jnz short loc_298BB
movzx r8d, word ptr [rcx+1]
add rcx, 3
jmp short loc_29836
loc_29894:
movzx r9d, word ptr [rcx+1]
movzx r8d, byte ptr [rcx+3]
add rcx, 4
shl r8d, 10h
or r8, r9
jmp short loc_29836
loc_298AB:
inc rcx
mov qword ptr [rbx+rsi*8], 0
xor r8d, r8d
jmp short loc_29855
loc_298BB:
mov r8d, [rcx+1]
add rcx, 9
jmp loc_29836
loc_298C8:
xor ecx, ecx
loc_298CA:
lea rax, [rcx+1]
mov [rbx+rdx*8], rax
mov byte ptr [rcx], 0
xor r14d, r14d
jmp short loc_29903
loc_298DA:
mov dword ptr [r15+90h], 7D0h
add r15, 97h
lea rax, client_errors
mov rsi, [rax]
mov edx, 1FFh
mov rdi, r15
call _strncpy
loc_29903:
mov eax, r14d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long mthd_my_read_one_row(long long a1, long long a2, long long a3, long long a4, unsigned long long a5, int a6)
{
int v8; // r13d
unsigned int v10; // eax
unsigned int v11; // r14d
unsigned __int8 *v12; // rcx
long long v13; // rdx
unsigned __int8 *v14; // rax
long long v15; // rsi
unsigned __int8 *v16; // rdi
unsigned long long v17; // r8
unsigned __int8 *v18; // rcx
long long v19; // r9
int v20; // r8d
v8 = a2;
v10 = ma_net_safe_read(a1, a2, a3, a4, a5, a6);
v11 = -1;
if ( v10 != 0xFFFFFFFFLL )
{
v12 = *(unsigned __int8 **)(a1 + 32);
if ( v10 <= 8 && *v12 == 0xFE )
{
*(_DWORD *)(a1 + 904) = *(unsigned __int16 *)(v12 + 1);
*(_DWORD *)(a1 + 896) = *(unsigned __int16 *)(v12 + 3);
return 1;
}
v13 = 0LL;
if ( (_DWORD)a2 )
{
v14 = &v12[v10];
v13 = (unsigned int)a2;
v15 = 0LL;
v16 = 0LL;
while ( 1 )
{
v17 = *v12;
if ( v17 > 0xFA )
{
if ( v17 == 251 )
{
++v12;
*(_QWORD *)(a3 + 8 * v15) = 0LL;
v17 = 0LL;
goto LABEL_12;
}
if ( (_DWORD)v17 == 253 )
{
v19 = *(unsigned __int16 *)(v12 + 1);
v20 = v12[3];
v18 = v12 + 4;
v17 = v19 | (unsigned int)(v20 << 16);
}
else if ( (_DWORD)v17 == 252 )
{
v17 = *(unsigned __int16 *)(v12 + 1);
v18 = v12 + 3;
}
else
{
v17 = *(unsigned int *)(v12 + 1);
v18 = v12 + 9;
}
}
else
{
v18 = v12 + 1;
}
if ( v17 > v14 - v18 || v18 > v14 )
{
*(_DWORD *)(a1 + 144) = 2000;
strncpy(a1 + 151, client_errors[0], 511LL);
return v11;
}
*(_QWORD *)(a3 + 8 * v15) = v18;
v12 = &v18[v17];
LABEL_12:
*(_QWORD *)(a4 + 8 * v15) = v17;
if ( v16 )
*v16 = 0;
++v15;
v16 = v12;
if ( v8 == v15 )
goto LABEL_24;
}
}
v12 = 0LL;
LABEL_24:
*(_QWORD *)(a3 + 8 * v13) = v12 + 1;
*v12 = 0;
return 0;
}
return v11;
}
|
mthd_my_read_one_row:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12,RCX
MOV RBX,RDX
MOV R13D,ESI
MOV R15,RDI
CALL 0x00126beb
MOV EAX,EAX
MOV R14D,0xffffffff
MOV ECX,0xffffffff
CMP RAX,RCX
JZ 0x00129903
MOV RCX,qword ptr [R15 + 0x20]
CMP EAX,0x8
JA 0x00129811
CMP byte ptr [RCX],0xfe
JNZ 0x00129811
MOVZX EAX,word ptr [RCX + 0x1]
MOV dword ptr [R15 + 0x388],EAX
MOVZX EAX,word ptr [RCX + 0x3]
MOV dword ptr [R15 + 0x380],EAX
MOV R14D,0x1
JMP 0x00129903
LAB_00129811:
XOR EDX,EDX
TEST R13D,R13D
JZ 0x001298c8
ADD RAX,RCX
MOV EDX,R13D
XOR ESI,ESI
XOR EDI,EDI
LAB_00129826:
MOVZX R8D,byte ptr [RCX]
CMP R8,0xfa
JA 0x0012986e
INC RCX
LAB_00129836:
MOV R9,RAX
SUB R9,RCX
CMP R8,R9
JA 0x001298da
CMP RCX,RAX
JA 0x001298da
MOV qword ptr [RBX + RSI*0x8],RCX
ADD RCX,R8
LAB_00129855:
MOV qword ptr [R12 + RSI*0x8],R8
TEST RDI,RDI
JZ 0x00129861
MOV byte ptr [RDI],0x0
LAB_00129861:
INC RSI
MOV RDI,RCX
CMP RDX,RSI
JNZ 0x00129826
JMP 0x001298ca
LAB_0012986e:
CMP R8,0xfb
JZ 0x001298ab
CMP R8D,0xfd
JZ 0x00129894
CMP R8D,0xfc
JNZ 0x001298bb
MOVZX R8D,word ptr [RCX + 0x1]
ADD RCX,0x3
JMP 0x00129836
LAB_00129894:
MOVZX R9D,word ptr [RCX + 0x1]
MOVZX R8D,byte ptr [RCX + 0x3]
ADD RCX,0x4
SHL R8D,0x10
OR R8,R9
JMP 0x00129836
LAB_001298ab:
INC RCX
MOV qword ptr [RBX + RSI*0x8],0x0
XOR R8D,R8D
JMP 0x00129855
LAB_001298bb:
MOV R8D,dword ptr [RCX + 0x1]
ADD RCX,0x9
JMP 0x00129836
LAB_001298c8:
XOR ECX,ECX
LAB_001298ca:
LEA RAX,[RCX + 0x1]
MOV qword ptr [RBX + RDX*0x8],RAX
MOV byte ptr [RCX],0x0
XOR R14D,R14D
JMP 0x00129903
LAB_001298da:
MOV dword ptr [R15 + 0x90],0x7d0
ADD R15,0x97
LEA RAX,[0x162a00]
MOV RSI,qword ptr [RAX]
MOV EDX,0x1ff
MOV RDI,R15
CALL 0x00114230
LAB_00129903:
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 mthd_my_read_one_row(long param_1,uint param_2,long param_3,long param_4)
{
byte bVar1;
uint uVar2;
byte *pbVar3;
byte *pbVar4;
byte *pbVar5;
ulong uVar6;
ulong uVar7;
byte *pbVar8;
ulong uVar9;
int8 uVar10;
uVar6 = (ulong)param_2;
uVar2 = ma_net_safe_read();
uVar10 = 0xffffffff;
if ((ulong)uVar2 != 0xffffffff) {
pbVar5 = *(byte **)(param_1 + 0x20);
if ((uVar2 < 9) && (*pbVar5 == 0xfe)) {
*(uint *)(param_1 + 0x388) = (uint)*(ushort *)(pbVar5 + 1);
*(uint *)(param_1 + 0x380) = (uint)*(ushort *)(pbVar5 + 3);
uVar10 = 1;
}
else {
if (param_2 == 0) {
pbVar5 = (byte *)0x0;
uVar6 = 0;
}
else {
pbVar3 = pbVar5 + uVar2;
uVar7 = 0;
pbVar8 = (byte *)0x0;
do {
bVar1 = *pbVar5;
uVar9 = (ulong)bVar1;
if (uVar9 < 0xfb) {
pbVar4 = pbVar5 + 1;
LAB_00129836:
if (((ulong)((long)pbVar3 - (long)pbVar4) < uVar9) || (pbVar3 < pbVar4)) {
*(int4 *)(param_1 + 0x90) = 2000;
strncpy((char *)(param_1 + 0x97),client_errors,0x1ff);
return 0xffffffff;
}
*(byte **)(param_3 + uVar7 * 8) = pbVar4;
pbVar5 = pbVar4 + uVar9;
}
else {
if (uVar9 != 0xfb) {
if (bVar1 == 0xfd) {
pbVar4 = pbVar5 + 4;
uVar9 = (ulong)*(uint3 *)(pbVar5 + 1);
}
else if (bVar1 == 0xfc) {
uVar9 = (ulong)*(ushort *)(pbVar5 + 1);
pbVar4 = pbVar5 + 3;
}
else {
uVar9 = (ulong)*(uint *)(pbVar5 + 1);
pbVar4 = pbVar5 + 9;
}
goto LAB_00129836;
}
pbVar5 = pbVar5 + 1;
*(int8 *)(param_3 + uVar7 * 8) = 0;
uVar9 = 0;
}
*(ulong *)(param_4 + uVar7 * 8) = uVar9;
if (pbVar8 != (byte *)0x0) {
*pbVar8 = 0;
}
uVar7 = uVar7 + 1;
pbVar8 = pbVar5;
} while (uVar6 != uVar7);
}
*(byte **)(param_3 + uVar6 * 8) = pbVar5 + 1;
*pbVar5 = 0;
uVar10 = 0;
}
}
return uVar10;
}
|
|
6,881 |
ftxui::(anonymous namespace)::InputBase::CursorColumn()
|
Andrewchistyakov[P]flashcards_lyc/build_O0/_deps/ftxui-src/src/ftxui/component/input.cpp
|
size_t CursorColumn() {
size_t iter = cursor_position();
int width = 0;
while (true) {
if (iter == 0) {
break;
}
iter = GlyphPrevious(content(), iter);
if (content()[iter] == '\n') {
break;
}
width += GlyphWidth(content(), iter);
}
return width;
}
|
O0
|
cpp
|
ftxui::(anonymous namespace)::InputBase::CursorColumn():
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x28, %rdi
addq $0xd0, %rdi
callq 0x5d970
movslq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5bb9b
jmp 0x5bc03
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x5d850
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x8dab0
movq -0x20(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x28, %rdi
callq 0x5d850
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xdb90
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x5bbdb
jmp 0x5bc03
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x5d850
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x5baf0
movq %rax, %rcx
movslq -0x14(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x14(%rbp)
jmp 0x5bb92
movslq -0x14(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
_ZN5ftxui12_GLOBAL__N_19InputBase12CursorColumnEv:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
mov [rbp+var_20], rdi
add rdi, 28h ; '('
add rdi, 0D0h
call _ZN5ftxui3RefIiEclEv; ftxui::Ref<int>::operator()(void)
movsxd rax, dword ptr [rax]
mov [rbp+var_10], rax
mov [rbp+var_14], 0
loc_5BB92:
cmp [rbp+var_10], 0
jnz short loc_5BB9B
jmp short loc_5BC03
loc_5BB9B:
mov rdi, [rbp+var_20]
add rdi, 28h ; '('
call _ZN5ftxui3RefINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEv; ftxui::Ref<std::string>::operator()(void)
mov rdi, rax
mov rsi, [rbp+var_10]
call _ZN5ftxui13GlyphPreviousERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm; ftxui::GlyphPrevious(std::string const&,ulong)
mov rdi, [rbp+var_20]
mov [rbp+var_10], rax
add rdi, 28h ; '('
call _ZN5ftxui3RefINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEv; ftxui::Ref<std::string>::operator()(void)
mov rdi, rax
mov rsi, [rbp+var_10]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm; std::string::operator[](ulong)
movsx eax, byte ptr [rax]
cmp eax, 0Ah
jnz short loc_5BBDB
jmp short loc_5BC03
loc_5BBDB:
mov rdi, [rbp+var_20]
add rdi, 28h ; '('
call _ZN5ftxui3RefINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEv; ftxui::Ref<std::string>::operator()(void)
mov rdi, rax
mov rsi, [rbp+var_10]
call _ZN5ftxui12_GLOBAL__N_110GlyphWidthERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm; ftxui::`anonymous namespace'::GlyphWidth(std::string const&,ulong)
mov rcx, rax
movsxd rax, [rbp+var_14]
add rax, rcx
mov [rbp+var_14], eax
jmp short loc_5BB92
loc_5BC03:
movsxd rax, [rbp+var_14]
add rsp, 20h
pop rbp
retn
|
long long ftxui::`anonymous namespace'::InputBase::CursorColumn(ftxui::_anonymous_namespace_::InputBase *this)
{
long long v1; // rax
long long v2; // rax
long long v3; // rax
int i; // [rsp+Ch] [rbp-14h]
long long v6; // [rsp+10h] [rbp-10h]
v6 = *(int *)ftxui::Ref<int>::operator()((char *)this + 248);
for ( i = 0; v6; i += ftxui::`anonymous namespace'::GlyphWidth(v3, v6) )
{
v1 = ftxui::Ref<std::string>::operator()((char *)this + 40);
v6 = ftxui::GlyphPrevious(v1, v6);
v2 = ftxui::Ref<std::string>::operator()((char *)this + 40);
if ( *(_BYTE *)std::string::operator[](v2, v6) == 10 )
break;
v3 = ftxui::Ref<std::string>::operator()((char *)this + 40);
}
return i;
}
|
CursorColumn:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RDI
ADD RDI,0x28
ADD RDI,0xd0
CALL 0x0015d970
MOVSXD RAX,dword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x14],0x0
LAB_0015bb92:
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x0015bb9b
JMP 0x0015bc03
LAB_0015bb9b:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x28
CALL 0x0015d850
MOV RDI,RAX
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x0018dab0
MOV RDI,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x10],RAX
ADD RDI,0x28
CALL 0x0015d850
MOV RDI,RAX
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x0010db90
MOVSX EAX,byte ptr [RAX]
CMP EAX,0xa
JNZ 0x0015bbdb
JMP 0x0015bc03
LAB_0015bbdb:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x28
CALL 0x0015d850
MOV RDI,RAX
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x0015baf0
MOV RCX,RAX
MOVSXD RAX,dword ptr [RBP + -0x14]
ADD RAX,RCX
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0015bb92
LAB_0015bc03:
MOVSXD RAX,dword ptr [RBP + -0x14]
ADD RSP,0x20
POP RBP
RET
|
/* ftxui::(anonymous namespace)::InputBase::CursorColumn() */
long __thiscall ftxui::(anonymous_namespace)::InputBase::CursorColumn(InputBase *this)
{
int iVar1;
int *piVar2;
string *psVar3;
ulong uVar4;
char *pcVar5;
int local_1c;
ulong local_18;
piVar2 = (int *)Ref<int>::operator()((Ref<int> *)(this + 0xf8));
local_18 = (ulong)*piVar2;
local_1c = 0;
while (local_18 != 0) {
psVar3 = (string *)
Ref<std::__cxx11::string>::operator()((Ref<std::__cxx11::string> *)(this + 0x28));
local_18 = GlyphPrevious(psVar3,local_18);
uVar4 = Ref<std::__cxx11::string>::operator()((Ref<std::__cxx11::string> *)(this + 0x28));
pcVar5 = (char *)std::__cxx11::string::operator[](uVar4);
if (*pcVar5 == '\n') break;
psVar3 = (string *)
Ref<std::__cxx11::string>::operator()((Ref<std::__cxx11::string> *)(this + 0x28));
iVar1 = GlyphWidth(psVar3,local_18);
local_1c = local_1c + iVar1;
}
return (long)local_1c;
}
|
|
6,882 |
split_maria_rtree_node
|
eloqsql/storage/maria/ma_rt_split.c
|
static int split_maria_rtree_node(SplitStruct *node, int n_entries,
int all_size, /* Total key's size */
int key_size,
int min_size, /* Minimal group size */
int size1, int size2 /* initial group sizes */,
double **d_buffer, int n_dim)
{
SplitStruct *cur;
SplitStruct *UNINIT_VAR(a);
SplitStruct *UNINIT_VAR(b);
double *g1= reserve_coords(d_buffer, n_dim);
double *g2= reserve_coords(d_buffer, n_dim);
SplitStruct *UNINIT_VAR(next);
int UNINIT_VAR(next_node);
int i;
SplitStruct *end= node + n_entries;
if (all_size < min_size * 2)
{
return 1;
}
cur= node;
for (; cur < end; cur++)
{
cur->square= count_square(cur->coords, n_dim);
cur->n_node= 0;
}
pick_seeds(node, n_entries, &a, &b, n_dim);
a->n_node= 1;
b->n_node= 2;
copy_coords(g1, a->coords, n_dim);
size1+= key_size;
copy_coords(g2, b->coords, n_dim);
size2+= key_size;
for (i=n_entries - 2; i>0; --i)
{
if (all_size - (size2 + key_size) < min_size) /* Can't write into group 2 */
{
mark_all_entries(node, n_entries, 1);
break;
}
if (all_size - (size1 + key_size) < min_size) /* Can't write into group 1 */
{
mark_all_entries(node, n_entries, 2);
break;
}
pick_next(node, n_entries, g1, g2, &next, &next_node, n_dim);
if (next_node == 1)
{
size1+= key_size;
mbr_join(g1, next->coords, n_dim);
}
else
{
size2+= key_size;
mbr_join(g2, next->coords, n_dim);
}
next->n_node= next_node;
}
return 0;
}
|
O0
|
c
|
split_maria_rtree_node:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x18(%rbp), %rdi
movl 0x20(%rbp), %esi
callq 0x8a1e0
movq %rax, -0x48(%rbp)
movq 0x18(%rbp), %rdi
movl 0x20(%rbp), %esi
callq 0x8a1e0
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x5c(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x68(%rbp)
movl -0x18(%rbp), %eax
movl -0x20(%rbp), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0x8a2b0
movl $0x1, -0x4(%rbp)
jmp 0x8a43a
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x68(%rbp), %rax
jae 0x8a2f3
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
movl 0x20(%rbp), %esi
callq 0x8a710
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
jmp 0x8a2b8
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl 0x20(%rbp), %r8d
leaq -0x38(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x8a780
movq -0x38(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x40(%rbp), %rax
movl $0x2, 0x8(%rax)
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rsi
movl 0x20(%rbp), %edx
callq 0x8a890
movl -0x1c(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rsi
movl 0x20(%rbp), %edx
callq 0x8a890
movl -0x1c(%rbp), %eax
addl 0x10(%rbp), %eax
movl %eax, 0x10(%rbp)
movl -0x14(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x60(%rbp)
cmpl $0x0, -0x60(%rbp)
jle 0x8a433
movl -0x18(%rbp), %eax
movl 0x10(%rbp), %ecx
addl -0x1c(%rbp), %ecx
subl %ecx, %eax
cmpl -0x20(%rbp), %eax
jge 0x8a394
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x1, %edx
callq 0x8a8d0
jmp 0x8a433
movl -0x18(%rbp), %eax
movl -0x24(%rbp), %ecx
addl -0x1c(%rbp), %ecx
subl %ecx, %eax
cmpl -0x20(%rbp), %eax
jge 0x8a3b7
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x2, %edx
callq 0x8a8d0
jmp 0x8a433
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rcx
movl 0x20(%rbp), %eax
leaq -0x58(%rbp), %r8
leaq -0x5c(%rbp), %r9
movl %eax, (%rsp)
callq 0x8a930
cmpl $0x1, -0x5c(%rbp)
jne 0x8a3fe
movl -0x1c(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rax
movq 0x18(%rax), %rsi
movl 0x20(%rbp), %edx
callq 0x8aa50
jmp 0x8a41b
movl -0x1c(%rbp), %eax
addl 0x10(%rbp), %eax
movl %eax, 0x10(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rax
movq 0x18(%rax), %rsi
movl 0x20(%rbp), %edx
callq 0x8aa50
movl -0x5c(%rbp), %ecx
movq -0x58(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x60(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x8a364
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
split_maria_rtree_node:
push rbp
mov rbp, rsp
sub rsp, 70h
mov eax, [rbp+arg_10]
mov rax, [rbp+arg_8]
mov eax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_1C], ecx
mov [rbp+var_20], r8d
mov [rbp+var_24], r9d
mov rax, [rbp+var_38]
mov [rbp+var_38], rax
mov rax, [rbp+var_40]
mov [rbp+var_40], rax
mov rdi, [rbp+arg_8]
mov esi, [rbp+arg_10]
call reserve_coords
mov [rbp+var_48], rax
mov rdi, [rbp+arg_8]
mov esi, [rbp+arg_10]
call reserve_coords
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
mov [rbp+var_58], rax
mov eax, [rbp+var_5C]
mov [rbp+var_5C], eax
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_14]
shl rcx, 5
add rax, rcx
mov [rbp+var_68], rax
mov eax, [rbp+var_18]
mov ecx, [rbp+var_20]
shl ecx, 1
cmp eax, ecx
jge short loc_8A2B0
mov [rbp+var_4], 1
jmp loc_8A43A
loc_8A2B0:
mov rax, [rbp+var_10]
mov [rbp+var_30], rax
loc_8A2B8:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_68]
jnb short loc_8A2F3
mov rax, [rbp+var_30]
mov rdi, [rax+18h]
mov esi, [rbp+arg_10]
call count_square
mov rax, [rbp+var_30]
movsd qword ptr [rax], xmm0
mov rax, [rbp+var_30]
mov dword ptr [rax+8], 0
mov rax, [rbp+var_30]
add rax, 20h ; ' '
mov [rbp+var_30], rax
jmp short loc_8A2B8
loc_8A2F3:
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
mov r8d, [rbp+arg_10]
lea rdx, [rbp+var_38]
lea rcx, [rbp+var_40]
call pick_seeds
mov rax, [rbp+var_38]
mov dword ptr [rax+8], 1
mov rax, [rbp+var_40]
mov dword ptr [rax+8], 2
mov rdi, [rbp+var_48]
mov rax, [rbp+var_38]
mov rsi, [rax+18h]
mov edx, [rbp+arg_10]
call copy_coords
mov eax, [rbp+var_1C]
add eax, [rbp+var_24]
mov [rbp+var_24], eax
mov rdi, [rbp+var_50]
mov rax, [rbp+var_40]
mov rsi, [rax+18h]
mov edx, [rbp+arg_10]
call copy_coords
mov eax, [rbp+var_1C]
add eax, [rbp+arg_0]
mov [rbp+arg_0], eax
mov eax, [rbp+var_14]
sub eax, 2
mov [rbp+var_60], eax
loc_8A364:
cmp [rbp+var_60], 0
jle loc_8A433
mov eax, [rbp+var_18]
mov ecx, [rbp+arg_0]
add ecx, [rbp+var_1C]
sub eax, ecx
cmp eax, [rbp+var_20]
jge short loc_8A394
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
mov edx, 1
call mark_all_entries
jmp loc_8A433
loc_8A394:
mov eax, [rbp+var_18]
mov ecx, [rbp+var_24]
add ecx, [rbp+var_1C]
sub eax, ecx
cmp eax, [rbp+var_20]
jge short loc_8A3B7
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
mov edx, 2
call mark_all_entries
jmp short loc_8A433
loc_8A3B7:
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
mov rdx, [rbp+var_48]
mov rcx, [rbp+var_50]
mov eax, [rbp+arg_10]
lea r8, [rbp+var_58]
lea r9, [rbp+var_5C]
mov [rsp+70h+var_70], eax
call pick_next
cmp [rbp+var_5C], 1
jnz short loc_8A3FE
mov eax, [rbp+var_1C]
add eax, [rbp+var_24]
mov [rbp+var_24], eax
mov rdi, [rbp+var_48]
mov rax, [rbp+var_58]
mov rsi, [rax+18h]
mov edx, [rbp+arg_10]
call mbr_join
jmp short loc_8A41B
loc_8A3FE:
mov eax, [rbp+var_1C]
add eax, [rbp+arg_0]
mov [rbp+arg_0], eax
mov rdi, [rbp+var_50]
mov rax, [rbp+var_58]
mov rsi, [rax+18h]
mov edx, [rbp+arg_10]
call mbr_join
loc_8A41B:
mov ecx, [rbp+var_5C]
mov rax, [rbp+var_58]
mov [rax+8], ecx
mov eax, [rbp+var_60]
add eax, 0FFFFFFFFh
mov [rbp+var_60], eax
jmp loc_8A364
loc_8A433:
mov [rbp+var_4], 0
loc_8A43A:
mov eax, [rbp+var_4]
add rsp, 70h
pop rbp
retn
|
long long split_maria_rtree_node(
unsigned long long a1,
unsigned int a2,
int a3,
int a4,
int a5,
int a6,
int a7,
long long *a8,
unsigned int a9)
{
int j; // [rsp+10h] [rbp-60h]
int v11; // [rsp+14h] [rbp-5Ch] BYREF
long long v12; // [rsp+18h] [rbp-58h] BYREF
long long v13; // [rsp+20h] [rbp-50h]
long long v14; // [rsp+28h] [rbp-48h]
long long v15; // [rsp+30h] [rbp-40h] BYREF
long long v16; // [rsp+38h] [rbp-38h] BYREF
unsigned long long i; // [rsp+40h] [rbp-30h]
int v18; // [rsp+4Ch] [rbp-24h]
int v19; // [rsp+50h] [rbp-20h]
int v20; // [rsp+54h] [rbp-1Ch]
int v21; // [rsp+58h] [rbp-18h]
unsigned int v22; // [rsp+5Ch] [rbp-14h]
unsigned long long v23; // [rsp+60h] [rbp-10h]
int v25; // [rsp+80h] [rbp+10h]
v23 = a1;
v22 = a2;
v21 = a3;
v20 = a4;
v19 = a5;
v18 = a6;
v14 = reserve_coords(a8, a9);
v13 = reserve_coords(a8, a9);
if ( v21 >= 2 * v19 )
{
for ( i = v23; i < 32LL * (int)a2 + a1; i += 32LL )
{
*(double *)i = count_square(*(_QWORD *)(i + 24), a9);
*(_DWORD *)(i + 8) = 0;
}
pick_seeds(v23, v22, &v16, &v15, a9);
*(_DWORD *)(v16 + 8) = 1;
*(_DWORD *)(v15 + 8) = 2;
copy_coords(v14, *(_QWORD *)(v16 + 24), a9);
v18 += v20;
copy_coords(v13, *(_QWORD *)(v15 + 24), a9);
v25 = a7 + v20;
for ( j = v22 - 2; j > 0; --j )
{
if ( v21 - (v20 + v25) < v19 )
{
mark_all_entries(v23, v22, 1LL);
break;
}
if ( v21 - (v20 + v18) < v19 )
{
mark_all_entries(v23, v22, 2LL);
break;
}
pick_next(v23, v22, v14, v13, (unsigned int)&v12, (unsigned int)&v11, a9);
if ( v11 == 1 )
{
v18 += v20;
mbr_join(v14, *(_QWORD *)(v12 + 24), a9);
}
else
{
v25 += v20;
mbr_join(v13, *(_QWORD *)(v12 + 24), a9);
}
*(_DWORD *)(v12 + 8) = v11;
}
return 0;
}
else
{
return 1;
}
}
|
split_maria_rtree_node:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV EAX,dword ptr [RBP + 0x20]
MOV RAX,qword ptr [RBP + 0x18]
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV dword ptr [RBP + -0x1c],ECX
MOV dword ptr [RBP + -0x20],R8D
MOV dword ptr [RBP + -0x24],R9D
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + 0x18]
MOV ESI,dword ptr [RBP + 0x20]
CALL 0x0018a1e0
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + 0x18]
MOV ESI,dword ptr [RBP + 0x20]
CALL 0x0018a1e0
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x58],RAX
MOV EAX,dword ptr [RBP + -0x5c]
MOV dword ptr [RBP + -0x5c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x14]
SHL RCX,0x5
ADD RAX,RCX
MOV qword ptr [RBP + -0x68],RAX
MOV EAX,dword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x20]
SHL ECX,0x1
CMP EAX,ECX
JGE 0x0018a2b0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0018a43a
LAB_0018a2b0:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RAX
LAB_0018a2b8:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x68]
JNC 0x0018a2f3
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RAX + 0x18]
MOV ESI,dword ptr [RBP + 0x20]
CALL 0x0018a710
MOV RAX,qword ptr [RBP + -0x30]
MOVSD qword ptr [RAX],XMM0
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x20
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0018a2b8
LAB_0018a2f3:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
MOV R8D,dword ptr [RBP + 0x20]
LEA RDX,[RBP + -0x38]
LEA RCX,[RBP + -0x40]
CALL 0x0018a780
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x8],0x1
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RAX + 0x8],0x2
MOV RDI,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RAX + 0x18]
MOV EDX,dword ptr [RBP + 0x20]
CALL 0x0018a890
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x24],EAX
MOV RDI,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RAX + 0x18]
MOV EDX,dword ptr [RBP + 0x20]
CALL 0x0018a890
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,dword ptr [RBP + 0x10]
MOV dword ptr [RBP + 0x10],EAX
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x2
MOV dword ptr [RBP + -0x60],EAX
LAB_0018a364:
CMP dword ptr [RBP + -0x60],0x0
JLE 0x0018a433
MOV EAX,dword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + 0x10]
ADD ECX,dword ptr [RBP + -0x1c]
SUB EAX,ECX
CMP EAX,dword ptr [RBP + -0x20]
JGE 0x0018a394
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
MOV EDX,0x1
CALL 0x0018a8d0
JMP 0x0018a433
LAB_0018a394:
MOV EAX,dword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x24]
ADD ECX,dword ptr [RBP + -0x1c]
SUB EAX,ECX
CMP EAX,dword ptr [RBP + -0x20]
JGE 0x0018a3b7
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
MOV EDX,0x2
CALL 0x0018a8d0
JMP 0x0018a433
LAB_0018a3b7:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
MOV RDX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RBP + 0x20]
LEA R8,[RBP + -0x58]
LEA R9,[RBP + -0x5c]
MOV dword ptr [RSP],EAX
CALL 0x0018a930
CMP dword ptr [RBP + -0x5c],0x1
JNZ 0x0018a3fe
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x24],EAX
MOV RDI,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x58]
MOV RSI,qword ptr [RAX + 0x18]
MOV EDX,dword ptr [RBP + 0x20]
CALL 0x0018aa50
JMP 0x0018a41b
LAB_0018a3fe:
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,dword ptr [RBP + 0x10]
MOV dword ptr [RBP + 0x10],EAX
MOV RDI,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x58]
MOV RSI,qword ptr [RAX + 0x18]
MOV EDX,dword ptr [RBP + 0x20]
CALL 0x0018aa50
LAB_0018a41b:
MOV ECX,dword ptr [RBP + -0x5c]
MOV RAX,qword ptr [RBP + -0x58]
MOV dword ptr [RAX + 0x8],ECX
MOV EAX,dword ptr [RBP + -0x60]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x60],EAX
JMP 0x0018a364
LAB_0018a433:
MOV dword ptr [RBP + -0x4],0x0
LAB_0018a43a:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x70
POP RBP
RET
|
int4
split_maria_rtree_node
(int8 *param_1,int param_2,int param_3,int param_4,int param_5,int param_6,
int param_7,int8 param_8,int4 param_9)
{
int8 *puVar1;
int8 uVar2;
int local_68;
int local_64;
long local_60;
int8 local_58;
int8 local_50;
long local_48;
long local_40;
int8 *local_38;
int local_2c;
int local_28;
int local_24;
int local_20;
int local_1c;
int8 *local_18;
int4 local_c;
local_2c = param_6;
local_28 = param_5;
local_24 = param_4;
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
local_50 = reserve_coords(param_8,param_9);
local_58 = reserve_coords(param_8,param_9);
puVar1 = local_18 + (long)local_1c * 4;
if (SBORROW4(local_20,local_28 * 2) == local_20 + local_28 * -2 < 0) {
for (local_38 = local_18; local_38 < puVar1; local_38 = local_38 + 4) {
uVar2 = count_square(local_38[3],param_9);
*local_38 = uVar2;
*(int4 *)(local_38 + 1) = 0;
}
pick_seeds(local_18,local_1c,&local_40,&local_48,param_9);
*(int4 *)(local_40 + 8) = 1;
*(int4 *)(local_48 + 8) = 2;
copy_coords(local_50,*(int8 *)(local_40 + 0x18),param_9);
local_2c = local_24 + local_2c;
copy_coords(local_58,*(int8 *)(local_48 + 0x18),param_9);
param_7 = local_24 + param_7;
for (local_68 = local_1c + -2; 0 < local_68; local_68 = local_68 + -1) {
if (local_20 - (param_7 + local_24) < local_28) {
mark_all_entries(local_18,local_1c,1);
break;
}
if (local_20 - (local_2c + local_24) < local_28) {
mark_all_entries(local_18,local_1c,2);
break;
}
pick_next(local_18,local_1c,local_50,local_58,&local_60,&local_64,param_9);
if (local_64 == 1) {
local_2c = local_24 + local_2c;
mbr_join(local_50,*(int8 *)(local_60 + 0x18),param_9);
}
else {
param_7 = local_24 + param_7;
mbr_join(local_58,*(int8 *)(local_60 + 0x18),param_9);
}
*(int *)(local_60 + 8) = local_64;
}
local_c = 0;
}
else {
local_c = 1;
}
return local_c;
}
|
|
6,883 |
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>::get_binary() const
|
llama.cpp/common/json.hpp
|
const binary_t& get_binary() const
{
if (!is_binary())
{
JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));
}
return *get_ptr<const binary_t*>();
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::get_binary() const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x8, (%rdi)
jne 0x760c9
movq 0x8(%r14), %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x1d520
movq %rax, %rbx
movq %r14, %rdi
callq 0x607fe
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x5ce92(%rip), %rsi # 0xd2f7f
leaq 0x10(%rsp), %rdi
callq 0x2f9da
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12e, %esi # imm = 0x12E
movq %r14, %rcx
callq 0x60626
xorl %ebp, %ebp
leaq 0x92da8(%rip), %rsi # 0x108ec0
leaq -0x4ce01(%rip), %rdx # 0x2931e
movq %rbx, %rdi
callq 0x1d890
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x76145
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1d160
testb %bpl, %bpl
jne 0x7614f
jmp 0x76157
movq %rax, %r14
movq %rbx, %rdi
callq 0x1dc90
movq %r14, %rdi
callq 0x1d8e0
nop
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10get_binaryEv:
push rbp; void *
push r14; int
push rbx; __int64
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 8
jnz short loc_760C9
mov rax, [r14+8]
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_760C9:
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, aTypeMustBeBina; "type must be binary, 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_76145
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_76145:
test bpl, bpl
jnz short loc_7614F
jmp short loc_76157
mov r14, rax
loc_7614F:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_76157:
mov rdi, r14
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::get_binary(
long long a1)
{
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
const char *v3; // [rsp+8h] [rbp-40h] BYREF
_QWORD v4[2]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 != 8 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v3 = 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)v4,
(long long)"type must be binary, but is ",
&v3);
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,
v4);
__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);
}
return *(_QWORD *)(a1 + 8);
}
|
get_binary:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x8
JNZ 0x001760c9
MOV RAX,qword ptr [R14 + 0x8]
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_001760c9:
MOV EDI,0x20
CALL 0x0011d520
MOV RBX,RAX
MOV RDI,R14
CALL 0x001607fe
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001760e6:
LEA RSI,[0x1d2f7f]
LEA RDI,[RSP + 0x10]
CALL 0x0012f9da
MOV BPL,0x1
LAB_001760fa:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12e
MOV RCX,R14
CALL 0x00160626
XOR EBP,EBP
LEA RSI,[0x208ec0]
LEA RDX,[0x12931e]
MOV RDI,RBX
CALL 0x0011d890
|
/* 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>::get_binary() const */
int8 __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::get_binary(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this)
{
int8 uVar1;
char *local_40;
detail local_38 [32];
if (*this == (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>
)0x8) {
return *(int8 *)(this + 8);
}
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 001760e6 to 001760f6 has its CatchHandler @ 0017614c */
detail::concat<std::__cxx11::string,char_const(&)[29],char_const*>
(local_38,"type must be binary, but is ",&local_40);
/* try { // try from 001760fa to 00176126 has its CatchHandler @ 00176127 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar1,0x12e,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
|
|
6,884 |
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>>>>>::get_codepoint()
|
hkr04[P]cpp-mcp/common/json.hpp
|
int get_codepoint()
{
// this function only makes sense after reading `\u`
JSON_ASSERT(current == 'u');
int codepoint = 0;
const auto factors = { 12u, 8u, 4u, 0u };
for (const auto factor : factors)
{
get();
if (current >= '0' && current <= '9')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
}
else if (current >= 'A' && current <= 'F')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
}
else if (current >= 'a' && current <= 'f')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
}
else
{
return -1;
}
}
JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
return codepoint;
}
|
O1
|
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>>>>>::get_codepoint():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movaps 0x3a156(%rip), %xmm0 # 0x43340
movaps %xmm0, (%rsp)
xorl %r14d, %r14d
pushq $-0x30
popq %r12
pushq $-0x37
popq %r13
xorl %r15d, %r15d
movl (%rsp,%r15), %ebp
movq %rbx, %rdi
callq 0x912c
movl 0x14(%rbx), %eax
leal -0x30(%rax), %edx
movl %r12d, %ecx
cmpl $0xa, %edx
jb 0x922c
leal -0x41(%rax), %edx
movl %r13d, %ecx
cmpl $0x6, %edx
jb 0x922c
leal -0x61(%rax), %edx
pushq $-0x57
popq %rcx
cmpl $0x5, %edx
ja 0x924a
addl %ecx, %eax
movl %ebp, %ecx
shll %cl, %eax
addl %r14d, %eax
movb $0x1, %cl
movl %eax, %r14d
testb %cl, %cl
je 0x924e
addq $0x4, %r15
cmpq $0x10, %r15
jne 0x91fc
jmp 0x9254
xorl %ecx, %ecx
jmp 0x923a
pushq $-0x1
popq %rax
movl %eax, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE13get_codepointEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
movaps xmm0, cs:xmmword_43340
movaps [rsp+48h+var_48], xmm0
xor r14d, r14d
push 0FFFFFFFFFFFFFFD0h
pop r12
push 0FFFFFFFFFFFFFFC9h
pop r13
xor r15d, r15d
loc_91FC:
mov ebp, dword ptr [rsp+r15+48h+var_48]
mov rdi, rbx
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, [rbx+14h]
lea edx, [rax-30h]
mov ecx, r12d
cmp edx, 0Ah
jb short loc_922C
lea edx, [rax-41h]
mov ecx, r13d
cmp edx, 6
jb short loc_922C
lea edx, [rax-61h]
push 0FFFFFFFFFFFFFFA9h
pop rcx
cmp edx, 5
ja short loc_924A
loc_922C:
add eax, ecx
mov ecx, ebp
shl eax, cl
add eax, r14d
mov cl, 1
mov r14d, eax
loc_923A:
test cl, cl
jz short loc_924E
add r15, 4
cmp r15, 10h
jnz short loc_91FC
jmp short loc_9254
loc_924A:
xor ecx, ecx
jmp short loc_923A
loc_924E:
push 0FFFFFFFFFFFFFFFFh
pop rax
mov r14d, eax
loc_9254:
mov eax, r14d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get_codepoint(
__m128i *a1)
{
unsigned int v1; // r14d
long long v2; // r15
int v3; // ebp
__int32 v4; // eax
int v5; // ecx
int v6; // eax
char v7; // cl
_OWORD v9[4]; // [rsp+0h] [rbp-48h]
v9[0] = xmmword_43340;
v1 = 0;
v2 = 0LL;
while ( 1 )
{
v3 = *(_DWORD *)((char *)v9 + v2);
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);
v4 = a1[1].m128i_i32[1];
v5 = -48;
if ( (unsigned int)(v4 - 48) >= 0xA
&& (v5 = -55, (unsigned int)(v4 - 65) >= 6)
&& (v5 = -87, (unsigned int)(v4 - 97) > 5) )
{
v7 = 0;
}
else
{
v6 = (v5 + v4) << v3;
v7 = 1;
v1 += v6;
}
if ( !v7 )
break;
v2 += 4LL;
if ( v2 == 16 )
return v1;
}
return (unsigned int)-1;
}
|
get_codepoint:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOVAPS XMM0,xmmword ptr [0x00143340]
MOVAPS xmmword ptr [RSP],XMM0
XOR R14D,R14D
PUSH -0x30
POP R12
PUSH -0x37
POP R13
XOR R15D,R15D
LAB_001091fc:
MOV EBP,dword ptr [RSP + R15*0x1]
MOV RDI,RBX
CALL 0x0010912c
MOV EAX,dword ptr [RBX + 0x14]
LEA EDX,[RAX + -0x30]
MOV ECX,R12D
CMP EDX,0xa
JC 0x0010922c
LEA EDX,[RAX + -0x41]
MOV ECX,R13D
CMP EDX,0x6
JC 0x0010922c
LEA EDX,[RAX + -0x61]
PUSH -0x57
POP RCX
CMP EDX,0x5
JA 0x0010924a
LAB_0010922c:
ADD EAX,ECX
MOV ECX,EBP
SHL EAX,CL
ADD EAX,R14D
MOV CL,0x1
MOV R14D,EAX
LAB_0010923a:
TEST CL,CL
JZ 0x0010924e
ADD R15,0x4
CMP R15,0x10
JNZ 0x001091fc
JMP 0x00109254
LAB_0010924a:
XOR ECX,ECX
JMP 0x0010923a
LAB_0010924e:
PUSH -0x1
POP RAX
MOV R14D,EAX
LAB_00109254:
MOV EAX,R14D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* 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 > > >::get_codepoint() */
int __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>>>
::get_codepoint(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)
{
int4 uVar1;
int iVar2;
bool bVar3;
int iVar4;
int iVar5;
long lVar6;
int8 local_48;
int8 uStack_40;
local_48 = _DAT_00143340;
uStack_40 = _UNK_00143348;
iVar4 = 0;
lVar6 = 0;
while( true ) {
uVar1 = *(int4 *)((long)&local_48 + lVar6);
get(this);
iVar2 = *(int *)(this + 0x14);
iVar5 = -0x30;
if (((iVar2 - 0x30U < 10) || (iVar5 = -0x37, iVar2 - 0x41U < 6)) ||
(iVar5 = -0x57, iVar2 - 0x61U < 6)) {
iVar4 = (iVar2 + iVar5 << ((byte)uVar1 & 0x1f)) + iVar4;
bVar3 = true;
}
else {
bVar3 = false;
}
if (!bVar3) break;
lVar6 = lVar6 + 4;
if (lVar6 == 0x10) {
return iVar4;
}
}
return -1;
}
|
|
6,885 |
testing::TestResult::RecordProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::TestProperty const&)
|
giladroyz[P]FindPeaks/build_O3/_deps/googletest-src/googletest/src/gtest.cc
|
void TestResult::RecordProperty(const std::string& xml_element,
const TestProperty& test_property) {
if (!ValidateTestProperty(xml_element, test_property)) {
return;
}
internal::MutexLock lock(&test_properties_mutex_);
const std::vector<TestProperty>::iterator property_with_matching_key =
std::find_if(test_properties_.begin(), test_properties_.end(),
internal::TestPropertyKeyIs(test_property.key()));
if (property_with_matching_key == test_properties_.end()) {
test_properties_.push_back(test_property);
return;
}
property_with_matching_key->SetValue(test_property.value());
}
|
O3
|
cpp
|
testing::TestResult::RecordProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::TestProperty const&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1fa2e
testb %al, %al
je 0x1f9b3
movq %rbx, %rdi
callq 0x36cf4
movq 0x50(%rbx), %r15
movq 0x58(%rbx), %r12
movq (%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x81e0
leaq 0x40(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq %rsi, %rdx
leaq 0x30(%rsp), %rdi
callq 0x391b4
leaq 0x30(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x33be3
movq %rax, %r15
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x1f940
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x84e0
leaq 0x20(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x1f95c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x84e0
cmpq 0x58(%rbx), %r15
je 0x1f99f
movq 0x20(%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x81e0
addq $0x20, %r15
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x8290
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x1f9ab
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x84e0
jmp 0x1f9ab
leaq 0x50(%rbx), %rdi
movq %r14, %rsi
callq 0x33d48
movq %rbx, %rdi
callq 0x36d92
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1fa12
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
jne 0x1fa03
jmp 0x1fa15
jmp 0x1fa12
jmp 0x1fa25
movq %rax, %r14
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x1f9f5
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x84e0
jmp 0x1f9f5
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fa15
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x84e0
jmp 0x1fa15
movq %rax, %r14
movq %rbx, %rdi
callq 0x36d92
movq %r14, %rdi
callq 0x8990
movq %rax, %rdi
callq 0x321df
nop
|
_ZN7testing10TestResult14RecordPropertyERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_12TestPropertyE:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 50h
mov r14, rdx
mov rbx, rdi
mov rdi, rsi
mov rsi, rdx
call _ZN7testing10TestResult20ValidateTestPropertyERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_12TestPropertyE; testing::TestResult::ValidateTestProperty(std::string const&,testing::TestProperty const&)
test al, al
jz loc_1F9B3
mov rdi, rbx; this
call _ZN7testing8internal9MutexBase4LockEv; testing::internal::MutexBase::Lock(void)
mov r15, [rbx+50h]
mov r12, [rbx+58h]
mov rsi, [r14]
lea rdi, [rsp+78h+var_68]
lea rdx, [rsp+78h+var_69]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2EPKcRKS3_; std::string::basic_string(char const*,std::allocator<char> const&)
lea r13, [rsp+78h+var_38]
mov [r13-10h], r13
mov rsi, [rsp+78h+var_68]
mov rdx, [rsp+78h+var_60]
add rdx, rsi
lea rdi, [rsp+78h+var_48]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rdx, [rsp+78h+var_48]; int
mov rdi, r15; int
mov rsi, r12; int
call _ZSt7find_ifIN9__gnu_cxx17__normal_iteratorIPN7testing12TestPropertyESt6vectorIS3_SaIS3_EEEENS2_8internal17TestPropertyKeyIsEET_SB_SB_T0_; std::find_if<__gnu_cxx::__normal_iterator<testing::TestProperty *,std::vector<testing::TestProperty>>,testing::internal::TestPropertyKeyIs>(__gnu_cxx::__normal_iterator<testing::TestProperty *,std::vector<testing::TestProperty>>,__gnu_cxx::__normal_iterator<testing::TestProperty *,std::vector<testing::TestProperty>>,testing::internal::TestPropertyKeyIs)
mov r15, rax
mov rdi, [rsp+78h+var_48]; void *
cmp rdi, r13
jz short loc_1F940
mov rsi, [rsp+78h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1F940:
lea r12, [rsp+78h+var_58]
mov rdi, [r12-10h]; void *
cmp rdi, r12
jz short loc_1F95C
mov rsi, [rsp+78h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1F95C:
cmp r15, [rbx+58h]
jz short loc_1F99F
mov rsi, [r14+20h]
lea rdi, [rsp+78h+var_68]
lea rdx, [rsp+78h+var_69]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2EPKcRKS3_; std::string::basic_string(char const*,std::allocator<char> const&)
add r15, 20h ; ' '
lea rsi, [rsp+78h+var_68]
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
mov rdi, [rsp+78h+var_68]; void *
cmp rdi, r12
jz short loc_1F9AB
mov rsi, [rsp+78h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_1F9AB
loc_1F99F:
lea rdi, [rbx+50h]
mov rsi, r14
call _ZNSt6vectorIN7testing12TestPropertyESaIS1_EE9push_backERKS1_; std::vector<testing::TestProperty>::push_back(testing::TestProperty const&)
loc_1F9AB:
mov rdi, rbx; this
call _ZN7testing8internal9MutexBase6UnlockEv; testing::internal::MutexBase::Unlock(void)
loc_1F9B3:
add rsp, 50h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
jmp short loc_1FA12
mov r14, rax
mov rdi, [rsp+78h+var_68]
cmp rdi, r12
jnz short loc_1FA03
jmp short loc_1FA15
jmp short loc_1FA12
jmp short loc_1FA25
mov r14, rax
mov rdi, [rsp+78h+var_48]; void *
cmp rdi, r13
jz short loc_1F9F5
mov rsi, [rsp+78h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_1F9F5
mov r14, rax
loc_1F9F5:
lea rax, [rsp+78h+var_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_1FA15
loc_1FA03:
mov rsi, [rsp+78h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_1FA15
loc_1FA12:
mov r14, rax
loc_1FA15:
mov rdi, rbx; this
call _ZN7testing8internal9MutexBase6UnlockEv; testing::internal::MutexBase::Unlock(void)
mov rdi, r14
call __Unwind_Resume
loc_1FA25:
mov rdi, rax
call __clang_call_terminate
|
RecordProperty:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x50
MOV R14,RDX
MOV RBX,RDI
MOV RDI,RSI
MOV RSI,RDX
CALL 0x0011fa2e
TEST AL,AL
JZ 0x0011f9b3
MOV RDI,RBX
CALL 0x00136cf4
MOV R15,qword ptr [RBX + 0x50]
MOV R12,qword ptr [RBX + 0x58]
MOV RSI,qword ptr [R14]
LAB_0011f8e7:
LEA RDI,[RSP + 0x10]
LEA RDX,[RSP + 0xf]
CALL 0x001081e0
LEA R13,[RSP + 0x40]
MOV qword ptr [R13 + -0x10],R13
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x18]
ADD RDX,RSI
LAB_0011f90c:
LEA RDI,[RSP + 0x30]
CALL 0x001391b4
LAB_0011f916:
LEA RDX,[RSP + 0x30]
MOV RDI,R15
MOV RSI,R12
CALL 0x00133be3
MOV R15,RAX
MOV RDI,qword ptr [RSP + 0x30]
CMP RDI,R13
JZ 0x0011f940
MOV RSI,qword ptr [RSP + 0x40]
INC RSI
CALL 0x001084e0
LAB_0011f940:
LEA R12,[RSP + 0x20]
MOV RDI,qword ptr [R12 + -0x10]
CMP RDI,R12
JZ 0x0011f95c
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x001084e0
LAB_0011f95c:
CMP R15,qword ptr [RBX + 0x58]
JZ 0x0011f99f
MOV RSI,qword ptr [R14 + 0x20]
LAB_0011f966:
LEA RDI,[RSP + 0x10]
LEA RDX,[RSP + 0xf]
CALL 0x001081e0
ADD R15,0x20
LAB_0011f979:
LEA RSI,[RSP + 0x10]
MOV RDI,R15
CALL 0x00108290
MOV RDI,qword ptr [RSP + 0x10]
CMP RDI,R12
JZ 0x0011f9ab
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x001084e0
JMP 0x0011f9ab
LAB_0011f99f:
LEA RDI,[RBX + 0x50]
MOV RSI,R14
CALL 0x00133d48
LAB_0011f9ab:
MOV RDI,RBX
CALL 0x00136d92
LAB_0011f9b3:
ADD RSP,0x50
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* testing::TestResult::RecordProperty(std::__cxx11::string const&, testing::TestProperty const&) */
void __thiscall
testing::TestResult::RecordProperty(TestResult *this,string *param_1,TestProperty *param_2)
{
int8 uVar1;
int8 uVar2;
long lVar3;
char cVar4;
allocator local_69;
long *local_68;
long local_60;
long local_58 [2];
long *local_48 [2];
long local_38 [2];
cVar4 = ValidateTestProperty(param_1,param_2);
if (cVar4 != '\0') {
internal::MutexBase::Lock((MutexBase *)this);
uVar1 = *(int8 *)(this + 0x50);
uVar2 = *(int8 *)(this + 0x58);
/* try { // try from 0011f8e7 to 0011f8f5 has its CatchHandler @ 0011fa12 */
std::__cxx11::string::string((string *)&local_68,*(char **)param_2,&local_69);
/* try { // try from 0011f90c to 0011f915 has its CatchHandler @ 0011f9f2 */
local_48[0] = local_38;
std::__cxx11::string::_M_construct<char*>(local_48,local_68,local_60 + (long)local_68);
/* try { // try from 0011f916 to 0011f925 has its CatchHandler @ 0011f9d6 */
lVar3 = std::
find_if<__gnu_cxx::__normal_iterator<testing::TestProperty*,std::vector<testing::TestProperty,std::allocator<testing::TestProperty>>>,testing::internal::TestPropertyKeyIs>
(uVar1,uVar2,local_48);
if (local_48[0] != local_38) {
operator_delete(local_48[0],local_38[0] + 1);
}
if (local_68 != local_58) {
operator_delete(local_68,local_58[0] + 1);
}
if (lVar3 == *(long *)(this + 0x58)) {
/* try { // try from 0011f99f to 0011f9aa has its CatchHandler @ 0011f9c1 */
std::vector<testing::TestProperty,std::allocator<testing::TestProperty>>::push_back
((vector<testing::TestProperty,std::allocator<testing::TestProperty>> *)
(this + 0x50),param_2);
}
else {
/* try { // try from 0011f966 to 0011f974 has its CatchHandler @ 0011f9d2 */
std::__cxx11::string::string((string *)&local_68,*(char **)(param_2 + 0x20),&local_69);
/* try { // try from 0011f979 to 0011f985 has its CatchHandler @ 0011f9c3 */
std::__cxx11::string::_M_assign((string *)(lVar3 + 0x20));
if (local_68 != local_58) {
operator_delete(local_68,local_58[0] + 1);
}
}
/* try { // try from 0011f9ab to 0011f9b2 has its CatchHandler @ 0011f9d4 */
internal::MutexBase::Unlock((MutexBase *)this);
}
return;
}
|
||
6,886 |
ggml_graph_view
|
ngxson[P]ggml-easy/ggml/src/ggml.c
|
struct ggml_cgraph ggml_graph_view(struct ggml_cgraph * cgraph0, int i0, int i1) {
struct ggml_cgraph cgraph = {
/*.size =*/ 0,
/*.n_nodes =*/ i1 - i0,
/*.n_leafs =*/ 0,
/*.nodes =*/ cgraph0->nodes + i0,
/*.grads =*/ NULL, // gradients would need visited_hash_set
/*.grad_accs =*/ NULL,
/*.leafs =*/ NULL,
/*.visited_hash_set =*/ { 0, NULL, NULL },
/*.order =*/ cgraph0->order,
};
return cgraph;
}
|
O2
|
c
|
ggml_graph_view:
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
subl %edx, %ecx
movl %ecx, 0x4(%rdi)
movslq %edx, %rcx
shlq $0x3, %rcx
addq 0x10(%rsi), %rcx
movq %rcx, 0x10(%rdi)
movl 0x48(%rsi), %ecx
movl %ecx, 0x48(%rdi)
retq
|
ggml_graph_view:
mov rax, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
movups xmmword ptr [rdi+40h], xmm0
movups xmmword ptr [rdi+30h], xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+10h], xmm0
sub ecx, edx
mov [rdi+4], ecx
movsxd rcx, edx
shl rcx, 3
add rcx, [rsi+10h]
mov [rdi+10h], rcx
mov ecx, [rsi+48h]
mov [rdi+48h], ecx
retn
|
long long ggml_graph_view(long long a1, long long a2, int a3, int a4)
{
long long result; // rax
result = a1;
*(_OWORD *)a1 = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
*(_DWORD *)(a1 + 4) = a4 - a3;
*(_QWORD *)(a1 + 16) = *(_QWORD *)(a2 + 16) + 8LL * a3;
*(_DWORD *)(a1 + 72) = *(_DWORD *)(a2 + 72);
return result;
}
|
ggml_graph_view:
MOV RAX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
SUB ECX,EDX
MOV dword ptr [RDI + 0x4],ECX
MOVSXD RCX,EDX
SHL RCX,0x3
ADD RCX,qword ptr [RSI + 0x10]
MOV qword ptr [RDI + 0x10],RCX
MOV ECX,dword ptr [RSI + 0x48]
MOV dword ptr [RDI + 0x48],ECX
RET
|
int8 * ggml_graph_view(int8 *param_1,long param_2,int param_3,int param_4)
{
*param_1 = 0;
param_1[1] = 0;
param_1[8] = 0;
param_1[9] = 0;
param_1[6] = 0;
param_1[7] = 0;
param_1[4] = 0;
param_1[5] = 0;
param_1[2] = 0;
param_1[3] = 0;
*(int *)((long)param_1 + 4) = param_4 - param_3;
param_1[2] = (long)param_3 * 8 + *(long *)(param_2 + 0x10);
*(int4 *)(param_1 + 9) = *(int4 *)(param_2 + 0x48);
return param_1;
}
|
|
6,887 |
test_opt_step_adamw::build_graph(ggml_context*)
|
monkey531[P]llama/tests/test-backend-ops.cpp
|
ggml_tensor * build_graph(ggml_context * ctx) override {
ggml_tensor * a = ggml_new_tensor_4d(ctx, type, ne[0], ne[1], ne[2], ne[3]);
ggml_set_param(ctx, a); // Despite tensor a having gradients the output tensor will not.
ggml_set_name(a, "a");
ggml_tensor * grad = ggml_new_tensor_4d(ctx, type, ne[0], ne[1], ne[2], ne[3]);
ggml_set_name(grad, "grad");
ggml_tensor * grad_m = ggml_new_tensor_4d(ctx, type, ne[0], ne[1], ne[2], ne[3]);
ggml_set_name(grad_m, "grad_m");
ggml_tensor * grad_v = ggml_new_tensor_4d(ctx, type, ne[0], ne[1], ne[2], ne[3]);
ggml_set_name(grad_v, "grad_v");
ggml_tensor * adamw_params = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, 7);
ggml_set_name(adamw_params, "adamw_params");
ggml_tensor * out = ggml_opt_step_adamw(ctx, a, grad, grad_m, grad_v, adamw_params);
ggml_set_name(out, "out");
return out;
}
|
O2
|
cpp
|
test_opt_step_adamw::build_graph(ggml_context*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x38(%rdi), %edx
movq 0x40(%rdi), %rcx
movq 0x48(%rdi), %r8
movq 0x50(%rdi), %r9
movq 0x58(%rdi), %rax
movq %rax, (%rsp)
callq 0x20c6c
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0xfac0
leaq 0x2565(%rip), %rsi # 0x30d8b
movq %r15, %rdi
callq 0xfb40
movl 0x38(%r14), %edx
movq 0x40(%r14), %rcx
movq 0x48(%r14), %r8
movq 0x50(%r14), %r9
movq 0x58(%r14), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20c6c
movq %rax, %r12
leaq 0x22d7(%rip), %rsi # 0x30b32
movq %rax, %rdi
callq 0xfb40
movl 0x38(%r14), %edx
movq 0x40(%r14), %rcx
movq 0x48(%r14), %r8
movq 0x50(%r14), %r9
movq 0x58(%r14), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20c6c
movq %rax, %r13
leaq 0x2921(%rip), %rsi # 0x311b1
movq %rax, %rdi
callq 0xfb40
movl 0x38(%r14), %edx
movq 0x40(%r14), %rcx
movq 0x48(%r14), %r8
movq 0x50(%r14), %r9
movq 0x58(%r14), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20c6c
movq %rax, %rbp
leaq 0x28f3(%rip), %rsi # 0x311b8
movq %rax, %rdi
callq 0xfb40
pushq $0x7
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x229c8
movq %rax, %r14
leaq 0x28d8(%rip), %rsi # 0x311bf
movq %rax, %rdi
callq 0xfb40
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %rbp, %r8
movq %r14, %r9
callq 0xf0d0
movq %rax, %rbx
leaq 0x2a22(%rip), %rsi # 0x31332
movq %rax, %rdi
callq 0xfb40
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZN19test_opt_step_adamw11build_graphEP12ggml_context:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov edx, [rdi+38h]
mov rcx, [rdi+40h]
mov r8, [rdi+48h]
mov r9, [rdi+50h]
mov rax, [rdi+58h]
mov [rsp+38h+var_38], rax
call _ZN9test_case18ggml_new_tensor_4dEP12ggml_context9ggml_typellll; test_case::ggml_new_tensor_4d(ggml_context *,ggml_type,long,long,long,long)
mov r15, rax
mov rdi, rbx
mov rsi, rax
call _ggml_set_param
lea rsi, aViewOfA+8; "a"
mov rdi, r15
call _ggml_set_name
mov edx, [r14+38h]
mov rcx, [r14+40h]
mov r8, [r14+48h]
mov r9, [r14+50h]
mov rax, [r14+58h]
mov [rsp+38h+var_38], rax
mov rdi, r14
mov rsi, rbx
call _ZN9test_case18ggml_new_tensor_4dEP12ggml_context9ggml_typellll; test_case::ggml_new_tensor_4d(ggml_context *,ggml_type,long,long,long,long)
mov r12, rax
lea rsi, aGrad; "grad"
mov rdi, rax
call _ggml_set_name
mov edx, [r14+38h]
mov rcx, [r14+40h]
mov r8, [r14+48h]
mov r9, [r14+50h]
mov rax, [r14+58h]
mov [rsp+38h+var_38], rax
mov rdi, r14
mov rsi, rbx
call _ZN9test_case18ggml_new_tensor_4dEP12ggml_context9ggml_typellll; test_case::ggml_new_tensor_4d(ggml_context *,ggml_type,long,long,long,long)
mov r13, rax
lea rsi, aGradM; "grad_m"
mov rdi, rax
call _ggml_set_name
mov edx, [r14+38h]
mov rcx, [r14+40h]
mov r8, [r14+48h]
mov r9, [r14+50h]
mov rax, [r14+58h]
mov [rsp+38h+var_38], rax
mov rdi, r14
mov rsi, rbx
call _ZN9test_case18ggml_new_tensor_4dEP12ggml_context9ggml_typellll; test_case::ggml_new_tensor_4d(ggml_context *,ggml_type,long,long,long,long)
mov rbp, rax
lea rsi, aGradV; "grad_v"
mov rdi, rax
call _ggml_set_name
push 7
pop rcx
mov rdi, r14
mov rsi, rbx
xor edx, edx
call _ZN9test_case18ggml_new_tensor_1dEP12ggml_context9ggml_typel; test_case::ggml_new_tensor_1d(ggml_context *,ggml_type,long)
mov r14, rax
lea rsi, aAdamwParams; "adamw_params"
mov rdi, rax
call _ggml_set_name
mov rdi, rbx
mov rsi, r15
mov rdx, r12
mov rcx, r13
mov r8, rbp
mov r9, r14
call _ggml_opt_step_adamw
mov rbx, rax
lea rsi, aSumOfOut+7; "out"
mov rdi, rax
call _ggml_set_name
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long test_opt_step_adamw::build_graph(long long a1, long long a2)
{
long long v3; // r15
long long v4; // r12
long long v5; // r13
long long v6; // rbp
long long v7; // r14
long long v8; // rbx
v3 = test_case::ggml_new_tensor_4d(
a1,
a2,
*(_DWORD *)(a1 + 56),
*(_QWORD *)(a1 + 64),
*(_QWORD *)(a1 + 72),
*(_QWORD *)(a1 + 80),
*(_QWORD *)(a1 + 88));
ggml_set_param(a2, v3);
ggml_set_name(v3, "a");
v4 = test_case::ggml_new_tensor_4d(
a1,
a2,
*(_DWORD *)(a1 + 56),
*(_QWORD *)(a1 + 64),
*(_QWORD *)(a1 + 72),
*(_QWORD *)(a1 + 80),
*(_QWORD *)(a1 + 88));
ggml_set_name(v4, "grad");
v5 = test_case::ggml_new_tensor_4d(
a1,
a2,
*(_DWORD *)(a1 + 56),
*(_QWORD *)(a1 + 64),
*(_QWORD *)(a1 + 72),
*(_QWORD *)(a1 + 80),
*(_QWORD *)(a1 + 88));
ggml_set_name(v5, "grad_m");
v6 = test_case::ggml_new_tensor_4d(
a1,
a2,
*(_DWORD *)(a1 + 56),
*(_QWORD *)(a1 + 64),
*(_QWORD *)(a1 + 72),
*(_QWORD *)(a1 + 80),
*(_QWORD *)(a1 + 88));
ggml_set_name(v6, "grad_v");
v7 = test_case::ggml_new_tensor_1d(a1, a2, 0, 7LL);
ggml_set_name(v7, "adamw_params");
v8 = ggml_opt_step_adamw(a2, v3, v4, v5, v6, v7);
ggml_set_name(v8, "out");
return v8;
}
|
build_graph:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV EDX,dword ptr [RDI + 0x38]
MOV RCX,qword ptr [RDI + 0x40]
MOV R8,qword ptr [RDI + 0x48]
MOV R9,qword ptr [RDI + 0x50]
MOV RAX,qword ptr [RDI + 0x58]
MOV qword ptr [RSP],RAX
CALL 0x00120c6c
MOV R15,RAX
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0010fac0
LEA RSI,[0x130d8b]
MOV RDI,R15
CALL 0x0010fb40
MOV EDX,dword ptr [R14 + 0x38]
MOV RCX,qword ptr [R14 + 0x40]
MOV R8,qword ptr [R14 + 0x48]
MOV R9,qword ptr [R14 + 0x50]
MOV RAX,qword ptr [R14 + 0x58]
MOV qword ptr [RSP],RAX
MOV RDI,R14
MOV RSI,RBX
CALL 0x00120c6c
MOV R12,RAX
LEA RSI,[0x130b32]
MOV RDI,RAX
CALL 0x0010fb40
MOV EDX,dword ptr [R14 + 0x38]
MOV RCX,qword ptr [R14 + 0x40]
MOV R8,qword ptr [R14 + 0x48]
MOV R9,qword ptr [R14 + 0x50]
MOV RAX,qword ptr [R14 + 0x58]
MOV qword ptr [RSP],RAX
MOV RDI,R14
MOV RSI,RBX
CALL 0x00120c6c
MOV R13,RAX
LEA RSI,[0x1311b1]
MOV RDI,RAX
CALL 0x0010fb40
MOV EDX,dword ptr [R14 + 0x38]
MOV RCX,qword ptr [R14 + 0x40]
MOV R8,qword ptr [R14 + 0x48]
MOV R9,qword ptr [R14 + 0x50]
MOV RAX,qword ptr [R14 + 0x58]
MOV qword ptr [RSP],RAX
MOV RDI,R14
MOV RSI,RBX
CALL 0x00120c6c
MOV RBP,RAX
LEA RSI,[0x1311b8]
MOV RDI,RAX
CALL 0x0010fb40
PUSH 0x7
POP RCX
MOV RDI,R14
MOV RSI,RBX
XOR EDX,EDX
CALL 0x001229c8
MOV R14,RAX
LEA RSI,[0x1311bf]
MOV RDI,RAX
CALL 0x0010fb40
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R12
MOV RCX,R13
MOV R8,RBP
MOV R9,R14
CALL 0x0010f0d0
MOV RBX,RAX
LEA RSI,[0x131332]
MOV RDI,RAX
CALL 0x0010fb40
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* test_opt_step_adamw::build_graph(ggml_context*) */
int8 __thiscall
test_opt_step_adamw::build_graph(test_opt_step_adamw *this,ggml_context *param_1)
{
int8 uVar1;
int8 uVar2;
int8 uVar3;
int8 uVar4;
int8 uVar5;
uVar1 = test_case::ggml_new_tensor_4d
((test_case *)this,param_1,*(int4 *)(this + 0x38),
*(int8 *)(this + 0x40),*(int8 *)(this + 0x48),
*(int8 *)(this + 0x50),*(int8 *)(this + 0x58));
ggml_set_param(param_1,uVar1);
ggml_set_name(uVar1,"a");
uVar2 = test_case::ggml_new_tensor_4d
((test_case *)this,param_1,*(int4 *)(this + 0x38),
*(int8 *)(this + 0x40),*(int8 *)(this + 0x48),
*(int8 *)(this + 0x50),*(int8 *)(this + 0x58));
ggml_set_name(uVar2,&DAT_00130b32);
uVar3 = test_case::ggml_new_tensor_4d
((test_case *)this,param_1,*(int4 *)(this + 0x38),
*(int8 *)(this + 0x40),*(int8 *)(this + 0x48),
*(int8 *)(this + 0x50),*(int8 *)(this + 0x58));
ggml_set_name(uVar3,"grad_m");
uVar4 = test_case::ggml_new_tensor_4d
((test_case *)this,param_1,*(int4 *)(this + 0x38),
*(int8 *)(this + 0x40),*(int8 *)(this + 0x48),
*(int8 *)(this + 0x50),*(int8 *)(this + 0x58));
ggml_set_name(uVar4,&DAT_001311b8);
uVar5 = test_case::ggml_new_tensor_1d((test_case *)this,param_1,0,7);
ggml_set_name(uVar5,"adamw_params");
uVar1 = ggml_opt_step_adamw(param_1,uVar1,uVar2,uVar3,uVar4,uVar5);
ggml_set_name(uVar1,"out");
return uVar1;
}
|
|
6,888 |
my_hash_sort_utf8mb3_nopad
|
eloqsql/strings/ctype-utf8.c
|
static void my_hash_sort_utf8mb3_nopad(CHARSET_INFO *cs, const uchar *s, size_t slen,
ulong *nr1, ulong *nr2)
{
my_wc_t wc;
int res;
const uchar *e= s+slen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
register ulong m1= *nr1, m2= *nr2;
while ((s < e) && (res=my_utf8mb3_uni(cs,&wc, (uchar *)s, (uchar*)e))>0 )
{
my_tosort_unicode(uni_plane, &wc, cs->state);
MY_HASH_ADD_16(m1, m2, wc);
s+= res;
}
*nr1= m1;
*nr2= m2;
}
|
O0
|
c
|
my_hash_sort_utf8mb3_nopad:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x59(%rbp)
jae 0x6fa7a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq 0x6d8d0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x6fa86
jmp 0x6fb27
movq -0x48(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edx
leaq -0x30(%rbp), %rsi
callq 0x6e680
jmp 0x6fa9c
movq -0x50(%rbp), %rax
andq $0x3f, %rax
addq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
andq $0xff, %rcx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x58(%rbp)
jmp 0x6fad8
movq -0x50(%rbp), %rax
andq $0x3f, %rax
addq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
shrq $0x8, %rcx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x58(%rbp)
jmp 0x6fb11
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x6fa4a
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x58(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_hash_sort_utf8mb3_nopad:
push rbp
mov rbp, rsp
sub rsp, 60h
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_10]
add rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_48], rax
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_50], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_58], rax
loc_6FA4A:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_59], al
jnb short loc_6FA7A
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_40]
lea rsi, [rbp+var_30]
call my_utf8mb3_uni
mov [rbp+var_34], eax
cmp eax, 0
setnle al
mov [rbp+var_59], al
loc_6FA7A:
mov al, [rbp+var_59]
test al, 1
jnz short loc_6FA86
jmp loc_6FB27
loc_6FA86:
mov rdi, [rbp+var_48]
mov rax, [rbp+var_8]
mov edx, [rax+0Ch]
lea rsi, [rbp+var_30]
call my_tosort_unicode
jmp short $+2
loc_6FA9C:
mov rax, [rbp+var_50]
and rax, 3Fh
add rax, [rbp+var_58]
mov rcx, [rbp+var_30]
and rcx, 0FFh
imul rax, rcx
mov rcx, [rbp+var_50]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
add rax, 3
mov [rbp+var_58], rax
jmp short $+2
loc_6FAD8:
mov rax, [rbp+var_50]
and rax, 3Fh
add rax, [rbp+var_58]
mov rcx, [rbp+var_30]
shr rcx, 8
imul rax, rcx
mov rcx, [rbp+var_50]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
add rax, 3
mov [rbp+var_58], rax
jmp short $+2
loc_6FB11:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
jmp loc_6FA4A
loc_6FB27:
mov rcx, [rbp+var_50]
mov rax, [rbp+var_20]
mov [rax], rcx
mov rcx, [rbp+var_58]
mov rax, [rbp+var_28]
mov [rax], rcx
add rsp, 60h
pop rbp
retn
|
_QWORD * my_hash_sort_utf8mb3_nopad(
long long a1,
unsigned long long a2,
long long a3,
unsigned long long *a4,
_QWORD *a5,
long long a6)
{
_QWORD *result; // rax
bool v7; // [rsp+7h] [rbp-59h]
long long v8; // [rsp+8h] [rbp-58h]
long long v9; // [rsp+8h] [rbp-58h]
unsigned long long v10; // [rsp+10h] [rbp-50h]
long long v11; // [rsp+10h] [rbp-50h]
_QWORD *v12; // [rsp+18h] [rbp-48h]
unsigned long long v13; // [rsp+20h] [rbp-40h]
int v14; // [rsp+2Ch] [rbp-34h]
unsigned long long v15; // [rsp+30h] [rbp-30h] BYREF
_QWORD *v16; // [rsp+38h] [rbp-28h]
unsigned long long *v17; // [rsp+40h] [rbp-20h]
long long v18; // [rsp+48h] [rbp-18h]
unsigned long long v19; // [rsp+50h] [rbp-10h]
long long v20; // [rsp+58h] [rbp-8h]
v20 = a1;
v19 = a2;
v18 = a3;
v17 = a4;
v16 = a5;
v13 = a3 + a2;
v12 = *(_QWORD **)(a1 + 120);
v10 = *a4;
v8 = *a5;
while ( 1 )
{
v7 = 0;
if ( v19 < v13 )
{
v14 = my_utf8mb3_uni(v20, (long long)&v15, v19, v13, (long long)a5, a6);
v7 = v14 > 0;
}
if ( !v7 )
break;
my_tosort_unicode(v12, &v15, *(_DWORD *)(v20 + 12));
v11 = v10 ^ ((v10 << 8) + (unsigned __int8)v15 * (v8 + (v10 & 0x3F)));
v9 = v8 + 3;
v10 = v11 ^ ((v11 << 8) + (v15 >> 8) * (v9 + (v11 & 0x3F)));
v8 = v9 + 3;
v19 += v14;
}
*v17 = v10;
result = v16;
*v16 = v8;
return result;
}
|
my_hash_sort_utf8mb3_nopad:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
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 + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
LAB_0016fa4a:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x59],AL
JNC 0x0016fa7a
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x30]
CALL 0x0016d8d0
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
SETG AL
MOV byte ptr [RBP + -0x59],AL
LAB_0016fa7a:
MOV AL,byte ptr [RBP + -0x59]
TEST AL,0x1
JNZ 0x0016fa86
JMP 0x0016fb27
LAB_0016fa86:
MOV RDI,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x8]
MOV EDX,dword ptr [RAX + 0xc]
LEA RSI,[RBP + -0x30]
CALL 0x0016e680
JMP 0x0016fa9c
LAB_0016fa9c:
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x30]
AND RCX,0xff
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0016fad8
LAB_0016fad8:
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x30]
SHR RCX,0x8
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0016fb11
LAB_0016fb11:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0016fa4a
LAB_0016fb27:
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
ADD RSP,0x60
POP RBP
RET
|
void my_hash_sort_utf8mb3_nopad
(long param_1,ulong param_2,long param_3,ulong *param_4,long *param_5)
{
int8 uVar1;
bool bVar2;
long local_60;
ulong local_58;
int local_3c;
ulong local_38;
long *local_30;
ulong *local_28;
long local_20;
ulong local_18;
long local_10;
uVar1 = *(int8 *)(param_1 + 0x78);
local_58 = *param_4;
local_60 = *param_5;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar2 = false;
if (local_18 < param_2 + param_3) {
local_3c = my_utf8mb3_uni(local_10,&local_38,local_18,param_2 + param_3);
bVar2 = 0 < local_3c;
}
if (!bVar2) break;
my_tosort_unicode(uVar1,&local_38,*(int4 *)(local_10 + 0xc));
local_58 = ((local_58 & 0x3f) + local_60) * (local_38 & 0xff) + local_58 * 0x100 ^ local_58;
local_58 = ((local_58 & 0x3f) + local_60 + 3) * (local_38 >> 8) + local_58 * 0x100 ^ local_58;
local_60 = local_60 + 6;
local_18 = local_18 + (long)local_3c;
}
*local_28 = local_58;
*local_30 = local_60;
return;
}
|
|
6,889 |
minja::IfNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const
|
monkey531[P]llama/common/minja.hpp
|
void do_render(std::ostringstream & out, const std::shared_ptr<Context> & context) const override {
for (const auto& branch : cascade) {
auto enter_branch = true;
if (branch.first) {
enter_branch = branch.first->evaluate(context).to_bool();
}
if (enter_branch) {
if (!branch.second) throw std::runtime_error("IfNode.cascade.second is null");
branch.second->render(out, context);
return;
}
}
}
|
O3
|
cpp
|
minja::IfNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, (%rsp)
movq 0x20(%rdi), %r13
movq 0x28(%rdi), %r14
cmpq %r14, %r13
je 0x5d606
movq %rdx, %rbx
leaq 0x48(%rsp), %r15
leaq 0x8(%rsp), %r12
movq (%r13), %rsi
testq %rsi, %rsi
je 0x5d5f1
movq %r12, %rdi
movq %rbx, %rdx
callq 0x3d442
movq %r12, %rdi
callq 0x3d640
movl %eax, %ebp
movq %r15, %rdi
xorl %esi, %esi
callq 0x3d7c0
movq %r15, %rdi
callq 0x4a3ae
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x5d589
callq 0x2f99c
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x5d598
callq 0x2f99c
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x5d5a7
callq 0x2f99c
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x5d5dd
movq 0x7f9d0(%rip), %rax # 0xdcf88
cmpb $0x0, (%rax)
je 0x5d5c8
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x5d5d2
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x5d5dd
movq (%rdi), %rax
callq *0x18(%rax)
testb %bpl, %bpl
jne 0x5d5f1
addq $0x20, %r13
cmpq %r14, %r13
jne 0x5d546
jmp 0x5d606
movq 0x10(%r13), %rdi
testq %rdi, %rdi
je 0x5d615
movq (%rsp), %rsi
movq %rbx, %rdx
callq 0x5d6ea
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x18360
movq %rax, %rbx
leaq 0x4e971(%rip), %rsi # 0xabf9a
movq %rax, %rdi
callq 0x18270
movq 0x7f9b0(%rip), %rsi # 0xdcfe8
movq 0x7f921(%rip), %rdx # 0xdcf60
movq %rbx, %rdi
callq 0x18b30
movq %rax, %r14
movq %rbx, %rdi
callq 0x184f0
jmp 0x5d661
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3d734
movq %r14, %rdi
callq 0x18b90
nop
|
_ZNK5minja6IfNode9do_renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS_7ContextEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov [rsp+88h+var_88], rsi
mov r13, [rdi+20h]
mov r14, [rdi+28h]
cmp r13, r14
jz loc_5D606
mov rbx, rdx
lea r15, [rsp+88h+var_40]
lea r12, [rsp+88h+var_80]
loc_5D546:
mov rsi, [r13+0]
test rsi, rsi
jz loc_5D5F1
mov rdi, r12
mov rdx, rbx
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
mov rdi, r12; this
call _ZNK5minja5Value7to_boolEv; minja::Value::to_bool(void)
mov ebp, eax
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rsp+88h+var_48]
test rdi, rdi
jz short loc_5D589
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5D589:
mov rdi, [rsp+88h+var_58]
test rdi, rdi
jz short loc_5D598
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5D598:
mov rdi, [rsp+88h+var_68]
test rdi, rdi
jz short loc_5D5A7
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5D5A7:
mov rdi, [rsp+88h+var_78]
test rdi, rdi
jz short loc_5D5DD
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_5D5C8
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_5D5D2
loc_5D5C8:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_5D5D2:
cmp eax, 1
jnz short loc_5D5DD
mov rax, [rdi]
call qword ptr [rax+18h]
loc_5D5DD:
test bpl, bpl
jnz short loc_5D5F1
add r13, 20h ; ' '
cmp r13, r14
jnz loc_5D546
jmp short loc_5D606
loc_5D5F1:
mov rdi, [r13+10h]
test rdi, rdi
jz short loc_5D615
mov rsi, [rsp+88h+var_88]
mov rdx, rbx
call _ZNK5minja12TemplateNode6renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS_7ContextEE; minja::TemplateNode::render(std::ostringstream &,std::shared_ptr<minja::Context> const&)
loc_5D606:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_5D615:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aIfnodeCascadeS; "IfNode.cascade.second is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_5D661
mov r14, rax
lea rdi, [rsp+88h+var_80]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_5D661:
mov rdi, r14
call __Unwind_Resume
|
do_render:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RSP],RSI
MOV R13,qword ptr [RDI + 0x20]
MOV R14,qword ptr [RDI + 0x28]
CMP R13,R14
JZ 0x0015d606
MOV RBX,RDX
LEA R15,[RSP + 0x48]
LEA R12,[RSP + 0x8]
LAB_0015d546:
MOV RSI,qword ptr [R13]
TEST RSI,RSI
JZ 0x0015d5f1
MOV RDI,R12
MOV RDX,RBX
CALL 0x0013d442
LAB_0015d55e:
MOV RDI,R12
CALL 0x0013d640
LAB_0015d566:
MOV EBP,EAX
MOV RDI,R15
XOR ESI,ESI
CALL 0x0013d7c0
MOV RDI,R15
CALL 0x0014a3ae
MOV RDI,qword ptr [RSP + 0x40]
TEST RDI,RDI
JZ 0x0015d589
CALL 0x0012f99c
LAB_0015d589:
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x0015d598
CALL 0x0012f99c
LAB_0015d598:
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x0015d5a7
CALL 0x0012f99c
LAB_0015d5a7:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x0015d5dd
MOV RAX,qword ptr [0x001dcf88]
CMP byte ptr [RAX],0x0
JZ 0x0015d5c8
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x0015d5d2
LAB_0015d5c8:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_0015d5d2:
CMP EAX,0x1
JNZ 0x0015d5dd
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_0015d5dd:
TEST BPL,BPL
JNZ 0x0015d5f1
ADD R13,0x20
CMP R13,R14
JNZ 0x0015d546
JMP 0x0015d606
LAB_0015d5f1:
MOV RDI,qword ptr [R13 + 0x10]
TEST RDI,RDI
JZ 0x0015d615
MOV RSI,qword ptr [RSP]
MOV RDX,RBX
CALL 0x0015d6ea
LAB_0015d606:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0015d615:
MOV EDI,0x10
CALL 0x00118360
MOV RBX,RAX
LAB_0015d622:
LEA RSI,[0x1abf9a]
MOV RDI,RAX
CALL 0x00118270
LAB_0015d631:
MOV RSI,qword ptr [0x001dcfe8]
MOV RDX,qword ptr [0x001dcf60]
MOV RDI,RBX
CALL 0x00118b30
|
/* minja::IfNode::do_render(std::__cxx11::ostringstream&, std::shared_ptr<minja::Context> const&)
const */
void minja::IfNode::do_render(ostringstream *param_1,shared_ptr *param_2)
{
int *piVar1;
int8 *puVar2;
char cVar3;
int iVar4;
runtime_error *this;
int8 *puVar5;
Expression local_80 [8];
long *local_78;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_68;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_58;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_48;
data local_40 [16];
puVar5 = *(int8 **)(param_1 + 0x20);
puVar2 = *(int8 **)(param_1 + 0x28);
if (puVar5 != puVar2) {
do {
if ((shared_ptr *)*puVar5 == (shared_ptr *)0x0) {
LAB_0015d5f1:
if ((ostringstream *)puVar5[2] != (ostringstream *)0x0) {
TemplateNode::render((ostringstream *)puVar5[2],param_2);
return;
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0015d622 to 0015d630 has its CatchHandler @ 0015d647 */
std::runtime_error::runtime_error(this,"IfNode.cascade.second is null");
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_001dcfe8,PTR__runtime_error_001dcf60);
}
Expression::evaluate(local_80,(shared_ptr *)*puVar5);
/* try { // try from 0015d55e to 0015d565 has its CatchHandler @ 0015d654 */
cVar3 = Value::to_bool((Value *)local_80);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_40,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_40);
if (local_48 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_48);
}
if (local_58 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_58);
}
if (local_68 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_68);
}
if (local_78 != (long *)0x0) {
if (*PTR___libc_single_threaded_001dcf88 == '\0') {
LOCK();
piVar1 = (int *)((long)local_78 + 0xc);
iVar4 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar4 = *(int *)((long)local_78 + 0xc);
*(int *)((long)local_78 + 0xc) = iVar4 + -1;
}
if (iVar4 == 1) {
(**(code **)(*local_78 + 0x18))();
}
}
if (cVar3 != '\0') goto LAB_0015d5f1;
puVar5 = puVar5 + 4;
} while (puVar5 != puVar2);
}
return;
}
|
||
6,890 |
testing::internal::AlwaysTrue()
|
seiftnesse[P]memoryallocator/build_O1/_deps/googletest-src/googletest/src/gtest.cc
|
bool AlwaysTrue() {
#if GTEST_HAS_EXCEPTIONS
// This condition is always false so AlwaysTrue() never actually throws,
// but it makes the compiler think that it may throw.
if (IsTrue(false)) throw ClassUniqueToAlwaysTrue();
#endif // GTEST_HAS_EXCEPTIONS
return true;
}
|
O1
|
cpp
|
testing::internal::AlwaysTrue():
movb $0x1, %al
retq
|
_ZN7testing8internal10AlwaysTrueEv:
mov al, 1
retn
|
char testing::internal::AlwaysTrue(testing::internal *this)
{
return 1;
}
|
AlwaysTrue:
MOV AL,0x1
RET
|
/* testing::internal::AlwaysTrue() */
int1 testing::internal::AlwaysTrue(void)
{
return 1;
}
|
|
6,891 |
my_getcputime
|
eloqsql/mysys/my_getsystime.c
|
ulonglong my_getcputime()
{
#ifdef CLOCK_THREAD_CPUTIME_ID
struct timespec tp;
if (clock_gettime(CLOCK_THREAD_CPUTIME_ID, &tp))
return 0;
return (ulonglong)tp.tv_sec*10000000+(ulonglong)tp.tv_nsec/100;
#elif defined(__NR_clock_gettime)
struct timespec tp;
if (syscall(__NR_clock_gettime, CLOCK_THREAD_CPUTIME_ID, &tp))
return 0;
return (ulonglong)tp.tv_sec*10000000+(ulonglong)tp.tv_nsec/100;
#endif /* CLOCK_THREAD_CPUTIME_ID */
return 0;
}
|
O3
|
c
|
my_getcputime:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x10(%rbp), %rsi
movl $0x3, %edi
callq 0x24280
testl %eax, %eax
je 0x2f1b0
xorl %eax, %eax
jmp 0x2f1d7
imulq $0x989680, -0x10(%rbp), %rcx # imm = 0x989680
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movabsq $0x28f5c28f5c28f5c3, %rdx # imm = 0x28F5C28F5C28F5C3
mulq %rdx
movq %rdx, %rax
shrq $0x2, %rax
addq %rcx, %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
|
my_getcputime:
push rbp
mov rbp, rsp
sub rsp, 10h
lea rsi, [rbp+var_10]
mov edi, 3
call _clock_gettime
test eax, eax
jz short loc_2F1B0
xor eax, eax
jmp short loc_2F1D7
loc_2F1B0:
imul rcx, [rbp+var_10], 989680h
mov rax, [rbp+var_8]
shr rax, 2
mov rdx, 28F5C28F5C28F5C3h
mul rdx
mov rax, rdx
shr rax, 2
add rax, rcx
loc_2F1D7:
add rsp, 10h
pop rbp
retn
|
unsigned long long my_getcputime()
{
long long v1; // [rsp+0h] [rbp-10h] BYREF
unsigned long long v2; // [rsp+8h] [rbp-8h]
if ( (unsigned int)clock_gettime(3LL, &v1) )
return 0LL;
else
return 10000000 * v1 + v2 / 0x64;
}
|
my_getcputime:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
LEA RSI,[RBP + -0x10]
MOV EDI,0x3
CALL 0x00124280
TEST EAX,EAX
JZ 0x0012f1b0
XOR EAX,EAX
JMP 0x0012f1d7
LAB_0012f1b0:
IMUL RCX,qword ptr [RBP + -0x10],0x989680
MOV RAX,qword ptr [RBP + -0x8]
SHR RAX,0x2
MOV RDX,0x28f5c28f5c28f5c3
MUL RDX
MOV RAX,RDX
SHR RAX,0x2
ADD RAX,RCX
LAB_0012f1d7:
ADD RSP,0x10
POP RBP
RET
|
long my_getcputime(void)
{
int iVar1;
long lVar2;
timespec local_18;
iVar1 = clock_gettime(3,&local_18);
if (iVar1 == 0) {
lVar2 = (ulong)local_18.tv_nsec / 100 + local_18.tv_sec * 10000000;
}
else {
lVar2 = 0;
}
return lVar2;
}
|
|
6,892 |
JS_FreeCString
|
bluesky950520[P]quickjs/quickjs.c
|
void JS_FreeCString(JSContext *ctx, const char *ptr)
{
JSString *p;
if (!ptr)
return;
/* purposely removing constness */
p = container_of(ptr, JSString, u);
JS_FreeValue(ctx, JS_MKPTR(JS_TAG_STRING, p));
}
|
O0
|
c
|
JS_FreeCString:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x30158
jmp 0x3018b
movq 0x18(%rsp), %rax
addq $-0x18, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq $-0x7, 0x8(%rsp)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x29f80
addq $0x28, %rsp
retq
|
JS_FreeCString:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
cmp [rsp+28h+var_10], 0
jnz short loc_30158
jmp short loc_3018B
loc_30158:
mov rax, [rsp+28h+var_10]
add rax, 0FFFFFFFFFFFFFFE8h
mov [rsp+28h+var_18], rax
mov rdi, [rsp+28h+var_8]
mov rax, [rsp+28h+var_18]
mov [rsp+28h+var_28], rax
mov [rsp+28h+var_20], 0FFFFFFFFFFFFFFF9h
mov rsi, [rsp+28h+var_28]
mov rdx, [rsp+28h+var_20]
call JS_FreeValue
loc_3018B:
add rsp, 28h
retn
|
long long JS_FreeCString(long long a1, long long a2)
{
long long result; // rax
if ( a2 )
return JS_FreeValue(a1, a2 - 24, -7LL);
return result;
}
|
JS_FreeCString:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
CMP qword ptr [RSP + 0x18],0x0
JNZ 0x00130158
JMP 0x0013018b
LAB_00130158:
MOV RAX,qword ptr [RSP + 0x18]
ADD RAX,-0x18
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],-0x7
MOV RSI,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x8]
CALL 0x00129f80
LAB_0013018b:
ADD RSP,0x28
RET
|
void JS_FreeCString(int8 param_1,long param_2)
{
if (param_2 != 0) {
JS_FreeValue(param_1,param_2 + -0x18,0xfffffffffffffff9);
}
return;
}
|
|
6,893 |
my_collation_get_by_name
|
eloqsql/mysys/charset.c
|
CHARSET_INFO *
my_collation_get_by_name(MY_CHARSET_LOADER *loader,
const char *name, myf flags)
{
uint cs_number;
CHARSET_INFO *cs;
my_pthread_once(&charsets_initialized, init_available_charsets);
cs_number= get_collation_number(name,flags);
my_charset_loader_init_mysys(loader);
cs= cs_number ? get_internal_charset(loader, cs_number, flags) : NULL;
if (!cs && (flags & MY_WME))
{
char index_file[FN_REFLEN + sizeof(MY_CHARSET_INDEX)];
strmov(get_charsets_dir(index_file),MY_CHARSET_INDEX);
my_error(EE_UNKNOWN_COLLATION, MYF(ME_BELL), name, index_file);
}
return cs;
}
|
O3
|
c
|
my_collation_get_by_name:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
leaq 0x346313(%rip), %rdi # 0x370220
leaq -0x7e1(%rip), %rsi # 0x29733
callq 0x24270
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29687
movb $0x0, (%r15)
leaq -0xfc9(%rip), %rcx # 0x28f66
movq %rcx, 0x80(%r15)
leaq -0xfc8(%rip), %rcx # 0x28f75
movq %rcx, 0x88(%r15)
leaq -0xfbb(%rip), %rcx # 0x28f90
movq %rcx, 0x90(%r15)
leaq -0x2493(%rip), %rcx # 0x27ac6
movq %rcx, 0x98(%r15)
leaq 0x2c6b01(%rip), %rcx # 0x2f0a68
movq (%rcx), %rcx
movq %rcx, 0xa0(%r15)
leaq -0xfca(%rip), %rcx # 0x28fae
movq %rcx, 0xa8(%r15)
testl %eax, %eax
je 0x29f95
movq %r15, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0x29bc2
movq %rax, %r15
jmp 0x29f98
xorl %r15d, %r15d
testq %r15, %r15
setne %al
testb $0x10, %r14b
sete %cl
orb %al, %cl
jne 0x29fe2
leaq -0x230(%rbp), %r14
movq %r14, %rdi
callq 0x294f3
movabsq $0x6d782e7865646e49, %rcx # imm = 0x6D782E7865646E49
movq %rcx, (%rax)
movw $0x6c, 0x8(%rax)
movl $0x4, %esi
movl $0x1c, %edi
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x2c0f7
movq %fs:0x28, %rax
cmpq -0x20(%rbp), %rax
jne 0x2a002
movq %r15, %rax
addq $0x218, %rsp # imm = 0x218
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x242f0
|
my_collation_get_by_name:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 218h
mov r14, rdx
mov rbx, rsi
mov r15, rdi
mov rax, fs:28h
mov [rbp+var_20], rax
lea rdi, charsets_initialized
lea rsi, init_available_charsets
call _pthread_once
mov rdi, rbx
mov rsi, r14
call get_collation_number
mov byte ptr [r15], 0
lea rcx, my_once_alloc_c
mov [r15+80h], rcx
lea rcx, my_malloc_c
mov [r15+88h], rcx
lea rcx, my_realloc_c
mov [r15+90h], rcx
lea rcx, my_free
mov [r15+98h], rcx
lea rcx, my_charset_error_reporter
mov rcx, [rcx]
mov [r15+0A0h], rcx
lea rcx, add_collation
mov [r15+0A8h], rcx
test eax, eax
jz short loc_29F95
mov rdi, r15
mov esi, eax
mov rdx, r14
call get_internal_charset
mov r15, rax
jmp short loc_29F98
loc_29F95:
xor r15d, r15d
loc_29F98:
test r15, r15
setnz al
test r14b, 10h
setz cl
or cl, al
jnz short loc_29FE2
lea r14, [rbp+var_230]
mov rdi, r14
call get_charsets_dir
mov rcx, 6D782E7865646E49h
mov [rax], rcx
mov word ptr [rax+8], 6Ch ; 'l'
mov esi, 4
mov edi, 1Ch
mov rdx, rbx
mov rcx, r14
xor eax, eax
call my_error
loc_29FE2:
mov rax, fs:28h
cmp rax, [rbp+var_20]
jnz short loc_2A002
mov rax, r15
add rsp, 218h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_2A002:
call ___stack_chk_fail
|
long long my_collation_get_by_name(long long a1, long long a2, long long a3)
{
unsigned int collation_number; // eax
long long internal_charset; // r15
int v6; // r8d
int v7; // r9d
_BYTE v9[528]; // [rsp+0h] [rbp-230h] BYREF
unsigned long long v10; // [rsp+210h] [rbp-20h]
v10 = __readfsqword(0x28u);
pthread_once(&charsets_initialized, init_available_charsets);
collation_number = get_collation_number(a2, a3);
*(_BYTE *)a1 = 0;
*(_QWORD *)(a1 + 128) = my_once_alloc_c;
*(_QWORD *)(a1 + 136) = my_malloc_c;
*(_QWORD *)(a1 + 144) = my_realloc_c;
*(_QWORD *)(a1 + 152) = my_free;
*(_QWORD *)(a1 + 160) = my_charset_error_reporter;
*(_QWORD *)(a1 + 168) = add_collation;
if ( collation_number )
internal_charset = get_internal_charset(a1, collation_number, a3);
else
internal_charset = 0LL;
if ( internal_charset == 0 && (a3 & 0x10) != 0 )
{
strcpy((char *)get_charsets_dir((long long)v9), "Index.xml");
my_error(28, 4, a2, (unsigned int)v9, v6, v7);
}
return internal_charset;
}
|
my_collation_get_by_name:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x218
MOV R14,RDX
MOV RBX,RSI
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
LEA RDI,[0x470220]
LEA RSI,[0x129733]
CALL 0x00124270
MOV RDI,RBX
MOV RSI,R14
CALL 0x00129687
MOV byte ptr [R15],0x0
LEA RCX,[0x128f66]
MOV qword ptr [R15 + 0x80],RCX
LEA RCX,[0x128f75]
MOV qword ptr [R15 + 0x88],RCX
LEA RCX,[0x128f90]
MOV qword ptr [R15 + 0x90],RCX
LEA RCX,[0x127ac6]
MOV qword ptr [R15 + 0x98],RCX
LEA RCX,[0x3f0a68]
MOV RCX,qword ptr [RCX]
MOV qword ptr [R15 + 0xa0],RCX
LEA RCX,[0x128fae]
MOV qword ptr [R15 + 0xa8],RCX
TEST EAX,EAX
JZ 0x00129f95
MOV RDI,R15
MOV ESI,EAX
MOV RDX,R14
CALL 0x00129bc2
MOV R15,RAX
JMP 0x00129f98
LAB_00129f95:
XOR R15D,R15D
LAB_00129f98:
TEST R15,R15
SETNZ AL
TEST R14B,0x10
SETZ CL
OR CL,AL
JNZ 0x00129fe2
LEA R14,[RBP + -0x230]
MOV RDI,R14
CALL 0x001294f3
MOV RCX,0x6d782e7865646e49
MOV qword ptr [RAX],RCX
MOV word ptr [RAX + 0x8],0x6c
MOV ESI,0x4
MOV EDI,0x1c
MOV RDX,RBX
MOV RCX,R14
XOR EAX,EAX
CALL 0x0012c0f7
LAB_00129fe2:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x0012a002
MOV RAX,R15
ADD RSP,0x218
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0012a002:
CALL 0x001242f0
|
long my_collation_get_by_name(int1 *param_1,int8 param_2,ulong param_3)
{
int iVar1;
long lVar2;
int8 *puVar3;
long in_FS_OFFSET;
int1 local_238 [528];
long local_28;
local_28 = *(long *)(in_FS_OFFSET + 0x28);
pthread_once(&charsets_initialized,init_available_charsets);
iVar1 = get_collation_number(param_2,param_3);
*param_1 = 0;
*(code **)(param_1 + 0x80) = my_once_alloc_c;
*(code **)(param_1 + 0x88) = my_malloc_c;
*(code **)(param_1 + 0x90) = my_realloc_c;
*(code **)(param_1 + 0x98) = my_free;
*(int **)(param_1 + 0xa0) = my_charset_error_reporter;
*(code **)(param_1 + 0xa8) = add_collation;
if (iVar1 == 0) {
lVar2 = 0;
}
else {
lVar2 = get_internal_charset(param_1,iVar1,param_3);
}
if ((param_3 & 0x10) != 0 && lVar2 == 0) {
puVar3 = (int8 *)get_charsets_dir(local_238);
*puVar3 = 0x6d782e7865646e49;
*(int2 *)(puVar3 + 1) = 0x6c;
my_error(0x1c,4,param_2,local_238);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_28) {
return lVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
6,894 |
ma_ft_add
|
eloqsql/storage/maria/ma_ft_update.c
|
int _ma_ft_add(MARIA_HA *info, uint keynr, uchar *keybuf, const uchar *record,
my_off_t pos)
{
int error= -1;
FT_WORD *wlist;
DBUG_ENTER("_ma_ft_add");
DBUG_PRINT("enter",("keynr: %d",keynr));
if ((wlist= _ma_ft_parserecord(info, keynr, record, &info->ft_memroot)))
error= _ma_ft_store(info,keynr,keybuf,wlist,pos);
free_root(&info->ft_memroot, MYF(MY_MARK_BLOCKS_FREE));
DBUG_PRINT("exit",("Return: %d",error));
DBUG_RETURN(error);
}
|
O0
|
c
|
ma_ft_add:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
jmp 0x97854
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rcx
addq $0x328, %rcx # imm = 0x328
callq 0x97150
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x97894
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x977b0
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x328, %rdi # imm = 0x328
movl $0x2, %esi
callq 0xb4190
jmp 0x978ab
jmp 0x978ad
movl -0x2c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
|
_ma_ft_add:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_2C], 0FFFFFFFFh
jmp short $+2
loc_97854:
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_8]
add rcx, 328h
call _ma_ft_parserecord
mov [rbp+var_38], rax
cmp rax, 0
jz short loc_97894
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_38]
mov r8, [rbp+var_28]
call _ma_ft_store
mov [rbp+var_2C], eax
loc_97894:
mov rdi, [rbp+var_8]
add rdi, 328h
mov esi, 2
call free_root
jmp short $+2
loc_978AB:
jmp short $+2
loc_978AD:
mov eax, [rbp+var_2C]
mov [rbp+var_3C], eax
mov eax, [rbp+var_3C]
add rsp, 40h
pop rbp
retn
|
long long ma_ft_add(_QWORD *a1, unsigned int a2, _BYTE *a3, long long a4, long long a5)
{
_QWORD *v6; // [rsp+8h] [rbp-38h]
unsigned int v7; // [rsp+14h] [rbp-2Ch]
v7 = -1;
v6 = (_QWORD *)ma_ft_parserecord(a1, a2, a4, (long long)(a1 + 101));
if ( v6 )
v7 = ma_ft_store(a1, a2, a3, v6, a5);
free_root(a1 + 101, 2LL);
return v7;
}
|
_ma_ft_add:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV dword ptr [RBP + -0x2c],0xffffffff
JMP 0x00197854
LAB_00197854:
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x8]
ADD RCX,0x328
CALL 0x00197150
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JZ 0x00197894
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x38]
MOV R8,qword ptr [RBP + -0x28]
CALL 0x001977b0
MOV dword ptr [RBP + -0x2c],EAX
LAB_00197894:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x328
MOV ESI,0x2
CALL 0x001b4190
JMP 0x001978ab
LAB_001978ab:
JMP 0x001978ad
LAB_001978ad:
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x3c],EAX
MOV EAX,dword ptr [RBP + -0x3c]
ADD RSP,0x40
POP RBP
RET
|
int4
_ma_ft_add(long param_1,int4 param_2,int8 param_3,int8 param_4,int8 param_5)
{
long lVar1;
int4 local_34;
local_34 = 0xffffffff;
lVar1 = _ma_ft_parserecord(param_1,param_2,param_4,param_1 + 0x328);
if (lVar1 != 0) {
local_34 = _ma_ft_store(param_1,param_2,param_3,lVar1,param_5);
}
free_root(param_1 + 0x328,2);
return local_34;
}
|
|
6,895 |
init_alloc_root
|
eloqsql/mysys/my_alloc.c
|
void init_alloc_root(PSI_memory_key key, MEM_ROOT *mem_root, size_t block_size,
size_t pre_alloc_size __attribute__((unused)),
myf my_flags)
{
DBUG_ENTER("init_alloc_root");
DBUG_PRINT("enter",("root: %p prealloc: %zu", mem_root, pre_alloc_size));
mem_root->free= mem_root->used= mem_root->pre_alloc= 0;
mem_root->min_malloc= 32;
mem_root->block_size= (block_size - ALLOC_ROOT_MIN_BLOCK_SIZE) & ~1;
if (my_flags & MY_THREAD_SPECIFIC)
mem_root->block_size|= 1;
mem_root->error_handler= 0;
mem_root->block_num= 4; /* We shift this with >>2 */
mem_root->first_block_usage= 0;
mem_root->m_psi_key= key;
#if !(defined(HAVE_valgrind) && defined(EXTRA_DEBUG))
if (pre_alloc_size)
{
size_t size= pre_alloc_size + ALIGN_SIZE(sizeof(USED_MEM));
if ((mem_root->free= mem_root->pre_alloc=
(USED_MEM*) my_malloc(key, size, MYF(my_flags))))
{
mem_root->free->size= size;
mem_root->free->left= pre_alloc_size;
mem_root->free->next= 0;
TRASH_MEM(mem_root->free);
}
}
#endif
DBUG_VOID_RETURN;
}
|
O3
|
c
|
init_alloc_root:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
xorl %eax, %eax
movq %rax, 0x10(%rsi)
movq $0x20, 0x18(%rsi)
andq $-0x2, %rdx
movl %r8d, %ecx
shrl $0x10, %ecx
andl $0x1, %ecx
addq %rdx, %rcx
addq $-0x28, %rcx
movq %rcx, 0x20(%rsi)
movq %rax, 0x30(%rsi)
movq $0x4, 0x28(%rsi)
movl %edi, 0x38(%rsi)
testq %rbx, %rbx
je 0x3d6d4
movq %rsi, %r14
leaq 0x18(%rbx), %r15
movq %r15, %rsi
movq %r8, %rdx
callq 0x37731
movq %rax, 0x10(%r14)
movq %rax, (%r14)
testq %rax, %rax
je 0x3d6d4
movq %r15, 0x10(%rax)
movq (%r14), %rax
movq %rbx, 0x8(%rax)
movq (%r14), %rax
movq $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
init_alloc_root:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rcx
xorps xmm0, xmm0
movups xmmword ptr [rsi], xmm0
xor eax, eax
mov [rsi+10h], rax
mov qword ptr [rsi+18h], 20h ; ' '
and rdx, 0FFFFFFFFFFFFFFFEh
mov ecx, r8d
shr ecx, 10h
and ecx, 1
add rcx, rdx
add rcx, 0FFFFFFFFFFFFFFD8h
mov [rsi+20h], rcx
mov [rsi+30h], rax
mov qword ptr [rsi+28h], 4
mov [rsi+38h], edi
test rbx, rbx
jz short loc_3D6D4
mov r14, rsi
lea r15, [rbx+18h]
mov rsi, r15
mov rdx, r8
call my_malloc
mov [r14+10h], rax
mov [r14], rax
test rax, rax
jz short loc_3D6D4
mov [rax+10h], r15
mov rax, [r14]
mov [rax+8], rbx
mov rax, [r14]
mov qword ptr [rax], 0
loc_3D6D4:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long init_alloc_root(unsigned int a1, long long *a2, long long a3, long long a4, unsigned int a5)
{
long long result; // rax
*(_OWORD *)a2 = 0LL;
result = 0LL;
a2[2] = 0LL;
a2[3] = 32LL;
a2[4] = (a3 & 0xFFFFFFFFFFFFFFFELL) + (HIWORD(a5) & 1) - 40;
a2[6] = 0LL;
a2[5] = 4LL;
*((_DWORD *)a2 + 14) = a1;
if ( a4 )
{
result = my_malloc(a1, a4 + 24, a5);
a2[2] = result;
*a2 = result;
if ( result )
{
*(_QWORD *)(result + 16) = a4 + 24;
*(_QWORD *)(*a2 + 8) = a4;
result = *a2;
*(_QWORD *)*a2 = 0LL;
}
}
return result;
}
|
init_alloc_root:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RCX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSI],XMM0
XOR EAX,EAX
MOV qword ptr [RSI + 0x10],RAX
MOV qword ptr [RSI + 0x18],0x20
AND RDX,-0x2
MOV ECX,R8D
SHR ECX,0x10
AND ECX,0x1
ADD RCX,RDX
ADD RCX,-0x28
MOV qword ptr [RSI + 0x20],RCX
MOV qword ptr [RSI + 0x30],RAX
MOV qword ptr [RSI + 0x28],0x4
MOV dword ptr [RSI + 0x38],EDI
TEST RBX,RBX
JZ 0x0013d6d4
MOV R14,RSI
LEA R15,[RBX + 0x18]
MOV RSI,R15
MOV RDX,R8
CALL 0x00137731
MOV qword ptr [R14 + 0x10],RAX
MOV qword ptr [R14],RAX
TEST RAX,RAX
JZ 0x0013d6d4
MOV qword ptr [RAX + 0x10],R15
MOV RAX,qword ptr [R14]
MOV qword ptr [RAX + 0x8],RBX
MOV RAX,qword ptr [R14]
MOV qword ptr [RAX],0x0
LAB_0013d6d4:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void init_alloc_root(int4 param_1,long *param_2,ulong param_3,long param_4,int8 param_5)
{
long lVar1;
*param_2 = 0;
param_2[1] = 0;
param_2[2] = 0;
param_2[3] = 0x20;
param_2[4] = (ulong)((uint)param_5 >> 0x10 & 1) + (param_3 & 0xfffffffffffffffe) + -0x28;
param_2[6] = 0;
param_2[5] = 4;
*(int4 *)(param_2 + 7) = param_1;
if (param_4 != 0) {
lVar1 = my_malloc(param_1,param_4 + 0x18,param_5);
param_2[2] = lVar1;
*param_2 = lVar1;
if (lVar1 != 0) {
*(long *)(lVar1 + 0x10) = param_4 + 0x18;
*(long *)(*param_2 + 8) = param_4;
*(int8 *)*param_2 = 0;
}
}
return;
}
|
|
6,896 |
nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::update(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>, nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>, bool)
|
llama.cpp/common/json.hpp
|
void update(const_iterator first, const_iterator last, bool merge_objects = false)
{
// implicitly convert null value to an empty object
if (is_null())
{
m_data.m_type = value_t::object;
m_data.m_value.object = create<object_t>();
assert_invariant();
}
if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", type_name()), this));
}
// check if range iterators belong to the same JSON object
if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
{
JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
}
// passed iterators must belong to objects
if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
{
JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", first.m_object->type_name()), first.m_object));
}
for (auto it = first; it != last; ++it)
{
if (merge_objects && it.value().is_object())
{
auto it2 = m_data.m_value.object->find(it.key());
if (it2 != m_data.m_value.object->end())
{
it2->second.update(it.value(), true);
continue;
}
}
m_data.m_value.object->operator[](it.key()) = it.value();
#if JSON_DIAGNOSTICS
m_data.m_value.object->operator[](it.key()).m_parent = this;
#endif
}
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::update(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>, nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movb (%rdi), %al
testb %al, %al
jne 0xf067f
movb $0x1, (%rbx)
movl $0x30, %edi
callq 0x25270
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %edx, %edx
movq %rdx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rdx, 0x28(%rax)
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe6386
movb (%rbx), %al
cmpb $0x1, %al
jne 0xf0793
movq (%r15), %rax
cmpq (%r14), %rax
jne 0xf07f2
cmpb $0x1, (%rax)
jne 0xf084e
movq %rsp, %rdi
movq %rax, (%rdi)
movups 0x8(%r15), %xmm0
movups %xmm0, 0x8(%rdi)
movq 0x18(%r15), %rax
movq %rax, 0x18(%rdi)
movq %r14, %rsi
callq 0xf0ad2
testb %al, %al
jne 0xf0784
movq %rsp, %r15
leaq 0x28(%rsp), %r12
testb %bpl, %bpl
je 0xf0722
movq %r15, %rdi
callq 0xf0db2
cmpb $0x1, (%rax)
jne 0xf0722
movq 0x8(%rbx), %r13
movq %r15, %rdi
callq 0xf0998
movq %r13, %rdi
movq %rax, %rsi
callq 0xf0f76
movq %rax, %r13
movq 0x8(%rbx), %rax
addq $0x8, %rax
cmpq %rax, %r13
je 0xf0722
addq $0x40, %r13
movq %r15, %rdi
callq 0xf0db2
movq %r13, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0xe6130
jmp 0xf0769
movq %r15, %rdi
callq 0xf0db2
movq %r12, %rdi
movq %rax, %rsi
callq 0xeacbe
movq 0x8(%rbx), %r13
movq %r15, %rdi
callq 0xf0998
movq %r13, %rdi
movq %rax, %rsi
callq 0xec2b6
movq %rax, %rdi
movq %r12, %rsi
callq 0xe8c42
movq %r12, %rdi
xorl %esi, %esi
callq 0xe6386
movq %r12, %rdi
callq 0xeb19e
movq %r15, %rdi
callq 0xf0a78
movq %r15, %rdi
movq %r14, %rsi
callq 0xf0ad2
testb %al, %al
je 0xf06cb
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x25790
movq %rax, %r14
movq %rbx, %rdi
callq 0xec148
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x91bbb(%rip), %rsi # 0x182372
movq %rsp, %rdi
callq 0xf0910
movb $0x1, %bpl
movq %rsp, %rdx
movq %r14, %rdi
movl $0x138, %esi # imm = 0x138
movq %rbx, %rcx
callq 0xebf70
xorl %ebp, %ebp
leaq 0xe9b02(%rip), %rsi # 0x1da2e0
leaq -0x6c583(%rip), %rdx # 0x84262
movq %r14, %rdi
callq 0x25c00
jmp 0xf08a8
movl $0x20, %edi
callq 0x25790
movq %rax, %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x91b7d(%rip), %rsi # 0x18238c
leaq 0x91b8a(%rip), %rdx # 0x1823a0
movq %rsp, %rdi
callq 0x52736
movb $0x1, %bpl
movq %rsp, %rdx
movq %r14, %rdi
movl $0xd2, %esi
movq %rbx, %rcx
callq 0xebd32
xorl %ebp, %ebp
leaq 0xea20b(%rip), %rsi # 0x1daa48
leaq -0x6c5e2(%rip), %rdx # 0x84262
movq %r14, %rdi
callq 0x25c00
jmp 0xf08a8
movl $0x20, %edi
callq 0x25790
movq %rax, %r14
movq (%r15), %rdi
callq 0xec148
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x91b00(%rip), %rsi # 0x182372
movq %rsp, %rdi
callq 0xf0910
movq (%r15), %rcx
movb $0x1, %bpl
movq %rsp, %rdx
movq %r14, %rdi
movl $0x138, %esi # imm = 0x138
callq 0xf0374
xorl %ebp, %ebp
leaq 0xe9a47(%rip), %rsi # 0x1da2e0
leaq -0x6c63e(%rip), %rdx # 0x84262
movq %r14, %rdi
callq 0x25c00
movq %rax, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xe6386
movq %r14, %rdi
callq 0xeb19e
jmp 0xf0908
jmp 0xf08d8
jmp 0xf08fd
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
jne 0xf08e9
jmp 0xf08f6
jmp 0xf08fd
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf08f6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x251b0
testb %bpl, %bpl
jne 0xf0900
jmp 0xf0908
movq %rax, %rbx
movq %r14, %rdi
callq 0x26150
movq %rbx, %rdi
callq 0x25ca0
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6updateENS0_6detail9iter_implIKSD_EESH_b:
push rbp; void *
push r15; int
push r14; __int64
push r13; int
push r12; void *
push rbx; int
sub rsp, 38h
mov ebp, ecx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov al, [rdi]
test al, al
jnz short loc_F067F
mov byte ptr [rbx], 1
mov edi, 30h ; '0'; unsigned __int64
call __Znwm; operator new(ulong)
lea rcx, [rax+8]
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
xor edx, edx
mov [rax+10h], rdx
mov [rax+18h], rcx
mov [rax+20h], rcx
mov [rax+28h], rdx
mov [rbx+8], rax
mov rdi, rbx
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov al, [rbx]
loc_F067F:
cmp al, 1
jnz loc_F0793
mov rax, [r15]
cmp rax, [r14]
jnz loc_F07F2
cmp byte ptr [rax], 1
jnz loc_F084E
mov rdi, rsp
mov [rdi], rax
movups xmm0, xmmword ptr [r15+8]
movups xmmword ptr [rdi+8], xmm0
mov rax, [r15+18h]
mov [rdi+18h], rax
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
test al, al
jnz loc_F0784
mov r15, rsp
lea r12, [rsp+68h+var_40]
loc_F06CB:
test bpl, bpl
jz short loc_F0722
mov rdi, r15
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEdeEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator*(void)
cmp byte ptr [rax], 1
jnz short loc_F0722
mov r13, [rbx+8]
mov rdi, r15
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE3keyEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::key(void)
mov rdi, r13
mov rsi, rax
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_N8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorS5_blmdSaNS9_14adl_serializerESC_IhSaIhEEvEEESt10_Select1stISH_ESt4lessIvESaISH_EE4findERS7_; std::_Rb_tree<std::string,std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::_Select1st<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::find(std::string const&)
mov r13, rax
mov rax, [rbx+8]
add rax, 8
cmp r13, rax
jz short loc_F0722
add r13, 40h ; '@'
mov rdi, r15
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEdeEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator*(void)
mov rdi, r13
mov rsi, rax
mov edx, 1
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6updateERKSD_b; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::update(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,bool)
jmp short loc_F0769
loc_F0722:
mov rdi, r15
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEdeEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator*(void)
mov rdi, r12
mov rsi, rax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov r13, [rbx+8]
mov rdi, r15
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE3keyEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::key(void)
mov rdi, r13
mov rsi, rax
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonIS_St6vectorS5_blmdSaNS7_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS5_SD_EEEixERSH_; std::map<std::string,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::operator[](std::string const&)
mov rdi, rax
mov rsi, r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r12
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_F0769:
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator++(void)
mov rdi, r15
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
test al, al
jz loc_F06CB
loc_F0784:
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_F0793:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov r14, rax
mov rdi, rbx
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<std::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+68h+var_48]
mov [rdx], rax
lea rsi, aCannotUseUpdat; "cannot use update() with "
mov rdi, rsp
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA26_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[26],char const*>(char const(&)[26],char const* &&)
mov bpl, 1
mov rdx, rsp
mov rdi, r14; this
mov esi, 138h; int
mov rcx, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp loc_F08A8
loc_F07F2:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea r15, [rsp+68h+var_58]
mov [r15-10h], r15
lea rsi, aIteratorsDoNot; "iterators do not fit"
lea rdx, aIteratorsDoNot+14h; ""
mov rdi, rsp
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov bpl, 1
mov rdx, rsp
mov rdi, r14; this
mov esi, 0D2h; int
mov rcx, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short loc_F08A8
loc_F084E:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov r14, rax
mov rdi, [r15]
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<std::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+68h+var_48]
mov [rdx], rax
lea rsi, aCannotUseUpdat; "cannot use update() with "
mov rdi, rsp
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA26_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[26],char const*>(char const(&)[26],char const* &&)
mov rcx, [r15]
mov bpl, 1
mov rdx, rsp
mov rdi, r14; this
mov esi, 138h; int
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonISt3mapSt6vectorNSt7__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, r14; void *
call ___cxa_throw
loc_F08A8:
mov rbx, rax
lea r14, [rsp+68h+var_40]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_F0908
jmp short loc_F08D8
jmp short loc_F08FD
mov rbx, rax
mov rdi, [rsp+68h+var_68]
cmp rdi, r15
jnz short loc_F08E9
jmp short loc_F08F6
jmp short loc_F08FD
loc_F08D8:
mov rbx, rax
lea rax, [rsp+68h+var_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_F08F6
loc_F08E9:
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_F08F6:
test bpl, bpl
jnz short loc_F0900
jmp short loc_F0908
loc_F08FD:
mov rbx, rax
loc_F0900:
mov rdi, r14; void *
call ___cxa_free_exception
loc_F0908:
mov rdi, rbx
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::basic_json<std::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>::update(
long long a1,
long long a2,
_QWORD *a3,
char a4)
{
char v6; // al
long long v7; // rax
long long result; // rax
long long v9; // r13
long long v10; // rax
long long v11; // r13
long long v12; // rsi
unsigned __int8 *v13; // rax
long long v14; // r13
long long v15; // rax
long long v16; // rdx
long long v17; // rcx
long long v18; // r8
int v19; // r9d
long long v20; // rax
long long v21; // rdx
long long v22; // rcx
long long v23; // r8
long long v24; // r9
nlohmann::json_abi_v3_11_3::detail::exception *exception; // r14
nlohmann::json_abi_v3_11_3::detail::exception *v26; // r14
nlohmann::json_abi_v3_11_3::detail::exception *v27; // r14
unsigned __int8 *v28; // [rsp+0h] [rbp-68h] BYREF
__int128 v29; // [rsp+8h] [rbp-60h] BYREF
long long v30; // [rsp+18h] [rbp-50h]
const char *v31; // [rsp+20h] [rbp-48h]
unsigned __int8 v32[64]; // [rsp+28h] [rbp-40h] BYREF
v6 = *(_BYTE *)a1;
if ( !*(_BYTE *)a1 )
{
*(_BYTE *)a1 = 1;
v7 = operator new(0x30uLL);
*(_OWORD *)v7 = 0LL;
*(_QWORD *)(v7 + 16) = 0LL;
*(_QWORD *)(v7 + 24) = v7 + 8;
*(_QWORD *)(v7 + 32) = v7 + 8;
*(_QWORD *)(v7 + 40) = 0LL;
*(_QWORD *)(a1 + 8) = v7;
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
v6 = *(_BYTE *)a1;
}
if ( v6 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v31 = nlohmann::json_abi_v3_11_3::basic_json<std::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(&)[26],char const*>(
&v28,
"cannot use update() with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
312,
&v28);
__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);
}
if ( *(_QWORD *)a2 != *a3 )
{
v26 = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v28 = (unsigned __int8 *)&v29 + 8;
std::string::_M_construct<char const*>((long long)&v28, "iterators do not fit", (long long)"");
ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
v26,
210,
&v28);
__cxa_throw(
v26,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::invalid_iterator,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
if ( **(_BYTE **)a2 != 1 )
{
v27 = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v31 = nlohmann::json_abi_v3_11_3::basic_json<std::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 **)a2);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[26],char const*>(
&v28,
"cannot use update() with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
v27,
312,
&v28);
__cxa_throw(
v27,
(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);
}
v28 = *(unsigned __int8 **)a2;
v29 = *(_OWORD *)(a2 + 8);
v30 = *(_QWORD *)(a2 + 24);
for ( result = ((long long ( *)(unsigned __int8 **, _QWORD *))ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_)(
&v28,
a3);
!(_BYTE)result;
result = ((long long ( *)(unsigned __int8 **, _QWORD *, long long, long long, long long, long long))ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_)(
&v28,
a3,
v21,
v22,
v23,
v24) )
{
if ( a4
&& *(_BYTE *)nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator*(&v28) == 1
&& (v9 = *(_QWORD *)(a1 + 8),
v10 = nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::key(&v28),
v11 = std::_Rb_tree<std::string,std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::_Select1st<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::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>>>>::find(
v9,
v10),
v11 != *(_QWORD *)(a1 + 8) + 8LL) )
{
v12 = nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator*(&v28);
nlohmann::json_abi_v3_11_3::basic_json<std::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>::update(
v11 + 64,
v12,
1u);
}
else
{
v13 = (unsigned __int8 *)nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator*(&v28);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
v32,
v13);
v14 = *(_QWORD *)(a1 + 8);
v15 = nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::key(&v28);
v20 = std::map<std::string,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::operator[](
v14,
v15,
v16,
v17,
v18,
v19);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
v20,
(long long)v32);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v32);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v32);
}
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator++(&v28);
}
return result;
}
|
update:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV EBP,ECX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV AL,byte ptr [RDI]
TEST AL,AL
JNZ 0x001f067f
MOV byte ptr [RBX],0x1
MOV EDI,0x30
CALL 0x00125270
LEA RCX,[RAX + 0x8]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
XOR EDX,EDX
MOV qword ptr [RAX + 0x10],RDX
MOV qword ptr [RAX + 0x18],RCX
MOV qword ptr [RAX + 0x20],RCX
MOV qword ptr [RAX + 0x28],RDX
MOV qword ptr [RBX + 0x8],RAX
MOV RDI,RBX
MOV ESI,0x1
CALL 0x001e6386
MOV AL,byte ptr [RBX]
LAB_001f067f:
CMP AL,0x1
JNZ 0x001f0793
MOV RAX,qword ptr [R15]
CMP RAX,qword ptr [R14]
JNZ 0x001f07f2
CMP byte ptr [RAX],0x1
JNZ 0x001f084e
MOV RDI,RSP
MOV qword ptr [RDI],RAX
MOVUPS XMM0,xmmword ptr [R15 + 0x8]
MOVUPS xmmword ptr [RDI + 0x8],XMM0
MOV RAX,qword ptr [R15 + 0x18]
MOV qword ptr [RDI + 0x18],RAX
MOV RSI,R14
CALL 0x001f0ad2
TEST AL,AL
JNZ 0x001f0784
MOV R15,RSP
LEA R12,[RSP + 0x28]
LAB_001f06cb:
TEST BPL,BPL
JZ 0x001f0722
MOV RDI,R15
CALL 0x001f0db2
CMP byte ptr [RAX],0x1
JNZ 0x001f0722
MOV R13,qword ptr [RBX + 0x8]
MOV RDI,R15
CALL 0x001f0998
MOV RDI,R13
MOV RSI,RAX
CALL 0x001f0f76
MOV R13,RAX
MOV RAX,qword ptr [RBX + 0x8]
ADD RAX,0x8
CMP R13,RAX
JZ 0x001f0722
ADD R13,0x40
MOV RDI,R15
CALL 0x001f0db2
MOV RDI,R13
MOV RSI,RAX
MOV EDX,0x1
CALL 0x001e6130
JMP 0x001f0769
LAB_001f0722:
MOV RDI,R15
CALL 0x001f0db2
MOV RDI,R12
MOV RSI,RAX
CALL 0x001eacbe
MOV R13,qword ptr [RBX + 0x8]
LAB_001f0739:
MOV RDI,R15
CALL 0x001f0998
MOV RDI,R13
MOV RSI,RAX
CALL 0x001ec2b6
LAB_001f074c:
MOV RDI,RAX
MOV RSI,R12
CALL 0x001e8c42
MOV RDI,R12
XOR ESI,ESI
CALL 0x001e6386
MOV RDI,R12
CALL 0x001eb19e
LAB_001f0769:
MOV RDI,R15
CALL 0x001f0a78
MOV RDI,R15
MOV RSI,R14
CALL 0x001f0ad2
TEST AL,AL
JZ 0x001f06cb
LAB_001f0784:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001f0793:
MOV EDI,0x20
CALL 0x00125790
MOV R14,RAX
MOV RDI,RBX
CALL 0x001ec148
LEA RDX,[RSP + 0x20]
MOV qword ptr [RDX],RAX
LAB_001f07b0:
LEA RSI,[0x282372]
MOV RDI,RSP
CALL 0x001f0910
MOV BPL,0x1
LAB_001f07c2:
MOV RDX,RSP
MOV RDI,R14
MOV ESI,0x138
MOV RCX,RBX
CALL 0x001ebf70
XOR EBP,EBP
LEA RSI,[0x2da2e0]
LEA RDX,[0x184262]
MOV RDI,R14
CALL 0x00125c00
LAB_001f07f2:
MOV EDI,0x20
CALL 0x00125790
MOV R14,RAX
LEA R15,[RSP + 0x10]
MOV qword ptr [R15 + -0x10],R15
LAB_001f0808:
LEA RSI,[0x28238c]
LEA RDX,[0x2823a0]
MOV RDI,RSP
CALL 0x00152736
MOV BPL,0x1
LAB_001f0821:
MOV RDX,RSP
MOV RDI,R14
MOV ESI,0xd2
MOV RCX,RBX
CALL 0x001ebd32
XOR EBP,EBP
LEA RSI,[0x2daa48]
LEA RDX,[0x184262]
MOV RDI,R14
CALL 0x00125c00
LAB_001f084e:
MOV EDI,0x20
CALL 0x00125790
MOV R14,RAX
MOV RDI,qword ptr [R15]
CALL 0x001ec148
LEA RDX,[RSP + 0x20]
MOV qword ptr [RDX],RAX
LAB_001f086b:
LEA RSI,[0x282372]
MOV RDI,RSP
CALL 0x001f0910
MOV RCX,qword ptr [R15]
MOV BPL,0x1
LAB_001f0880:
MOV RDX,RSP
MOV RDI,R14
MOV ESI,0x138
CALL 0x001f0374
XOR EBP,EBP
LEA RSI,[0x2da2e0]
LEA RDX,[0x184262]
MOV RDI,R14
CALL 0x00125c00
|
/* nlohmann::json_abi_v3_11_3::basic_json<std::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>::update(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const>,
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const>, bool) */
void __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<std::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>
::update(basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,int8 *param_2,int8 *param_3,char param_4)
{
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::_Select1st<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::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_00;
map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::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_01;
basic_json<std::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;
char cVar2;
int8 *puVar3;
char *pcVar4;
string *psVar5;
long lVar6;
basic_json *pbVar7;
basic_json<std::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>
*pbVar8;
int8 uVar9;
char *local_68;
int4 local_60;
int4 uStack_5c;
int4 uStack_58;
int4 uStack_54;
int8 local_50;
char *local_48;
basic_json<std::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>
local_40 [16];
bVar1 = *this;
if (bVar1 == (basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
*this = (basic_json<std::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>
)0x1;
puVar3 = (int8 *)operator_new(0x30);
*puVar3 = 0;
puVar3[1] = 0;
puVar3[2] = 0;
puVar3[3] = puVar3 + 1;
puVar3[4] = puVar3 + 1;
puVar3[5] = 0;
*(int8 **)(this + 8) = puVar3;
assert_invariant(SUB81(this,0));
bVar1 = *this;
}
if (bVar1 != (basic_json<std::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>
)0x1) {
uVar9 = __cxa_allocate_exception(0x20);
local_48 = (char *)type_name(this);
/* try { // try from 001f07b0 to 001f07be has its CatchHandler @ 001f08fd */
detail::concat<std::__cxx11::string,char_const(&)[26],char_const*>
((detail *)&local_68,"cannot use update() with ",&local_48);
/* try { // try from 001f07c2 to 001f07ec has its CatchHandler @ 001f08d8 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar9,0x138,&local_68,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar9,&detail::type_error::typeinfo,detail::exception::~exception);
}
local_68 = (char *)*param_2;
if (local_68 != (char *)*param_3) {
uVar9 = __cxa_allocate_exception(0x20);
local_68 = (char *)&uStack_58;
/* try { // try from 001f0808 to 001f081d has its CatchHandler @ 001f08d6 */
std::__cxx11::string::_M_construct<char_const*>(&local_68,"iterators do not fit","");
/* try { // try from 001f0821 to 001f084b has its CatchHandler @ 001f08c8 */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar9,0xd2,&local_68,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar9,&detail::invalid_iterator::typeinfo,detail::exception::~exception);
}
if (*local_68 != '\x01') {
uVar9 = __cxa_allocate_exception(0x20);
local_48 = (char *)type_name((basic_json<std::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_2);
/* try { // try from 001f086b to 001f0879 has its CatchHandler @ 001f08c6 */
detail::concat<std::__cxx11::string,char_const(&)[26],char_const*>
((detail *)&local_68,"cannot use update() with ",&local_48);
/* try { // try from 001f0880 to 001f08a7 has its CatchHandler @ 001f08c4 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar9,0x138,&local_68,*param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar9,&detail::type_error::typeinfo,detail::exception::~exception);
}
local_60 = *(int4 *)(param_2 + 1);
uStack_5c = *(int4 *)((long)param_2 + 0xc);
uStack_58 = *(int4 *)(param_2 + 2);
uStack_54 = *(int4 *)((long)param_2 + 0x14);
local_50 = param_2[3];
cVar2 = _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
(&local_68,param_3);
if (cVar2 == '\0') {
do {
if (param_4 == '\0') {
LAB_001f0722:
pbVar7 = (basic_json *)
detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::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>
::operator*((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_68);
basic_json(local_40,pbVar7);
this_01 = *(map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)(this + 8);
/* try { // try from 001f0739 to 001f074b has its CatchHandler @ 001f08a8 */
psVar5 = (string *)
detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::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>
::key((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_68);
pbVar8 = (basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)std::
map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::operator[](this_01,psVar5);
operator=(pbVar8,local_40);
assert_invariant(SUB81(local_40,0));
data::~data((data *)local_40);
}
else {
pcVar4 = (char *)detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::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>
::operator*((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_68);
if (*pcVar4 != '\x01') goto LAB_001f0722;
this_00 = *(_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::_Select1st<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)(this + 8);
psVar5 = (string *)
detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::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>
::key((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_68);
lVar6 = std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::_Select1st<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::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>>>>
::find(this_00,psVar5);
if (lVar6 == *(long *)(this + 8) + 8) goto LAB_001f0722;
pbVar7 = (basic_json *)
detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::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>
::operator*((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_68);
update((basic_json<std::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>
*)(lVar6 + 0x40),pbVar7,true);
}
detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::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>
::operator++((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_68);
cVar2 = _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
(&local_68,param_3);
} while (cVar2 == '\0');
}
return;
}
|
|
6,897 |
base64_encode_tail_using_maps
|
xtate/src/crypto/crypto-base64.c
|
void base64_encode_tail_using_maps(const base64_maps_t *maps, char dest[4],
const char *src, const size_t srclen) {
char longsrc[3] = {0};
assert(srclen <= 3);
memcpy(longsrc, src, srclen);
base64_encode_triplet_using_maps(maps, dest, longsrc);
memset(dest + 1 + srclen, '=', 3 - srclen);
}
|
O3
|
c
|
base64_encode_tail_using_maps:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4(%rsp), %r12
movb $0x0, 0x2(%r12)
movw $0x0, (%r12)
movq %r12, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x150c0
movzbl (%r12), %eax
movzbl 0x1(%r12), %ecx
movzbl 0x2(%r12), %edx
movl %eax, %esi
shrl $0x2, %esi
movb (%r15,%rsi), %sil
movb %sil, (%r14)
shll $0x4, %eax
andl $0x30, %eax
movl %ecx, %esi
shrl $0x4, %esi
orl %eax, %esi
movb (%r15,%rsi), %al
movb %al, 0x1(%r14)
andl $0xf, %ecx
movl %edx, %eax
shrl $0x6, %eax
leal (%rax,%rcx,4), %eax
movb (%r15,%rax), %al
movb %al, 0x2(%r14)
andl $0x3f, %edx
movb (%r15,%rdx), %al
movb %al, 0x3(%r14)
leaq (%r14,%rbx), %rdi
incq %rdi
movl $0x3, %edx
subq %rbx, %rdx
movl $0x3d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x15370
|
base64_encode_tail_using_maps:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rcx
mov r14, rsi
mov r15, rdi
lea r12, [rsp+28h+var_24]
mov byte ptr [r12+2], 0
mov word ptr [r12], 0
mov rdi, r12
mov rsi, rdx
mov rdx, rcx
call _memcpy
movzx eax, byte ptr [r12]
movzx ecx, byte ptr [r12+1]
movzx edx, byte ptr [r12+2]
mov esi, eax
shr esi, 2
mov sil, [r15+rsi]
mov [r14], sil
shl eax, 4
and eax, 30h
mov esi, ecx
shr esi, 4
or esi, eax
mov al, [r15+rsi]
mov [r14+1], al
and ecx, 0Fh
mov eax, edx
shr eax, 6
lea eax, [rax+rcx*4]
mov al, [r15+rax]
mov [r14+2], al
and edx, 3Fh
mov al, [r15+rdx]
mov [r14+3], al
lea rdi, [r14+rbx]
inc rdi
mov edx, 3
sub rdx, rbx
mov esi, 3Dh ; '='
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
jmp _memset
|
long long base64_encode_tail_using_maps(long long a1, _BYTE *a2, long long a3, long long a4)
{
long long v4; // rax
char v6; // al
unsigned int v7; // ecx
unsigned int v8; // edx
__int16 v10; // [rsp+0h] [rbp-24h] BYREF
unsigned __int8 v11; // [rsp+2h] [rbp-22h]
char v12; // [rsp+3h] [rbp-21h]
v12 = HIBYTE(v4);
v11 = 0;
v10 = 0;
memcpy(&v10, a3, a4);
v6 = v10;
v7 = HIBYTE(v10);
v8 = v11;
*a2 = *(_BYTE *)(a1 + ((unsigned __int8)v10 >> 2));
a2[1] = *(_BYTE *)(a1 + ((16 * v6) & 0x30 | (v7 >> 4)));
a2[2] = *(_BYTE *)(a1 + (v8 >> 6) + 4 * (v7 & 0xF));
a2[3] = *(_BYTE *)(a1 + (v8 & 0x3F));
return memset(&a2[a4 + 1], 61LL, 3 - a4);
}
|
base64_encode_tail_using_maps:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R14,RSI
MOV R15,RDI
LEA R12,[RSP + 0x4]
MOV byte ptr [R12 + 0x2],0x0
MOV word ptr [R12],0x0
MOV RDI,R12
MOV RSI,RDX
MOV RDX,RCX
CALL 0x001150c0
MOVZX EAX,byte ptr [R12]
MOVZX ECX,byte ptr [R12 + 0x1]
MOVZX EDX,byte ptr [R12 + 0x2]
MOV ESI,EAX
SHR ESI,0x2
MOV SIL,byte ptr [R15 + RSI*0x1]
MOV byte ptr [R14],SIL
SHL EAX,0x4
AND EAX,0x30
MOV ESI,ECX
SHR ESI,0x4
OR ESI,EAX
MOV AL,byte ptr [R15 + RSI*0x1]
MOV byte ptr [R14 + 0x1],AL
AND ECX,0xf
MOV EAX,EDX
SHR EAX,0x6
LEA EAX,[RAX + RCX*0x4]
MOV AL,byte ptr [R15 + RAX*0x1]
MOV byte ptr [R14 + 0x2],AL
AND EDX,0x3f
MOV AL,byte ptr [R15 + RDX*0x1]
MOV byte ptr [R14 + 0x3],AL
LEA RDI,[R14 + RBX*0x1]
INC RDI
MOV EDX,0x3
SUB RDX,RBX
MOV ESI,0x3d
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
JMP 0x00115370
|
void base64_encode_tail_using_maps(long param_1,int1 *param_2,void *param_3,size_t param_4)
{
ulong in_RAX;
int8 uStack_28;
uStack_28 = in_RAX & 0xff000000ffffffff;
memcpy((void *)((long)&uStack_28 + 4),param_3,param_4);
*param_2 = *(int1 *)(param_1 + (ulong)(uStack_28._4_1_ >> 2));
param_2[1] = *(int1 *)
(param_1 + (ulong)((uint)(uStack_28._5_1_ >> 4) | (uStack_28._4_1_ & 3) << 4));
param_2[2] = *(int1 *)
(param_1 + (ulong)((uint)(uStack_28._6_1_ >> 6) + (uStack_28._5_1_ & 0xf) * 4));
param_2[3] = *(int1 *)(param_1 + (ulong)(uStack_28._6_1_ & 0x3f));
memset(param_2 + param_4 + 1,0x3d,3 - param_4);
return;
}
|
|
6,898 |
stbi_load_from_memory
|
monkey531[P]llama/examples/llava/../../common/stb_image.h
|
STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
{
stbi__context s;
stbi__start_mem(&s,buffer,len);
return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
}
|
O1
|
c
|
stbi_load_from_memory:
subq $0xe8, %rsp
leaq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
xorl %r10d, %r10d
movl %r10d, 0x30(%rax)
movl %r10d, 0xb8(%rax)
movq %rdi, 0xd0(%rax)
movq %rdi, 0xc0(%rax)
movslq %esi, %rsi
addq %rdi, %rsi
movq %rsi, 0xd8(%rax)
movq %rsi, 0xc8(%rax)
movq %rax, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movl %r9d, %r8d
callq 0x28cc9
addq $0xe8, %rsp
retq
|
stbi_load_from_memory:
sub rsp, 0E8h
lea rax, [rsp+0E8h+var_E0]
mov qword ptr [rax+10h], 0
xor r10d, r10d
mov [rax+30h], r10d
mov [rax+0B8h], r10d
mov [rax+0D0h], rdi
mov [rax+0C0h], rdi
movsxd rsi, esi
add rsi, rdi
mov [rax+0D8h], rsi
mov [rax+0C8h], rsi
mov rdi, rax
mov rsi, rdx
mov rdx, rcx
mov rcx, r8
mov r8d, r9d
call _ZL31stbi__load_and_postprocess_8bitP13stbi__contextPiS1_S1_i; stbi__load_and_postprocess_8bit(stbi__context *,int *,int *,int *,int)
add rsp, 0E8h
retn
|
_BYTE * stbi_load_from_memory(long long a1, int a2, int *a3, int *a4, int *a5, unsigned int a6)
{
_BYTE v7[16]; // [rsp+8h] [rbp-E0h] BYREF
long long v8; // [rsp+18h] [rbp-D0h]
int v9; // [rsp+38h] [rbp-B0h]
int v10; // [rsp+C0h] [rbp-28h]
long long v11; // [rsp+C8h] [rbp-20h]
long long v12; // [rsp+D0h] [rbp-18h]
long long v13; // [rsp+D8h] [rbp-10h]
long long v14; // [rsp+E0h] [rbp-8h]
v8 = 0LL;
v9 = 0;
v10 = 0;
v13 = a1;
v11 = a1;
v14 = a1 + a2;
v12 = v14;
return stbi__load_and_postprocess_8bit((long long)v7, a3, a4, a5, a6);
}
|
stbi_load_from_memory:
SUB RSP,0xe8
LEA RAX,[RSP + 0x8]
MOV qword ptr [RAX + 0x10],0x0
XOR R10D,R10D
MOV dword ptr [RAX + 0x30],R10D
MOV dword ptr [RAX + 0xb8],R10D
MOV qword ptr [RAX + 0xd0],RDI
MOV qword ptr [RAX + 0xc0],RDI
MOVSXD RSI,ESI
ADD RSI,RDI
MOV qword ptr [RAX + 0xd8],RSI
MOV qword ptr [RAX + 0xc8],RSI
MOV RDI,RAX
MOV RSI,RDX
MOV RDX,RCX
MOV RCX,R8
MOV R8D,R9D
CALL 0x00128cc9
ADD RSP,0xe8
RET
|
void stbi_load_from_memory
(long param_1,int param_2,int *param_3,int *param_4,int *param_5,int param_6)
{
stbi__context local_e0 [16];
int8 local_d0;
int4 local_b0;
int4 local_28;
long local_20;
long local_18;
long local_10;
long local_8;
local_d0 = 0;
local_b0 = 0;
local_28 = 0;
local_18 = param_2 + param_1;
local_20 = param_1;
local_10 = param_1;
local_8 = local_18;
stbi__load_and_postprocess_8bit(local_e0,param_3,param_4,param_5,param_6);
return;
}
|
|
6,899 |
dirname_part
|
eloqsql/mysys/mf_dirname.c
|
size_t dirname_part(char *to, const char *name, size_t *to_res_length)
{
size_t length;
DBUG_ENTER("dirname_part");
DBUG_PRINT("enter",("'%s'",name));
length=dirname_length(name);
*to_res_length= (size_t) (convert_dirname(to, name, name+length) - to);
DBUG_RETURN(length);
}
|
O3
|
c
|
dirname_part:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq -0x1(%rsi), %rdx
movq %rsi, %rax
movzbl (%rax), %ecx
cmpl $0x2f, %ecx
je 0x9780e
testl %ecx, %ecx
jne 0x97811
jmp 0x97816
movq %rax, %rdx
incq %rax
jmp 0x97800
incq %rdx
movq %rdx, %r15
subq %rsi, %r15
movq %r14, %rdi
callq 0x9783b
subq %r14, %rax
movq %rax, (%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
dirname_part:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdx
mov r14, rdi
lea rdx, [rsi-1]
mov rax, rsi
loc_97800:
movzx ecx, byte ptr [rax]
cmp ecx, 2Fh ; '/'
jz short loc_9780E
test ecx, ecx
jnz short loc_97811
jmp short loc_97816
loc_9780E:
mov rdx, rax
loc_97811:
inc rax
jmp short loc_97800
loc_97816:
inc rdx
mov r15, rdx
sub r15, rsi
mov rdi, r14
call convert_dirname
sub rax, r14
mov [rbx], rax
mov rax, r15
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long dirname_part(long long a1, _BYTE *a2, _QWORD *a3)
{
_BYTE *v4; // rdx
_BYTE *i; // rax
_BYTE *v6; // rdx
long long v7; // r15
v4 = a2 - 1;
for ( i = a2; *i == 47; ++i )
{
v4 = i;
LABEL_6:
;
}
if ( *i )
goto LABEL_6;
v6 = v4 + 1;
v7 = v6 - a2;
*a3 = convert_dirname(a1, a2, v6) - a1;
return v7;
}
|
dirname_part:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RDI
LEA RDX,[RSI + -0x1]
MOV RAX,RSI
LAB_00197800:
MOVZX ECX,byte ptr [RAX]
CMP ECX,0x2f
JZ 0x0019780e
TEST ECX,ECX
JNZ 0x00197811
JMP 0x00197816
LAB_0019780e:
MOV RDX,RAX
LAB_00197811:
INC RAX
JMP 0x00197800
LAB_00197816:
INC RDX
MOV R15,RDX
SUB R15,RSI
MOV RDI,R14
CALL 0x0019783b
SUB RAX,R14
MOV qword ptr [RBX],RAX
MOV RAX,R15
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
char * dirname_part(long param_1,char *param_2,long *param_3)
{
char *pcVar1;
long lVar2;
char *pcVar3;
char *pcVar4;
pcVar3 = param_2 + -1;
for (pcVar1 = param_2; (pcVar4 = pcVar1, *pcVar1 == '/' || (pcVar4 = pcVar3, *pcVar1 != '\0'));
pcVar1 = pcVar1 + 1) {
pcVar3 = pcVar4;
}
lVar2 = convert_dirname(param_1);
*param_3 = lVar2 - param_1;
return pcVar3 + (1 - (long)param_2);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.