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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
19,800
|
postprocess_cpu_params(cpu_params&, cpu_params const*)
|
llama.cpp/common/common.cpp
|
void postprocess_cpu_params(cpu_params& cpuparams, const cpu_params* role_model) {
int32_t n_set = 0;
if (cpuparams.n_threads < 0) {
// Assuming everything about cpuparams is invalid
if (role_model != nullptr) {
cpuparams = *role_model;
} else {
cpuparams.n_threads = cpu_get_num_math();
}
}
for (int32_t i = 0; i < GGML_MAX_N_THREADS; i++) {
if (cpuparams.cpumask[i]) {
n_set++;
}
}
if (n_set && n_set < cpuparams.n_threads) {
// Not enough set bits, may experience performance issues.
LOG_WRN("Not enough set bits in CPU mask (%d) to satisfy requested thread count: %d\n", n_set, cpuparams.n_threads);
}
}
|
O3
|
cpp
|
postprocess_cpu_params(cpu_params&, cpu_params const*):
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jns 0xf56f6
testq %rsi, %rsi
je 0xf56ef
movl $0x214, %edx # imm = 0x214
movq %rbx, %rdi
callq 0x200e0
jmp 0xf56f6
callq 0xf54e2
movl %eax, (%rbx)
pxor %xmm1, %xmm1
movl $0x4, %eax
pxor %xmm0, %xmm0
movd (%rbx,%rax), %xmm2
punpcklbw %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1],xmm2[2],xmm1[2],xmm2[3],xmm1[3],xmm2[4],xmm1[4],xmm2[5],xmm1[5],xmm2[6],xmm1[6],xmm2[7],xmm1[7]
punpcklwd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1],xmm2[2],xmm1[2],xmm2[3],xmm1[3]
paddd %xmm2, %xmm0
addq $0x4, %rax
cmpq $0x204, %rax # imm = 0x204
jne 0xf5703
pshufd $0xee, %xmm0, %xmm1 # xmm1 = xmm0[2,3,2,3]
paddd %xmm0, %xmm1
pshufd $0x55, %xmm1, %xmm0 # xmm0 = xmm1[1,1,1,1]
paddd %xmm1, %xmm0
movd %xmm0, %ebp
testl %ebp, %ebp
je 0xf5770
cmpl (%rbx), %ebp
jge 0xf5770
leaq 0x6d18b(%rip), %rax # 0x1628d0
cmpl $0x0, (%rax)
js 0xf5770
callq 0x10c7f3
movl (%rbx), %r8d
leaq 0x2db1e(%rip), %rdx # 0x123277
movq %rax, %rdi
movl $0x3, %esi
movl %ebp, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x10c890
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
_Z22postprocess_cpu_paramsR10cpu_paramsPKS_:
push rbp
push rbx
push rax
mov rbx, rdi
cmp dword ptr [rdi], 0
jns short loc_F56F6
test rsi, rsi
jz short loc_F56EF
mov edx, 214h
mov rdi, rbx
call _memcpy
jmp short loc_F56F6
loc_F56EF:
call _Z16cpu_get_num_mathv; cpu_get_num_math(void)
mov [rbx], eax
loc_F56F6:
pxor xmm1, xmm1
mov eax, 4
pxor xmm0, xmm0
loc_F5703:
movd xmm2, dword ptr [rbx+rax]
punpcklbw xmm2, xmm1
punpcklwd xmm2, xmm1
paddd xmm0, xmm2
add rax, 4
cmp rax, 204h
jnz short loc_F5703
pshufd xmm1, xmm0, 0EEh
paddd xmm1, xmm0
pshufd xmm0, xmm1, 55h ; 'U'
paddd xmm0, xmm1
movd ebp, xmm0
test ebp, ebp
jz short loc_F5770
cmp ebp, [rbx]
jge short loc_F5770
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_F5770
call _Z15common_log_mainv; common_log_main(void)
mov r8d, [rbx]
lea rdx, aNotEnoughSetBi; "Not enough set bits in CPU mask (%d) to"...
mov rdi, rax
mov esi, 3
mov ecx, ebp
xor eax, eax
add rsp, 8
pop rbx
pop rbp
jmp _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_F5770:
add rsp, 8
pop rbx
pop rbp
retn
|
int * postprocess_cpu_params(int *a1, long long a2)
{
int *result; // rax
__m128i v3; // xmm0
__m128i v4; // xmm1
int v5; // ebp
int v6; // eax
int v7; // r9d
if ( *a1 < 0 )
{
if ( a2 )
memcpy(a1, a2, 532LL);
else
*a1 = cpu_get_num_math();
}
result = (_DWORD *)&byte_4;
v3 = 0LL;
do
v3 = _mm_add_epi32(
v3,
_mm_unpacklo_epi16(
_mm_unpacklo_epi8(_mm_cvtsi32_si128(*(int *)((char *)result++ + (_QWORD)a1)), (__m128i)0LL),
(__m128i)0LL));
while ( result != &dword_204 );
v4 = _mm_add_epi32(_mm_shuffle_epi32(v3, 238), v3);
v5 = _mm_cvtsi128_si32(_mm_add_epi32(_mm_shuffle_epi32(v4, 85), v4));
if ( v5 && v5 < *a1 )
{
result = (int *)&common_log_verbosity_thold;
if ( common_log_verbosity_thold >= 0 )
{
v6 = common_log_main();
return (int *)common_log_add(
v6,
3,
(unsigned int)"Not enough set bits in CPU mask (%d) to satisfy requested thread count: %d\n",
v5,
*a1,
v7);
}
}
return result;
}
|
postprocess_cpu_params:
PUSH RBP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CMP dword ptr [RDI],0x0
JNS 0x001f56f6
TEST RSI,RSI
JZ 0x001f56ef
MOV EDX,0x214
MOV RDI,RBX
CALL 0x001200e0
JMP 0x001f56f6
LAB_001f56ef:
CALL 0x001f54e2
MOV dword ptr [RBX],EAX
LAB_001f56f6:
PXOR XMM1,XMM1
MOV EAX,0x4
PXOR XMM0,XMM0
LAB_001f5703:
MOVD XMM2,dword ptr [RBX + RAX*0x1]
PUNPCKLBW XMM2,XMM1
PUNPCKLWD XMM2,XMM1
PADDD XMM0,XMM2
ADD RAX,0x4
CMP RAX,0x204
JNZ 0x001f5703
PSHUFD XMM1,XMM0,0xee
PADDD XMM1,XMM0
PSHUFD XMM0,XMM1,0x55
PADDD XMM0,XMM1
MOVD EBP,XMM0
TEST EBP,EBP
JZ 0x001f5770
CMP EBP,dword ptr [RBX]
JGE 0x001f5770
LEA RAX,[0x2628d0]
CMP dword ptr [RAX],0x0
JS 0x001f5770
CALL 0x0020c7f3
MOV R8D,dword ptr [RBX]
LEA RDX,[0x223277]
MOV RDI,RAX
MOV ESI,0x3
MOV ECX,EBP
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x0020c890
LAB_001f5770:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
/* postprocess_cpu_params(cpu_params&, cpu_params const*) */
void postprocess_cpu_params(cpu_params *param_1,cpu_params *param_2)
{
int1 auVar1 [13];
int1 auVar2 [13];
int1 auVar3 [13];
ulong uVar4;
int1 auVar5 [13];
int4 uVar6;
long lVar7;
int8 uVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
if (*(int *)param_1 < 0) {
if (param_2 == (cpu_params *)0x0) {
uVar6 = cpu_get_num_math();
*(int4 *)param_1 = uVar6;
}
else {
memcpy(param_1,param_2,0x214);
}
}
lVar7 = 4;
iVar9 = 0;
iVar10 = 0;
iVar11 = 0;
iVar12 = 0;
do {
uVar6 = *(int4 *)(param_1 + lVar7);
uVar4 = (ulong)(ushort)uVar6 & 0xffffffffffff00ff;
auVar1._8_4_ = 0;
auVar1._0_8_ = uVar4;
auVar1[0xc] = (char)((uint)uVar6 >> 0x18);
auVar2[8] = (char)((uint)uVar6 >> 0x10);
auVar2._0_8_ = uVar4;
auVar2[9] = 0;
auVar2._10_3_ = auVar1._10_3_;
auVar5._5_8_ = 0;
auVar5._0_5_ = auVar2._8_5_;
auVar3[4] = (char)((uint)uVar6 >> 8);
auVar3._0_4_ = (int)uVar4;
auVar3[5] = 0;
auVar3._6_7_ = SUB137(auVar5 << 0x40,6);
iVar9 = iVar9 + (int)uVar4;
iVar10 = iVar10 + auVar3._4_4_;
iVar11 = iVar11 + auVar2._8_4_;
iVar12 = iVar12 + (uint)(uint3)(auVar1._10_3_ >> 0x10);
lVar7 = lVar7 + 4;
} while (lVar7 != 0x204);
iVar9 = iVar12 + iVar10 + iVar11 + iVar9;
if (((iVar9 != 0) && (iVar9 < *(int *)param_1)) && (-1 < common_log_verbosity_thold)) {
uVar8 = common_log_main();
common_log_add(uVar8,3,
"Not enough set bits in CPU mask (%d) to satisfy requested thread count: %d\n",
iVar9,*(int4 *)param_1);
return;
}
return;
}
|
|
19,801
|
CLI::Error::Error(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CLI::ExitCodes)
|
MikePodsytnik[P]TCRtrie/build_O1/_deps/cli11-src/include/CLI/Error.hpp
|
Error(std::string name, std::string msg, ExitCodes exit_code) : Error(name, msg, static_cast<int>(exit_code)) {}
|
O1
|
cpp
|
CLI::Error::Error(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CLI::ExitCodes):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %rdi
movq %rax, %rsi
callq 0x178c0
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x178c0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x7520
leaq 0x32e8e(%rip), %rax # 0x491f0
movq %rax, (%rbx)
movl %ebp, 0x10(%rbx)
leaq 0x28(%rbx), %rax
movq %rax, 0x18(%rbx)
movq (%rsp), %rcx
cmpq %r15, %rcx
je 0x16388
movq %rcx, 0x18(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rbx)
jmp 0x1638f
movups (%r15), %xmm0
movups %xmm0, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rbx)
movq %r15, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x163c1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x7430
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x163d7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7430
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x16403
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x7430
jmp 0x16403
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x16419
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7430
movq %rbx, %rdi
callq 0x7780
nop
|
_ZN3CLI5ErrorC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_NS_9ExitCodesE:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 40h
mov ebp, ecx
mov r14, rdx
mov rbx, rdi
lea r15, [rsp+68h+var_58]
mov [r15-10h], r15
mov rax, [rsi]
mov rdx, [rsi+8]
add rdx, rax
mov rdi, rsp
mov rsi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea r12, [rsp+68h+var_38]
mov [r12-10h], r12
mov rsi, [r14]
mov rdx, [r14+8]
add rdx, rsi
lea rdi, [rsp+68h+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 rsi, [rsp+68h+var_48]
mov rdi, rbx
call __ZNSt13runtime_errorC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
lea rax, off_491F0
mov [rbx], rax
mov [rbx+10h], ebp
lea rax, [rbx+28h]
mov [rbx+18h], rax
mov rcx, [rsp+68h+var_68]
cmp rcx, r15
jz short loc_16388
mov [rbx+18h], rcx
mov rax, [rsp+68h+var_58]
mov [rbx+28h], rax
jmp short loc_1638F
loc_16388:
movups xmm0, xmmword ptr [r15]
movups xmmword ptr [rax], xmm0
loc_1638F:
mov rax, [rsp+68h+var_60]
mov [rbx+20h], rax
mov [rsp+68h+var_68], r15
mov [rsp+68h+var_60], 0
mov byte ptr [rsp+68h+var_58], 0
mov rdi, [rsp+68h+var_48]; void *
cmp rdi, r12
jz short loc_163C1
mov rsi, [rsp+68h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_163C1:
mov rdi, [rsp+68h+var_68]; void *
cmp rdi, r15
jz short loc_163D7
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_163D7:
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_18]; void *
cmp rdi, r12
jz short loc_16403
mov rsi, [rsp+arg_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_16403
mov rbx, rax
loc_16403:
mov rdi, [rsp+0]; void *
cmp rdi, r15
jz short loc_16419
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_16419:
mov rdi, rbx
call __Unwind_Resume
|
void CLI::Error::Error(long long a1, _QWORD *a2, _QWORD *a3, int a4)
{
void *v6; // [rsp+0h] [rbp-68h] BYREF
long long v7; // [rsp+8h] [rbp-60h]
__int128 v8; // [rsp+10h] [rbp-58h] BYREF
void *v9[2]; // [rsp+20h] [rbp-48h] BYREF
_QWORD v10[7]; // [rsp+30h] [rbp-38h] BYREF
v6 = &v8;
std::string::_M_construct<char *>(&v6, *a2, *a2 + a2[1]);
v9[0] = v10;
std::string::_M_construct<char *>(v9, *a3, *a3 + a3[1]);
std::runtime_error::runtime_error(a1, v9);
*(_QWORD *)a1 = off_491F0;
*(_DWORD *)(a1 + 16) = a4;
*(_QWORD *)(a1 + 24) = a1 + 40;
if ( v6 == &v8 )
{
*(_OWORD *)(a1 + 40) = v8;
}
else
{
*(_QWORD *)(a1 + 24) = v6;
*(_QWORD *)(a1 + 40) = v8;
}
*(_QWORD *)(a1 + 32) = v7;
v6 = &v8;
v7 = 0LL;
LOBYTE(v8) = 0;
if ( v9[0] != v10 )
operator delete(v9[0], v10[0] + 1LL);
if ( v6 != &v8 )
operator delete(v6, v8 + 1);
}
|
Error:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV EBP,ECX
MOV R14,RDX
MOV RBX,RDI
LEA R15,[RSP + 0x10]
MOV qword ptr [R15 + -0x10],R15
MOV RAX,qword ptr [RSI]
MOV RDX,qword ptr [RSI + 0x8]
ADD RDX,RAX
MOV RDI,RSP
MOV RSI,RAX
CALL 0x001178c0
LEA R12,[RSP + 0x30]
MOV qword ptr [R12 + -0x10],R12
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
ADD RDX,RSI
LAB_00116344:
LEA RDI,[RSP + 0x20]
CALL 0x001178c0
LAB_0011634e:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00107520
LAB_0011635b:
LEA RAX,[0x1491f0]
MOV qword ptr [RBX],RAX
MOV dword ptr [RBX + 0x10],EBP
LEA RAX,[RBX + 0x28]
MOV qword ptr [RBX + 0x18],RAX
MOV RCX,qword ptr [RSP]
CMP RCX,R15
JZ 0x00116388
MOV qword ptr [RBX + 0x18],RCX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RBX + 0x28],RAX
JMP 0x0011638f
LAB_00116388:
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RAX],XMM0
LAB_0011638f:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RSP],R15
MOV qword ptr [RSP + 0x8],0x0
MOV byte ptr [RSP + 0x10],0x0
MOV RDI,qword ptr [RSP + 0x20]
CMP RDI,R12
JZ 0x001163c1
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x00107430
LAB_001163c1:
MOV RDI,qword ptr [RSP]
CMP RDI,R15
JZ 0x001163d7
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x00107430
LAB_001163d7:
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* CLI::Error::Error(std::__cxx11::string, std::__cxx11::string, CLI::ExitCodes) */
void __thiscall CLI::Error::Error(Error *this,long *param_2,long *param_3,int4 param_4)
{
int1 *local_68;
int8 local_60;
int1 local_58;
int7 uStack_57;
int8 uStack_50;
long *local_48 [2];
long local_38 [2];
local_68 = &local_58;
std::__cxx11::string::_M_construct<char*>(&local_68,*param_2,param_2[1] + *param_2);
/* try { // try from 00116344 to 0011634d has its CatchHandler @ 00116400 */
local_48[0] = local_38;
std::__cxx11::string::_M_construct<char*>(local_48,*param_3,param_3[1] + *param_3);
/* try { // try from 0011634e to 0011635a has its CatchHandler @ 001163e4 */
std::runtime_error::runtime_error((runtime_error *)this,(string *)local_48);
*(int ***)this = &PTR__Error_001491f0;
*(int4 *)(this + 0x10) = param_4;
*(Error **)(this + 0x18) = this + 0x28;
if (local_68 == &local_58) {
*(ulong *)(this + 0x28) = CONCAT71(uStack_57,local_58);
*(int8 *)(this + 0x30) = uStack_50;
}
else {
*(int1 **)(this + 0x18) = local_68;
*(ulong *)(this + 0x28) = CONCAT71(uStack_57,local_58);
}
*(int8 *)(this + 0x20) = local_60;
local_60 = 0;
local_58 = 0;
local_68 = &local_58;
if (local_48[0] != local_38) {
operator_delete(local_48[0],local_38[0] + 1);
}
if (local_68 != &local_58) {
operator_delete(local_68,CONCAT71(uStack_57,local_58) + 1);
}
return;
}
|
|
19,802
|
ft_make_key
|
eloqsql/storage/myisam/ft_update.c
|
uint _ft_make_key(MI_INFO *info, uint keynr, uchar *keybuf, FT_WORD *wptr,
my_off_t filepos)
{
uchar buf[HA_FT_MAXBYTELEN+16];
float weight=(float) ((filepos==HA_OFFSET_ERROR) ? 0 : wptr->weight);
DBUG_ENTER("_ft_make_key");
mi_float4store(buf,weight);
int2store(buf+HA_FT_WLEN,wptr->len);
memcpy(buf+HA_FT_WLEN+2,wptr->pos,wptr->len);
DBUG_RETURN(_mi_make_key(info,keynr,(uchar*) keybuf,buf,filepos));
}
|
O0
|
c
|
ft_make_key:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x128(%rbp)
movl %esi, -0x12c(%rbp)
movq %rdx, -0x138(%rbp)
movq %rcx, -0x140(%rbp)
movq %r8, -0x148(%rbp)
cmpq $-0x1, -0x148(%rbp)
jne 0xaabe1
xorps %xmm0, %xmm0
movsd %xmm0, -0x160(%rbp)
jmp 0xaabf5
movq -0x140(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x160(%rbp)
movsd -0x160(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x14c(%rbp)
movb -0x149(%rbp), %al
movb %al, -0x120(%rbp)
movb -0x14a(%rbp), %al
movb %al, -0x11f(%rbp)
movb -0x14b(%rbp), %al
movb %al, -0x11e(%rbp)
movb -0x14c(%rbp), %al
movb %al, -0x11d(%rbp)
leaq -0x120(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x158(%rbp)
movq -0x140(%rbp), %rax
movq 0x10(%rax), %rax
movw %ax, %cx
movq -0x158(%rbp), %rax
movw %cx, (%rax)
leaq -0x120(%rbp), %rdi
addq $0x4, %rdi
addq $0x2, %rdi
movq -0x140(%rbp), %rax
movq (%rax), %rsi
movq -0x140(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x29090
movq -0x128(%rbp), %rdi
movl -0x12c(%rbp), %esi
movq -0x138(%rbp), %rdx
leaq -0x120(%rbp), %rcx
movq -0x148(%rbp), %r8
callq 0xb5ea0
movl %eax, -0x164(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xaacda
movl -0x164(%rbp), %eax
addq $0x170, %rsp # imm = 0x170
popq %rbp
retq
callq 0x29230
nop
|
_ft_make_key:
push rbp
mov rbp, rsp
sub rsp, 170h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_128], rdi
mov [rbp+var_12C], esi
mov [rbp+var_138], rdx
mov [rbp+var_140], rcx
mov [rbp+var_148], r8
cmp [rbp+var_148], 0FFFFFFFFFFFFFFFFh
jnz short loc_AABE1
xorps xmm0, xmm0
movsd [rbp+var_160], xmm0
jmp short loc_AABF5
loc_AABE1:
mov rax, [rbp+var_140]
movsd xmm0, qword ptr [rax+8]
movsd [rbp+var_160], xmm0
loc_AABF5:
movsd xmm0, [rbp+var_160]
cvtsd2ss xmm0, xmm0
movss [rbp+var_14C], xmm0
mov al, byte ptr [rbp+var_14C+3]
mov [rbp+var_120], al
mov al, byte ptr [rbp+var_14C+2]
mov [rbp+var_11F], al
mov al, byte ptr [rbp+var_14C+1]
mov [rbp+var_11E], al
mov al, byte ptr [rbp+var_14C]
mov [rbp+var_11D], al
lea rax, [rbp+var_120]
add rax, 4
mov [rbp+var_158], rax
mov rax, [rbp+var_140]
mov rax, [rax+10h]
mov cx, ax
mov rax, [rbp+var_158]
mov [rax], cx
lea rdi, [rbp+var_120]
add rdi, 4
add rdi, 2
mov rax, [rbp+var_140]
mov rsi, [rax]
mov rax, [rbp+var_140]
mov rdx, [rax+10h]
call _memcpy
mov rdi, [rbp+var_128]
mov esi, [rbp+var_12C]
mov rdx, [rbp+var_138]
lea rcx, [rbp+var_120]
mov r8, [rbp+var_148]
call _mi_make_key
mov [rbp+var_164], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_AACDA
mov eax, [rbp+var_164]
add rsp, 170h
pop rbp
retn
loc_AACDA:
call ___stack_chk_fail
|
long long ft_make_key(long long a1, unsigned int a2, long long a3, long long a4, long long a5)
{
float v5; // xmm0_4
double v7; // [rsp+10h] [rbp-160h]
_BYTE v10[4]; // [rsp+50h] [rbp-120h] BYREF
__int16 v11; // [rsp+54h] [rbp-11Ch]
_BYTE v12[282]; // [rsp+56h] [rbp-11Ah] BYREF
*(_QWORD *)&v12[274] = __readfsqword(0x28u);
if ( a5 == -1 )
v7 = 0.0;
else
v7 = *(double *)(a4 + 8);
v5 = v7;
v10[0] = HIBYTE(v5);
v10[1] = BYTE2(v5);
v10[2] = BYTE1(v5);
v10[3] = LOBYTE(v5);
v11 = *(_QWORD *)(a4 + 16);
memcpy(v12, *(_QWORD *)a4, *(_QWORD *)(a4 + 16));
return (unsigned int)mi_make_key(a1, a2, a3, v10, a5);
}
|
_ft_make_key:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x170
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x128],RDI
MOV dword ptr [RBP + -0x12c],ESI
MOV qword ptr [RBP + -0x138],RDX
MOV qword ptr [RBP + -0x140],RCX
MOV qword ptr [RBP + -0x148],R8
CMP qword ptr [RBP + -0x148],-0x1
JNZ 0x001aabe1
XORPS XMM0,XMM0
MOVSD qword ptr [RBP + -0x160],XMM0
JMP 0x001aabf5
LAB_001aabe1:
MOV RAX,qword ptr [RBP + -0x140]
MOVSD XMM0,qword ptr [RAX + 0x8]
MOVSD qword ptr [RBP + -0x160],XMM0
LAB_001aabf5:
MOVSD XMM0,qword ptr [RBP + -0x160]
CVTSD2SS XMM0,XMM0
MOVSS dword ptr [RBP + -0x14c],XMM0
MOV AL,byte ptr [RBP + -0x149]
MOV byte ptr [RBP + -0x120],AL
MOV AL,byte ptr [RBP + -0x14a]
MOV byte ptr [RBP + -0x11f],AL
MOV AL,byte ptr [RBP + -0x14b]
MOV byte ptr [RBP + -0x11e],AL
MOV AL,byte ptr [RBP + -0x14c]
MOV byte ptr [RBP + -0x11d],AL
LEA RAX,[RBP + -0x120]
ADD RAX,0x4
MOV qword ptr [RBP + -0x158],RAX
MOV RAX,qword ptr [RBP + -0x140]
MOV RAX,qword ptr [RAX + 0x10]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x158]
MOV word ptr [RAX],CX
LEA RDI,[RBP + -0x120]
ADD RDI,0x4
ADD RDI,0x2
MOV RAX,qword ptr [RBP + -0x140]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x140]
MOV RDX,qword ptr [RAX + 0x10]
CALL 0x00129090
MOV RDI,qword ptr [RBP + -0x128]
MOV ESI,dword ptr [RBP + -0x12c]
MOV RDX,qword ptr [RBP + -0x138]
LEA RCX,[RBP + -0x120]
MOV R8,qword ptr [RBP + -0x148]
CALL 0x001b5ea0
MOV dword ptr [RBP + -0x164],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001aacda
MOV EAX,dword ptr [RBP + -0x164]
ADD RSP,0x170
POP RBP
RET
LAB_001aacda:
CALL 0x00129230
|
int4
_ft_make_key(int8 param_1,int4 param_2,int8 param_3,int8 *param_4,
long param_5)
{
int4 uVar1;
long in_FS_OFFSET;
float fVar2;
double local_168;
int1 local_154;
int1 uStack_153;
int1 uStack_152;
int1 uStack_151;
int1 local_128;
int1 local_127;
int1 local_126;
int1 local_125;
int2 local_124;
int1 auStack_122 [274];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (param_5 == -1) {
local_168 = 0.0;
}
else {
local_168 = (double)param_4[1];
}
fVar2 = (float)local_168;
uStack_151 = (int1)((uint)fVar2 >> 0x18);
local_128 = uStack_151;
uStack_152 = (int1)((uint)fVar2 >> 0x10);
local_127 = uStack_152;
uStack_153 = (int1)((uint)fVar2 >> 8);
local_126 = uStack_153;
local_154 = SUB41(fVar2,0);
local_125 = local_154;
local_124 = (int2)param_4[2];
memcpy(auStack_122,(void *)*param_4,param_4[2]);
uVar1 = _mi_make_key(param_1,param_2,param_3,&local_128,param_5);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return uVar1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
19,803
|
unpack_dirname
|
eloqsql/mysys/mf_pack.c
|
size_t unpack_dirname(char * to, const char *from)
{
size_t length, h_length;
char buff[FN_REFLEN+1+4],*suffix,*tilde_expansion;
DBUG_ENTER("unpack_dirname");
length= normalize_dirname(buff, from);
if (buff[0] == FN_HOMELIB)
{
suffix=buff+1; tilde_expansion=expand_tilde(&suffix);
if (tilde_expansion)
{
length-= (size_t) (suffix-buff)-1;
if (length+(h_length= strlen(tilde_expansion)) <= FN_REFLEN)
{
if ((h_length > 0) && (tilde_expansion[h_length-1] == FN_LIBCHAR))
h_length--;
if (buff+h_length < suffix)
bmove(buff+h_length,suffix,length);
else
bmove_upp((uchar*) buff+h_length+length, (uchar*) suffix+length, length);
bmove(buff,tilde_expansion,h_length);
}
}
}
#ifdef USE_SYMDIR
if (my_use_symdir)
symdirget(buff);
#endif
DBUG_RETURN(system_filename(to,buff)); /* Fix for open */
}
|
O0
|
c
|
unpack_dirname:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp # imm = 0x250
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x218(%rbp)
movq %rsi, -0x220(%rbp)
leaq -0x210(%rbp), %rdi
movq -0x220(%rbp), %rsi
callq 0xeb200
movq %rax, -0x228(%rbp)
movsbl -0x210(%rbp), %eax
cmpl $0x7e, %eax
jne 0xeb4b1
leaq -0x210(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x238(%rbp)
leaq -0x238(%rbp), %rdi
callq 0xeb500
movq %rax, -0x240(%rbp)
cmpq $0x0, -0x240(%rbp)
je 0xeb4af
movq -0x238(%rbp), %rcx
leaq -0x210(%rbp), %rax
subq %rax, %rcx
subq $0x1, %rcx
movq -0x228(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x228(%rbp)
movq -0x228(%rbp), %rax
movq %rax, -0x248(%rbp)
movq -0x240(%rbp), %rdi
callq 0x2a330
movq %rax, %rcx
movq -0x248(%rbp), %rax
movq %rcx, -0x230(%rbp)
addq %rcx, %rax
cmpq $0x200, %rax # imm = 0x200
ja 0xeb4ad
cmpq $0x0, -0x230(%rbp)
jbe 0xeb42a
movq -0x240(%rbp), %rax
movq -0x230(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0xeb42a
movq -0x230(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x230(%rbp)
leaq -0x210(%rbp), %rax
addq -0x230(%rbp), %rax
cmpq -0x238(%rbp), %rax
jae 0xeb464
leaq -0x210(%rbp), %rdi
addq -0x230(%rbp), %rdi
movq -0x238(%rbp), %rsi
movq -0x228(%rbp), %rdx
callq 0x2a140
jmp 0xeb493
leaq -0x210(%rbp), %rdi
addq -0x230(%rbp), %rdi
addq -0x228(%rbp), %rdi
movq -0x238(%rbp), %rsi
addq -0x228(%rbp), %rsi
movq -0x228(%rbp), %rdx
callq 0x111890
leaq -0x210(%rbp), %rdi
movq -0x240(%rbp), %rsi
movq -0x230(%rbp), %rdx
callq 0x2a140
jmp 0xeb4af
jmp 0xeb4b1
jmp 0xeb4b3
movq -0x218(%rbp), %rdi
leaq -0x210(%rbp), %rsi
callq 0xeb5c0
movq %rax, -0x250(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xeb4ef
movq -0x250(%rbp), %rax
addq $0x250, %rsp # imm = 0x250
popq %rbp
retq
callq 0x2a250
nopw %cs:(%rax,%rax)
|
unpack_dirname:
push rbp
mov rbp, rsp
sub rsp, 250h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_218], rdi
mov [rbp+var_220], rsi
lea rdi, [rbp+var_210]
mov rsi, [rbp+var_220]
call normalize_dirname
mov [rbp+var_228], rax
movsx eax, [rbp+var_210]
cmp eax, 7Eh ; '~'
jnz loc_EB4B1
lea rax, [rbp+var_210]
add rax, 1
mov [rbp+var_238], rax
lea rdi, [rbp+var_238]
call expand_tilde
mov [rbp+var_240], rax
cmp [rbp+var_240], 0
jz loc_EB4AF
mov rcx, [rbp+var_238]
lea rax, [rbp+var_210]
sub rcx, rax
sub rcx, 1
mov rax, [rbp+var_228]
sub rax, rcx
mov [rbp+var_228], rax
mov rax, [rbp+var_228]
mov [rbp+var_248], rax
mov rdi, [rbp+var_240]
call _strlen
mov rcx, rax
mov rax, [rbp+var_248]
mov [rbp+var_230], rcx
add rax, rcx
cmp rax, 200h
ja loc_EB4AD
cmp [rbp+var_230], 0
jbe short loc_EB42A
mov rax, [rbp+var_240]
mov rcx, [rbp+var_230]
sub rcx, 1
movsx eax, byte ptr [rax+rcx]
cmp eax, 2Fh ; '/'
jnz short loc_EB42A
mov rax, [rbp+var_230]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_230], rax
loc_EB42A:
lea rax, [rbp+var_210]
add rax, [rbp+var_230]
cmp rax, [rbp+var_238]
jnb short loc_EB464
lea rdi, [rbp+var_210]
add rdi, [rbp+var_230]
mov rsi, [rbp+var_238]
mov rdx, [rbp+var_228]
call _memmove
jmp short loc_EB493
loc_EB464:
lea rdi, [rbp+var_210]
add rdi, [rbp+var_230]
add rdi, [rbp+var_228]
mov rsi, [rbp+var_238]
add rsi, [rbp+var_228]
mov rdx, [rbp+var_228]
call bmove_upp
loc_EB493:
lea rdi, [rbp+var_210]
mov rsi, [rbp+var_240]
mov rdx, [rbp+var_230]
call _memmove
loc_EB4AD:
jmp short $+2
loc_EB4AF:
jmp short $+2
loc_EB4B1:
jmp short $+2
loc_EB4B3:
mov rdi, [rbp+var_218]
lea rsi, [rbp+var_210]
call system_filename
mov [rbp+var_250], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_EB4EF
mov rax, [rbp+var_250]
add rsp, 250h
pop rbp
retn
loc_EB4EF:
call ___stack_chk_fail
|
long long unpack_dirname(long long a1, _BYTE *a2)
{
long long v3; // [rsp+8h] [rbp-248h]
long long v4; // [rsp+10h] [rbp-240h]
_BYTE *v5; // [rsp+18h] [rbp-238h] BYREF
long long v6; // [rsp+20h] [rbp-230h]
long long v7; // [rsp+28h] [rbp-228h]
_BYTE *v8; // [rsp+30h] [rbp-220h]
long long v9; // [rsp+38h] [rbp-218h]
char v10; // [rsp+40h] [rbp-210h] BYREF
_BYTE v11[527]; // [rsp+41h] [rbp-20Fh] BYREF
*(_QWORD *)&v11[519] = __readfsqword(0x28u);
v9 = a1;
v8 = a2;
v7 = normalize_dirname((long long)&v10, a2);
if ( v10 == 126 )
{
v5 = v11;
v4 = expand_tilde(&v5);
if ( v4 )
{
v7 -= v5 - &v10 - 1;
v3 = v7;
v6 = strlen(v4);
if ( (unsigned long long)(v6 + v3) <= 0x200 )
{
if ( v6 && *(_BYTE *)(v4 + v6 - 1) == 47 )
--v6;
if ( &v11[v6 - 1] >= v5 )
bmove_upp(&v11[v6 - 1 + v7], &v5[v7], v7);
else
memmove(&v11[v6 - 1], v5, v7);
memmove(&v10, v4, v6);
}
}
}
return system_filename(v9, &v10);
}
|
unpack_dirname:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x250
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x218],RDI
MOV qword ptr [RBP + -0x220],RSI
LEA RDI,[RBP + -0x210]
MOV RSI,qword ptr [RBP + -0x220]
CALL 0x001eb200
MOV qword ptr [RBP + -0x228],RAX
MOVSX EAX,byte ptr [RBP + -0x210]
CMP EAX,0x7e
JNZ 0x001eb4b1
LEA RAX,[RBP + -0x210]
ADD RAX,0x1
MOV qword ptr [RBP + -0x238],RAX
LEA RDI,[RBP + -0x238]
CALL 0x001eb500
MOV qword ptr [RBP + -0x240],RAX
CMP qword ptr [RBP + -0x240],0x0
JZ 0x001eb4af
MOV RCX,qword ptr [RBP + -0x238]
LEA RAX,[RBP + -0x210]
SUB RCX,RAX
SUB RCX,0x1
MOV RAX,qword ptr [RBP + -0x228]
SUB RAX,RCX
MOV qword ptr [RBP + -0x228],RAX
MOV RAX,qword ptr [RBP + -0x228]
MOV qword ptr [RBP + -0x248],RAX
MOV RDI,qword ptr [RBP + -0x240]
CALL 0x0012a330
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x248]
MOV qword ptr [RBP + -0x230],RCX
ADD RAX,RCX
CMP RAX,0x200
JA 0x001eb4ad
CMP qword ptr [RBP + -0x230],0x0
JBE 0x001eb42a
MOV RAX,qword ptr [RBP + -0x240]
MOV RCX,qword ptr [RBP + -0x230]
SUB RCX,0x1
MOVSX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x2f
JNZ 0x001eb42a
MOV RAX,qword ptr [RBP + -0x230]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x230],RAX
LAB_001eb42a:
LEA RAX,[RBP + -0x210]
ADD RAX,qword ptr [RBP + -0x230]
CMP RAX,qword ptr [RBP + -0x238]
JNC 0x001eb464
LEA RDI,[RBP + -0x210]
ADD RDI,qword ptr [RBP + -0x230]
MOV RSI,qword ptr [RBP + -0x238]
MOV RDX,qword ptr [RBP + -0x228]
CALL 0x0012a140
JMP 0x001eb493
LAB_001eb464:
LEA RDI,[RBP + -0x210]
ADD RDI,qword ptr [RBP + -0x230]
ADD RDI,qword ptr [RBP + -0x228]
MOV RSI,qword ptr [RBP + -0x238]
ADD RSI,qword ptr [RBP + -0x228]
MOV RDX,qword ptr [RBP + -0x228]
CALL 0x00211890
LAB_001eb493:
LEA RDI,[RBP + -0x210]
MOV RSI,qword ptr [RBP + -0x240]
MOV RDX,qword ptr [RBP + -0x230]
CALL 0x0012a140
LAB_001eb4ad:
JMP 0x001eb4af
LAB_001eb4af:
JMP 0x001eb4b1
LAB_001eb4b1:
JMP 0x001eb4b3
LAB_001eb4b3:
MOV RDI,qword ptr [RBP + -0x218]
LEA RSI,[RBP + -0x210]
CALL 0x001eb5c0
MOV qword ptr [RBP + -0x250],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001eb4ef
MOV RAX,qword ptr [RBP + -0x250]
ADD RSP,0x250
POP RBP
RET
LAB_001eb4ef:
CALL 0x0012a250
|
int8 unpack_dirname(int8 param_1,int8 param_2)
{
char *__s;
size_t sVar1;
int8 uVar2;
long in_FS_OFFSET;
char *local_240;
size_t local_238;
size_t local_230;
int8 local_228;
int8 local_220;
char local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_228 = param_2;
local_220 = param_1;
local_230 = normalize_dirname(local_218,param_2);
if (local_218[0] == '~') {
local_240 = local_218 + 1;
__s = (char *)expand_tilde(&local_240);
if (__s != (char *)0x0) {
sVar1 = local_230 - (long)(local_240 + (-1 - (long)local_218));
local_230 = sVar1;
local_238 = strlen(__s);
if (sVar1 + local_238 < 0x201) {
if ((local_238 != 0) && (__s[local_238 - 1] == '/')) {
local_238 = local_238 - 1;
}
if (local_218 + local_238 < local_240) {
memmove(local_218 + local_238,local_240,local_230);
}
else {
bmove_upp(local_218 + local_230 + local_238,local_240 + local_230,local_230);
}
memmove(local_218,__s,local_238);
}
}
}
uVar2 = system_filename(local_220,local_218);
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar2;
}
|
|
19,804
|
translog_first_lsn_in_log
|
eloqsql/storage/maria/ma_loghandler.c
|
LSN translog_first_lsn_in_log()
{
TRANSLOG_ADDRESS addr, horizon= translog_get_horizon();
TRANSLOG_VALIDATOR_DATA data;
uint file;
uint16 chunk_offset;
uchar *page;
DBUG_ENTER("translog_first_lsn_in_log");
DBUG_PRINT("info", ("Horizon: " LSN_FMT, LSN_IN_PARTS(horizon)));
DBUG_ASSERT(translog_status == TRANSLOG_OK ||
translog_status == TRANSLOG_READONLY);
if (!(file= translog_first_file(horizon, 0)))
{
/* log has no records yet */
DBUG_RETURN(LSN_IMPOSSIBLE);
}
addr= MAKE_LSN(file, TRANSLOG_PAGE_SIZE); /* the first page of the file */
data.addr= &addr;
{
TRANSLOG_PAGE_SIZE_BUFF psize_buff;
if ((page= translog_get_page(&data, psize_buff.buffer, NULL)) == NULL ||
(chunk_offset= translog_get_first_chunk_offset(page)) == 0)
DBUG_RETURN(LSN_ERROR);
}
addr+= chunk_offset;
DBUG_RETURN(translog_next_LSN(addr, horizon));
}
|
O0
|
c
|
translog_first_lsn_in_log:
pushq %rbp
movq %rsp, %rbp
subq $0x2050, %rsp # imm = 0x2050
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
callq 0x32c20
movq %rax, -0x2020(%rbp)
jmp 0x35386
jmp 0x35388
jmp 0x3538a
movq -0x2020(%rbp), %rdi
xorl %esi, %esi
callq 0x2ff60
movl %eax, -0x2034(%rbp)
cmpl $0x0, %eax
jne 0x353b5
jmp 0x353a5
movq $0x0, -0x2010(%rbp)
jmp 0x3545a
movl -0x2034(%rbp), %eax
shlq $0x20, %rax
orq $0x2000, %rax # imm = 0x2000
movq %rax, -0x2018(%rbp)
leaq -0x2018(%rbp), %rax
movq %rax, -0x2030(%rbp)
leaq -0x2008(%rbp), %rsi
leaq -0x2030(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x301f0
movq %rax, -0x2040(%rbp)
cmpq $0x0, %rax
je 0x3541c
movq -0x2040(%rbp), %rdi
callq 0x30780
movsbl %al, %eax
movw %ax, -0x2036(%rbp)
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0x3542b
jmp 0x3541e
movq $0x1, -0x2010(%rbp)
jmp 0x3545a
movzwl -0x2036(%rbp), %eax
addq -0x2018(%rbp), %rax
movq %rax, -0x2018(%rbp)
movq -0x2018(%rbp), %rdi
movq -0x2020(%rbp), %rsi
callq 0x35100
movq %rax, -0x2010(%rbp)
movq -0x2010(%rbp), %rax
movq %rax, -0x2048(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x3548a
movq -0x2048(%rbp), %rax
addq $0x2050, %rsp # imm = 0x2050
popq %rbp
retq
callq 0x2a250
nop
|
translog_first_lsn_in_log:
push rbp
mov rbp, rsp
sub rsp, 2050h
mov rax, fs:28h
mov [rbp+var_8], rax
call translog_get_horizon
mov [rbp+var_2020], rax
jmp short $+2
loc_35386:
jmp short $+2
loc_35388:
jmp short $+2
loc_3538A:
mov rdi, [rbp+var_2020]
xor esi, esi
call translog_first_file
mov [rbp+var_2034], eax
cmp eax, 0
jnz short loc_353B5
jmp short $+2
loc_353A5:
mov [rbp+var_2010], 0
jmp loc_3545A
loc_353B5:
mov eax, [rbp+var_2034]
shl rax, 20h
or rax, 2000h
mov [rbp+var_2018], rax
lea rax, [rbp+var_2018]
mov [rbp+var_2030], rax
lea rsi, [rbp+var_2008]
lea rdi, [rbp+var_2030]
xor eax, eax
mov edx, eax
call translog_get_page
mov [rbp+var_2040], rax
cmp rax, 0
jz short loc_3541C
mov rdi, [rbp+var_2040]
call translog_get_first_chunk_offset
movsx eax, al
mov [rbp+var_2036], ax
movzx eax, ax
cmp eax, 0
jnz short loc_3542B
loc_3541C:
jmp short $+2
loc_3541E:
mov [rbp+var_2010], 1
jmp short loc_3545A
loc_3542B:
movzx eax, [rbp+var_2036]
add rax, [rbp+var_2018]
mov [rbp+var_2018], rax
mov rdi, [rbp+var_2018]
mov rsi, [rbp+var_2020]
call translog_next_LSN
mov [rbp+var_2010], rax
loc_3545A:
mov rax, [rbp+var_2010]
mov [rbp+var_2048], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_3548A
mov rax, [rbp+var_2048]
add rsp, 2050h
pop rbp
retn
loc_3548A:
call ___stack_chk_fail
|
long long translog_first_lsn_in_log()
{
char first_chunk_offset; // al
long long page; // [rsp+10h] [rbp-2040h]
unsigned int file; // [rsp+1Ch] [rbp-2034h]
unsigned long long *v4; // [rsp+20h] [rbp-2030h] BYREF
long long horizon; // [rsp+30h] [rbp-2020h]
unsigned long long v6; // [rsp+38h] [rbp-2018h] BYREF
_BYTE v8[8192]; // [rsp+48h] [rbp-2008h] BYREF
unsigned long long v9; // [rsp+2048h] [rbp-8h]
v9 = __readfsqword(0x28u);
horizon = translog_get_horizon();
file = translog_first_file(horizon, 0);
if ( !file )
return 0LL;
v6 = ((unsigned long long)file << 32) | 0x2000;
v4 = &v6;
page = translog_get_page((long long **)&v4, (long long)v8, 0LL);
if ( !page )
return 1LL;
first_chunk_offset = translog_get_first_chunk_offset(page);
if ( !first_chunk_offset )
return 1LL;
v6 += (unsigned __int16)first_chunk_offset;
return translog_next_LSN(v6, horizon);
}
|
translog_first_lsn_in_log:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x2050
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
CALL 0x00132c20
MOV qword ptr [RBP + -0x2020],RAX
JMP 0x00135386
LAB_00135386:
JMP 0x00135388
LAB_00135388:
JMP 0x0013538a
LAB_0013538a:
MOV RDI,qword ptr [RBP + -0x2020]
XOR ESI,ESI
CALL 0x0012ff60
MOV dword ptr [RBP + -0x2034],EAX
CMP EAX,0x0
JNZ 0x001353b5
JMP 0x001353a5
LAB_001353a5:
MOV qword ptr [RBP + -0x2010],0x0
JMP 0x0013545a
LAB_001353b5:
MOV EAX,dword ptr [RBP + -0x2034]
SHL RAX,0x20
OR RAX,0x2000
MOV qword ptr [RBP + -0x2018],RAX
LEA RAX,[RBP + -0x2018]
MOV qword ptr [RBP + -0x2030],RAX
LEA RSI,[RBP + -0x2008]
LEA RDI,[RBP + -0x2030]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001301f0
MOV qword ptr [RBP + -0x2040],RAX
CMP RAX,0x0
JZ 0x0013541c
MOV RDI,qword ptr [RBP + -0x2040]
CALL 0x00130780
MOVSX EAX,AL
MOV word ptr [RBP + -0x2036],AX
MOVZX EAX,AX
CMP EAX,0x0
JNZ 0x0013542b
LAB_0013541c:
JMP 0x0013541e
LAB_0013541e:
MOV qword ptr [RBP + -0x2010],0x1
JMP 0x0013545a
LAB_0013542b:
MOVZX EAX,word ptr [RBP + -0x2036]
ADD RAX,qword ptr [RBP + -0x2018]
MOV qword ptr [RBP + -0x2018],RAX
MOV RDI,qword ptr [RBP + -0x2018]
MOV RSI,qword ptr [RBP + -0x2020]
CALL 0x00135100
MOV qword ptr [RBP + -0x2010],RAX
LAB_0013545a:
MOV RAX,qword ptr [RBP + -0x2010]
MOV qword ptr [RBP + -0x2048],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0013548a
MOV RAX,qword ptr [RBP + -0x2048]
ADD RSP,0x2050
POP RBP
RET
LAB_0013548a:
CALL 0x0012a250
|
int8 translog_first_lsn_in_log(void)
{
char cVar1;
uint uVar2;
long lVar3;
long in_FS_OFFSET;
ulong *local_2038 [2];
int8 local_2028;
ulong local_2020;
int8 local_2018;
int1 local_2010 [8192];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_2028 = translog_get_horizon();
uVar2 = translog_first_file(local_2028,0);
if (uVar2 == 0) {
local_2018 = 0;
}
else {
local_2020 = (ulong)uVar2 << 0x20 | 0x2000;
local_2038[0] = &local_2020;
lVar3 = translog_get_page(local_2038,local_2010,0);
if (lVar3 != 0) {
cVar1 = translog_get_first_chunk_offset(lVar3);
if ((short)cVar1 != 0) {
local_2020 = (ushort)(short)cVar1 + local_2020;
local_2018 = translog_next_LSN(local_2020,local_2028);
goto LAB_0013545a;
}
}
local_2018 = 1;
}
LAB_0013545a:
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_2018;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
19,805
|
testing::internal::LoadFlagsFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest.cc
|
static void LoadFlagsFromFile(const std::string& path) {
FILE* flagfile = posix::FOpen(path.c_str(), "r");
if (!flagfile) {
GTEST_LOG_(FATAL) << "Unable to open file \"" << GTEST_FLAG_GET(flagfile)
<< "\"";
}
std::string contents(ReadEntireFile(flagfile));
posix::FClose(flagfile);
std::vector<std::string> lines;
SplitString(contents, '\n', &lines);
for (size_t i = 0; i < lines.size(); ++i) {
if (lines[i].empty()) continue;
if (!ParseGoogleTestFlag(lines[i].c_str())) g_help_flag = true;
}
}
|
O0
|
cpp
|
testing::internal::LoadFlagsFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rdi
callq 0xf200
movq %rax, %rdi
leaq 0x30c7d(%rip), %rsi # 0x755b3
callq 0x4ea80
movq %rax, 0x88(%rsp)
cmpq $0x0, 0x88(%rsp)
jne 0x449ef
leaq 0x2fcce(%rip), %rdx # 0x74627
leaq 0x84(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movl $0x3, %esi
movl $0x1a08, %ecx # imm = 0x1A08
callq 0x1b8d0
movq 0x20(%rsp), %rdi
callq 0x107d0
movq %rax, %rdi
leaq 0x31871(%rip), %rsi # 0x761fa
callq 0xb460
movq %rax, 0x28(%rsp)
jmp 0x44995
movq 0x28(%rsp), %rdi
leaq 0x57d3f(%rip), %rsi # 0x9c6e0
callq 0xb3f0
movq %rax, 0x18(%rsp)
jmp 0x449ad
movq 0x18(%rsp), %rdi
leaq 0x30c9f(%rip), %rsi # 0x75658
callq 0xb460
jmp 0x449c0
leaq 0x84(%rsp), %rdi
callq 0x1ba40
jmp 0x449ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x84(%rsp), %rdi
callq 0x1ba40
jmp 0x44b23
movq 0x88(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x1bcc0
movq 0x88(%rsp), %rdi
callq 0x522b0
jmp 0x44a10
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x45e10
movq 0x10(%rsp), %rdx
leaq 0x50(%rsp), %rdi
movl $0xa, %esi
callq 0x18bf0
jmp 0x44a35
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x45e20
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x44afd
movq 0x30(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x45fa0
movq %rax, %rdi
callq 0x45090
testb $0x1, %al
jne 0x44a80
jmp 0x44aaf
jmp 0x44aea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x44b19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x45a80
jmp 0x44b19
movq 0x30(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x45fa0
movq %rax, %rdi
callq 0xf200
movq %rax, %rdi
callq 0x43ef0
movb %al, 0x7(%rsp)
jmp 0x44ad4
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x44ae8
jmp 0x44ade
leaq 0x57b4c(%rip), %rax # 0x9c631
movb $0x1, (%rax)
jmp 0x44aea
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x44a3e
leaq 0x38(%rsp), %rdi
callq 0x45a80
leaq 0x50(%rsp), %rdi
callq 0xec60
addq $0x98, %rsp
retq
leaq 0x50(%rsp), %rdi
callq 0xec60
movq 0x78(%rsp), %rdi
callq 0xb910
nopl (%rax)
|
_ZN7testing8internalL17LoadFlagsFromFileERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
sub rsp, 98h
mov [rsp+98h+var_8], rdi
mov rdi, [rsp+98h+var_8]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rdi, rax; this
lea rsi, aR+1; char *
call _ZN7testing8internal5posix5FOpenEPKcS3_; testing::internal::posix::FOpen(char const*,char const*)
mov [rsp+98h+var_10], rax
cmp [rsp+98h+var_10], 0
jnz loc_449EF
lea rdx, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/AlayaL"...
lea rdi, [rsp+98h+var_14]; int
mov [rsp+98h+var_78], rdi; int
mov esi, 3
mov ecx, 1A08h
call _ZN7testing8internal8GTestLogC2ENS0_16GTestLogSeverityEPKci; testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity,char const*,int)
mov rdi, [rsp+98h+var_78]; this
call _ZN7testing8internal8GTestLog9GetStreamEv; testing::internal::GTestLog::GetStream(void)
mov rdi, rax
lea rsi, aUnableToOpenFi; "Unable to open file \""
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+98h+var_70], rax
jmp short $+2
loc_44995:
mov rdi, [rsp+98h+var_70]
lea rsi, _ZN7testing20FLAGS_gtest_flagfileB5cxx11E; testing::FLAGS_gtest_flagfile
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov [rsp+98h+var_80], rax
jmp short $+2
loc_449AD:
mov rdi, [rsp+98h+var_80]
lea rsi, aMessage+0Fh; "\""
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_449C0:
lea rdi, [rsp+98h+var_14]; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
jmp short loc_449EF
mov rcx, rax
mov eax, edx
mov [rsp+arg_70], rcx
mov [rsp+arg_6C], eax
lea rdi, [rsp+arg_7C]; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
jmp loc_44B23
loc_449EF:
mov rsi, [rsp+98h+var_10]
lea rdi, [rsp+98h+var_48]
call _ZN7testing8internal14ReadEntireFileB5cxx11EP8_IO_FILE; testing::internal::ReadEntireFile(_IO_FILE *)
mov rdi, [rsp+98h+var_10]
call _ZN7testing8internal5posix6FCloseEP8_IO_FILE; testing::internal::posix::FClose(_IO_FILE *)
jmp short $+2
loc_44A10:
lea rdi, [rsp+98h+var_60]
mov [rsp+98h+var_88], rdi
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2Ev; std::vector<std::string>::vector(void)
mov rdx, [rsp+98h+var_88]
lea rdi, [rsp+98h+var_48]
mov esi, 0Ah
call _ZN7testing8internal11SplitStringERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEcPSt6vectorIS6_SaIS6_EE; testing::internal::SplitString(std::string const&,char,std::vector<std::string> *)
jmp short $+2
loc_44A35:
mov [rsp+98h+var_68], 0
loc_44A3E:
mov rax, [rsp+98h+var_68]
mov [rsp+98h+var_90], rax
lea rdi, [rsp+98h+var_60]
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE4sizeEv; std::vector<std::string>::size(void)
mov rcx, rax
mov rax, [rsp+98h+var_90]
cmp rax, rcx
jnb loc_44AFD
mov rsi, [rsp+98h+var_68]
lea rdi, [rsp+98h+var_60]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEixEm; std::vector<std::string>::operator[](ulong)
mov rdi, rax
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz short loc_44A80
jmp short loc_44AAF
loc_44A80:
jmp short loc_44AEA
mov rcx, rax
mov eax, edx
mov [rsp+arg_70], rcx
mov [rsp+arg_6C], eax
jmp loc_44B19
mov rcx, rax
mov eax, edx
mov [rsp+arg_70], rcx
mov [rsp+arg_6C], eax
lea rdi, [rsp+arg_30]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
jmp short loc_44B19
loc_44AAF:
mov rsi, [rsp+98h+var_68]; char *
lea rdi, [rsp+98h+var_60]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEixEm; std::vector<std::string>::operator[](ulong)
mov rdi, rax
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rdi, rax; this
call _ZN7testing8internalL19ParseGoogleTestFlagEPKc; testing::internal::ParseGoogleTestFlag(char const*)
mov [rsp+98h+var_91], al
jmp short $+2
loc_44AD4:
mov al, [rsp+98h+var_91]
test al, 1
jnz short loc_44AE8
jmp short $+2
loc_44ADE:
lea rax, _ZN7testing8internal11g_help_flagE; testing::internal::g_help_flag
mov byte ptr [rax], 1
loc_44AE8:
jmp short $+2
loc_44AEA:
mov rax, [rsp+98h+var_68]
add rax, 1
mov [rsp+98h+var_68], rax
jmp loc_44A3E
loc_44AFD:
lea rdi, [rsp+98h+var_60]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
lea rdi, [rsp+98h+var_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
add rsp, 98h
retn
loc_44B19:
lea rdi, [rsp+arg_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_44B23:
mov rdi, [rsp+arg_70]
call __Unwind_Resume
|
void testing::internal::LoadFlagsFromFile(long long a1)
{
testing::internal::posix *v1; // rax
const char *v2; // rdx
void *Stream; // rax
long long v4; // rax
long long v5; // rax
testing::internal *v6; // rax
long long v7; // rdx
bool *v8; // rcx
long long v9; // [rsp+18h] [rbp-80h]
long long v10; // [rsp+28h] [rbp-70h]
char *i; // [rsp+30h] [rbp-68h]
_BYTE v12[24]; // [rsp+38h] [rbp-60h] BYREF
_BYTE v13[52]; // [rsp+50h] [rbp-48h] BYREF
int v14; // [rsp+84h] [rbp-14h] BYREF
long long v15; // [rsp+88h] [rbp-10h]
long long v16; // [rsp+90h] [rbp-8h]
v16 = a1;
v1 = (testing::internal::posix *)std::string::c_str(a1);
v15 = testing::internal::posix::FOpen(v1, "r", v2);
if ( !v15 )
{
testing::internal::GTestLog::GTestLog(
(testing::internal::GTestLog *)&v14,
3,
(long long)"/workspace/llm4binary/github2025/AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest.cc",
6664);
Stream = testing::internal::GTestLog::GetStream((testing::internal::GTestLog *)&v14);
v10 = std::operator<<<std::char_traits<char>>(Stream, "Unable to open file \"");
v9 = std::operator<<<char>(v10, &testing::FLAGS_gtest_flagfile[abi:cxx11]);
std::operator<<<std::char_traits<char>>(v9, "\"");
testing::internal::GTestLog::~GTestLog((testing::internal::GTestLog *)&v14);
}
testing::internal::ReadEntireFile[abi:cxx11]((long long)v13, v15);
testing::internal::posix::FClose(v15);
std::vector<std::string>::vector(v12);
testing::internal::SplitString((long long)v13, 10, (long long)v12);
for ( i = 0LL; (unsigned long long)i < std::vector<std::string>::size(v12); ++i )
{
v4 = std::vector<std::string>::operator[](v12, i);
if ( (std::string::empty(v4) & 1) == 0 )
{
v5 = std::vector<std::string>::operator[](v12, i);
v6 = (testing::internal *)std::string::c_str(v5);
if ( (testing::internal::ParseGoogleTestFlag(v6, i, v7, v8) & 1) == 0 )
testing::internal::g_help_flag = 1;
}
}
std::vector<std::string>::~vector(v12);
std::string::~string(v13);
}
|
LoadFlagsFromFile:
SUB RSP,0x98
MOV qword ptr [RSP + 0x90],RDI
MOV RDI,qword ptr [RSP + 0x90]
CALL 0x0010f200
MOV RDI,RAX
LEA RSI,[0x1755b3]
CALL 0x0014ea80
MOV qword ptr [RSP + 0x88],RAX
CMP qword ptr [RSP + 0x88],0x0
JNZ 0x001449ef
LEA RDX,[0x174627]
LEA RDI,[RSP + 0x84]
MOV qword ptr [RSP + 0x20],RDI
MOV ESI,0x3
MOV ECX,0x1a08
CALL 0x0011b8d0
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x001107d0
MOV RDI,RAX
LAB_00144982:
LEA RSI,[0x1761fa]
CALL 0x0010b460
MOV qword ptr [RSP + 0x28],RAX
JMP 0x00144995
LAB_00144995:
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[0x19c6e0]
CALL 0x0010b3f0
MOV qword ptr [RSP + 0x18],RAX
JMP 0x001449ad
LAB_001449ad:
MOV RDI,qword ptr [RSP + 0x18]
LEA RSI,[0x175658]
CALL 0x0010b460
LAB_001449be:
JMP 0x001449c0
LAB_001449c0:
LEA RDI,[RSP + 0x84]
CALL 0x0011ba40
JMP 0x001449ef
LAB_001449ef:
MOV RSI,qword ptr [RSP + 0x88]
LEA RDI,[RSP + 0x50]
CALL 0x0011bcc0
MOV RDI,qword ptr [RSP + 0x88]
LAB_00144a09:
CALL 0x001522b0
JMP 0x00144a10
LAB_00144a10:
LEA RDI,[RSP + 0x38]
MOV qword ptr [RSP + 0x10],RDI
CALL 0x00145e10
MOV RDX,qword ptr [RSP + 0x10]
LAB_00144a24:
LEA RDI,[RSP + 0x50]
MOV ESI,0xa
CALL 0x00118bf0
JMP 0x00144a35
LAB_00144a35:
MOV qword ptr [RSP + 0x30],0x0
LAB_00144a3e:
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x8],RAX
LEA RDI,[RSP + 0x38]
CALL 0x00145e20
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
CMP RAX,RCX
JNC 0x00144afd
MOV RSI,qword ptr [RSP + 0x30]
LEA RDI,[RSP + 0x38]
CALL 0x00145fa0
MOV RDI,RAX
CALL 0x00145090
TEST AL,0x1
JNZ 0x00144a80
JMP 0x00144aaf
LAB_00144a80:
JMP 0x00144aea
LAB_00144aaf:
MOV RSI,qword ptr [RSP + 0x30]
LEA RDI,[RSP + 0x38]
CALL 0x00145fa0
MOV RDI,RAX
CALL 0x0010f200
MOV RDI,RAX
CALL 0x00143ef0
LAB_00144ace:
MOV byte ptr [RSP + 0x7],AL
JMP 0x00144ad4
LAB_00144ad4:
MOV AL,byte ptr [RSP + 0x7]
TEST AL,0x1
JNZ 0x00144ae8
JMP 0x00144ade
LAB_00144ade:
LEA RAX,[0x19c631]
MOV byte ptr [RAX],0x1
LAB_00144ae8:
JMP 0x00144aea
LAB_00144aea:
MOV RAX,qword ptr [RSP + 0x30]
ADD RAX,0x1
MOV qword ptr [RSP + 0x30],RAX
JMP 0x00144a3e
LAB_00144afd:
LEA RDI,[RSP + 0x38]
CALL 0x00145a80
LEA RDI,[RSP + 0x50]
CALL 0x0010ec60
ADD RSP,0x98
RET
|
/* testing::internal::LoadFlagsFromFile(std::__cxx11::string const&) */
void testing::internal::LoadFlagsFromFile(string *param_1)
{
byte bVar1;
char *pcVar2;
ostream *poVar3;
ulong uVar4;
string *psVar5;
ulong local_68;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> local_60 [24];
internal local_48 [52];
GTestLog local_14 [4];
_IO_FILE *local_10;
string *local_8;
local_8 = param_1;
pcVar2 = (char *)std::__cxx11::string::c_str(param_1);
local_10 = (_IO_FILE *)posix::FOpen(pcVar2,"r");
if (local_10 == (_IO_FILE *)0x0) {
GTestLog::GTestLog(local_14,3,
"/workspace/llm4binary/github2025/AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest.cc"
,0x1a08);
poVar3 = (ostream *)GTestLog::GetStream();
/* try { // try from 00144982 to 001449bd has its CatchHandler @ 001449cf */
poVar3 = std::operator<<(poVar3,"Unable to open file \"");
poVar3 = std::operator<<(poVar3,(string *)FLAGS_gtest_flagfile_abi_cxx11_);
std::operator<<(poVar3,"\"");
GTestLog::~GTestLog(local_14);
}
ReadEntireFile_abi_cxx11_(local_48,local_10);
/* try { // try from 00144a09 to 00144a0d has its CatchHandler @ 00144a82 */
posix::FClose(local_10);
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector(local_60);
/* try { // try from 00144a24 to 00144acd has its CatchHandler @ 00144a95 */
SplitString((string *)local_48,'\n',(vector *)local_60);
for (local_68 = 0;
uVar4 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::size(local_60)
, local_68 < uVar4; local_68 = local_68 + 1) {
psVar5 = (string *)
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::operator[]
(local_60,local_68);
uVar4 = std::__cxx11::string::empty(psVar5);
if ((uVar4 & 1) == 0) {
psVar5 = (string *)
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::operator[]
(local_60,local_68);
pcVar2 = (char *)std::__cxx11::string::c_str(psVar5);
bVar1 = ParseGoogleTestFlag(pcVar2);
if ((bVar1 & 1) == 0) {
g_help_flag = 1;
}
}
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector(local_60);
std::__cxx11::string::~string((string *)local_48);
return;
}
|
|
19,806
|
my_wc_mb_filename
|
eloqsql/strings/ctype-utf8.c
|
static int
my_wc_mb_filename(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int code;
static const char hex[]= "0123456789abcdef";
if (s >= e)
return MY_CS_TOOSMALL;
if (wc < 128 && filename_safe_char[wc])
{
*s= (uchar) wc;
return 1;
}
if (s + 3 > e)
return MY_CS_TOOSMALL3;
*s++= MY_FILENAME_ESCAPE;
if ((wc >= 0x00C0 && wc <= 0x05FF && (code= uni_0C00_05FF[wc - 0x00C0])) ||
(wc >= 0x1E00 && wc <= 0x1FFF && (code= uni_1E00_1FFF[wc - 0x1E00])) ||
(wc >= 0x2160 && wc <= 0x217F && (code= uni_2160_217F[wc - 0x2160])) ||
(wc >= 0x24B0 && wc <= 0x24EF && (code= uni_24B0_24EF[wc - 0x24B0])) ||
(wc >= 0xFF20 && wc <= 0xFF5F && (code= uni_FF20_FF5F[wc - 0xFF20])))
{
*s++= (code / 80) + 0x30;
*s++= (code % 80) + 0x30;
return 3;
}
/* Non letter */
if (s + 4 > e)
return MY_CS_TOOSMALL5;
*s++= hex[(wc >> 12) & 15];
*s++= hex[(wc >> 8) & 15];
*s++= hex[(wc >> 4) & 15];
*s++= hex[(wc) & 15];
return 5;
}
|
O3
|
c
|
my_wc_mb_filename:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0xeeba6
cmpq $0x7f, %rsi
ja 0xeeb06
leaq 0x28c8bd(%rip), %rax # 0x37b3b0
cmpb $0x0, (%rsi,%rax)
je 0xeeb06
movb %sil, (%rdx)
movl $0x1, %eax
jmp 0xeeba6
leaq 0x3(%rdx), %rdi
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rcx, %rdi
ja 0xeeba6
movb $0x40, (%rdx)
leaq -0xc0(%rsi), %rax
cmpq $0x53f, %rax # imm = 0x53F
ja 0xeeb3e
leaq 0x28fe1f(%rip), %rax # 0x37e950
movzwl -0x180(%rax,%rsi,2), %eax
testw %ax, %ax
jne 0xeeb81
movq %rsi, %rax
andq $-0x200, %rax # imm = 0xFE00
cmpq $0x1e00, %rax # imm = 0x1E00
jne 0xeeb63
leaq 0x28f8ba(%rip), %rax # 0x37e410
movzwl -0x3c00(%rax,%rsi,2), %eax
testw %ax, %ax
jne 0xeeb81
movq %rsi, %rax
andq $-0x20, %rax
cmpq $0x2160, %rax # imm = 0x2160
jne 0xeeba8
leaq 0x28fc97(%rip), %rax # 0x37e810
movzwl -0x42c0(%rax,%rsi,2), %eax
movzwl %ax, %ecx
imull $0xcccd, %ecx, %ecx # imm = 0xCCCD
shrl $0x16, %ecx
leal 0x30(%rcx), %esi
movb %sil, 0x1(%rdx)
shll $0x4, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
addb $0x30, %al
movb %al, 0x2(%rdx)
movl $0x3, %eax
popq %rbp
retq
leaq -0x24b0(%rsi), %rax
cmpq $0x3f, %rax
ja 0xeebd3
leaq -0x24ea(%rsi), %rax
cmpq $-0x34, %rax
jb 0xeec01
leaq 0x28fc87(%rip), %rax # 0x37e850
movzwl -0x4960(%rax,%rsi,2), %eax
jmp 0xeeb81
leaq -0xff20(%rsi), %rax
cmpq $0x3f, %rax
ja 0xeec01
movabsq $-0x7fffffe07ffffff, %rdi # imm = 0xF8000001F8000001
btq %rax, %rdi
jb 0xeec01
leaq 0x28fcd9(%rip), %rax # 0x37e8d0
movzwl -0x1fe40(%rax,%rsi,2), %eax
jmp 0xeeb81
leaq 0x5(%rdx), %rdi
movl $0xffffff97, %eax # imm = 0xFFFFFF97
cmpq %rcx, %rdi
ja 0xeeba6
movl %esi, %eax
shrl $0xc, %eax
andl $0xf, %eax
leaq 0x2907b2(%rip), %rcx # 0x37f3d0
movb (%rax,%rcx), %al
movb %al, 0x1(%rdx)
movl %esi, %eax
shrl $0x8, %eax
andl $0xf, %eax
movb (%rax,%rcx), %al
movb %al, 0x2(%rdx)
movl %esi, %eax
shrl $0x4, %eax
andl $0xf, %eax
movb (%rax,%rcx), %al
movb %al, 0x3(%rdx)
andl $0xf, %esi
movb (%rsi,%rcx), %al
movb %al, 0x4(%rdx)
movl $0x5, %eax
jmp 0xeeba6
|
my_wc_mb_filename:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb loc_EEBA6
cmp rsi, 7Fh
ja short loc_EEB06
lea rax, filename_safe_char
cmp byte ptr [rsi+rax], 0
jz short loc_EEB06
mov [rdx], sil
mov eax, 1
jmp loc_EEBA6
loc_EEB06:
lea rdi, [rdx+3]
mov eax, 0FFFFFF99h
cmp rdi, rcx
ja loc_EEBA6
mov byte ptr [rdx], 40h ; '@'
lea rax, [rsi-0C0h]
cmp rax, 53Fh
ja short loc_EEB3E
lea rax, uni_0C00_05FF
movzx eax, word ptr [rax+rsi*2-180h]
test ax, ax
jnz short loc_EEB81
loc_EEB3E:
mov rax, rsi
and rax, 0FFFFFFFFFFFFFE00h
cmp rax, 1E00h
jnz short loc_EEB63
lea rax, uni_1E00_1FFF
movzx eax, word ptr [rax+rsi*2-3C00h]
test ax, ax
jnz short loc_EEB81
loc_EEB63:
mov rax, rsi
and rax, 0FFFFFFFFFFFFFFE0h
cmp rax, 2160h
jnz short loc_EEBA8
lea rax, uni_2160_217F
movzx eax, word ptr [rax+rsi*2-42C0h]
loc_EEB81:
movzx ecx, ax
imul ecx, 0CCCDh
shr ecx, 16h
lea esi, [rcx+30h]
mov [rdx+1], sil
shl ecx, 4
lea ecx, [rcx+rcx*4]
sub eax, ecx
add al, 30h ; '0'
mov [rdx+2], al
mov eax, 3
loc_EEBA6:
pop rbp
retn
loc_EEBA8:
lea rax, [rsi-24B0h]
cmp rax, 3Fh ; '?'
ja short loc_EEBD3
lea rax, [rsi-24EAh]
cmp rax, 0FFFFFFFFFFFFFFCCh
jb short loc_EEC01
lea rax, uni_24B0_24EF
movzx eax, word ptr [rax+rsi*2-4960h]
jmp short loc_EEB81
loc_EEBD3:
lea rax, [rsi-0FF20h]
cmp rax, 3Fh ; '?'
ja short loc_EEC01
mov rdi, 0F8000001F8000001h
bt rdi, rax
jb short loc_EEC01
lea rax, uni_FF20_FF5F
movzx eax, word ptr [rax+rsi*2-1FE40h]
jmp short loc_EEB81
loc_EEC01:
lea rdi, [rdx+5]
mov eax, 0FFFFFF97h
cmp rdi, rcx
ja short loc_EEBA6
mov eax, esi
shr eax, 0Ch
and eax, 0Fh
lea rcx, my_wc_mb_filename_hex; "0123456789abcdef"
mov al, [rax+rcx]
mov [rdx+1], al
mov eax, esi
shr eax, 8
and eax, 0Fh
mov al, [rax+rcx]
mov [rdx+2], al
mov eax, esi
shr eax, 4
and eax, 0Fh
mov al, [rax+rcx]
mov [rdx+3], al
and esi, 0Fh
mov al, [rsi+rcx]
mov [rdx+4], al
mov eax, 5
jmp loc_EEBA6
|
long long my_wc_mb_filename(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
long long result; // rax
unsigned __int16 v5; // ax
unsigned long long v6; // rdi
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
if ( a2 <= 0x7F && filename_safe_char[a2] )
{
*a3 = a2;
return 1LL;
}
result = 4294967193LL;
if ( (unsigned long long)(a3 + 3) <= a4 )
{
*a3 = 64;
if ( a2 - 192 <= 0x53F )
{
v5 = uni_0C00_05FF[a2 - 192];
if ( v5 )
goto LABEL_12;
}
if ( (a2 & 0xFFFFFFFFFFFFFE00LL) == 0x1E00 )
{
v5 = uni_1E00_1FFF[a2 - 7680];
if ( v5 )
goto LABEL_12;
}
if ( (a2 & 0xFFFFFFFFFFFFFFE0LL) == 0x2160 )
{
v5 = uni_2160_217F[a2 - 8544];
LABEL_12:
a3[1] = v5 / 0x50u + 48;
a3[2] = v5 % 0x50u + 48;
return 3LL;
}
if ( a2 - 9392 > 0x3F )
{
if ( a2 - 65312 <= 0x3F )
{
v6 = 0xF8000001F8000001LL;
if ( !_bittest64((const long long *)&v6, a2 - 65312) )
{
v5 = uni_FF20_FF5F[a2 - 65312];
goto LABEL_12;
}
}
}
else if ( a2 - 9450 >= 0xFFFFFFFFFFFFFFCCLL )
{
v5 = uni_24B0_24EF[a2 - 9392];
goto LABEL_12;
}
result = 4294967191LL;
if ( (unsigned long long)(a3 + 5) <= a4 )
{
a3[1] = my_wc_mb_filename_hex[(unsigned __int16)a2 >> 12];
a3[2] = my_wc_mb_filename_hex[((unsigned int)a2 >> 8) & 0xF];
a3[3] = my_wc_mb_filename_hex[(unsigned __int8)a2 >> 4];
a3[4] = my_wc_mb_filename_hex[a2 & 0xF];
return 5LL;
}
}
}
return result;
}
|
my_wc_mb_filename:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001eeba6
CMP RSI,0x7f
JA 0x001eeb06
LEA RAX,[0x47b3b0]
CMP byte ptr [RSI + RAX*0x1],0x0
JZ 0x001eeb06
MOV byte ptr [RDX],SIL
MOV EAX,0x1
JMP 0x001eeba6
LAB_001eeb06:
LEA RDI,[RDX + 0x3]
MOV EAX,0xffffff99
CMP RDI,RCX
JA 0x001eeba6
MOV byte ptr [RDX],0x40
LEA RAX,[RSI + -0xc0]
CMP RAX,0x53f
JA 0x001eeb3e
LEA RAX,[0x47e950]
MOVZX EAX,word ptr [RAX + RSI*0x2 + -0x180]
TEST AX,AX
JNZ 0x001eeb81
LAB_001eeb3e:
MOV RAX,RSI
AND RAX,-0x200
CMP RAX,0x1e00
JNZ 0x001eeb63
LEA RAX,[0x47e410]
MOVZX EAX,word ptr [RAX + RSI*0x2 + -0x3c00]
TEST AX,AX
JNZ 0x001eeb81
LAB_001eeb63:
MOV RAX,RSI
AND RAX,-0x20
CMP RAX,0x2160
JNZ 0x001eeba8
LEA RAX,[0x47e810]
MOVZX EAX,word ptr [RAX + RSI*0x2 + -0x42c0]
LAB_001eeb81:
MOVZX ECX,AX
IMUL ECX,ECX,0xcccd
SHR ECX,0x16
LEA ESI,[RCX + 0x30]
MOV byte ptr [RDX + 0x1],SIL
SHL ECX,0x4
LEA ECX,[RCX + RCX*0x4]
SUB EAX,ECX
ADD AL,0x30
MOV byte ptr [RDX + 0x2],AL
MOV EAX,0x3
LAB_001eeba6:
POP RBP
RET
LAB_001eeba8:
LEA RAX,[RSI + -0x24b0]
CMP RAX,0x3f
JA 0x001eebd3
LEA RAX,[RSI + -0x24ea]
CMP RAX,-0x34
JC 0x001eec01
LEA RAX,[0x47e850]
MOVZX EAX,word ptr [RAX + RSI*0x2 + -0x4960]
JMP 0x001eeb81
LAB_001eebd3:
LEA RAX,[RSI + -0xff20]
CMP RAX,0x3f
JA 0x001eec01
MOV RDI,-0x7fffffe07ffffff
BT RDI,RAX
JC 0x001eec01
LEA RAX,[0x47e8d0]
MOVZX EAX,word ptr [RAX + RSI*0x2 + -0x1fe40]
JMP 0x001eeb81
LAB_001eec01:
LEA RDI,[RDX + 0x5]
MOV EAX,0xffffff97
CMP RDI,RCX
JA 0x001eeba6
MOV EAX,ESI
SHR EAX,0xc
AND EAX,0xf
LEA RCX,[0x47f3d0]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RDX + 0x1],AL
MOV EAX,ESI
SHR EAX,0x8
AND EAX,0xf
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RDX + 0x2],AL
MOV EAX,ESI
SHR EAX,0x4
AND EAX,0xf
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RDX + 0x3],AL
AND ESI,0xf
MOV AL,byte ptr [RSI + RCX*0x1]
MOV byte ptr [RDX + 0x4],AL
MOV EAX,0x5
JMP 0x001eeba6
|
int8
my_wc_mb_filename(int8 param_1,ulong param_2,int1 *param_3,int1 *param_4)
{
ushort uVar1;
if (param_4 <= param_3) {
return 0xffffff9b;
}
if ((param_2 < 0x80) && (filename_safe_char[param_2] != '\0')) {
*param_3 = (char)param_2;
return 1;
}
if (param_4 < param_3 + 3) {
return 0xffffff99;
}
*param_3 = 0x40;
if (((0x53f < param_2 - 0xc0) ||
(uVar1 = *(ushort *)(uni_1E00_1FFF + param_2 * 2 + 0x3c0), uVar1 == 0)) &&
(((param_2 & 0xfffffffffffffe00) != 0x1e00 ||
(uVar1 = *(ushort *)(unicode_to_jisx0212_eucjp + param_2 * 2 + 0x1f780), uVar1 == 0)))) {
if ((param_2 & 0xffffffffffffffe0) == 0x2160) {
uVar1 = *(ushort *)(unicode_to_jisx0212_eucjp + param_2 * 2 + 0x1f4c0);
}
else if (param_2 - 0x24b0 < 0x40) {
if (param_2 - 0x24ea < 0xffffffffffffffcc) {
LAB_001eec01:
if (param_4 < param_3 + 5) {
return 0xffffff97;
}
param_3[1] = "0123456789abcdef"[(uint)(param_2 >> 0xc) & 0xf];
param_3[2] = "0123456789abcdef"[(uint)(param_2 >> 8) & 0xf];
param_3[3] = "0123456789abcdef"[(uint)(param_2 >> 4) & 0xf];
param_3[4] = "0123456789abcdef"[(uint)param_2 & 0xf];
return 5;
}
uVar1 = *(ushort *)(unicode_to_jisx0212_eucjp + param_2 * 2 + 0x1ee60);
}
else {
if ((0x3f < param_2 - 0xff20) || ((0xf8000001f8000001U >> (param_2 - 0xff20 & 0x3f) & 1) != 0)
) goto LAB_001eec01;
uVar1 = *(ushort *)(unicode_to_jisx0212_eucjp + param_2 * 2 + 0x3a00);
}
}
param_3[1] = (char)(uVar1 / 0x50) + '0';
param_3[2] = (char)uVar1 + (char)(uVar1 / 0x50 << 4) * -5 + '0';
return 3;
}
|
|
19,807
|
my_coll_rule_shift_at_level
|
eloqsql/strings/ctype-uca.c
|
static void
my_coll_rule_shift_at_level(MY_COLL_RULE *r, int level)
{
switch (level)
{
case 4: /* Quaternary difference */
r->diff[3]++;
break;
case 3: /* Tertiary difference */
r->diff[2]++;
r->diff[3]= 0;
break;
case 2: /* Secondary difference */
r->diff[1]++;
r->diff[2]= r->diff[3]= 0;
break;
case 1: /* Primary difference */
r->diff[0]++;
r->diff[1]= r->diff[2]= r->diff[3]= 0;
break;
case 0:
/* Do nothing for '=': use the previous offsets for all levels */
break;
default:
DBUG_ASSERT(0);
}
}
|
O0
|
c
|
my_coll_rule_shift_at_level:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0x5b62d
movq -0x18(%rbp), %rax
leaq 0xf2ab9(%rip), %rcx # 0x14e030
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movl 0x8c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8c(%rax)
jmp 0x5b633
movq -0x8(%rbp), %rax
movl 0x88(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x88(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8c(%rax)
jmp 0x5b633
movq -0x8(%rbp), %rax
movl 0x84(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x84(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x88(%rax)
jmp 0x5b633
movq -0x8(%rbp), %rax
movl 0x80(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x80(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x88(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x84(%rax)
jmp 0x5b633
jmp 0x5b633
jmp 0x5b62f
jmp 0x5b631
jmp 0x5b633
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_coll_rule_shift_at_level:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov eax, [rbp+var_C]
mov [rbp+var_18], rax
sub rax, 4; switch 5 cases
ja def_5B57E; jumptable 000000000005B57E default case
mov rax, [rbp+var_18]
lea rcx, jpt_5B57E
movsxd rax, ds:(jpt_5B57E - 14E030h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_5B580:
mov rax, [rbp+var_8]; jumptable 000000000005B57E case 4
mov ecx, [rax+8Ch]
add ecx, 1
mov [rax+8Ch], ecx
jmp loc_5B633
loc_5B598:
mov rax, [rbp+var_8]; jumptable 000000000005B57E case 3
mov ecx, [rax+88h]
add ecx, 1
mov [rax+88h], ecx
mov rax, [rbp+var_8]
mov dword ptr [rax+8Ch], 0
jmp short loc_5B633
loc_5B5BB:
mov rax, [rbp+var_8]; jumptable 000000000005B57E case 2
mov ecx, [rax+84h]
add ecx, 1
mov [rax+84h], ecx
mov rax, [rbp+var_8]
mov dword ptr [rax+8Ch], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+88h], 0
jmp short loc_5B633
loc_5B5EC:
mov rax, [rbp+var_8]; jumptable 000000000005B57E case 1
mov ecx, [rax+80h]
add ecx, 1
mov [rax+80h], ecx
mov rax, [rbp+var_8]
mov dword ptr [rax+8Ch], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+88h], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+84h], 0
jmp short loc_5B633
loc_5B62B:
jmp short loc_5B633; jumptable 000000000005B57E case 0
def_5B57E:
jmp short $+2; jumptable 000000000005B57E default case
loc_5B62F:
jmp short $+2
loc_5B631:
jmp short $+2
loc_5B633:
pop rbp
retn
|
unsigned long long my_coll_rule_shift_at_level(_DWORD *a1, unsigned int a2)
{
unsigned long long result; // rax
result = a2;
switch ( a2 )
{
case 1u:
++a1[32];
a1[35] = 0;
a1[34] = 0;
result = (unsigned long long)a1;
a1[33] = 0;
break;
case 2u:
++a1[33];
a1[35] = 0;
result = (unsigned long long)a1;
a1[34] = 0;
break;
case 3u:
++a1[34];
result = (unsigned long long)a1;
a1[35] = 0;
break;
case 4u:
result = (unsigned long long)a1;
++a1[35];
break;
default:
return result;
}
return result;
}
|
my_coll_rule_shift_at_level:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV EAX,dword ptr [RBP + -0xc]
MOV qword ptr [RBP + -0x18],RAX
SUB RAX,0x4
JA 0x0015b62d
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[0x24e030]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_4:
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x8c]
ADD ECX,0x1
MOV dword ptr [RAX + 0x8c],ECX
JMP 0x0015b633
caseD_3:
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x88]
ADD ECX,0x1
MOV dword ptr [RAX + 0x88],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x8c],0x0
JMP 0x0015b633
caseD_2:
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x84]
ADD ECX,0x1
MOV dword ptr [RAX + 0x84],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x8c],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x88],0x0
JMP 0x0015b633
caseD_1:
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x80]
ADD ECX,0x1
MOV dword ptr [RAX + 0x80],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x8c],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x88],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x84],0x0
JMP 0x0015b633
caseD_0:
JMP 0x0015b633
LAB_0015b62d:
JMP 0x0015b62f
LAB_0015b62f:
JMP 0x0015b631
LAB_0015b631:
JMP 0x0015b633
default:
POP RBP
RET
|
void my_coll_rule_shift_at_level(long param_1,int4 param_2)
{
switch(param_2) {
case 0:
break;
case 1:
*(int *)(param_1 + 0x80) = *(int *)(param_1 + 0x80) + 1;
*(int4 *)(param_1 + 0x8c) = 0;
*(int4 *)(param_1 + 0x88) = 0;
*(int4 *)(param_1 + 0x84) = 0;
break;
case 2:
*(int *)(param_1 + 0x84) = *(int *)(param_1 + 0x84) + 1;
*(int4 *)(param_1 + 0x8c) = 0;
*(int4 *)(param_1 + 0x88) = 0;
break;
case 3:
*(int *)(param_1 + 0x88) = *(int *)(param_1 + 0x88) + 1;
*(int4 *)(param_1 + 0x8c) = 0;
break;
case 4:
*(int *)(param_1 + 0x8c) = *(int *)(param_1 + 0x8c) + 1;
}
return;
}
|
|
19,808
|
my_strxfrm_desc_and_reverse
|
eloqsql/strings/ctype-simple.c
|
void
my_strxfrm_desc_and_reverse(uchar *str, uchar *strend,
uint flags, uint level)
{
if (flags & (MY_STRXFRM_DESC_LEVEL1 << level))
{
if (flags & (MY_STRXFRM_REVERSE_LEVEL1 << level))
{
for (strend--; str <= strend;)
{
uchar tmp= *str;
*str++= ~*strend;
*strend--= ~tmp;
}
}
else
{
for (; str < strend; str++)
*str= ~*str;
}
}
else if (flags & (MY_STRXFRM_REVERSE_LEVEL1 << level))
{
for (strend--; str < strend;)
{
uchar tmp= *str;
*str++= *strend;
*strend--= tmp;
}
}
}
|
O0
|
c
|
my_strxfrm_desc_and_reverse:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
movl $0x100, %edx # imm = 0x100
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x5518c
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
movl $0x10000, %edx # imm = 0x10000
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x5515c
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x5515a
movq -0x8(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
xorl $-0x1, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movzbl -0x19(%rbp), %eax
xorl $-0x1, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0x5510e
jmp 0x5518a
jmp 0x5515e
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x55188
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
xorl $-0x1, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x5515e
jmp 0x5518a
jmp 0x551f2
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
movl $0x10000, %edx # imm = 0x10000
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x551f0
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x551ee
movq -0x8(%rbp), %rax
movb (%rax), %al
movb %al, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movb -0x1a(%rbp), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0x551ae
jmp 0x551f0
jmp 0x551f2
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_strxfrm_desc_and_reverse:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_18], ecx
mov eax, [rbp+var_14]
mov ecx, [rbp+var_18]
mov edx, 100h
shl edx, cl
mov ecx, edx
and eax, ecx
cmp eax, 0
jz loc_5518C
mov eax, [rbp+var_14]
mov ecx, [rbp+var_18]
mov edx, 10000h
shl edx, cl
mov ecx, edx
and eax, ecx
cmp eax, 0
jz short loc_5515C
mov rax, [rbp+var_10]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_10], rax
loc_5510E:
mov rax, [rbp+var_8]
cmp rax, [rbp+var_10]
ja short loc_5515A
mov rax, [rbp+var_8]
mov al, [rax]
mov [rbp+var_19], al
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
xor eax, 0FFFFFFFFh
mov cl, al
mov rax, [rbp+var_8]
mov rdx, rax
add rdx, 1
mov [rbp+var_8], rdx
mov [rax], cl
movzx eax, [rbp+var_19]
xor eax, 0FFFFFFFFh
mov cl, al
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_10], rdx
mov [rax], cl
jmp short loc_5510E
loc_5515A:
jmp short loc_5518A
loc_5515C:
jmp short $+2
loc_5515E:
mov rax, [rbp+var_8]
cmp rax, [rbp+var_10]
jnb short loc_55188
mov rax, [rbp+var_8]
movzx eax, byte ptr [rax]
xor eax, 0FFFFFFFFh
mov cl, al
mov rax, [rbp+var_8]
mov [rax], cl
mov rax, [rbp+var_8]
add rax, 1
mov [rbp+var_8], rax
jmp short loc_5515E
loc_55188:
jmp short $+2
loc_5518A:
jmp short loc_551F2
loc_5518C:
mov eax, [rbp+var_14]
mov ecx, [rbp+var_18]
mov edx, 10000h
shl edx, cl
mov ecx, edx
and eax, ecx
cmp eax, 0
jz short loc_551F0
mov rax, [rbp+var_10]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_10], rax
loc_551AE:
mov rax, [rbp+var_8]
cmp rax, [rbp+var_10]
jnb short loc_551EE
mov rax, [rbp+var_8]
mov al, [rax]
mov [rbp+var_1A], al
mov rax, [rbp+var_10]
mov cl, [rax]
mov rax, [rbp+var_8]
mov rdx, rax
add rdx, 1
mov [rbp+var_8], rdx
mov [rax], cl
mov cl, [rbp+var_1A]
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_10], rdx
mov [rax], cl
jmp short loc_551AE
loc_551EE:
jmp short $+2
loc_551F0:
jmp short $+2
loc_551F2:
pop rbp
retn
|
_BYTE * my_strxfrm_desc_and_reverse(_BYTE *a1, unsigned long long a2, unsigned int a3, char a4)
{
_BYTE *result; // rax
_BYTE *v5; // rax
_BYTE *v6; // rax
_BYTE *v7; // rax
_BYTE *v8; // rax
char v9; // [rsp+0h] [rbp-1Ah]
char v10; // [rsp+1h] [rbp-19h]
_BYTE *i; // [rsp+Ah] [rbp-10h]
_BYTE *j; // [rsp+Ah] [rbp-10h]
if ( ((256 << a4) & a3) != 0 )
{
if ( ((0x10000 << a4) & a3) != 0 )
{
for ( i = (_BYTE *)(a2 - 1); ; --i )
{
result = a1;
if ( a1 > i )
break;
v10 = *a1;
v5 = a1++;
*v5 = ~*i;
v6 = i;
*v6 = ~v10;
}
}
else
{
while ( 1 )
{
result = a1;
if ( (unsigned long long)a1 >= a2 )
break;
*a1 = ~*a1;
++a1;
}
}
}
else
{
result = (_BYTE *)((0x10000 << a4) & a3);
if ( (_DWORD)result )
{
for ( j = (_BYTE *)(a2 - 1); ; --j )
{
result = a1;
if ( a1 >= j )
break;
v9 = *a1;
v7 = a1++;
*v7 = *j;
v8 = j;
*v8 = v9;
}
}
}
return result;
}
|
my_strxfrm_desc_and_reverse:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV dword ptr [RBP + -0x18],ECX
MOV EAX,dword ptr [RBP + -0x14]
MOV ECX,dword ptr [RBP + -0x18]
MOV EDX,0x100
SHL EDX,CL
MOV ECX,EDX
AND EAX,ECX
CMP EAX,0x0
JZ 0x0015518c
MOV EAX,dword ptr [RBP + -0x14]
MOV ECX,dword ptr [RBP + -0x18]
MOV EDX,0x10000
SHL EDX,CL
MOV ECX,EDX
AND EAX,ECX
CMP EAX,0x0
JZ 0x0015515c
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x10],RAX
LAB_0015510e:
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x10]
JA 0x0015515a
MOV RAX,qword ptr [RBP + -0x8]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x19],AL
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
XOR EAX,0xffffffff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x8],RDX
MOV byte ptr [RAX],CL
MOVZX EAX,byte ptr [RBP + -0x19]
XOR EAX,0xffffffff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RAX],CL
JMP 0x0015510e
LAB_0015515a:
JMP 0x0015518a
LAB_0015515c:
JMP 0x0015515e
LAB_0015515e:
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x10]
JNC 0x00155188
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,byte ptr [RAX]
XOR EAX,0xffffffff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0015515e
LAB_00155188:
JMP 0x0015518a
LAB_0015518a:
JMP 0x001551f2
LAB_0015518c:
MOV EAX,dword ptr [RBP + -0x14]
MOV ECX,dword ptr [RBP + -0x18]
MOV EDX,0x10000
SHL EDX,CL
MOV ECX,EDX
AND EAX,ECX
CMP EAX,0x0
JZ 0x001551f0
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x10],RAX
LAB_001551ae:
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x10]
JNC 0x001551ee
MOV RAX,qword ptr [RBP + -0x8]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x1a],AL
MOV RAX,qword ptr [RBP + -0x10]
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x8],RDX
MOV byte ptr [RAX],CL
MOV CL,byte ptr [RBP + -0x1a]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RAX],CL
JMP 0x001551ae
LAB_001551ee:
JMP 0x001551f0
LAB_001551f0:
JMP 0x001551f2
LAB_001551f2:
POP RBP
RET
|
void my_strxfrm_desc_and_reverse(byte *param_1,byte *param_2,uint param_3,byte param_4)
{
byte bVar1;
byte *local_18;
byte *local_10;
if ((param_3 & 0x100 << (param_4 & 0x1f)) == 0) {
if ((param_3 & 0x10000 << (param_4 & 0x1f)) != 0) {
local_18 = param_2 + -1;
local_10 = param_1;
while (local_10 < local_18) {
bVar1 = *local_10;
*local_10 = *local_18;
*local_18 = bVar1;
local_18 = local_18 + -1;
local_10 = local_10 + 1;
}
}
}
else {
local_10 = param_1;
if ((param_3 & 0x10000 << (param_4 & 0x1f)) == 0) {
for (; local_10 < param_2; local_10 = local_10 + 1) {
*local_10 = *local_10 ^ 0xff;
}
}
else {
local_18 = param_2 + -1;
local_10 = param_1;
while (local_10 <= local_18) {
bVar1 = *local_10;
*local_10 = *local_18 ^ 0xff;
*local_18 = bVar1 ^ 0xff;
local_18 = local_18 + -1;
local_10 = local_10 + 1;
}
}
}
return;
}
|
|
19,809
|
testing::internal::edit_distance::(anonymous namespace)::Hunk::PrintHeader(std::ostream*) const
|
AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest.cc
|
void PrintHeader(std::ostream* ss) const {
*ss << "@@ ";
if (removes_) {
*ss << "-" << left_start_ << "," << (removes_ + common_);
}
if (removes_ && adds_) {
*ss << " ";
}
if (adds_) {
*ss << "+" << right_start_ << "," << (adds_ + common_);
}
*ss << " @@\n";
}
|
O0
|
cpp
|
testing::internal::edit_distance::(anonymous namespace)::Hunk::PrintHeader(std::ostream*) const:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
leaq 0x3681d(%rip), %rsi # 0x114800
callq 0x146a0
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0xde036
movq 0x8(%rsp), %rdi
leaq 0x36262(%rip), %rsi # 0x114261
callq 0x146a0
movq %rax, %rdi
movq (%rsp), %rax
movq (%rax), %rsi
callq 0x14130
movq %rax, %rdi
leaq 0x367e7(%rip), %rsi # 0x114804
callq 0x146a0
movq %rax, %rdi
movq (%rsp), %rax
movq 0x18(%rax), %rsi
addq 0x20(%rax), %rsi
callq 0x14130
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0xde05d
movq (%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0xde05d
movq 0x8(%rsp), %rdi
leaq 0x3528b(%rip), %rsi # 0x1132e3
callq 0x146a0
movq (%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0xde0ac
movq 0x8(%rsp), %rdi
leaq 0x2f656(%rip), %rsi # 0x10d6ca
callq 0x146a0
movq %rax, %rdi
movq (%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x14130
movq %rax, %rdi
leaq 0x36771(%rip), %rsi # 0x114804
callq 0x146a0
movq %rax, %rdi
movq (%rsp), %rax
movq 0x10(%rax), %rsi
addq 0x20(%rax), %rsi
callq 0x14130
movq 0x8(%rsp), %rdi
leaq 0x3674e(%rip), %rsi # 0x114806
callq 0x146a0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
|
_ZNK7testing8internal13edit_distance12_GLOBAL__N_14Hunk11PrintHeaderEPSo:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov [rsp+18h+var_10], rsi
mov rax, [rsp+18h+var_8]
mov [rsp+18h+var_18], rax
mov rdi, [rsp+18h+var_10]
lea rsi, asc_114800; "@@ "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rax, [rsp+18h+var_18]
cmp qword ptr [rax+18h], 0
jz short loc_DE036
mov rdi, [rsp+18h+var_10]
lea rsi, aTheValueOfFlag+13h; "-"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
mov rax, [rsp+18h+var_18]
mov rsi, [rax]
call __ZNSolsEm; std::ostream::operator<<(ulong)
mov rdi, rax
lea rsi, asc_114804; ","
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
mov rax, [rsp+18h+var_18]
mov rsi, [rax+18h]
add rsi, [rax+20h]
call __ZNSolsEm; std::ostream::operator<<(ulong)
loc_DE036:
mov rax, [rsp+18h+var_18]
cmp qword ptr [rax+18h], 0
jz short loc_DE05D
mov rax, [rsp+18h+var_18]
cmp qword ptr [rax+10h], 0
jz short loc_DE05D
mov rdi, [rsp+18h+var_10]
lea rsi, asc_1132E1+2; " "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
loc_DE05D:
mov rax, [rsp+18h+var_18]
cmp qword ptr [rax+10h], 0
jz short loc_DE0AC
mov rdi, [rsp+18h+var_10]
lea rsi, asc_10D6C9+1; "+"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
mov rax, [rsp+18h+var_18]
mov rsi, [rax+8]
call __ZNSolsEm; std::ostream::operator<<(ulong)
mov rdi, rax
lea rsi, asc_114804; ","
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
mov rax, [rsp+18h+var_18]
mov rsi, [rax+10h]
add rsi, [rax+20h]
call __ZNSolsEm; std::ostream::operator<<(ulong)
loc_DE0AC:
mov rdi, [rsp+18h+var_10]
lea rsi, asc_114806; " @@\n"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
add rsp, 18h
retn
|
long long testing::internal::edit_distance::`anonymous namespace'::Hunk::PrintHeader(
testing::internal::edit_distance::_anonymous_namespace_::Hunk *this,
std::ostream *a2)
{
long long v2; // rax
long long v3; // rax
long long v4; // rax
long long v5; // rax
long long v6; // rax
long long v7; // rax
std::operator<<<std::char_traits<char>>(a2, "@@ ");
if ( *((_QWORD *)this + 3) )
{
v2 = std::operator<<<std::char_traits<char>>(a2, "-");
v3 = std::ostream::operator<<(v2, *(_QWORD *)this);
v4 = std::operator<<<std::char_traits<char>>(v3, ",");
std::ostream::operator<<(v4, *((_QWORD *)this + 4) + *((_QWORD *)this + 3));
}
if ( *((_QWORD *)this + 3) && *((_QWORD *)this + 2) )
std::operator<<<std::char_traits<char>>(a2, " ");
if ( *((_QWORD *)this + 2) )
{
v5 = std::operator<<<std::char_traits<char>>(a2, "+");
v6 = std::ostream::operator<<(v5, *((_QWORD *)this + 1));
v7 = std::operator<<<std::char_traits<char>>(v6, ",");
std::ostream::operator<<(v7, *((_QWORD *)this + 4) + *((_QWORD *)this + 2));
}
return std::operator<<<std::char_traits<char>>(a2, " @@\n");
}
|
PrintHeader:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[0x214800]
CALL 0x001146a0
MOV RAX,qword ptr [RSP]
CMP qword ptr [RAX + 0x18],0x0
JZ 0x001de036
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[0x214261]
CALL 0x001146a0
MOV RDI,RAX
MOV RAX,qword ptr [RSP]
MOV RSI,qword ptr [RAX]
CALL 0x00114130
MOV RDI,RAX
LEA RSI,[0x214804]
CALL 0x001146a0
MOV RDI,RAX
MOV RAX,qword ptr [RSP]
MOV RSI,qword ptr [RAX + 0x18]
ADD RSI,qword ptr [RAX + 0x20]
CALL 0x00114130
LAB_001de036:
MOV RAX,qword ptr [RSP]
CMP qword ptr [RAX + 0x18],0x0
JZ 0x001de05d
MOV RAX,qword ptr [RSP]
CMP qword ptr [RAX + 0x10],0x0
JZ 0x001de05d
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[0x2132e3]
CALL 0x001146a0
LAB_001de05d:
MOV RAX,qword ptr [RSP]
CMP qword ptr [RAX + 0x10],0x0
JZ 0x001de0ac
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[0x20d6ca]
CALL 0x001146a0
MOV RDI,RAX
MOV RAX,qword ptr [RSP]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x00114130
MOV RDI,RAX
LEA RSI,[0x214804]
CALL 0x001146a0
MOV RDI,RAX
MOV RAX,qword ptr [RSP]
MOV RSI,qword ptr [RAX + 0x10]
ADD RSI,qword ptr [RAX + 0x20]
CALL 0x00114130
LAB_001de0ac:
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[0x214806]
CALL 0x001146a0
ADD RSP,0x18
RET
|
/* testing::internal::edit_distance::(anonymous namespace)::Hunk::PrintHeader(std::ostream*) const
*/
void __thiscall
testing::internal::edit_distance::(anonymous_namespace)::Hunk::PrintHeader
(Hunk *this,ostream *param_1)
{
ostream *poVar1;
std::operator<<(param_1,"@@ ");
if (*(long *)(this + 0x18) != 0) {
poVar1 = std::operator<<(param_1,"-");
poVar1 = (ostream *)std::ostream::operator<<(poVar1,*(ulong *)this);
poVar1 = std::operator<<(poVar1,",");
std::ostream::operator<<(poVar1,*(long *)(this + 0x18) + *(long *)(this + 0x20));
}
if ((*(long *)(this + 0x18) != 0) && (*(long *)(this + 0x10) != 0)) {
std::operator<<(param_1," ");
}
if (*(long *)(this + 0x10) != 0) {
poVar1 = std::operator<<(param_1,"+");
poVar1 = (ostream *)std::ostream::operator<<(poVar1,*(ulong *)(this + 8));
poVar1 = std::operator<<(poVar1,",");
std::ostream::operator<<(poVar1,*(long *)(this + 0x10) + *(long *)(this + 0x20));
}
std::operator<<(param_1," @@\n");
return;
}
|
|
19,810
|
my_open
|
eloqsql/mysys/my_open.c
|
File my_open(const char *FileName, int Flags, myf MyFlags)
/* Path-name of file */
/* Read | write .. */
/* Special flags */
{
File fd;
DBUG_ENTER("my_open");
DBUG_PRINT("my",("Name: '%s' Flags: %d MyFlags: %lu",
FileName, Flags, MyFlags));
if (!(MyFlags & (MY_WME | MY_FAE | MY_FFNF)))
MyFlags|= my_global_flags;
#if defined(_WIN32)
fd= my_win_open(FileName, Flags);
#else
if (MyFlags & MY_NOSYMLINKS)
fd = open_nosymlinks(FileName, Flags | O_CLOEXEC, my_umask);
else
fd = open(FileName, Flags | O_CLOEXEC, my_umask);
#endif
fd= my_register_filename(fd, FileName, FILE_BY_OPEN,
EE_FILENOTFOUND, MyFlags);
DBUG_RETURN(fd);
}
|
O0
|
c
|
my_open:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x3e715
movq -0x18(%rbp), %rax
andq $0x19, %rax
cmpq $0x0, %rax
jne 0x3e735
leaq 0x36f40e(%rip), %rax # 0x3adb38
movq (%rax), %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x200, %rax # imm = 0x200
cmpq $0x0, %rax
je 0x3e765
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
orl $0x80000, %esi # imm = 0x80000
leaq 0x19ec5f(%rip), %rax # 0x1dd3b8
movl (%rax), %edx
callq 0x3e7c0
movl %eax, -0x1c(%rbp)
jmp 0x3e785
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
orl $0x80000, %esi # imm = 0x80000
leaq 0x19ec3f(%rip), %rax # 0x1dd3b8
movl (%rax), %edx
movb $0x0, %al
callq 0x24500
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %r8
movl $0x1, %edx
movl $0x1d, %ecx
callq 0x3e830
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_open:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
jmp short $+2
loc_3E715:
mov rax, [rbp+var_18]
and rax, 19h
cmp rax, 0
jnz short loc_3E735
lea rax, my_global_flags
mov rax, [rax]
or rax, [rbp+var_18]
mov [rbp+var_18], rax
loc_3E735:
mov rax, [rbp+var_18]
and rax, 200h
cmp rax, 0
jz short loc_3E765
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
or esi, 80000h
lea rax, my_umask
mov edx, [rax]
call open_nosymlinks
mov [rbp+var_1C], eax
jmp short loc_3E785
loc_3E765:
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
or esi, 80000h
lea rax, my_umask
mov edx, [rax]
mov al, 0
call _open64
mov [rbp+var_1C], eax
loc_3E785:
mov edi, [rbp+var_1C]
mov rsi, [rbp+var_8]
mov r8, [rbp+var_18]
mov edx, 1
mov ecx, 1Dh
call my_register_filename
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
mov [rbp+var_20], eax
mov eax, [rbp+var_20]
add rsp, 20h
pop rbp
retn
|
long long my_open(long long a1, int a2, long long a3)
{
unsigned int v4; // [rsp+4h] [rbp-1Ch]
long long v5; // [rsp+8h] [rbp-18h]
v5 = a3;
if ( (a3 & 0x19) == 0 )
v5 = a3 | my_global_flags;
if ( (v5 & 0x200) != 0 )
v4 = open_nosymlinks(a1, a2 | 0x80000u, my_umask);
else
v4 = open64(a1, a2 | 0x80000u, my_umask);
return (unsigned int)my_register_filename(v4, a1, 1LL, 29LL, v5);
}
|
my_open:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
JMP 0x0013e715
LAB_0013e715:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x19
CMP RAX,0x0
JNZ 0x0013e735
LEA RAX,[0x4adb38]
MOV RAX,qword ptr [RAX]
OR RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
LAB_0013e735:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x200
CMP RAX,0x0
JZ 0x0013e765
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
OR ESI,0x80000
LEA RAX,[0x2dd3b8]
MOV EDX,dword ptr [RAX]
CALL 0x0013e7c0
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x0013e785
LAB_0013e765:
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
OR ESI,0x80000
LEA RAX,[0x2dd3b8]
MOV EDX,dword ptr [RAX]
MOV AL,0x0
CALL 0x00124500
MOV dword ptr [RBP + -0x1c],EAX
LAB_0013e785:
MOV EDI,dword ptr [RBP + -0x1c]
MOV RSI,qword ptr [RBP + -0x8]
MOV R8,qword ptr [RBP + -0x18]
MOV EDX,0x1
MOV ECX,0x1d
CALL 0x0013e830
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x20]
ADD RSP,0x20
POP RBP
RET
|
int4 my_open(char *param_1,uint param_2,ulong param_3)
{
int4 uVar1;
int4 local_24;
int8 local_20;
local_20 = param_3;
if ((param_3 & 0x19) == 0) {
local_20 = my_global_flags | param_3;
}
if ((local_20 & 0x200) == 0) {
local_24 = open64(param_1,param_2 | 0x80000,(ulong)my_umask);
}
else {
local_24 = open_nosymlinks(param_1,param_2 | 0x80000,my_umask);
}
uVar1 = my_register_filename(local_24,param_1,1,0x1d,local_20);
return uVar1;
}
|
|
19,811
|
ma_decrypt
|
eloqsql/storage/maria/ma_crypt.c
|
static int ma_decrypt(MARIA_SHARE *share, MARIA_CRYPT_DATA *crypt_data,
const uchar *src, uchar *dst, uint size,
uint pageno, LSN lsn,
uint key_version)
{
int rc;
uint32 dstlen= 0; /* Must be set because of error message */
rc= encryption_scheme_decrypt(src, size, dst, &dstlen,
&crypt_data->scheme, key_version,
crypt_data->space, pageno, lsn);
DBUG_ASSERT(!my_assert_on_error || rc == MY_AES_OK);
DBUG_ASSERT(!my_assert_on_error || dstlen == size);
if (! (rc == MY_AES_OK && dstlen == size))
{
my_errno= HA_ERR_DECRYPTION_FAILED;
if (!share->silence_encryption_errors)
my_printf_error(HA_ERR_DECRYPTION_FAILED,
"failed to decrypt '%s' rc: %d dstlen: %u size: %u\n",
MYF(ME_FATAL|ME_ERROR_LOG),
share->open_file_name.str, rc, dstlen, size);
return 1;
}
return 0;
}
|
O0
|
c
|
ma_decrypt:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %r8
movl 0x18(%rbp), %r9d
movq -0x18(%rbp), %rax
movl 0x60(%rax), %r11d
movl -0x30(%rbp), %r10d
movq 0x10(%rbp), %rax
leaq -0x38(%rbp), %rcx
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x2b1d0
movl %eax, -0x34(%rbp)
jmp 0x5e9cd
jmp 0x5e9cf
jmp 0x5e9d1
cmpl $0x0, -0x34(%rbp)
jne 0x5e9df
movl -0x38(%rbp), %eax
cmpl -0x2c(%rbp), %eax
je 0x5ea31
callq 0xf55f0
movl $0xc0, (%rax)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x7ec(%rax)
jne 0x5ea28
movq -0x10(%rbp), %rax
movq 0x5e0(%rax), %rcx
movl -0x34(%rbp), %r8d
movl -0x38(%rbp), %r9d
movl -0x2c(%rbp), %eax
movl $0xc0, %edi
leaq 0xf2ce2(%rip), %rsi # 0x1516fb
movl $0x1040, %edx # imm = 0x1040
movl %eax, (%rsp)
movb $0x0, %al
callq 0xef290
movl $0x1, -0x4(%rbp)
jmp 0x5ea38
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ma_decrypt:
push rbp
mov rbp, rsp
sub rsp, 50h
mov eax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_2C], r8d
mov [rbp+var_30], r9d
mov [rbp+var_38], 0
mov rdi, [rbp+var_20]
mov esi, [rbp+var_2C]
mov rdx, [rbp+var_28]
mov r8, [rbp+var_18]
mov r9d, [rbp+arg_8]
mov rax, [rbp+var_18]
mov r11d, [rax+60h]
mov r10d, [rbp+var_30]
mov rax, [rbp+arg_0]
lea rcx, [rbp+var_38]
mov [rsp+50h+var_50], r11d
mov [rsp+50h+var_48], r10d
mov [rsp+50h+var_40], rax
call encryption_scheme_decrypt
mov [rbp+var_34], eax
jmp short $+2
loc_5E9CD:
jmp short $+2
loc_5E9CF:
jmp short $+2
loc_5E9D1:
cmp [rbp+var_34], 0
jnz short loc_5E9DF
mov eax, [rbp+var_38]
cmp eax, [rbp+var_2C]
jz short loc_5EA31
loc_5E9DF:
call _my_thread_var
mov dword ptr [rax], 0C0h
mov rax, [rbp+var_10]
cmp byte ptr [rax+7ECh], 0
jnz short loc_5EA28
mov rax, [rbp+var_10]
mov rcx, [rax+5E0h]
mov r8d, [rbp+var_34]
mov r9d, [rbp+var_38]
mov eax, [rbp+var_2C]
mov edi, 0C0h
lea rsi, aFailedToDecryp; "failed to decrypt '%s' rc: %d dstlen:"...
mov edx, 1040h
mov [rsp+50h+var_50], eax
mov al, 0
call my_printf_error
loc_5EA28:
mov [rbp+var_4], 1
jmp short loc_5EA38
loc_5EA31:
mov [rbp+var_4], 0
loc_5EA38:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
|
long long ma_decrypt(long long a1, double a2, long long a3, long long a4, long long a5, int a6)
{
int v7; // [rsp+1Ch] [rbp-34h]
v7 = encryption_scheme_decrypt();
if ( v7 || a6 )
{
*(_DWORD *)my_thread_var(a2) = 192;
if ( !*(_BYTE *)(a1 + 2028) )
my_printf_error(
192,
(unsigned int)"failed to decrypt '%s' rc: %d dstlen: %u size: %u\n",
4160,
*(_QWORD *)(a1 + 1504),
v7,
0);
return 1;
}
else
{
return 0;
}
}
|
ma_decrypt:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV EAX,dword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV dword ptr [RBP + -0x2c],R8D
MOV dword ptr [RBP + -0x30],R9D
MOV dword ptr [RBP + -0x38],0x0
MOV RDI,qword ptr [RBP + -0x20]
MOV ESI,dword ptr [RBP + -0x2c]
MOV RDX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x18]
MOV R9D,dword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + -0x18]
MOV R11D,dword ptr [RAX + 0x60]
MOV R10D,dword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + 0x10]
LEA RCX,[RBP + -0x38]
MOV dword ptr [RSP],R11D
MOV dword ptr [RSP + 0x8],R10D
MOV qword ptr [RSP + 0x10],RAX
CALL 0x0012b1d0
MOV dword ptr [RBP + -0x34],EAX
JMP 0x0015e9cd
LAB_0015e9cd:
JMP 0x0015e9cf
LAB_0015e9cf:
JMP 0x0015e9d1
LAB_0015e9d1:
CMP dword ptr [RBP + -0x34],0x0
JNZ 0x0015e9df
MOV EAX,dword ptr [RBP + -0x38]
CMP EAX,dword ptr [RBP + -0x2c]
JZ 0x0015ea31
LAB_0015e9df:
CALL 0x001f55f0
MOV dword ptr [RAX],0xc0
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX + 0x7ec],0x0
JNZ 0x0015ea28
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x5e0]
MOV R8D,dword ptr [RBP + -0x34]
MOV R9D,dword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x2c]
MOV EDI,0xc0
LEA RSI,[0x2516fb]
MOV EDX,0x1040
MOV dword ptr [RSP],EAX
MOV AL,0x0
CALL 0x001ef290
LAB_0015ea28:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0015ea38
LAB_0015ea31:
MOV dword ptr [RBP + -0x4],0x0
LAB_0015ea38:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int4
ma_decrypt(long param_1,long param_2,int8 param_3,int8 param_4,int param_5,
int4 param_6,int8 param_7,int4 param_8)
{
int4 *puVar1;
int local_40;
int local_3c;
int4 local_38;
int local_34;
int8 local_30;
int8 local_28;
long local_20;
long local_18;
int4 local_c;
local_40 = 0;
local_38 = param_6;
local_34 = param_5;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
local_3c = encryption_scheme_decrypt
(param_3,param_5,param_4,&local_40,param_2,param_8,
*(int4 *)(param_2 + 0x60),param_6,param_7);
if ((local_3c == 0) && (local_40 == local_34)) {
local_c = 0;
}
else {
puVar1 = (int4 *)_my_thread_var();
*puVar1 = 0xc0;
if (*(char *)(local_18 + 0x7ec) == '\0') {
my_printf_error(0xc0,"failed to decrypt \'%s\' rc: %d dstlen: %u size: %u\n",0x1040,
*(int8 *)(local_18 + 0x5e0),local_3c,local_40,local_34);
}
local_c = 1;
}
return local_c;
}
|
|
19,812
|
OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::buildFaceVertexSiblingsFromVertexFaceSiblings(std::vector<unsigned short, std::allocator<unsigned short>>&) const
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/vtr/fvarLevel.cpp
|
void
FVarLevel::buildFaceVertexSiblingsFromVertexFaceSiblings(std::vector<Sibling>& fvSiblings) const {
fvSiblings.resize(_level.getNumFaceVerticesTotal());
std::memset(&fvSiblings[0], 0, _level.getNumFaceVerticesTotal() * sizeof(Sibling));
for (int vIndex = 0; vIndex < _level.getNumVertices(); ++vIndex) {
// We can skip cases of one sibling as we initialized to 0...
if (getNumVertexValues(vIndex) > 1) {
ConstIndexArray vFaces = _level.getVertexFaces(vIndex);
ConstLocalIndexArray vInFace = _level.getVertexFaceLocalIndices(vIndex);
ConstSiblingArray vSiblings = getVertexFaceSiblings(vIndex);
for (int j = 0; j < vFaces.size(); ++j) {
if (vSiblings[j] > 0) {
fvSiblings[_level.getOffsetOfFaceVertices(vFaces[j]) + vInFace[j]] = vSiblings[j];
}
}
}
}
}
|
O1
|
cpp
|
OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::buildFaceVertexSiblingsFromVertexFaceSiblings(std::vector<unsigned short, std::allocator<unsigned short>>&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x38(%rax), %rcx
subq 0x30(%rax), %rcx
shrq $0x2, %rcx
movslq %ecx, %rsi
movq %rbx, %rdi
callq 0x39160
movq (%r14), %rax
movq 0x38(%rax), %rdx
subq 0x30(%rax), %rdx
movq (%rbx), %rdi
shlq $0x1e, %rdx
sarq $0x1f, %rdx
andq $-0x2, %rdx
xorl %esi, %esi
callq 0x391b0
movq (%r14), %rax
movslq 0x8(%rax), %rcx
testq %rcx, %rcx
jle 0x3ebde
movq 0x48(%r14), %rdx
movq 0x78(%r14), %rsi
xorl %edi, %edi
cmpw $0x2, (%rdx,%rdi,2)
jb 0x3ebd6
movq 0x108(%rax), %r9
movslq (%r9,%rdi,8), %r8
testq %r8, %r8
jle 0x3ebd6
movslq 0x4(%r9,%rdi,8), %r11
leaq (,%r11,4), %r9
addq 0x120(%rax), %r9
leaq (%r11,%r11), %r10
addq 0x138(%rax), %r10
leaq (%rsi,%r11,2), %r11
movq (%rbx), %r14
xorl %r15d, %r15d
movzwl (%r11,%r15,2), %ebp
testw %bp, %bp
je 0x3ebce
movslq (%r9,%r15,4), %r12
movq 0x18(%rax), %r13
movslq 0x4(%r13,%r12,8), %r12
movzwl (%r10,%r15,2), %r13d
addq %r12, %r13
movw %bp, (%r14,%r13,2)
incq %r15
cmpq %r15, %r8
jne 0x3ebaa
incq %rdi
cmpq %rcx, %rdi
jne 0x3eb6a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZNK10OpenSubdiv6v3_6_03Vtr8internal9FVarLevel45buildFaceVertexSiblingsFromVertexFaceSiblingsERSt6vectorItSaItEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov rax, [rdi]
mov rcx, [rax+38h]
sub rcx, [rax+30h]
shr rcx, 2
movsxd rsi, ecx
mov rdi, rbx
call __ZNSt6vectorItSaItEE6resizeEm; std::vector<ushort>::resize(ulong)
mov rax, [r14]
mov rdx, [rax+38h]
sub rdx, [rax+30h]
mov rdi, [rbx]
shl rdx, 1Eh
sar rdx, 1Fh
and rdx, 0FFFFFFFFFFFFFFFEh
xor esi, esi
call _memset
mov rax, [r14]
movsxd rcx, dword ptr [rax+8]
test rcx, rcx
jle short loc_3EBDE
mov rdx, [r14+48h]
mov rsi, [r14+78h]
xor edi, edi
loc_3EB6A:
cmp word ptr [rdx+rdi*2], 2
jb short loc_3EBD6
mov r9, [rax+108h]
movsxd r8, dword ptr [r9+rdi*8]
test r8, r8
jle short loc_3EBD6
movsxd r11, dword ptr [r9+rdi*8+4]
lea r9, ds:0[r11*4]
add r9, [rax+120h]
lea r10, [r11+r11]
add r10, [rax+138h]
lea r11, [rsi+r11*2]
mov r14, [rbx]
xor r15d, r15d
loc_3EBAA:
movzx ebp, word ptr [r11+r15*2]
test bp, bp
jz short loc_3EBCE
movsxd r12, dword ptr [r9+r15*4]
mov r13, [rax+18h]
movsxd r12, dword ptr [r13+r12*8+4]
movzx r13d, word ptr [r10+r15*2]
add r13, r12
mov [r14+r13*2], bp
loc_3EBCE:
inc r15
cmp r8, r15
jnz short loc_3EBAA
loc_3EBD6:
inc rdi
cmp rdi, rcx
jnz short loc_3EB6A
loc_3EBDE:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
_QWORD * OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::buildFaceVertexSiblingsFromVertexFaceSiblings(
_QWORD *a1,
_QWORD *a2)
{
_QWORD *result; // rax
long long v4; // rcx
long long v5; // rdx
long long v6; // rsi
long long i; // rdi
long long v8; // r9
long long v9; // r8
long long v10; // r11
long long v11; // r9
long long v12; // r10
long long v13; // r11
long long v14; // r14
long long j; // r15
__int16 v16; // bp
std::vector<unsigned short>::resize(a2, (int)((*(_QWORD *)(*a1 + 56LL) - *(_QWORD *)(*a1 + 48LL)) >> 2));
memset(*a2, 0LL, ((long long)((*(_QWORD *)(*a1 + 56LL) - *(_QWORD *)(*a1 + 48LL)) << 30) >> 31) & 0xFFFFFFFFFFFFFFFELL);
result = (_QWORD *)*a1;
v4 = *(int *)(*a1 + 8LL);
if ( v4 > 0 )
{
v5 = a1[9];
v6 = a1[15];
for ( i = 0LL; i != v4; ++i )
{
if ( *(_WORD *)(v5 + 2 * i) >= 2u )
{
v8 = result[33];
v9 = *(int *)(v8 + 8 * i);
if ( v9 > 0 )
{
v10 = *(int *)(v8 + 8 * i + 4);
v11 = result[36] + 4 * v10;
v12 = result[39] + 2 * v10;
v13 = v6 + 2 * v10;
v14 = *a2;
for ( j = 0LL; j != v9; ++j )
{
v16 = *(_WORD *)(v13 + 2 * j);
if ( v16 )
*(_WORD *)(v14
+ 2
* (*(int *)(result[3] + 8LL * *(int *)(v11 + 4 * j) + 4)
+ (unsigned long long)*(unsigned __int16 *)(v12 + 2 * j))) = v16;
}
}
}
}
}
return result;
}
|
buildFaceVertexSiblingsFromVertexFaceSiblings:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr [RDI]
MOV RCX,qword ptr [RAX + 0x38]
SUB RCX,qword ptr [RAX + 0x30]
SHR RCX,0x2
MOVSXD RSI,ECX
MOV RDI,RBX
CALL 0x00139160
MOV RAX,qword ptr [R14]
MOV RDX,qword ptr [RAX + 0x38]
SUB RDX,qword ptr [RAX + 0x30]
MOV RDI,qword ptr [RBX]
SHL RDX,0x1e
SAR RDX,0x1f
AND RDX,-0x2
XOR ESI,ESI
CALL 0x001391b0
MOV RAX,qword ptr [R14]
MOVSXD RCX,dword ptr [RAX + 0x8]
TEST RCX,RCX
JLE 0x0013ebde
MOV RDX,qword ptr [R14 + 0x48]
MOV RSI,qword ptr [R14 + 0x78]
XOR EDI,EDI
LAB_0013eb6a:
CMP word ptr [RDX + RDI*0x2],0x2
JC 0x0013ebd6
MOV R9,qword ptr [RAX + 0x108]
MOVSXD R8,dword ptr [R9 + RDI*0x8]
TEST R8,R8
JLE 0x0013ebd6
MOVSXD R11,dword ptr [R9 + RDI*0x8 + 0x4]
LEA R9,[R11*0x4]
ADD R9,qword ptr [RAX + 0x120]
LEA R10,[R11 + R11*0x1]
ADD R10,qword ptr [RAX + 0x138]
LEA R11,[RSI + R11*0x2]
MOV R14,qword ptr [RBX]
XOR R15D,R15D
LAB_0013ebaa:
MOVZX EBP,word ptr [R11 + R15*0x2]
TEST BP,BP
JZ 0x0013ebce
MOVSXD R12,dword ptr [R9 + R15*0x4]
MOV R13,qword ptr [RAX + 0x18]
MOVSXD R12,dword ptr [R13 + R12*0x8 + 0x4]
MOVZX R13D,word ptr [R10 + R15*0x2]
ADD R13,R12
MOV word ptr [R14 + R13*0x2],BP
LAB_0013ebce:
INC R15
CMP R8,R15
JNZ 0x0013ebaa
LAB_0013ebd6:
INC RDI
CMP RDI,RCX
JNZ 0x0013eb6a
LAB_0013ebde:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::buildFaceVertexSiblingsFromVertexFaceSiblings(std::vector<unsigned
short, std::allocator<unsigned short> >&) const */
void __thiscall
OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::buildFaceVertexSiblingsFromVertexFaceSiblings
(FVarLevel *this,vector *param_1)
{
short sVar1;
int iVar2;
long lVar3;
long lVar4;
long lVar5;
long lVar6;
long lVar7;
long lVar8;
long lVar9;
long lVar10;
long lVar11;
long lVar12;
std::vector<unsigned_short,std::allocator<unsigned_short>>::resize
((vector<unsigned_short,std::allocator<unsigned_short>> *)param_1,
(long)(int)((ulong)(*(long *)(*(long *)this + 0x38) - *(long *)(*(long *)this + 0x30))
>> 2));
memset(*(void **)param_1,0,
(*(long *)(*(long *)this + 0x38) - *(long *)(*(long *)this + 0x30)) * 0x40000000 >> 0x1f &
0xfffffffffffffffe);
lVar3 = *(long *)this;
iVar2 = *(int *)(lVar3 + 8);
if (0 < (long)iVar2) {
lVar4 = *(long *)(this + 0x48);
lVar5 = *(long *)(this + 0x78);
lVar9 = 0;
do {
if (1 < *(ushort *)(lVar4 + lVar9 * 2)) {
lVar10 = (long)*(int *)(*(long *)(lVar3 + 0x108) + lVar9 * 8);
if (0 < lVar10) {
lVar11 = (long)*(int *)(*(long *)(lVar3 + 0x108) + 4 + lVar9 * 8);
lVar6 = *(long *)(lVar3 + 0x120);
lVar7 = *(long *)(lVar3 + 0x138);
lVar8 = *(long *)param_1;
lVar12 = 0;
do {
sVar1 = *(short *)(lVar5 + lVar11 * 2 + lVar12 * 2);
if (sVar1 != 0) {
*(short *)(lVar8 + ((ulong)*(ushort *)(lVar11 * 2 + lVar7 + lVar12 * 2) +
(long)*(int *)(*(long *)(lVar3 + 0x18) + 4 +
(long)*(int *)(lVar11 * 4 + lVar6 + lVar12 * 4) * 8))
* 2) = sVar1;
}
lVar12 = lVar12 + 1;
} while (lVar10 != lVar12);
}
}
lVar9 = lVar9 + 1;
} while (lVar9 != iVar2);
}
return;
}
|
|
19,813
|
OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::buildFaceVertexSiblingsFromVertexFaceSiblings(std::vector<unsigned short, std::allocator<unsigned short>>&) const
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/vtr/fvarLevel.cpp
|
void
FVarLevel::buildFaceVertexSiblingsFromVertexFaceSiblings(std::vector<Sibling>& fvSiblings) const {
fvSiblings.resize(_level.getNumFaceVerticesTotal());
std::memset(&fvSiblings[0], 0, _level.getNumFaceVerticesTotal() * sizeof(Sibling));
for (int vIndex = 0; vIndex < _level.getNumVertices(); ++vIndex) {
// We can skip cases of one sibling as we initialized to 0...
if (getNumVertexValues(vIndex) > 1) {
ConstIndexArray vFaces = _level.getVertexFaces(vIndex);
ConstLocalIndexArray vInFace = _level.getVertexFaceLocalIndices(vIndex);
ConstSiblingArray vSiblings = getVertexFaceSiblings(vIndex);
for (int j = 0; j < vFaces.size(); ++j) {
if (vSiblings[j] > 0) {
fvSiblings[_level.getOffsetOfFaceVertices(vFaces[j]) + vInFace[j]] = vSiblings[j];
}
}
}
}
}
|
O2
|
cpp
|
OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::buildFaceVertexSiblingsFromVertexFaceSiblings(std::vector<unsigned short, std::allocator<unsigned short>>&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x38(%rax), %rcx
subq 0x30(%rax), %rcx
shrq $0x2, %rcx
movslq %ecx, %rsi
movq %rbx, %rdi
callq 0x50b30
movq (%r14), %rax
movq 0x38(%rax), %rdx
subq 0x30(%rax), %rdx
movq (%rbx), %rdi
shlq $0x1e, %rdx
sarq $0x1f, %rdx
andq $-0x2, %rdx
xorl %esi, %esi
callq 0x50c10
movq (%r14), %rdi
xorl %r15d, %r15d
movslq 0x8(%rdi), %rax
cmpq %rax, %r15
jge 0x579f8
movq 0x48(%r14), %rax
cmpw $0x2, (%rax,%r15,2)
jb 0x579f0
movl %r15d, %esi
callq 0x55df0
movq %rax, %r12
movl %edx, %r13d
movq (%r14), %rdi
movl %r15d, %esi
callq 0x507c0
movq %rax, %rbp
movq %r14, %rdi
movl %r15d, %esi
callq 0x51830
movq (%r14), %rdi
movq (%rbx), %rcx
testl %r13d, %r13d
movl $0x0, %edx
cmovlel %edx, %r13d
xorl %edx, %edx
cmpq %rdx, %r13
je 0x579f0
movzwl (%rax,%rdx,2), %esi
testw %si, %si
je 0x579eb
movslq (%r12,%rdx,4), %r8
movq 0x18(%rdi), %r9
movslq 0x4(%r9,%r8,8), %r8
movzwl (%rbp,%rdx,2), %r9d
addq %r8, %r9
movw %si, (%rcx,%r9,2)
incq %rdx
jmp 0x579c2
incq %r15
jmp 0x57972
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZNK10OpenSubdiv6v3_6_03Vtr8internal9FVarLevel45buildFaceVertexSiblingsFromVertexFaceSiblingsERSt6vectorItSaItEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov rax, [rdi]
mov rcx, [rax+38h]
sub rcx, [rax+30h]
shr rcx, 2
movsxd rsi, ecx
mov rdi, rbx
call __ZNSt6vectorItSaItEE6resizeEm; std::vector<ushort>::resize(ulong)
mov rax, [r14]
mov rdx, [rax+38h]
sub rdx, [rax+30h]
mov rdi, [rbx]
shl rdx, 1Eh
sar rdx, 1Fh
and rdx, 0FFFFFFFFFFFFFFFEh
xor esi, esi
call _memset
mov rdi, [r14]; this
xor r15d, r15d
loc_57972:
movsxd rax, dword ptr [rdi+8]
cmp r15, rax
jge short loc_579F8
mov rax, [r14+48h]
cmp word ptr [rax+r15*2], 2
jb short loc_579F0
mov esi, r15d; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level14getVertexFacesEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexFaces(int)
mov r12, rax
mov r13d, edx
mov rdi, [r14]; this
mov esi, r15d; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level25getVertexFaceLocalIndicesEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexFaceLocalIndices(int)
mov rbp, rax
mov rdi, r14; this
mov esi, r15d; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal9FVarLevel21getVertexFaceSiblingsEi; OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::getVertexFaceSiblings(int)
mov rdi, [r14]
mov rcx, [rbx]
test r13d, r13d
mov edx, 0
cmovle r13d, edx
xor edx, edx
loc_579C2:
cmp r13, rdx
jz short loc_579F0
movzx esi, word ptr [rax+rdx*2]
test si, si
jz short loc_579EB
movsxd r8, dword ptr [r12+rdx*4]
mov r9, [rdi+18h]
movsxd r8, dword ptr [r9+r8*8+4]
movzx r9d, word ptr [rbp+rdx*2+0]
add r9, r8
mov [rcx+r9*2], si
loc_579EB:
inc rdx
jmp short loc_579C2
loc_579F0:
inc r15
jmp loc_57972
loc_579F8:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::buildFaceVertexSiblingsFromVertexFaceSiblings(
OpenSubdiv::v3_6_0::Vtr::internal::Level **this,
_QWORD *a2)
{
OpenSubdiv::v3_6_0::Vtr::internal::Level *v4; // rdi
long long i; // r15
long long result; // rax
long long VertexFaces; // r12
unsigned int v8; // edx
long long v9; // r13
long long VertexFaceLocalIndices; // rbp
long long VertexFaceSiblings; // rax
long long v12; // rcx
long long j; // rdx
__int16 v14; // si
std::vector<unsigned short>::resize(a2, (int)((*((_QWORD *)*this + 7) - *((_QWORD *)*this + 6)) >> 2));
memset(*a2, 0LL, ((long long)((*((_QWORD *)*this + 7) - *((_QWORD *)*this + 6)) << 30) >> 31) & 0xFFFFFFFFFFFFFFFELL);
v4 = *this;
for ( i = 0LL; ; ++i )
{
result = *((int *)v4 + 2);
if ( i >= result )
break;
if ( *((_WORD *)this[9] + i) >= 2u )
{
VertexFaces = OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexFaces(v4, i);
v9 = v8;
VertexFaceLocalIndices = OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexFaceLocalIndices(*this, i);
VertexFaceSiblings = OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::getVertexFaceSiblings(
(OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel *)this,
i);
v4 = *this;
v12 = *a2;
if ( (int)v9 <= 0 )
v9 = 0LL;
for ( j = 0LL; v9 != j; ++j )
{
v14 = *(_WORD *)(VertexFaceSiblings + 2 * j);
if ( v14 )
*(_WORD *)(v12
+ 2
* (*(int *)(*((_QWORD *)v4 + 3) + 8LL * *(int *)(VertexFaces + 4 * j) + 4)
+ (unsigned long long)*(unsigned __int16 *)(VertexFaceLocalIndices + 2 * j))) = v14;
}
}
}
return result;
}
|
buildFaceVertexSiblingsFromVertexFaceSiblings:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr [RDI]
MOV RCX,qword ptr [RAX + 0x38]
SUB RCX,qword ptr [RAX + 0x30]
SHR RCX,0x2
MOVSXD RSI,ECX
MOV RDI,RBX
CALL 0x00150b30
MOV RAX,qword ptr [R14]
MOV RDX,qword ptr [RAX + 0x38]
SUB RDX,qword ptr [RAX + 0x30]
MOV RDI,qword ptr [RBX]
SHL RDX,0x1e
SAR RDX,0x1f
AND RDX,-0x2
XOR ESI,ESI
CALL 0x00150c10
MOV RDI,qword ptr [R14]
XOR R15D,R15D
LAB_00157972:
MOVSXD RAX,dword ptr [RDI + 0x8]
CMP R15,RAX
JGE 0x001579f8
MOV RAX,qword ptr [R14 + 0x48]
CMP word ptr [RAX + R15*0x2],0x2
JC 0x001579f0
MOV ESI,R15D
CALL 0x00155df0
MOV R12,RAX
MOV R13D,EDX
MOV RDI,qword ptr [R14]
MOV ESI,R15D
CALL 0x001507c0
MOV RBP,RAX
MOV RDI,R14
MOV ESI,R15D
CALL 0x00151830
MOV RDI,qword ptr [R14]
MOV RCX,qword ptr [RBX]
TEST R13D,R13D
MOV EDX,0x0
CMOVLE R13D,EDX
XOR EDX,EDX
LAB_001579c2:
CMP R13,RDX
JZ 0x001579f0
MOVZX ESI,word ptr [RAX + RDX*0x2]
TEST SI,SI
JZ 0x001579eb
MOVSXD R8,dword ptr [R12 + RDX*0x4]
MOV R9,qword ptr [RDI + 0x18]
MOVSXD R8,dword ptr [R9 + R8*0x8 + 0x4]
MOVZX R9D,word ptr [RBP + RDX*0x2]
ADD R9,R8
MOV word ptr [RCX + R9*0x2],SI
LAB_001579eb:
INC RDX
JMP 0x001579c2
LAB_001579f0:
INC R15
JMP 0x00157972
LAB_001579f8:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::buildFaceVertexSiblingsFromVertexFaceSiblings(std::vector<unsigned
short, std::allocator<unsigned short> >&) const */
void __thiscall
OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::buildFaceVertexSiblingsFromVertexFaceSiblings
(FVarLevel *this,vector *param_1)
{
short sVar1;
long lVar2;
long lVar3;
long lVar4;
ulong uVar5;
Level *this_00;
ulong uVar6;
int iVar7;
long lVar8;
int1 auVar9 [12];
std::vector<unsigned_short,std::allocator<unsigned_short>>::resize
((vector<unsigned_short,std::allocator<unsigned_short>> *)param_1,
(long)(int)((ulong)(*(long *)(*(long *)this + 0x38) - *(long *)(*(long *)this + 0x30))
>> 2));
memset(*(void **)param_1,0,
(*(long *)(*(long *)this + 0x38) - *(long *)(*(long *)this + 0x30)) * 0x40000000 >> 0x1f &
0xfffffffffffffffe);
this_00 = *(Level **)this;
for (lVar8 = 0; lVar8 < *(int *)(this_00 + 8); lVar8 = lVar8 + 1) {
if (1 < *(ushort *)(*(long *)(this + 0x48) + lVar8 * 2)) {
iVar7 = (int)lVar8;
auVar9 = Level::getVertexFaces(this_00,iVar7);
uVar6 = (ulong)auVar9._8_4_;
lVar3 = Level::getVertexFaceLocalIndices(*(Level **)this,iVar7);
lVar4 = getVertexFaceSiblings(this,iVar7);
this_00 = *(Level **)this;
lVar2 = *(long *)param_1;
if ((int)auVar9._8_4_ < 1) {
uVar6 = 0;
}
for (uVar5 = 0; uVar6 != uVar5; uVar5 = uVar5 + 1) {
sVar1 = *(short *)(lVar4 + uVar5 * 2);
if (sVar1 != 0) {
*(short *)(lVar2 + ((ulong)*(ushort *)(lVar3 + uVar5 * 2) +
(long)*(int *)(*(long *)(this_00 + 0x18) + 4 +
(long)*(int *)(auVar9._0_8_ + uVar5 * 4) * 8)) * 2) =
sVar1;
}
}
}
}
return;
}
|
|
19,814
|
OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::buildFaceVertexSiblingsFromVertexFaceSiblings(std::vector<unsigned short, std::allocator<unsigned short>>&) const
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/vtr/fvarLevel.cpp
|
void
FVarLevel::buildFaceVertexSiblingsFromVertexFaceSiblings(std::vector<Sibling>& fvSiblings) const {
fvSiblings.resize(_level.getNumFaceVerticesTotal());
std::memset(&fvSiblings[0], 0, _level.getNumFaceVerticesTotal() * sizeof(Sibling));
for (int vIndex = 0; vIndex < _level.getNumVertices(); ++vIndex) {
// We can skip cases of one sibling as we initialized to 0...
if (getNumVertexValues(vIndex) > 1) {
ConstIndexArray vFaces = _level.getVertexFaces(vIndex);
ConstLocalIndexArray vInFace = _level.getVertexFaceLocalIndices(vIndex);
ConstSiblingArray vSiblings = getVertexFaceSiblings(vIndex);
for (int j = 0; j < vFaces.size(); ++j) {
if (vSiblings[j] > 0) {
fvSiblings[_level.getOffsetOfFaceVertices(vFaces[j]) + vInFace[j]] = vSiblings[j];
}
}
}
}
}
|
O3
|
cpp
|
OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::buildFaceVertexSiblingsFromVertexFaceSiblings(std::vector<unsigned short, std::allocator<unsigned short>>&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x38(%rax), %rcx
subq 0x30(%rax), %rcx
shrq $0x2, %rcx
movslq %ecx, %rsi
movq %rbx, %rdi
callq 0x39150
movq (%r14), %rax
movq 0x38(%rax), %rdx
subq 0x30(%rax), %rdx
movq (%rbx), %rdi
shlq $0x1e, %rdx
sarq $0x1f, %rdx
andq $-0x2, %rdx
xorl %esi, %esi
callq 0x391a0
movq (%r14), %rax
movslq 0x8(%rax), %rcx
testq %rcx, %rcx
jle 0x3ebc2
movq 0x48(%r14), %rdx
movq 0x78(%r14), %rsi
xorl %edi, %edi
cmpw $0x2, (%rdx,%rdi,2)
jb 0x3ebba
movq 0x108(%rax), %r9
movslq (%r9,%rdi,8), %r8
testq %r8, %r8
jle 0x3ebba
movslq 0x4(%r9,%rdi,8), %r11
leaq (,%r11,4), %r9
addq 0x120(%rax), %r9
leaq (%r11,%r11), %r10
addq 0x138(%rax), %r10
leaq (%rsi,%r11,2), %r11
movq (%rbx), %r14
xorl %r15d, %r15d
movzwl (%r11,%r15,2), %ebp
testw %bp, %bp
je 0x3ebb2
movslq (%r9,%r15,4), %r12
movq 0x18(%rax), %r13
movslq 0x4(%r13,%r12,8), %r12
movzwl (%r10,%r15,2), %r13d
addq %r12, %r13
movw %bp, (%r14,%r13,2)
incq %r15
cmpq %r15, %r8
jne 0x3eb8e
incq %rdi
cmpq %rcx, %rdi
jne 0x3eb4e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZNK10OpenSubdiv6v3_6_03Vtr8internal9FVarLevel45buildFaceVertexSiblingsFromVertexFaceSiblingsERSt6vectorItSaItEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov rax, [rdi]
mov rcx, [rax+38h]
sub rcx, [rax+30h]
shr rcx, 2
movsxd rsi, ecx
mov rdi, rbx
call __ZNSt6vectorItSaItEE6resizeEm; std::vector<ushort>::resize(ulong)
mov rax, [r14]
mov rdx, [rax+38h]
sub rdx, [rax+30h]
mov rdi, [rbx]
shl rdx, 1Eh
sar rdx, 1Fh
and rdx, 0FFFFFFFFFFFFFFFEh
xor esi, esi
call _memset
mov rax, [r14]
movsxd rcx, dword ptr [rax+8]
test rcx, rcx
jle short loc_3EBC2
mov rdx, [r14+48h]
mov rsi, [r14+78h]
xor edi, edi
loc_3EB4E:
cmp word ptr [rdx+rdi*2], 2
jb short loc_3EBBA
mov r9, [rax+108h]
movsxd r8, dword ptr [r9+rdi*8]
test r8, r8
jle short loc_3EBBA
movsxd r11, dword ptr [r9+rdi*8+4]
lea r9, ds:0[r11*4]
add r9, [rax+120h]
lea r10, [r11+r11]
add r10, [rax+138h]
lea r11, [rsi+r11*2]
mov r14, [rbx]
xor r15d, r15d
loc_3EB8E:
movzx ebp, word ptr [r11+r15*2]
test bp, bp
jz short loc_3EBB2
movsxd r12, dword ptr [r9+r15*4]
mov r13, [rax+18h]
movsxd r12, dword ptr [r13+r12*8+4]
movzx r13d, word ptr [r10+r15*2]
add r13, r12
mov [r14+r13*2], bp
loc_3EBB2:
inc r15
cmp r8, r15
jnz short loc_3EB8E
loc_3EBBA:
inc rdi
cmp rdi, rcx
jnz short loc_3EB4E
loc_3EBC2:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
_QWORD * OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::buildFaceVertexSiblingsFromVertexFaceSiblings(
_QWORD *a1,
_QWORD *a2)
{
_QWORD *result; // rax
long long v4; // rcx
long long v5; // rdx
long long v6; // rsi
long long i; // rdi
long long v8; // r9
long long v9; // r8
long long v10; // r11
long long v11; // r9
long long v12; // r10
long long v13; // r11
long long v14; // r14
long long j; // r15
__int16 v16; // bp
std::vector<unsigned short>::resize(a2, (int)((*(_QWORD *)(*a1 + 56LL) - *(_QWORD *)(*a1 + 48LL)) >> 2));
memset(*a2, 0LL, ((long long)((*(_QWORD *)(*a1 + 56LL) - *(_QWORD *)(*a1 + 48LL)) << 30) >> 31) & 0xFFFFFFFFFFFFFFFELL);
result = (_QWORD *)*a1;
v4 = *(int *)(*a1 + 8LL);
if ( v4 > 0 )
{
v5 = a1[9];
v6 = a1[15];
for ( i = 0LL; i != v4; ++i )
{
if ( *(_WORD *)(v5 + 2 * i) >= 2u )
{
v8 = result[33];
v9 = *(int *)(v8 + 8 * i);
if ( v9 > 0 )
{
v10 = *(int *)(v8 + 8 * i + 4);
v11 = result[36] + 4 * v10;
v12 = result[39] + 2 * v10;
v13 = v6 + 2 * v10;
v14 = *a2;
for ( j = 0LL; j != v9; ++j )
{
v16 = *(_WORD *)(v13 + 2 * j);
if ( v16 )
*(_WORD *)(v14
+ 2
* (*(int *)(result[3] + 8LL * *(int *)(v11 + 4 * j) + 4)
+ (unsigned long long)*(unsigned __int16 *)(v12 + 2 * j))) = v16;
}
}
}
}
}
return result;
}
|
buildFaceVertexSiblingsFromVertexFaceSiblings:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr [RDI]
MOV RCX,qword ptr [RAX + 0x38]
SUB RCX,qword ptr [RAX + 0x30]
SHR RCX,0x2
MOVSXD RSI,ECX
MOV RDI,RBX
CALL 0x00139150
MOV RAX,qword ptr [R14]
MOV RDX,qword ptr [RAX + 0x38]
SUB RDX,qword ptr [RAX + 0x30]
MOV RDI,qword ptr [RBX]
SHL RDX,0x1e
SAR RDX,0x1f
AND RDX,-0x2
XOR ESI,ESI
CALL 0x001391a0
MOV RAX,qword ptr [R14]
MOVSXD RCX,dword ptr [RAX + 0x8]
TEST RCX,RCX
JLE 0x0013ebc2
MOV RDX,qword ptr [R14 + 0x48]
MOV RSI,qword ptr [R14 + 0x78]
XOR EDI,EDI
LAB_0013eb4e:
CMP word ptr [RDX + RDI*0x2],0x2
JC 0x0013ebba
MOV R9,qword ptr [RAX + 0x108]
MOVSXD R8,dword ptr [R9 + RDI*0x8]
TEST R8,R8
JLE 0x0013ebba
MOVSXD R11,dword ptr [R9 + RDI*0x8 + 0x4]
LEA R9,[R11*0x4]
ADD R9,qword ptr [RAX + 0x120]
LEA R10,[R11 + R11*0x1]
ADD R10,qword ptr [RAX + 0x138]
LEA R11,[RSI + R11*0x2]
MOV R14,qword ptr [RBX]
XOR R15D,R15D
LAB_0013eb8e:
MOVZX EBP,word ptr [R11 + R15*0x2]
TEST BP,BP
JZ 0x0013ebb2
MOVSXD R12,dword ptr [R9 + R15*0x4]
MOV R13,qword ptr [RAX + 0x18]
MOVSXD R12,dword ptr [R13 + R12*0x8 + 0x4]
MOVZX R13D,word ptr [R10 + R15*0x2]
ADD R13,R12
MOV word ptr [R14 + R13*0x2],BP
LAB_0013ebb2:
INC R15
CMP R8,R15
JNZ 0x0013eb8e
LAB_0013ebba:
INC RDI
CMP RDI,RCX
JNZ 0x0013eb4e
LAB_0013ebc2:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::buildFaceVertexSiblingsFromVertexFaceSiblings(std::vector<unsigned
short, std::allocator<unsigned short> >&) const */
void __thiscall
OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::buildFaceVertexSiblingsFromVertexFaceSiblings
(FVarLevel *this,vector *param_1)
{
short sVar1;
int iVar2;
long lVar3;
long lVar4;
long lVar5;
long lVar6;
long lVar7;
long lVar8;
long lVar9;
long lVar10;
long lVar11;
long lVar12;
std::vector<unsigned_short,std::allocator<unsigned_short>>::resize
((vector<unsigned_short,std::allocator<unsigned_short>> *)param_1,
(long)(int)((ulong)(*(long *)(*(long *)this + 0x38) - *(long *)(*(long *)this + 0x30))
>> 2));
memset(*(void **)param_1,0,
(*(long *)(*(long *)this + 0x38) - *(long *)(*(long *)this + 0x30)) * 0x40000000 >> 0x1f &
0xfffffffffffffffe);
lVar3 = *(long *)this;
iVar2 = *(int *)(lVar3 + 8);
if (0 < (long)iVar2) {
lVar4 = *(long *)(this + 0x48);
lVar5 = *(long *)(this + 0x78);
lVar9 = 0;
do {
if (1 < *(ushort *)(lVar4 + lVar9 * 2)) {
lVar10 = (long)*(int *)(*(long *)(lVar3 + 0x108) + lVar9 * 8);
if (0 < lVar10) {
lVar11 = (long)*(int *)(*(long *)(lVar3 + 0x108) + 4 + lVar9 * 8);
lVar6 = *(long *)(lVar3 + 0x120);
lVar7 = *(long *)(lVar3 + 0x138);
lVar8 = *(long *)param_1;
lVar12 = 0;
do {
sVar1 = *(short *)(lVar5 + lVar11 * 2 + lVar12 * 2);
if (sVar1 != 0) {
*(short *)(lVar8 + ((ulong)*(ushort *)(lVar11 * 2 + lVar7 + lVar12 * 2) +
(long)*(int *)(*(long *)(lVar3 + 0x18) + 4 +
(long)*(int *)(lVar11 * 4 + lVar6 + lVar12 * 4) * 8))
* 2) = sVar1;
}
lVar12 = lVar12 + 1;
} while (lVar10 != lVar12);
}
}
lVar9 = lVar9 + 1;
} while (lVar9 != iVar2);
}
return;
}
|
|
19,815
|
my_wildcmp_unicode_impl
|
eloqsql/strings/ctype-utf8.c
|
static
int my_wildcmp_unicode_impl(CHARSET_INFO *cs,
const char *str,const char *str_end,
const char *wildstr,const char *wildend,
int escape, int w_one, int w_many,
MY_UNICASE_INFO *weights, int recurse_level)
{
int result= -1; /* Not found, using wildcards */
my_wc_t s_wc, w_wc;
int scan;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
if (my_string_stack_guard && my_string_stack_guard(recurse_level))
return 1;
while (wildstr != wildend)
{
while (1)
{
my_bool escaped= 0;
if ((scan= mb_wc(cs, &w_wc, (const uchar*)wildstr,
(const uchar*)wildend)) <= 0)
return 1;
if (w_wc == (my_wc_t) w_many)
{
result= 1; /* Found an anchor char */
break;
}
wildstr+= scan;
if (w_wc == (my_wc_t) escape && wildstr < wildend)
{
if ((scan= mb_wc(cs, &w_wc, (const uchar*)wildstr,
(const uchar*)wildend)) <= 0)
return 1;
wildstr+= scan;
escaped= 1;
}
if ((scan= mb_wc(cs, &s_wc, (const uchar*)str,
(const uchar*)str_end)) <= 0)
return 1;
str+= scan;
if (!escaped && w_wc == (my_wc_t) w_one)
{
result= 1; /* Found an anchor char */
}
else
{
if (weights)
{
my_tosort_unicode(weights, &s_wc, cs->state);
my_tosort_unicode(weights, &w_wc, cs->state);
}
if (s_wc != w_wc)
return 1; /* No match */
}
if (wildstr == wildend)
return (str != str_end); /* Match if both are at end */
}
if (w_wc == (my_wc_t) w_many)
{ /* Found w_many */
/* Remove any '%' and '_' from the wild search string */
for ( ; wildstr != wildend ; )
{
if ((scan= mb_wc(cs, &w_wc, (const uchar*)wildstr,
(const uchar*)wildend)) <= 0)
return 1;
if (w_wc == (my_wc_t) w_many)
{
wildstr+= scan;
continue;
}
if (w_wc == (my_wc_t) w_one)
{
wildstr+= scan;
if ((scan= mb_wc(cs, &s_wc, (const uchar*)str,
(const uchar*)str_end)) <= 0)
return 1;
str+= scan;
continue;
}
break; /* Not a wild character */
}
if (wildstr == wildend)
return 0; /* Ok if w_many is last */
if (str == str_end)
return -1;
if ((scan= mb_wc(cs, &w_wc, (const uchar*)wildstr,
(const uchar*)wildend)) <= 0)
return 1;
wildstr+= scan;
if (w_wc == (my_wc_t) escape)
{
if (wildstr < wildend)
{
if ((scan= mb_wc(cs, &w_wc, (const uchar*)wildstr,
(const uchar*)wildend)) <= 0)
return 1;
wildstr+= scan;
}
}
while (1)
{
/* Skip until the first character from wildstr is found */
while (str != str_end)
{
if ((scan= mb_wc(cs, &s_wc, (const uchar*)str,
(const uchar*)str_end)) <= 0)
return 1;
if (weights)
{
my_tosort_unicode(weights, &s_wc, cs->state);
my_tosort_unicode(weights, &w_wc, cs->state);
}
if (s_wc == w_wc)
break;
str+= scan;
}
if (str == str_end)
return -1;
str+= scan;
result= my_wildcmp_unicode_impl(cs, str, str_end, wildstr, wildend,
escape, w_one, w_many,
weights, recurse_level + 1);
if (result <= 0)
return result;
}
}
}
return (str != str_end ? 1 : 0);
}
|
O3
|
c
|
my_wildcmp_unicode_impl:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r9d, -0x54(%rbp)
movq %r8, %r12
movq %rcx, %r13
movq %rdx, -0x50(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdi, %r15
movl 0x28(%rbp), %eax
movq %rax, -0x60(%rbp)
movq 0xb8(%rdi), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
leaq 0xb3d7bf(%rip), %rax # 0xc08998
movq (%rax), %rax
testq %rax, %rax
je 0xcb1f3
movl 0x28(%rbp), %edi
callq *%rax
movl $0x1, %ebx
testl %eax, %eax
jne 0xcb583
cmpq %r12, %r13
je 0xcb382
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %ecx
cltq
movq %rax, -0x78(%rbp)
movslq -0x54(%rbp), %rax
movq %rax, -0x70(%rbp)
movslq %ecx, %rax
movq %rax, -0x68(%rbp)
movq %r15, %rdi
leaq -0x30(%rbp), %rsi
movq %r13, %rdx
movq %r12, %rcx
movq -0x40(%rbp), %r14
callq *%r14
testl %eax, %eax
jle 0xcb57e
movq -0x30(%rbp), %rcx
cmpq -0x78(%rbp), %rcx
je 0xcb394
movl %eax, %eax
addq %rax, %r13
cmpq -0x70(%rbp), %rcx
jne 0xcb29a
cmpq %r12, %r13
jae 0xcb29a
movq %r15, %rdi
leaq -0x30(%rbp), %rsi
movq %r13, %rdx
movq %r12, %rcx
callq *%r14
testl %eax, %eax
jle 0xcb57e
movl %eax, %ebx
movq %r15, %rdi
leaq -0x48(%rbp), %rsi
movq %r14, %rax
movq -0x38(%rbp), %r14
movq %r14, %rdx
movq -0x50(%rbp), %rcx
callq *%rax
testl %eax, %eax
jle 0xcb57e
movl %ebx, %ecx
addq %rcx, %r13
movl %eax, %eax
addq %rax, %r14
movq %r14, -0x38(%rbp)
jmp 0xcb2ce
movq %r15, %rdi
leaq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rbx
movq %rbx, %rdx
movq -0x50(%rbp), %rcx
callq *%r14
testl %eax, %eax
jle 0xcb57e
movl %eax, %eax
addq %rax, %rbx
movq %rbx, -0x38(%rbp)
movq -0x68(%rbp), %rax
cmpq %rax, -0x30(%rbp)
je 0xcb379
movq -0x48(%rbp), %rax
movq 0x20(%rbp), %r8
testq %r8, %r8
je 0xcb367
movl 0xc(%r15), %ecx
movq (%r8), %rdx
movl $0xfffd, %esi # imm = 0xFFFD
cmpq %rdx, %rax
ja 0xcb31c
movq 0x8(%r8), %rsi
movq %rax, %rdi
shrq $0x8, %rdi
movq (%rsi,%rdi,8), %rsi
testq %rsi, %rsi
je 0xcb323
xorl %edi, %edi
testw %cx, %cx
setns %dil
movzbl %al, %eax
leaq (%rax,%rax,2), %rax
leaq (%rsi,%rax,4), %rax
movl 0x4(%rax,%rdi,4), %esi
movq %rsi, -0x48(%rbp)
movq %rsi, %rax
movq -0x30(%rbp), %rsi
movl $0xfffd, %edi # imm = 0xFFFD
cmpq %rdx, %rsi
ja 0xcb35e
movq 0x8(%r8), %rdx
movq %rsi, %rdi
shrq $0x8, %rdi
movq (%rdx,%rdi,8), %rdx
testq %rdx, %rdx
je 0xcb36b
xorl %edi, %edi
testw %cx, %cx
setns %dil
movzbl %sil, %ecx
leaq (%rcx,%rcx,2), %rcx
leaq (%rdx,%rcx,4), %rcx
movl 0x4(%rcx,%rdi,4), %edi
movq %rdi, -0x30(%rbp)
movq %rdi, %rsi
jmp 0xcb36b
movq -0x30(%rbp), %rsi
movl $0x1, %ebx
cmpq %rsi, %rax
jne 0xcb583
cmpq %r12, %r13
jne 0xcb217
xorl %ebx, %ebx
movq -0x50(%rbp), %rax
cmpq %rax, -0x38(%rbp)
setne %bl
jmp 0xcb583
xorl %ebx, %ebx
cmpq %r12, %r13
je 0xcb583
movq %r15, %rdi
leaq -0x30(%rbp), %rsi
movq %r13, %rdx
movq %r12, %rcx
callq *%r14
testl %eax, %eax
jle 0xcb57e
movl %eax, %r14d
movq -0x30(%rbp), %rax
cmpq -0x78(%rbp), %rax
jne 0xcb3d8
movl %r14d, %eax
addq %rax, %r13
cmpq %r12, %r13
movq -0x40(%rbp), %r14
jne 0xcb39f
jmp 0xcb583
cmpq -0x68(%rbp), %rax
jne 0xcb406
movq %r15, %rdi
leaq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x50(%rbp), %rcx
callq *-0x40(%rbp)
testl %eax, %eax
jle 0xcb57e
movl %r14d, %ecx
addq %rcx, %r13
movl %eax, %eax
addq %rax, -0x38(%rbp)
jmp 0xcb3ca
movq -0x50(%rbp), %r14
cmpq %r14, -0x38(%rbp)
je 0xcb594
leaq -0x30(%rbp), %rsi
movq %r15, %rdi
movq %r13, %rdx
movq %r12, %rcx
callq *-0x40(%rbp)
testl %eax, %eax
jle 0xcb57e
movl %eax, %eax
addq %rax, %r13
movq -0x70(%rbp), %rax
cmpq %rax, -0x30(%rbp)
jne 0xcb45d
cmpq %r12, %r13
jae 0xcb45d
leaq -0x30(%rbp), %rsi
movq %r15, %rdi
movq %r13, %rdx
movq %r12, %rcx
callq *-0x40(%rbp)
testl %eax, %eax
jle 0xcb57e
movl %eax, %eax
addq %rax, %r13
movq -0x60(%rbp), %rax
incl %eax
movq %rax, -0x60(%rbp)
movq -0x38(%rbp), %rbx
cmpq %r14, %rbx
je 0xcb594
movq %r15, %rdi
leaq -0x48(%rbp), %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq *-0x40(%rbp)
testl %eax, %eax
jle 0xcb57e
movq -0x48(%rbp), %rcx
movq 0x20(%rbp), %rsi
testq %rsi, %rsi
je 0xcb532
movl 0xc(%r15), %edx
movq (%rsi), %rsi
movl $0xfffd, %edi # imm = 0xFFFD
cmpq %rsi, %rcx
ja 0xcb4e0
movq 0x20(%rbp), %rdi
movq 0x8(%rdi), %rdi
movq %rcx, %r8
shrq $0x8, %r8
movq (%rdi,%r8,8), %rdi
testq %rdi, %rdi
je 0xcb4e7
xorl %r8d, %r8d
testw %dx, %dx
setns %r8b
movzbl %cl, %ecx
leaq (%rcx,%rcx,2), %rcx
leaq (%rdi,%rcx,4), %rcx
movl 0x4(%rcx,%r8,4), %edi
movq %rdi, -0x48(%rbp)
movq %rdi, %rcx
movq -0x30(%rbp), %rdi
movl $0xfffd, %r8d # imm = 0xFFFD
cmpq %rsi, %rdi
ja 0xcb529
movq 0x20(%rbp), %rsi
movq 0x8(%rsi), %rsi
movq %rdi, %r8
shrq $0x8, %r8
movq (%rsi,%r8,8), %rsi
testq %rsi, %rsi
je 0xcb536
xorl %r8d, %r8d
testw %dx, %dx
setns %r8b
movzbl %dil, %edx
leaq (%rdx,%rdx,2), %rdx
leaq (%rsi,%rdx,4), %rdx
movl 0x4(%rdx,%r8,4), %r8d
movq %r8, -0x30(%rbp)
movq %r8, %rdi
jmp 0xcb536
movq -0x30(%rbp), %rdi
movl %eax, %eax
addq %rax, %rbx
cmpq %rdi, %rcx
jne 0xcb46b
movq %r15, %rdi
movq %rbx, -0x38(%rbp)
movq %rbx, %rsi
movq %r14, %rdx
movq %r13, %rcx
movq %r12, %r8
movl -0x54(%rbp), %r9d
pushq -0x60(%rbp)
pushq 0x20(%rbp)
movl 0x18(%rbp), %eax
pushq %rax
movl 0x10(%rbp), %eax
pushq %rax
callq 0xcb196
addq $0x20, %rsp
movl %eax, %ebx
testl %eax, %eax
jg 0xcb467
jmp 0xcb583
movl $0x1, %ebx
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
jmp 0xcb583
|
my_wildcmp_unicode_impl:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov [rbp+var_54], r9d
mov r12, r8
mov r13, rcx
mov [rbp+var_50], rdx
mov [rbp+var_38], rsi
mov r15, rdi
mov eax, [rbp+arg_18]
mov [rbp+var_60], rax
mov rax, [rdi+0B8h]
mov rax, [rax+28h]
mov [rbp+var_40], rax
lea rax, my_string_stack_guard
mov rax, [rax]
test rax, rax
jz short loc_CB1F3
mov edi, [rbp+arg_18]
call rax
mov ebx, 1
test eax, eax
jnz loc_CB583
loc_CB1F3:
cmp r13, r12
jz loc_CB382
mov eax, [rbp+arg_8]
mov ecx, [rbp+arg_0]
cdqe
mov [rbp+var_78], rax
movsxd rax, [rbp+var_54]
mov [rbp+var_70], rax
movsxd rax, ecx
mov [rbp+var_68], rax
loc_CB217:
mov rdi, r15
lea rsi, [rbp+var_30]
mov rdx, r13
mov rcx, r12
mov r14, [rbp+var_40]
call r14
test eax, eax
jle loc_CB57E
mov rcx, [rbp+var_30]
cmp rcx, [rbp+var_78]
jz loc_CB394
mov eax, eax
add r13, rax
cmp rcx, [rbp+var_70]
jnz short loc_CB29A
cmp r13, r12
jnb short loc_CB29A
mov rdi, r15
lea rsi, [rbp+var_30]
mov rdx, r13
mov rcx, r12
call r14
test eax, eax
jle loc_CB57E
mov ebx, eax
mov rdi, r15
lea rsi, [rbp+var_48]
mov rax, r14
mov r14, [rbp+var_38]
mov rdx, r14
mov rcx, [rbp+var_50]
call rax
test eax, eax
jle loc_CB57E
mov ecx, ebx
add r13, rcx
mov eax, eax
add r14, rax
mov [rbp+var_38], r14
jmp short loc_CB2CE
loc_CB29A:
mov rdi, r15
lea rsi, [rbp+var_48]
mov rbx, [rbp+var_38]
mov rdx, rbx
mov rcx, [rbp+var_50]
call r14
test eax, eax
jle loc_CB57E
mov eax, eax
add rbx, rax
mov [rbp+var_38], rbx
mov rax, [rbp+var_68]
cmp [rbp+var_30], rax
jz loc_CB379
loc_CB2CE:
mov rax, [rbp+var_48]
mov r8, [rbp+arg_10]
test r8, r8
jz loc_CB367
mov ecx, [r15+0Ch]
mov rdx, [r8]
mov esi, 0FFFDh
cmp rax, rdx
ja short loc_CB31C
mov rsi, [r8+8]
mov rdi, rax
shr rdi, 8
mov rsi, [rsi+rdi*8]
test rsi, rsi
jz short loc_CB323
xor edi, edi
test cx, cx
setns dil
movzx eax, al
lea rax, [rax+rax*2]
lea rax, [rsi+rax*4]
mov esi, [rax+rdi*4+4]
loc_CB31C:
mov [rbp+var_48], rsi
mov rax, rsi
loc_CB323:
mov rsi, [rbp+var_30]
mov edi, 0FFFDh
cmp rsi, rdx
ja short loc_CB35E
mov rdx, [r8+8]
mov rdi, rsi
shr rdi, 8
mov rdx, [rdx+rdi*8]
test rdx, rdx
jz short loc_CB36B
xor edi, edi
test cx, cx
setns dil
movzx ecx, sil
lea rcx, [rcx+rcx*2]
lea rcx, [rdx+rcx*4]
mov edi, [rcx+rdi*4+4]
loc_CB35E:
mov [rbp+var_30], rdi
mov rsi, rdi
jmp short loc_CB36B
loc_CB367:
mov rsi, [rbp+var_30]
loc_CB36B:
mov ebx, 1
cmp rax, rsi
jnz loc_CB583
loc_CB379:
cmp r13, r12
jnz loc_CB217
loc_CB382:
xor ebx, ebx
mov rax, [rbp+var_50]
cmp [rbp+var_38], rax
setnz bl
jmp loc_CB583
loc_CB394:
xor ebx, ebx
cmp r13, r12
jz loc_CB583
loc_CB39F:
mov rdi, r15
lea rsi, [rbp+var_30]
mov rdx, r13
mov rcx, r12
call r14
test eax, eax
jle loc_CB57E
mov r14d, eax
mov rax, [rbp+var_30]
cmp rax, [rbp+var_78]
jnz short loc_CB3D8
mov eax, r14d
add r13, rax
loc_CB3CA:
cmp r13, r12
mov r14, [rbp+var_40]
jnz short loc_CB39F
jmp loc_CB583
loc_CB3D8:
cmp rax, [rbp+var_68]
jnz short loc_CB406
mov rdi, r15
lea rsi, [rbp+var_48]
mov rdx, [rbp+var_38]
mov rcx, [rbp+var_50]
call [rbp+var_40]
test eax, eax
jle loc_CB57E
mov ecx, r14d
add r13, rcx
mov eax, eax
add [rbp+var_38], rax
jmp short loc_CB3CA
loc_CB406:
mov r14, [rbp+var_50]
cmp [rbp+var_38], r14
jz loc_CB594
lea rsi, [rbp+var_30]
mov rdi, r15
mov rdx, r13
mov rcx, r12
call [rbp+var_40]
test eax, eax
jle loc_CB57E
mov eax, eax
add r13, rax
mov rax, [rbp+var_70]
cmp [rbp+var_30], rax
jnz short loc_CB45D
cmp r13, r12
jnb short loc_CB45D
lea rsi, [rbp+var_30]
mov rdi, r15
mov rdx, r13
mov rcx, r12
call [rbp+var_40]
test eax, eax
jle loc_CB57E
mov eax, eax
add r13, rax
loc_CB45D:
mov rax, [rbp+var_60]
inc eax
mov [rbp+var_60], rax
loc_CB467:
mov rbx, [rbp+var_38]
loc_CB46B:
cmp rbx, r14
jz loc_CB594
mov rdi, r15
lea rsi, [rbp+var_48]
mov rdx, rbx
mov rcx, r14
call [rbp+var_40]
test eax, eax
jle loc_CB57E
mov rcx, [rbp+var_48]
mov rsi, [rbp+arg_10]
test rsi, rsi
jz loc_CB532
mov edx, [r15+0Ch]
mov rsi, [rsi]
mov edi, 0FFFDh
cmp rcx, rsi
ja short loc_CB4E0
mov rdi, [rbp+arg_10]
mov rdi, [rdi+8]
mov r8, rcx
shr r8, 8
mov rdi, [rdi+r8*8]
test rdi, rdi
jz short loc_CB4E7
xor r8d, r8d
test dx, dx
setns r8b
movzx ecx, cl
lea rcx, [rcx+rcx*2]
lea rcx, [rdi+rcx*4]
mov edi, [rcx+r8*4+4]
loc_CB4E0:
mov [rbp+var_48], rdi
mov rcx, rdi
loc_CB4E7:
mov rdi, [rbp+var_30]
mov r8d, 0FFFDh
cmp rdi, rsi
ja short loc_CB529
mov rsi, [rbp+arg_10]
mov rsi, [rsi+8]
mov r8, rdi
shr r8, 8
mov rsi, [rsi+r8*8]
test rsi, rsi
jz short loc_CB536
xor r8d, r8d
test dx, dx
setns r8b
movzx edx, dil
lea rdx, [rdx+rdx*2]
lea rdx, [rsi+rdx*4]
mov r8d, [rdx+r8*4+4]
loc_CB529:
mov [rbp+var_30], r8
mov rdi, r8
jmp short loc_CB536
loc_CB532:
mov rdi, [rbp+var_30]
loc_CB536:
mov eax, eax
add rbx, rax
cmp rcx, rdi
jnz loc_CB46B
mov rdi, r15
mov [rbp+var_38], rbx
mov rsi, rbx
mov rdx, r14
mov rcx, r13
mov r8, r12
mov r9d, [rbp+var_54]
push [rbp+var_60]
push [rbp+arg_10]
mov eax, [rbp+arg_8]
push rax
mov eax, [rbp+arg_0]
push rax
call my_wildcmp_unicode_impl
add rsp, 20h
mov ebx, eax
test eax, eax
jg loc_CB467
jmp short loc_CB583
loc_CB57E:
mov ebx, 1
loc_CB583:
mov eax, ebx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_CB594:
mov ebx, 0FFFFFFFFh
jmp short loc_CB583
|
long long my_wildcmp_unicode_impl(
long long a1,
long long a2,
unsigned long long a3,
unsigned long long a4,
unsigned long long a5,
int a6,
int a7,
int a8,
unsigned long long *a9,
unsigned int a10)
{
unsigned int v13; // ebx
long long ( *v14)(long long, unsigned __int8 *, unsigned long long, unsigned long long); // r14
int v15; // eax
int v16; // eax
unsigned int v17; // ebx
long long ( *v18)(long long, unsigned long long *, long long, long long); // rax
long long v19; // r14
int v20; // eax
long long v21; // rbx
int v22; // eax
long long v23; // rax
int v24; // ecx
unsigned long long v25; // rdx
long long v26; // rsi
long long v27; // rsi
long long v28; // rsi
long long v29; // rdi
long long v30; // rdx
int v31; // eax
unsigned int v32; // r14d
int v33; // eax
int v34; // eax
unsigned long long v35; // r13
int v36; // eax
unsigned long long v37; // rbx
int v38; // eax
long long v39; // rcx
int v40; // edx
unsigned long long v41; // rsi
long long v42; // rdi
long long v43; // rdi
long long v44; // rdi
long long v45; // r8
long long v46; // rsi
unsigned long long v50; // [rsp+38h] [rbp-48h] BYREF
long long ( *v51)(long long, unsigned __int8 *, unsigned long long, unsigned long long); // [rsp+40h] [rbp-40h]
long long v52; // [rsp+48h] [rbp-38h]
unsigned __int8 v53[48]; // [rsp+50h] [rbp-30h] BYREF
v52 = a2;
v51 = *(long long ( **)(long long, unsigned __int8 *, unsigned long long, unsigned long long))(*(_QWORD *)(a1 + 184)
+ 40LL);
if ( my_string_stack_guard )
{
v13 = 1;
if ( (unsigned int)my_string_stack_guard(a10) )
return v13;
}
if ( a4 == a5 )
return v52 != a3;
while ( 1 )
{
v14 = v51;
v15 = v51(a1, v53, a4, a5);
if ( v15 <= 0 )
return 1;
if ( *(_QWORD *)v53 == a8 )
break;
a4 += (unsigned int)v15;
if ( *(_QWORD *)v53 == a6 && a4 < a5 )
{
v16 = v14(a1, v53, a4, a5);
if ( v16 <= 0 )
return 1;
v17 = v16;
v18 = (long long ( *)(long long, unsigned long long *, long long, long long))v14;
v19 = v52;
v20 = v18(a1, &v50, v52, a3);
if ( v20 <= 0 )
return 1;
a4 += v17;
v52 = (unsigned int)v20 + v19;
LABEL_13:
v23 = v50;
if ( a9 )
{
v24 = *(_DWORD *)(a1 + 12);
v25 = *a9;
v26 = 65533LL;
if ( v50 > *a9 )
goto LABEL_17;
v27 = *(_QWORD *)(a9[1] + 8 * (v50 >> 8));
if ( v27 )
{
v26 = *(unsigned int *)(v27 + 12LL * (unsigned __int8)v50 + 4LL * ((v24 & 0x8000u) == 0) + 4);
LABEL_17:
v50 = v26;
v23 = v26;
}
v28 = *(_QWORD *)v53;
v29 = 65533LL;
if ( *(_QWORD *)v53 > v25 )
{
LABEL_21:
*(_QWORD *)v53 = v29;
v28 = v29;
}
else
{
v30 = *(_QWORD *)(a9[1] + 8LL * (*(_QWORD *)v53 >> 8));
if ( v30 )
{
v29 = *(unsigned int *)(v30 + 12LL * v53[0] + 4LL * ((v24 & 0x8000u) == 0) + 4);
goto LABEL_21;
}
}
}
else
{
v28 = *(_QWORD *)v53;
}
v13 = 1;
if ( v23 != v28 )
return v13;
goto LABEL_24;
}
v21 = v52;
v22 = v14(a1, (unsigned __int8 *)&v50, v52, a3);
if ( v22 <= 0 )
return 1;
v52 = (unsigned int)v22 + v21;
if ( *(_QWORD *)v53 != a7 )
goto LABEL_13;
LABEL_24:
if ( a4 == a5 )
return v52 != a3;
}
v13 = 0;
if ( a4 == a5 )
return v13;
while ( 2 )
{
v31 = v14(a1, v53, a4, a5);
if ( v31 <= 0 )
return 1;
v32 = v31;
if ( *(_QWORD *)v53 == a8 )
{
a4 += (unsigned int)v31;
LABEL_30:
v14 = v51;
if ( a4 == a5 )
return v13;
continue;
}
break;
}
if ( *(_QWORD *)v53 == a7 )
{
v33 = v51(a1, (unsigned __int8 *)&v50, v52, a3);
if ( v33 <= 0 )
return 1;
a4 += v32;
v52 += (unsigned int)v33;
goto LABEL_30;
}
if ( v52 == a3 )
return (unsigned int)-1;
v34 = v51(a1, v53, a4, a5);
if ( v34 <= 0 )
return 1;
v35 = (unsigned int)v34 + a4;
if ( *(_QWORD *)v53 != a6 || v35 >= a5 )
{
LABEL_41:
v37 = v52;
while ( 1 )
{
if ( v37 == a3 )
return (unsigned int)-1;
v38 = v51(a1, (unsigned __int8 *)&v50, v37, a3);
if ( v38 <= 0 )
return 1;
v39 = v50;
if ( !a9 )
{
v44 = *(_QWORD *)v53;
goto LABEL_54;
}
v40 = *(_DWORD *)(a1 + 12);
v41 = *a9;
v42 = 65533LL;
if ( v50 <= *a9 )
{
v43 = *(_QWORD *)(a9[1] + 8 * (v50 >> 8));
if ( !v43 )
goto LABEL_49;
v42 = *(unsigned int *)(v43 + 12LL * (unsigned __int8)v50 + 4LL * ((v40 & 0x8000u) == 0) + 4);
}
v50 = v42;
v39 = v42;
LABEL_49:
v44 = *(_QWORD *)v53;
v45 = 65533LL;
if ( *(_QWORD *)v53 > v41 )
goto LABEL_52;
v46 = *(_QWORD *)(a9[1] + 8LL * (*(_QWORD *)v53 >> 8));
if ( v46 )
{
v45 = *(unsigned int *)(v46 + 12LL * v53[0] + 4LL * ((v40 & 0x8000u) == 0) + 4);
LABEL_52:
*(_QWORD *)v53 = v45;
v44 = v45;
}
LABEL_54:
v37 += (unsigned int)v38;
if ( v39 == v44 )
{
v52 = v37;
v13 = my_wildcmp_unicode_impl(a1, v37, a3, v35, a5, a6, a7, a8, (long long)a9, a10 + 1);
if ( (int)v13 > 0 )
goto LABEL_41;
return v13;
}
}
}
v36 = v51(a1, v53, v35, a5);
if ( v36 > 0 )
{
LODWORD(v35) = v36 + v35;
goto LABEL_41;
}
return 1;
}
|
my_wildcmp_unicode_impl:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV dword ptr [RBP + -0x54],R9D
MOV R12,R8
MOV R13,RCX
MOV qword ptr [RBP + -0x50],RDX
MOV qword ptr [RBP + -0x38],RSI
MOV R15,RDI
MOV EAX,dword ptr [RBP + 0x28]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RDI + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x40],RAX
LEA RAX,[0xd08998]
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x001cb1f3
MOV EDI,dword ptr [RBP + 0x28]
CALL RAX
MOV EBX,0x1
TEST EAX,EAX
JNZ 0x001cb583
LAB_001cb1f3:
CMP R13,R12
JZ 0x001cb382
MOV EAX,dword ptr [RBP + 0x18]
MOV ECX,dword ptr [RBP + 0x10]
CDQE
MOV qword ptr [RBP + -0x78],RAX
MOVSXD RAX,dword ptr [RBP + -0x54]
MOV qword ptr [RBP + -0x70],RAX
MOVSXD RAX,ECX
MOV qword ptr [RBP + -0x68],RAX
LAB_001cb217:
MOV RDI,R15
LEA RSI,[RBP + -0x30]
MOV RDX,R13
MOV RCX,R12
MOV R14,qword ptr [RBP + -0x40]
CALL R14
TEST EAX,EAX
JLE 0x001cb57e
MOV RCX,qword ptr [RBP + -0x30]
CMP RCX,qword ptr [RBP + -0x78]
JZ 0x001cb394
MOV EAX,EAX
ADD R13,RAX
CMP RCX,qword ptr [RBP + -0x70]
JNZ 0x001cb29a
CMP R13,R12
JNC 0x001cb29a
MOV RDI,R15
LEA RSI,[RBP + -0x30]
MOV RDX,R13
MOV RCX,R12
CALL R14
TEST EAX,EAX
JLE 0x001cb57e
MOV EBX,EAX
MOV RDI,R15
LEA RSI,[RBP + -0x48]
MOV RAX,R14
MOV R14,qword ptr [RBP + -0x38]
MOV RDX,R14
MOV RCX,qword ptr [RBP + -0x50]
CALL RAX
TEST EAX,EAX
JLE 0x001cb57e
MOV ECX,EBX
ADD R13,RCX
MOV EAX,EAX
ADD R14,RAX
MOV qword ptr [RBP + -0x38],R14
JMP 0x001cb2ce
LAB_001cb29a:
MOV RDI,R15
LEA RSI,[RBP + -0x48]
MOV RBX,qword ptr [RBP + -0x38]
MOV RDX,RBX
MOV RCX,qword ptr [RBP + -0x50]
CALL R14
TEST EAX,EAX
JLE 0x001cb57e
MOV EAX,EAX
ADD RBX,RAX
MOV qword ptr [RBP + -0x38],RBX
MOV RAX,qword ptr [RBP + -0x68]
CMP qword ptr [RBP + -0x30],RAX
JZ 0x001cb379
LAB_001cb2ce:
MOV RAX,qword ptr [RBP + -0x48]
MOV R8,qword ptr [RBP + 0x20]
TEST R8,R8
JZ 0x001cb367
MOV ECX,dword ptr [R15 + 0xc]
MOV RDX,qword ptr [R8]
MOV ESI,0xfffd
CMP RAX,RDX
JA 0x001cb31c
MOV RSI,qword ptr [R8 + 0x8]
MOV RDI,RAX
SHR RDI,0x8
MOV RSI,qword ptr [RSI + RDI*0x8]
TEST RSI,RSI
JZ 0x001cb323
XOR EDI,EDI
TEST CX,CX
SETNS DIL
MOVZX EAX,AL
LEA RAX,[RAX + RAX*0x2]
LEA RAX,[RSI + RAX*0x4]
MOV ESI,dword ptr [RAX + RDI*0x4 + 0x4]
LAB_001cb31c:
MOV qword ptr [RBP + -0x48],RSI
MOV RAX,RSI
LAB_001cb323:
MOV RSI,qword ptr [RBP + -0x30]
MOV EDI,0xfffd
CMP RSI,RDX
JA 0x001cb35e
MOV RDX,qword ptr [R8 + 0x8]
MOV RDI,RSI
SHR RDI,0x8
MOV RDX,qword ptr [RDX + RDI*0x8]
TEST RDX,RDX
JZ 0x001cb36b
XOR EDI,EDI
TEST CX,CX
SETNS DIL
MOVZX ECX,SIL
LEA RCX,[RCX + RCX*0x2]
LEA RCX,[RDX + RCX*0x4]
MOV EDI,dword ptr [RCX + RDI*0x4 + 0x4]
LAB_001cb35e:
MOV qword ptr [RBP + -0x30],RDI
MOV RSI,RDI
JMP 0x001cb36b
LAB_001cb367:
MOV RSI,qword ptr [RBP + -0x30]
LAB_001cb36b:
MOV EBX,0x1
CMP RAX,RSI
JNZ 0x001cb583
LAB_001cb379:
CMP R13,R12
JNZ 0x001cb217
LAB_001cb382:
XOR EBX,EBX
MOV RAX,qword ptr [RBP + -0x50]
CMP qword ptr [RBP + -0x38],RAX
SETNZ BL
JMP 0x001cb583
LAB_001cb394:
XOR EBX,EBX
CMP R13,R12
JZ 0x001cb583
LAB_001cb39f:
MOV RDI,R15
LEA RSI,[RBP + -0x30]
MOV RDX,R13
MOV RCX,R12
CALL R14
TEST EAX,EAX
JLE 0x001cb57e
MOV R14D,EAX
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x78]
JNZ 0x001cb3d8
MOV EAX,R14D
ADD R13,RAX
LAB_001cb3ca:
CMP R13,R12
MOV R14,qword ptr [RBP + -0x40]
JNZ 0x001cb39f
JMP 0x001cb583
LAB_001cb3d8:
CMP RAX,qword ptr [RBP + -0x68]
JNZ 0x001cb406
MOV RDI,R15
LEA RSI,[RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x50]
CALL qword ptr [RBP + -0x40]
TEST EAX,EAX
JLE 0x001cb57e
MOV ECX,R14D
ADD R13,RCX
MOV EAX,EAX
ADD qword ptr [RBP + -0x38],RAX
JMP 0x001cb3ca
LAB_001cb406:
MOV R14,qword ptr [RBP + -0x50]
CMP qword ptr [RBP + -0x38],R14
JZ 0x001cb594
LEA RSI,[RBP + -0x30]
MOV RDI,R15
MOV RDX,R13
MOV RCX,R12
CALL qword ptr [RBP + -0x40]
TEST EAX,EAX
JLE 0x001cb57e
MOV EAX,EAX
ADD R13,RAX
MOV RAX,qword ptr [RBP + -0x70]
CMP qword ptr [RBP + -0x30],RAX
JNZ 0x001cb45d
CMP R13,R12
JNC 0x001cb45d
LEA RSI,[RBP + -0x30]
MOV RDI,R15
MOV RDX,R13
MOV RCX,R12
CALL qword ptr [RBP + -0x40]
TEST EAX,EAX
JLE 0x001cb57e
MOV EAX,EAX
ADD R13,RAX
LAB_001cb45d:
MOV RAX,qword ptr [RBP + -0x60]
INC EAX
MOV qword ptr [RBP + -0x60],RAX
LAB_001cb467:
MOV RBX,qword ptr [RBP + -0x38]
LAB_001cb46b:
CMP RBX,R14
JZ 0x001cb594
MOV RDI,R15
LEA RSI,[RBP + -0x48]
MOV RDX,RBX
MOV RCX,R14
CALL qword ptr [RBP + -0x40]
TEST EAX,EAX
JLE 0x001cb57e
MOV RCX,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + 0x20]
TEST RSI,RSI
JZ 0x001cb532
MOV EDX,dword ptr [R15 + 0xc]
MOV RSI,qword ptr [RSI]
MOV EDI,0xfffd
CMP RCX,RSI
JA 0x001cb4e0
MOV RDI,qword ptr [RBP + 0x20]
MOV RDI,qword ptr [RDI + 0x8]
MOV R8,RCX
SHR R8,0x8
MOV RDI,qword ptr [RDI + R8*0x8]
TEST RDI,RDI
JZ 0x001cb4e7
XOR R8D,R8D
TEST DX,DX
SETNS R8B
MOVZX ECX,CL
LEA RCX,[RCX + RCX*0x2]
LEA RCX,[RDI + RCX*0x4]
MOV EDI,dword ptr [RCX + R8*0x4 + 0x4]
LAB_001cb4e0:
MOV qword ptr [RBP + -0x48],RDI
MOV RCX,RDI
LAB_001cb4e7:
MOV RDI,qword ptr [RBP + -0x30]
MOV R8D,0xfffd
CMP RDI,RSI
JA 0x001cb529
MOV RSI,qword ptr [RBP + 0x20]
MOV RSI,qword ptr [RSI + 0x8]
MOV R8,RDI
SHR R8,0x8
MOV RSI,qword ptr [RSI + R8*0x8]
TEST RSI,RSI
JZ 0x001cb536
XOR R8D,R8D
TEST DX,DX
SETNS R8B
MOVZX EDX,DIL
LEA RDX,[RDX + RDX*0x2]
LEA RDX,[RSI + RDX*0x4]
MOV R8D,dword ptr [RDX + R8*0x4 + 0x4]
LAB_001cb529:
MOV qword ptr [RBP + -0x30],R8
MOV RDI,R8
JMP 0x001cb536
LAB_001cb532:
MOV RDI,qword ptr [RBP + -0x30]
LAB_001cb536:
MOV EAX,EAX
ADD RBX,RAX
CMP RCX,RDI
JNZ 0x001cb46b
MOV RDI,R15
MOV qword ptr [RBP + -0x38],RBX
MOV RSI,RBX
MOV RDX,R14
MOV RCX,R13
MOV R8,R12
MOV R9D,dword ptr [RBP + -0x54]
PUSH qword ptr [RBP + -0x60]
PUSH qword ptr [RBP + 0x20]
MOV EAX,dword ptr [RBP + 0x18]
PUSH RAX
MOV EAX,dword ptr [RBP + 0x10]
PUSH RAX
CALL 0x001cb196
ADD RSP,0x20
MOV EBX,EAX
TEST EAX,EAX
JG 0x001cb467
JMP 0x001cb583
LAB_001cb57e:
MOV EBX,0x1
LAB_001cb583:
MOV EAX,EBX
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001cb594:
MOV EBX,0xffffffff
JMP 0x001cb583
|
uint my_wildcmp_unicode_impl
(long param_1,long param_2,long param_3,ulong param_4,ulong param_5,int param_6,
int param_7,int param_8,ulong *param_9,int param_10)
{
long lVar1;
code *pcVar2;
ulong uVar3;
int iVar4;
uint uVar5;
uint uVar6;
short sVar7;
long lVar8;
ulong local_50;
code *local_48;
long local_40;
ulong local_38;
local_48 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
local_40 = param_2;
if ((my_string_stack_guard != (code *)0x0) &&
(iVar4 = (*my_string_stack_guard)(param_10), iVar4 != 0)) {
return 1;
}
if (param_4 != param_5) {
do {
pcVar2 = local_48;
uVar5 = (*local_48)(param_1,&local_38,param_4,param_5);
lVar8 = local_40;
if ((int)uVar5 < 1) {
return 1;
}
if (local_38 == (long)param_8) {
do {
if (param_4 == param_5) {
return 0;
}
uVar5 = (*pcVar2)(param_1,&local_38,param_4,param_5);
if ((int)uVar5 < 1) {
return 1;
}
if (local_38 != (long)param_8) {
if (local_38 != (long)param_7) {
if (local_40 == param_3) {
return 0xffffffff;
}
uVar5 = (*local_48)(param_1,&local_38,param_4,param_5);
if (0 < (int)uVar5) {
param_4 = param_4 + uVar5;
if ((local_38 == (long)param_6) && (param_4 < param_5)) {
uVar5 = (*local_48)(param_1,&local_38,param_4,param_5);
if ((int)uVar5 < 1) {
return 1;
}
param_4 = param_4 + uVar5;
}
lVar8 = local_40;
while( true ) {
if (lVar8 == param_3) {
return 0xffffffff;
}
uVar5 = (*local_48)(param_1,&local_50,lVar8,param_3);
if ((int)uVar5 < 1) break;
uVar3 = local_38;
if (param_9 != (ulong *)0x0) {
sVar7 = (short)*(int4 *)(param_1 + 0xc);
uVar3 = 0xfffd;
if ((local_50 <= *param_9) &&
(lVar1 = *(long *)(param_9[1] + (local_50 >> 8) * 8), uVar3 = local_50,
lVar1 != 0)) {
uVar3 = (ulong)*(uint *)(lVar1 + (local_50 & 0xff) * 0xc + 4 +
(ulong)(-1 < sVar7) * 4);
}
local_50 = uVar3;
uVar3 = 0xfffd;
if ((local_38 <= *param_9) &&
(lVar1 = *(long *)(param_9[1] + (local_38 >> 8) * 8), uVar3 = local_38,
lVar1 != 0)) {
uVar3 = (ulong)*(uint *)(lVar1 + (local_38 & 0xff) * 0xc + 4 +
(ulong)(-1 < sVar7) * 4);
}
}
local_38 = uVar3;
lVar8 = lVar8 + (ulong)uVar5;
if ((local_50 == local_38) &&
(local_40 = lVar8,
uVar5 = my_wildcmp_unicode_impl
(param_1,lVar8,param_3,param_4,param_5,param_6,param_7,
param_8,param_9,param_10 + 1), lVar8 = local_40,
(int)uVar5 < 1)) {
return uVar5;
}
}
return 1;
}
return 1;
}
uVar6 = (*local_48)(param_1,&local_50,local_40,param_3);
if ((int)uVar6 < 1) {
return 1;
}
local_40 = local_40 + (ulong)uVar6;
}
param_4 = param_4 + uVar5;
pcVar2 = local_48;
} while( true );
}
param_4 = param_4 + uVar5;
if ((local_38 == (long)param_6) && (param_4 < param_5)) {
uVar5 = (*pcVar2)(param_1,&local_38,param_4,param_5);
lVar8 = local_40;
if ((int)uVar5 < 1) {
return 1;
}
uVar6 = (*pcVar2)(param_1,&local_50,local_40,param_3);
if ((int)uVar6 < 1) {
return 1;
}
param_4 = param_4 + uVar5;
local_40 = lVar8 + (ulong)uVar6;
LAB_001cb2ce:
uVar3 = local_38;
if (param_9 != (ulong *)0x0) {
sVar7 = (short)*(int4 *)(param_1 + 0xc);
uVar3 = 0xfffd;
if ((local_50 <= *param_9) &&
(lVar8 = *(long *)(param_9[1] + (local_50 >> 8) * 8), uVar3 = local_50, lVar8 != 0)) {
uVar3 = (ulong)*(uint *)(lVar8 + (local_50 & 0xff) * 0xc + 4 + (ulong)(-1 < sVar7) * 4);
}
local_50 = uVar3;
uVar3 = 0xfffd;
if ((local_38 <= *param_9) &&
(lVar8 = *(long *)(param_9[1] + (local_38 >> 8) * 8), uVar3 = local_38, lVar8 != 0)) {
uVar3 = (ulong)*(uint *)(lVar8 + (local_38 & 0xff) * 0xc + 4 + (ulong)(-1 < sVar7) * 4);
}
}
local_38 = uVar3;
if (local_50 != local_38) {
return 1;
}
}
else {
uVar5 = (*pcVar2)(param_1,&local_50,local_40,param_3);
if ((int)uVar5 < 1) {
return 1;
}
local_40 = lVar8 + (ulong)uVar5;
if (local_38 != (long)param_7) goto LAB_001cb2ce;
}
} while (param_4 != param_5);
}
return (uint)(local_40 != param_3);
}
|
|
19,816
|
get_exported_names
|
bluesky950520[P]quickjs/quickjs.c
|
static __exception int get_exported_names(JSContext *ctx,
GetExportNamesState *s,
JSModuleDef *m, BOOL from_star)
{
ExportedNameEntry *en;
int i, j;
/* check circular reference */
for(i = 0; i < s->modules_count; i++) {
if (s->modules[i] == m)
return 0;
}
if (js_resize_array(ctx, (void **)&s->modules, sizeof(s->modules[0]),
&s->modules_size, s->modules_count + 1))
return -1;
s->modules[s->modules_count++] = m;
for(i = 0; i < m->export_entries_count; i++) {
JSExportEntry *me = &m->export_entries[i];
if (from_star && me->export_name == JS_ATOM_default)
continue;
j = find_exported_name(s, me->export_name);
if (j < 0) {
if (js_resize_array(ctx, (void **)&s->exported_names, sizeof(s->exported_names[0]),
&s->exported_names_size,
s->exported_names_count + 1))
return -1;
en = &s->exported_names[s->exported_names_count++];
en->export_name = me->export_name;
/* avoid a second lookup for simple module exports */
if (from_star || me->export_type != JS_EXPORT_TYPE_LOCAL)
en->u.me = NULL;
else
en->u.me = me;
} else {
en = &s->exported_names[j];
en->u.me = NULL;
}
}
for(i = 0; i < m->star_export_entries_count; i++) {
JSStarExportEntry *se = &m->star_export_entries[i];
JSModuleDef *m1;
m1 = m->req_module_entries[se->req_module_idx].module;
if (get_exported_names(ctx, s, m1, TRUE))
return -1;
}
return 0;
}
|
O2
|
c
|
get_exported_names:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r12d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0xc(%rsi), %r8d
xorl %eax, %eax
testl %r8d, %r8d
movl $0x0, %ecx
cmovgl %r8d, %ecx
cmpq %rax, %rcx
je 0x3ed90
movq (%r14), %rdx
leaq 0x1(%rax), %rsi
cmpq %rbx, (%rdx,%rax,8)
movq %rsi, %rax
jne 0x3ed74
xorl %ecx, %ecx
jmp 0x3eed9
leaq 0x8(%r14), %rcx
incl %r8d
pushq $0x8
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3ec9f
pushq $-0x1
popq %rcx
testl %eax, %eax
jne 0x3eed9
movq %r15, 0x8(%rsp)
movq (%r14), %rax
movslq 0xc(%r14), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0xc(%r14)
movq %rbx, (%rax,%rcx,8)
leaq 0x10(%r14), %r13
leaq 0x18(%r14), %rax
movq %rax, 0x10(%rsp)
xorl %ebp, %ebp
movslq 0x30(%rbx), %rax
cmpq %rax, %rbp
jge 0x3ee93
movq 0x28(%rbx), %r15
movq %rbp, %rcx
shlq $0x5, %rcx
movl 0x18(%r15,%rcx), %eax
testl %r12d, %r12d
je 0x3ee01
cmpl $0x16, %eax
je 0x3ee85
addq %rcx, %r15
movl 0x1c(%r14), %r8d
testl %r8d, %r8d
movl $0x0, %ecx
cmovgl %r8d, %ecx
shlq $0x4, %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x3ee2e
movq (%r13), %rsi
cmpl %eax, (%rsi,%rdx)
je 0x3ee7f
addq $0x10, %rdx
jmp 0x3ee1a
incl %r8d
movq 0x8(%rsp), %rdi
movq %r13, %rsi
pushq $0x10
popq %rdx
movq 0x10(%rsp), %rcx
callq 0x3ec9f
testl %eax, %eax
jne 0x3eed6
movq 0x10(%r14), %rcx
movslq 0x1c(%r14), %rdx
leal 0x1(%rdx), %esi
shlq $0x4, %rdx
leaq (%rcx,%rdx), %rax
movl %esi, 0x1c(%r14)
movl 0x18(%r15), %esi
movl %esi, (%rcx,%rdx)
testl %r12d, %r12d
jne 0x3ee78
cmpl $0x0, 0x10(%r15)
je 0x3ee8d
andq $0x0, 0x8(%rax)
jmp 0x3ee85
andq $0x0, 0x8(%rsi,%rdx)
incq %rbp
jmp 0x3edd6
movq %r15, 0x8(%rax)
jmp 0x3ee85
xorl %r15d, %r15d
pushq $0x1
popq %r12
movq 0x8(%rsp), %r13
movslq 0x40(%rbx), %rax
cmpq %rax, %r15
jge 0x3ed89
movq 0x18(%rbx), %rax
movq 0x38(%rbx), %rcx
movslq (%rcx,%r15,4), %rcx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %rdx
movq %r13, %rdi
movq %r14, %rsi
movl %r12d, %ecx
callq 0x3ed48
incq %r15
testl %eax, %eax
je 0x3ee9f
pushq $-0x1
popq %rcx
movl %ecx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
get_exported_names:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r12d, ecx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov r8d, [rsi+0Ch]
xor eax, eax
test r8d, r8d
mov ecx, 0
cmovg ecx, r8d
loc_3ED74:
cmp rcx, rax
jz short loc_3ED90
mov rdx, [r14]
lea rsi, [rax+1]
cmp [rdx+rax*8], rbx
mov rax, rsi
jnz short loc_3ED74
loc_3ED89:
xor ecx, ecx
jmp loc_3EED9
loc_3ED90:
lea rcx, [r14+8]
inc r8d
push 8
pop rdx
mov rdi, r15
mov rsi, r14
call js_resize_array
push 0FFFFFFFFFFFFFFFFh
pop rcx
test eax, eax
jnz loc_3EED9
mov [rsp+48h+var_40], r15
mov rax, [r14]
movsxd rcx, dword ptr [r14+0Ch]
lea edx, [rcx+1]
mov [r14+0Ch], edx
mov [rax+rcx*8], rbx
lea r13, [r14+10h]
lea rax, [r14+18h]
mov [rsp+48h+var_38], rax
xor ebp, ebp
loc_3EDD6:
movsxd rax, dword ptr [rbx+30h]
cmp rbp, rax
jge loc_3EE93
mov r15, [rbx+28h]
mov rcx, rbp
shl rcx, 5
mov eax, [r15+rcx+18h]
test r12d, r12d
jz short loc_3EE01
cmp eax, 16h
jz loc_3EE85
loc_3EE01:
add r15, rcx
mov r8d, [r14+1Ch]
test r8d, r8d
mov ecx, 0
cmovg ecx, r8d
shl rcx, 4
xor edx, edx
loc_3EE1A:
cmp rcx, rdx
jz short loc_3EE2E
mov rsi, [r13+0]
cmp [rsi+rdx], eax
jz short loc_3EE7F
add rdx, 10h
jmp short loc_3EE1A
loc_3EE2E:
inc r8d
mov rdi, [rsp+48h+var_40]
mov rsi, r13
push 10h
pop rdx
mov rcx, [rsp+48h+var_38]
call js_resize_array
test eax, eax
jnz loc_3EED6
mov rcx, [r14+10h]
movsxd rdx, dword ptr [r14+1Ch]
lea esi, [rdx+1]
shl rdx, 4
lea rax, [rcx+rdx]
mov [r14+1Ch], esi
mov esi, [r15+18h]
mov [rcx+rdx], esi
test r12d, r12d
jnz short loc_3EE78
cmp dword ptr [r15+10h], 0
jz short loc_3EE8D
loc_3EE78:
and qword ptr [rax+8], 0
jmp short loc_3EE85
loc_3EE7F:
and qword ptr [rsi+rdx+8], 0
loc_3EE85:
inc rbp
jmp loc_3EDD6
loc_3EE8D:
mov [rax+8], r15
jmp short loc_3EE85
loc_3EE93:
xor r15d, r15d
push 1
pop r12
mov r13, [rsp+48h+var_40]
loc_3EE9F:
movsxd rax, dword ptr [rbx+40h]
cmp r15, rax
jge loc_3ED89
mov rax, [rbx+18h]
mov rcx, [rbx+38h]
movsxd rcx, dword ptr [rcx+r15*4]
shl rcx, 4
mov rdx, [rax+rcx+8]
mov rdi, r13
mov rsi, r14
mov ecx, r12d
call get_exported_names
inc r15
test eax, eax
jz short loc_3EE9F
loc_3EED6:
push 0FFFFFFFFFFFFFFFFh
pop rcx
loc_3EED9:
mov eax, ecx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long get_exported_names(long long a1, long long a2, long long a3, int a4)
{
int v6; // r8d
long long v7; // rax
long long v8; // rcx
unsigned int v10; // ecx
int v11; // eax
long long v12; // rax
long long v13; // rcx
_QWORD *v14; // r13
long long i; // rbp
long long v16; // r15
int v17; // eax
long long v18; // r15
int v19; // r8d
long long v20; // rcx
long long v21; // rcx
long long j; // rdx
long long v23; // rdx
long long v24; // rax
long long v25; // r15
v6 = *(_DWORD *)(a2 + 12);
v7 = 0LL;
v8 = 0LL;
if ( v6 > 0 )
v8 = (unsigned int)v6;
while ( v8 != v7 )
{
if ( *(_QWORD *)(*(_QWORD *)a2 + 8 * v7++) == a3 )
return 0;
}
v11 = js_resize_array(a1, a2, 8LL, (_DWORD *)(a2 + 8), v6 + 1);
v10 = -1;
if ( !v11 )
{
v12 = *(_QWORD *)a2;
v13 = *(int *)(a2 + 12);
*(_DWORD *)(a2 + 12) = v13 + 1;
*(_QWORD *)(v12 + 8 * v13) = a3;
v14 = (_QWORD *)(a2 + 16);
for ( i = 0LL; i < *(int *)(a3 + 48); ++i )
{
v16 = *(_QWORD *)(a3 + 40);
v17 = *(_DWORD *)(v16 + 32 * i + 24);
if ( !a4 || v17 != 22 )
{
v18 = 32 * i + v16;
v19 = *(_DWORD *)(a2 + 28);
v20 = 0LL;
if ( v19 > 0 )
v20 = (unsigned int)v19;
v21 = 16 * v20;
for ( j = 0LL; v21 != j; j += 16LL )
{
if ( *(_DWORD *)(*v14 + j) == v17 )
{
*(_QWORD *)(*v14 + j + 8) = 0LL;
goto LABEL_22;
}
}
if ( (unsigned int)js_resize_array(a1, a2 + 16, 16LL, (_DWORD *)(a2 + 24), v19 + 1) )
return (unsigned int)-1;
v23 = *(int *)(a2 + 28);
v24 = *(_QWORD *)(a2 + 16) + 16 * v23;
*(_DWORD *)(a2 + 28) = v23 + 1;
*(_DWORD *)v24 = *(_DWORD *)(v18 + 24);
if ( a4 || *(_DWORD *)(v18 + 16) )
*(_QWORD *)(v24 + 8) = 0LL;
else
*(_QWORD *)(v24 + 8) = v18;
}
LABEL_22:
;
}
v25 = 0LL;
while ( v25 < *(int *)(a3 + 64) )
{
if ( (unsigned int)get_exported_names(
a1,
a2,
*(_QWORD *)(*(_QWORD *)(a3 + 24) + 16LL * *(int *)(*(_QWORD *)(a3 + 56) + 4 * v25++) + 8),
1LL) )
return (unsigned int)-1;
}
return 0;
}
return v10;
}
|
get_exported_names:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12D,ECX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV R8D,dword ptr [RSI + 0xc]
XOR EAX,EAX
TEST R8D,R8D
MOV ECX,0x0
CMOVG ECX,R8D
LAB_0013ed74:
CMP RCX,RAX
JZ 0x0013ed90
MOV RDX,qword ptr [R14]
LEA RSI,[RAX + 0x1]
CMP qword ptr [RDX + RAX*0x8],RBX
MOV RAX,RSI
JNZ 0x0013ed74
LAB_0013ed89:
XOR ECX,ECX
JMP 0x0013eed9
LAB_0013ed90:
LEA RCX,[R14 + 0x8]
INC R8D
PUSH 0x8
POP RDX
MOV RDI,R15
MOV RSI,R14
CALL 0x0013ec9f
PUSH -0x1
POP RCX
TEST EAX,EAX
JNZ 0x0013eed9
MOV qword ptr [RSP + 0x8],R15
MOV RAX,qword ptr [R14]
MOVSXD RCX,dword ptr [R14 + 0xc]
LEA EDX,[RCX + 0x1]
MOV dword ptr [R14 + 0xc],EDX
MOV qword ptr [RAX + RCX*0x8],RBX
LEA R13,[R14 + 0x10]
LEA RAX,[R14 + 0x18]
MOV qword ptr [RSP + 0x10],RAX
XOR EBP,EBP
LAB_0013edd6:
MOVSXD RAX,dword ptr [RBX + 0x30]
CMP RBP,RAX
JGE 0x0013ee93
MOV R15,qword ptr [RBX + 0x28]
MOV RCX,RBP
SHL RCX,0x5
MOV EAX,dword ptr [R15 + RCX*0x1 + 0x18]
TEST R12D,R12D
JZ 0x0013ee01
CMP EAX,0x16
JZ 0x0013ee85
LAB_0013ee01:
ADD R15,RCX
MOV R8D,dword ptr [R14 + 0x1c]
TEST R8D,R8D
MOV ECX,0x0
CMOVG ECX,R8D
SHL RCX,0x4
XOR EDX,EDX
LAB_0013ee1a:
CMP RCX,RDX
JZ 0x0013ee2e
MOV RSI,qword ptr [R13]
CMP dword ptr [RSI + RDX*0x1],EAX
JZ 0x0013ee7f
ADD RDX,0x10
JMP 0x0013ee1a
LAB_0013ee2e:
INC R8D
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,R13
PUSH 0x10
POP RDX
MOV RCX,qword ptr [RSP + 0x10]
CALL 0x0013ec9f
TEST EAX,EAX
JNZ 0x0013eed6
MOV RCX,qword ptr [R14 + 0x10]
MOVSXD RDX,dword ptr [R14 + 0x1c]
LEA ESI,[RDX + 0x1]
SHL RDX,0x4
LEA RAX,[RCX + RDX*0x1]
MOV dword ptr [R14 + 0x1c],ESI
MOV ESI,dword ptr [R15 + 0x18]
MOV dword ptr [RCX + RDX*0x1],ESI
TEST R12D,R12D
JNZ 0x0013ee78
CMP dword ptr [R15 + 0x10],0x0
JZ 0x0013ee8d
LAB_0013ee78:
AND qword ptr [RAX + 0x8],0x0
JMP 0x0013ee85
LAB_0013ee7f:
AND qword ptr [RSI + RDX*0x1 + 0x8],0x0
LAB_0013ee85:
INC RBP
JMP 0x0013edd6
LAB_0013ee8d:
MOV qword ptr [RAX + 0x8],R15
JMP 0x0013ee85
LAB_0013ee93:
XOR R15D,R15D
PUSH 0x1
POP R12
MOV R13,qword ptr [RSP + 0x8]
LAB_0013ee9f:
MOVSXD RAX,dword ptr [RBX + 0x40]
CMP R15,RAX
JGE 0x0013ed89
MOV RAX,qword ptr [RBX + 0x18]
MOV RCX,qword ptr [RBX + 0x38]
MOVSXD RCX,dword ptr [RCX + R15*0x4]
SHL RCX,0x4
MOV RDX,qword ptr [RAX + RCX*0x1 + 0x8]
MOV RDI,R13
MOV RSI,R14
MOV ECX,R12D
CALL 0x0013ed48
INC R15
TEST EAX,EAX
JZ 0x0013ee9f
LAB_0013eed6:
PUSH -0x1
POP RCX
LAB_0013eed9:
MOV EAX,ECX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int4 get_exported_names(int8 param_1,long *param_2,long param_3,int param_4)
{
uint uVar1;
int iVar2;
ulong uVar3;
ulong uVar4;
long lVar5;
long lVar6;
long lVar7;
long lVar8;
uVar1 = *(uint *)((long)param_2 + 0xc);
uVar3 = 0;
uVar4 = 0;
if (0 < (int)uVar1) {
uVar3 = (ulong)uVar1;
}
while (uVar3 != uVar4) {
lVar7 = uVar4 * 8;
uVar4 = uVar4 + 1;
if (*(long *)(*param_2 + lVar7) == param_3) {
return 0;
}
}
iVar2 = js_resize_array(param_1,param_2,8,param_2 + 1,uVar1 + 1);
if (iVar2 != 0) {
return 0xffffffff;
}
iVar2 = *(int *)((long)param_2 + 0xc);
*(int *)((long)param_2 + 0xc) = iVar2 + 1;
*(long *)(*param_2 + (long)iVar2 * 8) = param_3;
lVar7 = 0;
do {
if (*(int *)(param_3 + 0x30) <= lVar7) {
lVar7 = 0;
do {
if (*(int *)(param_3 + 0x40) <= lVar7) {
return 0;
}
iVar2 = get_exported_names(param_1,param_2,
*(int8 *)
(*(long *)(param_3 + 0x18) + 8 +
(long)*(int *)(*(long *)(param_3 + 0x38) + lVar7 * 4) * 0x10),1)
;
lVar7 = lVar7 + 1;
} while (iVar2 == 0);
return 0xffffffff;
}
iVar2 = *(int *)(*(long *)(param_3 + 0x28) + 0x18 + lVar7 * 0x20);
if ((param_4 == 0) || (iVar2 != 0x16)) {
lVar8 = *(long *)(param_3 + 0x28) + lVar7 * 0x20;
uVar1 = *(uint *)((long)param_2 + 0x1c);
uVar4 = 0;
if (0 < (int)uVar1) {
uVar4 = (ulong)uVar1;
}
for (lVar5 = 0; uVar4 * 0x10 != lVar5; lVar5 = lVar5 + 0x10) {
lVar6 = param_2[2];
if (*(int *)(lVar6 + lVar5) == iVar2) {
*(int8 *)(lVar6 + 8 + lVar5) = 0;
goto LAB_0013ee85;
}
}
iVar2 = js_resize_array(param_1,param_2 + 2,0x10,param_2 + 3,uVar1 + 1);
if (iVar2 != 0) {
return 0xffffffff;
}
lVar6 = (long)*(int *)((long)param_2 + 0x1c) * 0x10;
lVar5 = param_2[2] + lVar6;
*(int *)((long)param_2 + 0x1c) = *(int *)((long)param_2 + 0x1c) + 1;
*(int4 *)(param_2[2] + lVar6) = *(int4 *)(lVar8 + 0x18);
if ((param_4 == 0) && (*(int *)(lVar8 + 0x10) == 0)) {
*(long *)(lVar5 + 8) = lVar8;
}
else {
*(int8 *)(lVar5 + 8) = 0;
}
}
LAB_0013ee85:
lVar7 = lVar7 + 1;
} while( true );
}
|
|
19,817
|
nglog::GetTempDirectories(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
|
ng-log[P]ng-log/src/logging.cc
|
static void GetTempDirectories(vector<string>& list) {
list.clear();
#ifdef NGLOG_OS_WINDOWS
// On windows we'll try to find a directory in this order:
// C:/Documents & Settings/whomever/TEMP (or whatever GetTempPath() is)
// C:/TMP/
// C:/TEMP/
char tmp[MAX_PATH];
if (GetTempPathA(MAX_PATH, tmp)) list.push_back(tmp);
list.push_back("C:\\TMP\\");
list.push_back("C:\\TEMP\\");
#else
// Directories, in order of preference. If we find a dir that
// exists, we stop adding other less-preferred dirs
const char* candidates[] = {
// Non-null only during unittest/regtest
getenv("TEST_TMPDIR"),
// Explicitly-supplied temp dirs
getenv("TMPDIR"),
getenv("TMP"),
// If all else fails
"/tmp",
};
for (auto d : candidates) {
if (!d) continue; // Empty env var
// Make sure we don't surprise anyone who's expecting a '/'
string dstr = d;
if (dstr[dstr.size() - 1] != '/') {
dstr += "/";
}
list.push_back(dstr);
struct stat statbuf;
if (!stat(d, &statbuf) && S_ISDIR(statbuf.st_mode)) {
// We found a dir that exists - we're done.
return;
}
}
#endif
}
|
O2
|
cpp
|
nglog::GetTempDirectories(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
callq 0x1aa64
leaq 0x12f3a(%rip), %rdi # 0x1e3b6
callq 0x7700
movq %rax, (%rsp)
leaq 0x12f2f(%rip), %rdi # 0x1e3bb
callq 0x7700
movq %rax, 0x8(%rsp)
leaq 0x1413c(%rip), %rdi # 0x1f5d9
callq 0x7700
movq %rax, 0x10(%rsp)
leaq 0x1412f(%rip), %rax # 0x1f5dd
movq %rax, 0x18(%rsp)
xorl %ebp, %ebp
leaq 0x28(%rsp), %r14
leaq 0x48(%rsp), %r15
leaq 0x1325b(%rip), %r12 # 0x1e721
cmpq $0x20, %rbp
je 0xb543
movq (%rsp,%rbp), %r13
testq %r13, %r13
je 0xb533
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x8e36
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpb $0x2f, -0x1(%rax,%rcx)
je 0xb4ff
movq %r14, %rdi
movq %r12, %rsi
callq 0x7a80
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe69a
movq %r13, %rdi
movq %r15, %rsi
callq 0x74f0
testl %eax, %eax
jne 0xb52b
movl 0x60(%rsp), %eax
movl $0xf000, %ecx # imm = 0xF000
andl %ecx, %eax
cmpl $0x4000, %eax # imm = 0x4000
je 0xb539
movq %r14, %rdi
callq 0x7b38
addq $0x8, %rbp
jmp 0xb4c6
leaq 0x28(%rsp), %rdi
callq 0x7b38
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x7b38
movq %rbx, %rdi
callq 0x7a00
|
_ZN5nglogL18GetTempDirectoriesERSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0D8h
mov rbx, rdi
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE5clearEv; std::vector<std::string>::clear(void)
lea rdi, aTestTmpdir; "TEST_TMPDIR"
call _getenv
mov [rsp+108h+var_108], rax
lea rdi, aTestTmpdir+5; "TMPDIR"
call _getenv
mov [rsp+108h+var_100], rax
lea rdi, aTmp_0; "TMP"
call _getenv
mov [rsp+108h+var_F8], rax
lea rax, aTmp; "/tmp"
mov [rsp+108h+var_F0], rax
xor ebp, ebp
lea r14, [rsp+108h+var_E0]
lea r15, [rsp+108h+var_C0]
lea r12, asc_1E720+1; "/"
loc_B4C6:
cmp rbp, 20h ; ' '
jz short loc_B543
mov r13, [rsp+rbp+108h+var_108]
test r13, r13
jz short loc_B533
mov rdi, r14
mov rsi, r13
mov rdx, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rax, [rsp+108h+var_E0]
mov rcx, [rsp+108h+var_D8]
cmp byte ptr [rax+rcx-1], 2Fh ; '/'
jz short loc_B4FF
mov rdi, r14
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
loc_B4FF:
mov rdi, rbx
mov rsi, r14
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backERKS5_; std::vector<std::string>::push_back(std::string const&)
mov rdi, r13
mov rsi, r15
call _stat
test eax, eax
jnz short loc_B52B
mov eax, [rsp+108h+var_A8]
mov ecx, 0F000h
and eax, ecx
cmp eax, 4000h
jz short loc_B539
loc_B52B:
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_B533:
add rbp, 8
jmp short loc_B4C6
loc_B539:
lea rdi, [rsp+108h+var_E0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_B543:
add rsp, 0D8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_20]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
|
void nglog::GetTempDirectories(long long a1)
{
long long i; // rbp
long long v2; // r13
long long v3; // rdx
long long v4; // r8
long long v5; // r9
long long v6; // [rsp+0h] [rbp-108h]
long long v7; // [rsp+8h] [rbp-100h]
long long v8; // [rsp+10h] [rbp-F8h]
const char *v9; // [rsp+18h] [rbp-F0h]
long long v10; // [rsp+28h] [rbp-E0h] BYREF
long long v11; // [rsp+30h] [rbp-D8h]
_BYTE v12[24]; // [rsp+48h] [rbp-C0h] BYREF
int v13; // [rsp+60h] [rbp-A8h]
std::vector<std::string>::clear();
v6 = getenv("TEST_TMPDIR");
v7 = getenv("TMPDIR");
v8 = getenv("TMP");
v9 = "/tmp";
for ( i = 0LL; i != 32; i += 8LL )
{
v2 = *(long long *)((char *)&v6 + i);
if ( v2 )
{
std::string::basic_string<std::allocator<char>>(&v10, *(long long *)((char *)&v6 + i));
if ( *(_BYTE *)(v10 + v11 - 1) != 47 )
std::string::append(&v10, "/", v3, v11, v4, v5, v6, v7, v8, v9);
std::vector<std::string>::push_back(a1, &v10);
if ( !(unsigned int)stat(v2, v12) && (v13 & 0xF000) == 0x4000 )
{
std::string::~string(&v10);
return;
}
std::string::~string(&v10);
}
}
}
|
GetTempDirectories:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xd8
MOV RBX,RDI
CALL 0x0011aa64
LEA RDI,[0x11e3b6]
CALL 0x00107700
MOV qword ptr [RSP],RAX
LEA RDI,[0x11e3bb]
CALL 0x00107700
MOV qword ptr [RSP + 0x8],RAX
LEA RDI,[0x11f5d9]
CALL 0x00107700
MOV qword ptr [RSP + 0x10],RAX
LEA RAX,[0x11f5dd]
MOV qword ptr [RSP + 0x18],RAX
XOR EBP,EBP
LEA R14,[RSP + 0x28]
LEA R15,[RSP + 0x48]
LEA R12,[0x11e721]
LAB_0010b4c6:
CMP RBP,0x20
JZ 0x0010b543
MOV R13,qword ptr [RSP + RBP*0x1]
TEST R13,R13
JZ 0x0010b533
MOV RDI,R14
MOV RSI,R13
MOV RDX,R15
CALL 0x00108e36
MOV RAX,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RSP + 0x30]
CMP byte ptr [RAX + RCX*0x1 + -0x1],0x2f
JZ 0x0010b4ff
LAB_0010b4f4:
MOV RDI,R14
MOV RSI,R12
CALL 0x00107a80
LAB_0010b4ff:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0010e69a
LAB_0010b50a:
MOV RDI,R13
MOV RSI,R15
CALL 0x001074f0
TEST EAX,EAX
JNZ 0x0010b52b
MOV EAX,dword ptr [RSP + 0x60]
MOV ECX,0xf000
AND EAX,ECX
CMP EAX,0x4000
JZ 0x0010b539
LAB_0010b52b:
MOV RDI,R14
CALL 0x00107b38
LAB_0010b533:
ADD RBP,0x8
JMP 0x0010b4c6
LAB_0010b539:
LEA RDI,[RSP + 0x28]
CALL 0x00107b38
LAB_0010b543:
ADD RSP,0xd8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nglog::GetTempDirectories(std::vector<std::__cxx11::string, std::allocator<std::__cxx11::string >
>&) */
void nglog::GetTempDirectories(vector *param_1)
{
char *__file;
int iVar1;
long lVar2;
char *local_108 [5];
long local_e0;
long local_d8;
stat local_c0;
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::clear
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)param_1);
local_108[0] = getenv("TEST_TMPDIR");
local_108[1] = getenv("TMPDIR");
local_108[2] = getenv("TMP");
local_108[3] = "/tmp";
lVar2 = 0;
do {
if (lVar2 == 0x20) {
return;
}
__file = *(char **)((long)local_108 + lVar2);
if (__file != (char *)0x0) {
std::__cxx11::string::string<std::allocator<char>>
((string *)&local_e0,__file,(allocator *)&local_c0);
if (*(char *)(local_e0 + -1 + local_d8) != '/') {
/* try { // try from 0010b4f4 to 0010b509 has its CatchHandler @ 0010b555 */
std::__cxx11::string::append((char *)&local_e0);
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::push_back
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)param_1,
(string *)&local_e0);
iVar1 = stat(__file,&local_c0);
if ((iVar1 == 0) && ((local_c0.st_mode & 0xf000) == 0x4000)) {
std::__cxx11::string::~string((string *)&local_e0);
return;
}
std::__cxx11::string::~string((string *)&local_e0);
}
lVar2 = lVar2 + 8;
} while( true );
}
|
|
19,818
|
use_head
|
eloqsql/storage/maria/ma_bitmap.c
|
static void use_head(MARIA_HA *info, pgcache_page_no_t page, uint size,
uint block_position)
{
MARIA_FILE_BITMAP *bitmap= &info->s->bitmap;
MARIA_BITMAP_BLOCK *block;
uchar *data;
uint offset, tmp, offset_page;
DBUG_ENTER("use_head");
DBUG_ASSERT(page % bitmap->pages_covered);
block= dynamic_element(&info->bitmap_blocks, block_position,
MARIA_BITMAP_BLOCK*);
block->page= page;
block->page_count= 1 + TAIL_BIT;
block->empty_space= size;
block->used= BLOCKUSED_TAIL;
/*
Mark place used by reading/writing 2 bytes at a time to handle
bitmaps in overlapping bytes
*/
offset_page= (uint) (page - bitmap->page - 1) * 3;
offset= offset_page & 7;
data= bitmap->map + offset_page / 8;
tmp= uint2korr(data);
block->org_bitmap_value= (tmp >> offset) & 7;
tmp= (tmp & ~(7 << offset)) | (FULL_HEAD_PAGE << offset);
int2store(data, tmp);
bitmap->changed= 1;
DBUG_EXECUTE("bitmap", _ma_print_bitmap_changes(bitmap););
DBUG_VOID_RETURN;
}
|
O0
|
c
|
use_head:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0xa10, %rax # imm = 0xA10
movq %rax, -0x20(%rbp)
jmp 0x42be5
movq -0x8(%rbp), %rax
movq 0x2c0(%rax), %rax
movl -0x18(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movl $0x8001, 0x8(%rax) # imm = 0x8001
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x28(%rbp), %rax
movb $0x4, 0x14(%rax)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
subq 0x10(%rcx), %rax
subq $0x1, %rax
imull $0x3, %eax, %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
andl $0x7, %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x3c(%rbp), %ecx
shrl $0x3, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl -0x34(%rbp), %ecx
shrl %cl, %eax
andl $0x7, %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x15(%rax)
movl -0x38(%rbp), %eax
movl -0x34(%rbp), %ecx
movl $0x7, %edx
shll %cl, %edx
movl %edx, %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movl -0x34(%rbp), %ecx
movl $0x4, %edx
shll %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x38(%rbp), %eax
movw %ax, %cx
movq -0x48(%rbp), %rax
movw %cx, (%rax)
movq -0x20(%rbp), %rax
movb $0x1, 0x20(%rax)
jmp 0x42cbe
jmp 0x42cc0
jmp 0x42cc2
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
use_head:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_18], ecx
mov rax, [rbp+var_8]
mov rax, [rax]
add rax, 0A10h
mov [rbp+var_20], rax
jmp short $+2
loc_42BE5:
mov rax, [rbp+var_8]
mov rax, [rax+2C0h]
mov ecx, [rbp+var_18]
imul rcx, 18h
add rax, rcx
mov [rbp+var_28], rax
mov rcx, [rbp+var_10]
mov rax, [rbp+var_28]
mov [rax], rcx
mov rax, [rbp+var_28]
mov dword ptr [rax+8], 8001h
mov ecx, [rbp+var_14]
mov rax, [rbp+var_28]
mov [rax+0Ch], ecx
mov rax, [rbp+var_28]
mov byte ptr [rax+14h], 4
mov rax, [rbp+var_10]
mov rcx, [rbp+var_20]
sub rax, [rcx+10h]
sub rax, 1
imul eax, 3
mov [rbp+var_3C], eax
mov eax, [rbp+var_3C]
and eax, 7
mov [rbp+var_34], eax
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov ecx, [rbp+var_3C]
shr ecx, 3
mov ecx, ecx
add rax, rcx
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
movzx eax, word ptr [rax]
mov [rbp+var_38], eax
mov eax, [rbp+var_38]
mov ecx, [rbp+var_34]
shr eax, cl
and eax, 7
mov cl, al
mov rax, [rbp+var_28]
mov [rax+15h], cl
mov eax, [rbp+var_38]
mov ecx, [rbp+var_34]
mov edx, 7
shl edx, cl
mov ecx, edx
xor ecx, 0FFFFFFFFh
and eax, ecx
mov ecx, [rbp+var_34]
mov edx, 4
shl edx, cl
mov ecx, edx
or eax, ecx
mov [rbp+var_38], eax
mov rax, [rbp+var_30]
mov [rbp+var_48], rax
mov eax, [rbp+var_38]
mov cx, ax
mov rax, [rbp+var_48]
mov [rax], cx
mov rax, [rbp+var_20]
mov byte ptr [rax+20h], 1
jmp short $+2
loc_42CBE:
jmp short $+2
loc_42CC0:
jmp short $+2
loc_42CC2:
pop rbp
retn
|
long long use_head(_QWORD *a1, long long a2, int a3, unsigned int a4)
{
long long result; // rax
unsigned int v5; // [rsp+Ch] [rbp-3Ch]
unsigned int v6; // [rsp+10h] [rbp-38h]
_WORD *v7; // [rsp+18h] [rbp-30h]
long long v8; // [rsp+20h] [rbp-28h]
long long v9; // [rsp+28h] [rbp-20h]
v9 = *a1 + 2576LL;
v8 = 24LL * a4 + a1[88];
*(_QWORD *)v8 = a2;
*(_DWORD *)(v8 + 8) = 32769;
*(_DWORD *)(v8 + 12) = a3;
*(_BYTE *)(v8 + 20) = 4;
v5 = 3 * (a2 - *(_DWORD *)(v9 + 16) - 1);
v7 = (_WORD *)((v5 >> 3) + *(_QWORD *)(v9 + 8));
v6 = (unsigned __int16)*v7;
*(_BYTE *)(v8 + 21) = (v6 >> (v5 & 7)) & 7;
*v7 = (4 << (v5 & 7)) | ~(7 << (v5 & 7)) & v6;
result = v9;
*(_BYTE *)(v9 + 32) = 1;
return result;
}
|
use_head:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV dword ptr [RBP + -0x18],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
ADD RAX,0xa10
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00142be5
LAB_00142be5:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x2c0]
MOV ECX,dword ptr [RBP + -0x18]
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x8],0x8001
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0xc],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x14],0x4
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x20]
SUB RAX,qword ptr [RCX + 0x10]
SUB RAX,0x1
IMUL EAX,EAX,0x3
MOV dword ptr [RBP + -0x3c],EAX
MOV EAX,dword ptr [RBP + -0x3c]
AND EAX,0x7
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x3c]
SHR ECX,0x3
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,word ptr [RAX]
MOV dword ptr [RBP + -0x38],EAX
MOV EAX,dword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x34]
SHR EAX,CL
AND EAX,0x7
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x15],CL
MOV EAX,dword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x34]
MOV EDX,0x7
SHL EDX,CL
MOV ECX,EDX
XOR ECX,0xffffffff
AND EAX,ECX
MOV ECX,dword ptr [RBP + -0x34]
MOV EDX,0x4
SHL EDX,CL
MOV ECX,EDX
OR EAX,ECX
MOV dword ptr [RBP + -0x38],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x48],RAX
MOV EAX,dword ptr [RBP + -0x38]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x48]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x20],0x1
JMP 0x00142cbe
LAB_00142cbe:
JMP 0x00142cc0
LAB_00142cc0:
JMP 0x00142cc2
LAB_00142cc2:
POP RBP
RET
|
void use_head(long *param_1,int8 param_2,int4 param_3,uint param_4)
{
ushort uVar1;
long lVar2;
uint uVar3;
int8 *puVar4;
ushort *puVar5;
byte bVar6;
lVar2 = *param_1;
puVar4 = (int8 *)(param_1[0x58] + (ulong)param_4 * 0x18);
*puVar4 = param_2;
*(int4 *)(puVar4 + 1) = 0x8001;
*(int4 *)((long)puVar4 + 0xc) = param_3;
*(int1 *)((long)puVar4 + 0x14) = 4;
uVar3 = (((int)param_2 - (int)*(int8 *)(lVar2 + 0xa20)) + -1) * 3;
bVar6 = (byte)uVar3 & 7;
puVar5 = (ushort *)(*(long *)(lVar2 + 0xa18) + (ulong)(uVar3 >> 3));
uVar1 = *puVar5;
*(byte *)((long)puVar4 + 0x15) = (byte)(uVar1 >> bVar6) & 7;
*puVar5 = uVar1 & ((ushort)(7 << bVar6) ^ 0xffff) | (ushort)(4 << bVar6);
*(int1 *)(lVar2 + 0xa30) = 1;
return;
}
|
|
19,819
|
ma_test_if_changed
|
eloqsql/storage/maria/ma_locking.c
|
int _ma_test_if_changed(register MARIA_HA *info)
{
#ifdef MARIA_EXTERNAL_LOCKING
MARIA_SHARE *share= info->s;
if (share->state.process != share->last_process ||
share->state.unique != info->last_unique ||
share->state.update_count != info->last_loop)
{ /* Keyfile has changed */
DBUG_PRINT("info",("index file changed"));
if (share->state.process != share->this_process)
VOID(flush_pagecache_blocks(share->pagecache, &share->kfile,
FLUSH_RELEASE));
share->last_process=share->state.process;
info->last_unique= share->state.unique;
info->last_loop= share->state.update_count;
info->update|= HA_STATE_WRITTEN; /* Must use file on next */
info->data_changed= 1; /* For maria_is_changed */
return 1;
}
#endif
return (!(info->update & HA_STATE_AKTIV) ||
(info->update & (HA_STATE_WRITTEN | HA_STATE_DELETED |
HA_STATE_KEY_CHANGED)));
}
|
O0
|
c
|
ma_test_if_changed:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x624(%rax), %ecx
andl $0x2, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x9(%rbp)
je 0x48c17
movq -0x8(%rbp), %rax
movl 0x624(%rax), %eax
andl $0x8c, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ma_test_if_changed:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov ecx, [rax+624h]
and ecx, 2
mov al, 1
cmp ecx, 0
mov [rbp+var_9], al
jz short loc_48C17
mov rax, [rbp+var_8]
mov eax, [rax+624h]
and eax, 8Ch
cmp eax, 0
setnz al
mov [rbp+var_9], al
loc_48C17:
mov al, [rbp+var_9]
and al, 1
movzx eax, al
pop rbp
retn
|
_BOOL8 ma_test_if_changed(long long a1)
{
bool v2; // [rsp+1h] [rbp-9h]
v2 = 1;
if ( (*(_DWORD *)(a1 + 1572) & 2) != 0 )
return (*(_DWORD *)(a1 + 1572) & 0x8C) != 0;
return v2;
}
|
_ma_test_if_changed:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x624]
AND ECX,0x2
MOV AL,0x1
CMP ECX,0x0
MOV byte ptr [RBP + -0x9],AL
JZ 0x00148c17
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x624]
AND EAX,0x8c
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x9],AL
LAB_00148c17:
MOV AL,byte ptr [RBP + -0x9]
AND AL,0x1
MOVZX EAX,AL
POP RBP
RET
|
bool _ma_test_if_changed(long param_1)
{
int1 local_11;
local_11 = true;
if ((*(uint *)(param_1 + 0x624) & 2) != 0) {
local_11 = (*(uint *)(param_1 + 0x624) & 0x8c) != 0;
}
return local_11;
}
|
|
19,820
|
action_console_write
|
navaro[P]qoraal-tictactoe/build_O3/_deps/qoraal_engine-src/src/parts/console.c
|
int32_t
action_console_write (PENGINE_T instance, uint32_t parm, uint32_t flags)
{
const char* str = 0 ;
if (flags & (PART_ACTION_FLAG_VALIDATE)) {
return parts_valadate_string (instance, parm, flags) ;
}
str = parts_get_string(instance, parm, flags) ;
if (str) {
#if !defined CFG_ENGINE_STRSUB_DISABLE
char buffer[96] ;
strsub_parse_string_to (0, str, strlen(str), buffer, 96) ;
console_out (buffer) ;
#else
console_out (str) ;
#endif
}
return ENGINE_OK ;
}
|
O3
|
c
|
action_console_write:
testb $0x1, %dl
jne 0x822a
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
callq 0x82c6
testq %rax, %rax
je 0x6929
movq %rax, %rbx
movq %rax, %rdi
callq 0x61a0
leaq -0x70(%rbp), %rcx
xorl %edi, %edi
movq %rbx, %rsi
movl %eax, %edx
movl $0x60, %r8d
callq 0x1b8ea
leaq 0x3a036(%rip), %rax # 0x40948
movq (%rax), %rax
testq %rax, %rax
je 0x6929
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x6929
leaq -0x70(%rbp), %rdi
callq *%rax
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
|
action_console_write:
test dl, 1
jnz parts_valadate_string
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
call parts_get_string
test rax, rax
jz short loc_6929
mov rbx, rax
mov rdi, rax
call _strlen
lea rcx, [rbp-70h]
xor edi, edi
mov rsi, rbx
mov edx, eax
mov r8d, 60h ; '`'
call strsub_parse_string_to
lea rax, _qoraal_instance
mov rax, [rax]
test rax, rax
jz short loc_6929
mov rax, [rax+10h]
test rax, rax
jz short loc_6929
lea rdi, [rbp-70h]
call rax
loc_6929:
xor eax, eax
add rsp, 68h
pop rbx
pop rbp
retn
|
long long action_console_write(long long a1, long long a2, char a3)
{
long long string; // rax
long long v4; // rbx
unsigned int v5; // eax
void ( *v6)(_BYTE *); // rax
_BYTE v8[120]; // [rsp-78h] [rbp-78h] BYREF
if ( (a3 & 1) != 0 )
return parts_valadate_string();
string = parts_get_string();
if ( string )
{
v4 = string;
v5 = strlen(string);
strsub_parse_string_to(0LL, v4, v5, v8, 96LL);
if ( qoraal_instance )
{
v6 = *(void ( **)(_BYTE *))(qoraal_instance + 16);
if ( v6 )
v6(v8);
}
}
return 0LL;
}
|
action_console_write:
TEST DL,0x1
JNZ 0x0010822a
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
CALL 0x001082c6
TEST RAX,RAX
JZ 0x00106929
MOV RBX,RAX
MOV RDI,RAX
CALL 0x001061a0
LEA RCX,[RBP + -0x70]
XOR EDI,EDI
MOV RSI,RBX
MOV EDX,EAX
MOV R8D,0x60
CALL 0x0011b8ea
LEA RAX,[0x140948]
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x00106929
MOV RAX,qword ptr [RAX + 0x10]
TEST RAX,RAX
JZ 0x00106929
LEA RDI,[RBP + -0x70]
CALL RAX
LAB_00106929:
XOR EAX,EAX
ADD RSP,0x68
POP RBX
POP RBP
RET
|
int8 action_console_write(int8 param_1,int2 param_2,ulong param_3)
{
char *__s;
size_t sVar1;
long lVar2;
int1 local_78 [88];
int8 uStack_20;
if ((param_3 & 1) == 0) {
__s = (char *)parts_get_string();
if (__s != (char *)0x0) {
sVar1 = strlen(__s);
strsub_parse_string_to(0,__s,sVar1 & 0xffffffff,local_78,0x60);
if ((_qoraal_instance != 0) && (*(code **)(_qoraal_instance + 0x10) != (code *)0x0)) {
(**(code **)(_qoraal_instance + 0x10))(local_78);
}
}
return 0;
}
if ((param_3 & 8) != 0) {
uStack_20 = 0x108241;
lVar2 = engine_get_string(param_1,param_2,0);
if (lVar2 != 0) {
return 0;
}
}
return 0xffffffff;
}
|
|
19,821
|
my_thread_destory_thr_mutex
|
eloqsql/mysys/my_thr_init.c
|
static void my_thread_destory_thr_mutex(struct st_my_thread_var *var)
{
mysql_mutex_destroy(&var->mutex);
mysql_cond_destroy(&var->suspend);
}
|
O3
|
c
|
my_thread_destory_thr_mutex:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x40(%rdi), %r14
movq 0x80(%rdi), %rdi
testq %rdi, %rdi
je 0x268eb
leaq 0x2cbf46(%rip), %rax # 0x2f2820
movq (%rax), %rax
callq *0x48(%rax)
movq $0x0, 0x80(%rbx)
movq %r14, %rdi
callq 0x24360
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
jne 0x2690c
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x245b0
leaq 0x2cbf0d(%rip), %rax # 0x2f2820
movq (%rax), %rax
callq *0x68(%rax)
movq $0x0, 0x38(%rbx)
jmp 0x268fc
|
my_thread_destory_thr_mutex:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
lea r14, [rdi+40h]
mov rdi, [rdi+80h]
test rdi, rdi
jz short loc_268EB
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+48h]
mov qword ptr [rbx+80h], 0
loc_268EB:
mov rdi, r14
call _pthread_mutex_destroy
mov rdi, [rbx+38h]
test rdi, rdi
jnz short loc_2690C
loc_268FC:
add rbx, 8
mov rdi, rbx
pop rbx
pop r14
pop rbp
jmp _pthread_cond_destroy
loc_2690C:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+68h]
mov qword ptr [rbx+38h], 0
jmp short loc_268FC
|
long long my_thread_destory_thr_mutex(long long a1)
{
if ( *(_QWORD *)(a1 + 128) )
{
(*((void (**)(void))PSI_server[0] + 9))();
*(_QWORD *)(a1 + 128) = 0LL;
}
pthread_mutex_destroy(a1 + 64);
if ( *(_QWORD *)(a1 + 56) )
{
(*((void (**)(void))PSI_server[0] + 13))();
*(_QWORD *)(a1 + 56) = 0LL;
}
return pthread_cond_destroy(a1 + 8);
}
|
my_thread_destory_thr_mutex:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
LEA R14,[RDI + 0x40]
MOV RDI,qword ptr [RDI + 0x80]
TEST RDI,RDI
JZ 0x001268eb
LEA RAX,[0x3f2820]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [RBX + 0x80],0x0
LAB_001268eb:
MOV RDI,R14
CALL 0x00124360
MOV RDI,qword ptr [RBX + 0x38]
TEST RDI,RDI
JNZ 0x0012690c
LAB_001268fc:
ADD RBX,0x8
MOV RDI,RBX
POP RBX
POP R14
POP RBP
JMP 0x001245b0
LAB_0012690c:
LEA RAX,[0x3f2820]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x68]
MOV qword ptr [RBX + 0x38],0x0
JMP 0x001268fc
|
void my_thread_destory_thr_mutex(long param_1)
{
if (*(long *)(param_1 + 0x80) != 0) {
(**(code **)(PSI_server + 0x48))();
*(int8 *)(param_1 + 0x80) = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 0x40));
if (*(long *)(param_1 + 0x38) != 0) {
(**(code **)(PSI_server + 0x68))();
*(int8 *)(param_1 + 0x38) = 0;
}
pthread_cond_destroy((pthread_cond_t *)(param_1 + 8));
return;
}
|
|
19,822
|
google::protobuf::SimpleDescriptorDatabase::DescriptorIndex<google::protobuf::FileDescriptorProto const*>::FindAllExtensionNumbers(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<int, std::allocator<int>>*)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor_database.cc
|
bool SimpleDescriptorDatabase::DescriptorIndex<Value>::FindAllExtensionNumbers(
const std::string& containing_type, std::vector<int>* output) {
typename std::map<std::pair<std::string, int>, Value>::const_iterator it =
by_extension_.lower_bound(std::make_pair(containing_type, 0));
bool success = false;
for (; it != by_extension_.end() && it->first.first == containing_type;
++it) {
output->push_back(it->first.second);
success = true;
}
return success;
}
|
O0
|
cpp
|
google::protobuf::SimpleDescriptorDatabase::DescriptorIndex<google::protobuf::FileDescriptorProto const*>::FindAllExtensionNumbers(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<int, std::allocator<int>>*):
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x60, %rax
movq %rax, 0x18(%rsp)
movq 0x98(%rsp), %rsi
movl $0x0, 0x54(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x54(%rsp), %rdx
callq 0x2f2c90
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2f2c60
movq %rax, 0x28(%rsp)
jmp 0x2ea3ef
movq 0x28(%rsp), %rax
movq %rax, 0x80(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x2f2cd0
leaq 0x58(%rsp), %rdi
callq 0x2ec4d0
movb $0x0, 0x43(%rsp)
movq 0x10(%rsp), %rdi
addq $0x60, %rdi
callq 0x2f2d10
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2f2cd0
leaq 0x88(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x2f2cf0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x2ea463
jmp 0x2ea484
leaq 0x88(%rsp), %rdi
callq 0x2f2a20
movq %rax, %rdi
movq 0x98(%rsp), %rsi
callq 0x38780
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x2ea48e
jmp 0x2ea4e8
movq 0x90(%rsp), %rax
movq %rax, (%rsp)
leaq 0x88(%rsp), %rdi
callq 0x2f2a20
movq (%rsp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x28d900
movb $0x1, 0x43(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x2f2d40
jmp 0x2ea420
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x2ec4d0
jmp 0x2ea4f6
movb 0x43(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x21700
|
_ZN6google8protobuf24SimpleDescriptorDatabase15DescriptorIndexIPKNS0_19FileDescriptorProtoEE23FindAllExtensionNumbersERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPSt6vectorIiSaIiEE:
sub rsp, 0A8h
mov [rsp+0A8h+var_8], rdi
mov [rsp+0A8h+var_10], rsi
mov [rsp+0A8h+var_18], rdx
mov rax, [rsp+0A8h+var_8]
mov [rsp+0A8h+var_98], rax
add rax, 60h ; '`'
mov [rsp+0A8h+var_90], rax
mov rsi, [rsp+0A8h+var_10]
mov [rsp+0A8h+var_54], 0
lea rdi, [rsp+0A8h+var_50]
mov [rsp+0A8h+var_88], rdi
lea rdx, [rsp+0A8h+var_54]
call _ZSt9make_pairIRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiESt4pairINSt25__strip_reference_wrapperINSt5decayIT_E4typeEE6__typeENS9_INSA_IT0_E4typeEE6__typeEEOSB_OSG_; std::make_pair<std::string const&,int>(std::string const&&&,int&&)
mov rdi, [rsp+0A8h+var_90]
mov rsi, [rsp+0A8h+var_88]
call _ZNSt3mapISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiEPKN6google8protobuf19FileDescriptorProtoESt4lessIS7_ESaIS0_IKS7_SC_EEE11lower_boundERSF_; std::map<std::pair<std::string,int>,google::protobuf::FileDescriptorProto const*>::lower_bound(std::pair<std::string,int> const&)
mov [rsp+0A8h+var_80], rax
jmp short $+2
loc_2EA3EF:
mov rax, [rsp+0A8h+var_80]
mov [rsp+0A8h+var_28], rax
lea rdi, [rsp+0A8h+var_20]
lea rsi, [rsp+0A8h+var_28]
call _ZNSt23_Rb_tree_const_iteratorISt4pairIKS0_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiEPKN6google8protobuf19FileDescriptorProtoEEEC2ERKSt17_Rb_tree_iteratorISE_E; std::_Rb_tree_const_iterator<std::pair<std::pair const<std::string,int>,google::protobuf::FileDescriptorProto const*>>::_Rb_tree_const_iterator(std::_Rb_tree_iterator<std::pair<std::pair const<std::string,int>,google::protobuf::FileDescriptorProto const*>> const&)
lea rdi, [rsp+0A8h+var_50]
call _ZNSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiED2Ev; std::pair<std::string,int>::~pair()
mov [rsp+0A8h+var_65], 0
loc_2EA420:
mov rdi, [rsp+0A8h+var_98]
add rdi, 60h ; '`'
call _ZNSt3mapISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiEPKN6google8protobuf19FileDescriptorProtoESt4lessIS7_ESaIS0_IKS7_SC_EEE3endEv; std::map<std::pair<std::string,int>,google::protobuf::FileDescriptorProto const*>::end(void)
mov [rsp+0A8h+var_78], rax
lea rdi, [rsp+0A8h+var_70]
lea rsi, [rsp+0A8h+var_78]
call _ZNSt23_Rb_tree_const_iteratorISt4pairIKS0_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiEPKN6google8protobuf19FileDescriptorProtoEEEC2ERKSt17_Rb_tree_iteratorISE_E; std::_Rb_tree_const_iterator<std::pair<std::pair const<std::string,int>,google::protobuf::FileDescriptorProto const*>>::_Rb_tree_const_iterator(std::_Rb_tree_iterator<std::pair<std::pair const<std::string,int>,google::protobuf::FileDescriptorProto const*>> const&)
lea rdi, [rsp+0A8h+var_20]
lea rsi, [rsp+0A8h+var_70]
call _ZStneRKSt23_Rb_tree_const_iteratorISt4pairIKS0_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiEPKN6google8protobuf19FileDescriptorProtoEEESH_; std::operator!=(std::_Rb_tree_const_iterator<std::pair<std::pair const<std::string,int>,google::protobuf::FileDescriptorProto const*>> const&,std::_Rb_tree_const_iterator<std::pair<std::pair const<std::string,int>,google::protobuf::FileDescriptorProto const*>> const&)
mov cl, al
xor eax, eax
test cl, 1
mov [rsp+0A8h+var_99], al
jnz short loc_2EA463
jmp short loc_2EA484
loc_2EA463:
lea rdi, [rsp+0A8h+var_20]
call _ZNKSt23_Rb_tree_const_iteratorISt4pairIKS0_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiEPKN6google8protobuf19FileDescriptorProtoEEEptEv; std::_Rb_tree_const_iterator<std::pair<std::pair const<std::string,int>,google::protobuf::FileDescriptorProto const*>>::operator->(void)
mov rdi, rax
mov rsi, [rsp+0A8h+var_10]
call _ZSteqIcEN9__gnu_cxx11__enable_ifIXsr9__is_charIT_EE7__valueEbE6__typeERKNSt7__cxx1112basic_stringIS2_St11char_traitsIS2_ESaIS2_EEESC_
mov [rsp+0A8h+var_99], al
loc_2EA484:
mov al, [rsp+0A8h+var_99]
test al, 1
jnz short loc_2EA48E
jmp short loc_2EA4E8
loc_2EA48E:
mov rax, [rsp+0A8h+var_18]
mov [rsp+0A8h+var_A8], rax
lea rdi, [rsp+0A8h+var_20]
call _ZNKSt23_Rb_tree_const_iteratorISt4pairIKS0_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiEPKN6google8protobuf19FileDescriptorProtoEEEptEv; std::_Rb_tree_const_iterator<std::pair<std::pair const<std::string,int>,google::protobuf::FileDescriptorProto const*>>::operator->(void)
mov rdi, [rsp+0A8h+var_A8]
mov rsi, rax
add rsi, 20h ; ' '
call _ZNSt6vectorIiSaIiEE9push_backERKi; std::vector<int>::push_back(int const&)
mov [rsp+0A8h+var_65], 1
lea rdi, [rsp+0A8h+var_20]
call _ZNSt23_Rb_tree_const_iteratorISt4pairIKS0_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiEPKN6google8protobuf19FileDescriptorProtoEEEppEv; std::_Rb_tree_const_iterator<std::pair<std::pair const<std::string,int>,google::protobuf::FileDescriptorProto const*>>::operator++(void)
jmp loc_2EA420
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
lea rdi, [rsp+arg_50]
call _ZNSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiED2Ev; std::pair<std::string,int>::~pair()
jmp short loc_2EA4F6
loc_2EA4E8:
mov al, [rsp+0A8h+var_65]
and al, 1
add rsp, 0A8h
retn
loc_2EA4F6:
mov rdi, [rsp+arg_40]
call __Unwind_Resume
|
char google::protobuf::SimpleDescriptorDatabase::DescriptorIndex<google::protobuf::FileDescriptorProto const*>::FindAllExtensionNumbers(
long long a1,
long long a2,
long long a3)
{
long long v3; // rax
long long v4; // rsi
long long v5; // rdx
long long v6; // rcx
long long v7; // r8
long long v8; // r9
long long v10; // [rsp+0h] [rbp-A8h]
char v11; // [rsp+Fh] [rbp-99h]
long long v12; // [rsp+30h] [rbp-78h] BYREF
_BYTE v13[11]; // [rsp+38h] [rbp-70h] BYREF
char v14; // [rsp+43h] [rbp-65h]
int v15; // [rsp+54h] [rbp-54h] BYREF
_BYTE v16[40]; // [rsp+58h] [rbp-50h] BYREF
long long v17; // [rsp+80h] [rbp-28h] BYREF
char v18[8]; // [rsp+88h] [rbp-20h] BYREF
long long v19; // [rsp+90h] [rbp-18h]
long long v20; // [rsp+98h] [rbp-10h]
long long v21; // [rsp+A0h] [rbp-8h]
v21 = a1;
v20 = a2;
v19 = a3;
v15 = 0;
std::make_pair<std::string const&,int>(v16, a2, &v15);
v17 = std::map<std::pair<std::string,int>,google::protobuf::FileDescriptorProto const*>::lower_bound(a1 + 96, v16);
std::_Rb_tree_const_iterator<std::pair<std::pair const<std::string,int>,google::protobuf::FileDescriptorProto const*>>::_Rb_tree_const_iterator(
v18,
&v17);
std::pair<std::string,int>::~pair(v16);
v14 = 0;
while ( 1 )
{
v12 = std::map<std::pair<std::string,int>,google::protobuf::FileDescriptorProto const*>::end(a1 + 96);
std::_Rb_tree_const_iterator<std::pair<std::pair const<std::string,int>,google::protobuf::FileDescriptorProto const*>>::_Rb_tree_const_iterator(
v13,
&v12);
v11 = 0;
if ( (std::operator!=(v18, v13) & 1) != 0 )
{
v3 = std::_Rb_tree_const_iterator<std::pair<std::pair const<std::string,int>,google::protobuf::FileDescriptorProto const*>>::operator->(v18);
v11 = std::operator==<char>(v3, v20);
}
if ( (v11 & 1) == 0 )
break;
v10 = v19;
v4 = std::_Rb_tree_const_iterator<std::pair<std::pair const<std::string,int>,google::protobuf::FileDescriptorProto const*>>::operator->(v18)
+ 32;
std::vector<int>::push_back(v10, v4, v5, v6, v7, v8);
v14 = 1;
std::_Rb_tree_const_iterator<std::pair<std::pair const<std::string,int>,google::protobuf::FileDescriptorProto const*>>::operator++(v18);
}
return v14 & 1;
}
|
GetOwningArena:
PUSH RAX
MOV qword ptr [RSP],RDI
MOV RDI,qword ptr [RSP]
CALL 0x002ea390
POP RCX
RET
|
/* google::protobuf::Arena::InternalHelper<google::protobuf::MessageLite>::GetOwningArena(google::protobuf::MessageLite
const*) */
void google::protobuf::Arena::InternalHelper<google::protobuf::MessageLite>::GetOwningArena
(MessageLite *param_1)
{
MessageLite::GetOwningArena(param_1);
return;
}
|
|
19,823
|
google::protobuf::SimpleDescriptorDatabase::DescriptorIndex<google::protobuf::FileDescriptorProto const*>::FindAllExtensionNumbers(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<int, std::allocator<int>>*)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor_database.cc
|
bool SimpleDescriptorDatabase::DescriptorIndex<Value>::FindAllExtensionNumbers(
const std::string& containing_type, std::vector<int>* output) {
typename std::map<std::pair<std::string, int>, Value>::const_iterator it =
by_extension_.lower_bound(std::make_pair(containing_type, 0));
bool success = false;
for (; it != by_extension_.end() && it->first.first == containing_type;
++it) {
output->push_back(it->first.second);
success = true;
}
return success;
}
|
O3
|
cpp
|
google::protobuf::SimpleDescriptorDatabase::DescriptorIndex<google::protobuf::FileDescriptorProto const*>::FindAllExtensionNumbers(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<int, std::allocator<int>>*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x2586a
movl $0x0, 0x20(%r15)
movq 0x70(%r12), %rbp
leaq 0x68(%r12), %r15
movq %r15, 0x8(%rsp)
testq %rbp, %rbp
je 0x159185
addq $0x60, %r12
leaq 0x10(%rsp), %r13
movq 0x8(%rsp), %r15
leaq 0x20(%rbp), %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0x15ac40
testb %al, %al
cmoveq %rbp, %r15
movzbl %al, %eax
movq 0x10(%rbp,%rax,8), %rbp
testq %rbp, %rbp
jne 0x159163
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x159199
callq 0x1f4a0
movq 0x8(%rsp), %r12
cmpq %r12, %r15
je 0x159207
movq 0x28(%r15), %rdx
cmpq 0x8(%r14), %rdx
jne 0x159207
xorl %ebp, %ebp
testq %rdx, %rdx
je 0x1591c4
movq (%r14), %rsi
movq 0x20(%r15), %rdi
callq 0x1f500
testl %eax, %eax
jne 0x159209
leaq 0x40(%r15), %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1591e0
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1591e8
movq %rbx, %rdi
callq 0x142072
movq %r15, %rdi
callq 0x1f570
cmpq %r12, %rax
je 0x15921e
movq %rax, %r15
movq 0x28(%rax), %rdx
movb $0x1, %bpl
cmpq 0x8(%r14), %rdx
je 0x1591af
jmp 0x159209
xorl %ebp, %ebp
andb $0x1, %bpl
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %bpl
jmp 0x159209
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x15923a
callq 0x1f4a0
movq %rbx, %rdi
callq 0x1f860
|
_ZN6google8protobuf24SimpleDescriptorDatabase15DescriptorIndexIPKNS0_19FileDescriptorProtoEE23FindAllExtensionNumbersERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPSt6vectorIiSaIiEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov rbx, rdx
mov r14, rsi
mov r12, rdi
lea rax, [rsp+68h+var_48]
mov [rax-10h], rax
mov rsi, [rsi]
mov rdx, [r14+8]
add rdx, rsi
lea r15, [rsp+68h+var_58]
mov rdi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov dword ptr [r15+20h], 0
mov rbp, [r12+70h]
lea r15, [r12+68h]
mov [rsp+68h+var_60], r15
test rbp, rbp
jz short loc_159185
add r12, 60h ; '`'
lea r13, [rsp+68h+var_58]
mov r15, [rsp+68h+var_60]
loc_159163:
lea rsi, [rbp+20h]
mov rdi, r12
mov rdx, r13
call _ZNKSt4lessISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiEEclERKS7_SA_; std::less<std::pair<std::string,int>>::operator()(std::pair<std::string,int> const&,std::pair<std::string,int> const&)
test al, al
cmovz r15, rbp
movzx eax, al
mov rbp, [rbp+rax*8+10h]
test rbp, rbp
jnz short loc_159163
loc_159185:
mov rdi, [rsp+68h+var_58]; void *
lea rax, [rsp+68h+var_48]
cmp rdi, rax
jz short loc_159199
call __ZdlPv; operator delete(void *)
loc_159199:
mov r12, [rsp+68h+var_60]
cmp r15, r12
jz short loc_159207
mov rdx, [r15+28h]
cmp rdx, [r14+8]
jnz short loc_159207
xor ebp, ebp
loc_1591AF:
test rdx, rdx
jz short loc_1591C4
mov rsi, [r14]
mov rdi, [r15+20h]
call _bcmp
test eax, eax
jnz short loc_159209
loc_1591C4:
lea rdx, [r15+40h]
mov rsi, [rbx+8]
cmp rsi, [rbx+10h]
jz short loc_1591E0
mov eax, [rdx]
mov [rsi], eax
add rsi, 4
mov [rbx+8], rsi
jmp short loc_1591E8
loc_1591E0:
mov rdi, rbx
call _ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_; std::vector<int>::_M_realloc_insert<int const&>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,int const&)
loc_1591E8:
mov rdi, r15
call __ZSt18_Rb_tree_incrementPKSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base const*)
cmp rax, r12
jz short loc_15921E
mov r15, rax
mov rdx, [rax+28h]
mov bpl, 1
cmp rdx, [r14+8]
jz short loc_1591AF
jmp short loc_159209
loc_159207:
xor ebp, ebp
loc_159209:
and bpl, 1
mov eax, ebp
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_15921E:
mov bpl, 1
jmp short loc_159209
mov rbx, rax
mov rdi, [rsp+arg_8]; void *
lea rax, [rsp+arg_18]
cmp rdi, rax
jz short loc_15923A
call __ZdlPv; operator delete(void *)
loc_15923A:
mov rdi, rbx
call __Unwind_Resume
|
long long google::protobuf::SimpleDescriptorDatabase::DescriptorIndex<google::protobuf::FileDescriptorProto const*>::FindAllExtensionNumbers(
long long a1,
_QWORD *a2,
long long *a3)
{
long long v5; // rbp
long long v6; // r15
unsigned __int8 v7; // al
long long v8; // rdx
unsigned int v9; // ebp
_DWORD *v10; // rdx
_DWORD *v11; // rsi
long long v12; // rax
long long v14; // [rsp+8h] [rbp-60h]
void *v15[2]; // [rsp+10h] [rbp-58h] BYREF
_BYTE v16[16]; // [rsp+20h] [rbp-48h] BYREF
int v17; // [rsp+30h] [rbp-38h]
v15[0] = v16;
std::string::_M_construct<char *>((long long)v15, (_BYTE *)*a2, *a2 + a2[1]);
v17 = 0;
v5 = *(_QWORD *)(a1 + 112);
v6 = a1 + 104;
v14 = a1 + 104;
if ( v5 )
{
v6 = a1 + 104;
do
{
v7 = std::less<std::pair<std::string,int>>::operator()(a1 + 96, v5 + 32, v15);
if ( !v7 )
v6 = v5;
v5 = *(_QWORD *)(v5 + 8LL * v7 + 16);
}
while ( v5 );
}
if ( v15[0] != v16 )
operator delete(v15[0]);
if ( v6 == v14 )
return 0;
v8 = *(_QWORD *)(v6 + 40);
if ( v8 != a2[1] )
{
return 0;
}
else
{
v9 = 0;
while ( !v8 || !(unsigned int)bcmp(*(_QWORD *)(v6 + 32), *a2) )
{
v10 = (_DWORD *)(v6 + 64);
v11 = (_DWORD *)a3[1];
if ( v11 == (_DWORD *)a3[2] )
{
std::vector<int>::_M_realloc_insert<int const&>(a3, (long long)v11, v10);
}
else
{
*v11 = *v10;
a3[1] = (long long)(v11 + 1);
}
v12 = std::_Rb_tree_increment(v6);
if ( v12 == v14 )
{
LOBYTE(v9) = 1;
return v9;
}
v6 = v12;
v8 = *(_QWORD *)(v12 + 40);
LOBYTE(v9) = 1;
if ( v8 != a2[1] )
return v9;
}
}
return v9;
}
| |||
19,824
|
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> const>::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> const*)
|
monkey531[P]llama/common/./json.hpp
|
explicit iter_impl(pointer object) noexcept : m_object(object)
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
m_it.object_iterator = typename object_t::iterator();
break;
}
case value_t::array:
{
m_it.array_iterator = typename array_t::iterator();
break;
}
case value_t::null:
case value_t::string:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::binary:
case value_t::discarded:
default:
{
m_it.primitive_iterator = primitive_iterator_t();
break;
}
}
}
|
O0
|
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> const>::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> const*):
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x8(%rsp)
callq 0xbb580
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0xbb5a0
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq %rdi, 0x10(%rsp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x50430
movq 0x10(%rsp), %rdi
callq 0xbb5c0
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0xc7e8d
jmp 0xc7eac
leaq 0x10e023(%rip), %rdi # 0x1d5eb7
leaq 0x104a81(%rip), %rsi # 0x1cc91c
movl $0x32ab, %edx # imm = 0x32AB
leaq 0x109090(%rip), %rcx # 0x1d0f37
callq 0x50230
movq 0x18(%rsp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
movq %rax, (%rsp)
subq $0x9, %rax
ja 0xc7f0b
movq (%rsp), %rax
leaq 0xfae88(%rip), %rcx # 0x1c2d54
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x30(%rsp), %rdi
callq 0xbb580
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0xc7f34
leaq 0x28(%rsp), %rdi
callq 0xbb5a0
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x10(%rax)
jmp 0xc7f34
jmp 0xc7f0b
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x50430
leaq 0x20(%rsp), %rdi
callq 0xbb5c0
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x18(%rax)
addq $0x48, %rsp
retq
nopl (%rax)
|
_ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2EPSG_:
sub rsp, 48h
mov [rsp+48h+var_8], rdi
mov [rsp+48h+var_10], rsi
mov rdi, [rsp+48h+var_8]
mov [rsp+48h+var_30], rdi
mov rax, [rsp+48h+var_10]
mov [rdi], rax
add rdi, 8
mov [rsp+48h+var_40], rdi
call _ZN9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEC2Ev; __gnu_cxx::__normal_iterator<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>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::__normal_iterator(void)
mov rdi, [rsp+48h+var_40]
add rdi, 8
call _ZN9__gnu_cxx17__normal_iteratorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEES5_ISF_SaISF_EEEC2Ev; __gnu_cxx::__normal_iterator<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::vector<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>>>::__normal_iterator(void)
mov rdi, [rsp+48h+var_40]
add rdi, 10h
mov [rsp+48h+var_38], rdi
xor esi, esi
mov edx, 8
call _memset
mov rdi, [rsp+48h+var_38]; this
call _ZN8nlohmann16json_abi_v3_11_36detail20primitive_iterator_tC2Ev; nlohmann::json_abi_v3_11_3::detail::primitive_iterator_t::primitive_iterator_t(void)
mov rax, [rsp+48h+var_30]
cmp qword ptr [rax], 0
jz short loc_C7E8D
jmp short loc_C7EAC
loc_C7E8D:
lea rdi, aAnchorMObjectN+7; "m_object != nullptr"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov edx, 32ABh
lea rcx, aNlohmannDetail_0; "nlohmann::detail::iter_impl<const nlohm"...
call ___assert_fail
loc_C7EAC:
mov rax, [rsp+48h+var_30]
mov rax, [rax]
movzx eax, byte ptr [rax]
mov [rsp+48h+var_48], rax
sub rax, 9; switch 10 cases
ja short def_C7ED3; jumptable 00000000000C7ED3 default case
mov rax, [rsp+48h+var_48]
lea rcx, jpt_C7ED3
movsxd rax, ds:(jpt_C7ED3 - 1C2D54h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_C7ED5:
lea rdi, [rsp+48h+var_18]; jumptable 00000000000C7ED3 case 1
call _ZN9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEC2Ev; __gnu_cxx::__normal_iterator<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>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::__normal_iterator(void)
mov rax, [rsp+48h+var_30]
mov rcx, [rsp+48h+var_18]
mov [rax+8], rcx
jmp short loc_C7F34
loc_C7EEF:
lea rdi, [rsp+48h+var_20]; jumptable 00000000000C7ED3 case 2
call _ZN9__gnu_cxx17__normal_iteratorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEES5_ISF_SaISF_EEEC2Ev; __gnu_cxx::__normal_iterator<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::vector<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>>>::__normal_iterator(void)
mov rax, [rsp+48h+var_30]
mov rcx, [rsp+48h+var_20]
mov [rax+10h], rcx
jmp short loc_C7F34
loc_C7F09:
jmp short $+2; jumptable 00000000000C7ED3 cases 0,3-9
def_C7ED3:
lea rdi, [rsp+48h+var_28]; jumptable 00000000000C7ED3 default case
xor esi, esi
mov edx, 8
call _memset
lea rdi, [rsp+48h+var_28]; this
call _ZN8nlohmann16json_abi_v3_11_36detail20primitive_iterator_tC2Ev; nlohmann::json_abi_v3_11_3::detail::primitive_iterator_t::primitive_iterator_t(void)
mov rax, [rsp+48h+var_30]
mov rcx, [rsp+48h+var_28]
mov [rax+18h], rcx
loc_C7F34:
add rsp, 48h
retn
|
_QWORD * nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::iter_impl(
_QWORD *a1,
long long a2)
{
_QWORD *result; // rax
long long v3; // [rsp+20h] [rbp-28h] BYREF
long long v4; // [rsp+28h] [rbp-20h] BYREF
_QWORD v5[3]; // [rsp+30h] [rbp-18h] BYREF
v5[2] = a1;
v5[1] = a2;
*a1 = a2;
__gnu_cxx::__normal_iterator<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>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::__normal_iterator(a1 + 1);
__gnu_cxx::__normal_iterator<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::vector<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>>>::__normal_iterator(a1 + 2);
memset(a1 + 3, 0LL, sizeof(_QWORD));
nlohmann::json_abi_v3_11_3::detail::primitive_iterator_t::primitive_iterator_t((nlohmann::json_abi_v3_11_3::detail::primitive_iterator_t *)(a1 + 3));
if ( !*a1 )
__assert_fail(
"m_object != nullptr",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
12971LL,
"nlohmann::detail::iter_impl<const nlohmann::basic_json<nlohmann::ordered_map>>::iter_impl(pointer) [BasicJsonType "
"= const nlohmann::basic_json<nlohmann::ordered_map>]");
switch ( *(_BYTE *)*a1 )
{
case 1:
__gnu_cxx::__normal_iterator<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>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::__normal_iterator(v5);
result = a1;
a1[1] = v5[0];
break;
case 2:
__gnu_cxx::__normal_iterator<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::vector<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>>>::__normal_iterator(&v4);
result = a1;
a1[2] = v4;
break;
default:
memset(&v3, 0LL, sizeof(v3));
nlohmann::json_abi_v3_11_3::detail::primitive_iterator_t::primitive_iterator_t((nlohmann::json_abi_v3_11_3::detail::primitive_iterator_t *)&v3);
result = a1;
a1[3] = v3;
break;
}
return result;
}
|
operator():
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RAX]
CALL 0x001523f0
TEST AL,0x1
JNZ 0x002c7e41
JMP 0x002c7e48
LAB_002c7e41:
MOV byte ptr [RSP + 0x27],0x0
JMP 0x002c7e75
LAB_002c7e48:
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX + 0x8]
MOV RSI,qword ptr [RAX]
MOV byte ptr [RSP + 0x17],0x1
LEA RDX,[RSP + 0x17]
CALL 0x002c6e20
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX]
CALL 0x00152820
MOV byte ptr [RSP + 0x27],0x1
LAB_002c7e75:
MOV AL,byte ptr [RSP + 0x27]
AND AL,0x1
ADD RSP,0x28
RET
|
/* SchemaConverter::_visit_pattern(std::__cxx11::string const&, std::__cxx11::string
const&)::{lambda()#1}::TEMPNAMEPLACEHOLDERVALUE[abi:cxx11]()
const::{lambda()#2}::TEMPNAMEPLACEHOLDERVALUE[abi:cxx11]()
const::{lambda()#1}::TEMPNAMEPLACEHOLDERVALUE() const */
_func_TEMPNAMEPLACEHOLDERVALUE * __thiscall const::{lambda()#1}::operator()(_lambda___1_ *this)
{
ulong uVar1;
bool bVar2;
bool local_11;
_lambda___1_ *local_10;
local_10 = this;
uVar1 = std::__cxx11::string::empty();
bVar2 = (uVar1 & 1) == 0;
if (bVar2) {
local_11 = true;
std::
vector<std::pair<std::__cxx11::string,bool>,std::allocator<std::pair<std::__cxx11::string,bool>>>
::emplace_back<std::__cxx11::string&,bool>
(*(vector<std::pair<std::__cxx11::string,bool>,std::allocator<std::pair<std::__cxx11::string,bool>>>
**)(this + 8),*(string **)this,&local_11);
uVar1 = std::__cxx11::string::clear();
}
return (_func_TEMPNAMEPLACEHOLDERVALUE *)CONCAT71((int7)(uVar1 >> 8),bVar2);
}
|
|
19,825
|
client_factory::create_player(Dimension*, entt::entity)
|
untodesu[P]voxelius/game/client/factory.cc
|
void client_factory::create_player(Dimension *dimension, entt::entity entity)
{
shared_factory::create_player(dimension, entity);
const auto &head = dimension->entities.get<HeadComponent>(entity);
dimension->entities.emplace_or_replace<HeadComponentIntr>(entity, head);
dimension->entities.emplace_or_replace<HeadComponentPrev>(entity, head);
const auto &transform = dimension->entities.get<TransformComponent>(entity);
dimension->entities.emplace_or_replace<TransformComponentIntr>(entity, transform);
dimension->entities.emplace_or_replace<TransformComponentPrev>(entity, transform);
if(globals::sound_ctx) {
dimension->entities.emplace_or_replace<SoundEmitterComponent>(entity);
}
}
|
O0
|
cpp
|
client_factory::create_player(Dimension*, entt::entity):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x14d360
movq -0x8(%rbp), %rdi
addq $0x158, %rdi # imm = 0x158
movl -0xc(%rbp), %esi
callq 0x8f5a0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x158, %rdi # imm = 0x158
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x8f5e0
movq -0x8(%rbp), %rdi
addq $0x158, %rdi # imm = 0x158
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x8f690
movq -0x8(%rbp), %rdi
addq $0x158, %rdi # imm = 0x158
movl -0xc(%rbp), %esi
callq 0x8f740
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x158, %rdi # imm = 0x158
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x8f780
movq -0x8(%rbp), %rdi
addq $0x158, %rdi # imm = 0x158
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x8f830
leaq 0x47ed04(%rip), %rax # 0x50e280
cmpq $0x0, (%rax)
je 0x8f595
movq -0x8(%rbp), %rdi
addq $0x158, %rdi # imm = 0x158
movl -0xc(%rbp), %esi
callq 0x8f8e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
_ZN14client_factory13create_playerEP9DimensionN4entt6entityE:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
call _ZN14shared_factory13create_playerEP9DimensionN4entt6entityE; shared_factory::create_player(Dimension *,entt::entity)
mov rdi, [rbp+var_8]
add rdi, 158h
mov esi, [rbp+var_C]
call _ZN4entt14basic_registryINS_6entityESaIS1_EE3getIJ13HeadComponentEEEDcS1_
mov [rbp+var_18], rax
mov rdi, [rbp+var_8]
add rdi, 158h
mov esi, [rbp+var_C]
mov rdx, [rbp+var_18]
call _ZN4entt14basic_registryINS_6entityESaIS1_EE18emplace_or_replaceI17HeadComponentIntrJRK13HeadComponentEEEDcS1_DpOT0_
mov rdi, [rbp+var_8]
add rdi, 158h
mov esi, [rbp+var_C]
mov rdx, [rbp+var_18]
call _ZN4entt14basic_registryINS_6entityESaIS1_EE18emplace_or_replaceI17HeadComponentPrevJRK13HeadComponentEEEDcS1_DpOT0_
mov rdi, [rbp+var_8]
add rdi, 158h
mov esi, [rbp+var_C]
call _ZN4entt14basic_registryINS_6entityESaIS1_EE3getIJ18TransformComponentEEEDcS1_
mov [rbp+var_20], rax
mov rdi, [rbp+var_8]
add rdi, 158h
mov esi, [rbp+var_C]
mov rdx, [rbp+var_20]
call _ZN4entt14basic_registryINS_6entityESaIS1_EE18emplace_or_replaceI22TransformComponentIntrJRK18TransformComponentEEEDcS1_DpOT0_
mov rdi, [rbp+var_8]
add rdi, 158h
mov esi, [rbp+var_C]
mov rdx, [rbp+var_20]
call _ZN4entt14basic_registryINS_6entityESaIS1_EE18emplace_or_replaceI22TransformComponentPrevJRK18TransformComponentEEEDcS1_DpOT0_
lea rax, _ZN7globals9sound_ctxE; globals::sound_ctx
cmp qword ptr [rax], 0
jz short loc_8F595
mov rdi, [rbp+var_8]
add rdi, 158h
mov esi, [rbp+var_C]
call _ZN4entt14basic_registryINS_6entityESaIS1_EE18emplace_or_replaceI21SoundEmitterComponentJEEEDcS1_DpOT0_
loc_8F595:
add rsp, 20h
pop rbp
retn
|
_QWORD * client_factory::create_player(long long a1, unsigned int a2)
{
_QWORD *result; // rax
long long v3; // [rsp+0h] [rbp-20h]
long long v4; // [rsp+8h] [rbp-18h]
shared_factory::create_player(a1, a2);
v4 = entt::basic_registry<entt::entity,std::allocator<entt::entity>>::get<HeadComponent>(a1 + 344, a2);
entt::basic_registry<entt::entity,std::allocator<entt::entity>>::emplace_or_replace<HeadComponentIntr,HeadComponent const&>(
a1 + 344,
a2,
v4);
entt::basic_registry<entt::entity,std::allocator<entt::entity>>::emplace_or_replace<HeadComponentPrev,HeadComponent const&>(
a1 + 344,
a2,
v4);
v3 = entt::basic_registry<entt::entity,std::allocator<entt::entity>>::get<TransformComponent>(a1 + 344, a2);
entt::basic_registry<entt::entity,std::allocator<entt::entity>>::emplace_or_replace<TransformComponentIntr,TransformComponent const&>(
a1 + 344,
a2,
v3);
entt::basic_registry<entt::entity,std::allocator<entt::entity>>::emplace_or_replace<TransformComponentPrev,TransformComponent const&>(
a1 + 344,
a2,
v3);
result = globals::sound_ctx;
if ( globals::sound_ctx[0] )
return (_QWORD *)entt::basic_registry<entt::entity,std::allocator<entt::entity>>::emplace_or_replace<SoundEmitterComponent>(
a1 + 344,
a2);
return result;
}
|
create_player:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
CALL 0x0024d360
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x158
MOV ESI,dword ptr [RBP + -0xc]
CALL 0x0018f5a0
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x158
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x0018f5e0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x158
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x0018f690
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x158
MOV ESI,dword ptr [RBP + -0xc]
CALL 0x0018f740
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x158
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0018f780
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x158
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0018f830
LEA RAX,[0x60e280]
CMP qword ptr [RAX],0x0
JZ 0x0018f595
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x158
MOV ESI,dword ptr [RBP + -0xc]
CALL 0x0018f8e0
LAB_0018f595:
ADD RSP,0x20
POP RBP
RET
|
/* client_factory::create_player(Dimension*, entt::entity) */
void client_factory::create_player(long param_1,int4 param_2)
{
_func_decltype_auto *p_Var1;
shared_factory::create_player(param_1,param_2);
p_Var1 = entt::basic_registry<entt::entity,std::allocator<entt::entity>>::get<HeadComponent>
((basic_registry<entt::entity,std::allocator<entt::entity>> *)(param_1 + 0x158)
,param_2);
entt::basic_registry<entt::entity,std::allocator<entt::entity>>::
emplace_or_replace<HeadComponentIntr,HeadComponent_const&>
((basic_registry<entt::entity,std::allocator<entt::entity>> *)(param_1 + 0x158),param_2,
p_Var1);
entt::basic_registry<entt::entity,std::allocator<entt::entity>>::
emplace_or_replace<HeadComponentPrev,HeadComponent_const&>
((basic_registry<entt::entity,std::allocator<entt::entity>> *)(param_1 + 0x158),param_2,
p_Var1);
p_Var1 = entt::basic_registry<entt::entity,std::allocator<entt::entity>>::get<TransformComponent>
((basic_registry<entt::entity,std::allocator<entt::entity>> *)(param_1 + 0x158)
,param_2);
entt::basic_registry<entt::entity,std::allocator<entt::entity>>::
emplace_or_replace<TransformComponentIntr,TransformComponent_const&>
((basic_registry<entt::entity,std::allocator<entt::entity>> *)(param_1 + 0x158),param_2,
p_Var1);
entt::basic_registry<entt::entity,std::allocator<entt::entity>>::
emplace_or_replace<TransformComponentPrev,TransformComponent_const&>
((basic_registry<entt::entity,std::allocator<entt::entity>> *)(param_1 + 0x158),param_2,
p_Var1);
if (globals::sound_ctx != 0) {
entt::basic_registry<entt::entity,std::allocator<entt::entity>>::
emplace_or_replace<SoundEmitterComponent>
((basic_registry<entt::entity,std::allocator<entt::entity>> *)(param_1 + 0x158),
param_2);
}
return;
}
|
|
19,826
|
normalize_dirname
|
eloqsql/mysys/mf_pack.c
|
size_t normalize_dirname(char *to, const char *from)
{
size_t length;
char buff[FN_REFLEN + 1];
DBUG_ENTER("normalize_dirname");
/*
Despite the name, this actually converts the name to the system's
format (TODO: name this properly).
*/
(void) intern_filename(buff, from);
length= strlen(buff); /* Fix that '/' is last */
if (length &&
#ifdef FN_DEVCHAR
buff[length - 1] != FN_DEVCHAR &&
#endif
buff[length - 1] != FN_LIBCHAR && buff[length - 1] != '/')
{
/* we need reserve 2 bytes for the trailing slash and the zero */
if (length >= sizeof (buff) - 1)
length= sizeof (buff) - 2;
buff[length]= FN_LIBCHAR;
buff[length + 1]= '\0';
}
length=cleanup_dirname(to, buff);
DBUG_RETURN(length);
}
|
O0
|
c
|
normalize_dirname:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x218(%rbp)
movq %rsi, -0x220(%rbp)
leaq -0x210(%rbp), %rdi
movq -0x220(%rbp), %rsi
callq 0xeac40
leaq -0x210(%rbp), %rdi
callq 0x2a330
movq %rax, -0x228(%rbp)
cmpq $0x0, -0x228(%rbp)
je 0xeb2bc
movq -0x228(%rbp), %rax
subq $0x1, %rax
movsbl -0x210(%rbp,%rax), %eax
cmpl $0x2f, %eax
je 0xeb2bc
movq -0x228(%rbp), %rax
subq $0x1, %rax
movsbl -0x210(%rbp,%rax), %eax
cmpl $0x2f, %eax
je 0xeb2bc
cmpq $0x200, -0x228(%rbp) # imm = 0x200
jb 0xeb29e
movq $0x1ff, -0x228(%rbp) # imm = 0x1FF
movq -0x228(%rbp), %rax
movb $0x2f, -0x210(%rbp,%rax)
movq -0x228(%rbp), %rax
movb $0x0, -0x20f(%rbp,%rax)
movq -0x218(%rbp), %rdi
leaq -0x210(%rbp), %rsi
callq 0xead30
movq %rax, -0x228(%rbp)
movq -0x228(%rbp), %rax
movq %rax, -0x230(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xeb306
movq -0x230(%rbp), %rax
addq $0x230, %rsp # imm = 0x230
popq %rbp
retq
callq 0x2a250
nopl (%rax,%rax)
|
normalize_dirname:
push rbp
mov rbp, rsp
sub rsp, 230h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_218], rdi
mov [rbp+var_220], rsi
lea rdi, [rbp+var_210]
mov rsi, [rbp+var_220]
call intern_filename
lea rdi, [rbp+var_210]
call _strlen
mov [rbp+var_228], rax
cmp [rbp+var_228], 0
jz short loc_EB2BC
mov rax, [rbp+var_228]
sub rax, 1
movsx eax, [rbp+rax+var_210]
cmp eax, 2Fh ; '/'
jz short loc_EB2BC
mov rax, [rbp+var_228]
sub rax, 1
movsx eax, [rbp+rax+var_210]
cmp eax, 2Fh ; '/'
jz short loc_EB2BC
cmp [rbp+var_228], 200h
jb short loc_EB29E
mov [rbp+var_228], 1FFh
loc_EB29E:
mov rax, [rbp+var_228]
mov [rbp+rax+var_210], 2Fh ; '/'
mov rax, [rbp+var_228]
mov [rbp+rax+var_20F], 0
loc_EB2BC:
mov rdi, [rbp+var_218]
lea rsi, [rbp+var_210]
call cleanup_dirname
mov [rbp+var_228], rax
mov rax, [rbp+var_228]
mov [rbp+var_230], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_EB306
mov rax, [rbp+var_230]
add rsp, 230h
pop rbp
retn
loc_EB306:
call ___stack_chk_fail
|
long long normalize_dirname(long long a1, _BYTE *a2)
{
unsigned long long v3; // [rsp+8h] [rbp-228h]
long long v4; // [rsp+18h] [rbp-218h]
_BYTE v5[520]; // [rsp+20h] [rbp-210h] BYREF
unsigned long long v6; // [rsp+228h] [rbp-8h]
v6 = __readfsqword(0x28u);
v4 = a1;
intern_filename((long long)v5, a2);
v3 = strlen(v5);
if ( v3 && v5[v3 - 1] != 47 )
{
if ( v3 >= 0x200 )
v3 = 511LL;
v5[v3] = 47;
v5[v3 + 1] = 0;
}
return cleanup_dirname(v4, v5);
}
|
normalize_dirname:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x230
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x218],RDI
MOV qword ptr [RBP + -0x220],RSI
LEA RDI,[RBP + -0x210]
MOV RSI,qword ptr [RBP + -0x220]
CALL 0x001eac40
LEA RDI,[RBP + -0x210]
CALL 0x0012a330
MOV qword ptr [RBP + -0x228],RAX
CMP qword ptr [RBP + -0x228],0x0
JZ 0x001eb2bc
MOV RAX,qword ptr [RBP + -0x228]
SUB RAX,0x1
MOVSX EAX,byte ptr [RBP + RAX*0x1 + -0x210]
CMP EAX,0x2f
JZ 0x001eb2bc
MOV RAX,qword ptr [RBP + -0x228]
SUB RAX,0x1
MOVSX EAX,byte ptr [RBP + RAX*0x1 + -0x210]
CMP EAX,0x2f
JZ 0x001eb2bc
CMP qword ptr [RBP + -0x228],0x200
JC 0x001eb29e
MOV qword ptr [RBP + -0x228],0x1ff
LAB_001eb29e:
MOV RAX,qword ptr [RBP + -0x228]
MOV byte ptr [RBP + RAX*0x1 + -0x210],0x2f
MOV RAX,qword ptr [RBP + -0x228]
MOV byte ptr [RBP + RAX*0x1 + -0x20f],0x0
LAB_001eb2bc:
MOV RDI,qword ptr [RBP + -0x218]
LEA RSI,[RBP + -0x210]
CALL 0x001ead30
MOV qword ptr [RBP + -0x228],RAX
MOV RAX,qword ptr [RBP + -0x228]
MOV qword ptr [RBP + -0x230],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001eb306
MOV RAX,qword ptr [RBP + -0x230]
ADD RSP,0x230
POP RBP
RET
LAB_001eb306:
CALL 0x0012a250
|
int8 normalize_dirname(int8 param_1,int8 param_2)
{
int8 uVar1;
long in_FS_OFFSET;
size_t local_230;
int8 local_220;
char local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_220 = param_1;
intern_filename(local_218,param_2);
local_230 = strlen(local_218);
if (((local_230 != 0) && (local_218[local_230 - 1] != '/')) && (local_218[local_230 - 1] != '/'))
{
if (0x1ff < local_230) {
local_230 = 0x1ff;
}
local_218[local_230] = '/';
local_218[local_230 + 1] = '\0';
}
uVar1 = cleanup_dirname(local_220,local_218);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return uVar1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
19,827
|
OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetLimitStencil(int) const
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/../far/stencilTable.h
|
inline LimitStencilReal<REAL>
LimitStencilTableReal<REAL>::GetLimitStencil(Index i) const {
assert((! this->GetOffsets().empty()) && i<(int)this->GetOffsets().size());
Index ofs = this->GetOffsets()[i];
if (!_duWeights.empty() && !_dvWeights.empty() &&
!_duuWeights.empty() && !_duvWeights.empty() && !_dvvWeights.empty()) {
return LimitStencilReal<REAL>(
const_cast<int *>(&this->GetSizes()[i]),
const_cast<Index *>(&this->GetControlIndices()[ofs]),
const_cast<REAL *>(&this->GetWeights()[ofs]),
const_cast<REAL *>(&GetDuWeights()[ofs]),
const_cast<REAL *>(&GetDvWeights()[ofs]),
const_cast<REAL *>(&GetDuuWeights()[ofs]),
const_cast<REAL *>(&GetDuvWeights()[ofs]),
const_cast<REAL *>(&GetDvvWeights()[ofs]) );
} else if (!_duWeights.empty() && !_dvWeights.empty()) {
return LimitStencilReal<REAL>(
const_cast<int *>(&this->GetSizes()[i]),
const_cast<Index *>(&this->GetControlIndices()[ofs]),
const_cast<REAL *>(&this->GetWeights()[ofs]),
const_cast<REAL *>(&GetDuWeights()[ofs]),
const_cast<REAL *>(&GetDvWeights()[ofs]) );
} else {
return LimitStencilReal<REAL>(
const_cast<int *>(&this->GetSizes()[i]),
const_cast<Index *>(&this->GetControlIndices()[ofs]),
const_cast<REAL *>(&this->GetWeights()[ofs]) );
}
}
|
O0
|
c
|
OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetLimitStencil(int) const:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xcd810
movq %rax, %rdi
callq 0xca720
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x19(%rbp)
jne 0x155b07
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0xcd810
movq %rax, %rdi
callq 0xd7ae0
movq %rax, %rcx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
setl %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x155b10
jmp 0x155b12
jmp 0x155b31
leaq 0x9bcca(%rip), %rdi # 0x1f17e3
leaq 0x9bb88(%rip), %rsi # 0x1f16a8
movl $0x2ee, %edx # imm = 0x2EE
leaq 0x9bcfa(%rip), %rcx # 0x1f1826
callq 0xc9440
movq -0x28(%rbp), %rdi
callq 0xcd810
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0xd09b0
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x18(%rbp)
addq $0x70, %rdi
callq 0xc8700
testb $0x1, %al
jne 0x155cbc
movq -0x28(%rbp), %rdi
addq $0x88, %rdi
callq 0xc8700
testb $0x1, %al
jne 0x155cbc
movq -0x28(%rbp), %rdi
addq $0xa0, %rdi
callq 0xc8700
testb $0x1, %al
jne 0x155cbc
movq -0x28(%rbp), %rdi
addq $0xb8, %rdi
callq 0xc8700
testb $0x1, %al
jne 0x155cbc
movq -0x28(%rbp), %rdi
addq $0xd0, %rdi
callq 0xc8700
testb $0x1, %al
jne 0x155cbc
movq -0x28(%rbp), %rdi
callq 0xc6b70
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0xd09b0
movq -0x28(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0xd1d10
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0xd09b0
movq -0x28(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0xc5400
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0xd1480
movq -0x28(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0xd3b00
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0xd1480
movq -0x28(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0xd10b0
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0xd1480
movq -0x28(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0xc7da0
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0xd1480
movq -0x28(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0xcf140
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0xd1480
movq -0x28(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0xcde90
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0xd1480
movq -0x38(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
movq -0x60(%rbp), %r8
movq -0x58(%rbp), %r9
movq -0x50(%rbp), %r11
movq -0x48(%rbp), %r10
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0xd0da0
jmp 0x155e3a
movq -0x28(%rbp), %rdi
addq $0x70, %rdi
callq 0xc8700
testb $0x1, %al
jne 0x155db1
movq -0x28(%rbp), %rdi
addq $0x88, %rdi
callq 0xc8700
testb $0x1, %al
jne 0x155db1
movq -0x28(%rbp), %rdi
callq 0xc6b70
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0xd09b0
movq -0x28(%rbp), %rdi
movq %rax, -0x98(%rbp)
callq 0xd1d10
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0xd09b0
movq -0x28(%rbp), %rdi
movq %rax, -0x90(%rbp)
callq 0xc5400
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0xd1480
movq -0x28(%rbp), %rdi
movq %rax, -0x88(%rbp)
callq 0xd3b00
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0xd1480
movq -0x28(%rbp), %rdi
movq %rax, -0x80(%rbp)
callq 0xd10b0
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0xd1480
movq -0x38(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
movq -0x88(%rbp), %rcx
movq -0x80(%rbp), %r8
movq %rax, %r9
xorl %eax, %eax
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0xd0da0
jmp 0x155e3a
movq -0x28(%rbp), %rdi
callq 0xc6b70
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0xd09b0
movq -0x28(%rbp), %rdi
movq %rax, -0xa8(%rbp)
callq 0xd1d10
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0xd09b0
movq -0x28(%rbp), %rdi
movq %rax, -0xa0(%rbp)
callq 0xc5400
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0xd1480
movq -0x38(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq %rax, %rcx
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %r8
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0xd0da0
movq -0x30(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
_ZNK10OpenSubdiv6v3_6_03Far21LimitStencilTableRealIfE15GetLimitStencilEi:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov [rbp+var_38], rdi
mov rax, rdi
mov [rbp+var_30], rax
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov rdi, [rbp+var_10]
mov [rbp+var_28], rdi
call __ZNK10OpenSubdiv6v3_6_03Far16StencilTableRealIfE10GetOffsetsEv; OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::GetOffsets(void)
mov rdi, rax
call __ZNKSt6vectorIiSaIiEE5emptyEv; std::vector<int>::empty(void)
mov cl, al
xor eax, eax
test cl, 1
mov [rbp+var_19], al
jnz short loc_155B07
mov rdi, [rbp+var_28]
mov eax, [rbp+var_14]
mov [rbp+var_3C], eax
call __ZNK10OpenSubdiv6v3_6_03Far16StencilTableRealIfE10GetOffsetsEv; OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::GetOffsets(void)
mov rdi, rax
call __ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
mov rcx, rax
mov eax, [rbp+var_3C]
cmp eax, ecx
setl al
mov [rbp+var_19], al
loc_155B07:
mov al, [rbp+var_19]
test al, 1
jnz short loc_155B10
jmp short loc_155B12
loc_155B10:
jmp short loc_155B31
loc_155B12:
lea rdi, aThisGetoffsets; "(! this->GetOffsets().empty()) && i<(in"...
lea rsi, aWorkspaceLlm4b_18; "/workspace/llm4binary/github/2025_star3"...
mov edx, 2EEh
lea rcx, aLimitstencilre; "LimitStencilReal<REAL> OpenSubdiv::v3_6"...
call ___assert_fail
loc_155B31:
mov rdi, [rbp+var_28]
call __ZNK10OpenSubdiv6v3_6_03Far16StencilTableRealIfE10GetOffsetsEv; OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::GetOffsets(void)
mov rdi, rax
movsxd rsi, [rbp+var_14]
call __ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov rdi, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_18], eax
add rdi, 70h ; 'p'
call __ZNKSt6vectorIfSaIfEE5emptyEv; std::vector<float>::empty(void)
test al, 1
jnz loc_155CBC
mov rdi, [rbp+var_28]
add rdi, 88h
call __ZNKSt6vectorIfSaIfEE5emptyEv; std::vector<float>::empty(void)
test al, 1
jnz loc_155CBC
mov rdi, [rbp+var_28]
add rdi, 0A0h
call __ZNKSt6vectorIfSaIfEE5emptyEv; std::vector<float>::empty(void)
test al, 1
jnz loc_155CBC
mov rdi, [rbp+var_28]
add rdi, 0B8h
call __ZNKSt6vectorIfSaIfEE5emptyEv; std::vector<float>::empty(void)
test al, 1
jnz loc_155CBC
mov rdi, [rbp+var_28]
add rdi, 0D0h
call __ZNKSt6vectorIfSaIfEE5emptyEv; std::vector<float>::empty(void)
test al, 1
jnz loc_155CBC
mov rdi, [rbp+var_28]
call __ZNK10OpenSubdiv6v3_6_03Far16StencilTableRealIfE8GetSizesEv; OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::GetSizes(void)
mov rdi, rax
movsxd rsi, [rbp+var_14]
call __ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov rdi, [rbp+var_28]
mov [rbp+var_78], rax
call __ZNK10OpenSubdiv6v3_6_03Far16StencilTableRealIfE17GetControlIndicesEv; OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::GetControlIndices(void)
mov rdi, rax
movsxd rsi, [rbp+var_18]
call __ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov rdi, [rbp+var_28]
mov [rbp+var_70], rax
call __ZNK10OpenSubdiv6v3_6_03Far16StencilTableRealIfE10GetWeightsEv; OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::GetWeights(void)
mov rdi, rax
movsxd rsi, [rbp+var_18]
call __ZNKSt6vectorIfSaIfEEixEm; std::vector<float>::operator[](ulong)
mov rdi, [rbp+var_28]
mov [rbp+var_68], rax
call __ZNK10OpenSubdiv6v3_6_03Far21LimitStencilTableRealIfE12GetDuWeightsEv; OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetDuWeights(void)
mov rdi, rax
movsxd rsi, [rbp+var_18]
call __ZNKSt6vectorIfSaIfEEixEm; std::vector<float>::operator[](ulong)
mov rdi, [rbp+var_28]
mov [rbp+var_60], rax
call __ZNK10OpenSubdiv6v3_6_03Far21LimitStencilTableRealIfE12GetDvWeightsEv; OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetDvWeights(void)
mov rdi, rax
movsxd rsi, [rbp+var_18]
call __ZNKSt6vectorIfSaIfEEixEm; std::vector<float>::operator[](ulong)
mov rdi, [rbp+var_28]
mov [rbp+var_58], rax
call __ZNK10OpenSubdiv6v3_6_03Far21LimitStencilTableRealIfE13GetDuuWeightsEv; OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetDuuWeights(void)
mov rdi, rax
movsxd rsi, [rbp+var_18]
call __ZNKSt6vectorIfSaIfEEixEm; std::vector<float>::operator[](ulong)
mov rdi, [rbp+var_28]
mov [rbp+var_50], rax
call __ZNK10OpenSubdiv6v3_6_03Far21LimitStencilTableRealIfE13GetDuvWeightsEv; OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetDuvWeights(void)
mov rdi, rax
movsxd rsi, [rbp+var_18]
call __ZNKSt6vectorIfSaIfEEixEm; std::vector<float>::operator[](ulong)
mov rdi, [rbp+var_28]
mov [rbp+var_48], rax
call __ZNK10OpenSubdiv6v3_6_03Far21LimitStencilTableRealIfE13GetDvvWeightsEv; OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetDvvWeights(void)
mov rdi, rax
movsxd rsi, [rbp+var_18]
call __ZNKSt6vectorIfSaIfEEixEm; std::vector<float>::operator[](ulong)
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_78]
mov rdx, [rbp+var_70]
mov rcx, [rbp+var_68]
mov r8, [rbp+var_60]
mov r9, [rbp+var_58]
mov r11, [rbp+var_50]
mov r10, [rbp+var_48]
mov [rsp+0C0h+var_C0], r11
mov [rsp+0C0h+var_B8], r10
mov [rsp+0C0h+var_B0], rax
call __ZN10OpenSubdiv6v3_6_03Far16LimitStencilRealIfEC2EPiS4_PfS5_S5_S5_S5_S5_; OpenSubdiv::v3_6_0::Far::LimitStencilReal<float>::LimitStencilReal(int *,int *,float *,float *,float *,float *,float *,float *)
jmp loc_155E3A
loc_155CBC:
mov rdi, [rbp+var_28]
add rdi, 70h ; 'p'
call __ZNKSt6vectorIfSaIfEE5emptyEv; std::vector<float>::empty(void)
test al, 1
jnz loc_155DB1
mov rdi, [rbp+var_28]
add rdi, 88h
call __ZNKSt6vectorIfSaIfEE5emptyEv; std::vector<float>::empty(void)
test al, 1
jnz loc_155DB1
mov rdi, [rbp+var_28]
call __ZNK10OpenSubdiv6v3_6_03Far16StencilTableRealIfE8GetSizesEv; OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::GetSizes(void)
mov rdi, rax
movsxd rsi, [rbp+var_14]
call __ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov rdi, [rbp+var_28]
mov [rbp+var_98], rax
call __ZNK10OpenSubdiv6v3_6_03Far16StencilTableRealIfE17GetControlIndicesEv; OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::GetControlIndices(void)
mov rdi, rax
movsxd rsi, [rbp+var_18]
call __ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov rdi, [rbp+var_28]
mov [rbp+var_90], rax
call __ZNK10OpenSubdiv6v3_6_03Far16StencilTableRealIfE10GetWeightsEv; OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::GetWeights(void)
mov rdi, rax
movsxd rsi, [rbp+var_18]
call __ZNKSt6vectorIfSaIfEEixEm; std::vector<float>::operator[](ulong)
mov rdi, [rbp+var_28]
mov [rbp+var_88], rax
call __ZNK10OpenSubdiv6v3_6_03Far21LimitStencilTableRealIfE12GetDuWeightsEv; OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetDuWeights(void)
mov rdi, rax
movsxd rsi, [rbp+var_18]
call __ZNKSt6vectorIfSaIfEEixEm; std::vector<float>::operator[](ulong)
mov rdi, [rbp+var_28]
mov [rbp+var_80], rax
call __ZNK10OpenSubdiv6v3_6_03Far21LimitStencilTableRealIfE12GetDvWeightsEv; OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetDvWeights(void)
mov rdi, rax
movsxd rsi, [rbp+var_18]
call __ZNKSt6vectorIfSaIfEEixEm; std::vector<float>::operator[](ulong)
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_98]
mov rdx, [rbp+var_90]
mov rcx, [rbp+var_88]
mov r8, [rbp+var_80]
mov r9, rax
xor eax, eax
mov [rsp+0C0h+var_C0], 0
mov [rsp+0C0h+var_B8], 0
mov [rsp+0C0h+var_B0], 0
call __ZN10OpenSubdiv6v3_6_03Far16LimitStencilRealIfEC2EPiS4_PfS5_S5_S5_S5_S5_; OpenSubdiv::v3_6_0::Far::LimitStencilReal<float>::LimitStencilReal(int *,int *,float *,float *,float *,float *,float *,float *)
jmp loc_155E3A
loc_155DB1:
mov rdi, [rbp+var_28]
call __ZNK10OpenSubdiv6v3_6_03Far16StencilTableRealIfE8GetSizesEv; OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::GetSizes(void)
mov rdi, rax
movsxd rsi, [rbp+var_14]
call __ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov rdi, [rbp+var_28]
mov [rbp+var_A8], rax
call __ZNK10OpenSubdiv6v3_6_03Far16StencilTableRealIfE17GetControlIndicesEv; OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::GetControlIndices(void)
mov rdi, rax
movsxd rsi, [rbp+var_18]
call __ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov rdi, [rbp+var_28]
mov [rbp+var_A0], rax
call __ZNK10OpenSubdiv6v3_6_03Far16StencilTableRealIfE10GetWeightsEv; OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::GetWeights(void)
mov rdi, rax
movsxd rsi, [rbp+var_18]
call __ZNKSt6vectorIfSaIfEEixEm; std::vector<float>::operator[](ulong)
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_A8]
mov rdx, [rbp+var_A0]
mov rcx, rax
xor eax, eax
mov r9d, eax
mov r8, r9
mov [rsp+0C0h+var_C0], 0
mov [rsp+0C0h+var_B8], 0
mov [rsp+0C0h+var_B0], 0
call __ZN10OpenSubdiv6v3_6_03Far16LimitStencilRealIfEC2EPiS4_PfS5_S5_S5_S5_S5_; OpenSubdiv::v3_6_0::Far::LimitStencilReal<float>::LimitStencilReal(int *,int *,float *,float *,float *,float *,float *,float *)
loc_155E3A:
mov rax, [rbp+var_30]
add rsp, 0C0h
pop rbp
retn
|
_QWORD * OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetLimitStencil(
_QWORD *a1,
long long a2,
int a3)
{
long long Offsets; // rax
long long v4; // rax
long long v5; // rax
char v6; // al
long long v7; // rax
long long v8; // rax
long long v9; // rax
long long v10; // rax
long long v11; // rax
long long DuuWeights; // rax
long long DuvWeights; // rax
long long DvvWeights; // rax
long long v15; // rax
long long v16; // rax
long long v17; // rax
long long v18; // rax
long long DuWeights; // rax
long long DvWeights; // rax
long long v21; // rax
long long Sizes; // rax
long long ControlIndices; // rax
long long Weights; // rax
long long v25; // rax
long long v27; // [rsp+18h] [rbp-A8h]
long long v28; // [rsp+20h] [rbp-A0h]
long long v29; // [rsp+28h] [rbp-98h]
long long v30; // [rsp+30h] [rbp-90h]
long long v31; // [rsp+38h] [rbp-88h]
long long v32; // [rsp+40h] [rbp-80h]
long long v33; // [rsp+48h] [rbp-78h]
long long v34; // [rsp+50h] [rbp-70h]
long long v35; // [rsp+58h] [rbp-68h]
long long v36; // [rsp+60h] [rbp-60h]
long long v37; // [rsp+68h] [rbp-58h]
long long v38; // [rsp+70h] [rbp-50h]
long long v39; // [rsp+78h] [rbp-48h]
bool v40; // [rsp+A7h] [rbp-19h]
int v41; // [rsp+A8h] [rbp-18h]
Offsets = OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::GetOffsets(a2);
v40 = 0;
if ( (std::vector<int>::empty(Offsets) & 1) == 0 )
{
v4 = OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::GetOffsets(a2);
v40 = a3 < (int)std::vector<int>::size(v4);
}
if ( !v40 )
__assert_fail(
"(! this->GetOffsets().empty()) && i<(int)this->GetOffsets().size()",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/../far/stencilTable.h",
750LL,
"LimitStencilReal<REAL> OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetLimitStencil(Index) const [REAL = float]");
v5 = OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::GetOffsets(a2);
v41 = *(_DWORD *)std::vector<int>::operator[](v5, a3);
v6 = std::vector<float>::empty(a2 + 112);
if ( (v6 & 1) != 0
|| (std::vector<float>::empty(a2 + 136) & 1) != 0
|| (std::vector<float>::empty(a2 + 160) & 1) != 0
|| (std::vector<float>::empty(a2 + 184) & 1) != 0
|| (std::vector<float>::empty(a2 + 208) & 1) != 0 )
{
if ( (std::vector<float>::empty(a2 + 112) & 1) != 0 || (std::vector<float>::empty(a2 + 136) & 1) != 0 )
{
Sizes = OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::GetSizes(a2);
v27 = std::vector<int>::operator[](Sizes, a3);
ControlIndices = OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::GetControlIndices(a2);
v28 = std::vector<int>::operator[](ControlIndices, v41);
Weights = OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::GetWeights(a2);
v25 = std::vector<float>::operator[](Weights, v41);
OpenSubdiv::v3_6_0::Far::LimitStencilReal<float>::LimitStencilReal(a1, v27, v28, v25, 0LL, 0LL, 0LL, 0LL, 0LL);
}
else
{
v16 = OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::GetSizes(a2);
v29 = std::vector<int>::operator[](v16, a3);
v17 = OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::GetControlIndices(a2);
v30 = std::vector<int>::operator[](v17, v41);
v18 = OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::GetWeights(a2);
v31 = std::vector<float>::operator[](v18, v41);
DuWeights = OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetDuWeights(a2);
v32 = std::vector<float>::operator[](DuWeights, v41);
DvWeights = OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetDvWeights(a2);
v21 = std::vector<float>::operator[](DvWeights, v41);
OpenSubdiv::v3_6_0::Far::LimitStencilReal<float>::LimitStencilReal(a1, v29, v30, v31, v32, v21, 0LL, 0LL, 0LL);
}
}
else
{
v7 = OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::GetSizes(a2);
v33 = std::vector<int>::operator[](v7, a3);
v8 = OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::GetControlIndices(a2);
v34 = std::vector<int>::operator[](v8, v41);
v9 = OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::GetWeights(a2);
v35 = std::vector<float>::operator[](v9, v41);
v10 = OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetDuWeights(a2);
v36 = std::vector<float>::operator[](v10, v41);
v11 = OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetDvWeights(a2);
v37 = std::vector<float>::operator[](v11, v41);
DuuWeights = OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetDuuWeights(a2);
v38 = std::vector<float>::operator[](DuuWeights, v41);
DuvWeights = OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetDuvWeights(a2);
v39 = std::vector<float>::operator[](DuvWeights, v41);
DvvWeights = OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetDvvWeights(a2);
v15 = std::vector<float>::operator[](DvvWeights, v41);
OpenSubdiv::v3_6_0::Far::LimitStencilReal<float>::LimitStencilReal(a1, v33, v34, v35, v36, v37, v38, v39, v15);
}
return a1;
}
| |||
19,828
|
OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetLimitStencil(int) const
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/../far/stencilTable.h
|
inline LimitStencilReal<REAL>
LimitStencilTableReal<REAL>::GetLimitStencil(Index i) const {
assert((! this->GetOffsets().empty()) && i<(int)this->GetOffsets().size());
Index ofs = this->GetOffsets()[i];
if (!_duWeights.empty() && !_dvWeights.empty() &&
!_duuWeights.empty() && !_duvWeights.empty() && !_dvvWeights.empty()) {
return LimitStencilReal<REAL>(
const_cast<int *>(&this->GetSizes()[i]),
const_cast<Index *>(&this->GetControlIndices()[ofs]),
const_cast<REAL *>(&this->GetWeights()[ofs]),
const_cast<REAL *>(&GetDuWeights()[ofs]),
const_cast<REAL *>(&GetDvWeights()[ofs]),
const_cast<REAL *>(&GetDuuWeights()[ofs]),
const_cast<REAL *>(&GetDuvWeights()[ofs]),
const_cast<REAL *>(&GetDvvWeights()[ofs]) );
} else if (!_duWeights.empty() && !_dvWeights.empty()) {
return LimitStencilReal<REAL>(
const_cast<int *>(&this->GetSizes()[i]),
const_cast<Index *>(&this->GetControlIndices()[ofs]),
const_cast<REAL *>(&this->GetWeights()[ofs]),
const_cast<REAL *>(&GetDuWeights()[ofs]),
const_cast<REAL *>(&GetDvWeights()[ofs]) );
} else {
return LimitStencilReal<REAL>(
const_cast<int *>(&this->GetSizes()[i]),
const_cast<Index *>(&this->GetControlIndices()[ofs]),
const_cast<REAL *>(&this->GetWeights()[ofs]) );
}
}
|
O1
|
c
|
OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetLimitStencil(int) const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rax
movq 0x28(%rsi), %rcx
movq 0x30(%rsi), %rsi
cmpq %rsi, %rcx
je 0x72360
subq %rcx, %rsi
shrq $0x2, %rsi
cmpl %edx, %esi
jle 0x72360
movq %rdi, %rbx
movslq %edx, %rsi
movslq (%rcx,%rsi,4), %rcx
movq 0x70(%rax), %rdi
movq 0x78(%rax), %rdx
cmpq %rdx, %rdi
je 0x7231e
movq 0x88(%rax), %r9
cmpq 0x90(%rax), %r9
je 0x722ce
movq 0xa0(%rax), %r11
cmpq 0xa8(%rax), %r11
je 0x722ce
movq 0xb8(%rax), %r14
cmpq 0xc0(%rax), %r14
je 0x722ce
movq 0xd0(%rax), %r15
cmpq 0xd8(%rax), %r15
je 0x722ce
shlq $0x2, %rsi
addq 0x10(%rax), %rsi
leaq (,%rcx,4), %r10
movq 0x40(%rax), %rdx
addq %r10, %rdx
addq 0x58(%rax), %r10
leaq (%rdi,%rcx,4), %r8
leaq (%r9,%rcx,4), %r9
leaq (%r11,%rcx,4), %rax
leaq (%r14,%rcx,4), %rdi
leaq (%r15,%rcx,4), %rcx
movq %rcx, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq %rax, (%rsp)
jmp 0x72316
cmpq %rdx, %rdi
je 0x7231e
movq 0x88(%rax), %r9
cmpq 0x90(%rax), %r9
je 0x7231e
shlq $0x2, %rsi
addq 0x10(%rax), %rsi
leaq (,%rcx,4), %r10
movq 0x40(%rax), %rdx
addq %r10, %rdx
addq 0x58(%rax), %r10
leaq (%rdi,%rcx,4), %r8
leaq (%r9,%rcx,4), %r9
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq %rbx, %rdi
movq %r10, %rcx
jmp 0x7234e
shlq $0x2, %rsi
addq 0x10(%rax), %rsi
shlq $0x2, %rcx
movq 0x40(%rax), %rdx
addq %rcx, %rdx
addq 0x58(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x3ad50
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x474b8(%rip), %rdi # 0xb981f
leaq 0x47376(%rip), %rsi # 0xb96e4
leaq 0x474ed(%rip), %rcx # 0xb9862
movl $0x2ee, %edx # imm = 0x2EE
callq 0x39560
nop
|
_ZNK10OpenSubdiv6v3_6_03Far21LimitStencilTableRealIfE15GetLimitStencilEi:
push r15
push r14
push rbx
sub rsp, 20h
mov rax, rsi
mov rcx, [rsi+28h]
mov rsi, [rsi+30h]
cmp rcx, rsi
jz loc_72360
sub rsi, rcx
shr rsi, 2
cmp esi, edx
jle loc_72360
mov rbx, rdi
movsxd rsi, edx
movsxd rcx, dword ptr [rcx+rsi*4]
mov rdi, [rax+70h]
mov rdx, [rax+78h]
cmp rdi, rdx
jz loc_7231E
mov r9, [rax+88h]
cmp r9, [rax+90h]
jz short loc_722CE
mov r11, [rax+0A0h]
cmp r11, [rax+0A8h]
jz short loc_722CE
mov r14, [rax+0B8h]
cmp r14, [rax+0C0h]
jz short loc_722CE
mov r15, [rax+0D0h]
cmp r15, [rax+0D8h]
jz short loc_722CE
shl rsi, 2
add rsi, [rax+10h]
lea r10, ds:0[rcx*4]
mov rdx, [rax+40h]
add rdx, r10
add r10, [rax+58h]
lea r8, [rdi+rcx*4]
lea r9, [r9+rcx*4]
lea rax, [r11+rcx*4]
lea rdi, [r14+rcx*4]
lea rcx, [r15+rcx*4]
mov [rsp+38h+var_28], rcx
mov qword ptr [rsp+38h+var_38+8], rdi
mov qword ptr [rsp+38h+var_38], rax
jmp short loc_72316
loc_722CE:
cmp rdi, rdx
jz short loc_7231E
mov r9, [rax+88h]
cmp r9, [rax+90h]
jz short loc_7231E
shl rsi, 2
add rsi, [rax+10h]
lea r10, ds:0[rcx*4]
mov rdx, [rax+40h]
add rdx, r10
add r10, [rax+58h]
lea r8, [rdi+rcx*4]
lea r9, [r9+rcx*4]
xorps xmm0, xmm0
movups [rsp+38h+var_38], xmm0
mov [rsp+38h+var_28], 0
loc_72316:
mov rdi, rbx
mov rcx, r10
jmp short loc_7234E
loc_7231E:
shl rsi, 2
add rsi, [rax+10h]
shl rcx, 2
mov rdx, [rax+40h]
add rdx, rcx
add rcx, [rax+58h]
xorps xmm0, xmm0
movups [rsp+38h+var_38], xmm0
mov [rsp+38h+var_28], 0
mov rdi, rbx
xor r8d, r8d
xor r9d, r9d
loc_7234E:
call __ZN10OpenSubdiv6v3_6_03Far16LimitStencilRealIfEC2EPiS4_PfS5_S5_S5_S5_S5_; OpenSubdiv::v3_6_0::Far::LimitStencilReal<float>::LimitStencilReal(int *,int *,float *,float *,float *,float *,float *,float *)
mov rax, rbx
add rsp, 20h
pop rbx
pop r14
pop r15
retn
loc_72360:
lea rdi, aThisGetoffsets; "(! this->GetOffsets().empty()) && i<(in"...
lea rsi, aWorkspaceLlm4b_19; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aLimitstencilre; "LimitStencilReal<REAL> OpenSubdiv::v3_6"...
mov edx, 2EEh
call ___assert_fail
|
long long OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetLimitStencil(
long long a1,
_QWORD *a2,
int a3)
{
long long v4; // rcx
long long v5; // rsi
long long v7; // rsi
long long v8; // rcx
long long v9; // rdi
long long v10; // rdx
long long v11; // r9
long long v12; // r11
long long v13; // r14
long long v14; // r15
long long v15; // rsi
long long v16; // rdx
long long v17; // r10
long long v18; // r8
long long v19; // r9
long long v20; // r9
long long v21; // rdi
long long v22; // rcx
long long v23; // rcx
__int128 v25; // [rsp+0h] [rbp-38h]
long long v26; // [rsp+10h] [rbp-28h]
v4 = a2[5];
v5 = a2[6];
if ( v4 == v5 || (int)((unsigned long long)(v5 - v4) >> 2) <= a3 )
__assert_fail(
"(! this->GetOffsets().empty()) && i<(int)this->GetOffsets().size()",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/../far/stencilTable.h",
750LL,
"LimitStencilReal<REAL> OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetLimitStencil(Index) const [REAL = float]");
v7 = a3;
v8 = *(int *)(v4 + 4LL * a3);
v9 = a2[14];
v10 = a2[15];
if ( v9 == v10 )
goto LABEL_13;
v11 = a2[17];
if ( v11 == a2[18] || (v12 = a2[20], v12 == a2[21]) || (v13 = a2[23], v13 == a2[24]) || (v14 = a2[26], v14 == a2[27]) )
{
if ( v9 != v10 )
{
v20 = a2[17];
if ( v20 != a2[18] )
{
v15 = a2[2] + 4 * v7;
v16 = 4 * v8 + a2[8];
v17 = a2[11] + 4 * v8;
v18 = v9 + 4 * v8;
v19 = v20 + 4 * v8;
v25 = 0LL;
v26 = 0LL;
goto LABEL_12;
}
}
LABEL_13:
v15 = a2[2] + 4 * v7;
v23 = 4 * v8;
v16 = v23 + a2[8];
v22 = a2[11] + v23;
v25 = 0LL;
v26 = 0LL;
v21 = a1;
v18 = 0LL;
v19 = 0LL;
goto LABEL_14;
}
v15 = a2[2] + 4 * v7;
v16 = 4 * v8 + a2[8];
v17 = a2[11] + 4 * v8;
v18 = v9 + 4 * v8;
v19 = v11 + 4 * v8;
v26 = v14 + 4 * v8;
*((_QWORD *)&v25 + 1) = v13 + 4 * v8;
*(_QWORD *)&v25 = v12 + 4 * v8;
LABEL_12:
v21 = a1;
v22 = v17;
LABEL_14:
OpenSubdiv::v3_6_0::Far::LimitStencilReal<float>::LimitStencilReal(v21, v15, v16, v22, v18, v19, v25, v26);
return a1;
}
|
GetLimitStencil:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x20
MOV RAX,RSI
MOV RCX,qword ptr [RSI + 0x28]
MOV RSI,qword ptr [RSI + 0x30]
CMP RCX,RSI
JZ 0x00172360
SUB RSI,RCX
SHR RSI,0x2
CMP ESI,EDX
JLE 0x00172360
MOV RBX,RDI
MOVSXD RSI,EDX
MOVSXD RCX,dword ptr [RCX + RSI*0x4]
MOV RDI,qword ptr [RAX + 0x70]
MOV RDX,qword ptr [RAX + 0x78]
CMP RDI,RDX
JZ 0x0017231e
MOV R9,qword ptr [RAX + 0x88]
CMP R9,qword ptr [RAX + 0x90]
JZ 0x001722ce
MOV R11,qword ptr [RAX + 0xa0]
CMP R11,qword ptr [RAX + 0xa8]
JZ 0x001722ce
MOV R14,qword ptr [RAX + 0xb8]
CMP R14,qword ptr [RAX + 0xc0]
JZ 0x001722ce
MOV R15,qword ptr [RAX + 0xd0]
CMP R15,qword ptr [RAX + 0xd8]
JZ 0x001722ce
SHL RSI,0x2
ADD RSI,qword ptr [RAX + 0x10]
LEA R10,[RCX*0x4]
MOV RDX,qword ptr [RAX + 0x40]
ADD RDX,R10
ADD R10,qword ptr [RAX + 0x58]
LEA R8,[RDI + RCX*0x4]
LEA R9,[R9 + RCX*0x4]
LEA RAX,[R11 + RCX*0x4]
LEA RDI,[R14 + RCX*0x4]
LEA RCX,[R15 + RCX*0x4]
MOV qword ptr [RSP + 0x10],RCX
MOV qword ptr [RSP + 0x8],RDI
MOV qword ptr [RSP],RAX
JMP 0x00172316
LAB_001722ce:
CMP RDI,RDX
JZ 0x0017231e
MOV R9,qword ptr [RAX + 0x88]
CMP R9,qword ptr [RAX + 0x90]
JZ 0x0017231e
SHL RSI,0x2
ADD RSI,qword ptr [RAX + 0x10]
LEA R10,[RCX*0x4]
MOV RDX,qword ptr [RAX + 0x40]
ADD RDX,R10
ADD R10,qword ptr [RAX + 0x58]
LEA R8,[RDI + RCX*0x4]
LEA R9,[R9 + RCX*0x4]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
LAB_00172316:
MOV RDI,RBX
MOV RCX,R10
JMP 0x0017234e
LAB_0017231e:
SHL RSI,0x2
ADD RSI,qword ptr [RAX + 0x10]
SHL RCX,0x2
MOV RDX,qword ptr [RAX + 0x40]
ADD RDX,RCX
ADD RCX,qword ptr [RAX + 0x58]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
MOV RDI,RBX
XOR R8D,R8D
XOR R9D,R9D
LAB_0017234e:
CALL 0x0013ad50
MOV RAX,RBX
ADD RSP,0x20
POP RBX
POP R14
POP R15
RET
LAB_00172360:
LEA RDI,[0x1b981f]
LEA RSI,[0x1b96e4]
LEA RCX,[0x1b9862]
MOV EDX,0x2ee
CALL 0x00139560
|
/* OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetLimitStencil(int) const */
LimitStencilReal<float> *
OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetLimitStencil(int param_1)
{
long lVar1;
long lVar2;
int in_EDX;
int *piVar3;
long in_RSI;
long lVar4;
int *piVar5;
int4 in_register_0000003c;
float *pfVar6;
float *pfVar7;
float *pfVar8;
float *pfVar9;
float *pfVar10;
float *pfVar11;
lVar1 = *(long *)(in_RSI + 0x28);
if ((lVar1 == *(long *)(in_RSI + 0x30)) ||
((int)((ulong)(*(long *)(in_RSI + 0x30) - lVar1) >> 2) <= in_EDX)) {
/* WARNING: Subroutine does not return */
__assert_fail("(! this->GetOffsets().empty()) && i<(int)this->GetOffsets().size()",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/../far/stencilTable.h"
,0x2ee,
"LimitStencilReal<REAL> OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetLimitStencil(Index) const [REAL = float]"
);
}
lVar4 = (long)in_EDX;
lVar2 = (long)*(int *)(lVar1 + lVar4 * 4);
lVar1 = *(long *)(in_RSI + 0x70);
if (lVar1 == *(long *)(in_RSI + 0x78)) {
LAB_0017231e:
piVar5 = (int *)(lVar4 * 4 + *(long *)(in_RSI + 0x10));
piVar3 = (int *)(*(long *)(in_RSI + 0x40) + lVar2 * 4);
pfVar8 = (float *)(lVar2 * 4 + *(long *)(in_RSI + 0x58));
pfVar9 = (float *)0x0;
pfVar10 = (float *)0x0;
pfVar11 = (float *)0x0;
pfVar6 = (float *)0x0;
pfVar7 = (float *)0x0;
}
else {
if ((((*(long *)(in_RSI + 0x88) == *(long *)(in_RSI + 0x90)) ||
(*(long *)(in_RSI + 0xa0) == *(long *)(in_RSI + 0xa8))) ||
(*(long *)(in_RSI + 0xb8) == *(long *)(in_RSI + 0xc0))) ||
(*(long *)(in_RSI + 0xd0) == *(long *)(in_RSI + 0xd8))) {
if ((lVar1 == *(long *)(in_RSI + 0x78)) ||
(*(long *)(in_RSI + 0x88) == *(long *)(in_RSI + 0x90))) goto LAB_0017231e;
piVar5 = (int *)(lVar4 * 4 + *(long *)(in_RSI + 0x10));
piVar3 = (int *)(*(long *)(in_RSI + 0x40) + lVar2 * 4);
pfVar8 = (float *)(lVar2 * 4 + *(long *)(in_RSI + 0x58));
pfVar7 = (float *)(*(long *)(in_RSI + 0x88) + lVar2 * 4);
pfVar9 = (float *)0x0;
pfVar10 = (float *)0x0;
pfVar11 = (float *)0x0;
}
else {
piVar5 = (int *)(lVar4 * 4 + *(long *)(in_RSI + 0x10));
piVar3 = (int *)(*(long *)(in_RSI + 0x40) + lVar2 * 4);
pfVar8 = (float *)(lVar2 * 4 + *(long *)(in_RSI + 0x58));
pfVar7 = (float *)(*(long *)(in_RSI + 0x88) + lVar2 * 4);
pfVar9 = (float *)(*(long *)(in_RSI + 0xa0) + lVar2 * 4);
pfVar10 = (float *)(*(long *)(in_RSI + 0xb8) + lVar2 * 4);
pfVar11 = (float *)(*(long *)(in_RSI + 0xd0) + lVar2 * 4);
}
pfVar6 = (float *)(lVar1 + lVar2 * 4);
}
LimitStencilReal<float>::LimitStencilReal
((LimitStencilReal<float> *)CONCAT44(in_register_0000003c,param_1),piVar5,piVar3,pfVar8,
pfVar6,pfVar7,pfVar9,pfVar10,pfVar11);
return (LimitStencilReal<float> *)CONCAT44(in_register_0000003c,param_1);
}
|
|
19,829
|
OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetLimitStencil(int) const
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/../far/stencilTable.h
|
inline LimitStencilReal<REAL>
LimitStencilTableReal<REAL>::GetLimitStencil(Index i) const {
assert((! this->GetOffsets().empty()) && i<(int)this->GetOffsets().size());
Index ofs = this->GetOffsets()[i];
if (!_duWeights.empty() && !_dvWeights.empty() &&
!_duuWeights.empty() && !_duvWeights.empty() && !_dvvWeights.empty()) {
return LimitStencilReal<REAL>(
const_cast<int *>(&this->GetSizes()[i]),
const_cast<Index *>(&this->GetControlIndices()[ofs]),
const_cast<REAL *>(&this->GetWeights()[ofs]),
const_cast<REAL *>(&GetDuWeights()[ofs]),
const_cast<REAL *>(&GetDvWeights()[ofs]),
const_cast<REAL *>(&GetDuuWeights()[ofs]),
const_cast<REAL *>(&GetDuvWeights()[ofs]),
const_cast<REAL *>(&GetDvvWeights()[ofs]) );
} else if (!_duWeights.empty() && !_dvWeights.empty()) {
return LimitStencilReal<REAL>(
const_cast<int *>(&this->GetSizes()[i]),
const_cast<Index *>(&this->GetControlIndices()[ofs]),
const_cast<REAL *>(&this->GetWeights()[ofs]),
const_cast<REAL *>(&GetDuWeights()[ofs]),
const_cast<REAL *>(&GetDvWeights()[ofs]) );
} else {
return LimitStencilReal<REAL>(
const_cast<int *>(&this->GetSizes()[i]),
const_cast<Index *>(&this->GetControlIndices()[ofs]),
const_cast<REAL *>(&this->GetWeights()[ofs]) );
}
}
|
O2
|
c
|
OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetLimitStencil(int) const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rax
movq 0x28(%rsi), %rcx
movq 0x30(%rsi), %rsi
cmpq %rsi, %rcx
je 0x83e05
subq %rcx, %rsi
shrq $0x2, %rsi
cmpl %edx, %esi
jle 0x83e05
movq %rdi, %rbx
movslq %edx, %rsi
movslq (%rcx,%rsi,4), %rcx
movq 0x70(%rax), %rdi
cmpq 0x78(%rax), %rdi
je 0x83d84
movq 0x88(%rax), %r9
cmpq 0x90(%rax), %r9
je 0x83d84
movq 0xa0(%rax), %r11
cmpq 0xa8(%rax), %r11
je 0x83db8
movq 0xb8(%rax), %r14
cmpq 0xc0(%rax), %r14
je 0x83db8
movq 0xd0(%rax), %r15
cmpq 0xd8(%rax), %r15
je 0x83db8
shlq $0x2, %rsi
addq 0x10(%rax), %rsi
leaq (,%rcx,4), %rdx
addq 0x40(%rax), %rdx
leaq (,%rcx,8), %r10
addq 0x58(%rax), %r10
leaq (%rdi,%rcx,8), %r8
leaq (%r9,%rcx,8), %r9
leaq (%r11,%rcx,8), %rax
leaq (%r14,%rcx,8), %rdi
leaq (%r15,%rcx,8), %rcx
movq %rcx, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq %rax, (%rsp)
jmp 0x83ded
shlq $0x2, %rsi
addq 0x10(%rax), %rsi
leaq (,%rcx,4), %rdx
addq 0x40(%rax), %rdx
shlq $0x3, %rcx
addq 0x58(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
jmp 0x83df3
shlq $0x2, %rsi
addq 0x10(%rax), %rsi
leaq (,%rcx,4), %rdx
addq 0x40(%rax), %rdx
leaq (,%rcx,8), %r10
addq 0x58(%rax), %r10
leaq (%rdi,%rcx,8), %r8
leaq (%r9,%rcx,8), %r9
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq %rbx, %rdi
movq %r10, %rcx
callq 0x53cd0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3ffaf(%rip), %rdi # 0xc3dbb
leaq 0x3fe6d(%rip), %rsi # 0xc3c80
leaq 0x4005e(%rip), %rcx # 0xc3e78
movl $0x2ee, %edx # imm = 0x2EE
callq 0x512a0
|
_ZNK10OpenSubdiv6v3_6_03Far21LimitStencilTableRealIdE15GetLimitStencilEi:
push r15
push r14
push rbx
sub rsp, 20h
mov rax, rsi
mov rcx, [rsi+28h]
mov rsi, [rsi+30h]
cmp rcx, rsi
jz loc_83E05
sub rsi, rcx
shr rsi, 2
cmp esi, edx
jle loc_83E05
mov rbx, rdi
movsxd rsi, edx
movsxd rcx, dword ptr [rcx+rsi*4]
mov rdi, [rax+70h]
cmp rdi, [rax+78h]
jz loc_83D84
mov r9, [rax+88h]
cmp r9, [rax+90h]
jz short loc_83D84
mov r11, [rax+0A0h]
cmp r11, [rax+0A8h]
jz loc_83DB8
mov r14, [rax+0B8h]
cmp r14, [rax+0C0h]
jz loc_83DB8
mov r15, [rax+0D0h]
cmp r15, [rax+0D8h]
jz short loc_83DB8
shl rsi, 2
add rsi, [rax+10h]
lea rdx, ds:0[rcx*4]
add rdx, [rax+40h]
lea r10, ds:0[rcx*8]
add r10, [rax+58h]
lea r8, [rdi+rcx*8]
lea r9, [r9+rcx*8]
lea rax, [r11+rcx*8]
lea rdi, [r14+rcx*8]
lea rcx, [r15+rcx*8]
mov [rsp+38h+var_28], rcx
mov qword ptr [rsp+38h+var_38+8], rdi
mov qword ptr [rsp+38h+var_38], rax
jmp short loc_83DED
loc_83D84:
shl rsi, 2
add rsi, [rax+10h]
lea rdx, ds:0[rcx*4]
add rdx, [rax+40h]
shl rcx, 3
add rcx, [rax+58h]
xorps xmm0, xmm0
movups [rsp+38h+var_38], xmm0
and [rsp+38h+var_28], 0
mov rdi, rbx
xor r8d, r8d
xor r9d, r9d
jmp short loc_83DF3
loc_83DB8:
shl rsi, 2
add rsi, [rax+10h]
lea rdx, ds:0[rcx*4]
add rdx, [rax+40h]
lea r10, ds:0[rcx*8]
add r10, [rax+58h]
lea r8, [rdi+rcx*8]
lea r9, [r9+rcx*8]
xorps xmm0, xmm0
movups [rsp+38h+var_38], xmm0
and [rsp+38h+var_28], 0
loc_83DED:
mov rdi, rbx
mov rcx, r10
loc_83DF3:
call __ZN10OpenSubdiv6v3_6_03Far16LimitStencilRealIdEC2EPiS4_PdS5_S5_S5_S5_S5_; OpenSubdiv::v3_6_0::Far::LimitStencilReal<double>::LimitStencilReal(int *,int *,double *,double *,double *,double *,double *,double *)
mov rax, rbx
add rsp, 20h
pop rbx
pop r14
pop r15
retn
loc_83E05:
lea rdi, aThisGetoffsets; "(! this->GetOffsets().empty()) && i<(in"...
lea rsi, aWorkspaceLlm4b_19; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aLimitstencilre_0; "LimitStencilReal<REAL> OpenSubdiv::v3_6"...
mov edx, 2EEh
call ___assert_fail
|
long long OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<double>::GetLimitStencil(
long long a1,
_QWORD *a2,
int a3)
{
long long v4; // rcx
long long v5; // rsi
long long v7; // rcx
long long v8; // rdi
long long v9; // r9
long long v10; // r11
long long v11; // r14
long long v12; // r15
long long v13; // rsi
long long v14; // rdx
long long v15; // r10
long long v16; // r8
long long v17; // r9
__int128 v19; // [rsp+0h] [rbp-38h]
long long v20; // [rsp+10h] [rbp-28h]
v4 = a2[5];
v5 = a2[6];
if ( v4 == v5 || (int)((unsigned long long)(v5 - v4) >> 2) <= a3 )
__assert_fail(
"(! this->GetOffsets().empty()) && i<(int)this->GetOffsets().size()",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/../far/stencilTable.h",
750LL,
"LimitStencilReal<REAL> OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<double>::GetLimitStencil(Index) const [REAL = double]");
v7 = *(int *)(v4 + 4LL * a3);
v8 = a2[14];
if ( v8 == a2[15] || (v9 = a2[17], v9 == a2[18]) )
{
OpenSubdiv::v3_6_0::Far::LimitStencilReal<double>::LimitStencilReal(
a1,
a2[2] + 4LL * a3,
a2[8] + 4 * v7,
a2[11] + 8 * v7,
0LL,
0LL,
0LL,
0LL);
}
else
{
v10 = a2[20];
if ( v10 == a2[21] || (v11 = a2[23], v11 == a2[24]) || (v12 = a2[26], v12 == a2[27]) )
{
v13 = a2[2] + 4LL * a3;
v14 = a2[8] + 4 * v7;
v15 = a2[11] + 8 * v7;
v16 = v8 + 8 * v7;
v17 = v9 + 8 * v7;
v19 = 0LL;
v20 = 0LL;
}
else
{
v13 = a2[2] + 4LL * a3;
v14 = a2[8] + 4 * v7;
v15 = a2[11] + 8 * v7;
v16 = v8 + 8 * v7;
v17 = v9 + 8 * v7;
v20 = v12 + 8 * v7;
*((_QWORD *)&v19 + 1) = v11 + 8 * v7;
*(_QWORD *)&v19 = v10 + 8 * v7;
}
OpenSubdiv::v3_6_0::Far::LimitStencilReal<double>::LimitStencilReal(a1, v13, v14, v15, v16, v17, v19, v20);
}
return a1;
}
|
GetLimitStencil:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x20
MOV RAX,RSI
MOV RCX,qword ptr [RSI + 0x28]
MOV RSI,qword ptr [RSI + 0x30]
CMP RCX,RSI
JZ 0x00183e05
SUB RSI,RCX
SHR RSI,0x2
CMP ESI,EDX
JLE 0x00183e05
MOV RBX,RDI
MOVSXD RSI,EDX
MOVSXD RCX,dword ptr [RCX + RSI*0x4]
MOV RDI,qword ptr [RAX + 0x70]
CMP RDI,qword ptr [RAX + 0x78]
JZ 0x00183d84
MOV R9,qword ptr [RAX + 0x88]
CMP R9,qword ptr [RAX + 0x90]
JZ 0x00183d84
MOV R11,qword ptr [RAX + 0xa0]
CMP R11,qword ptr [RAX + 0xa8]
JZ 0x00183db8
MOV R14,qword ptr [RAX + 0xb8]
CMP R14,qword ptr [RAX + 0xc0]
JZ 0x00183db8
MOV R15,qword ptr [RAX + 0xd0]
CMP R15,qword ptr [RAX + 0xd8]
JZ 0x00183db8
SHL RSI,0x2
ADD RSI,qword ptr [RAX + 0x10]
LEA RDX,[RCX*0x4]
ADD RDX,qword ptr [RAX + 0x40]
LEA R10,[RCX*0x8]
ADD R10,qword ptr [RAX + 0x58]
LEA R8,[RDI + RCX*0x8]
LEA R9,[R9 + RCX*0x8]
LEA RAX,[R11 + RCX*0x8]
LEA RDI,[R14 + RCX*0x8]
LEA RCX,[R15 + RCX*0x8]
MOV qword ptr [RSP + 0x10],RCX
MOV qword ptr [RSP + 0x8],RDI
MOV qword ptr [RSP],RAX
JMP 0x00183ded
LAB_00183d84:
SHL RSI,0x2
ADD RSI,qword ptr [RAX + 0x10]
LEA RDX,[RCX*0x4]
ADD RDX,qword ptr [RAX + 0x40]
SHL RCX,0x3
ADD RCX,qword ptr [RAX + 0x58]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP],XMM0
AND qword ptr [RSP + 0x10],0x0
MOV RDI,RBX
XOR R8D,R8D
XOR R9D,R9D
JMP 0x00183df3
LAB_00183db8:
SHL RSI,0x2
ADD RSI,qword ptr [RAX + 0x10]
LEA RDX,[RCX*0x4]
ADD RDX,qword ptr [RAX + 0x40]
LEA R10,[RCX*0x8]
ADD R10,qword ptr [RAX + 0x58]
LEA R8,[RDI + RCX*0x8]
LEA R9,[R9 + RCX*0x8]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP],XMM0
AND qword ptr [RSP + 0x10],0x0
LAB_00183ded:
MOV RDI,RBX
MOV RCX,R10
LAB_00183df3:
CALL 0x00153cd0
MOV RAX,RBX
ADD RSP,0x20
POP RBX
POP R14
POP R15
RET
LAB_00183e05:
LEA RDI,[0x1c3dbb]
LEA RSI,[0x1c3c80]
LEA RCX,[0x1c3e78]
MOV EDX,0x2ee
CALL 0x001512a0
|
/* OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<double>::GetLimitStencil(int) const */
LimitStencilReal<double> *
OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<double>::GetLimitStencil(int param_1)
{
long lVar1;
int in_EDX;
int *piVar2;
long in_RSI;
long lVar3;
int *piVar4;
int4 in_register_0000003c;
double *pdVar5;
double *pdVar6;
double *pdVar7;
double *pdVar8;
double *pdVar9;
double *pdVar10;
lVar1 = *(long *)(in_RSI + 0x28);
if ((lVar1 != *(long *)(in_RSI + 0x30)) &&
(in_EDX < (int)((ulong)(*(long *)(in_RSI + 0x30) - lVar1) >> 2))) {
lVar3 = (long)in_EDX;
lVar1 = (long)*(int *)(lVar1 + lVar3 * 4);
if ((*(long *)(in_RSI + 0x70) == *(long *)(in_RSI + 0x78)) ||
(*(long *)(in_RSI + 0x88) == *(long *)(in_RSI + 0x90))) {
piVar4 = (int *)(lVar3 * 4 + *(long *)(in_RSI + 0x10));
piVar2 = (int *)(lVar1 * 4 + *(long *)(in_RSI + 0x40));
pdVar7 = (double *)(lVar1 * 8 + *(long *)(in_RSI + 0x58));
pdVar8 = (double *)0x0;
pdVar9 = (double *)0x0;
pdVar10 = (double *)0x0;
pdVar5 = (double *)0x0;
pdVar6 = (double *)0x0;
}
else {
if (((*(long *)(in_RSI + 0xa0) == *(long *)(in_RSI + 0xa8)) ||
(*(long *)(in_RSI + 0xb8) == *(long *)(in_RSI + 0xc0))) ||
(*(long *)(in_RSI + 0xd0) == *(long *)(in_RSI + 0xd8))) {
piVar4 = (int *)(lVar3 * 4 + *(long *)(in_RSI + 0x10));
piVar2 = (int *)(lVar1 * 4 + *(long *)(in_RSI + 0x40));
pdVar7 = (double *)(lVar1 * 8 + *(long *)(in_RSI + 0x58));
pdVar8 = (double *)0x0;
pdVar9 = (double *)0x0;
pdVar10 = (double *)0x0;
}
else {
piVar4 = (int *)(lVar3 * 4 + *(long *)(in_RSI + 0x10));
piVar2 = (int *)(lVar1 * 4 + *(long *)(in_RSI + 0x40));
pdVar7 = (double *)(lVar1 * 8 + *(long *)(in_RSI + 0x58));
pdVar8 = (double *)(*(long *)(in_RSI + 0xa0) + lVar1 * 8);
pdVar9 = (double *)(*(long *)(in_RSI + 0xb8) + lVar1 * 8);
pdVar10 = (double *)(*(long *)(in_RSI + 0xd0) + lVar1 * 8);
}
pdVar6 = (double *)(*(long *)(in_RSI + 0x88) + lVar1 * 8);
pdVar5 = (double *)(*(long *)(in_RSI + 0x70) + lVar1 * 8);
}
LimitStencilReal<double>::LimitStencilReal
((LimitStencilReal<double> *)CONCAT44(in_register_0000003c,param_1),piVar4,piVar2,
pdVar7,pdVar5,pdVar6,pdVar8,pdVar9,pdVar10);
return (LimitStencilReal<double> *)CONCAT44(in_register_0000003c,param_1);
}
/* WARNING: Subroutine does not return */
__assert_fail("(! this->GetOffsets().empty()) && i<(int)this->GetOffsets().size()",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/../far/stencilTable.h"
,0x2ee,
"LimitStencilReal<REAL> OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<double>::GetLimitStencil(Index) const [REAL = double]"
);
}
|
|
19,830
|
OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetLimitStencil(int) const
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/../far/stencilTable.h
|
inline LimitStencilReal<REAL>
LimitStencilTableReal<REAL>::GetLimitStencil(Index i) const {
assert((! this->GetOffsets().empty()) && i<(int)this->GetOffsets().size());
Index ofs = this->GetOffsets()[i];
if (!_duWeights.empty() && !_dvWeights.empty() &&
!_duuWeights.empty() && !_duvWeights.empty() && !_dvvWeights.empty()) {
return LimitStencilReal<REAL>(
const_cast<int *>(&this->GetSizes()[i]),
const_cast<Index *>(&this->GetControlIndices()[ofs]),
const_cast<REAL *>(&this->GetWeights()[ofs]),
const_cast<REAL *>(&GetDuWeights()[ofs]),
const_cast<REAL *>(&GetDvWeights()[ofs]),
const_cast<REAL *>(&GetDuuWeights()[ofs]),
const_cast<REAL *>(&GetDuvWeights()[ofs]),
const_cast<REAL *>(&GetDvvWeights()[ofs]) );
} else if (!_duWeights.empty() && !_dvWeights.empty()) {
return LimitStencilReal<REAL>(
const_cast<int *>(&this->GetSizes()[i]),
const_cast<Index *>(&this->GetControlIndices()[ofs]),
const_cast<REAL *>(&this->GetWeights()[ofs]),
const_cast<REAL *>(&GetDuWeights()[ofs]),
const_cast<REAL *>(&GetDvWeights()[ofs]) );
} else {
return LimitStencilReal<REAL>(
const_cast<int *>(&this->GetSizes()[i]),
const_cast<Index *>(&this->GetControlIndices()[ofs]),
const_cast<REAL *>(&this->GetWeights()[ofs]) );
}
}
|
O3
|
c
|
OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetLimitStencil(int) const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rax
movq 0x28(%rsi), %rcx
movq 0x30(%rsi), %rsi
cmpq %rsi, %rcx
je 0x73940
subq %rcx, %rsi
shrq $0x2, %rsi
cmpl %edx, %esi
jle 0x73940
movq %rdi, %rbx
movslq %edx, %rsi
movslq (%rcx,%rsi,4), %rcx
movq 0x70(%rax), %rdi
cmpq 0x78(%rax), %rdi
je 0x738c3
movq 0x88(%rax), %r9
cmpq 0x90(%rax), %r9
je 0x738c3
movq 0xa0(%rax), %r11
cmpq 0xa8(%rax), %r11
je 0x738f5
movq 0xb8(%rax), %r14
cmpq 0xc0(%rax), %r14
je 0x738f5
movq 0xd0(%rax), %r15
cmpq 0xd8(%rax), %r15
je 0x738f5
shlq $0x2, %rsi
addq 0x10(%rax), %rsi
leaq (,%rcx,4), %r10
movq 0x40(%rax), %rdx
addq %r10, %rdx
addq 0x58(%rax), %r10
leaq (%rdi,%rcx,4), %r8
leaq (%r9,%rcx,4), %r9
leaq (%r11,%rcx,4), %rax
leaq (%r14,%rcx,4), %rdi
leaq (%r15,%rcx,4), %rcx
movq %rcx, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq %rax, (%rsp)
jmp 0x73928
shlq $0x2, %rsi
addq 0x10(%rax), %rsi
shlq $0x2, %rcx
movq 0x40(%rax), %rdx
addq %rcx, %rdx
addq 0x58(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
jmp 0x7392e
shlq $0x2, %rsi
addq 0x10(%rax), %rsi
leaq (,%rcx,4), %r10
movq 0x40(%rax), %rdx
addq %r10, %rdx
addq 0x58(%rax), %r10
leaq (%rdi,%rcx,4), %r8
leaq (%r9,%rcx,4), %r9
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq %rbx, %rdi
movq %r10, %rcx
callq 0x3ad20
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x49618(%rip), %rdi # 0xbcf5f
leaq 0x494d6(%rip), %rsi # 0xbce24
leaq 0x4964d(%rip), %rcx # 0xbcfa2
movl $0x2ee, %edx # imm = 0x2EE
callq 0x39540
nop
|
_ZNK10OpenSubdiv6v3_6_03Far21LimitStencilTableRealIfE15GetLimitStencilEi:
push r15
push r14
push rbx
sub rsp, 20h
mov rax, rsi
mov rcx, [rsi+28h]
mov rsi, [rsi+30h]
cmp rcx, rsi
jz loc_73940
sub rsi, rcx
shr rsi, 2
cmp esi, edx
jle loc_73940
mov rbx, rdi
movsxd rsi, edx
movsxd rcx, dword ptr [rcx+rsi*4]
mov rdi, [rax+70h]
cmp rdi, [rax+78h]
jz loc_738C3
mov r9, [rax+88h]
cmp r9, [rax+90h]
jz short loc_738C3
mov r11, [rax+0A0h]
cmp r11, [rax+0A8h]
jz loc_738F5
mov r14, [rax+0B8h]
cmp r14, [rax+0C0h]
jz loc_738F5
mov r15, [rax+0D0h]
cmp r15, [rax+0D8h]
jz short loc_738F5
shl rsi, 2
add rsi, [rax+10h]
lea r10, ds:0[rcx*4]
mov rdx, [rax+40h]
add rdx, r10
add r10, [rax+58h]
lea r8, [rdi+rcx*4]
lea r9, [r9+rcx*4]
lea rax, [r11+rcx*4]
lea rdi, [r14+rcx*4]
lea rcx, [r15+rcx*4]
mov [rsp+38h+var_28], rcx
mov qword ptr [rsp+38h+var_38+8], rdi
mov qword ptr [rsp+38h+var_38], rax
jmp short loc_73928
loc_738C3:
shl rsi, 2
add rsi, [rax+10h]
shl rcx, 2
mov rdx, [rax+40h]
add rdx, rcx
add rcx, [rax+58h]
xorps xmm0, xmm0
movups [rsp+38h+var_38], xmm0
mov [rsp+38h+var_28], 0
mov rdi, rbx
xor r8d, r8d
xor r9d, r9d
jmp short loc_7392E
loc_738F5:
shl rsi, 2
add rsi, [rax+10h]
lea r10, ds:0[rcx*4]
mov rdx, [rax+40h]
add rdx, r10
add r10, [rax+58h]
lea r8, [rdi+rcx*4]
lea r9, [r9+rcx*4]
xorps xmm0, xmm0
movups [rsp+38h+var_38], xmm0
mov [rsp+38h+var_28], 0
loc_73928:
mov rdi, rbx
mov rcx, r10
loc_7392E:
call __ZN10OpenSubdiv6v3_6_03Far16LimitStencilRealIfEC2EPiS4_PfS5_S5_S5_S5_S5_; OpenSubdiv::v3_6_0::Far::LimitStencilReal<float>::LimitStencilReal(int *,int *,float *,float *,float *,float *,float *,float *)
mov rax, rbx
add rsp, 20h
pop rbx
pop r14
pop r15
retn
loc_73940:
lea rdi, aThisGetoffsets; "(! this->GetOffsets().empty()) && i<(in"...
lea rsi, aWorkspaceLlm4b_19; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aLimitstencilre; "LimitStencilReal<REAL> OpenSubdiv::v3_6"...
mov edx, 2EEh
call ___assert_fail
|
long long OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetLimitStencil(
long long a1,
_QWORD *a2,
int a3)
{
long long v4; // rcx
long long v5; // rsi
long long v7; // rcx
long long v8; // rdi
long long v9; // r9
long long v10; // r11
long long v11; // r14
long long v12; // r15
long long v13; // rsi
long long v14; // rdx
long long v15; // r10
long long v16; // r8
long long v17; // r9
__int128 v19; // [rsp+0h] [rbp-38h]
long long v20; // [rsp+10h] [rbp-28h]
v4 = a2[5];
v5 = a2[6];
if ( v4 == v5 || (int)((unsigned long long)(v5 - v4) >> 2) <= a3 )
__assert_fail(
"(! this->GetOffsets().empty()) && i<(int)this->GetOffsets().size()",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/../far/stencilTable.h",
750LL,
"LimitStencilReal<REAL> OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetLimitStencil(Index) const [REAL = float]");
v7 = *(int *)(v4 + 4LL * a3);
v8 = a2[14];
if ( v8 == a2[15] || (v9 = a2[17], v9 == a2[18]) )
{
OpenSubdiv::v3_6_0::Far::LimitStencilReal<float>::LimitStencilReal(
a1,
a2[2] + 4LL * a3,
4 * v7 + a2[8],
a2[11] + 4 * v7,
0LL,
0LL,
0LL,
0LL);
}
else
{
v10 = a2[20];
if ( v10 == a2[21] || (v11 = a2[23], v11 == a2[24]) || (v12 = a2[26], v12 == a2[27]) )
{
v13 = a2[2] + 4LL * a3;
v14 = 4 * v7 + a2[8];
v15 = a2[11] + 4 * v7;
v16 = v8 + 4 * v7;
v17 = v9 + 4 * v7;
v19 = 0LL;
v20 = 0LL;
}
else
{
v13 = a2[2] + 4LL * a3;
v14 = 4 * v7 + a2[8];
v15 = a2[11] + 4 * v7;
v16 = v8 + 4 * v7;
v17 = v9 + 4 * v7;
v20 = v12 + 4 * v7;
*((_QWORD *)&v19 + 1) = v11 + 4 * v7;
*(_QWORD *)&v19 = v10 + 4 * v7;
}
OpenSubdiv::v3_6_0::Far::LimitStencilReal<float>::LimitStencilReal(a1, v13, v14, v15, v16, v17, v19, v20);
}
return a1;
}
|
GetLimitStencil:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x20
MOV RAX,RSI
MOV RCX,qword ptr [RSI + 0x28]
MOV RSI,qword ptr [RSI + 0x30]
CMP RCX,RSI
JZ 0x00173940
SUB RSI,RCX
SHR RSI,0x2
CMP ESI,EDX
JLE 0x00173940
MOV RBX,RDI
MOVSXD RSI,EDX
MOVSXD RCX,dword ptr [RCX + RSI*0x4]
MOV RDI,qword ptr [RAX + 0x70]
CMP RDI,qword ptr [RAX + 0x78]
JZ 0x001738c3
MOV R9,qword ptr [RAX + 0x88]
CMP R9,qword ptr [RAX + 0x90]
JZ 0x001738c3
MOV R11,qword ptr [RAX + 0xa0]
CMP R11,qword ptr [RAX + 0xa8]
JZ 0x001738f5
MOV R14,qword ptr [RAX + 0xb8]
CMP R14,qword ptr [RAX + 0xc0]
JZ 0x001738f5
MOV R15,qword ptr [RAX + 0xd0]
CMP R15,qword ptr [RAX + 0xd8]
JZ 0x001738f5
SHL RSI,0x2
ADD RSI,qword ptr [RAX + 0x10]
LEA R10,[RCX*0x4]
MOV RDX,qword ptr [RAX + 0x40]
ADD RDX,R10
ADD R10,qword ptr [RAX + 0x58]
LEA R8,[RDI + RCX*0x4]
LEA R9,[R9 + RCX*0x4]
LEA RAX,[R11 + RCX*0x4]
LEA RDI,[R14 + RCX*0x4]
LEA RCX,[R15 + RCX*0x4]
MOV qword ptr [RSP + 0x10],RCX
MOV qword ptr [RSP + 0x8],RDI
MOV qword ptr [RSP],RAX
JMP 0x00173928
LAB_001738c3:
SHL RSI,0x2
ADD RSI,qword ptr [RAX + 0x10]
SHL RCX,0x2
MOV RDX,qword ptr [RAX + 0x40]
ADD RDX,RCX
ADD RCX,qword ptr [RAX + 0x58]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
MOV RDI,RBX
XOR R8D,R8D
XOR R9D,R9D
JMP 0x0017392e
LAB_001738f5:
SHL RSI,0x2
ADD RSI,qword ptr [RAX + 0x10]
LEA R10,[RCX*0x4]
MOV RDX,qword ptr [RAX + 0x40]
ADD RDX,R10
ADD R10,qword ptr [RAX + 0x58]
LEA R8,[RDI + RCX*0x4]
LEA R9,[R9 + RCX*0x4]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
LAB_00173928:
MOV RDI,RBX
MOV RCX,R10
LAB_0017392e:
CALL 0x0013ad20
MOV RAX,RBX
ADD RSP,0x20
POP RBX
POP R14
POP R15
RET
LAB_00173940:
LEA RDI,[0x1bcf5f]
LEA RSI,[0x1bce24]
LEA RCX,[0x1bcfa2]
MOV EDX,0x2ee
CALL 0x00139540
|
/* OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetLimitStencil(int) const */
LimitStencilReal<float> *
OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetLimitStencil(int param_1)
{
long lVar1;
int in_EDX;
int *piVar2;
long in_RSI;
long lVar3;
int *piVar4;
int4 in_register_0000003c;
float *pfVar5;
float *pfVar6;
float *pfVar7;
float *pfVar8;
float *pfVar9;
float *pfVar10;
lVar1 = *(long *)(in_RSI + 0x28);
if ((lVar1 != *(long *)(in_RSI + 0x30)) &&
(in_EDX < (int)((ulong)(*(long *)(in_RSI + 0x30) - lVar1) >> 2))) {
lVar3 = (long)in_EDX;
lVar1 = (long)*(int *)(lVar1 + lVar3 * 4);
if ((*(long *)(in_RSI + 0x70) == *(long *)(in_RSI + 0x78)) ||
(*(long *)(in_RSI + 0x88) == *(long *)(in_RSI + 0x90))) {
piVar4 = (int *)(lVar3 * 4 + *(long *)(in_RSI + 0x10));
piVar2 = (int *)(*(long *)(in_RSI + 0x40) + lVar1 * 4);
pfVar7 = (float *)(lVar1 * 4 + *(long *)(in_RSI + 0x58));
pfVar8 = (float *)0x0;
pfVar9 = (float *)0x0;
pfVar10 = (float *)0x0;
pfVar5 = (float *)0x0;
pfVar6 = (float *)0x0;
}
else {
if (((*(long *)(in_RSI + 0xa0) == *(long *)(in_RSI + 0xa8)) ||
(*(long *)(in_RSI + 0xb8) == *(long *)(in_RSI + 0xc0))) ||
(*(long *)(in_RSI + 0xd0) == *(long *)(in_RSI + 0xd8))) {
piVar4 = (int *)(lVar3 * 4 + *(long *)(in_RSI + 0x10));
piVar2 = (int *)(*(long *)(in_RSI + 0x40) + lVar1 * 4);
pfVar7 = (float *)(lVar1 * 4 + *(long *)(in_RSI + 0x58));
pfVar8 = (float *)0x0;
pfVar9 = (float *)0x0;
pfVar10 = (float *)0x0;
}
else {
piVar4 = (int *)(lVar3 * 4 + *(long *)(in_RSI + 0x10));
piVar2 = (int *)(*(long *)(in_RSI + 0x40) + lVar1 * 4);
pfVar7 = (float *)(lVar1 * 4 + *(long *)(in_RSI + 0x58));
pfVar8 = (float *)(*(long *)(in_RSI + 0xa0) + lVar1 * 4);
pfVar9 = (float *)(*(long *)(in_RSI + 0xb8) + lVar1 * 4);
pfVar10 = (float *)(*(long *)(in_RSI + 0xd0) + lVar1 * 4);
}
pfVar6 = (float *)(*(long *)(in_RSI + 0x88) + lVar1 * 4);
pfVar5 = (float *)(*(long *)(in_RSI + 0x70) + lVar1 * 4);
}
LimitStencilReal<float>::LimitStencilReal
((LimitStencilReal<float> *)CONCAT44(in_register_0000003c,param_1),piVar4,piVar2,
pfVar7,pfVar5,pfVar6,pfVar8,pfVar9,pfVar10);
return (LimitStencilReal<float> *)CONCAT44(in_register_0000003c,param_1);
}
/* WARNING: Subroutine does not return */
__assert_fail("(! this->GetOffsets().empty()) && i<(int)this->GetOffsets().size()",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/../far/stencilTable.h"
,0x2ee,
"LimitStencilReal<REAL> OpenSubdiv::v3_6_0::Far::LimitStencilTableReal<float>::GetLimitStencil(Index) const [REAL = float]"
);
}
|
|
19,831
|
my_uca_implicit_weight_put
|
eloqsql/strings/ctype-uca.c
|
static inline void
my_uca_implicit_weight_put(uint16 *to, my_wc_t code, uint level)
{
switch (level) {
case 1: to[0]= 0x0020; to[1]= 0; break; /* Secondary level */
case 2: to[0]= 0x0002; to[1]= 0; break; /* Tertiary level */
case 3: to[0]= 0x0001; to[1]= 0; break; /* Quaternary level */
default:
DBUG_ASSERT(0);
case 0:
break;
}
/* Primary level */
to[0]= (uint16)(code >> 15) + my_uca_implicit_weight_base(code);
to[1]= (code & 0x7FFF) | 0x8000;
to[2]= 0;
}
|
O0
|
c
|
my_uca_implicit_weight_put:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x3, %rax
ja 0x572c3
movq -0x20(%rbp), %rax
leaq 0xf3781(%rip), %rcx # 0x14a9fc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movw $0x20, (%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x2(%rax)
jmp 0x572cb
movq -0x8(%rbp), %rax
movw $0x2, (%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x2(%rax)
jmp 0x572cb
movq -0x8(%rbp), %rax
movw $0x1, (%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x2(%rax)
jmp 0x572cb
jmp 0x572c5
jmp 0x572c7
jmp 0x572c9
jmp 0x572cb
movq -0x10(%rbp), %rax
shrq $0xf, %rax
movzwl %ax, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x57330
movw %ax, %cx
movl -0x24(%rbp), %eax
movzwl %cx, %ecx
addl %ecx, %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, (%rax)
movq -0x10(%rbp), %rax
andq $0x7fff, %rax # imm = 0x7FFF
orq $0x8000, %rax # imm = 0x8000
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x2(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x4(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_uca_implicit_weight_put:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov eax, [rbp+var_14]
mov [rbp+var_20], rax
sub rax, 3; switch 4 cases
ja short def_57282; jumptable 0000000000057282 default case
mov rax, [rbp+var_20]
lea rcx, jpt_57282
movsxd rax, ds:(jpt_57282 - 14A9FCh)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_57284:
mov rax, [rbp+var_8]; jumptable 0000000000057282 case 1
mov word ptr [rax], 20h ; ' '
mov rax, [rbp+var_8]
mov word ptr [rax+2], 0
jmp short loc_572CB
loc_57299:
mov rax, [rbp+var_8]; jumptable 0000000000057282 case 2
mov word ptr [rax], 2
mov rax, [rbp+var_8]
mov word ptr [rax+2], 0
jmp short loc_572CB
loc_572AE:
mov rax, [rbp+var_8]; jumptable 0000000000057282 case 3
mov word ptr [rax], 1
mov rax, [rbp+var_8]
mov word ptr [rax+2], 0
jmp short loc_572CB
def_57282:
jmp short $+2; jumptable 0000000000057282 default case
loc_572C5:
jmp short $+2
loc_572C7:
jmp short $+2; jumptable 0000000000057282 case 0
loc_572C9:
jmp short $+2; jumptable 0000000000057282 case 0
loc_572CB:
mov rax, [rbp+var_10]
shr rax, 0Fh
movzx eax, ax
mov [rbp+var_24], eax
mov rdi, [rbp+var_10]
call my_uca_implicit_weight_base
mov cx, ax
mov eax, [rbp+var_24]
movzx ecx, cx
add eax, ecx
mov cx, ax
mov rax, [rbp+var_8]
mov [rax], cx
mov rax, [rbp+var_10]
and rax, 7FFFh
or rax, 8000h
mov cx, ax
mov rax, [rbp+var_8]
mov [rax+2], cx
mov rax, [rbp+var_8]
mov word ptr [rax+4], 0
add rsp, 30h
pop rbp
retn
|
_WORD * my_uca_implicit_weight_put(_WORD *a1, unsigned long long a2, int a3)
{
_WORD *result; // rax
switch ( a3 )
{
case 1:
*a1 = 32;
a1[1] = 0;
break;
case 2:
*a1 = 2;
a1[1] = 0;
break;
case 3:
*a1 = 1;
a1[1] = 0;
break;
default:
break;
}
*a1 = my_uca_implicit_weight_base(a2) + (a2 >> 15);
a1[1] = a2 & 0x7FFF | 0x8000;
result = a1;
a1[2] = 0;
return result;
}
|
my_uca_implicit_weight_put:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV EAX,dword ptr [RBP + -0x14]
MOV qword ptr [RBP + -0x20],RAX
SUB RAX,0x3
JA 0x001572c3
MOV RAX,qword ptr [RBP + -0x20]
LEA RCX,[0x24a9fc]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX],0x20
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX + 0x2],0x0
JMP 0x001572cb
caseD_2:
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX],0x2
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX + 0x2],0x0
JMP 0x001572cb
caseD_3:
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX],0x1
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX + 0x2],0x0
JMP 0x001572cb
LAB_001572c3:
JMP 0x001572c5
LAB_001572c5:
JMP 0x001572c7
LAB_001572c7:
JMP 0x001572c9
caseD_0:
JMP 0x001572cb
LAB_001572cb:
MOV RAX,qword ptr [RBP + -0x10]
SHR RAX,0xf
MOVZX EAX,AX
MOV dword ptr [RBP + -0x24],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00157330
MOV CX,AX
MOV EAX,dword ptr [RBP + -0x24]
MOVZX ECX,CX
ADD EAX,ECX
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x10]
AND RAX,0x7fff
OR RAX,0x8000
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX + 0x2],CX
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX + 0x4],0x0
ADD RSP,0x30
POP RBP
RET
|
void my_uca_implicit_weight_put(short *param_1,ulong param_2,int4 param_3)
{
short sVar1;
switch(param_3) {
default:
break;
case 1:
*param_1 = 0x20;
param_1[1] = 0;
break;
case 2:
*param_1 = 2;
param_1[1] = 0;
break;
case 3:
*param_1 = 1;
param_1[1] = 0;
}
sVar1 = my_uca_implicit_weight_base(param_2);
*param_1 = (short)(param_2 >> 0xf) + sVar1;
param_1[1] = (ushort)param_2 & 0x7fff | 0x8000;
param_1[2] = 0;
return;
}
|
|
19,832
|
mul_fp12
|
corpus-core[P]colibri-stateless/build_O2/_deps/blst-src/src/fp12_tower.c
|
static void mul_fp12(vec384fp12 ret, const vec384fp12 a, const vec384fp12 b)
{
vec768fp6 t0, t1, rx;
vec384fp6 t2;
mul_fp6x2(t0, a[0], b[0]);
mul_fp6x2(t1, a[1], b[1]);
/* ret[1] = (a0 + a1)*(b0 + b1) - a0*b0 - a1*b1
= a0*b1 + a1*b0 */
add_fp6(t2, a[0], a[1]);
add_fp6(ret[1], b[0], b[1]);
mul_fp6x2(rx, ret[1], t2);
sub_fp6x2(rx, rx, t0);
sub_fp6x2(rx, rx, t1);
redc_fp6x2(ret[1], rx);
/* ret[0] = a0*b0 + a1*b1*v */
mul_by_u_plus_1_fp2x2(rx[0], t1[2]);
add_fp2x2(rx[0], t0[0], rx[0]);
add_fp2x2(rx[1], t0[1], t1[0]);
add_fp2x2(rx[2], t0[2], t1[1]);
redc_fp6x2(ret[0], rx);
}
|
O2
|
c
|
mul_fp12:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7f8, %rsp # imm = 0x7F8
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, -0x30(%rbp)
leaq -0x820(%rbp), %r14
movq %r14, %rdi
callq 0x5bd7b
movl $0x120, %r13d # imm = 0x120
leaq (%rbx,%r13), %r15
leaq (%r12,%r13), %rdx
movq %rdx, -0x38(%rbp)
leaq -0x3a0(%rbp), %rdi
movq %r15, %rsi
callq 0x5bd7b
leaq -0x160(%rbp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x5bce4
addq -0x30(%rbp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq -0x38(%rbp), %rdx
callq 0x5bce4
leaq -0x5e0(%rbp), %r12
movq %r12, %rdi
movq %r13, %rsi
leaq -0x160(%rbp), %rdx
callq 0x5bd7b
movq %r12, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x5c1b7
movq %r12, %rdi
movq %r12, %rsi
leaq -0x3a0(%rbp), %rbx
movq %rbx, %rdx
callq 0x5c1b7
movq %r13, %rdi
movq %r12, %rsi
callq 0x5bf69
movl $0x180, %r15d # imm = 0x180
leaq (%rbx,%r15), %rsi
movq %rbx, %r13
movq %r12, %rdi
callq 0x5c009
movq %r12, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x5c04d
movl $0xc0, %ebx
leaq (%r12,%rbx), %rdi
leaq (%r14,%rbx), %rsi
movq %r13, %rdx
callq 0x5c04d
leaq (%r12,%r15), %rdi
addq %r15, %r14
addq %r13, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5c04d
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x5bf69
addq $0x7f8, %rsp # imm = 0x7F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
mul_fp12:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 7F8h
mov r12, rdx
mov rbx, rsi
mov [rbp+var_30], rdi
lea r14, [rbp+var_820]
mov rdi, r14
call mul_fp6x2
mov r13d, 120h
lea r15, [rbx+r13]
lea rdx, [r12+r13]
mov [rbp+var_38], rdx
lea rdi, [rbp+var_3A0]
mov rsi, r15
call mul_fp6x2
lea rdi, [rbp+var_160]
mov rsi, rbx
mov rdx, r15
call add_fp6
add r13, [rbp+var_30]
mov rdi, r13
mov rsi, r12
mov rdx, [rbp+var_38]
call add_fp6
lea r12, [rbp+var_5E0]
mov rdi, r12
mov rsi, r13
lea rdx, [rbp+var_160]
call mul_fp6x2
mov rdi, r12
mov rsi, r12
mov rdx, r14
call _sub_fp6x2
mov rdi, r12
mov rsi, r12
lea rbx, [rbp+var_3A0]
mov rdx, rbx
call _sub_fp6x2
mov rdi, r13
mov rsi, r12
call redc_fp6x2
mov r15d, 180h
lea rsi, [rbx+r15]
mov r13, rbx
mov rdi, r12
call mul_by_u_plus_1_fp2x2
mov rdi, r12
mov rsi, r14
mov rdx, r12
call add_fp2x2
mov ebx, 0C0h
lea rdi, [r12+rbx]
lea rsi, [r14+rbx]
mov rdx, r13
call add_fp2x2
lea rdi, [r12+r15]
add r14, r15
add rbx, r13
mov rsi, r14
mov rdx, rbx
call add_fp2x2
mov rdi, [rbp+var_30]
mov rsi, r12
call redc_fp6x2
add rsp, 7F8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long mul_fp12(long long a1, long long a2, long long a3)
{
long long v4; // r13
_BYTE v6[192]; // [rsp+0h] [rbp-820h] BYREF
long long v7; // [rsp+C0h] [rbp-760h] BYREF
long long v8; // [rsp+180h] [rbp-6A0h] BYREF
_BYTE v9[192]; // [rsp+240h] [rbp-5E0h] BYREF
long long v10; // [rsp+300h] [rbp-520h] BYREF
long long v11; // [rsp+3C0h] [rbp-460h] BYREF
_BYTE v12[192]; // [rsp+480h] [rbp-3A0h] BYREF
long long v13; // [rsp+540h] [rbp-2E0h] BYREF
long long v14; // [rsp+600h] [rbp-220h] BYREF
_BYTE v15[296]; // [rsp+6C0h] [rbp-160h] BYREF
long long v16; // [rsp+7E8h] [rbp-38h]
long long v17; // [rsp+7F0h] [rbp-30h]
v17 = a1;
mul_fp6x2(v6);
v16 = a3 + 288;
mul_fp6x2(v12);
add_fp6(v15, a2, a2 + 288);
v4 = v17 + 288;
add_fp6(v17 + 288, a3, v16);
mul_fp6x2(v9);
sub_fp6x2(v9, v9, v6);
sub_fp6x2(v9, v9, v12);
redc_fp6x2(v4, v9);
mul_by_u_plus_1_fp2x2(v9, &v14);
add_fp2x2(v9, v6, v9);
add_fp2x2(&v10, &v7, v12);
add_fp2x2(&v11, &v8, &v13);
return redc_fp6x2(v17, v9);
}
|
mul_fp12:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x7f8
MOV R12,RDX
MOV RBX,RSI
MOV qword ptr [RBP + -0x30],RDI
LEA R14,[RBP + -0x820]
MOV RDI,R14
CALL 0x0015bd7b
MOV R13D,0x120
LEA R15,[RBX + R13*0x1]
LEA RDX,[R12 + R13*0x1]
MOV qword ptr [RBP + -0x38],RDX
LEA RDI,[RBP + -0x3a0]
MOV RSI,R15
CALL 0x0015bd7b
LEA RDI,[RBP + -0x160]
MOV RSI,RBX
MOV RDX,R15
CALL 0x0015bce4
ADD R13,qword ptr [RBP + -0x30]
MOV RDI,R13
MOV RSI,R12
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x0015bce4
LEA R12,[RBP + -0x5e0]
MOV RDI,R12
MOV RSI,R13
LEA RDX,[RBP + -0x160]
CALL 0x0015bd7b
MOV RDI,R12
MOV RSI,R12
MOV RDX,R14
CALL 0x0015c1b7
MOV RDI,R12
MOV RSI,R12
LEA RBX,[RBP + -0x3a0]
MOV RDX,RBX
CALL 0x0015c1b7
MOV RDI,R13
MOV RSI,R12
CALL 0x0015bf69
MOV R15D,0x180
LEA RSI,[RBX + R15*0x1]
MOV R13,RBX
MOV RDI,R12
CALL 0x0015c009
MOV RDI,R12
MOV RSI,R14
MOV RDX,R12
CALL 0x0015c04d
MOV EBX,0xc0
LEA RDI,[R12 + RBX*0x1]
LEA RSI,[R14 + RBX*0x1]
MOV RDX,R13
CALL 0x0015c04d
LEA RDI,[R12 + R15*0x1]
ADD R14,R15
ADD RBX,R13
MOV RSI,R14
MOV RDX,RBX
CALL 0x0015c04d
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,R12
CALL 0x0015bf69
ADD RSP,0x7f8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void mul_fp12(long param_1,long param_2,long param_3)
{
long lVar1;
int1 local_828 [192];
int1 local_768 [192];
int1 auStack_6a8 [192];
int1 local_5e8 [192];
int1 local_528 [192];
int1 local_468 [192];
int1 local_3a8 [192];
int1 auStack_2e8 [192];
int1 local_228 [192];
int1 local_168 [296];
long local_40;
long local_38;
local_38 = param_1;
mul_fp6x2(local_828);
local_40 = param_3 + 0x120;
mul_fp6x2(local_3a8,param_2 + 0x120);
add_fp6(local_168,param_2,param_2 + 0x120);
lVar1 = local_38 + 0x120;
add_fp6(lVar1,param_3,local_40);
mul_fp6x2(local_5e8,lVar1,local_168);
sub_fp6x2(local_5e8,local_5e8,local_828);
sub_fp6x2(local_5e8,local_5e8,local_3a8);
redc_fp6x2(lVar1,local_5e8);
mul_by_u_plus_1_fp2x2(local_5e8,local_228);
add_fp2x2(local_5e8,local_828,local_5e8);
add_fp2x2(local_528,local_768,local_3a8);
add_fp2x2(local_468,auStack_6a8,auStack_2e8);
redc_fp6x2(local_38,local_5e8);
return;
}
|
|
19,833
|
parse_alpha_component
|
dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-paint.c
|
static bool parse_alpha_component(const char** begin, const char* end, float* component)
{
float value = 0;
if(!plutovg_parse_number(begin, end, &value))
return false;
if(plutovg_skip_delim(begin, end, '%'))
value /= 100.f;
*component = plutovg_clamp(value, 0.f, 1.f);
return true;
}
|
O0
|
c
|
parse_alpha_component:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0xdff0
testb $0x1, %al
jne 0xdf5a
movb $0x0, -0x1(%rbp)
jmp 0xdfe1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x25, %edx
callq 0xdce0
testb $0x1, %al
jne 0xdf72
jmp 0xdf88
movss -0x24(%rbp), %xmm0
movss 0x2d095(%rip), %xmm1 # 0x3b014
divss %xmm1, %xmm0
movss %xmm0, -0x24(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x24(%rbp), %xmm0
jbe 0xdf9b
xorps %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
jmp 0xdfd0
movss -0x24(%rbp), %xmm0
movss 0x2d07c(%rip), %xmm1 # 0x3b024
ucomiss %xmm1, %xmm0
jbe 0xdfbc
movss 0x2d06f(%rip), %xmm0 # 0x3b024
movss %xmm0, -0x2c(%rbp)
jmp 0xdfc6
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x28(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
parse_alpha_component:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
xorps xmm0, xmm0
movss [rbp+var_24], xmm0
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
lea rdx, [rbp+var_24]
call plutovg_parse_number_0
test al, 1
jnz short loc_DF5A
mov [rbp+var_1], 0
jmp loc_DFE1
loc_DF5A:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, 25h ; '%'
call plutovg_skip_delim_0
test al, 1
jnz short loc_DF72
jmp short loc_DF88
loc_DF72:
movss xmm0, [rbp+var_24]
movss xmm1, cs:dword_3B014
divss xmm0, xmm1
movss [rbp+var_24], xmm0
loc_DF88:
xorps xmm0, xmm0
ucomiss xmm0, [rbp+var_24]
jbe short loc_DF9B
xorps xmm0, xmm0
movss [rbp+var_28], xmm0
jmp short loc_DFD0
loc_DF9B:
movss xmm0, [rbp+var_24]
movss xmm1, cs:dword_3B024
ucomiss xmm0, xmm1
jbe short loc_DFBC
movss xmm0, cs:dword_3B024
movss [rbp+var_2C], xmm0
jmp short loc_DFC6
loc_DFBC:
movss xmm0, [rbp+var_24]
movss [rbp+var_2C], xmm0
loc_DFC6:
movss xmm0, [rbp+var_2C]
movss [rbp+var_28], xmm0
loc_DFD0:
movss xmm0, [rbp+var_28]
mov rax, [rbp+var_20]
movss dword ptr [rax], xmm0
mov [rbp+var_1], 1
loc_DFE1:
mov al, [rbp+var_1]
and al, 1
add rsp, 30h
pop rbp
retn
|
char parse_alpha_component(unsigned long long *a1, unsigned long long a2, int *a3)
{
int v4; // [rsp+4h] [rbp-2Ch]
int v5; // [rsp+8h] [rbp-28h]
float v6; // [rsp+Ch] [rbp-24h] BYREF
int *v7; // [rsp+10h] [rbp-20h]
unsigned long long v8; // [rsp+18h] [rbp-18h]
unsigned long long *v9; // [rsp+20h] [rbp-10h]
v9 = a1;
v8 = a2;
v7 = a3;
v6 = 0.0;
if ( (plutovg_parse_number_0(a1, a2, &v6) & 1) == 0 )
return 0;
if ( (plutovg_skip_delim_0(v9, v8, 37) & 1) != 0 )
v6 = v6 / 100.0;
if ( v6 >= 0.0 )
{
if ( v6 <= 1.0 )
v4 = LODWORD(v6);
else
v4 = 1065353216;
v5 = v4;
}
else
{
v5 = 0;
}
*v7 = v5;
return 1;
}
|
parse_alpha_component:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x24],XMM0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
LEA RDX,[RBP + -0x24]
CALL 0x0010dff0
TEST AL,0x1
JNZ 0x0010df5a
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0010dfe1
LAB_0010df5a:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,0x25
CALL 0x0010dce0
TEST AL,0x1
JNZ 0x0010df72
JMP 0x0010df88
LAB_0010df72:
MOVSS XMM0,dword ptr [RBP + -0x24]
MOVSS XMM1,dword ptr [0x0013b014]
DIVSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x24],XMM0
LAB_0010df88:
XORPS XMM0,XMM0
UCOMISS XMM0,dword ptr [RBP + -0x24]
JBE 0x0010df9b
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x28],XMM0
JMP 0x0010dfd0
LAB_0010df9b:
MOVSS XMM0,dword ptr [RBP + -0x24]
MOVSS XMM1,dword ptr [0x0013b024]
UCOMISS XMM0,XMM1
JBE 0x0010dfbc
MOVSS XMM0,dword ptr [0x0013b024]
MOVSS dword ptr [RBP + -0x2c],XMM0
JMP 0x0010dfc6
LAB_0010dfbc:
MOVSS XMM0,dword ptr [RBP + -0x24]
MOVSS dword ptr [RBP + -0x2c],XMM0
LAB_0010dfc6:
MOVSS XMM0,dword ptr [RBP + -0x2c]
MOVSS dword ptr [RBP + -0x28],XMM0
LAB_0010dfd0:
MOVSS XMM0,dword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x20]
MOVSS dword ptr [RAX],XMM0
MOV byte ptr [RBP + -0x1],0x1
LAB_0010dfe1:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x30
POP RBP
RET
|
int1 parse_alpha_component(int8 param_1,int8 param_2,float *param_3)
{
ulong uVar1;
float local_34;
float local_30;
float local_2c;
float *local_28;
int8 local_20;
int8 local_18;
int1 local_9;
local_2c = 0.0;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
uVar1 = plutovg_parse_number(param_1,param_2,&local_2c);
if ((uVar1 & 1) == 0) {
local_9 = 0;
}
else {
uVar1 = plutovg_skip_delim(local_18,local_20,0x25);
if ((uVar1 & 1) != 0) {
local_2c = local_2c / DAT_0013b014;
}
if (0.0 <= local_2c) {
if (local_2c <= DAT_0013b024) {
local_34 = local_2c;
}
else {
local_34 = DAT_0013b024;
}
local_30 = local_34;
}
else {
local_30 = 0.0;
}
*local_28 = local_30;
local_9 = 1;
}
return local_9;
}
|
|
19,834
|
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>::basic_json<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
|
msxemulator/build_O3/_deps/picotool-src/lib/nlohmann_json/single_include/nlohmann/json.hpp
|
basic_json(CompatibleType && val) noexcept(noexcept( // NOLINT(bugprone-forwarding-reference-overload,bugprone-exception-escape)
JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
std::forward<CompatibleType>(val))))
{
JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
set_parents();
assert_invariant();
}
|
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>::basic_json<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %r14, %rdi
xorl %esi, %esi
callq 0x5c650
movb $0x3, (%rbx)
movq %r15, %rdi
callq 0x699aa
movq %rax, (%r14)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5c638
movq %r14, %rdi
callq 0xf7d0
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_:
push r15
push r14
push rbx
mov r15, rsi
mov rbx, rdi
lea r14, [rdi+8]
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov rdi, r14
xor esi, esi
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10json_value7destroyENS0_6detail7value_tE; 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>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t)
mov byte ptr [rbx], 3
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS9_JRKS9_EEEPT_DpOT0_; 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>::create<std::string,std::string const&>(std::string const&)
mov [r14], rax
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov rdi, rbx
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()
mov rdi, r14
call __Unwind_Resume
|
long long ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_(
long long a1,
long long a2)
{
long long result; // rax
*(_OWORD *)a1 = 0LL;
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>::json_value::destroy(
(void ***)(a1 + 8),
0);
*(_BYTE *)a1 = 3;
result = 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>::create<std::string,std::string const&>(a2);
*(_QWORD *)(a1 + 8) = result;
return result;
}
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_:
PUSH R15
PUSH R14
PUSH RBX
MOV R15,RSI
MOV RBX,RDI
LEA R14,[RDI + 0x8]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
LAB_001698fd:
MOV RDI,R14
XOR ESI,ESI
CALL 0x0015c650
MOV byte ptr [RBX],0x3
MOV RDI,R15
CALL 0x001699aa
LAB_00169912:
MOV qword ptr [R14],RAX
POP RBX
POP R14
POP R15
RET
|
void _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
(int8 *param_1,string *param_2)
{
string *psVar1;
*param_1 = 0;
param_1[1] = 0;
/* try { // try from 001698fd to 00169911 has its CatchHandler @ 0016991b */
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>
::json_value::destroy((json_value *)(param_1 + 1),0);
*(int1 *)param_1 = 3;
psVar1 = 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>
::create<std::__cxx11::string,std::__cxx11::string_const&>(param_2);
*(string **)(param_1 + 1) = psVar1;
return;
}
|
|
19,835
|
proof_create_multiproof
|
corpus-core[P]colibri-stateless/src/chains/eth/proofer/proof_logs.c
|
static c4_status_t proof_create_multiproof(proofer_ctx_t* ctx, proof_logs_block_t* block) {
int i = 0;
gindex_t* gindex = safe_calloc(3 + block->tx_count, sizeof(gindex_t));
gindex[0] = ssz_gindex(block->beacon_block.body.def, 2, "executionPayload", "blockNumber");
gindex[1] = ssz_gindex(block->beacon_block.body.def, 2, "executionPayload", "blockHash");
gindex[2] = ssz_gindex(block->beacon_block.body.def, 2, "executionPayload", "receiptsRoot");
for (proof_logs_tx_t* tx = block->txs; tx; tx = tx->next, i++)
gindex[i + 3] = ssz_gindex(block->beacon_block.body.def, 3, "executionPayload", "transactions", tx->tx_index);
block->proof = ssz_create_multi_proof_for_gindexes(block->beacon_block.body, block->body_root, gindex, 3 + block->tx_count);
safe_free(gindex);
return C4_SUCCESS;
}
|
O0
|
c
|
proof_create_multiproof:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
addl $0x3, %eax
movl %eax, %eax
movl %eax, %edi
movl $0x8, %esi
callq 0x18620
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rdi
movl $0x2, %esi
leaq 0x494a8(%rip), %rdx # 0x526d2
leaq 0x49434(%rip), %rcx # 0x52665
movb $0x0, %al
callq 0x1c250
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rdi
movl $0x2, %esi
leaq 0x49479(%rip), %rdx # 0x526d2
leaq 0x49483(%rip), %rcx # 0x526e3
movb $0x0, %al
callq 0x1c250
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rdi
movl $0x2, %esi
leaq 0x49449(%rip), %rdx # 0x526d2
leaq 0x494e2(%rip), %rcx # 0x52772
movb $0x0, %al
callq 0x1c250
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x930d
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rdi
movq -0x28(%rbp), %rax
movl 0x28(%rax), %r8d
movl $0x3, %esi
leaq 0x493fe(%rip), %rdx # 0x526d2
leaq 0x49420(%rip), %rcx # 0x526fb
movb $0x0, %al
callq 0x1c250
movq %rax, %rdx
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x92ae
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
addq $0x58, %rax
addq $0x38, %rax
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rcx
movl 0x50(%rcx), %edx
addl $0x3, %edx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x1ce90
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rdi
callq 0x18740
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
proof_create_multiproof:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], 0
mov rax, [rbp+var_10]
mov eax, [rax+50h]
add eax, 3
mov eax, eax
mov edi, eax
mov esi, 8
call safe_calloc
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax+0A0h]
mov esi, 2
lea rdx, aExecutionpaylo; "executionPayload"
lea rcx, aBlocknumber; "blockNumber"
mov al, 0
call ssz_gindex
mov rcx, rax
mov rax, [rbp+var_20]
mov [rax], rcx
mov rax, [rbp+var_10]
mov rdi, [rax+0A0h]
mov esi, 2
lea rdx, aExecutionpaylo; "executionPayload"
lea rcx, aBlockhash; "blockHash"
mov al, 0
call ssz_gindex
mov rcx, rax
mov rax, [rbp+var_20]
mov [rax+8], rcx
mov rax, [rbp+var_10]
mov rdi, [rax+0A0h]
mov esi, 2
lea rdx, aExecutionpaylo; "executionPayload"
lea rcx, aReceiptsroot; "receiptsRoot"
mov al, 0
call ssz_gindex
mov rcx, rax
mov rax, [rbp+var_20]
mov [rax+10h], rcx
mov rax, [rbp+var_10]
mov rax, [rax+48h]
mov [rbp+var_28], rax
loc_92AE:
cmp [rbp+var_28], 0
jz short loc_930D
mov rax, [rbp+var_10]
mov rdi, [rax+0A0h]
mov rax, [rbp+var_28]
mov r8d, [rax+28h]
mov esi, 3
lea rdx, aExecutionpaylo; "executionPayload"
lea rcx, aTransactions; "transactions"
mov al, 0
call ssz_gindex
mov rdx, rax
mov rax, [rbp+var_20]
mov ecx, [rbp+var_14]
add ecx, 3
movsxd rcx, ecx
mov [rax+rcx*8], rdx
mov rax, [rbp+var_28]
mov rax, [rax+58h]
mov [rbp+var_28], rax
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp short loc_92AE
loc_930D:
mov rax, [rbp+var_10]
mov [rbp+var_40], rax
mov rax, [rbp+var_10]
add rax, 58h ; 'X'
add rax, 38h ; '8'
mov rdi, [rbp+var_10]
add rdi, 0C0h
mov rsi, [rbp+var_20]
mov rcx, [rbp+var_10]
mov edx, [rcx+50h]
add edx, 3
mov rcx, [rax]
mov [rsp+60h+var_60], rcx
mov rcx, [rax+8]
mov [rsp+60h+var_58], rcx
mov rax, [rax+10h]
mov [rsp+60h+var_50], rax
call ssz_create_multi_proof_for_gindexes
mov ecx, eax
mov rax, [rbp+var_40]
mov dword ptr [rbp+var_38], ecx
mov [rbp+var_30], rdx
mov rcx, [rbp+var_38]
mov [rax+18h], rcx
mov rcx, [rbp+var_30]
mov [rax+20h], rcx
mov rdi, [rbp+var_20]
call safe_free
xor eax, eax
add rsp, 60h
pop rbp
retn
|
long long proof_create_multiproof(long long a1, long long a2)
{
int v2; // r8d
int v3; // r9d
int v4; // r8d
int v5; // r9d
int v6; // r8d
int v7; // r9d
int v8; // r8d
int v9; // r9d
long long v10; // rdx
long long v12; // [rsp+28h] [rbp-38h]
long long v13; // [rsp+38h] [rbp-28h]
long long *v14; // [rsp+40h] [rbp-20h]
int v15; // [rsp+4Ch] [rbp-14h]
v15 = 0;
v14 = (long long *)safe_calloc((unsigned int)(*(_DWORD *)(a2 + 80) + 3), 8LL);
*v14 = ssz_gindex(*(_QWORD *)(a2 + 160), 2, (unsigned int)"executionPayload", (unsigned int)"blockNumber", v2, v3);
v14[1] = ssz_gindex(*(_QWORD *)(a2 + 160), 2, (unsigned int)"executionPayload", (unsigned int)"blockHash", v4, v5);
v14[2] = ssz_gindex(*(_QWORD *)(a2 + 160), 2, (unsigned int)"executionPayload", (unsigned int)"receiptsRoot", v6, v7);
v13 = *(_QWORD *)(a2 + 72);
while ( v13 )
{
v14[v15 + 3] = ssz_gindex(
*(_QWORD *)(a2 + 160),
3,
(unsigned int)"executionPayload",
(unsigned int)"transactions",
*(_DWORD *)(v13 + 40),
v9);
v13 = *(_QWORD *)(v13 + 88);
++v15;
}
LODWORD(v12) = ssz_create_multi_proof_for_gindexes(
(int)a2 + 192,
(_DWORD)v14,
*(_DWORD *)(a2 + 80) + 3,
*(_QWORD *)(a2 + 152),
v8,
v9,
*(_QWORD *)(a2 + 144),
*(_QWORD *)(a2 + 152),
*(_QWORD *)(a2 + 160));
*(_QWORD *)(a2 + 24) = v12;
*(_QWORD *)(a2 + 32) = v10;
safe_free(v14);
return 0LL;
}
|
proof_create_multiproof:
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],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x50]
ADD EAX,0x3
MOV EAX,EAX
MOV EDI,EAX
MOV ESI,0x8
CALL 0x00118620
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0xa0]
MOV ESI,0x2
LEA RDX,[0x1526d2]
LEA RCX,[0x152665]
MOV AL,0x0
CALL 0x0011c250
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0xa0]
MOV ESI,0x2
LEA RDX,[0x1526d2]
LEA RCX,[0x1526e3]
MOV AL,0x0
CALL 0x0011c250
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0xa0]
MOV ESI,0x2
LEA RDX,[0x1526d2]
LEA RCX,[0x152772]
MOV AL,0x0
CALL 0x0011c250
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x48]
MOV qword ptr [RBP + -0x28],RAX
LAB_001092ae:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0010930d
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0xa0]
MOV RAX,qword ptr [RBP + -0x28]
MOV R8D,dword ptr [RAX + 0x28]
MOV ESI,0x3
LEA RDX,[0x1526d2]
LEA RCX,[0x1526fb]
MOV AL,0x0
CALL 0x0011c250
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x14]
ADD ECX,0x3
MOVSXD RCX,ECX
MOV qword ptr [RAX + RCX*0x8],RDX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x58]
MOV qword ptr [RBP + -0x28],RAX
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001092ae
LAB_0010930d:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x58
ADD RAX,0x38
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0xc0
MOV RSI,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RCX + 0x50]
ADD EDX,0x3
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x0011ce90
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x38],ECX
MOV qword ptr [RBP + -0x30],RDX
MOV RCX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x18],RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x20],RCX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00118740
XOR EAX,EAX
ADD RSP,0x60
POP RBP
RET
|
int8 proof_create_multiproof(int8 param_1,long param_2)
{
int4 uVar1;
int8 *puVar2;
int8 uVar3;
int8 extraout_RDX;
int4 uStack_3c;
long local_30;
int local_1c;
local_1c = 0;
puVar2 = (int8 *)safe_calloc(*(int *)(param_2 + 0x50) + 3,8);
uVar3 = ssz_gindex(*(int8 *)(param_2 + 0xa0),2,"executionPayload","blockNumber");
*puVar2 = uVar3;
uVar3 = ssz_gindex(*(int8 *)(param_2 + 0xa0),2,"executionPayload","blockHash");
puVar2[1] = uVar3;
uVar3 = ssz_gindex(*(int8 *)(param_2 + 0xa0),2,"executionPayload","receiptsRoot");
puVar2[2] = uVar3;
for (local_30 = *(long *)(param_2 + 0x48); local_30 != 0; local_30 = *(long *)(local_30 + 0x58)) {
uVar3 = ssz_gindex(*(int8 *)(param_2 + 0xa0),3,"executionPayload","transactions",
*(int4 *)(local_30 + 0x28));
puVar2[local_1c + 3] = uVar3;
local_1c = local_1c + 1;
}
uVar1 = ssz_create_multi_proof_for_gindexes(param_2 + 0xc0,puVar2,*(int *)(param_2 + 0x50) + 3);
*(ulong *)(param_2 + 0x18) = CONCAT44(uStack_3c,uVar1);
*(int8 *)(param_2 + 0x20) = extraout_RDX;
safe_free(puVar2);
return 0;
}
|
|
19,836
|
add_task(int)
|
tinyCoroLab/examples/mutex.cpp
|
task<> add_task(int i)
{
co_await mtx.lock();
log::info("task {} fetch lock", i);
for (int i = 0; i < 10000; i++)
{
data += 1;
}
mtx.unlock();
co_return;
}
|
O3
|
cpp
|
add_task(int):
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl $0x38, %edi
callq 0x7250
leaq 0xd0(%rip), %rcx # 0x7a96
movq %rcx, (%rax)
leaq 0x1d5(%rip), %rcx # 0x7ba5
movq %rcx, 0x8(%rax)
movl %ebx, 0x30(%rax)
movq $0x0, 0x10(%rax)
movq %rax, (%r14)
movb $0x0, 0x34(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
_Z8add_taski:
push r14
push rbx
push rax
mov ebx, esi
mov r14, rdi
mov edi, 38h ; '8'; unsigned __int64
call __Znwm; operator new(ulong)
lea rcx, _Z8add_taski_resume; add_task(int) [clone]
mov [rax], rcx
lea rcx, _Z8add_taski_destroy; add_task(int) [clone]
mov [rax+8], rcx
mov [rax+30h], ebx
mov qword ptr [rax+10h], 0
mov [r14], rax
mov byte ptr [rax+34h], 0
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
|
_QWORD * add_task(_QWORD *a1, int a2)
{
long long v2; // rax
v2 = operator new(0x38uLL);
*(_QWORD *)v2 = add_task;
*(_QWORD *)(v2 + 8) = add_task;
*(_DWORD *)(v2 + 48) = a2;
*(_QWORD *)(v2 + 16) = 0LL;
*a1 = v2;
*(_BYTE *)(v2 + 52) = 0;
return a1;
}
|
add_task:
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,ESI
MOV R14,RDI
MOV EDI,0x38
CALL 0x00107250
LEA RCX,[0x107a96]
MOV qword ptr [RAX],RCX
LEA RCX,[0x107ba5]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x30],EBX
MOV qword ptr [RAX + 0x10],0x0
MOV qword ptr [R14],RAX
MOV byte ptr [RAX + 0x34],0x0
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* add_task(int) */
int8 * add_task(int param_1)
{
int8 *puVar1;
int4 in_ESI;
int4 in_register_0000003c;
puVar1 = (int8 *)operator_new(0x38);
*puVar1 = add_task;
puVar1[1] = add_task;
*(int4 *)(puVar1 + 6) = in_ESI;
puVar1[2] = 0;
*(int8 *)CONCAT44(in_register_0000003c,param_1) = puVar1;
*(int1 *)((long)puVar1 + 0x34) = 0;
return (int8 *)CONCAT44(in_register_0000003c,param_1);
}
|
|
19,837
|
std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> string_split<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
|
monkey531[P]llama/common/common.h
|
std::vector<std::string> string_split<std::string>(const std::string & input, char separator)
{
std::vector<std::string> parts;
size_t begin_pos = 0;
size_t separator_pos = input.find(separator);
while (separator_pos != std::string::npos) {
std::string part = input.substr(begin_pos, separator_pos - begin_pos);
parts.emplace_back(part);
begin_pos = separator_pos + 1;
separator_pos = input.find(separator, begin_pos);
}
parts.emplace_back(input.substr(begin_pos, separator_pos - begin_pos));
return parts;
}
|
O0
|
c
|
std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> string_split<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char):
subq $0x88, %rsp
movq %rdi, (%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x8(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movb %al, 0x77(%rsp)
movb $0x0, 0x76(%rsp)
callq 0x63330
movq $0x0, 0x68(%rsp)
movq 0x78(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movsbl 0x77(%rsp), %esi
callq 0x5b2b0
movq %rax, 0x60(%rsp)
cmpq $-0x1, 0x60(%rsp)
je 0x8299d
movq 0x78(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x60(%rsp), %rcx
subq %rdx, %rcx
leaq 0x40(%rsp), %rdi
callq 0x5b140
jmp 0x8292b
movq (%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x94350
jmp 0x8293b
movq 0x60(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x68(%rsp)
movq 0x78(%rsp), %rdi
movb 0x77(%rsp), %al
movq 0x68(%rsp), %rdx
movsbl %al, %esi
callq 0x5b2b0
movq %rax, 0x60(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5b588
jmp 0x82901
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x82a13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5b588
jmp 0x82a13
movq 0x78(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x60(%rsp), %rcx
subq %rdx, %rcx
leaq 0x10(%rsp), %rdi
callq 0x5b140
jmp 0x829bb
movq (%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x943d0
jmp 0x829cb
leaq 0x10(%rsp), %rdi
callq 0x5b588
movb $0x1, 0x76(%rsp)
testb $0x1, 0x76(%rsp)
jne 0x82a06
jmp 0x829fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x5b588
jmp 0x82a13
movq (%rsp), %rdi
callq 0x63380
movq 0x8(%rsp), %rax
addq $0x88, %rsp
retq
movq (%rsp), %rdi
callq 0x63380
movq 0x38(%rsp), %rdi
callq 0x5abf0
nopw %cs:(%rax,%rax)
|
_ZL12string_splitINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEESt6vectorIT_SaIS7_EERKS5_c:
sub rsp, 88h
mov [rsp+88h+var_88], rdi
mov al, dl
mov rcx, rdi
mov [rsp+88h+var_80], rcx
mov [rsp+88h+var_8], rdi
mov [rsp+88h+var_10], rsi
mov [rsp+88h+var_11], al
mov [rsp+88h+var_12], 0
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2Ev; std::vector<std::string>::vector(void)
mov [rsp+88h+var_20], 0
mov rdi, [rsp+88h+var_10]
xor eax, eax
mov edx, eax
movsx esi, [rsp+88h+var_11]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEcm; std::string::find(char,ulong)
mov [rsp+88h+var_28], rax
loc_82901:
cmp [rsp+88h+var_28], 0FFFFFFFFFFFFFFFFh
jz loc_8299D
mov rsi, [rsp+88h+var_10]
mov rdx, [rsp+88h+var_20]
mov rcx, [rsp+88h+var_28]
sub rcx, rdx
lea rdi, [rsp+88h+var_48]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
jmp short $+2
loc_8292B:
mov rdi, [rsp+88h+var_88]
lea rsi, [rsp+88h+var_48]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJRS5_EEES9_DpOT_; std::vector<std::string>::emplace_back<std::string&>(std::string&)
jmp short $+2
loc_8293B:
mov rax, [rsp+88h+var_28]
add rax, 1
mov [rsp+88h+var_20], rax
mov rdi, [rsp+88h+var_10]
mov al, [rsp+88h+var_11]
mov rdx, [rsp+88h+var_20]
movsx esi, al
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEcm; std::string::find(char,ulong)
mov [rsp+88h+var_28], rax
lea rdi, [rsp+88h+var_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_82901
mov rcx, rax
mov eax, edx
mov [rsp+arg_30], rcx
mov [rsp+arg_2C], eax
jmp loc_82A13
mov rcx, rax
mov eax, edx
mov [rsp+arg_30], rcx
mov [rsp+arg_2C], eax
lea rdi, [rsp+arg_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_82A13
loc_8299D:
mov rsi, [rsp+88h+var_10]
mov rdx, [rsp+88h+var_20]
mov rcx, [rsp+88h+var_28]
sub rcx, rdx
lea rdi, [rsp+88h+var_78]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
jmp short $+2
loc_829BB:
mov rdi, [rsp+88h+var_88]
lea rsi, [rsp+88h+var_78]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
jmp short $+2
loc_829CB:
lea rdi, [rsp+88h+var_78]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov [rsp+88h+var_12], 1
test [rsp+88h+var_12], 1
jnz short loc_82A06
jmp short loc_829FD
mov rcx, rax
mov eax, edx
mov [rsp+arg_30], rcx
mov [rsp+arg_2C], eax
lea rdi, [rsp+arg_8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_82A13
loc_829FD:
mov rdi, [rsp+88h+var_88]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
loc_82A06:
mov rax, [rsp+88h+var_80]
add rsp, 88h
retn
loc_82A13:
mov rdi, [rsp+0]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, [rsp+arg_30]
call __Unwind_Resume
|
long long string_split<std::string>(long long a1, long long a2, char a3)
{
_BYTE v4[48]; // [rsp+10h] [rbp-78h] BYREF
_BYTE v5[32]; // [rsp+40h] [rbp-48h] BYREF
long long v6; // [rsp+60h] [rbp-28h]
long long v7; // [rsp+68h] [rbp-20h]
char v8; // [rsp+76h] [rbp-12h]
char v9; // [rsp+77h] [rbp-11h]
long long v10; // [rsp+78h] [rbp-10h]
long long v11; // [rsp+80h] [rbp-8h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = 0;
std::vector<std::string>::vector(a1);
v7 = 0LL;
v6 = std::string::find(a2, (unsigned int)v9, 0LL);
while ( v6 != -1 )
{
std::string::substr(v5, v10, v7, v6 - v7);
std::vector<std::string>::emplace_back<std::string&>(a1, v5);
v7 = v6 + 1;
v6 = std::string::find(v10, (unsigned int)v9, v6 + 1);
std::string::~string(v5);
}
std::string::substr(v4, v10, v7, -1 - v7);
std::vector<std::string>::emplace_back<std::string>(a1, v4);
std::string::~string(v4);
return a1;
}
|
string_split<std::__cxx11::string>:
SUB RSP,0x88
MOV qword ptr [RSP],RDI
MOV AL,DL
MOV RCX,RDI
MOV qword ptr [RSP + 0x8],RCX
MOV qword ptr [RSP + 0x80],RDI
MOV qword ptr [RSP + 0x78],RSI
MOV byte ptr [RSP + 0x77],AL
MOV byte ptr [RSP + 0x76],0x0
CALL 0x00163330
MOV qword ptr [RSP + 0x68],0x0
MOV RDI,qword ptr [RSP + 0x78]
XOR EAX,EAX
MOV EDX,EAX
MOVSX ESI,byte ptr [RSP + 0x77]
CALL 0x0015b2b0
MOV qword ptr [RSP + 0x60],RAX
LAB_00182901:
CMP qword ptr [RSP + 0x60],-0x1
JZ 0x0018299d
MOV RSI,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x68]
MOV RCX,qword ptr [RSP + 0x60]
SUB RCX,RDX
LAB_0018291f:
LEA RDI,[RSP + 0x40]
CALL 0x0015b140
JMP 0x0018292b
LAB_0018292b:
MOV RDI,qword ptr [RSP]
LEA RSI,[RSP + 0x40]
CALL 0x00194350
JMP 0x0018293b
LAB_0018293b:
MOV RAX,qword ptr [RSP + 0x60]
ADD RAX,0x1
MOV qword ptr [RSP + 0x68],RAX
MOV RDI,qword ptr [RSP + 0x78]
MOV AL,byte ptr [RSP + 0x77]
MOV RDX,qword ptr [RSP + 0x68]
MOVSX ESI,AL
CALL 0x0015b2b0
MOV qword ptr [RSP + 0x60],RAX
LEA RDI,[RSP + 0x40]
CALL 0x0015b588
JMP 0x00182901
LAB_0018299d:
MOV RSI,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x68]
MOV RCX,qword ptr [RSP + 0x60]
SUB RCX,RDX
LAB_001829af:
LEA RDI,[RSP + 0x10]
CALL 0x0015b140
JMP 0x001829bb
LAB_001829bb:
MOV RDI,qword ptr [RSP]
LEA RSI,[RSP + 0x10]
CALL 0x001943d0
LAB_001829c9:
JMP 0x001829cb
LAB_001829cb:
LEA RDI,[RSP + 0x10]
CALL 0x0015b588
MOV byte ptr [RSP + 0x76],0x1
TEST byte ptr [RSP + 0x76],0x1
JNZ 0x00182a06
JMP 0x001829fd
LAB_001829fd:
MOV RDI,qword ptr [RSP]
CALL 0x00163380
LAB_00182a06:
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x88
RET
|
/* WARNING: Removing unreachable block (ram,0x001829e1) */
/* std::vector<std::__cxx11::string, std::allocator<std::__cxx11::string > >
string_split<std::__cxx11::string >(std::__cxx11::string const&, char) */
string * string_split<std::__cxx11::string>(string *param_1,char param_2)
{
char in_DL;
int7 in_register_00000031;
string local_78 [48];
string local_48 [32];
long local_28;
long local_20;
int1 local_12;
char local_11;
ulong local_10;
string *local_8;
local_10 = CONCAT71(in_register_00000031,param_2);
local_12 = 0;
local_11 = in_DL;
local_8 = param_1;
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)param_1);
local_20 = 0;
local_28 = std::__cxx11::string::find((char)local_10,(ulong)(uint)(int)local_11);
while (local_28 != -1) {
/* try { // try from 0018291f to 00182928 has its CatchHandler @ 00182970 */
std::__cxx11::string::substr((ulong)local_48,local_10);
/* try { // try from 0018292b to 00182938 has its CatchHandler @ 00182983 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string&>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)param_1,local_48
);
local_20 = local_28 + 1;
local_28 = std::__cxx11::string::find((char)local_10,(ulong)(uint)(int)local_11);
std::__cxx11::string::~string(local_48);
}
/* try { // try from 001829af to 001829b8 has its CatchHandler @ 00182970 */
std::__cxx11::string::substr((ulong)local_78,local_10);
/* try { // try from 001829bb to 001829c8 has its CatchHandler @ 001829e3 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)param_1,local_78);
std::__cxx11::string::~string(local_78);
return param_1;
}
|
|
19,838
|
std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> string_split<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
|
monkey531[P]llama/common/common.h
|
std::vector<std::string> string_split<std::string>(const std::string & input, char separator)
{
std::vector<std::string> parts;
size_t begin_pos = 0;
size_t separator_pos = input.find(separator);
while (separator_pos != std::string::npos) {
std::string part = input.substr(begin_pos, separator_pos - begin_pos);
parts.emplace_back(part);
begin_pos = separator_pos + 1;
separator_pos = input.find(separator, begin_pos);
}
parts.emplace_back(input.substr(begin_pos, separator_pos - begin_pos));
return parts;
}
|
O2
|
c
|
std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> string_split<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
xorl %r13d, %r13d
movq %rsi, %rdi
movl %edx, %esi
xorl %edx, %edx
callq 0x23b90
movq %rax, %r15
leaq 0x8(%rsp), %r12
movsbl %bpl, %eax
movl %eax, 0x4(%rsp)
cmpq $-0x1, %r15
je 0x358e9
movq %r15, %rcx
subq %r13, %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x23940
movq %rbx, %rbp
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3ad14
incq %r15
movq %r14, %rdi
movl 0x4(%rsp), %esi
movq %r15, %rdx
callq 0x23b90
movq %rax, %rbx
movq %r12, %rdi
callq 0x241f8
movq %r15, %r13
movq %rbx, %r15
movq %rbp, %rbx
jmp 0x35899
movq %r13, %rcx
notq %rcx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x23940
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3ad50
leaq 0x8(%rsp), %rdi
callq 0x241f8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rbp
jmp 0x35937
jmp 0x3592f
movq %rbx, %rbp
movq %rax, %r14
jmp 0x35944
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x241f8
movq %rbp, %rdi
callq 0x276c2
movq %r14, %rdi
callq 0x23fc0
|
_ZL12string_splitINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEESt6vectorIT_SaIS7_EERKS5_c:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov ebp, edx
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
and qword ptr [rdi+10h], 0
xor r13d, r13d
mov rdi, rsi
mov esi, edx
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEcm; std::string::find(char,ulong)
mov r15, rax
lea r12, [rsp+58h+var_50]
movsx eax, bpl
mov [rsp+58h+var_54], eax
loc_35899:
cmp r15, 0FFFFFFFFFFFFFFFFh
jz short loc_358E9
mov rcx, r15
sub rcx, r13
mov rdi, r12
mov rsi, r14
mov rdx, r13
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rbp, rbx
mov rdi, rbx
mov rsi, r12
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJRS5_EEES9_DpOT_; std::vector<std::string>::emplace_back<std::string&>(std::string&)
inc r15
mov rdi, r14
mov esi, [rsp+58h+var_54]
mov rdx, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEcm; std::string::find(char,ulong)
mov rbx, rax
mov rdi, r12; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov r13, r15
mov r15, rbx
mov rbx, rbp
jmp short loc_35899
loc_358E9:
mov rcx, r13
not rcx
lea rdi, [rsp+58h+var_50]
mov rsi, r14
mov rdx, r13
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
lea rsi, [rsp+58h+var_50]
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
lea rdi, [rsp+58h+var_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbp, rbx
jmp short loc_35937
jmp short $+2
loc_3592F:
mov rbp, rbx
mov r14, rax
jmp short loc_35944
loc_35937:
mov r14, rax
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_35944:
mov rdi, rbp
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, r14
call __Unwind_Resume
|
long long string_split<std::string>(long long a1, long long a2, unsigned int a3)
{
char v3; // bp
long long v4; // rbx
long long v5; // r13
long long v6; // r15
long long v7; // rbp
long long v8; // r15
long long v9; // rbx
unsigned int v11; // [rsp+4h] [rbp-54h]
_BYTE v12[80]; // [rsp+8h] [rbp-50h] BYREF
v3 = a3;
v4 = a1;
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
v5 = 0LL;
v6 = std::string::find(a2, a3, 0LL);
v11 = v3;
while ( v6 != -1 )
{
std::string::substr(v12, a2, v5, v6 - v5);
v7 = v4;
std::vector<std::string>::emplace_back<std::string&>(v4, v12);
v8 = v6 + 1;
v9 = std::string::find(a2, v11, v8);
std::string::~string(v12);
v5 = v8;
v6 = v9;
v4 = v7;
}
std::string::substr(v12, a2, v5, ~v5);
std::vector<std::string>::emplace_back<std::string>(v4, v12);
std::string::~string(v12);
return v4;
}
|
string_split<std::__cxx11::string>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBP,EDX
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
AND qword ptr [RDI + 0x10],0x0
XOR R13D,R13D
MOV RDI,RSI
MOV ESI,EDX
XOR EDX,EDX
CALL 0x00123b90
MOV R15,RAX
LEA R12,[RSP + 0x8]
MOVSX EAX,BPL
MOV dword ptr [RSP + 0x4],EAX
LAB_00135899:
CMP R15,-0x1
JZ 0x001358e9
MOV RCX,R15
SUB RCX,R13
LAB_001358a5:
MOV RDI,R12
MOV RSI,R14
MOV RDX,R13
CALL 0x00123940
LAB_001358b3:
MOV RBP,RBX
MOV RDI,RBX
MOV RSI,R12
CALL 0x0013ad14
INC R15
MOV RDI,R14
MOV ESI,dword ptr [RSP + 0x4]
MOV RDX,R15
CALL 0x00123b90
MOV RBX,RAX
MOV RDI,R12
CALL 0x001241f8
MOV R13,R15
MOV R15,RBX
MOV RBX,RBP
JMP 0x00135899
LAB_001358e9:
MOV RCX,R13
NOT RCX
LAB_001358ef:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
MOV RDX,R13
CALL 0x00123940
LAB_001358ff:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x0013ad50
LAB_0013590c:
LEA RDI,[RSP + 0x8]
CALL 0x001241f8
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* std::vector<std::__cxx11::string, std::allocator<std::__cxx11::string > >
string_split<std::__cxx11::string >(std::__cxx11::string const&, char) */
string * string_split<std::__cxx11::string>(string *param_1,char param_2)
{
long lVar1;
uint in_EDX;
int7 in_register_00000031;
string local_50 [32];
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
lVar1 = std::__cxx11::string::find(param_2,(ulong)in_EDX);
while (lVar1 != -1) {
/* try { // try from 001358a5 to 001358b2 has its CatchHandler @ 0013592f */
std::__cxx11::string::substr((ulong)local_50,CONCAT71(in_register_00000031,param_2));
/* try { // try from 001358b3 to 001358c0 has its CatchHandler @ 00135937 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string&>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)param_1,local_50
);
lVar1 = std::__cxx11::string::find(param_2,(ulong)(uint)(int)(char)in_EDX);
std::__cxx11::string::~string(local_50);
}
/* try { // try from 001358ef to 001358fe has its CatchHandler @ 0013592d */
std::__cxx11::string::substr((ulong)local_50,CONCAT71(in_register_00000031,param_2));
/* try { // try from 001358ff to 0013590b has its CatchHandler @ 00135928 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)param_1,local_50);
std::__cxx11::string::~string(local_50);
return param_1;
}
|
|
19,839
|
google::protobuf::EnumDescriptor::GetLocationPath(std::vector<int, std::allocator<int>>*) const
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc
|
void EnumDescriptor::GetLocationPath(std::vector<int>* output) const {
if (containing_type()) {
containing_type()->GetLocationPath(output);
output->push_back(DescriptorProto::kEnumTypeFieldNumber);
output->push_back(index());
} else {
output->push_back(FileDescriptorProto::kEnumTypeFieldNumber);
output->push_back(index());
}
}
|
O0
|
cpp
|
google::protobuf::EnumDescriptor::GetLocationPath(std::vector<int, std::allocator<int>>*) const:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x76f90
cmpq $0x0, %rax
je 0x4180a
movq 0x10(%rsp), %rdi
callq 0x76f90
movq %rax, %rdi
movq 0x28(%rsp), %rsi
callq 0x41340
movq 0x28(%rsp), %rdi
movl $0x4, 0x24(%rsp)
leaq 0x24(%rsp), %rsi
callq 0x768b0
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x76fa0
movq 0x8(%rsp), %rdi
movl %eax, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x768b0
jmp 0x41846
movq 0x28(%rsp), %rdi
movl $0x5, 0x1c(%rsp)
leaq 0x1c(%rsp), %rsi
callq 0x768b0
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
callq 0x76fa0
movq (%rsp), %rdi
movl %eax, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x768b0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
|
_ZNK6google8protobuf14EnumDescriptor15GetLocationPathEPSt6vectorIiSaIiEE:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_10], rsi
mov rdi, [rsp+38h+var_8]; this
mov [rsp+38h+var_28], rdi
call _ZNK6google8protobuf14EnumDescriptor15containing_typeEv; google::protobuf::EnumDescriptor::containing_type(void)
cmp rax, 0
jz short loc_4180A
mov rdi, [rsp+38h+var_28]; this
call _ZNK6google8protobuf14EnumDescriptor15containing_typeEv; google::protobuf::EnumDescriptor::containing_type(void)
mov rdi, rax
mov rsi, [rsp+38h+var_10]
call _ZNK6google8protobuf10Descriptor15GetLocationPathEPSt6vectorIiSaIiEE; google::protobuf::Descriptor::GetLocationPath(std::vector<int> *)
mov rdi, [rsp+38h+var_10]
mov [rsp+38h+var_14], 4
lea rsi, [rsp+38h+var_14]
call _ZNSt6vectorIiSaIiEE9push_backEOi; std::vector<int>::push_back(int &&)
mov rdi, [rsp+38h+var_28]; this
mov rax, [rsp+38h+var_10]
mov [rsp+38h+var_30], rax
call _ZNK6google8protobuf14EnumDescriptor5indexEv; google::protobuf::EnumDescriptor::index(void)
mov rdi, [rsp+38h+var_30]
mov [rsp+38h+var_18], eax
lea rsi, [rsp+38h+var_18]
call _ZNSt6vectorIiSaIiEE9push_backEOi; std::vector<int>::push_back(int &&)
jmp short loc_41846
loc_4180A:
mov rdi, [rsp+38h+var_10]
mov [rsp+38h+var_1C], 5
lea rsi, [rsp+38h+var_1C]
call _ZNSt6vectorIiSaIiEE9push_backEOi; std::vector<int>::push_back(int &&)
mov rdi, [rsp+38h+var_28]; this
mov rax, [rsp+38h+var_10]
mov [rsp+38h+var_38], rax
call _ZNK6google8protobuf14EnumDescriptor5indexEv; google::protobuf::EnumDescriptor::index(void)
mov rdi, [rsp+38h+var_38]
mov [rsp+38h+var_20], eax
lea rsi, [rsp+38h+var_20]
call _ZNSt6vectorIiSaIiEE9push_backEOi; std::vector<int>::push_back(int &&)
loc_41846:
add rsp, 38h
retn
|
long long google::protobuf::EnumDescriptor::GetLocationPath(google::protobuf::EnumDescriptor *a1, long long a2)
{
google::protobuf::Descriptor *v2; // rax
long long v4; // [rsp+0h] [rbp-38h]
long long v5; // [rsp+8h] [rbp-30h]
int v6; // [rsp+18h] [rbp-20h] BYREF
int v7; // [rsp+1Ch] [rbp-1Ch] BYREF
int v8; // [rsp+20h] [rbp-18h] BYREF
int v9; // [rsp+24h] [rbp-14h] BYREF
long long v10; // [rsp+28h] [rbp-10h]
google::protobuf::EnumDescriptor *v11; // [rsp+30h] [rbp-8h]
v11 = a1;
v10 = a2;
if ( google::protobuf::EnumDescriptor::containing_type(a1) )
{
v2 = (google::protobuf::Descriptor *)google::protobuf::EnumDescriptor::containing_type(a1);
google::protobuf::Descriptor::GetLocationPath(v2, v10);
v9 = 4;
std::vector<int>::push_back(v10, &v9);
v5 = v10;
v8 = google::protobuf::EnumDescriptor::index(a1);
return std::vector<int>::push_back(v5, &v8);
}
else
{
v7 = 5;
std::vector<int>::push_back(v10, &v7);
v4 = v10;
v6 = google::protobuf::EnumDescriptor::index(a1);
return std::vector<int>::push_back(v4, &v6);
}
}
|
GetLocationPath:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV qword ptr [RSP + 0x28],RSI
MOV RDI,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x10],RDI
CALL 0x00176f90
CMP RAX,0x0
JZ 0x0014180a
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x00176f90
MOV RDI,RAX
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x00141340
MOV RDI,qword ptr [RSP + 0x28]
MOV dword ptr [RSP + 0x24],0x4
LEA RSI,[RSP + 0x24]
CALL 0x001768b0
MOV RDI,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x8],RAX
CALL 0x00176fa0
MOV RDI,qword ptr [RSP + 0x8]
MOV dword ptr [RSP + 0x20],EAX
LEA RSI,[RSP + 0x20]
CALL 0x001768b0
JMP 0x00141846
LAB_0014180a:
MOV RDI,qword ptr [RSP + 0x28]
MOV dword ptr [RSP + 0x1c],0x5
LEA RSI,[RSP + 0x1c]
CALL 0x001768b0
MOV RDI,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP],RAX
CALL 0x00176fa0
MOV RDI,qword ptr [RSP]
MOV dword ptr [RSP + 0x18],EAX
LEA RSI,[RSP + 0x18]
CALL 0x001768b0
LAB_00141846:
ADD RSP,0x38
RET
|
/* google::protobuf::EnumDescriptor::GetLocationPath(std::vector<int, std::allocator<int> >*) const
*/
void __thiscall
google::protobuf::EnumDescriptor::GetLocationPath(EnumDescriptor *this,vector *param_1)
{
vector<int,std::allocator<int>> *pvVar1;
long lVar2;
Descriptor *this_00;
int local_20 [3];
int local_14;
vector<int,std::allocator<int>> *local_10;
EnumDescriptor *local_8;
local_10 = (vector<int,std::allocator<int>> *)param_1;
local_8 = this;
lVar2 = containing_type(this);
if (lVar2 == 0) {
local_20[1] = 5;
std::vector<int,std::allocator<int>>::push_back(local_10,local_20 + 1);
pvVar1 = local_10;
local_20[0] = index(this);
std::vector<int,std::allocator<int>>::push_back(pvVar1,local_20);
}
else {
this_00 = (Descriptor *)containing_type(this);
Descriptor::GetLocationPath(this_00,(vector *)local_10);
local_14 = 4;
std::vector<int,std::allocator<int>>::push_back(local_10,&local_14);
pvVar1 = local_10;
local_20[2] = index(this);
std::vector<int,std::allocator<int>>::push_back(pvVar1,local_20 + 2);
}
return;
}
|
|
19,840
|
nlohmann::json_abi_v3_11_3::detail::lexer<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>, nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::next_byte_in_range(std::initializer_list<int>)
|
zkingston[P]unknot/build_O1/_deps/json-src/include/nlohmann/detail/input/lexer.hpp
|
bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
{
JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
add(current);
for (auto range = ranges.begin(); range != ranges.end(); ++range)
{
get();
if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range))) // NOLINT(bugprone-inc-dec-in-conditions)
{
add(current);
}
else
{
error_message = "invalid string: ill-formed UTF-8 byte";
return false;
}
}
return true;
}
|
O1
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::lexer<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>, nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::next_byte_in_range(std::initializer_list<int>):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movsbl 0x14(%rdi), %esi
leaq 0x50(%rdi), %r15
movq %r15, %rdi
callq 0xf8a0
testq %r12, %r12
sete %bpl
je 0x31f48
leaq (%r14,%r12,4), %r12
movq %rbx, %rdi
callq 0x10818
movl 0x14(%rbx), %eax
cmpl %eax, (%r14)
jg 0x31f39
cmpl 0x4(%r14), %eax
leaq 0x4(%r14), %r14
setle %cl
testb %cl, %cl
je 0x31f3d
movsbl %al, %esi
movq %r15, %rdi
callq 0xf8a0
addq $0x4, %r14
cmpq %r12, %r14
sete %bpl
jne 0x31f00
jmp 0x31f48
xorl %ecx, %ecx
jmp 0x31f1b
leaq 0x25f090(%rip), %rax # 0x290fd4
movq %rax, 0x70(%rbx)
andb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE18next_byte_in_rangeESt16initializer_listIiE:
push rbp
push r15
push r14
push r12
push rbx
mov r12, rdx
mov r14, rsi
mov rbx, rdi
movsx esi, byte ptr [rdi+14h]
lea r15, [rdi+50h]
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
test r12, r12
setz bpl
jz short loc_31F48
lea r12, [r14+r12*4]
loc_31F00:
mov rdi, rbx; this
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<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>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get(void)
mov eax, [rbx+14h]
cmp [r14], eax
jg short loc_31F39
cmp eax, [r14+4]
lea r14, [r14+4]
setle cl
loc_31F1B:
test cl, cl
jz short loc_31F3D
movsx esi, al
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
add r14, 4
cmp r14, r12
setz bpl
jnz short loc_31F00
jmp short loc_31F48
loc_31F39:
xor ecx, ecx
jmp short loc_31F1B
loc_31F3D:
lea rax, aInvalidStringI; "invalid string: ill-formed UTF-8 byte"
mov [rbx+70h], rax
loc_31F48:
and bpl, 1
mov eax, ebp
pop rbx
pop r12
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<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>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::next_byte_in_range(
nlohmann::json_abi_v3_11_3::detail::input_stream_adapter *this,
_DWORD *a2,
long long a3,
double a4,
__m128 a5)
{
unsigned int v5; // ebp
_DWORD *v7; // r14
_DWORD *v8; // r12
int v9; // eax
bool v10; // zf
bool v11; // sf
bool v12; // of
char v13; // cl
v7 = a2;
std::string::push_back((char *)this + 80, (unsigned int)*((char *)this + 20));
LOBYTE(v5) = a3 == 0;
if ( a3 )
{
v8 = &a2[a3];
while ( 1 )
{
nlohmann::json_abi_v3_11_3::detail::lexer<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>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get(
this,
a4,
a5);
v9 = *((_DWORD *)this + 5);
if ( *v7 > v9 )
{
v13 = 0;
}
else
{
v12 = __OFSUB__(v9, v7[1]);
v10 = v9 == v7[1];
v11 = v9 - v7[1] < 0;
++v7;
v13 = v11 ^ v12 | v10;
}
if ( !v13 )
break;
std::string::push_back((char *)this + 80, (unsigned int)(char)v9);
LOBYTE(v5) = ++v7 == v8;
if ( v7 == v8 )
goto LABEL_10;
}
*((_QWORD *)this + 14) = "invalid string: ill-formed UTF-8 byte";
}
LABEL_10:
LOBYTE(v5) = v5 & 1;
return v5;
}
|
next_byte_in_range:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R12,RDX
MOV R14,RSI
MOV RBX,RDI
MOVSX ESI,byte ptr [RDI + 0x14]
LEA R15,[RDI + 0x50]
MOV RDI,R15
CALL 0x0010f8a0
TEST R12,R12
SETZ BPL
JZ 0x00131f48
LEA R12,[R14 + R12*0x4]
LAB_00131f00:
MOV RDI,RBX
CALL 0x00110818
MOV EAX,dword ptr [RBX + 0x14]
CMP dword ptr [R14],EAX
JG 0x00131f39
CMP EAX,dword ptr [R14 + 0x4]
LEA R14,[R14 + 0x4]
SETLE CL
LAB_00131f1b:
TEST CL,CL
JZ 0x00131f3d
MOVSX ESI,AL
MOV RDI,R15
CALL 0x0010f8a0
ADD R14,0x4
CMP R14,R12
SETZ BPL
JNZ 0x00131f00
JMP 0x00131f48
LAB_00131f39:
XOR ECX,ECX
JMP 0x00131f1b
LAB_00131f3d:
LEA RAX,[0x390fd4]
MOV qword ptr [RBX + 0x70],RAX
LAB_00131f48:
AND BPL,0x1
MOV EAX,EBP
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<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>,
nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::next_byte_in_range(std::initializer_list<int>)
*/
ulong nlohmann::json_abi_v3_11_3::detail::
lexer<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>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
::next_byte_in_range
(lexer<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>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
*param_1,int *param_2,long param_3)
{
int *piVar1;
int *piVar2;
bool bVar3;
int8 unaff_RBP;
char cVar4;
bool bVar5;
cVar4 = (char)param_1 + 'P';
std::__cxx11::string::push_back(cVar4);
bVar5 = param_3 == 0;
if (!bVar5) {
piVar2 = param_2 + param_3;
do {
get(param_1);
if (*(int *)(param_1 + 0x14) < *param_2) {
bVar3 = false;
}
else {
piVar1 = param_2 + 1;
param_2 = param_2 + 1;
bVar3 = *(int *)(param_1 + 0x14) <= *piVar1;
}
if (!bVar3) {
*(char **)(param_1 + 0x70) = "invalid string: ill-formed UTF-8 byte";
break;
}
std::__cxx11::string::push_back(cVar4);
param_2 = param_2 + 1;
bVar5 = param_2 == piVar2;
} while (!bVar5);
}
return CONCAT71((int7)((ulong)unaff_RBP >> 8),bVar5) & 0xffffffff;
}
|
|
19,841
|
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(char*, int&, int&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp)
|
monkey531[P]llama/common/json.hpp
|
inline void grisu2(char* buf, int& len, int& decimal_exponent,
diyfp m_minus, diyfp v, diyfp m_plus)
{
JSON_ASSERT(m_plus.e == m_minus.e);
JSON_ASSERT(m_plus.e == v.e);
// --------(-----------------------+-----------------------)-------- (A)
// m- v m+
//
// --------------------(-----------+-----------------------)-------- (B)
// m- v m+
//
// First scale v (and m- and m+) such that the exponent is in the range
// [alpha, gamma].
const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
// The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
const diyfp w = diyfp::mul(v, c_minus_k);
const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
const diyfp w_plus = diyfp::mul(m_plus, c_minus_k);
// ----(---+---)---------------(---+---)---------------(---+---)----
// w- w w+
// = c*m- = c*v = c*m+
//
// diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
// w+ are now off by a small amount.
// In fact:
//
// w - v * 10^k < 1 ulp
//
// To account for this inaccuracy, add resp. subtract 1 ulp.
//
// --------+---[---------------(---+---)---------------]---+--------
// w- M- w M+ w+
//
// Now any number in [M-, M+] (bounds included) will round to w when input,
// regardless of how the input rounding algorithm breaks ties.
//
// And digit_gen generates the shortest possible such number in [M-, M+].
// Note that this does not mean that Grisu2 always generates the shortest
// possible number in the interval (m-, m+).
const diyfp M_minus(w_minus.f + 1, w_minus.e);
const diyfp M_plus (w_plus.f - 1, w_plus.e );
decimal_exponent = -cached.k; // = -(-k) = k
grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(char*, int&, int&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, 0x58(%rsp)
movl %r8d, 0x60(%rsp)
cmpl %r8d, 0xc8(%rsp)
jne 0x7c95c
movq %rdi, 0x20(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
leaq 0xb0(%rsp), %r13
cmpl %r8d, 0x8(%r13)
jne 0x7c978
movl %r8d, %edi
callq 0x7ca33
movq %rdx, %r12
leaq 0x68(%rsp), %r14
movq %rax, (%r14)
movl %r12d, 0x8(%r14)
movq %r13, %rdi
movq %r14, %rsi
callq 0x7cb74
movq %rax, %r15
movl %edx, %ebx
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
callq 0x7cb74
movq %rax, %r13
movl %edx, %ebp
leaq 0xc0(%rsp), %rdi
movq %r14, %rsi
callq 0x7cb74
incq %r13
decq %rax
shrq $0x20, %r12
negl %r12d
movq 0x30(%rsp), %rcx
movl %r12d, (%rcx)
movq %r15, 0x48(%rsp)
movl %ebx, 0x50(%rsp)
movq %rax, 0x38(%rsp)
movl %edx, 0x40(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, 0x10(%rsp)
movups 0x48(%rsp), %xmm0
movups %xmm0, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq %rcx, %rdx
movq %r13, %rcx
movl %ebp, %r8d
callq 0x7cbd0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2de3a(%rip), %rdi # 0xaa79d
leaq 0x2c607(%rip), %rdx # 0xa8f71
leaq 0x30ac6(%rip), %rcx # 0xad437
movl $0x454b, %esi # imm = 0x454B
jmp 0x7c992
leaq 0x2de1e(%rip), %rdi # 0xaa79d
leaq 0x2c5eb(%rip), %rdx # 0xa8f71
leaq 0x30ac0(%rip), %rcx # 0xad44d
movl $0x454c, %esi # imm = 0x454C
xorl %eax, %eax
callq 0x18af0
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl6grisu2EPcRiS4_NS2_5diyfpES5_S5_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov [rsp+0A8h+var_50], rcx
mov [rsp+0A8h+var_48], r8d
cmp [rsp+0A8h+arg_18], r8d
jnz loc_7C95C
mov [rsp+0A8h+var_88], rdi
mov [rsp+0A8h+var_80], rsi
mov [rsp+0A8h+var_78], rdx
lea r13, [rsp+0A8h+arg_0]
cmp [r13+8], r8d
jnz loc_7C978
mov edi, r8d; this
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl36get_cached_power_for_binary_exponentEi; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::get_cached_power_for_binary_exponent(int)
mov r12, rdx
lea r14, [rsp+0A8h+var_40]
mov [r14], rax
mov [r14+8], r12d
mov rdi, r13
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3mulERKS3_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&)
mov r15, rax
mov ebx, edx
lea rdi, [rsp+0A8h+var_50]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3mulERKS3_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&)
mov r13, rax
mov ebp, edx
lea rdi, [rsp+0A8h+arg_10]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3mulERKS3_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&)
inc r13
dec rax
shr r12, 20h
neg r12d
mov rcx, [rsp+0A8h+var_78]
mov [rcx], r12d
mov qword ptr [rsp+0A8h+var_60], r15
mov dword ptr [rsp+0A8h+var_60+8], ebx
mov qword ptr [rsp+0A8h+var_70], rax
mov dword ptr [rsp+0A8h+var_70+8], edx
movups xmm0, xmmword ptr [rsp+0A8h+var_70]
movups xmmword ptr [rsp+0A8h+var_98], xmm0; char
movups xmm0, xmmword ptr [rsp+0A8h+var_60]
movups xmmword ptr [rsp+0A8h+var_A8], xmm0; char
mov rdi, [rsp+0A8h+var_88]; this
mov rsi, [rsp+0A8h+var_80]
mov rdx, rcx
mov rcx, r13
mov r8d, ebp
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl16grisu2_digit_genEPcRiS4_NS2_5diyfpES5_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(char *,int &,int &,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp)
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7C95C:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMPlusEMMinusE; "m_plus.e == m_minus.e"
mov esi, 454Bh
jmp short loc_7C992
loc_7C978:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMPlusEVE; "m_plus.e == v.e"
mov esi, 454Ch
loc_7C992:
xor eax, eax
call _ggml_abort
nop
|
long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *a1,
int a2,
_DWORD *a3,
long long a4,
unsigned int a5,
long long a6,
char a7,
int a8,
char a9,
int a10)
{
long long cached_power_for_binary_exponent; // rax
int v11; // rdx^4
int v12; // r12^4
int v13; // edx
char v14; // r15
int v15; // edx
int v16; // ebx
char v17; // al
int v18; // edx
long long v20; // rsi
long long v22; // [rsp+58h] [rbp-50h] BYREF
unsigned int v23; // [rsp+60h] [rbp-48h]
long long v24; // [rsp+68h] [rbp-40h] BYREF
int v25; // [rsp+70h] [rbp-38h]
v22 = a4;
v23 = a5;
if ( a10 == a5 )
{
if ( a8 == a5 )
{
cached_power_for_binary_exponent = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::get_cached_power_for_binary_exponent(
(nlohmann::json_abi_v3_11_3::detail::dtoa_impl *)a5,
a2);
v12 = v11;
v24 = cached_power_for_binary_exponent;
v25 = v13;
v14 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(&a7, &v24);
v16 = v15;
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(&v22, &v24);
v17 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(&a9, &v24);
*a3 = -v12;
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(a1, v14, v16, v17 - 1, v18);
}
v20 = 17740LL;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17740LL,
"GGML_ASSERT(%s) failed",
"m_plus.e == v.e");
}
else
{
v20 = 17739LL;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17739LL,
"GGML_ASSERT(%s) failed",
"m_plus.e == m_minus.e");
}
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
v20);
}
|
grisu2:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RSP + 0x58],RCX
MOV dword ptr [RSP + 0x60],R8D
CMP dword ptr [RSP + 0xc8],R8D
JNZ 0x0017c95c
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x30],RDX
LEA R13,[RSP + 0xb0]
CMP dword ptr [R13 + 0x8],R8D
JNZ 0x0017c978
MOV EDI,R8D
CALL 0x0017ca33
MOV R12,RDX
LEA R14,[RSP + 0x68]
MOV qword ptr [R14],RAX
MOV dword ptr [R14 + 0x8],R12D
MOV RDI,R13
MOV RSI,R14
CALL 0x0017cb74
MOV R15,RAX
MOV EBX,EDX
LEA RDI,[RSP + 0x58]
MOV RSI,R14
CALL 0x0017cb74
MOV R13,RAX
MOV EBP,EDX
LEA RDI,[RSP + 0xc0]
MOV RSI,R14
CALL 0x0017cb74
INC R13
DEC RAX
SHR R12,0x20
NEG R12D
MOV RCX,qword ptr [RSP + 0x30]
MOV dword ptr [RCX],R12D
MOV qword ptr [RSP + 0x48],R15
MOV dword ptr [RSP + 0x50],EBX
MOV qword ptr [RSP + 0x38],RAX
MOV dword ptr [RSP + 0x40],EDX
MOVUPS XMM0,xmmword ptr [RSP + 0x38]
MOVUPS xmmword ptr [RSP + 0x10],XMM0
MOVUPS XMM0,xmmword ptr [RSP + 0x48]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,RCX
MOV RCX,R13
MOV R8D,EBP
CALL 0x0017cbd0
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017c95c:
LEA RDI,[0x1aa79d]
LEA RDX,[0x1a8f71]
LEA RCX,[0x1ad437]
MOV ESI,0x454b
JMP 0x0017c992
LAB_0017c978:
LEA RDI,[0x1aa79d]
LEA RDX,[0x1a8f71]
LEA RCX,[0x1ad44d]
MOV ESI,0x454c
LAB_0017c992:
XOR EAX,EAX
CALL 0x00118af0
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(char*, int&, int&,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp) */
void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2
(int8 param_1,int8 param_2,int *param_3,int8 param_4,int param_5,
int8 param_6,int8 param_7,int param_8,int8 param_9,int param_10)
{
int4 uVar1;
char *pcVar2;
int4 extraout_EDX;
int8 uVar3;
int1 auVar4 [16];
int1 auVar5 [12];
int1 auVar6 [12];
int4 uStack_64;
int8 local_50;
int local_48;
int8 local_40;
int4 local_38;
local_50 = param_4;
local_48 = param_5;
if (param_10 == param_5) {
if (param_8 == param_5) {
auVar4 = get_cached_power_for_binary_exponent(param_5);
local_40 = auVar4._0_8_;
local_38 = auVar4._8_4_;
uVar1 = diyfp::mul((diyfp *)¶m_7,(diyfp *)&local_40);
auVar5 = diyfp::mul((diyfp *)&local_50,(diyfp *)&local_40);
auVar6 = diyfp::mul((diyfp *)¶m_9,(diyfp *)&local_40);
*param_3 = -auVar4._12_4_;
grisu2_digit_gen(param_1,param_2,param_3,auVar5._0_8_ + 1,auVar5._8_4_,param_6,uVar1,
extraout_EDX,auVar6._0_8_ + -1,CONCAT44(uStack_64,auVar6._8_4_));
return;
}
pcVar2 = "m_plus.e == v.e";
uVar3 = 0x454c;
}
else {
pcVar2 = "m_plus.e == m_minus.e";
uVar3 = 0x454b;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",uVar3,
"GGML_ASSERT(%s) failed",pcVar2);
}
|
|
19,842
|
digest_hash_get_key(unsigned char const*, unsigned long*, char)
|
eloqsql/storage/perfschema/pfs_digest.cc
|
C_MODE_START
static uchar *digest_hash_get_key(const uchar *entry, size_t *length,
my_bool)
{
const PFS_statements_digest_stat * const *typed_entry;
const PFS_statements_digest_stat *digest;
const void *result;
typed_entry= reinterpret_cast<const PFS_statements_digest_stat*const*>(entry);
assert(typed_entry != NULL);
digest= *typed_entry;
assert(digest != NULL);
*length= sizeof (PFS_digest_key);
result= & digest->m_digest_key;
return const_cast<uchar*> (reinterpret_cast<const uchar*> (result));
}
|
O0
|
cpp
|
digest_hash_get_key(unsigned char const*, unsigned long*, char):
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq $0xd4, (%rax)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ZL19digest_hash_get_keyPKhPmc:
push rbp
mov rbp, rsp
mov al, dl
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_11], al
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov qword ptr [rax], 0D4h
mov rax, [rbp+var_28]
add rax, 4
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
pop rbp
retn
|
long long digest_hash_get_key(const unsigned __int8 *a1, unsigned long long *a2)
{
long long v3; // [rsp+8h] [rbp-28h]
v3 = *(_QWORD *)a1;
*a2 = 212LL;
return v3 + 4;
}
|
digest_hash_get_key:
PUSH RBP
MOV RBP,RSP
MOV AL,DL
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV byte ptr [RBP + -0x11],AL
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],0xd4
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x4
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
POP RBP
RET
|
/* digest_hash_get_key(unsigned char const*, unsigned long*, char) */
long digest_hash_get_key(uchar *param_1,ulong *param_2,char param_3)
{
long lVar1;
lVar1 = *(long *)param_1;
*param_2 = 0xd4;
return lVar1 + 4;
}
|
|
19,843
|
uf_prespace
|
eloqsql/storage/myisam/mi_packrec.c
|
static void uf_prespace(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff, uchar *to,
uchar *end)
{
uint spaces;
if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
{
bit_buff->error=1;
return;
}
bfill((uchar*) to,spaces,' ');
if (to+spaces != end)
decode_bytes(rec,bit_buff,to+spaces,end);
}
|
O3
|
c
|
uf_prespace:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl 0x4(%rsi), %ecx
movl 0x1c(%rdi), %r13d
cmpl %r13d, %ecx
jae 0x8a5a4
subl %ecx, %r13d
leaq 0x62e82(%rip), %rax # 0xed3f0
movq %rbx, -0x30(%rbp)
movl (%rax,%rcx,4), %ebx
andl (%r14), %ebx
movl %r13d, %ecx
shll %cl, %ebx
movq %r14, %rdi
callq 0x891c5
movl $0x20, %eax
subl %r13d, %eax
movl %eax, 0x4(%r14)
movl (%r14), %eax
negl %r13d
movl %r13d, %ecx
shrl %cl, %eax
addl %ebx, %eax
movq -0x30(%rbp), %rbx
jmp 0x8a5be
movl (%r14), %eax
subl %r13d, %ecx
movl %ecx, 0x4(%r14)
shrl %cl, %eax
movl 0x1c(%r15), %ecx
leaq 0x62e35(%rip), %rdx # 0xed3f0
andl (%rdx,%rcx,4), %eax
movl %eax, %edx
leaq (%r12,%rdx), %r13
cmpq %rbx, %r13
jbe 0x8a5d3
movl $0x1, 0x28(%r14)
jmp 0x8a604
movq %r12, %rdi
movl $0x20, %esi
callq 0x2a2a0
cmpq %rbx, %r13
je 0x8a604
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x89ab6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
uf_prespace_0:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rcx
mov r12, rdx
mov r14, rsi
mov r15, rdi
mov ecx, [rsi+4]
mov r13d, [rdi+1Ch]
cmp ecx, r13d
jnb short loc_8A5A4
sub r13d, ecx
lea rax, mask_0
mov [rbp+var_30], rbx
mov ebx, [rax+rcx*4]
and ebx, [r14]
mov ecx, r13d
shl ebx, cl
mov rdi, r14
call fill_buffer_0
mov eax, 20h ; ' '
sub eax, r13d
mov [r14+4], eax
mov eax, [r14]
neg r13d
mov ecx, r13d
shr eax, cl
add eax, ebx
mov rbx, [rbp+var_30]
jmp short loc_8A5BE
loc_8A5A4:
mov eax, [r14]
sub ecx, r13d
mov [r14+4], ecx
shr eax, cl
mov ecx, [r15+1Ch]
lea rdx, mask_0
and eax, [rdx+rcx*4]
loc_8A5BE:
mov edx, eax
lea r13, [r12+rdx]
cmp r13, rbx
jbe short loc_8A5D3
mov dword ptr [r14+28h], 1
jmp short loc_8A604
loc_8A5D3:
mov rdi, r12
mov esi, 20h ; ' '
call _memset
cmp r13, rbx
jz short loc_8A604
mov rdi, r15
mov rsi, r14
mov rdx, r13
mov rcx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp decode_bytes_0
loc_8A604:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long uf_prespace_0(long long a1, unsigned int *a2, long long a3, _BYTE *a4)
{
long long v6; // rcx
unsigned int v7; // r13d
int v8; // r13d
int v9; // ebx
long long result; // rax
unsigned int v11; // eax
unsigned int v12; // ecx
_BYTE *v13; // r13
_BYTE *v14; // [rsp+0h] [rbp-30h]
v6 = a2[1];
v7 = *(_DWORD *)(a1 + 28);
if ( (unsigned int)v6 >= v7 )
{
v11 = *a2;
v12 = v6 - v7;
a2[1] = v12;
result = mask_0[*(unsigned int *)(a1 + 28)] & (v11 >> v12);
}
else
{
v8 = v7 - v6;
v14 = a4;
v9 = (*a2 & mask_0[v6]) << v8;
fill_buffer_0((long long)a2);
a2[1] = 32 - v8;
result = v9 + (*a2 >> -(char)v8);
a4 = v14;
}
v13 = (_BYTE *)(a3 + (unsigned int)result);
if ( v13 <= a4 )
{
result = memset(a3, 32LL, (unsigned int)result);
if ( v13 != a4 )
return (long long)decode_bytes_0(a1, (long long)a2, v13, a4);
}
else
{
a2[10] = 1;
}
return result;
}
|
uf_prespace:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R12,RDX
MOV R14,RSI
MOV R15,RDI
MOV ECX,dword ptr [RSI + 0x4]
MOV R13D,dword ptr [RDI + 0x1c]
CMP ECX,R13D
JNC 0x0018a5a4
SUB R13D,ECX
LEA RAX,[0x1ed3f0]
MOV qword ptr [RBP + -0x30],RBX
MOV EBX,dword ptr [RAX + RCX*0x4]
AND EBX,dword ptr [R14]
MOV ECX,R13D
SHL EBX,CL
MOV RDI,R14
CALL 0x001891c5
MOV EAX,0x20
SUB EAX,R13D
MOV dword ptr [R14 + 0x4],EAX
MOV EAX,dword ptr [R14]
NEG R13D
MOV ECX,R13D
SHR EAX,CL
ADD EAX,EBX
MOV RBX,qword ptr [RBP + -0x30]
JMP 0x0018a5be
LAB_0018a5a4:
MOV EAX,dword ptr [R14]
SUB ECX,R13D
MOV dword ptr [R14 + 0x4],ECX
SHR EAX,CL
MOV ECX,dword ptr [R15 + 0x1c]
LEA RDX,[0x1ed3f0]
AND EAX,dword ptr [RDX + RCX*0x4]
LAB_0018a5be:
MOV EDX,EAX
LEA R13,[R12 + RDX*0x1]
CMP R13,RBX
JBE 0x0018a5d3
MOV dword ptr [R14 + 0x28],0x1
JMP 0x0018a604
LAB_0018a5d3:
MOV RDI,R12
MOV ESI,0x20
CALL 0x0012a2a0
CMP R13,RBX
JZ 0x0018a604
MOV RDI,R15
MOV RSI,R14
MOV RDX,R13
MOV RCX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00189ab6
LAB_0018a604:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void uf_prespace(long param_1,uint *param_2,void *param_3,ulong param_4)
{
ulong uVar1;
uint uVar2;
uint uVar3;
uint uVar4;
uint uVar5;
byte bVar6;
uVar5 = param_2[1];
uVar2 = *(uint *)(param_1 + 0x1c);
if (uVar5 < uVar2) {
uVar3 = (&mask)[uVar5];
uVar4 = *param_2;
bVar6 = (byte)(uVar2 - uVar5);
fill_buffer(param_2);
param_2[1] = 0x20 - (uVar2 - uVar5);
uVar5 = (*param_2 >> (-bVar6 & 0x1f)) + ((uVar3 & uVar4) << (bVar6 & 0x1f));
}
else {
param_2[1] = uVar5 - uVar2;
uVar5 = *param_2 >> ((byte)(uVar5 - uVar2) & 0x1f) & (&mask)[*(uint *)(param_1 + 0x1c)];
}
uVar1 = (long)param_3 + (ulong)uVar5;
if (param_4 < uVar1) {
param_2[10] = 1;
}
else {
memset(param_3,0x20,(ulong)uVar5);
if (uVar1 != param_4) {
decode_bytes(param_1,param_2,uVar1,param_4);
return;
}
}
return;
}
|
|
19,844
|
PFS_buffer_scalable_container<PFS_rwlock, 1024, 1024, PFS_buffer_default_array<PFS_rwlock>, PFS_buffer_default_allocator<PFS_rwlock>>::init(long)
|
eloqsql/storage/perfschema/pfs_buffer_container.h
|
int init(long max_size)
{
int i;
m_initialized= true;
m_full= true;
m_max= PFS_PAGE_COUNT * PFS_PAGE_SIZE;
m_max_page_count= PFS_PAGE_COUNT;
m_last_page_size= PFS_PAGE_SIZE;
m_lost= 0;
m_monotonic.m_u32= 0;
m_max_page_index.m_u32= 0;
for (i=0 ; i < PFS_PAGE_COUNT; i++)
{
m_pages[i]= NULL;
}
if (max_size == 0)
{
/* No allocation. */
m_max_page_count= 0;
}
else if (max_size > 0)
{
if (max_size % PFS_PAGE_SIZE == 0)
{
m_max_page_count= max_size / PFS_PAGE_SIZE;
}
else
{
m_max_page_count= max_size / PFS_PAGE_SIZE + 1;
m_last_page_size= max_size % PFS_PAGE_SIZE;
}
/* Bounded allocation. */
m_full= false;
if (m_max_page_count > PFS_PAGE_COUNT)
{
m_max_page_count= PFS_PAGE_COUNT;
m_last_page_size= PFS_PAGE_SIZE;
}
}
else
{
/* max_size = -1 means unbounded allocation */
m_full= false;
}
assert(m_max_page_count <= PFS_PAGE_COUNT);
assert(0 < m_last_page_size);
assert(m_last_page_size <= PFS_PAGE_SIZE);
pthread_mutex_init(& m_critical_section, NULL);
return 0;
}
|
O0
|
c
|
PFS_buffer_scalable_container<PFS_rwlock, 1024, 1024, PFS_buffer_default_array<PFS_rwlock>, PFS_buffer_default_allocator<PFS_rwlock>>::init(long):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x1, 0x8(%rax)
movb $0x1, 0x9(%rax)
movq $0x100000, 0x10(%rax) # imm = 0x100000
movq $0x400, 0x98(%rax) # imm = 0x400
movq $0x400, 0xa0(%rax) # imm = 0x400
movq $0x0, (%rax)
movl $0x0, 0x18(%rax)
movl $0x0, 0x58(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x400, -0x14(%rbp) # imm = 0x400
jge 0x56322
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq $0x0, 0xa8(%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x562fa
cmpq $0x0, -0x10(%rbp)
jne 0x5633d
movq -0x20(%rbp), %rax
movq $0x0, 0x98(%rax)
jmp 0x563ee
cmpq $0x0, -0x10(%rbp)
jle 0x563e4
movq -0x10(%rbp), %rax
movl $0x400, %ecx # imm = 0x400
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x5637a
movq -0x10(%rbp), %rax
movl $0x400, %ecx # imm = 0x400
cqto
idivq %rcx
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x98(%rax)
jmp 0x563b3
movq -0x10(%rbp), %rax
movl $0x400, %ecx # imm = 0x400
cqto
idivq %rcx
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq $0x1, %rcx
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
movl $0x400, %ecx # imm = 0x400
cqto
idivq %rcx
movq -0x20(%rbp), %rax
movq %rdx, 0xa0(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x9(%rax)
cmpq $0x400, 0x98(%rax) # imm = 0x400
jbe 0x563e2
movq -0x20(%rbp), %rax
movq $0x400, 0x98(%rax) # imm = 0x400
movq $0x400, 0xa0(%rax) # imm = 0x400
jmp 0x563ec
movq -0x20(%rbp), %rax
movb $0x0, 0x9(%rax)
jmp 0x563ee
movq -0x20(%rbp), %rdi
addq $0x20b0, %rdi # imm = 0x20B0
xorl %eax, %eax
movl %eax, %esi
callq 0x26500
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
_ZN29PFS_buffer_scalable_containerI17PFS_prepared_stmtLi1024ELi1024E24PFS_buffer_default_arrayIS0_E28PFS_buffer_default_allocatorIS0_EE4initEl:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
mov byte ptr [rax+8], 1
mov byte ptr [rax+9], 1
mov qword ptr [rax+10h], offset unk_100000
mov qword ptr [rax+98h], 400h
mov qword ptr [rax+0A0h], 400h
mov qword ptr [rax], 0
mov dword ptr [rax+18h], 0
mov dword ptr [rax+58h], 0
mov [rbp+var_14], 0
loc_562FA:
cmp [rbp+var_14], 400h
jge short loc_56322
mov rax, [rbp+var_20]
movsxd rcx, [rbp+var_14]
mov qword ptr [rax+rcx*8+0A8h], 0
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp short loc_562FA
loc_56322:
cmp [rbp+var_10], 0
jnz short loc_5633D
mov rax, [rbp+var_20]
mov qword ptr [rax+98h], 0
jmp loc_563EE
loc_5633D:
cmp [rbp+var_10], 0
jle loc_563E4
mov rax, [rbp+var_10]
mov ecx, 400h
cqo
idiv rcx
cmp rdx, 0
jnz short loc_5637A
mov rax, [rbp+var_10]
mov ecx, 400h
cqo
idiv rcx
mov rcx, rax
mov rax, [rbp+var_20]
mov [rax+98h], rcx
jmp short loc_563B3
loc_5637A:
mov rax, [rbp+var_10]
mov ecx, 400h
cqo
idiv rcx
mov rcx, rax
mov rax, [rbp+var_20]
add rcx, 1
mov [rax+98h], rcx
mov rax, [rbp+var_10]
mov ecx, 400h
cqo
idiv rcx
mov rax, [rbp+var_20]
mov [rax+0A0h], rdx
loc_563B3:
mov rax, [rbp+var_20]
mov byte ptr [rax+9], 0
cmp qword ptr [rax+98h], 400h
jbe short loc_563E2
mov rax, [rbp+var_20]
mov qword ptr [rax+98h], 400h
mov qword ptr [rax+0A0h], 400h
loc_563E2:
jmp short loc_563EC
loc_563E4:
mov rax, [rbp+var_20]
mov byte ptr [rax+9], 0
loc_563EC:
jmp short $+2
loc_563EE:
mov rdi, [rbp+var_20]
add rdi, 20B0h
xor eax, eax
mov esi, eax
call _pthread_mutex_init
xor eax, eax
add rsp, 20h
pop rbp
retn
|
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>>::init(
long long a1,
long long a2)
{
int i; // [rsp+Ch] [rbp-14h]
*(_BYTE *)(a1 + 8) = 1;
*(_BYTE *)(a1 + 9) = 1;
*(_QWORD *)(a1 + 16) = &unk_100000;
*(_QWORD *)(a1 + 152) = 1024LL;
*(_QWORD *)(a1 + 160) = 1024LL;
*(_QWORD *)a1 = 0LL;
*(_DWORD *)(a1 + 24) = 0;
*(_DWORD *)(a1 + 88) = 0;
for ( i = 0; i < 1024; ++i )
*(_QWORD *)(a1 + 8LL * i + 168) = 0LL;
if ( a2 )
{
if ( a2 <= 0 )
{
*(_BYTE *)(a1 + 9) = 0;
}
else
{
if ( a2 % 1024 )
{
*(_QWORD *)(a1 + 152) = a2 / 1024 + 1;
*(_QWORD *)(a1 + 160) = a2 % 1024;
}
else
{
*(_QWORD *)(a1 + 152) = a2 / 1024;
}
*(_BYTE *)(a1 + 9) = 0;
if ( *(_QWORD *)(a1 + 152) > 0x400uLL )
{
*(_QWORD *)(a1 + 152) = 1024LL;
*(_QWORD *)(a1 + 160) = 1024LL;
}
}
}
else
{
*(_QWORD *)(a1 + 152) = 0LL;
}
pthread_mutex_init(a1 + 8368, 0LL);
return 0LL;
}
|
init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV byte ptr [RAX + 0x8],0x1
MOV byte ptr [RAX + 0x9],0x1
MOV qword ptr [RAX + 0x10],0x100000
MOV qword ptr [RAX + 0x98],0x400
MOV qword ptr [RAX + 0xa0],0x400
MOV qword ptr [RAX],0x0
MOV dword ptr [RAX + 0x18],0x0
MOV dword ptr [RAX + 0x58],0x0
MOV dword ptr [RBP + -0x14],0x0
LAB_001562fa:
CMP dword ptr [RBP + -0x14],0x400
JGE 0x00156322
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,dword ptr [RBP + -0x14]
MOV qword ptr [RAX + RCX*0x8 + 0xa8],0x0
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001562fa
LAB_00156322:
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x0015633d
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x98],0x0
JMP 0x001563ee
LAB_0015633d:
CMP qword ptr [RBP + -0x10],0x0
JLE 0x001563e4
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,0x400
CQO
IDIV RCX
CMP RDX,0x0
JNZ 0x0015637a
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,0x400
CQO
IDIV RCX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x98],RCX
JMP 0x001563b3
LAB_0015637a:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,0x400
CQO
IDIV RCX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RCX,0x1
MOV qword ptr [RAX + 0x98],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,0x400
CQO
IDIV RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0xa0],RDX
LAB_001563b3:
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x9],0x0
CMP qword ptr [RAX + 0x98],0x400
JBE 0x001563e2
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x98],0x400
MOV qword ptr [RAX + 0xa0],0x400
LAB_001563e2:
JMP 0x001563ec
LAB_001563e4:
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x9],0x0
LAB_001563ec:
JMP 0x001563ee
LAB_001563ee:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x20b0
XOR EAX,EAX
MOV ESI,EAX
CALL 0x00126500
XOR EAX,EAX
ADD RSP,0x20
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>
>::init(long) */
int8 __thiscall
PFS_buffer_scalable_container<PFS_prepared_stmt,1024,1024,PFS_buffer_default_array<PFS_prepared_stmt>,PFS_buffer_default_allocator<PFS_prepared_stmt>>
::init(PFS_buffer_scalable_container<PFS_prepared_stmt,1024,1024,PFS_buffer_default_array<PFS_prepared_stmt>,PFS_buffer_default_allocator<PFS_prepared_stmt>>
*this,long param_1)
{
int local_1c;
this[8] = (PFS_buffer_scalable_container<PFS_prepared_stmt,1024,1024,PFS_buffer_default_array<PFS_prepared_stmt>,PFS_buffer_default_allocator<PFS_prepared_stmt>>
)0x1;
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;
*(int8 *)(this + 0x10) = 0x100000;
*(int8 *)(this + 0x98) = 0x400;
*(int8 *)(this + 0xa0) = 0x400;
*(int8 *)this = 0;
*(int4 *)(this + 0x18) = 0;
*(int4 *)(this + 0x58) = 0;
for (local_1c = 0; local_1c < 0x400; local_1c = local_1c + 1) {
*(int8 *)(this + (long)local_1c * 8 + 0xa8) = 0;
}
if (param_1 == 0) {
*(int8 *)(this + 0x98) = 0;
}
else if (param_1 < 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>>
)0x0;
}
else {
if (param_1 % 0x400 == 0) {
*(long *)(this + 0x98) = param_1 / 0x400;
}
else {
*(long *)(this + 0x98) = param_1 / 0x400 + 1;
*(long *)(this + 0xa0) = param_1 % 0x400;
}
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>>
)0x0;
if (0x400 < *(ulong *)(this + 0x98)) {
*(int8 *)(this + 0x98) = 0x400;
*(int8 *)(this + 0xa0) = 0x400;
}
}
pthread_mutex_init((pthread_mutex_t *)(this + 0x20b0),(pthread_mutexattr_t *)0x0);
return 0;
}
|
|
19,845
|
PFS_buffer_scalable_container<PFS_rwlock, 1024, 1024, PFS_buffer_default_array<PFS_rwlock>, PFS_buffer_default_allocator<PFS_rwlock>>::init(long)
|
eloqsql/storage/perfschema/pfs_buffer_container.h
|
int init(long max_size)
{
int i;
m_initialized= true;
m_full= true;
m_max= PFS_PAGE_COUNT * PFS_PAGE_SIZE;
m_max_page_count= PFS_PAGE_COUNT;
m_last_page_size= PFS_PAGE_SIZE;
m_lost= 0;
m_monotonic.m_u32= 0;
m_max_page_index.m_u32= 0;
for (i=0 ; i < PFS_PAGE_COUNT; i++)
{
m_pages[i]= NULL;
}
if (max_size == 0)
{
/* No allocation. */
m_max_page_count= 0;
}
else if (max_size > 0)
{
if (max_size % PFS_PAGE_SIZE == 0)
{
m_max_page_count= max_size / PFS_PAGE_SIZE;
}
else
{
m_max_page_count= max_size / PFS_PAGE_SIZE + 1;
m_last_page_size= max_size % PFS_PAGE_SIZE;
}
/* Bounded allocation. */
m_full= false;
if (m_max_page_count > PFS_PAGE_COUNT)
{
m_max_page_count= PFS_PAGE_COUNT;
m_last_page_size= PFS_PAGE_SIZE;
}
}
else
{
/* max_size = -1 means unbounded allocation */
m_full= false;
}
assert(m_max_page_count <= PFS_PAGE_COUNT);
assert(0 < m_last_page_size);
assert(m_last_page_size <= PFS_PAGE_SIZE);
pthread_mutex_init(& m_critical_section, NULL);
return 0;
}
|
O3
|
c
|
PFS_buffer_scalable_container<PFS_rwlock, 1024, 1024, PFS_buffer_default_array<PFS_rwlock>, PFS_buffer_default_allocator<PFS_rwlock>>::init(long):
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movw $0x101, 0x8(%rdi) # imm = 0x101
movq $0x4000, 0x10(%rdi) # imm = 0x4000
movl $0x80, %eax
movq %rax, 0x98(%rdi)
movq %rax, 0xa0(%rdi)
movq $0x0, (%rdi)
xorl %eax, %eax
movl %eax, 0x18(%rdi)
movl %eax, 0x58(%rdi)
addq $0xa8, %rdi
movl $0x400, %edx # imm = 0x400
xorl %esi, %esi
callq 0x261c0
testq %r14, %r14
je 0x3d6d0
jle 0x3d6dd
movq %r14, %rax
shrq $0x7, %rax
andq $0x7f, %r14
je 0x3d6a8
incq %rax
movq %r14, 0xa0(%rbx)
movq %rax, 0x98(%rbx)
movb $0x0, 0x9(%rbx)
cmpq $0x81, %rax
jb 0x3d6e1
movl $0x80, %eax
movq %rax, 0x98(%rbx)
movq %rax, 0xa0(%rbx)
jmp 0x3d6e1
movq $0x0, 0x98(%rbx)
jmp 0x3d6e1
movb $0x0, 0x9(%rbx)
addq $0x4b0, %rbx # imm = 0x4B0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x26520
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
|
_ZN29PFS_buffer_scalable_containerI8PFS_userLi128ELi128E14PFS_user_array18PFS_user_allocatorE4initEl:
push rbp
mov rbp, rsp
push r14
push rbx
mov r14, rsi
mov rbx, rdi
mov word ptr [rdi+8], 101h
mov qword ptr [rdi+10h], 4000h
mov eax, 80h
mov [rdi+98h], rax
mov [rdi+0A0h], rax
mov qword ptr [rdi], 0
xor eax, eax
mov [rdi+18h], eax
mov [rdi+58h], eax
add rdi, 0A8h
mov edx, 400h
xor esi, esi
call _memset
test r14, r14
jz short loc_3D6D0
jle short loc_3D6DD
mov rax, r14
shr rax, 7
and r14, 7Fh
jz short loc_3D6A8
inc rax
mov [rbx+0A0h], r14
loc_3D6A8:
mov [rbx+98h], rax
mov byte ptr [rbx+9], 0
cmp rax, 81h
jb short loc_3D6E1
mov eax, 80h
mov [rbx+98h], rax
mov [rbx+0A0h], rax
jmp short loc_3D6E1
loc_3D6D0:
mov qword ptr [rbx+98h], 0
jmp short loc_3D6E1
loc_3D6DD:
mov byte ptr [rbx+9], 0
loc_3D6E1:
add rbx, 4B0h
mov rdi, rbx
xor esi, esi
call _pthread_mutex_init
xor eax, eax
pop rbx
pop r14
pop rbp
retn
|
long long PFS_buffer_scalable_container<PFS_user,128,128,PFS_user_array,PFS_user_allocator>::init(
long long a1,
long long a2)
{
unsigned long long v2; // rax
*(_WORD *)(a1 + 8) = 257;
*(_QWORD *)(a1 + 16) = 0x4000LL;
*(_QWORD *)(a1 + 152) = 128LL;
*(_QWORD *)(a1 + 160) = 128LL;
*(_QWORD *)a1 = 0LL;
*(_DWORD *)(a1 + 24) = 0;
*(_DWORD *)(a1 + 88) = 0;
memset(a1 + 168, 0LL, 1024LL);
if ( a2 )
{
if ( a2 <= 0 )
{
*(_BYTE *)(a1 + 9) = 0;
}
else
{
v2 = (unsigned long long)a2 >> 7;
if ( (a2 & 0x7F) != 0 )
{
++v2;
*(_QWORD *)(a1 + 160) = a2 & 0x7F;
}
*(_QWORD *)(a1 + 152) = v2;
*(_BYTE *)(a1 + 9) = 0;
if ( v2 >= 0x81 )
{
*(_QWORD *)(a1 + 152) = 128LL;
*(_QWORD *)(a1 + 160) = 128LL;
}
}
}
else
{
*(_QWORD *)(a1 + 152) = 0LL;
}
pthread_mutex_init(a1 + 1200, 0LL);
return 0LL;
}
|
init:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
MOV word ptr [RDI + 0x8],0x101
MOV qword ptr [RDI + 0x10],0x4000
MOV EAX,0x80
MOV qword ptr [RDI + 0x98],RAX
MOV qword ptr [RDI + 0xa0],RAX
MOV qword ptr [RDI],0x0
XOR EAX,EAX
MOV dword ptr [RDI + 0x18],EAX
MOV dword ptr [RDI + 0x58],EAX
ADD RDI,0xa8
MOV EDX,0x400
XOR ESI,ESI
CALL 0x001261c0
TEST R14,R14
JZ 0x0013d6d0
JLE 0x0013d6dd
MOV RAX,R14
SHR RAX,0x7
AND R14,0x7f
JZ 0x0013d6a8
INC RAX
MOV qword ptr [RBX + 0xa0],R14
LAB_0013d6a8:
MOV qword ptr [RBX + 0x98],RAX
MOV byte ptr [RBX + 0x9],0x0
CMP RAX,0x81
JC 0x0013d6e1
MOV EAX,0x80
MOV qword ptr [RBX + 0x98],RAX
MOV qword ptr [RBX + 0xa0],RAX
JMP 0x0013d6e1
LAB_0013d6d0:
MOV qword ptr [RBX + 0x98],0x0
JMP 0x0013d6e1
LAB_0013d6dd:
MOV byte ptr [RBX + 0x9],0x0
LAB_0013d6e1:
ADD RBX,0x4b0
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00126520
XOR EAX,EAX
POP RBX
POP R14
POP RBP
RET
|
/* PFS_buffer_scalable_container<PFS_user, 128, 128, PFS_user_array, PFS_user_allocator>::init(long)
*/
int8 __thiscall
PFS_buffer_scalable_container<PFS_user,128,128,PFS_user_array,PFS_user_allocator>::init
(PFS_buffer_scalable_container<PFS_user,128,128,PFS_user_array,PFS_user_allocator> *this,
long param_1)
{
ulong uVar1;
*(int2 *)(this + 8) = 0x101;
*(int8 *)(this + 0x10) = 0x4000;
*(int8 *)(this + 0x98) = 0x80;
*(int8 *)(this + 0xa0) = 0x80;
*(int8 *)this = 0;
*(int4 *)(this + 0x18) = 0;
*(int4 *)(this + 0x58) = 0;
memset(this + 0xa8,0,0x400);
if (param_1 == 0) {
*(int8 *)(this + 0x98) = 0;
}
else if (param_1 < 1) {
this[9] = (PFS_buffer_scalable_container<PFS_user,128,128,PFS_user_array,PFS_user_allocator>)0x0
;
}
else {
uVar1 = (ulong)param_1 >> 7;
if ((param_1 & 0x7fU) != 0) {
uVar1 = uVar1 + 1;
*(ulong *)(this + 0xa0) = param_1 & 0x7fU;
}
*(ulong *)(this + 0x98) = uVar1;
this[9] = (PFS_buffer_scalable_container<PFS_user,128,128,PFS_user_array,PFS_user_allocator>)0x0
;
if (0x80 < uVar1) {
*(int8 *)(this + 0x98) = 0x80;
*(int8 *)(this + 0xa0) = 0x80;
}
}
pthread_mutex_init((pthread_mutex_t *)(this + 0x4b0),(pthread_mutexattr_t *)0x0);
return 0;
}
|
|
19,846
|
coro::utils::trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const*)
|
tinyCoroLab/src/utils.cpp
|
std::string& trim(std::string& s, const char* to_trim)
{
if (s.empty())
{
return s;
}
s.erase(0, s.find_first_not_of(to_trim));
s.erase(s.find_last_not_of(to_trim) + 1);
return s;
}
|
O3
|
cpp
|
coro::utils::trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const*):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x22b5b
movq %rsi, %r14
movq %rsi, %rdi
callq 0x8100
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x22bd8
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x22b7e
movq %r14, %rdi
callq 0x8100
movq %rbx, %rdi
movq %r14, %rsi
movq $-0x1, %rdx
movq %rax, %rcx
callq 0x22ca6
incq %rax
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
jb 0x22b66
movq %rax, 0x8(%rbx)
movq (%rbx), %rcx
movb $0x0, (%rcx,%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x473b(%rip), %rdi # 0x272a8
leaq 0x4720(%rip), %rsi # 0x27294
movq %rax, %rdx
xorl %eax, %eax
callq 0x8430
|
_ZN4coro5utils4trimERNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPKc:
push r14
push rbx
push rax
mov rbx, rdi
cmp qword ptr [rdi+8], 0
jz short loc_22B5B
mov r14, rsi
mov rdi, rsi
call _strlen
mov rdi, rbx
mov rsi, r14
xor edx, edx
mov rcx, rax
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE17find_first_not_ofEPKcmm; std::string::find_first_not_of(char const*,ulong,ulong)
mov rdi, rbx
xor esi, esi
mov rdx, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5eraseEmm; std::string::erase(ulong,ulong)
mov rdi, r14
call _strlen
mov rdi, rbx
mov rsi, r14
mov rdx, 0FFFFFFFFFFFFFFFFh
mov rcx, rax
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE16find_last_not_ofEPKcmm; std::string::find_last_not_of(char const*,ulong,ulong)
inc rax
mov rcx, [rbx+8]
cmp rcx, rax
jb short loc_22B66
mov [rbx+8], rax
mov rcx, [rbx]
mov byte ptr [rcx+rax], 0
loc_22B5B:
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
loc_22B66:
lea rdi, aSPosWhichIsZuT; "%s: __pos (which is %zu) > this->size()"...
lea rsi, aBasicStringEra; "basic_string::erase"
mov rdx, rax
xor eax, eax
call __ZSt24__throw_out_of_range_fmtPKcz; std::__throw_out_of_range_fmt(char const*,...)
|
_QWORD * coro::utils::trim(_QWORD *a1, long long a2)
{
long long v2; // rax
long long first_not_of; // rax
long long v4; // rax
unsigned long long v5; // rax
unsigned long long v6; // rcx
if ( a1[1] )
{
v2 = strlen(a2);
first_not_of = std::string::find_first_not_of(a1, a2, 0LL, v2);
std::string::erase(a1, 0LL, first_not_of);
v4 = strlen(a2);
v5 = std::string::find_last_not_of(a1, a2, -1LL, v4) + 1;
v6 = a1[1];
if ( v6 < v5 )
std::__throw_out_of_range_fmt(
"%s: __pos (which is %zu) > this->size() (which is %zu)",
"basic_string::erase",
v5,
v6);
a1[1] = v5;
*(_BYTE *)(*a1 + v5) = 0;
}
return a1;
}
|
trim:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
CMP qword ptr [RDI + 0x8],0x0
JZ 0x00122b5b
MOV R14,RSI
MOV RDI,RSI
CALL 0x00108100
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
MOV RCX,RAX
CALL 0x00122bd8
MOV RDI,RBX
XOR ESI,ESI
MOV RDX,RAX
CALL 0x00122b7e
MOV RDI,R14
CALL 0x00108100
MOV RDI,RBX
MOV RSI,R14
MOV RDX,-0x1
MOV RCX,RAX
CALL 0x00122ca6
INC RAX
MOV RCX,qword ptr [RBX + 0x8]
CMP RCX,RAX
JC 0x00122b66
MOV qword ptr [RBX + 0x8],RAX
MOV RCX,qword ptr [RBX]
MOV byte ptr [RCX + RAX*0x1],0x0
LAB_00122b5b:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_00122b66:
LEA RDI,[0x1272a8]
LEA RSI,[0x127294]
MOV RDX,RAX
XOR EAX,EAX
CALL 0x00108430
|
/* coro::utils::trim(std::__cxx11::string&, char const*) */
string * coro::utils::trim(string *param_1,char *param_2)
{
string *psVar1;
size_t sVar2;
ulong uVar3;
long lVar4;
void *pvVar5;
char *__n;
ulong extraout_RDX;
string *extraout_RDX_00;
string *psVar6;
char *pcVar7;
char *pcVar8;
char *pcVar9;
if (*(long *)(param_1 + 8) != 0) {
sVar2 = strlen(param_2);
uVar3 = std::__cxx11::string::find_first_not_of(param_1,param_2,0,sVar2);
std::__cxx11::string::erase(param_1,0,uVar3);
sVar2 = strlen(param_2);
lVar4 = std::__cxx11::string::find_last_not_of(param_1,param_2,0xffffffffffffffff,sVar2);
uVar3 = lVar4 + 1;
if (*(ulong *)(param_1 + 8) < uVar3) {
pcVar8 = "%s: __pos (which is %zu) > this->size() (which is %zu)";
pcVar7 = "basic_string::erase";
std::__throw_out_of_range_fmt
("%s: __pos (which is %zu) > this->size() (which is %zu)","basic_string::erase",
uVar3);
__n = *(char **)((string *)pcVar8 + 8);
if (pcVar7 <= __n) {
if (extraout_RDX != 0) {
if (extraout_RDX == 0xffffffffffffffff) {
*(char **)((string *)pcVar8 + 8) = pcVar7;
pcVar7[*(long *)pcVar8] = '\0';
}
else {
uVar3 = extraout_RDX;
if ((ulong)((long)__n - (long)pcVar7) < extraout_RDX) {
uVar3 = (long)__n - (long)pcVar7;
}
std::__cxx11::string::_M_erase((string *)pcVar8,(ulong)pcVar7,uVar3);
}
}
return (string *)pcVar8;
}
pcVar9 = "%s: __pos (which is %zu) > this->size() (which is %zu)";
pcVar8 = "basic_string::erase";
std::__throw_out_of_range_fmt
("%s: __pos (which is %zu) > this->size() (which is %zu)","basic_string::erase",
pcVar7);
psVar1 = *(string **)((long)pcVar9 + 8);
if (extraout_RDX_00 < psVar1) {
lVar4 = *(long *)pcVar9;
psVar6 = extraout_RDX_00;
do {
if (__n == (char *)0x0) {
return extraout_RDX_00;
}
pvVar5 = memchr(pcVar8,(int)(char)psVar6[lVar4],(size_t)__n);
if (pvVar5 == (void *)0x0) {
return psVar6;
}
psVar6 = psVar6 + 1;
} while (psVar1 != psVar6);
}
return (string *)0xffffffffffffffff;
}
*(ulong *)(param_1 + 8) = uVar3;
*(int1 *)(*(long *)param_1 + uVar3) = 0;
}
return param_1;
}
|
|
19,847
|
resize_simple_key_cache
|
eloqsql/mysys/mf_keycache.c
|
static
int resize_simple_key_cache(SIMPLE_KEY_CACHE_CB *keycache,
uint key_cache_block_size,
size_t use_mem, uint division_limit,
uint age_threshold, uint changed_blocks_hash_size)
{
int blocks= 0;
DBUG_ENTER("resize_simple_key_cache");
DBUG_ASSERT(keycache->key_cache_inited);
/*
Note that the cache_lock mutex and the resize_queue are left untouched.
We do not lose the cache_lock and will release it only at the end of
this function.
*/
if (prepare_resize_simple_key_cache(keycache, 0))
goto finish;
/* The following will work even if use_mem is 0 */
blocks= init_simple_key_cache(keycache, key_cache_block_size, use_mem,
division_limit, age_threshold,
changed_blocks_hash_size);
finish:
finish_resize_simple_key_cache(keycache);
DBUG_RETURN(blocks);
}
|
O3
|
c
|
resize_simple_key_cache:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, -0x30(%rbp)
movl %r8d, -0x2c(%rbp)
movl %ecx, %r12d
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
xorl %r13d, %r13d
xorl %esi, %esi
callq 0x9af0e
testl %eax, %eax
jne 0x9a3f4
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
movl %r12d, %ecx
movl -0x2c(%rbp), %r8d
movl -0x30(%rbp), %r9d
callq 0x99ef9
movl %eax, %r13d
movq %rbx, %rdi
callq 0x9b0f2
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
resize_simple_key_cache:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov [rbp+var_30], r9d
mov [rbp+var_2C], r8d
mov r12d, ecx
mov r14, rdx
mov r15d, esi
mov rbx, rdi
xor r13d, r13d
xor esi, esi
call prepare_resize_simple_key_cache
test eax, eax
jnz short loc_9A3F4
mov rdi, rbx
mov esi, r15d
mov rdx, r14
mov ecx, r12d
mov r8d, [rbp+var_2C]
mov r9d, [rbp+var_30]
call init_simple_key_cache
mov r13d, eax
loc_9A3F4:
mov rdi, rbx
call finish_resize_simple_key_cache
mov eax, r13d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long resize_simple_key_cache(
char *a1,
unsigned int a2,
unsigned long long a3,
unsigned int a4,
unsigned int a5,
unsigned int a6)
{
unsigned int inited; // r13d
inited = 0;
if ( !(unsigned int)prepare_resize_simple_key_cache(a1, 0LL) )
inited = init_simple_key_cache(a1, a2, a3, a4, a5, a6);
finish_resize_simple_key_cache(a1);
return inited;
}
|
resize_simple_key_cache:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV dword ptr [RBP + -0x30],R9D
MOV dword ptr [RBP + -0x2c],R8D
MOV R12D,ECX
MOV R14,RDX
MOV R15D,ESI
MOV RBX,RDI
XOR R13D,R13D
XOR ESI,ESI
CALL 0x0019af0e
TEST EAX,EAX
JNZ 0x0019a3f4
MOV RDI,RBX
MOV ESI,R15D
MOV RDX,R14
MOV ECX,R12D
MOV R8D,dword ptr [RBP + -0x2c]
MOV R9D,dword ptr [RBP + -0x30]
CALL 0x00199ef9
MOV R13D,EAX
LAB_0019a3f4:
MOV RDI,RBX
CALL 0x0019b0f2
MOV EAX,R13D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int4
resize_simple_key_cache
(int8 param_1,int4 param_2,int8 param_3,int4 param_4,
int4 param_5,int4 param_6)
{
int iVar1;
int4 uVar2;
uVar2 = 0;
iVar1 = prepare_resize_simple_key_cache(param_1,0);
if (iVar1 == 0) {
uVar2 = init_simple_key_cache(param_1,param_2,param_3,param_4,param_5,param_6);
}
finish_resize_simple_key_cache(param_1);
return uVar2;
}
|
|
19,848
|
enough_free_entries_on_page
|
eloqsql/storage/maria/ma_blockrec.c
|
my_bool enough_free_entries_on_page(MARIA_SHARE *share,
uchar *page_buff)
{
enum en_page_type page_type;
page_type= (enum en_page_type) (page_buff[PAGE_TYPE_OFFSET] &
~(uchar) PAGE_CAN_BE_COMPACTED);
if (page_type == HEAD_PAGE)
{
uint row_count= (uint) page_buff[DIR_COUNT_OFFSET];
return !(row_count == MAX_ROWS_PER_PAGE &&
page_buff[DIR_FREE_OFFSET] == END_OF_DIR_FREE_LIST);
}
return enough_free_entries(page_buff, share->block_size,
1 + share->base.blobs);
}
|
O3
|
c
|
enough_free_entries_on_page:
pushq %rbp
movq %rsp, %rbp
movb 0x7(%rsi), %al
andb $0x7f, %al
cmpb $0x1, %al
jne 0x5cf48
movb $0x1, %al
cmpb $-0x1, 0x8(%rsi)
jne 0x5cf94
cmpb $-0x1, 0x9(%rsi)
setne %al
jmp 0x5cf94
movl 0x3f0(%rdi), %eax
movzbl 0x8(%rsi), %ecx
addl %eax, %ecx
incl %ecx
movb $0x1, %al
cmpl $0x100, %ecx # imm = 0x100
jb 0x5cf94
movb 0x9(%rsi), %dl
cmpb $-0x1, %dl
je 0x5cf92
movl 0x7bc(%rdi), %edi
addl $0xffffff01, %ecx # imm = 0xFFFFFF01
addq %rdi, %rsi
addq $-0x5, %rsi
decl %ecx
je 0x5cf94
movzbl %dl, %edx
shll $0x2, %edx
movq %rsi, %rdi
subq %rdx, %rdi
movb (%rdi), %dl
cmpb $-0x1, %dl
jne 0x5cf7b
xorl %eax, %eax
popq %rbp
retq
|
enough_free_entries_on_page:
push rbp
mov rbp, rsp
mov al, [rsi+7]
and al, 7Fh
cmp al, 1
jnz short loc_5CF48
mov al, 1
cmp byte ptr [rsi+8], 0FFh
jnz short loc_5CF94
cmp byte ptr [rsi+9], 0FFh
setnz al
jmp short loc_5CF94
loc_5CF48:
mov eax, [rdi+3F0h]
movzx ecx, byte ptr [rsi+8]
add ecx, eax
inc ecx
mov al, 1
cmp ecx, 100h
jb short loc_5CF94
mov dl, [rsi+9]
cmp dl, 0FFh
jz short loc_5CF92
mov edi, [rdi+7BCh]
add ecx, 0FFFFFF01h
add rsi, rdi
add rsi, 0FFFFFFFFFFFFFFFBh
loc_5CF7B:
dec ecx
jz short loc_5CF94
movzx edx, dl
shl edx, 2
mov rdi, rsi
sub rdi, rdx
mov dl, [rdi]
cmp dl, 0FFh
jnz short loc_5CF7B
loc_5CF92:
xor eax, eax
loc_5CF94:
pop rbp
retn
|
bool enough_free_entries_on_page(long long a1, _BYTE *a2)
{
bool result; // al
unsigned __int8 v3; // dl
int v4; // ecx
long long v5; // rsi
if ( (a2[7] & 0x7F) == 1 )
{
result = 1;
if ( a2[8] == 0xFF )
return a2[9] != 0xFF;
}
else
{
result = 1;
if ( *(_DWORD *)(a1 + 1008) + (unsigned int)(unsigned __int8)a2[8] + 1 >= 0x100 )
{
v3 = a2[9];
if ( v3 == 0xFF )
{
return 0;
}
else
{
v4 = *(_DWORD *)(a1 + 1008) + (unsigned __int8)a2[8] - 254;
v5 = (long long)&a2[*(unsigned int *)(a1 + 1980) - 5];
while ( --v4 )
{
v3 = *(_BYTE *)(v5 - 4 * (unsigned int)v3);
if ( v3 == 0xFF )
return 0;
}
}
}
}
return result;
}
|
enough_free_entries_on_page:
PUSH RBP
MOV RBP,RSP
MOV AL,byte ptr [RSI + 0x7]
AND AL,0x7f
CMP AL,0x1
JNZ 0x0015cf48
MOV AL,0x1
CMP byte ptr [RSI + 0x8],0xff
JNZ 0x0015cf94
CMP byte ptr [RSI + 0x9],0xff
SETNZ AL
JMP 0x0015cf94
LAB_0015cf48:
MOV EAX,dword ptr [RDI + 0x3f0]
MOVZX ECX,byte ptr [RSI + 0x8]
ADD ECX,EAX
INC ECX
MOV AL,0x1
CMP ECX,0x100
JC 0x0015cf94
MOV DL,byte ptr [RSI + 0x9]
CMP DL,0xff
JZ 0x0015cf92
MOV EDI,dword ptr [RDI + 0x7bc]
ADD ECX,0xffffff01
ADD RSI,RDI
ADD RSI,-0x5
LAB_0015cf7b:
DEC ECX
JZ 0x0015cf94
MOVZX EDX,DL
SHL EDX,0x2
MOV RDI,RSI
SUB RDI,RDX
MOV DL,byte ptr [RDI]
CMP DL,0xff
JNZ 0x0015cf7b
LAB_0015cf92:
XOR EAX,EAX
LAB_0015cf94:
POP RBP
RET
|
int8 enough_free_entries_on_page(long param_1,long param_2)
{
int8 in_RAX;
ulong uVar1;
int8 uVar2;
int iVar4;
byte bVar5;
int7 uVar3;
uVar1 = CONCAT71((int7)((ulong)in_RAX >> 8),*(int1 *)(param_2 + 7)) & 0xffffffffffffff7f;
if ((char)uVar1 == '\x01') {
uVar3 = (int7)(uVar1 >> 8);
uVar2 = CONCAT71(uVar3,1);
if (*(char *)(param_2 + 8) == -1) {
uVar2 = CONCAT71(uVar3,*(char *)(param_2 + 9) != -1);
}
}
else {
iVar4 = (uint)*(byte *)(param_2 + 8) + *(int *)(param_1 + 0x3f0);
uVar2 = CONCAT71((uint7)(uint3)((uint)*(int *)(param_1 + 0x3f0) >> 8),1);
if (0xff < iVar4 + 1U) {
bVar5 = *(byte *)(param_2 + 9);
if (bVar5 != 0xff) {
iVar4 = iVar4 + -0xfe;
do {
iVar4 = iVar4 + -1;
if (iVar4 == 0) {
return uVar2;
}
bVar5 = *(byte *)(param_2 + (ulong)*(uint *)(param_1 + 0x7bc) + -5 + (ulong)bVar5 * -4);
} while (bVar5 != 0xff);
}
uVar2 = 0;
}
}
return uVar2;
}
|
|
19,849
|
mi_mempack_get_block_info
|
eloqsql/storage/myisam/mi_packrec.c
|
static uchar *_mi_mempack_get_block_info(MI_INFO *myisam,
MI_BIT_BUFF *bit_buff,
MI_BLOCK_INFO *info,
uchar **rec_buff_p,
uchar *header)
{
header+= read_pack_length((uint) myisam->s->pack.version, header,
&info->rec_len);
if (myisam->s->base.blobs)
{
header+= read_pack_length((uint) myisam->s->pack.version, header,
&info->blob_len);
/* mi_alloc_rec_buff sets my_errno on error */
if (!(mi_alloc_rec_buff(myisam, info->blob_len ,
rec_buff_p)))
return 0; /* not enough memory */
bit_buff->blob_pos= (uchar*) *rec_buff_p;
bit_buff->blob_end= (uchar*) *rec_buff_p + info->blob_len;
}
return header;
}
|
O3
|
c
|
mi_mempack_get_block_info:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r14
movzbl (%r8), %eax
cmpq $0xfd, %rax
ja 0x3cddb
movl $0x1, %ecx
jmp 0x3ce16
cmpl $0xfe, %eax
jne 0x3cded
movzwl 0x1(%rbx), %eax
movl $0x3, %ecx
jmp 0x3ce16
movq (%rdi), %rax
cmpb $0x1, 0x244(%rax)
jne 0x3ce0e
movzwl 0x1(%rbx), %ecx
movzbl 0x3(%rbx), %eax
shll $0x10, %eax
orq %rcx, %rax
movl $0x4, %ecx
jmp 0x3ce16
movl 0x1(%rbx), %eax
movl $0x5, %ecx
movq %rax, 0x18(%r15)
addq %rcx, %rbx
movq (%rdi), %rax
cmpl $0x0, 0x188(%rax)
je 0x3cea1
movzbl (%rbx), %esi
cmpq $0xfd, %rsi
ja 0x3ce3d
movl $0x1, %r13d
jmp 0x3ce79
cmpl $0xfe, %esi
jne 0x3ce51
movzwl 0x1(%rbx), %esi
movl $0x3, %r13d
jmp 0x3ce79
cmpb $0x1, 0x244(%rax)
jne 0x3ce70
movzwl 0x1(%rbx), %eax
movzbl 0x3(%rbx), %esi
shll $0x10, %esi
orq %rax, %rsi
movl $0x4, %r13d
jmp 0x3ce79
movl 0x1(%rbx), %esi
movl $0x5, %r13d
movq %rsi, 0x30(%r15)
movq %r12, %rdx
callq 0x38ed9
testq %rax, %rax
je 0x3ce9f
addq %r13, %rbx
movq (%r12), %rax
movq %rax, 0x18(%r14)
addq 0x30(%r15), %rax
movq %rax, 0x20(%r14)
jmp 0x3cea1
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
_mi_mempack_get_block_info:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, r8
mov r12, rcx
mov r15, rdx
mov r14, rsi
movzx eax, byte ptr [r8]
cmp rax, 0FDh
ja short loc_3CDDB
mov ecx, 1
jmp short loc_3CE16
loc_3CDDB:
cmp eax, 0FEh
jnz short loc_3CDED
movzx eax, word ptr [rbx+1]
mov ecx, 3
jmp short loc_3CE16
loc_3CDED:
mov rax, [rdi]
cmp byte ptr [rax+244h], 1
jnz short loc_3CE0E
movzx ecx, word ptr [rbx+1]
movzx eax, byte ptr [rbx+3]
shl eax, 10h
or rax, rcx
mov ecx, 4
jmp short loc_3CE16
loc_3CE0E:
mov eax, [rbx+1]
mov ecx, 5
loc_3CE16:
mov [r15+18h], rax
add rbx, rcx
mov rax, [rdi]
cmp dword ptr [rax+188h], 0
jz short loc_3CEA1
movzx esi, byte ptr [rbx]
cmp rsi, 0FDh
ja short loc_3CE3D
mov r13d, 1
jmp short loc_3CE79
loc_3CE3D:
cmp esi, 0FEh
jnz short loc_3CE51
movzx esi, word ptr [rbx+1]
mov r13d, 3
jmp short loc_3CE79
loc_3CE51:
cmp byte ptr [rax+244h], 1
jnz short loc_3CE70
movzx eax, word ptr [rbx+1]
movzx esi, byte ptr [rbx+3]
shl esi, 10h
or rsi, rax
mov r13d, 4
jmp short loc_3CE79
loc_3CE70:
mov esi, [rbx+1]
mov r13d, 5
loc_3CE79:
mov [r15+30h], rsi
mov rdx, r12
call mi_alloc_rec_buff
test rax, rax
jz short loc_3CE9F
add rbx, r13
mov rax, [r12]
mov [r14+18h], rax
add rax, [r15+30h]
mov [r14+20h], rax
jmp short loc_3CEA1
loc_3CE9F:
xor ebx, ebx
loc_3CEA1:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
unsigned __int8 * mi_mempack_get_block_info(
long long *a1,
long long a2,
long long a3,
long long *a4,
unsigned __int8 *a5)
{
unsigned long long v8; // rax
long long v9; // rcx
unsigned __int8 *v10; // rbx
unsigned long long v11; // rsi
long long v12; // r13
long long v13; // rax
v8 = *a5;
if ( v8 > 0xFD )
{
if ( (_DWORD)v8 == 254 )
{
v8 = *(unsigned __int16 *)(a5 + 1);
v9 = 3LL;
}
else if ( *(_BYTE *)(*a1 + 580) == 1 )
{
v8 = *(unsigned __int16 *)(a5 + 1) | (unsigned long long)(a5[3] << 16);
v9 = 4LL;
}
else
{
v8 = *(unsigned int *)(a5 + 1);
v9 = 5LL;
}
}
else
{
v9 = 1LL;
}
*(_QWORD *)(a3 + 24) = v8;
v10 = &a5[v9];
if ( *(_DWORD *)(*a1 + 392) )
{
v11 = *v10;
if ( v11 > 0xFD )
{
if ( (_DWORD)v11 == 254 )
{
v11 = *(unsigned __int16 *)(v10 + 1);
v12 = 3LL;
}
else if ( *(_BYTE *)(*a1 + 580) == 1 )
{
v11 = *(unsigned __int16 *)(v10 + 1) | (unsigned long long)(v10[3] << 16);
v12 = 4LL;
}
else
{
v11 = *(unsigned int *)(v10 + 1);
v12 = 5LL;
}
}
else
{
v12 = 1LL;
}
*(_QWORD *)(a3 + 48) = v11;
if ( mi_alloc_rec_buff(a1, v11, a4) )
{
v10 += v12;
v13 = *a4;
*(_QWORD *)(a2 + 24) = *a4;
*(_QWORD *)(a2 + 32) = *(_QWORD *)(a3 + 48) + v13;
}
else
{
return 0LL;
}
}
return v10;
}
|
_mi_mempack_get_block_info:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,R8
MOV R12,RCX
MOV R15,RDX
MOV R14,RSI
MOVZX EAX,byte ptr [R8]
CMP RAX,0xfd
JA 0x0013cddb
MOV ECX,0x1
JMP 0x0013ce16
LAB_0013cddb:
CMP EAX,0xfe
JNZ 0x0013cded
MOVZX EAX,word ptr [RBX + 0x1]
MOV ECX,0x3
JMP 0x0013ce16
LAB_0013cded:
MOV RAX,qword ptr [RDI]
CMP byte ptr [RAX + 0x244],0x1
JNZ 0x0013ce0e
MOVZX ECX,word ptr [RBX + 0x1]
MOVZX EAX,byte ptr [RBX + 0x3]
SHL EAX,0x10
OR RAX,RCX
MOV ECX,0x4
JMP 0x0013ce16
LAB_0013ce0e:
MOV EAX,dword ptr [RBX + 0x1]
MOV ECX,0x5
LAB_0013ce16:
MOV qword ptr [R15 + 0x18],RAX
ADD RBX,RCX
MOV RAX,qword ptr [RDI]
CMP dword ptr [RAX + 0x188],0x0
JZ 0x0013cea1
MOVZX ESI,byte ptr [RBX]
CMP RSI,0xfd
JA 0x0013ce3d
MOV R13D,0x1
JMP 0x0013ce79
LAB_0013ce3d:
CMP ESI,0xfe
JNZ 0x0013ce51
MOVZX ESI,word ptr [RBX + 0x1]
MOV R13D,0x3
JMP 0x0013ce79
LAB_0013ce51:
CMP byte ptr [RAX + 0x244],0x1
JNZ 0x0013ce70
MOVZX EAX,word ptr [RBX + 0x1]
MOVZX ESI,byte ptr [RBX + 0x3]
SHL ESI,0x10
OR RSI,RAX
MOV R13D,0x4
JMP 0x0013ce79
LAB_0013ce70:
MOV ESI,dword ptr [RBX + 0x1]
MOV R13D,0x5
LAB_0013ce79:
MOV qword ptr [R15 + 0x30],RSI
MOV RDX,R12
CALL 0x00138ed9
TEST RAX,RAX
JZ 0x0013ce9f
ADD RBX,R13
MOV RAX,qword ptr [R12]
MOV qword ptr [R14 + 0x18],RAX
ADD RAX,qword ptr [R15 + 0x30]
MOV qword ptr [R14 + 0x20],RAX
JMP 0x0013cea1
LAB_0013ce9f:
XOR EBX,EBX
LAB_0013cea1:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
byte * _mi_mempack_get_block_info
(long *param_1,long param_2,long param_3,long *param_4,byte *param_5)
{
long lVar1;
long lVar2;
ulong uVar3;
uVar3 = (ulong)*param_5;
if (uVar3 < 0xfe) {
lVar2 = 1;
}
else if (*param_5 == 0xfe) {
uVar3 = (ulong)*(ushort *)(param_5 + 1);
lVar2 = 3;
}
else if (*(char *)(*param_1 + 0x244) == '\x01') {
uVar3 = (ulong)*(uint3 *)(param_5 + 1);
lVar2 = 4;
}
else {
uVar3 = (ulong)*(uint *)(param_5 + 1);
lVar2 = 5;
}
*(ulong *)(param_3 + 0x18) = uVar3;
param_5 = param_5 + lVar2;
if (*(int *)(*param_1 + 0x188) != 0) {
uVar3 = (ulong)*param_5;
if (uVar3 < 0xfe) {
lVar2 = 1;
}
else if (*param_5 == 0xfe) {
uVar3 = (ulong)*(ushort *)(param_5 + 1);
lVar2 = 3;
}
else if (*(char *)(*param_1 + 0x244) == '\x01') {
uVar3 = (ulong)*(uint3 *)(param_5 + 1);
lVar2 = 4;
}
else {
uVar3 = (ulong)*(uint *)(param_5 + 1);
lVar2 = 5;
}
*(ulong *)(param_3 + 0x30) = uVar3;
lVar1 = mi_alloc_rec_buff(param_1,uVar3,param_4);
if (lVar1 == 0) {
param_5 = (byte *)0x0;
}
else {
param_5 = param_5 + lVar2;
lVar2 = *param_4;
*(long *)(param_2 + 0x18) = lVar2;
*(long *)(param_2 + 0x20) = lVar2 + *(long *)(param_3 + 0x30);
}
}
return param_5;
}
|
|
19,850
|
mi_ck_write_btree
|
eloqsql/storage/myisam/mi_write.c
|
int _mi_ck_write_btree(register MI_INFO *info, uint keynr, uchar *key,
uint key_length)
{
int error;
uint comp_flag;
MI_KEYDEF *keyinfo=info->s->keyinfo+keynr;
my_off_t *root=&info->s->state.key_root[keynr];
DBUG_ENTER("_mi_ck_write_btree");
if (keyinfo->flag & HA_SORT_ALLOWS_SAME)
comp_flag=SEARCH_BIGGER; /* Put after same key */
else if (keyinfo->flag & (HA_NOSAME|HA_FULLTEXT))
{
comp_flag=SEARCH_FIND | SEARCH_UPDATE | SEARCH_INSERT; /* No duplicates */
if (keyinfo->flag & HA_NULL_ARE_EQUAL)
comp_flag|= SEARCH_NULL_ARE_EQUAL;
}
else
comp_flag=SEARCH_SAME; /* Keys in rec-pos order */
error=_mi_ck_real_write_btree(info, keyinfo, key, key_length,
root, comp_flag);
if (info->ft1_to_ft2)
{
if (!error)
error= _mi_ft_convert_to_ft2(info, keynr, key);
delete_dynamic(info->ft1_to_ft2);
my_free(info->ft1_to_ft2);
info->ft1_to_ft2=0;
}
DBUG_RETURN(error);
}
|
O3
|
c
|
mi_ck_write_btree:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movq (%rdi), %rdx
movq 0x218(%rdx), %rax
movl %esi, %r8d
imulq $0x70, %r8, %rdi
leaq (%rax,%rdi), %rsi
shlq $0x3, %r8
movzwl 0xa(%rax,%rdi), %eax
movl $0x8, %r9d
addq 0x98(%rdx), %r8
btl $0x9, %eax
jb 0x895b0
testb $-0x7f, %al
je 0x895aa
andl $0x800, %eax # imm = 0x800
shll $0x4, %eax
orl $0x20041, %eax # imm = 0x20041
movl %eax, %r9d
jmp 0x895b0
movl $0x4, %r9d
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8960f
movl %eax, %r12d
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x89603
testl %r12d, %r12d
jne 0x895e7
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x75abb
movl %eax, %r12d
movq 0x88(%rbx), %rdi
callq 0x930b0
movq 0x88(%rbx), %rdi
callq 0xa1412
movq $0x0, 0x88(%rbx)
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
_mi_ck_write_btree:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r14, rdx
mov r15d, esi
mov rbx, rdi
mov rdx, [rdi]
mov rax, [rdx+218h]
mov r8d, esi
imul rdi, r8, 70h ; 'p'
lea rsi, [rax+rdi]
shl r8, 3
movzx eax, word ptr [rax+rdi+0Ah]
mov r9d, 8
add r8, [rdx+98h]
bt eax, 9
jb short loc_895B0
test al, 81h
jz short loc_895AA
and eax, 800h
shl eax, 4
or eax, 20041h
mov r9d, eax
jmp short loc_895B0
loc_895AA:
mov r9d, 4
loc_895B0:
mov rdi, rbx
mov rdx, r14
call _mi_ck_real_write_btree
mov r12d, eax
mov rdi, [rbx+88h]
test rdi, rdi
jz short loc_89603
test r12d, r12d
jnz short loc_895E7
mov rdi, rbx
mov esi, r15d
mov rdx, r14
call _mi_ft_convert_to_ft2
mov r12d, eax
mov rdi, [rbx+88h]
loc_895E7:
call delete_dynamic
mov rdi, [rbx+88h]
call my_free
mov qword ptr [rbx+88h], 0
loc_89603:
mov eax, r12d
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long mi_ck_write_btree(long long *a1, unsigned int a2, unsigned __int8 *a3, long long a4)
{
long long v7; // r8
long long v8; // rsi
__int16 v9; // ax
long long v10; // r9
long long v11; // r8
unsigned int v12; // r12d
long long v13; // rdi
v7 = a2;
v8 = *(_QWORD *)(*a1 + 536) + 112LL * a2;
v9 = *(_WORD *)(v8 + 10);
v10 = 8LL;
v11 = *(_QWORD *)(*a1 + 152) + 8 * v7;
if ( (v9 & 0x200) == 0 )
{
if ( (v9 & 0x81) != 0 )
v10 = (16 * (v9 & 0x800)) | 0x20041u;
else
v10 = 4LL;
}
v12 = mi_ck_real_write_btree(a1, v8, a3, a4, v11, v10);
v13 = a1[17];
if ( v13 )
{
if ( !v12 )
{
v12 = mi_ft_convert_to_ft2(a1, a2, a3);
v13 = a1[17];
}
delete_dynamic(v13);
my_free(a1[17]);
a1[17] = 0LL;
}
return v12;
}
|
_mi_ck_write_btree:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14,RDX
MOV R15D,ESI
MOV RBX,RDI
MOV RDX,qword ptr [RDI]
MOV RAX,qword ptr [RDX + 0x218]
MOV R8D,ESI
IMUL RDI,R8,0x70
LEA RSI,[RAX + RDI*0x1]
SHL R8,0x3
MOVZX EAX,word ptr [RAX + RDI*0x1 + 0xa]
MOV R9D,0x8
ADD R8,qword ptr [RDX + 0x98]
BT EAX,0x9
JC 0x001895b0
TEST AL,0x81
JZ 0x001895aa
AND EAX,0x800
SHL EAX,0x4
OR EAX,0x20041
MOV R9D,EAX
JMP 0x001895b0
LAB_001895aa:
MOV R9D,0x4
LAB_001895b0:
MOV RDI,RBX
MOV RDX,R14
CALL 0x0018960f
MOV R12D,EAX
MOV RDI,qword ptr [RBX + 0x88]
TEST RDI,RDI
JZ 0x00189603
TEST R12D,R12D
JNZ 0x001895e7
MOV RDI,RBX
MOV ESI,R15D
MOV RDX,R14
CALL 0x00175abb
MOV R12D,EAX
MOV RDI,qword ptr [RBX + 0x88]
LAB_001895e7:
CALL 0x001930b0
MOV RDI,qword ptr [RBX + 0x88]
CALL 0x001a1412
MOV qword ptr [RBX + 0x88],0x0
LAB_00189603:
MOV EAX,R12D
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int _mi_ck_write_btree(long *param_1,uint param_2,int8 param_3,int8 param_4)
{
ushort uVar1;
uint uVar2;
int iVar3;
long lVar4;
long lVar5;
lVar5 = *(long *)(*param_1 + 0x218);
lVar4 = (ulong)param_2 * 0x70;
uVar1 = *(ushort *)(lVar5 + 10 + lVar4);
uVar2 = 8;
if ((uVar1 >> 9 & 1) == 0) {
if ((uVar1 & 0x81) == 0) {
uVar2 = 4;
}
else {
uVar2 = (uVar1 & 0x800) << 4 | 0x20041;
}
}
iVar3 = _mi_ck_real_write_btree
(param_1,lVar5 + lVar4,param_3,param_4,
(ulong)param_2 * 8 + *(long *)(*param_1 + 0x98),uVar2);
lVar5 = param_1[0x11];
if (lVar5 != 0) {
if (iVar3 == 0) {
iVar3 = _mi_ft_convert_to_ft2(param_1,param_2,param_3);
lVar5 = param_1[0x11];
}
delete_dynamic(lVar5);
my_free(param_1[0x11]);
param_1[0x11] = 0;
}
return iVar3;
}
|
|
19,851
|
pem_des_decrypt
|
msxemulator/build_O3/_deps/pico_sdk-src/lib/mbedtls/library/pem.c
|
static int pem_des_decrypt(unsigned char des_iv[8],
unsigned char *buf, size_t buflen,
const unsigned char *pwd, size_t pwdlen)
{
mbedtls_des_context des_ctx;
unsigned char des_key[8];
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
mbedtls_des_init(&des_ctx);
if ((ret = pem_pbkdf1(des_key, 8, des_iv, pwd, pwdlen)) != 0) {
goto exit;
}
if ((ret = mbedtls_des_setkey_dec(&des_ctx, des_key)) != 0) {
goto exit;
}
ret = mbedtls_des_crypt_cbc(&des_ctx, MBEDTLS_DES_DECRYPT, buflen,
des_iv, buf, buf);
exit:
mbedtls_des_free(&des_ctx);
mbedtls_platform_zeroize(des_key, 8);
return ret;
}
|
O3
|
c
|
pem_des_decrypt:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
callq 0x9b458
movq %rsp, %rdi
movl $0x8, %esi
movq %r15, %rdx
movq %r13, %rcx
movq %r12, %r8
callq 0x9899f
testl %eax, %eax
jne 0x986d6
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x9b998
testl %eax, %eax
jne 0x986d6
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %r15, %rcx
movq %rbx, %r8
movq %rbx, %r9
callq 0x9be0f
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x9b47b
movq %rsp, %rdi
movl $0x8, %esi
callq 0x8db8c
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
pem_des_decrypt:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov r12, r8
mov r13, rcx
mov r14, rdx
mov rbx, rsi
mov r15, rdi
lea rdi, [rsp+0B8h+var_B0]
call mbedtls_des_init
mov rdi, rsp
mov esi, 8
mov rdx, r15
mov rcx, r13
mov r8, r12
call pem_pbkdf1
test eax, eax
jnz short loc_986D6
lea rdi, [rsp+0B8h+var_B0]
mov rsi, rsp
call mbedtls_des_setkey_dec
test eax, eax
jnz short loc_986D6
lea rdi, [rsp+0B8h+var_B0]
xor esi, esi
mov rdx, r14
mov rcx, r15
mov r8, rbx
mov r9, rbx
call mbedtls_des_crypt_cbc
loc_986D6:
mov ebp, eax
lea rdi, [rsp+0B8h+var_B0]
call mbedtls_des_free
mov rdi, rsp
mov esi, 8
call mbedtls_platform_zeroize
mov eax, ebp
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long pem_des_decrypt(long long a1, long long a2, long long a3, long long a4, long long a5)
{
unsigned int v8; // eax
unsigned int v9; // ebp
long long v11; // [rsp+0h] [rbp-B8h] BYREF
_BYTE v12[176]; // [rsp+8h] [rbp-B0h] BYREF
mbedtls_des_init(v12);
v8 = pem_pbkdf1(&v11, 8LL, a1, a4, a5);
if ( !v8 )
{
v8 = mbedtls_des_setkey_dec(v12, &v11);
if ( !v8 )
v8 = mbedtls_des_crypt_cbc(v12, 0LL, a3, a1, a2, a2);
}
v9 = v8;
mbedtls_des_free(v12);
mbedtls_platform_zeroize((long long)&v11, 8LL);
return v9;
}
|
pem_des_decrypt:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV R12,R8
MOV R13,RCX
MOV R14,RDX
MOV RBX,RSI
MOV R15,RDI
LEA RDI,[RSP + 0x8]
CALL 0x0019b458
MOV RDI,RSP
MOV ESI,0x8
MOV RDX,R15
MOV RCX,R13
MOV R8,R12
CALL 0x0019899f
TEST EAX,EAX
JNZ 0x001986d6
LEA RDI,[RSP + 0x8]
MOV RSI,RSP
CALL 0x0019b998
TEST EAX,EAX
JNZ 0x001986d6
LEA RDI,[RSP + 0x8]
XOR ESI,ESI
MOV RDX,R14
MOV RCX,R15
MOV R8,RBX
MOV R9,RBX
CALL 0x0019be0f
LAB_001986d6:
MOV EBP,EAX
LEA RDI,[RSP + 0x8]
CALL 0x0019b47b
MOV RDI,RSP
MOV ESI,0x8
CALL 0x0018db8c
MOV EAX,EBP
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int pem_des_decrypt(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5)
{
int iVar1;
int1 auStack_b8 [8];
int1 local_b0 [128];
mbedtls_des_init(local_b0);
iVar1 = pem_pbkdf1(auStack_b8,8,param_1,param_4,param_5);
if (iVar1 == 0) {
iVar1 = mbedtls_des_setkey_dec(local_b0,auStack_b8);
if (iVar1 == 0) {
iVar1 = mbedtls_des_crypt_cbc(local_b0,0,param_3,param_1,param_2,param_2);
}
}
mbedtls_des_free(local_b0);
mbedtls_platform_zeroize(auStack_b8,8);
return iVar1;
}
|
|
19,852
|
mysql_server_end
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
void STDCALL mysql_server_end(void)
{
if (!mysql_client_init)
return;
release_configuration_dirs();
mysql_client_plugin_deinit();
list_free(pvio_callback, 0);
if (ma_init_done)
ma_end(0);
#ifdef HAVE_TLS
ma_pvio_tls_end();
#endif
mysql_client_init= 0;
ma_init_done= 0;
#ifdef WIN32
init_once = (INIT_ONCE)INIT_ONCE_STATIC_INIT;
#else
init_once = (pthread_once_t)PTHREAD_ONCE_INIT;
#endif
}
|
O0
|
c
|
mysql_server_end:
pushq %rbp
movq %rsp, %rbp
cmpb $0x0, 0x3e3f9(%rip) # 0x60434
jne 0x2203f
jmp 0x22093
movb $0x0, %al
callq 0x47010
movb $0x0, %al
callq 0x35c60
leaq 0x3e3e4(%rip), %rax # 0x60438
movq (%rax), %rdi
xorl %esi, %esi
callq 0x22f80
leaq 0x3e3dc(%rip), %rax # 0x60441
cmpb $0x0, (%rax)
je 0x22071
xorl %edi, %edi
callq 0x25550
movb $0x0, %al
callq 0x24540
movb $0x0, 0x3e3b5(%rip) # 0x60434
leaq 0x3e3bb(%rip), %rax # 0x60441
movb $0x0, (%rax)
movl $0x0, 0x3e39d(%rip) # 0x60430
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
mysql_server_end:
push rbp
mov rbp, rsp
cmp cs:mysql_client_init, 0
jnz short loc_2203F
jmp short loc_22093
loc_2203F:
mov al, 0
call release_configuration_dirs
mov al, 0
call mysql_client_plugin_deinit
lea rax, pvio_callback
mov rdi, [rax]
xor esi, esi
call list_free
lea rax, ma_init_done
cmp byte ptr [rax], 0
jz short loc_22071
xor edi, edi
call ma_end
loc_22071:
mov al, 0
call ma_pvio_tls_end
mov cs:mysql_client_init, 0
lea rax, ma_init_done
mov byte ptr [rax], 0
mov cs:init_once, 0
loc_22093:
pop rbp
retn
|
void *mysql_server_end()
{
void *result; // rax
if ( mysql_client_init )
{
release_configuration_dirs();
mysql_client_plugin_deinit();
list_free(pvio_callback, 0LL);
if ( ma_init_done )
ma_end(0LL);
ma_pvio_tls_end();
mysql_client_init = 0;
result = &ma_init_done;
ma_init_done = 0;
init_once = 0;
}
return result;
}
|
mysql_server_end:
PUSH RBP
MOV RBP,RSP
CMP byte ptr [0x00160434],0x0
JNZ 0x0012203f
JMP 0x00122093
LAB_0012203f:
MOV AL,0x0
CALL 0x00147010
MOV AL,0x0
CALL 0x00135c60
LEA RAX,[0x160438]
MOV RDI,qword ptr [RAX]
XOR ESI,ESI
CALL 0x00122f80
LEA RAX,[0x160441]
CMP byte ptr [RAX],0x0
JZ 0x00122071
XOR EDI,EDI
CALL 0x00125550
LAB_00122071:
MOV AL,0x0
CALL 0x00124540
MOV byte ptr [0x00160434],0x0
LEA RAX,[0x160441]
MOV byte ptr [RAX],0x0
MOV dword ptr [0x00160430],0x0
LAB_00122093:
POP RBP
RET
|
void mysql_server_end(void)
{
if (mysql_client_init != '\0') {
release_configuration_dirs();
mysql_client_plugin_deinit();
list_free(pvio_callback,0);
if (ma_init_done != '\0') {
ma_end(0);
}
ma_pvio_tls_end();
mysql_client_init = '\0';
ma_init_done = '\0';
init_once = 0;
}
return;
}
|
|
19,853
|
u4toa
|
bluesky950520[P]quickjs/tests/test_conv.c
|
static char *u4toa(char p[minimum_length(4)], uint32_t n)
{
const char *digits = digits100;
if (n >= 100) {
uint32_t n1 = n / 100;
n -= n1 * 100;
*p = digits[2 * n1];
p += digits[2 * n1] != '0';
*p++ = digits[2 * n1 + 1];
*p++ = digits[2 * n];
*p++ = digits[2 * n + 1];
return p;
} else {
*p = digits[2 * n];
p += digits[2 * n] != '0';
*p++ = digits[2 * n + 1];
return p;
}
}
|
O0
|
c
|
u4toa:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
leaq 0xa200(%rip), %rax # 0xd050
movq %rax, -0x20(%rsp)
cmpl $0x64, -0x14(%rsp)
jb 0x2f3e
movl -0x14(%rsp), %eax
movl $0x64, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x24(%rsp)
imull $0x64, -0x24(%rsp), %ecx
movl -0x14(%rsp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rsp)
movq -0x20(%rsp), %rax
movl -0x24(%rsp), %ecx
shll %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %cl
movq -0x10(%rsp), %rax
movb %cl, (%rax)
movq -0x20(%rsp), %rax
movl -0x24(%rsp), %ecx
shll %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
cmpl $0x30, %eax
setne %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x10(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rsp)
movq -0x20(%rsp), %rax
movl -0x24(%rsp), %ecx
shll %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %cl
movq -0x10(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rsp)
movb %cl, (%rax)
movq -0x20(%rsp), %rax
movl -0x14(%rsp), %ecx
shll %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %cl
movq -0x10(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rsp)
movb %cl, (%rax)
movq -0x20(%rsp), %rax
movl -0x14(%rsp), %ecx
shll %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %cl
movq -0x10(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rsp)
movb %cl, (%rax)
movq -0x10(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x2fb1
movq -0x20(%rsp), %rax
movl -0x14(%rsp), %ecx
shll %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %cl
movq -0x10(%rsp), %rax
movb %cl, (%rax)
movq -0x20(%rsp), %rax
movl -0x14(%rsp), %ecx
shll %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
cmpl $0x30, %eax
setne %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x10(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rsp)
movq -0x20(%rsp), %rax
movl -0x14(%rsp), %ecx
shll %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %cl
movq -0x10(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rsp)
movb %cl, (%rax)
movq -0x10(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw (%rax,%rax)
|
u4toa:
mov [rsp+var_10], rdi
mov [rsp+var_14], esi
lea rax, digits100
mov [rsp+var_20], rax
cmp [rsp+var_14], 64h ; 'd'
jb loc_2F3E
mov eax, [rsp+var_14]
mov ecx, 64h ; 'd'
xor edx, edx
div ecx
mov [rsp+var_24], eax
imul ecx, [rsp+var_24], 64h ; 'd'
mov eax, [rsp+var_14]
sub eax, ecx
mov [rsp+var_14], eax
mov rax, [rsp+var_20]
mov ecx, [rsp+var_24]
shl ecx, 1
mov ecx, ecx
mov cl, [rax+rcx]
mov rax, [rsp+var_10]
mov [rax], cl
mov rax, [rsp+var_20]
mov ecx, [rsp+var_24]
shl ecx, 1
mov ecx, ecx
movzx eax, byte ptr [rax+rcx]
cmp eax, 30h ; '0'
setnz al
and al, 1
movzx ecx, al
mov rax, [rsp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rsp+var_10], rax
mov rax, [rsp+var_20]
mov ecx, [rsp+var_24]
shl ecx, 1
add ecx, 1
mov ecx, ecx
mov cl, [rax+rcx]
mov rax, [rsp+var_10]
mov rdx, rax
add rdx, 1
mov [rsp+var_10], rdx
mov [rax], cl
mov rax, [rsp+var_20]
mov ecx, [rsp+var_14]
shl ecx, 1
mov ecx, ecx
mov cl, [rax+rcx]
mov rax, [rsp+var_10]
mov rdx, rax
add rdx, 1
mov [rsp+var_10], rdx
mov [rax], cl
mov rax, [rsp+var_20]
mov ecx, [rsp+var_14]
shl ecx, 1
add ecx, 1
mov ecx, ecx
mov cl, [rax+rcx]
mov rax, [rsp+var_10]
mov rdx, rax
add rdx, 1
mov [rsp+var_10], rdx
mov [rax], cl
mov rax, [rsp+var_10]
mov [rsp+var_8], rax
jmp short loc_2FB1
loc_2F3E:
mov rax, [rsp+var_20]
mov ecx, [rsp+var_14]
shl ecx, 1
mov ecx, ecx
mov cl, [rax+rcx]
mov rax, [rsp+var_10]
mov [rax], cl
mov rax, [rsp+var_20]
mov ecx, [rsp+var_14]
shl ecx, 1
mov ecx, ecx
movzx eax, byte ptr [rax+rcx]
cmp eax, 30h ; '0'
setnz al
and al, 1
movzx ecx, al
mov rax, [rsp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rsp+var_10], rax
mov rax, [rsp+var_20]
mov ecx, [rsp+var_14]
shl ecx, 1
add ecx, 1
mov ecx, ecx
mov cl, [rax+rcx]
mov rax, [rsp+var_10]
mov rdx, rax
add rdx, 1
mov [rsp+var_10], rdx
mov [rax], cl
mov rax, [rsp+var_10]
mov [rsp+var_8], rax
loc_2FB1:
mov rax, [rsp+var_8]
retn
|
_BYTE * u4toa(_BYTE *a1, unsigned int a2)
{
_BYTE *v2; // rax
unsigned int v4; // [rsp+10h] [rbp-14h]
_BYTE *v5; // [rsp+14h] [rbp-10h]
v4 = a2;
if ( a2 < 0x64 )
{
*a1 = digits100[2 * a2];
v5 = &a1[digits100[2 * a2] != 48];
}
else
{
v4 = a2 % 0x64;
*a1 = digits100[2 * (a2 / 0x64)];
v2 = &a1[digits100[2 * (a2 / 0x64)] != 48];
*v2++ = digits100[2 * (a2 / 0x64) + 1];
v5 = v2 + 1;
*v2 = digits100[2 * (a2 % 0x64)];
}
*v5 = digits100[2 * v4 + 1];
return v5 + 1;
}
|
u4toa:
MOV qword ptr [RSP + -0x10],RDI
MOV dword ptr [RSP + -0x14],ESI
LEA RAX,[0x10d050]
MOV qword ptr [RSP + -0x20],RAX
CMP dword ptr [RSP + -0x14],0x64
JC 0x00102f3e
MOV EAX,dword ptr [RSP + -0x14]
MOV ECX,0x64
XOR EDX,EDX
DIV ECX
MOV dword ptr [RSP + -0x24],EAX
IMUL ECX,dword ptr [RSP + -0x24],0x64
MOV EAX,dword ptr [RSP + -0x14]
SUB EAX,ECX
MOV dword ptr [RSP + -0x14],EAX
MOV RAX,qword ptr [RSP + -0x20]
MOV ECX,dword ptr [RSP + -0x24]
SHL ECX,0x1
MOV ECX,ECX
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RSP + -0x10]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RSP + -0x20]
MOV ECX,dword ptr [RSP + -0x24]
SHL ECX,0x1
MOV ECX,ECX
MOVZX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x30
SETNZ AL
AND AL,0x1
MOVZX ECX,AL
MOV RAX,qword ptr [RSP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RSP + -0x10],RAX
MOV RAX,qword ptr [RSP + -0x20]
MOV ECX,dword ptr [RSP + -0x24]
SHL ECX,0x1
ADD ECX,0x1
MOV ECX,ECX
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RSP + -0x10]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RSP + -0x10],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RSP + -0x20]
MOV ECX,dword ptr [RSP + -0x14]
SHL ECX,0x1
MOV ECX,ECX
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RSP + -0x10]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RSP + -0x10],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RSP + -0x20]
MOV ECX,dword ptr [RSP + -0x14]
SHL ECX,0x1
ADD ECX,0x1
MOV ECX,ECX
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RSP + -0x10]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RSP + -0x10],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RSP + -0x10]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x00102fb1
LAB_00102f3e:
MOV RAX,qword ptr [RSP + -0x20]
MOV ECX,dword ptr [RSP + -0x14]
SHL ECX,0x1
MOV ECX,ECX
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RSP + -0x10]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RSP + -0x20]
MOV ECX,dword ptr [RSP + -0x14]
SHL ECX,0x1
MOV ECX,ECX
MOVZX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x30
SETNZ AL
AND AL,0x1
MOVZX ECX,AL
MOV RAX,qword ptr [RSP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RSP + -0x10],RAX
MOV RAX,qword ptr [RSP + -0x20]
MOV ECX,dword ptr [RSP + -0x14]
SHL ECX,0x1
ADD ECX,0x1
MOV ECX,ECX
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RSP + -0x10]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RSP + -0x10],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RSP + -0x10]
MOV qword ptr [RSP + -0x8],RAX
LAB_00102fb1:
MOV RAX,qword ptr [RSP + -0x8]
RET
|
int1 * u4toa(int1 *param_1,uint param_2)
{
uint uVar1;
int1 *local_8;
if (param_2 < 100) {
*param_1 = digits100[param_2 << 1];
local_8 = param_1 + (int)(uint)(digits100[param_2 << 1] != '0') + 1;
param_1[(int)(uint)(digits100[param_2 << 1] != '0')] = digits100[param_2 * 2 + 1];
}
else {
uVar1 = param_2 / 100;
*param_1 = digits100[uVar1 << 1];
param_1 = param_1 + (int)(uint)(digits100[uVar1 << 1] != '0');
*param_1 = digits100[uVar1 * 2 + 1];
param_1[1] = digits100[param_2 % 100 << 1];
local_8 = param_1 + 3;
param_1[2] = digits100[(param_2 % 100) * 2 + 1];
}
return local_8;
}
|
|
19,854
|
u4toa
|
bluesky950520[P]quickjs/tests/test_conv.c
|
static char *u4toa(char p[minimum_length(4)], uint32_t n)
{
const char *digits = digits100;
if (n >= 100) {
uint32_t n1 = n / 100;
n -= n1 * 100;
*p = digits[2 * n1];
p += digits[2 * n1] != '0';
*p++ = digits[2 * n1 + 1];
*p++ = digits[2 * n];
*p++ = digits[2 * n + 1];
return p;
} else {
*p = digits[2 * n];
p += digits[2 * n] != '0';
*p++ = digits[2 * n + 1];
return p;
}
}
|
O2
|
c
|
u4toa:
cmpl $0x64, %esi
jb 0x2656
pushq $0x64
popq %rcx
movl %esi, %eax
xorl %edx, %edx
divl %ecx
imull $-0x64, %eax, %ecx
addl %esi, %ecx
leaq 0x3a55(%rip), %rdx # 0x6080
movb (%rdx,%rax,2), %sil
movb 0x1(%rdx,%rax,2), %r8b
movb %sil, (%rdi)
xorl %eax, %eax
cmpb $0x30, %sil
setne %al
addq %rdi, %rax
addq $0x3, %rax
movb %r8b, -0x3(%rax)
addl %ecx, %ecx
movzwl (%rcx,%rdx), %ecx
movw %cx, -0x2(%rax)
retq
movl %esi, %eax
leaq 0x3a21(%rip), %rcx # 0x6080
movb (%rcx,%rax,2), %dl
addq %rax, %rax
movb %dl, (%rdi)
xorl %esi, %esi
cmpb $0x30, %dl
setne %sil
movl %eax, %eax
movb 0x1(%rax,%rcx), %cl
leaq (%rdi,%rsi), %rax
incq %rax
movb %cl, -0x1(%rax)
retq
|
u4toa:
cmp esi, 64h ; 'd'
jb short loc_2656
push 64h ; 'd'
pop rcx
mov eax, esi
xor edx, edx
div ecx
imul ecx, eax, -64h
add ecx, esi
lea rdx, digits100; "000102030405060708091011121314151617181"...
mov sil, [rdx+rax*2]
mov r8b, [rdx+rax*2+1]
mov [rdi], sil
xor eax, eax
cmp sil, 30h ; '0'
setnz al
add rax, rdi
add rax, 3
mov [rax-3], r8b
add ecx, ecx
movzx ecx, word ptr [rcx+rdx]
mov [rax-2], cx
retn
loc_2656:
mov eax, esi
lea rcx, digits100; "000102030405060708091011121314151617181"...
mov dl, [rcx+rax*2]
add rax, rax
mov [rdi], dl
xor esi, esi
cmp dl, 30h ; '0'
setnz sil
mov eax, eax
mov cl, [rax+rcx+1]
lea rax, [rdi+rsi]
inc rax
mov [rax-1], cl
retn
|
long long u4toa(char *a1, unsigned int a2)
{
long long v2; // rax
unsigned int v3; // ecx
char v4; // si
char v5; // r8
long long result; // rax
char v7; // dl
int v8; // eax
_BOOL8 v9; // rsi
char v10; // cl
if ( a2 < 0x64 )
{
v7 = digits100[2 * a2];
v8 = 2 * a2;
*a1 = v7;
v9 = v7 != 48;
v10 = digits100[v8 + 1];
result = (long long)&a1[v9 + 1];
a1[v9] = v10;
}
else
{
v2 = a2 / 0x64;
v3 = a2 % 0x64;
v4 = digits100[2 * v2];
v5 = digits100[2 * v2 + 1];
*a1 = v4;
result = (long long)&a1[(v4 != 48) + 3];
*(_BYTE *)(result - 3) = v5;
*(_WORD *)(result - 2) = *(_WORD *)&digits100[2 * v3];
}
return result;
}
|
u4toa:
CMP ESI,0x64
JC 0x00102656
PUSH 0x64
POP RCX
MOV EAX,ESI
XOR EDX,EDX
DIV ECX
IMUL ECX,EAX,-0x64
ADD ECX,ESI
LEA RDX,[0x106080]
MOV SIL,byte ptr [RDX + RAX*0x2]
MOV R8B,byte ptr [RDX + RAX*0x2 + 0x1]
MOV byte ptr [RDI],SIL
XOR EAX,EAX
CMP SIL,0x30
SETNZ AL
ADD RAX,RDI
ADD RAX,0x3
MOV byte ptr [RAX + -0x3],R8B
ADD ECX,ECX
MOVZX ECX,word ptr [RCX + RDX*0x1]
MOV word ptr [RAX + -0x2],CX
RET
LAB_00102656:
MOV EAX,ESI
LEA RCX,[0x106080]
MOV DL,byte ptr [RCX + RAX*0x2]
ADD RAX,RAX
MOV byte ptr [RDI],DL
XOR ESI,ESI
CMP DL,0x30
SETNZ SIL
MOV EAX,EAX
MOV CL,byte ptr [RAX + RCX*0x1 + 0x1]
LEA RAX,[RDI + RSI*0x1]
INC RAX
MOV byte ptr [RAX + -0x1],CL
RET
|
void u4toa(char *param_1,uint param_2)
{
char cVar1;
char cVar2;
ulong uVar3;
if (99 < param_2) {
uVar3 = (ulong)param_2 / 100;
cVar1 = digits100[uVar3 * 2];
cVar2 = digits100[uVar3 * 2 + 1];
*param_1 = cVar1;
param_1[cVar1 != '0'] = cVar2;
*(int2 *)(param_1 + (cVar1 != '0') + 1) =
*(int2 *)(digits100 + ((int)uVar3 * -100 + param_2) * 2);
return;
}
cVar1 = digits100[(ulong)param_2 * 2];
*param_1 = cVar1;
param_1[cVar1 != '0'] = digits100[(ulong)(param_2 * 2) + 1];
return;
}
|
|
19,855
|
my_uni_utf8mb3_no_range
|
eloqsql/strings/ctype-utf8.c
|
static int my_uni_utf8mb3_no_range(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *r)
{
int count;
if (wc < 0x80)
count= 1;
else if (wc < 0x800)
count= 2;
else if (wc < 0x10000)
count= 3;
else
return MY_CS_ILUNI;
switch (count)
{
case 3: r[2]= (uchar) (0x80 | (wc & 0x3f)); wc= wc >> 6; wc |= 0x800;
/* fall through */
case 2: r[1]= (uchar) (0x80 | (wc & 0x3f)); wc= wc >> 6; wc |= 0xc0;
/* fall through */
case 1: r[0]= (uchar) wc;
}
return count;
}
|
O0
|
c
|
my_uni_utf8mb3_no_range:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x80, -0x18(%rbp)
jae 0x6f343
movl $0x1, -0x24(%rbp)
jmp 0x6f379
cmpq $0x800, -0x18(%rbp) # imm = 0x800
jae 0x6f356
movl $0x2, -0x24(%rbp)
jmp 0x6f377
cmpq $0x10000, -0x18(%rbp) # imm = 0x10000
jae 0x6f369
movl $0x3, -0x24(%rbp)
jmp 0x6f375
movl $0x0, -0x4(%rbp)
jmp 0x6f40e
jmp 0x6f377
jmp 0x6f379
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
subl $0x1, %eax
je 0x6f3fc
jmp 0x6f386
movl -0x28(%rbp), %eax
subl $0x2, %eax
je 0x6f3cb
jmp 0x6f390
movl -0x28(%rbp), %eax
subl $0x3, %eax
jne 0x6f408
jmp 0x6f39a
movq -0x18(%rbp), %rax
andq $0x3f, %rax
orq $0x80, %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x18(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
orq $0x800, %rax # imm = 0x800
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x3f, %rax
orq $0x80, %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x18(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
orq $0xc0, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_uni_utf8mb3_no_range:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
cmp [rbp+var_18], 80h
jnb short loc_6F343
mov [rbp+var_24], 1
jmp short loc_6F379
loc_6F343:
cmp [rbp+var_18], 800h
jnb short loc_6F356
mov [rbp+var_24], 2
jmp short loc_6F377
loc_6F356:
cmp [rbp+var_18], offset stru_10000
jnb short loc_6F369
mov [rbp+var_24], 3
jmp short loc_6F375
loc_6F369:
mov [rbp+var_4], 0
jmp loc_6F40E
loc_6F375:
jmp short $+2
loc_6F377:
jmp short $+2
loc_6F379:
mov eax, [rbp+var_24]
mov [rbp+var_28], eax
sub eax, 1
jz short loc_6F3FC
jmp short $+2
loc_6F386:
mov eax, [rbp+var_28]
sub eax, 2
jz short loc_6F3CB
jmp short $+2
loc_6F390:
mov eax, [rbp+var_28]
sub eax, 3
jnz short loc_6F408
jmp short $+2
loc_6F39A:
mov rax, [rbp+var_18]
and rax, 3Fh
or rax, 80h
mov cl, al
mov rax, [rbp+var_20]
mov [rax+2], cl
mov rax, [rbp+var_18]
shr rax, 6
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
or rax, 800h
mov [rbp+var_18], rax
loc_6F3CB:
mov rax, [rbp+var_18]
and rax, 3Fh
or rax, 80h
mov cl, al
mov rax, [rbp+var_20]
mov [rax+1], cl
mov rax, [rbp+var_18]
shr rax, 6
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
or rax, 0C0h
mov [rbp+var_18], rax
loc_6F3FC:
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
loc_6F408:
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
loc_6F40E:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long my_uni_utf8mb3_no_range(long long a1, unsigned long long a2, _BYTE *a3)
{
unsigned int v4; // [rsp+4h] [rbp-24h]
unsigned long long v5; // [rsp+10h] [rbp-18h]
v5 = a2;
if ( a2 >= 0x80 )
{
if ( a2 >= 0x800 )
{
if ( a2 >= (unsigned long long)&stru_10000 )
return 0;
v4 = 3;
}
else
{
v4 = 2;
}
}
else
{
v4 = 1;
}
if ( v4 != 1 )
{
if ( v4 != 2 )
{
a3[2] = a2 & 0x3F | 0x80;
v5 = (a2 >> 6) | 0x800;
}
a3[1] = v5 & 0x3F | 0x80;
v5 = (v5 >> 6) | 0xC0;
}
*a3 = v5;
return v4;
}
|
my_uni_utf8mb3_no_range:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
CMP qword ptr [RBP + -0x18],0x80
JNC 0x0016f343
MOV dword ptr [RBP + -0x24],0x1
JMP 0x0016f379
LAB_0016f343:
CMP qword ptr [RBP + -0x18],0x800
JNC 0x0016f356
MOV dword ptr [RBP + -0x24],0x2
JMP 0x0016f377
LAB_0016f356:
CMP qword ptr [RBP + -0x18],0x10000
JNC 0x0016f369
MOV dword ptr [RBP + -0x24],0x3
JMP 0x0016f375
LAB_0016f369:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0016f40e
LAB_0016f375:
JMP 0x0016f377
LAB_0016f377:
JMP 0x0016f379
LAB_0016f379:
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x28],EAX
SUB EAX,0x1
JZ 0x0016f3fc
JMP 0x0016f386
LAB_0016f386:
MOV EAX,dword ptr [RBP + -0x28]
SUB EAX,0x2
JZ 0x0016f3cb
JMP 0x0016f390
LAB_0016f390:
MOV EAX,dword ptr [RBP + -0x28]
SUB EAX,0x3
JNZ 0x0016f408
JMP 0x0016f39a
LAB_0016f39a:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x3f
OR RAX,0x80
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x6
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
OR RAX,0x800
MOV qword ptr [RBP + -0x18],RAX
LAB_0016f3cb:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x3f
OR RAX,0x80
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x6
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
OR RAX,0xc0
MOV qword ptr [RBP + -0x18],RAX
LAB_0016f3fc:
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
LAB_0016f408:
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
LAB_0016f40e:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int my_uni_utf8mb3_no_range(int8 param_1,ulong param_2,int1 *param_3)
{
int local_2c;
ulong local_20;
if (param_2 < 0x80) {
local_2c = 1;
}
else if (param_2 < 0x800) {
local_2c = 2;
}
else {
if (0xffff < param_2) {
return 0;
}
local_2c = 3;
}
local_20 = param_2;
if (local_2c != 1) {
if (local_2c != 2) {
if (local_2c != 3) {
return local_2c;
}
param_3[2] = (byte)param_2 & 0x3f | 0x80;
local_20 = param_2 >> 6 | 0x800;
}
param_3[1] = (byte)local_20 & 0x3f | 0x80;
local_20 = local_20 >> 6 | 0xc0;
}
*param_3 = (char)local_20;
return local_2c;
}
|
|
19,856
|
transid_get_packed
|
eloqsql/storage/maria/ma_key.c
|
ulonglong transid_get_packed(MARIA_SHARE *share, const uchar *from)
{
ulonglong value;
uint length;
if (from[0] < MARIA_MIN_TRANSID_PACK_OFFSET)
value= (ulonglong) from[0];
else
{
value= 0;
for (length= (uint) (from[0] - MARIA_TRANSID_PACK_OFFSET),
value= (ulonglong) from[1], from+=2;
--length ;
from++)
value= (value << 8) + ((ulonglong) *from);
}
return (value >> 1) + share->state.create_trid;
}
|
O3
|
c
|
transid_get_packed:
pushq %rbp
movq %rsp, %rbp
movzbl (%rsi), %ecx
cmpq $0xf2, %rcx
ja 0x36b76
movq %rcx, %rax
jmp 0x36b9f
movzbl 0x1(%rsi), %eax
cmpl $0xfa, %ecx
je 0x36b9f
addq $-0xfa, %rcx
xorl %edx, %edx
shlq $0x8, %rax
movzbl 0x2(%rsi,%rdx), %r8d
orq %r8, %rax
incq %rdx
cmpl %edx, %ecx
jne 0x36b8b
shrq %rax
addq 0xe0(%rdi), %rax
popq %rbp
retq
|
transid_get_packed:
push rbp
mov rbp, rsp
movzx ecx, byte ptr [rsi]
cmp rcx, 0F2h
ja short loc_36B76
mov rax, rcx
jmp short loc_36B9F
loc_36B76:
movzx eax, byte ptr [rsi+1]
cmp ecx, 0FAh
jz short loc_36B9F
add rcx, 0FFFFFFFFFFFFFF06h
xor edx, edx
loc_36B8B:
shl rax, 8
movzx r8d, byte ptr [rsi+rdx+2]
or rax, r8
inc rdx
cmp ecx, edx
jnz short loc_36B8B
loc_36B9F:
shr rax, 1
add rax, [rdi+0E0h]
pop rbp
retn
|
unsigned long long transid_get_packed(long long a1, unsigned __int8 *a2)
{
unsigned long long v2; // rcx
unsigned long long v3; // rax
int v4; // ecx
long long v5; // rdx
v2 = *a2;
if ( v2 > 0xF2 )
{
v3 = a2[1];
if ( (_DWORD)v2 != 250 )
{
v4 = v2 - 250;
v5 = 0LL;
do
v3 = a2[v5++ + 2] | (v3 << 8);
while ( v4 != (_DWORD)v5 );
}
}
else
{
v3 = *a2;
}
return *(_QWORD *)(a1 + 224) + (v3 >> 1);
}
|
transid_get_packed:
PUSH RBP
MOV RBP,RSP
MOVZX ECX,byte ptr [RSI]
CMP RCX,0xf2
JA 0x00136b76
MOV RAX,RCX
JMP 0x00136b9f
LAB_00136b76:
MOVZX EAX,byte ptr [RSI + 0x1]
CMP ECX,0xfa
JZ 0x00136b9f
ADD RCX,-0xfa
XOR EDX,EDX
LAB_00136b8b:
SHL RAX,0x8
MOVZX R8D,byte ptr [RSI + RDX*0x1 + 0x2]
OR RAX,R8
INC RDX
CMP ECX,EDX
JNZ 0x00136b8b
LAB_00136b9f:
SHR RAX,0x1
ADD RAX,qword ptr [RDI + 0xe0]
POP RBP
RET
|
long transid_get_packed(long param_1,byte *param_2)
{
byte bVar1;
ulong uVar2;
long lVar3;
bVar1 = *param_2;
uVar2 = (ulong)bVar1;
if ((0xf2 < uVar2) && (uVar2 = (ulong)param_2[1], bVar1 != 0xfa)) {
lVar3 = 0;
do {
uVar2 = uVar2 << 8 | (ulong)param_2[lVar3 + 2];
lVar3 = lVar3 + 1;
} while (bVar1 - 0xfa != (int)lVar3);
}
return (uVar2 >> 1) + *(long *)(param_1 + 0xe0);
}
|
|
19,857
|
lunasvg::Transform::rotated(float, float, float)
|
dmazzella[P]pylunasvg/lunasvg/source/graphics.cpp
|
Transform Transform::rotated(float angle, float cx, float cy)
{
plutovg_matrix_t matrix;
if(cx == 0.f && cy == 0.f) {
plutovg_matrix_init_rotate(&matrix, PLUTOVG_DEG2RAD(angle));
} else {
plutovg_matrix_init_translate(&matrix, cx, cy);
plutovg_matrix_rotate(&matrix, PLUTOVG_DEG2RAD(angle));
plutovg_matrix_translate(&matrix, -cx, -cy);
}
return matrix;
}
|
O0
|
cpp
|
lunasvg::Transform::rotated(float, float, float):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movss -0x8(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x11af5
jp 0x11af5
movss -0xc(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x11af5
jp 0x11af5
movss 0x7a647(%rip), %xmm0 # 0x8c12c
mulss -0x4(%rbp), %xmm0
leaq -0x24(%rbp), %rdi
callq 0x5c7a0
jmp 0x11b4b
movss -0x8(%rbp), %xmm0
movss -0xc(%rbp), %xmm1
leaq -0x24(%rbp), %rdi
callq 0x5c720
movss 0x7a61c(%rip), %xmm0 # 0x8c12c
mulss -0x4(%rbp), %xmm0
leaq -0x24(%rbp), %rdi
callq 0x5ca70
movss -0x8(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm0
movss -0xc(%rbp), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm1
leaq -0x24(%rbp), %rdi
callq 0x5c870
movq -0x38(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x144d0
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ZN7lunasvg9Transform7rotatedEfff:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_30], rdi
movss [rbp+var_4], xmm0
movss [rbp+var_8], xmm1
movss [rbp+var_C], xmm2
movss xmm0, [rbp+var_8]
xorps xmm1, xmm1
ucomiss xmm0, xmm1
jnz short loc_11AF5
jp short loc_11AF5
movss xmm0, [rbp+var_C]
xorps xmm1, xmm1
ucomiss xmm0, xmm1
jnz short loc_11AF5
jp short loc_11AF5
movss xmm0, cs:dword_8C12C
mulss xmm0, [rbp+var_4]
lea rdi, [rbp+var_24]
call plutovg_matrix_init_rotate
jmp short loc_11B4B
loc_11AF5:
movss xmm0, [rbp+var_8]
movss xmm1, [rbp+var_C]
lea rdi, [rbp+var_24]
call plutovg_matrix_init_translate
movss xmm0, cs:dword_8C12C
mulss xmm0, [rbp+var_4]
lea rdi, [rbp+var_24]
call plutovg_matrix_rotate
movss xmm0, [rbp+var_8]
movd eax, xmm0
xor eax, 80000000h
movd xmm0, eax
movss xmm1, [rbp+var_C]
movd eax, xmm1
xor eax, 80000000h
movd xmm1, eax
lea rdi, [rbp+var_24]
call plutovg_matrix_translate
loc_11B4B:
mov rdi, [rbp+var_38]
lea rsi, [rbp+var_24]
call _ZN7lunasvg9TransformC2ERK14plutovg_matrix; lunasvg::Transform::Transform(plutovg_matrix const&)
mov rax, [rbp+var_30]
add rsp, 40h
pop rbp
retn
|
lunasvg::Transform * lunasvg::Transform::rotated(lunasvg::Transform *this, float a2, float a3, float a4)
{
_BYTE v5[24]; // [rsp+1Ch] [rbp-24h] BYREF
float v6; // [rsp+34h] [rbp-Ch]
float v7; // [rsp+38h] [rbp-8h]
float v8; // [rsp+3Ch] [rbp-4h]
v8 = a2;
v7 = a3;
v6 = a4;
if ( a3 == 0.0 && v6 == 0.0 )
{
plutovg_matrix_init_rotate(v5, 0.017453292 * v8);
}
else
{
plutovg_matrix_init_translate(v5, v7, v6);
plutovg_matrix_rotate(v5, 0.017453292 * v8);
plutovg_matrix_translate(
v5,
*(double *)_mm_cvtsi32_si128(_mm_cvtsi128_si32((__m128i)LODWORD(v7)) ^ 0x80000000).m128i_i64,
*(double *)_mm_cvtsi32_si128(_mm_cvtsi128_si32((__m128i)LODWORD(v6)) ^ 0x80000000).m128i_i64);
}
lunasvg::Transform::Transform(this, v5);
return this;
}
|
rotated:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x30],RDI
MOVSS dword ptr [RBP + -0x4],XMM0
MOVSS dword ptr [RBP + -0x8],XMM1
MOVSS dword ptr [RBP + -0xc],XMM2
MOVSS XMM0,dword ptr [RBP + -0x8]
XORPS XMM1,XMM1
UCOMISS XMM0,XMM1
JNZ 0x00111af5
JP 0x00111af5
MOVSS XMM0,dword ptr [RBP + -0xc]
XORPS XMM1,XMM1
UCOMISS XMM0,XMM1
JNZ 0x00111af5
JP 0x00111af5
MOVSS XMM0,dword ptr [0x0018c12c]
MULSS XMM0,dword ptr [RBP + -0x4]
LEA RDI,[RBP + -0x24]
CALL 0x0015c7a0
JMP 0x00111b4b
LAB_00111af5:
MOVSS XMM0,dword ptr [RBP + -0x8]
MOVSS XMM1,dword ptr [RBP + -0xc]
LEA RDI,[RBP + -0x24]
CALL 0x0015c720
MOVSS XMM0,dword ptr [0x0018c12c]
MULSS XMM0,dword ptr [RBP + -0x4]
LEA RDI,[RBP + -0x24]
CALL 0x0015ca70
MOVSS XMM0,dword ptr [RBP + -0x8]
MOVD EAX,XMM0
XOR EAX,0x80000000
MOVD XMM0,EAX
MOVSS XMM1,dword ptr [RBP + -0xc]
MOVD EAX,XMM1
XOR EAX,0x80000000
MOVD XMM1,EAX
LEA RDI,[RBP + -0x24]
CALL 0x0015c870
LAB_00111b4b:
MOV RDI,qword ptr [RBP + -0x38]
LEA RSI,[RBP + -0x24]
CALL 0x001144d0
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x40
POP RBP
RET
|
/* lunasvg::Transform::rotated(float, float, float) */
Transform * __thiscall
lunasvg::Transform::rotated(Transform *this,float param_1,float param_2,float param_3)
{
plutovg_matrix local_2c [24];
float local_14;
float local_10;
float local_c;
local_14 = param_3;
local_10 = param_2;
local_c = param_1;
if ((((param_2 != 0.0) || (NAN(param_2))) || (param_3 != 0.0)) || (NAN(param_3))) {
plutovg_matrix_init_translate(local_2c);
plutovg_matrix_rotate(DAT_0018c12c * local_c,local_2c);
plutovg_matrix_translate(-local_10,-local_14,local_2c);
}
else {
plutovg_matrix_init_rotate(DAT_0018c12c * param_1,local_2c);
}
Transform(this,local_2c);
return this;
}
|
|
19,858
|
lunasvg::Transform::rotated(float, float, float)
|
dmazzella[P]pylunasvg/lunasvg/source/graphics.cpp
|
Transform Transform::rotated(float angle, float cx, float cy)
{
plutovg_matrix_t matrix;
if(cx == 0.f && cy == 0.f) {
plutovg_matrix_init_rotate(&matrix, PLUTOVG_DEG2RAD(angle));
} else {
plutovg_matrix_init_translate(&matrix, cx, cy);
plutovg_matrix_rotate(&matrix, PLUTOVG_DEG2RAD(angle));
plutovg_matrix_translate(&matrix, -cx, -cy);
}
return matrix;
}
|
O1
|
cpp
|
lunasvg::Transform::rotated(float, float, float):
pushq %r14
pushq %rbx
subq $0x48, %rsp
movaps %xmm0, %xmm3
movq %rdi, %rbx
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
jne 0xcab9
jp 0xcab9
ucomiss %xmm0, %xmm2
jne 0xcab9
jp 0xcab9
mulss 0x36696(%rip), %xmm3 # 0x43140
leaq 0x8(%rsp), %rdi
movaps %xmm3, %xmm0
callq 0x27c82
jmp 0xcb11
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movaps %xmm1, %xmm0
movaps %xmm1, 0x20(%rsp)
movaps %xmm2, %xmm1
movaps %xmm2, 0x30(%rsp)
movss %xmm3, 0x4(%rsp)
callq 0x27c59
movss 0x4(%rsp), %xmm0
mulss 0x36656(%rip), %xmm0 # 0x43140
movq %r14, %rdi
callq 0x27e33
movaps 0x36607(%rip), %xmm2 # 0x43100
movaps 0x20(%rsp), %xmm0
xorps %xmm2, %xmm0
movaps 0x30(%rsp), %xmm1
xorps %xmm2, %xmm1
movq %r14, %rdi
callq 0x27d29
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
nop
|
_ZN7lunasvg9Transform7rotatedEfff:
push r14
push rbx
sub rsp, 48h
movaps xmm3, xmm0
mov rbx, rdi
xorps xmm0, xmm0
ucomiss xmm1, xmm0
jnz short loc_CAB9
jp short loc_CAB9
ucomiss xmm2, xmm0
jnz short loc_CAB9
jp short loc_CAB9
mulss xmm3, cs:dword_43140
lea rdi, [rsp+58h+var_50]
movaps xmm0, xmm3
call plutovg_matrix_init_rotate
jmp short loc_CB11
loc_CAB9:
lea r14, [rsp+58h+var_50]
mov rdi, r14
movaps xmm0, xmm1
movaps [rsp+58h+var_38], xmm1
movaps xmm1, xmm2
movaps [rsp+58h+var_28], xmm2
movss [rsp+58h+var_54], xmm3
call plutovg_matrix_init_translate
movss xmm0, [rsp+58h+var_54]
mulss xmm0, cs:dword_43140
mov rdi, r14
call plutovg_matrix_rotate
movaps xmm2, cs:xmmword_43100
movaps xmm0, [rsp+58h+var_38]
xorps xmm0, xmm2
movaps xmm1, [rsp+58h+var_28]
xorps xmm1, xmm2
mov rdi, r14
call plutovg_matrix_translate
loc_CB11:
mov rax, [rsp+58h+var_40]
mov [rbx+10h], rax
movups xmm0, [rsp+58h+var_50]
movups xmmword ptr [rbx], xmm0
mov rax, rbx
add rsp, 48h
pop rbx
pop r14
retn
|
lunasvg::Transform * lunasvg::Transform::rotated(lunasvg::Transform *this, double a2, __m128 a3, __m128 a4)
{
double v4; // xmm3_8
__int128 v6; // [rsp+8h] [rbp-50h] BYREF
long long v7; // [rsp+18h] [rbp-40h]
__m128 v8; // [rsp+20h] [rbp-38h]
__m128 v9; // [rsp+30h] [rbp-28h]
HIDWORD(v4) = HIDWORD(a2);
if ( a3.m128_f32[0] == 0.0 && a4.m128_f32[0] == 0.0 )
{
*(float *)&v4 = *(float *)&a2 * 0.017453292;
plutovg_matrix_init_rotate(&v6, v4);
}
else
{
v8 = a3;
v9 = a4;
plutovg_matrix_init_translate(&v6, a3.m128_f32[0], a4.m128_f32[0]);
plutovg_matrix_rotate(&v6, *(float *)&a2 * 0.017453292);
plutovg_matrix_translate(
&v6,
COERCE_DOUBLE(v8.m128_u64[0] ^ 0x8000000080000000LL),
COERCE_DOUBLE(v9.m128_u64[0] ^ 0x8000000080000000LL));
}
*((_QWORD *)this + 2) = v7;
*(_OWORD *)this = v6;
return this;
}
|
rotated:
PUSH R14
PUSH RBX
SUB RSP,0x48
MOVAPS XMM3,XMM0
MOV RBX,RDI
XORPS XMM0,XMM0
UCOMISS XMM1,XMM0
JNZ 0x0010cab9
JP 0x0010cab9
UCOMISS XMM2,XMM0
JNZ 0x0010cab9
JP 0x0010cab9
MULSS XMM3,dword ptr [0x00143140]
LEA RDI,[RSP + 0x8]
MOVAPS XMM0,XMM3
CALL 0x00127c82
JMP 0x0010cb11
LAB_0010cab9:
LEA R14,[RSP + 0x8]
MOV RDI,R14
MOVAPS XMM0,XMM1
MOVAPS xmmword ptr [RSP + 0x20],XMM1
MOVAPS XMM1,XMM2
MOVAPS xmmword ptr [RSP + 0x30],XMM2
MOVSS dword ptr [RSP + 0x4],XMM3
CALL 0x00127c59
MOVSS XMM0,dword ptr [RSP + 0x4]
MULSS XMM0,dword ptr [0x00143140]
MOV RDI,R14
CALL 0x00127e33
MOVAPS XMM2,xmmword ptr [0x00143100]
MOVAPS XMM0,xmmword ptr [RSP + 0x20]
XORPS XMM0,XMM2
MOVAPS XMM1,xmmword ptr [RSP + 0x30]
XORPS XMM1,XMM2
MOV RDI,R14
CALL 0x00127d29
LAB_0010cb11:
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RBX + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x8]
MOVUPS xmmword ptr [RBX],XMM0
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R14
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* lunasvg::Transform::rotated(float, float, float) */
Transform * __thiscall
lunasvg::Transform::rotated(Transform *this,float param_1,float param_2,float param_3)
{
int8 local_50;
int8 uStack_48;
int8 local_40;
float local_38;
float local_28;
if ((((param_2 != 0.0) || (NAN(param_2))) || (param_3 != 0.0)) || (NAN(param_3))) {
local_38 = param_2;
local_28 = param_3;
plutovg_matrix_init_translate(param_2,param_3,&local_50);
plutovg_matrix_rotate(param_1 * DAT_00143140,&local_50);
plutovg_matrix_translate
((uint)local_38 ^ _DAT_00143100,(uint)local_28 ^ _DAT_00143100,&local_50);
}
else {
plutovg_matrix_init_rotate(param_1 * DAT_00143140,&local_50);
}
*(int8 *)(this + 0x10) = local_40;
*(int8 *)this = local_50;
*(int8 *)(this + 8) = uStack_48;
return this;
}
|
|
19,859
|
pfs_end_sp_v1
|
eloqsql/storage/perfschema/pfs.cc
|
void pfs_end_sp_v1(PSI_sp_locker *locker)
{
PSI_sp_locker_state *state= reinterpret_cast<PSI_sp_locker_state*> (locker);
assert(state != NULL);
ulonglong timer_end;
ulonglong wait_time;
PFS_program *pfs_program= reinterpret_cast<PFS_program *>(state->m_sp_share);
PFS_sp_stat *stat= &pfs_program->m_sp_stat;
if (state->m_flags & STATE_FLAG_TIMED)
{
timer_end= state->m_timer();
wait_time= timer_end - state->m_timer_start;
/* Now use this timer_end and wait_time for timing information. */
stat->aggregate_value(wait_time);
}
else
{
stat->aggregate_counted();
}
}
|
O0
|
cpp
|
pfs_end_sp_v1:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x178, %rax # imm = 0x178
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4fc16
movq -0x10(%rbp), %rax
callq *0x18(%rax)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq 0x10(%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x51f70
jmp 0x4fc1f
movq -0x30(%rbp), %rdi
callq 0x51fa0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
pfs_end_sp_v1:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax+20h]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
add rax, 178h
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov eax, [rax]
and eax, 1
cmp eax, 0
jz short loc_4FC16
mov rax, [rbp+var_10]
call qword ptr [rax+18h]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
sub rax, [rcx+10h]
mov [rbp+var_20], rax
mov rdi, [rbp+var_30]; this
mov rsi, [rbp+var_20]; unsigned __int64
call _ZN11PFS_sp_stat15aggregate_valueEy; PFS_sp_stat::aggregate_value(ulong long)
jmp short loc_4FC1F
loc_4FC16:
mov rdi, [rbp+var_30]; this
call _ZN11PFS_sp_stat17aggregate_countedEv; PFS_sp_stat::aggregate_counted(void)
loc_4FC1F:
add rsp, 30h
pop rbp
retn
|
long long pfs_end_sp_v1(long long a1)
{
PFS_sp_stat *v2; // [rsp+0h] [rbp-30h]
long long v3; // [rsp+10h] [rbp-20h]
v2 = (PFS_sp_stat *)(*(_QWORD *)(a1 + 32) + 376LL);
if ( (*(_DWORD *)a1 & 1) == 0 )
return PFS_sp_stat::aggregate_counted(v2);
v3 = (*(long long (**)(void))(a1 + 24))() - *(_QWORD *)(a1 + 16);
return PFS_sp_stat::aggregate_value(v2, v3);
}
|
pfs_end_sp_v1:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x178
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
AND EAX,0x1
CMP EAX,0x0
JZ 0x0014fc16
MOV RAX,qword ptr [RBP + -0x10]
CALL qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,qword ptr [RCX + 0x10]
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00151f70
JMP 0x0014fc1f
LAB_0014fc16:
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00151fa0
LAB_0014fc1f:
ADD RSP,0x30
POP RBP
RET
|
void pfs_end_sp_v1(uint *param_1)
{
long lVar1;
long lVar2;
lVar1 = *(long *)(param_1 + 8);
if ((*param_1 & 1) == 0) {
PFS_sp_stat::aggregate_counted((PFS_sp_stat *)(lVar1 + 0x178));
}
else {
lVar2 = (**(code **)(param_1 + 6))();
PFS_sp_stat::aggregate_value((PFS_sp_stat *)(lVar1 + 0x178),lVar2 - *(long *)(param_1 + 4));
}
return;
}
|
|
19,860
|
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>> 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>::erase<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>>, 0>(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>>)
|
monkey531[P]llama/common/json.hpp
|
IteratorType erase(IteratorType pos)
{
// make sure iterator fits the current value
if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
{
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
}
IteratorType result = end();
switch (m_data.m_type)
{
case value_t::boolean:
case value_t::number_float:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::string:
case value_t::binary:
{
if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
{
JSON_THROW(invalid_iterator::create(205, "iterator out of range", this));
}
if (is_string())
{
AllocatorType<string_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1);
m_data.m_value.string = nullptr;
}
else if (is_binary())
{
AllocatorType<binary_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1);
m_data.m_value.binary = nullptr;
}
m_data.m_type = value_t::null;
assert_invariant();
break;
}
case value_t::object:
{
result.m_it.object_iterator = m_data.m_value.object->erase(pos.m_it.object_iterator);
break;
}
case value_t::array:
{
result.m_it.array_iterator = m_data.m_value.array->erase(pos.m_it.array_iterator);
break;
}
case value_t::null:
case value_t::discarded:
default:
JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
}
return result;
}
|
O0
|
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>> 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>::erase<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>>, 0>(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>>):
subq $0x138, %rsp # imm = 0x138
movq %rdx, 0x50(%rsp)
movq %rdi, 0x58(%rsp)
movq %rdi, %rax
movq %rax, 0x60(%rsp)
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
movq %rdx, 0x120(%rsp)
movq 0x128(%rsp), %rax
movq %rax, 0x68(%rsp)
cmpq (%rdx), %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xb4161
jmp 0xb4247
movb $0x1, 0xeb(%rsp)
movl $0x20, %edi
callq 0x5d680
movq %rax, 0x40(%rsp)
leaq 0xff(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x5e0f0
movq 0x48(%rsp), %rdx
leaq 0x163159(%rip), %rsi # 0x2172ef
leaq 0x100(%rsp), %rdi
callq 0x65290
jmp 0xb41a5
movq 0x68(%rsp), %rcx
movq 0x40(%rsp), %rdi
movl $0xca, %esi
leaq 0x100(%rsp), %rdx
callq 0xb8b40
jmp 0xb41c3
movq 0x40(%rsp), %rdi
movb $0x0, 0xeb(%rsp)
leaq 0x1f8b61(%rip), %rsi # 0x2acd38
leaq 0x4b12(%rip), %rdx # 0xb8cf0
callq 0x5db00
jmp 0xb4653
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
jmp 0xb421f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
leaq 0x100(%rsp), %rdi
callq 0x5e568
leaq 0xff(%rsp), %rdi
callq 0x5e540
testb $0x1, 0xeb(%rsp)
jne 0xb4238
jmp 0xb4242
movq 0x40(%rsp), %rdi
callq 0x5df90
jmp 0xb4646
movq 0x68(%rsp), %rsi
movq 0x58(%rsp), %rdi
callq 0xb3e60
movq 0x68(%rsp), %rax
movzbl (%rax), %eax
movq %rax, 0x38(%rsp)
subq $0x9, %rax
ja 0xb4572
movq 0x38(%rsp), %rax
leaq 0x15c953(%rip), %rcx # 0x210bcc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x50(%rsp), %rdi
addq $0x8, %rdi
addq $0x10, %rdi
callq 0xb8f50
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xb42a3
jmp 0xb4389
movb $0x1, 0xc6(%rsp)
movl $0x20, %edi
callq 0x5d680
movq %rax, 0x28(%rsp)
leaq 0xc7(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x5e0f0
movq 0x30(%rsp), %rdx
leaq 0x16303b(%rip), %rsi # 0x217313
leaq 0xc8(%rsp), %rdi
callq 0x65290
jmp 0xb42e7
movq 0x68(%rsp), %rcx
movq 0x28(%rsp), %rdi
movl $0xcd, %esi
leaq 0xc8(%rsp), %rdx
callq 0xb8b40
jmp 0xb4305
movq 0x28(%rsp), %rdi
movb $0x0, 0xc6(%rsp)
leaq 0x1f8a1f(%rip), %rsi # 0x2acd38
leaq 0x49d0(%rip), %rdx # 0xb8cf0
callq 0x5db00
jmp 0xb4653
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
jmp 0xb4361
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
leaq 0xc8(%rsp), %rdi
callq 0x5e568
leaq 0xc7(%rsp), %rdi
callq 0x5e540
testb $0x1, 0xc6(%rsp)
jne 0xb437a
jmp 0xb4384
movq 0x28(%rsp), %rdi
callq 0x5df90
jmp 0xb4646
movq 0x68(%rsp), %rdi
callq 0xb8f70
testb $0x1, %al
jne 0xb439c
jmp 0xb4420
leaq 0xc5(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x65750
movq 0x68(%rsp), %rax
movq 0x20(%rsp), %rdi
movq 0x8(%rax), %rsi
callq 0x90520
movq 0x68(%rsp), %rax
movq 0x20(%rsp), %rdi
movq 0x8(%rax), %rsi
movl $0x1, %edx
callq 0x66020
jmp 0xb43db
movq 0x68(%rsp), %rax
movq $0x0, 0x8(%rax)
leaq 0xc5(%rsp), %rdi
callq 0x657f0
jmp 0xb44b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
leaq 0xc5(%rsp), %rdi
callq 0x657f0
jmp 0xb4646
movq 0x68(%rsp), %rdi
callq 0xb8f90
testb $0x1, %al
jne 0xb4433
jmp 0xb44b4
leaq 0xc4(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xa5660
movq 0x68(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x8(%rax), %rsi
callq 0xb7fa0
movq 0x68(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x8(%rax), %rsi
movl $0x1, %edx
callq 0xa5cb0
jmp 0xb4472
movq 0x68(%rsp), %rax
movq $0x0, 0x8(%rax)
leaq 0xc4(%rsp), %rdi
callq 0xa57d0
jmp 0xb44b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
leaq 0xc4(%rsp), %rdi
callq 0xa57d0
jmp 0xb4646
jmp 0xb44b6
movq 0x68(%rsp), %rdi
movb $0x0, (%rdi)
movl $0x1, %esi
callq 0xa3b30
jmp 0xb4639
movq 0x50(%rsp), %rax
movq 0x68(%rsp), %rcx
movq 0x8(%rcx), %rdi
movq 0x8(%rax), %rax
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rsi
callq 0xb8fb0
movq %rax, %rcx
movq 0x58(%rsp), %rax
movq %rcx, 0xb8(%rsp)
movq 0xb8(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0xb4639
movq 0x50(%rsp), %rsi
movq 0x68(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
addq $0x8, %rsi
addq $0x8, %rsi
leaq 0xa0(%rsp), %rdi
callq 0xb9090
movq 0x10(%rsp), %rdi
movq 0xa0(%rsp), %rsi
callq 0xb9020
movq %rax, %rcx
movq 0x58(%rsp), %rax
movq %rcx, 0xa8(%rsp)
movq 0xa8(%rsp), %rcx
movq %rcx, 0x10(%rax)
jmp 0xb4639
jmp 0xb4572
movb $0x1, 0x77(%rsp)
movl $0x20, %edi
callq 0x5d680
movq 0x68(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0xb9330
movq %rax, 0x78(%rsp)
leaq 0x162d8d(%rip), %rsi # 0x217329
leaq 0x80(%rsp), %rdi
leaq 0x78(%rsp), %rdx
callq 0xb9280
jmp 0xb45b0
movq 0x68(%rsp), %rcx
movq 0x8(%rsp), %rdi
movl $0x133, %esi # imm = 0x133
leaq 0x80(%rsp), %rdx
callq 0xb90d0
jmp 0xb45ce
movq 0x8(%rsp), %rdi
movb $0x0, 0x77(%rsp)
leaq 0x1f8799(%rip), %rsi # 0x2acd78
leaq 0x4dfa(%rip), %rdx # 0xb93e0
callq 0x5db00
jmp 0xb4653
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
jmp 0xb4624
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x5e568
testb $0x1, 0x77(%rsp)
jne 0xb462d
jmp 0xb4637
movq 0x8(%rsp), %rdi
callq 0x5df90
jmp 0xb4646
movq 0x60(%rsp), %rax
addq $0x138, %rsp # imm = 0x138
retq
movq 0xf0(%rsp), %rdi
callq 0x5dbc0
nopw %cs:(%rax,%rax)
nopl (%rax)
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_:
sub rsp, 138h
mov qword ptr [rsp+138h+var_E8], rdx; char
mov qword ptr [rsp+138h+var_E0], rdi; int
mov rax, rdi
mov qword ptr [rsp+138h+var_D8], rax; int
mov [rsp+138h+var_8], rdi
mov qword ptr [rsp+138h+var_10], rsi
mov [rsp+138h+var_18], rdx
mov rax, qword ptr [rsp+138h+var_10]
mov qword ptr [rsp+138h+var_D0], rax; int
cmp rax, [rdx]
setnz al
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_B4161
jmp loc_B4247
loc_B4161:
mov [rsp+138h+var_4D], 1
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov [rsp+138h+var_F8], rax; __int64
lea rdi, [rsp+138h+var_39]
mov qword ptr [rsp+138h+var_F0], rdi; int
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdx, qword ptr [rsp+138h+var_F0]
lea rsi, aIteratorDoesNo; "iterator does not fit current value"
lea rdi, [rsp+138h+var_39+1]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_B41A5:
mov rcx, qword ptr [rsp+138h+var_D0]
mov rdi, [rsp+138h+var_F8]; int
mov esi, 0CAh
lea rdx, [rsp+138h+var_39+1]
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
jmp short $+2
loc_B41C3:
mov rdi, [rsp+138h+var_F8]; void *
mov [rsp+138h+var_4D], 0
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorD2Ev; void (*)(void *)
call ___cxa_throw
jmp loc_B4653
mov rcx, rax
mov eax, edx
mov [rsp+arg_E8], rcx
mov [rsp+arg_E4], eax
jmp short loc_B421F
mov rcx, rax
mov eax, edx
mov [rsp+arg_E8], rcx
mov [rsp+arg_E4], eax
lea rdi, [rsp+arg_F8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_B421F:
lea rdi, [rsp+arg_F7]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
test [rsp+arg_E3], 1
jnz short loc_B4238
jmp short loc_B4242
loc_B4238:
mov rdi, [rsp+arg_38]; void *
call ___cxa_free_exception
loc_B4242:
jmp loc_B4646
loc_B4247:
mov rsi, qword ptr [rsp+138h+var_D0]
mov rdi, qword ptr [rsp+138h+var_E0]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE3endEv; 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>::end(void)
mov rax, qword ptr [rsp+138h+var_D0]
movzx eax, byte ptr [rax]
mov qword ptr [rsp+138h+var_100], rax; int
sub rax, 9; switch 10 cases
ja def_B4280; jumptable 00000000000B4280 default case
mov rax, qword ptr [rsp+138h+var_100]
lea rcx, jpt_B4280
movsxd rax, ds:(jpt_B4280 - 210BCCh)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_B4282:
mov rdi, qword ptr [rsp+138h+var_E8]; jumptable 00000000000B4280 cases 3-8
add rdi, 8
add rdi, 10h; this
call _ZNK8nlohmann16json_abi_v3_11_36detail20primitive_iterator_t8is_beginEv; nlohmann::json_abi_v3_11_3::detail::primitive_iterator_t::is_begin(void)
xor al, 0FFh
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_B42A3
jmp loc_B4389
loc_B42A3:
mov [rsp+138h+var_72], 1
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov [rsp+138h+var_110], rax; int
lea rdi, [rsp+138h+var_71]
mov qword ptr [rsp+138h+var_108], rdi; int
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdx, qword ptr [rsp+138h+var_108]
lea rsi, aIteratorOutOfR; "iterator out of range"
lea rdi, [rsp+138h+var_71+1]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_B42E7:
mov rcx, qword ptr [rsp+138h+var_D0]
mov rdi, [rsp+138h+var_110]; int
mov esi, 0CDh
lea rdx, [rsp+138h+var_71+1]
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
jmp short $+2
loc_B4305:
mov rdi, [rsp+138h+var_110]; void *
mov [rsp+138h+var_72], 0
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorD2Ev; void (*)(void *)
call ___cxa_throw
jmp loc_B4653
mov rcx, rax
mov eax, edx
mov [rsp+arg_E8], rcx
mov [rsp+arg_E4], eax
jmp short loc_B4361
mov rcx, rax
mov eax, edx
mov [rsp+arg_E8], rcx
mov [rsp+arg_E4], eax
lea rdi, [rsp+arg_C0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_B4361:
lea rdi, [rsp+arg_BF]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
test [rsp+arg_BE], 1
jnz short loc_B437A
jmp short loc_B4384
loc_B437A:
mov rdi, [rsp+arg_20]; void *
call ___cxa_free_exception
loc_B4384:
jmp loc_B4646
loc_B4389:
mov rdi, qword ptr [rsp+138h+var_D0]
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9is_stringEv; 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>::is_string(void)
test al, 1
jnz short loc_B439C
jmp loc_B4420
loc_B439C:
lea rdi, [rsp+138h+var_73]
mov [rsp+138h+var_118], rdi
call _ZNSaINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEC2Ev; std::allocator<std::string>::allocator(void)
mov rax, qword ptr [rsp+138h+var_D0]
mov rdi, [rsp+138h+var_118]
mov rsi, [rax+8]
call _ZNSt16allocator_traitsISaINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEE7destroyIS5_EEvRS6_PT_; std::allocator_traits<std::allocator<std::string>>::destroy<std::string>(std::allocator<std::string>&,std::string *)
mov rax, qword ptr [rsp+138h+var_D0]
mov rdi, [rsp+138h+var_118]
mov rsi, [rax+8]
mov edx, 1
call _ZNSt16allocator_traitsISaINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEE10deallocateERS6_PS5_m; std::allocator_traits<std::allocator<std::string>>::deallocate(std::allocator<std::string>&,std::string*,ulong)
jmp short $+2
loc_B43DB:
mov rax, qword ptr [rsp+138h+var_D0]
mov qword ptr [rax+8], 0
lea rdi, [rsp+138h+var_73]
call _ZNSaINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEED2Ev; std::allocator<std::string>::~allocator()
jmp loc_B44B6
mov rcx, rax
mov eax, edx
mov [rsp+arg_E8], rcx
mov [rsp+arg_E4], eax
lea rdi, [rsp+arg_BD]
call _ZNSaINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEED2Ev; std::allocator<std::string>::~allocator()
jmp loc_B4646
loc_B4420:
mov rdi, qword ptr [rsp+138h+var_D0]
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9is_binaryEv; 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>::is_binary(void)
test al, 1
jnz short loc_B4433
jmp loc_B44B4
loc_B4433:
lea rdi, [rsp+138h+var_74]
mov [rsp+138h+var_120], rdi
call _ZNSaIN8nlohmann16json_abi_v3_11_327byte_container_with_subtypeISt6vectorIhSaIhEEEEEC2Ev; std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>>>::allocator(void)
mov rax, qword ptr [rsp+138h+var_D0]
mov rdi, [rsp+138h+var_120]
mov rsi, [rax+8]
call _ZNSt16allocator_traitsISaIN8nlohmann16json_abi_v3_11_327byte_container_with_subtypeISt6vectorIhSaIhEEEEEE7destroyIS6_EEvRS7_PT_; std::allocator_traits<std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>>>>::destroy<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>>>(std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>>>&,nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>> *)
mov rax, qword ptr [rsp+138h+var_D0]
mov rdi, [rsp+138h+var_120]
mov rsi, [rax+8]
mov edx, 1
call _ZNSt16allocator_traitsISaIN8nlohmann16json_abi_v3_11_327byte_container_with_subtypeISt6vectorIhSaIhEEEEEE10deallocateERS7_PS6_m; std::allocator_traits<std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>>>>::deallocate(std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>>>&,nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>>*,ulong)
jmp short $+2
loc_B4472:
mov rax, qword ptr [rsp+138h+var_D0]
mov qword ptr [rax+8], 0
lea rdi, [rsp+138h+var_74]
call _ZNSaIN8nlohmann16json_abi_v3_11_327byte_container_with_subtypeISt6vectorIhSaIhEEEEED2Ev; std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>>>::~allocator()
jmp short loc_B44B4
mov rcx, rax
mov eax, edx
mov [rsp+arg_E8], rcx
mov [rsp+arg_E4], eax
lea rdi, [rsp+arg_BC]
call _ZNSaIN8nlohmann16json_abi_v3_11_327byte_container_with_subtypeISt6vectorIhSaIhEEEEED2Ev; std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>>>::~allocator()
jmp loc_B4646
loc_B44B4:
jmp short $+2
loc_B44B6:
mov rdi, qword ptr [rsp+138h+var_D0]
mov byte ptr [rdi], 0
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
jmp loc_B4639
loc_B44CD:
mov rax, qword ptr [rsp+138h+var_E8]; jumptable 00000000000B4280 case 1
mov rcx, qword ptr [rsp+138h+var_D0]
mov rdi, [rcx+8]
mov rax, [rax+8]
mov [rsp+138h+var_88], rax
mov rsi, [rsp+138h+var_88]
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEE; 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>>>>::erase(__gnu_cxx::__normal_iterator<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>>*,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>)
mov rcx, rax
mov rax, qword ptr [rsp+138h+var_E0]
mov [rsp+138h+var_80], rcx
mov rcx, [rsp+138h+var_80]
mov [rax+8], rcx
jmp loc_B4639
loc_B4515:
mov rsi, qword ptr [rsp+138h+var_E8]; jumptable 00000000000B4280 case 2
mov rax, qword ptr [rsp+138h+var_D0]
mov rax, [rax+8]
mov [rsp+138h+var_128], rax
add rsi, 8
add rsi, 8
lea rdi, [rsp+138h+var_98]
call _ZN9__gnu_cxx17__normal_iteratorIPKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEES5_ISF_SaISF_EEEC2IPSF_EERKNS0_IT_NS_11__enable_ifIXsr3std10__are_sameISN_SM_EE7__valueESJ_E6__typeEEE
mov rdi, [rsp+138h+var_128]
mov rsi, [rsp+138h+var_98]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE5eraseEN9__gnu_cxx17__normal_iteratorIPKSD_SF_EE; std::vector<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>>::erase(__gnu_cxx::__normal_iterator<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*,std::vector<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 rcx, rax
mov rax, qword ptr [rsp+138h+var_E0]
mov [rsp+138h+var_90], rcx
mov rcx, [rsp+138h+var_90]
mov [rax+10h], rcx
jmp loc_B4639
loc_B4570:
jmp short $+2; jumptable 00000000000B4280 cases 0,9
def_B4280:
mov [rsp+138h+var_C1], 1; jumptable 00000000000B4280 default case
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rdi, qword ptr [rsp+138h+var_D0]
mov [rsp+138h+var_130], rax; int
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)
mov qword ptr [rsp+138h+var_C0], rax; int
lea rsi, aCannotUseErase; "cannot use erase() with "
lea rdi, [rsp+138h+var_B8]
lea rdx, [rsp+138h+var_C0]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA25_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[25],char const*>(char const(&)[25],char const* &&)
jmp short $+2
loc_B45B0:
mov rcx, qword ptr [rsp+138h+var_D0]
mov rdi, [rsp+138h+var_130]; int
mov esi, 133h
lea rdx, [rsp+138h+var_B8]
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
jmp short $+2
loc_B45CE:
mov rdi, [rsp+138h+var_130]; void *
mov [rsp+138h+var_C1], 0
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail10type_errorD2Ev; void (*)(void *)
call ___cxa_throw
jmp short loc_B4653
mov rcx, rax
mov eax, edx
mov [rsp+arg_E8], rcx
mov [rsp+arg_E4], eax
jmp short loc_B4624
mov rcx, rax
mov eax, edx
mov [rsp+arg_E8], rcx
mov [rsp+arg_E4], eax
lea rdi, [rsp+arg_78]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_B4624:
test [rsp+arg_6F], 1
jnz short loc_B462D
jmp short loc_B4637
loc_B462D:
mov rdi, [rsp+arg_0]; void *
call ___cxa_free_exception
loc_B4637:
jmp short loc_B4646
loc_B4639:
mov rax, qword ptr [rsp+138h+var_D8]
add rsp, 138h
retn
loc_B4646:
mov rdi, [rsp+arg_E8]
call __Unwind_Resume
loc_B4653:
nop word ptr [rax+rax+00000000h]
nop dword ptr [rax]
|
long long ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_(
long long a1,
unsigned __int8 *a2,
unsigned __int8 **a3)
{
long long v3; // rcx
long long v4; // r8
long long v5; // r9
long long v6; // rcx
long long v7; // r8
long long v8; // r9
int v9; // ecx
int v10; // r8d
int v11; // r9d
int v13; // [rsp+0h] [rbp-138h]
int v14; // [rsp+8h] [rbp-130h]
int v15; // [rsp+8h] [rbp-130h]
void *v16; // [rsp+8h] [rbp-130h]
int v17; // [rsp+10h] [rbp-128h]
long long v18; // [rsp+10h] [rbp-128h]
char v19; // [rsp+18h] [rbp-120h]
int v20; // [rsp+20h] [rbp-118h]
int v21; // [rsp+28h] [rbp-110h]
int v22; // [rsp+28h] [rbp-110h]
void *v23; // [rsp+28h] [rbp-110h]
int v24; // [rsp+30h] [rbp-108h]
int v25; // [rsp+38h] [rbp-100h]
int v26; // [rsp+38h] [rbp-100h]
void *v27; // [rsp+40h] [rbp-F8h]
void *exception; // [rsp+40h] [rbp-F8h]
void *v29; // [rsp+40h] [rbp-F8h]
int v30; // [rsp+48h] [rbp-F0h]
char v32; // [rsp+70h] [rbp-C8h]
int v33[2]; // [rsp+78h] [rbp-C0h] BYREF
int v34; // [rsp+80h] [rbp-B8h] BYREF
int v35; // [rsp+88h] [rbp-B0h]
char v36; // [rsp+90h] [rbp-A8h]
long long v37; // [rsp+A0h] [rbp-98h] BYREF
long long v38; // [rsp+A8h] [rbp-90h]
char v39; // [rsp+C4h] [rbp-74h] BYREF
_BYTE v40[2]; // [rsp+C5h] [rbp-73h] BYREF
int v41[9]; // [rsp+C7h] [rbp-71h] BYREF
char v42; // [rsp+EBh] [rbp-4Dh]
int v43[8]; // [rsp+FFh] [rbp-39h] BYREF
unsigned __int8 **v44; // [rsp+120h] [rbp-18h]
int v45[2]; // [rsp+128h] [rbp-10h]
long long v46; // [rsp+130h] [rbp-8h]
v46 = a1;
*(_QWORD *)v45 = a2;
v44 = a3;
if ( a2 != *a3 )
{
exception = __cxa_allocate_exception(0x20uLL);
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>(
(long long)v43 + 1,
(long long)"iterator does not fit current value",
(long long)v43);
ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
(int)exception,
v13,
v14,
v17,
v19,
v20,
v21,
v24,
v25,
(long long)exception,
(int)v43,
(char)a3,
a1,
a1,
(int)a2,
v32,
v33[0],
v34,
v35,
v36);
v42 = 0;
__cxa_throw(
v29,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::invalid_iterator,
nlohmann::json_abi_v3_11_3::detail::invalid_iterator::~invalid_iterator);
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::end(
a1,
(long long)a2);
v26 = *a2;
switch ( *a2 )
{
case 1u:
*(_QWORD *)(a1 + 8) = 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>>>>::erase(
*((_QWORD *)a2 + 1),
a3[1]);
break;
case 2u:
v18 = *((_QWORD *)a2 + 1);
__gnu_cxx::__normal_iterator<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*,std::vector<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>>>::__normal_iterator<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>*>(
&v37,
a3 + 2);
v38 = std::vector<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>>::erase(
v18,
v37);
*(_QWORD *)(a1 + 16) = v38;
break;
case 3u:
case 4u:
case 5u:
case 6u:
case 7u:
case 8u:
if ( (nlohmann::json_abi_v3_11_3::detail::primitive_iterator_t::is_begin((nlohmann::json_abi_v3_11_3::detail::primitive_iterator_t *)(a3 + 3)) & 1) == 0 )
{
v22 = (unsigned int)__cxa_allocate_exception(0x20uLL);
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>(
(long long)v41 + 1,
(long long)"iterator out of range",
(long long)v41);
ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
v22,
v13,
v14,
v17,
v19,
v20,
v22,
(int)v41,
v26,
(long long)v27,
v30,
(char)a3,
a1,
a1,
(int)a2,
v32,
v33[0],
v34,
v35,
v36);
v40[1] = 0;
__cxa_throw(
v23,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::invalid_iterator,
nlohmann::json_abi_v3_11_3::detail::invalid_iterator::~invalid_iterator);
}
if ( (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>::is_string(a2) & 1) != 0 )
{
std::allocator<std::string>::allocator((long long)v40);
std::allocator_traits<std::allocator<std::string>>::destroy<std::string>((long long)v40, *((_QWORD *)a2 + 1));
std::allocator_traits<std::allocator<std::string>>::deallocate(
(long long)v40,
*((_QWORD *)a2 + 1),
1LL,
v3,
v4,
v5);
*((_QWORD *)a2 + 1) = 0LL;
std::allocator<std::string>::~allocator((long long)v40);
}
else if ( (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>::is_binary(a2) & 1) != 0 )
{
std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned char>>>::allocator((long long)&v39);
std::allocator_traits<std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned char>>>>::destroy<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned char>>>(
&v39,
*((_QWORD *)a2 + 1));
std::allocator_traits<std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned char>>>>::deallocate(
(long long)&v39,
*((_QWORD *)a2 + 1),
1LL,
v6,
v7,
v8);
*((_QWORD *)a2 + 1) = 0LL;
std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned char>>>::~allocator((long long)&v39);
}
*a2 = 0;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((long long)a2);
break;
default:
v15 = (unsigned int)__cxa_allocate_exception(0x20uLL);
*(_QWORD *)v33 = 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(a2);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[25],char const*>(
(unsigned int)&v34,
(unsigned int)"cannot use erase() with ",
(unsigned int)v33,
v9,
v10,
v11);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
v15,
v13,
v15,
v17,
v19,
v20,
v21,
v24,
v26,
(long long)v27,
v30,
(char)a3,
a1,
a1,
(int)a2,
v32,
v33[0],
v34,
v35,
v36);
__cxa_throw(
v16,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
nlohmann::json_abi_v3_11_3::detail::type_error::~type_error);
}
return a1;
}
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_:
SUB RSP,0x138
MOV qword ptr [RSP + 0x50],RDX
MOV qword ptr [RSP + 0x58],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x60],RAX
MOV qword ptr [RSP + 0x130],RDI
MOV qword ptr [RSP + 0x128],RSI
MOV qword ptr [RSP + 0x120],RDX
MOV RAX,qword ptr [RSP + 0x128]
MOV qword ptr [RSP + 0x68],RAX
CMP RAX,qword ptr [RDX]
SETNZ AL
XOR AL,0xff
XOR AL,0xff
TEST AL,0x1
JNZ 0x001b4161
JMP 0x001b4247
LAB_001b4161:
MOV byte ptr [RSP + 0xeb],0x1
MOV EDI,0x20
CALL 0x0015d680
MOV qword ptr [RSP + 0x40],RAX
LEA RDI,[RSP + 0xff]
MOV qword ptr [RSP + 0x48],RDI
CALL 0x0015e0f0
MOV RDX,qword ptr [RSP + 0x48]
LAB_001b418f:
LEA RSI,[0x3172ef]
LEA RDI,[RSP + 0x100]
CALL 0x00165290
JMP 0x001b41a5
LAB_001b41a5:
MOV RCX,qword ptr [RSP + 0x68]
MOV RDI,qword ptr [RSP + 0x40]
MOV ESI,0xca
LEA RDX,[RSP + 0x100]
CALL 0x001b8b40
JMP 0x001b41c3
LAB_001b41c3:
MOV RDI,qword ptr [RSP + 0x40]
MOV byte ptr [RSP + 0xeb],0x0
LEA RSI,[0x3acd38]
LEA RDX,[0x1b8cf0]
CALL 0x0015db00
LAB_001b4247:
MOV RSI,qword ptr [RSP + 0x68]
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x001b3e60
MOV RAX,qword ptr [RSP + 0x68]
MOVZX EAX,byte ptr [RAX]
MOV qword ptr [RSP + 0x38],RAX
SUB RAX,0x9
JA 0x001b4572
MOV RAX,qword ptr [RSP + 0x38]
LEA RCX,[0x310bcc]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_3:
MOV RDI,qword ptr [RSP + 0x50]
ADD RDI,0x8
ADD RDI,0x10
CALL 0x001b8f50
XOR AL,0xff
XOR AL,0xff
XOR AL,0xff
TEST AL,0x1
JNZ 0x001b42a3
JMP 0x001b4389
LAB_001b42a3:
MOV byte ptr [RSP + 0xc6],0x1
MOV EDI,0x20
CALL 0x0015d680
MOV qword ptr [RSP + 0x28],RAX
LEA RDI,[RSP + 0xc7]
MOV qword ptr [RSP + 0x30],RDI
CALL 0x0015e0f0
MOV RDX,qword ptr [RSP + 0x30]
LAB_001b42d1:
LEA RSI,[0x317313]
LEA RDI,[RSP + 0xc8]
CALL 0x00165290
JMP 0x001b42e7
LAB_001b42e7:
MOV RCX,qword ptr [RSP + 0x68]
MOV RDI,qword ptr [RSP + 0x28]
MOV ESI,0xcd
LEA RDX,[RSP + 0xc8]
CALL 0x001b8b40
JMP 0x001b4305
LAB_001b4305:
MOV RDI,qword ptr [RSP + 0x28]
MOV byte ptr [RSP + 0xc6],0x0
LEA RSI,[0x3acd38]
LEA RDX,[0x1b8cf0]
CALL 0x0015db00
LAB_001b4389:
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x001b8f70
TEST AL,0x1
JNZ 0x001b439c
JMP 0x001b4420
LAB_001b439c:
LEA RDI,[RSP + 0xc5]
MOV qword ptr [RSP + 0x20],RDI
CALL 0x00165750
MOV RAX,qword ptr [RSP + 0x68]
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x00190520
MOV RAX,qword ptr [RSP + 0x68]
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RAX + 0x8]
LAB_001b43cf:
MOV EDX,0x1
CALL 0x00166020
JMP 0x001b43db
LAB_001b43db:
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RAX + 0x8],0x0
LEA RDI,[RSP + 0xc5]
CALL 0x001657f0
JMP 0x001b44b6
LAB_001b4420:
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x001b8f90
TEST AL,0x1
JNZ 0x001b4433
JMP 0x001b44b4
LAB_001b4433:
LEA RDI,[RSP + 0xc4]
MOV qword ptr [RSP + 0x18],RDI
CALL 0x001a5660
MOV RAX,qword ptr [RSP + 0x68]
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x001b7fa0
MOV RAX,qword ptr [RSP + 0x68]
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RAX + 0x8]
LAB_001b4466:
MOV EDX,0x1
CALL 0x001a5cb0
LAB_001b4470:
JMP 0x001b4472
LAB_001b4472:
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RAX + 0x8],0x0
LEA RDI,[RSP + 0xc4]
CALL 0x001a57d0
JMP 0x001b44b4
LAB_001b44b4:
JMP 0x001b44b6
LAB_001b44b6:
MOV RDI,qword ptr [RSP + 0x68]
MOV byte ptr [RDI],0x0
MOV ESI,0x1
CALL 0x001a3b30
JMP 0x001b4639
caseD_1:
MOV RAX,qword ptr [RSP + 0x50]
MOV RCX,qword ptr [RSP + 0x68]
MOV RDI,qword ptr [RCX + 0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0xb0],RAX
MOV RSI,qword ptr [RSP + 0xb0]
CALL 0x001b8fb0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0xb8],RCX
MOV RCX,qword ptr [RSP + 0xb8]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x001b4639
caseD_2:
MOV RSI,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RSP + 0x68]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x10],RAX
ADD RSI,0x8
ADD RSI,0x8
LEA RDI,[RSP + 0xa0]
CALL 0x001b9090
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0xa0]
CALL 0x001b9020
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0xa8],RCX
MOV RCX,qword ptr [RSP + 0xa8]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x001b4639
caseD_0:
JMP 0x001b4572
default:
MOV byte ptr [RSP + 0x77],0x1
MOV EDI,0x20
CALL 0x0015d680
MOV RDI,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0x8],RAX
CALL 0x001b9330
MOV qword ptr [RSP + 0x78],RAX
LAB_001b4595:
LEA RSI,[0x317329]
LEA RDI,[RSP + 0x80]
LEA RDX,[RSP + 0x78]
CALL 0x001b9280
JMP 0x001b45b0
LAB_001b45b0:
MOV RCX,qword ptr [RSP + 0x68]
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,0x133
LEA RDX,[RSP + 0x80]
CALL 0x001b90d0
JMP 0x001b45ce
LAB_001b45ce:
MOV RDI,qword ptr [RSP + 0x8]
MOV byte ptr [RSP + 0x77],0x0
LEA RSI,[0x3acd78]
LEA RDX,[0x1b93e0]
CALL 0x0015db00
LAB_001b4639:
MOV RAX,qword ptr [RSP + 0x60]
ADD RSP,0x138
RET
|
long _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_
(long param_1,
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*param_2,long *param_3)
{
vector<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<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>>>
*pvVar1;
byte bVar2;
ulong uVar3;
int8 uVar4;
char *local_c0;
detail local_b8 [32];
int8 local_98 [2];
long local_88;
allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned_char,std::allocator<unsigned_char>>>>
local_74;
allocator<std::__cxx11::string> local_73;
int1 local_72;
allocator local_71;
string local_70 [35];
int1 local_4d;
allocator local_39;
string local_38 [32];
long *local_18;
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_10;
long local_8;
local_18 = param_3;
local_10 = param_2;
local_8 = param_1;
if (param_2 !=
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)*param_3) {
local_4d = 1;
uVar4 = __cxa_allocate_exception(0x20);
std::allocator<char>::allocator();
/* try { // try from 001b418f to 001b41a2 has its CatchHandler @ 001b41e8 */
std::__cxx11::string::string<std::allocator<char>>
(local_38,"iterator does not fit current value",&local_39);
/* try { // try from 001b41a5 to 001b41e2 has its CatchHandler @ 001b41fe */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar4,0xca,local_38,param_2);
local_4d = 0;
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&nlohmann::json_abi_v3_11_3::detail::invalid_iterator::typeinfo,
nlohmann::json_abi_v3_11_3::detail::invalid_iterator::~invalid_iterator);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::end();
switch(*param_2) {
case (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:
case (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>
)0x9:
default:
uVar4 = __cxa_allocate_exception(0x20);
local_c0 = (char *)nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::type_name(param_2);
/* try { // try from 001b4595 to 001b45ad has its CatchHandler @ 001b45ed */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[25],char_const*>
(local_b8,"cannot use erase() with ",&local_c0);
/* try { // try from 001b45b0 to 001b45ea has its CatchHandler @ 001b4603 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar4,0x133,local_b8,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::type_error::~type_error);
case (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:
local_88 = param_3[1];
uVar4 = 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>>>>
::erase(*(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>>>>
**)(param_2 + 8),local_88);
*(int8 *)(param_1 + 8) = uVar4;
break;
case (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>
)0x2:
pvVar1 = *(vector<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<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>>>
**)(param_2 + 8);
__gnu_cxx::
__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const*,std::vector<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<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>>>>
::
__normal_iterator<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>*>
((__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const*,std::vector<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<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>>>>
*)local_98,(__normal_iterator *)(param_3 + 2));
uVar4 = std::
vector<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<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>>>
::erase(pvVar1,local_98[0]);
*(int8 *)(param_1 + 0x10) = uVar4;
break;
case (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>
)0x3:
case (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>
)0x4:
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x5:
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x6:
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x7:
case (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:
bVar2 = nlohmann::json_abi_v3_11_3::detail::primitive_iterator_t::is_begin
((primitive_iterator_t *)(param_3 + 3));
if (((bVar2 ^ 0xff) & 1) != 0) {
local_72 = 1;
uVar4 = __cxa_allocate_exception(0x20);
std::allocator<char>::allocator();
/* try { // try from 001b42d1 to 001b42e4 has its CatchHandler @ 001b432a */
std::__cxx11::string::string<std::allocator<char>>(local_70,"iterator out of range",&local_71)
;
/* try { // try from 001b42e7 to 001b4324 has its CatchHandler @ 001b4340 */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar4,0xcd,local_70,param_2);
local_72 = 0;
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&nlohmann::json_abi_v3_11_3::detail::invalid_iterator::typeinfo,
nlohmann::json_abi_v3_11_3::detail::invalid_iterator::~invalid_iterator);
}
uVar3 = 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>
::is_string(param_2);
if ((uVar3 & 1) == 0) {
uVar3 = 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>
::is_binary(param_2);
if ((uVar3 & 1) != 0) {
std::
allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned_char,std::allocator<unsigned_char>>>>
::allocator(&local_74);
std::
allocator_traits<std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned_char,std::allocator<unsigned_char>>>>>
::
destroy<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned_char,std::allocator<unsigned_char>>>>
((allocator *)&local_74,*(byte_container_with_subtype **)(param_2 + 8));
/* try { // try from 001b4466 to 001b446f has its CatchHandler @ 001b448e */
std::
allocator_traits<std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned_char,std::allocator<unsigned_char>>>>>
::deallocate((allocator *)&local_74,*(byte_container_with_subtype **)(param_2 + 8),1);
*(int8 *)(param_2 + 8) = 0;
std::
allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned_char,std::allocator<unsigned_char>>>>
::~allocator(&local_74);
}
}
else {
std::allocator<std::__cxx11::string>::allocator(&local_73);
std::allocator_traits<std::allocator<std::__cxx11::string>>::destroy<std::__cxx11::string>
((allocator *)&local_73,*(string **)(param_2 + 8));
/* try { // try from 001b43cf to 001b43d8 has its CatchHandler @ 001b43fa */
std::allocator_traits<std::allocator<std::__cxx11::string>>::deallocate
((allocator *)&local_73,*(string **)(param_2 + 8),1);
*(int8 *)(param_2 + 8) = 0;
std::allocator<std::__cxx11::string>::~allocator(&local_73);
}
*param_2 = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(param_2,0));
}
return param_1;
}
|
|
19,861
|
minja::Value::at(minja::Value const&)
|
monkey531[P]llama/common/minja.hpp
|
Value& at(const Value & index) {
if (!index.is_hashable()) throw std::runtime_error("Unashable type: " + dump());
if (is_array()) return array_->at(index.get<int>());
if (is_object()) return object_->at(index.primitive_);
throw std::runtime_error("Value is not an array or object: " + dump());
}
|
O2
|
cpp
|
minja::Value::at(minja::Value const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x7f8b0
testb %al, %al
je 0x89ab1
movq 0x10(%r14), %r15
testq %r15, %r15
je 0x89a92
movq %rbx, %rdi
callq 0x87aba
movslq %eax, %rsi
movq %r15, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x879bc
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x89b0e
addq $0x40, %rbx
movq %rbx, %rsi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8aa5e
pushq $0x10
popq %rdi
callq 0x265e0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x7f8c0
leaq 0x48d03(%rip), %rsi # 0xd27d8
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x74fe2
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x27450
xorl %ebp, %ebp
movq 0x984f3(%rip), %rsi # 0x121ff0
movq 0x98454(%rip), %rdx # 0x121f58
movq %rbx, %rdi
callq 0x275b0
jmp 0x89b69
pushq $0x10
popq %rdi
callq 0x265e0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x7f8c0
leaq 0x48df2(%rip), %rsi # 0xd2924
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x74fe2
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x27450
xorl %ebp, %ebp
movq 0x98496(%rip), %rsi # 0x121ff0
movq 0x983f7(%rip), %rdx # 0x121f58
movq %rbx, %rdi
callq 0x275b0
jmp 0x89b6f
jmp 0x89b7e
jmp 0x89b95
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x27998
jmp 0x89b84
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x27998
testb %bpl, %bpl
jne 0x89b98
jmp 0x89ba0
movq %rax, %r14
movq %rbx, %rdi
callq 0x268f0
movq %r14, %rdi
callq 0x27660
|
_ZN5minja5Value2atERKS0_:
push rbp
push r15
push r14
push rbx
sub rsp, 48h
mov rbx, rsi
mov r14, rdi
mov rdi, rsi; this
call _ZNK5minja5Value12is_primitiveEv; minja::Value::is_primitive(void)
test al, al
jz short loc_89AB1
mov r15, [r14+10h]
test r15, r15
jz short loc_89A92
mov rdi, rbx
call _ZNK5minja5Value3getIiEET_v; minja::Value::get<int>(void)
movsxd rsi, eax
mov rdi, r15
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
jmp _ZNSt6vectorIN5minja5ValueESaIS1_EE2atEm; std::vector<minja::Value>::at(ulong)
loc_89A92:
mov rdi, [r14+20h]
test rdi, rdi
jz short loc_89B0E
add rbx, 40h ; '@'
mov rsi, rbx
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
jmp _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atERSJ_; nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>::at(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
loc_89AB1:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+68h+var_60]
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r14
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aUnashableType; "Unashable type: "
lea rdi, [rsp+68h+var_40]
lea rdx, [rsp+68h+var_60]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+68h+var_40]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_89B69
loc_89B0E:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+68h+var_60]
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r14
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aValueIsNotAnAr_0; "Value is not an array or object: "
lea rdi, [rsp+68h+var_40]
lea rdx, [rsp+68h+var_60]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+68h+var_40]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_89B69:
jmp short loc_89B6F
jmp short loc_89B7E
jmp short loc_89B95
loc_89B6F:
mov r14, rax
lea rdi, [rsp+68h+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_89B84
loc_89B7E:
mov r14, rax
mov bpl, 1
loc_89B84:
lea rdi, [rsp+68h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_89B98
jmp short loc_89BA0
loc_89B95:
mov r14, rax
loc_89B98:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_89BA0:
mov rdi, r14
call __Unwind_Resume
|
long long minja::Value::at(minja::Value *this, const minja::Value *a2)
{
_QWORD *v3; // r15
int v4; // eax
long long v6; // rdi
void *exception; // rbx
void *v8; // rbx
_BYTE v9[32]; // [rsp+8h] [rbp-60h] BYREF
_BYTE v10[64]; // [rsp+28h] [rbp-40h] BYREF
if ( !minja::Value::is_primitive(a2) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v9, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v10, (long long)"Unashable type: ", (long long)v9);
std::runtime_error::runtime_error(exception, v10);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v3 = (_QWORD *)*((_QWORD *)this + 2);
if ( v3 )
{
v4 = minja::Value::get<int>(a2);
return std::vector<minja::Value>::at(v3, v4);
}
else
{
v6 = *((_QWORD *)this + 4);
if ( !v6 )
{
v8 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v9, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v10, (long long)"Value is not an array or object: ", (long long)v9);
std::runtime_error::runtime_error(v8, v10);
__cxa_throw(
v8,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::at(
v6,
(char *)a2 + 64);
}
}
|
at:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV RBX,RSI
MOV R14,RDI
MOV RDI,RSI
CALL 0x0017f8b0
TEST AL,AL
JZ 0x00189ab1
MOV R15,qword ptr [R14 + 0x10]
TEST R15,R15
JZ 0x00189a92
MOV RDI,RBX
CALL 0x00187aba
MOVSXD RSI,EAX
MOV RDI,R15
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
JMP 0x001879bc
LAB_00189a92:
MOV RDI,qword ptr [R14 + 0x20]
TEST RDI,RDI
JZ 0x00189b0e
ADD RBX,0x40
MOV RSI,RBX
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
JMP 0x0018aa5e
LAB_00189ab1:
PUSH 0x10
POP RDI
CALL 0x001265e0
MOV RBX,RAX
LAB_00189abc:
LEA RDI,[RSP + 0x8]
PUSH -0x1
POP RDX
MOV RSI,R14
XOR ECX,ECX
CALL 0x0017f8c0
LAB_00189ace:
LEA RSI,[0x1d27d8]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x00174fe2
MOV BPL,0x1
LAB_00189ae7:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x00127450
XOR EBP,EBP
MOV RSI,qword ptr [0x00221ff0]
MOV RDX,qword ptr [0x00221f58]
MOV RDI,RBX
CALL 0x001275b0
LAB_00189b0e:
PUSH 0x10
POP RDI
CALL 0x001265e0
MOV RBX,RAX
LAB_00189b19:
LEA RDI,[RSP + 0x8]
PUSH -0x1
POP RDX
MOV RSI,R14
XOR ECX,ECX
CALL 0x0017f8c0
LAB_00189b2b:
LEA RSI,[0x1d2924]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x00174fe2
MOV BPL,0x1
LAB_00189b44:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x00127450
XOR EBP,EBP
MOV RSI,qword ptr [0x00221ff0]
MOV RDX,qword ptr [0x00221f58]
MOV RDI,RBX
CALL 0x001275b0
|
/* minja::Value::at(minja::Value const&) */
void __thiscall minja::Value::at(Value *this,Value *param_1)
{
vector<minja::Value,std::allocator<minja::Value>> *this_00;
runtime_error *prVar1;
char cVar2;
int iVar3;
int1 local_60 [32];
string local_40 [32];
cVar2 = is_primitive(param_1);
if (cVar2 == '\0') {
prVar1 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00189abc to 00189acd has its CatchHandler @ 00189b95 */
dump_abi_cxx11_((int)local_60,SUB81(this,0));
/* try { // try from 00189ace to 00189ae3 has its CatchHandler @ 00189b7e */
std::operator+((char *)local_40,(string *)"Unashable type: ");
/* try { // try from 00189ae7 to 00189b0b has its CatchHandler @ 00189b6f */
std::runtime_error::runtime_error(prVar1,local_40);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar1,PTR_typeinfo_00221ff0,PTR__runtime_error_00221f58);
}
this_00 = *(vector<minja::Value,std::allocator<minja::Value>> **)(this + 0x10);
if (this_00 != (vector<minja::Value,std::allocator<minja::Value>> *)0x0) {
iVar3 = get<int>(param_1);
std::vector<minja::Value,std::allocator<minja::Value>>::at(this_00,(long)iVar3);
return;
}
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) {
nlohmann::json_abi_v3_11_3::
ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::at(*(ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
**)(this + 0x20),param_1 + 0x40);
return;
}
prVar1 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00189b19 to 00189b2a has its CatchHandler @ 00189b6d */
dump_abi_cxx11_((int)local_60,SUB81(this,0));
/* try { // try from 00189b2b to 00189b40 has its CatchHandler @ 00189b6b */
std::operator+((char *)local_40,(string *)"Value is not an array or object: ");
/* try { // try from 00189b44 to 00189b68 has its CatchHandler @ 00189b69 */
std::runtime_error::runtime_error(prVar1,local_40);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar1,PTR_typeinfo_00221ff0,PTR__runtime_error_00221f58);
}
|
|
19,862
|
minja::Value::at(minja::Value const&)
|
monkey531[P]llama/common/minja.hpp
|
Value& at(const Value & index) {
if (!index.is_hashable()) throw std::runtime_error("Unashable type: " + dump());
if (is_array()) return array_->at(index.get<int>());
if (is_object()) return object_->at(index.primitive_);
throw std::runtime_error("Value is not an array or object: " + dump());
}
|
O3
|
cpp
|
minja::Value::at(minja::Value const&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpq $0x0, 0x10(%rsi)
jne 0xb7441
cmpq $0x0, 0x20(%rsi)
jne 0xb7441
cmpq $0x0, 0x30(%rsi)
jne 0xb7441
movq 0x10(%r14), %rbx
testq %rbx, %rbx
je 0xb7427
movq %rsi, %rdi
callq 0xb4a00
movslq %eax, %rsi
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0xb749e
leaq (%rsi,%rsi,4), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0xb74ac
addq $0x40, %rsi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xb8960
movl $0x10, %edi
callq 0x1d5b0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0xaa67c
leaq 0x5e481(%rip), %rsi # 0x1158e8
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x9cdd5
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x1e430
xorl %ebp, %ebp
movq 0x9eb5b(%rip), %rsi # 0x155fe8
movq 0x9eac4(%rip), %rdx # 0x155f58
movq %rbx, %rdi
callq 0x1e5b0
jmp 0xb7507
leaq 0x5e5b1(%rip), %rdi # 0x115a56
xorl %eax, %eax
callq 0x1e2b0
movl $0x10, %edi
callq 0x1d5b0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0xaa67c
leaq 0x5e562(%rip), %rsi # 0x115a34
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x9cdd5
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x1e430
xorl %ebp, %ebp
movq 0x9eaf0(%rip), %rsi # 0x155fe8
movq 0x9ea59(%rip), %rdx # 0x155f58
movq %rbx, %rdi
callq 0x1e5b0
jmp 0xb750d
jmp 0xb754d
jmp 0xb756d
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb752b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1dc50
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb7546
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1dc50
testb %bpl, %bpl
jne 0xb7570
jmp 0xb7578
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb7570
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1dc50
jmp 0xb7570
movq %rax, %r14
movq %rbx, %rdi
callq 0x1d8c0
movq %r14, %rdi
callq 0x1e660
|
_ZN5minja5Value2atERKS0_:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rdi
cmp qword ptr [rsi+10h], 0
jnz short loc_B7441
cmp qword ptr [rsi+20h], 0
jnz short loc_B7441
cmp qword ptr [rsi+30h], 0
jnz short loc_B7441
mov rbx, [r14+10h]
test rbx, rbx
jz short loc_B7427
mov rdi, rsi
call _ZNK5minja5Value3getIiEET_v; minja::Value::get<int>(void)
movsxd rsi, eax
mov rax, [rbx]
mov rcx, [rbx+8]
sub rcx, rax
sar rcx, 4
mov rdx, 0CCCCCCCCCCCCCCCDh
imul rdx, rcx
cmp rdx, rsi
jbe loc_B749E
lea rcx, [rsi+rsi*4]
shl rcx, 4
add rax, rcx
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
loc_B7427:
mov rdi, [r14+20h]
test rdi, rdi
jz short loc_B74AC
add rsi, 40h ; '@'
add rsp, 40h
pop rbx
pop r14
pop rbp
jmp _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atERSJ_; nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>::at(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
loc_B7441:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aUnashableType; "Unashable type: "
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_B7507
loc_B749E:
lea rdi, aVectorMRangeCh; "vector::_M_range_check: __n (which is %"...
xor eax, eax
call __ZSt24__throw_out_of_range_fmtPKcz; std::__throw_out_of_range_fmt(char const*,...)
loc_B74AC:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aValueIsNotAnAr_0; "Value is not an array or object: "
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_B7507:
jmp short loc_B750D
jmp short loc_B754D
jmp short loc_B756D
loc_B750D:
mov r14, rax
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_B752B
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B752B:
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_B7546
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B7546:
test bpl, bpl
jnz short loc_B7570
jmp short loc_B7578
loc_B754D:
mov r14, rax
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_B7570
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_B7570
loc_B756D:
mov r14, rax
loc_B7570:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_B7578:
mov rdi, r14
call __Unwind_Resume
|
unsigned long long minja::Value::at(minja::Value *this, const minja::Value *a2)
{
_QWORD *v3; // rbx
unsigned long long v4; // rsi
unsigned long long v5; // rdx
long long v7; // rdi
void *exception; // rbx
void *v9; // rbx
_BYTE v10[16]; // [rsp+0h] [rbp-58h] BYREF
_BYTE v11[16]; // [rsp+20h] [rbp-38h] BYREF
if ( *((_QWORD *)a2 + 2) || *((_QWORD *)a2 + 4) || *((_QWORD *)a2 + 6) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v10, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v11, (long long)"Unashable type: ", (long long)v10);
std::runtime_error::runtime_error(exception, v11);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v3 = (_QWORD *)*((_QWORD *)this + 2);
if ( v3 )
{
v4 = (int)minja::Value::get<int>(a2);
v5 = 0xCCCCCCCCCCCCCCCDLL * ((long long)(v3[1] - *v3) >> 4);
if ( v5 <= v4 )
std::__throw_out_of_range_fmt("vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)", v4, v5);
return 80 * v4 + *v3;
}
else
{
v7 = *((_QWORD *)this + 4);
if ( !v7 )
{
v9 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v10, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v11, (long long)"Value is not an array or object: ", (long long)v10);
std::runtime_error::runtime_error(v9, v11);
__cxa_throw(
v9,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::at(
v7,
(char *)a2 + 64);
}
}
|
at:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
CMP qword ptr [RSI + 0x10],0x0
JNZ 0x001b7441
CMP qword ptr [RSI + 0x20],0x0
JNZ 0x001b7441
CMP qword ptr [RSI + 0x30],0x0
JNZ 0x001b7441
MOV RBX,qword ptr [R14 + 0x10]
TEST RBX,RBX
JZ 0x001b7427
MOV RDI,RSI
CALL 0x001b4a00
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [RBX + 0x8]
SUB RCX,RAX
SAR RCX,0x4
MOV RDX,-0x3333333333333333
IMUL RDX,RCX
CMP RDX,RSI
JBE 0x001b749e
LEA RCX,[RSI + RSI*0x4]
SHL RCX,0x4
ADD RAX,RCX
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
LAB_001b7427:
MOV RDI,qword ptr [R14 + 0x20]
TEST RDI,RDI
JZ 0x001b74ac
ADD RSI,0x40
ADD RSP,0x40
POP RBX
POP R14
POP RBP
JMP 0x001b8960
LAB_001b7441:
MOV EDI,0x10
CALL 0x0011d5b0
MOV RBX,RAX
LAB_001b744e:
MOV RDI,RSP
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001aa67c
LAB_001b7460:
LEA RSI,[0x2158e8]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x0019cdd5
MOV BPL,0x1
LAB_001b7477:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x0011e430
XOR EBP,EBP
MOV RSI,qword ptr [0x00255fe8]
MOV RDX,qword ptr [0x00255f58]
MOV RDI,RBX
CALL 0x0011e5b0
LAB_001b749e:
LEA RDI,[0x215a56]
XOR EAX,EAX
CALL 0x0011e2b0
LAB_001b74ac:
MOV EDI,0x10
CALL 0x0011d5b0
MOV RBX,RAX
LAB_001b74b9:
MOV RDI,RSP
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001aa67c
LAB_001b74cb:
LEA RSI,[0x215a34]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x0019cdd5
MOV BPL,0x1
LAB_001b74e2:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x0011e430
XOR EBP,EBP
MOV RSI,qword ptr [0x00255fe8]
MOV RDX,qword ptr [0x00255f58]
MOV RDI,RBX
CALL 0x0011e5b0
|
/* minja::Value::at(minja::Value const&) */
long __thiscall minja::Value::at(Value *this,Value *param_1)
{
long *plVar1;
int iVar2;
long lVar3;
runtime_error *prVar4;
ulong uVar5;
ulong uVar6;
int1 auStack_58 [32];
string local_38 [32];
if (((*(long *)(param_1 + 0x10) == 0) && (*(long *)(param_1 + 0x20) == 0)) &&
(*(long *)(param_1 + 0x30) == 0)) {
plVar1 = *(long **)(this + 0x10);
if (plVar1 == (long *)0x0) {
if (*(ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
**)(this + 0x20) !=
(ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*)0x0) {
lVar3 = nlohmann::json_abi_v3_11_3::
ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::at(*(ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
**)(this + 0x20),(basic_json *)(param_1 + 0x40));
return lVar3;
}
}
else {
iVar2 = get<int>(param_1);
uVar6 = (ulong)iVar2;
uVar5 = (plVar1[1] - *plVar1 >> 4) * -0x3333333333333333;
if (uVar6 <= uVar5 && uVar5 - uVar6 != 0) {
return *plVar1 + uVar6 * 0x50;
}
std::__throw_out_of_range_fmt
("vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)");
}
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001b74b9 to 001b74ca has its CatchHandler @ 001b750b */
dump_abi_cxx11_((int)auStack_58,SUB81(this,0));
/* try { // try from 001b74cb to 001b74de has its CatchHandler @ 001b7509 */
std::operator+((char *)local_38,(string *)"Value is not an array or object: ");
/* try { // try from 001b74e2 to 001b7506 has its CatchHandler @ 001b7507 */
std::runtime_error::runtime_error(prVar4,local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_00255fe8,PTR__runtime_error_00255f58);
}
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001b744e to 001b745f has its CatchHandler @ 001b756d */
dump_abi_cxx11_((int)auStack_58,SUB81(this,0));
/* try { // try from 001b7460 to 001b7473 has its CatchHandler @ 001b754d */
std::operator+((char *)local_38,(string *)"Unashable type: ");
/* try { // try from 001b7477 to 001b749b has its CatchHandler @ 001b750d */
std::runtime_error::runtime_error(prVar4,local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_00255fe8,PTR__runtime_error_00255f58);
}
|
|
19,863
|
js_ecvt1
|
bluesky950520[P]quickjs/quickjs.c
|
static int js_ecvt1(double d, int n_digits,
char dest[minimum_length(JS_ECVT_BUF_SIZE)],
size_t size, int *decpt)
{
/* d is positive, ensure decimal point is always present */
snprintf(dest, size, "%#.*e", n_digits - 1, d);
/* dest contents:
0: first digit
1: '.' decimal point (locale specific)
2..n_digits: (n_digits-1) additional digits
n_digits+1: 'e' exponent mark
n_digits+2..: exponent sign, value and null terminator
*/
/* extract the exponent (actually the position of the decimal point) */
*decpt = 1 + atoi(dest + n_digits + 2);
return n_digits;
}
|
O0
|
c
|
js_ecvt1:
subq $0x28, %rsp
movsd %xmm0, 0x20(%rsp)
movl %edi, 0x1c(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
movsd 0x20(%rsp), %xmm0
leaq 0xab4f8(%rip), %rdx # 0x10cac2
movb $0x1, %al
callq 0xe2d0
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rax
addq %rax, %rdi
addq $0x2, %rdi
callq 0xe850
movl %eax, %ecx
addl $0x1, %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
|
js_ecvt1:
sub rsp, 28h
movsd [rsp+28h+var_8], xmm0
mov [rsp+28h+var_C], edi
mov [rsp+28h+var_18], rsi
mov [rsp+28h+var_20], rdx
mov [rsp+28h+var_28], rcx
mov rdi, [rsp+28h+var_18]
mov rsi, [rsp+28h+var_20]
mov ecx, [rsp+28h+var_C]
sub ecx, 1
movsd xmm0, [rsp+28h+var_8]
lea rdx, aE; "%#.*e"
mov al, 1
call _snprintf
mov rdi, [rsp+28h+var_18]
movsxd rax, [rsp+28h+var_C]
add rdi, rax
add rdi, 2
call _atoi
mov ecx, eax
add ecx, 1
mov rax, [rsp+28h+var_28]
mov [rax], ecx
mov eax, [rsp+28h+var_C]
add rsp, 28h
retn
|
long long js_ecvt1(unsigned int a1, long long a2, long long a3, _DWORD *a4, double a5)
{
snprintf(a2, a3, "%#.*e", a1 - 1, a5);
*a4 = atoi((int)a1 + a2 + 2) + 1;
return a1;
}
|
js_ecvt1:
SUB RSP,0x28
MOVSD qword ptr [RSP + 0x20],XMM0
MOV dword ptr [RSP + 0x1c],EDI
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RSP + 0x8],RDX
MOV qword ptr [RSP],RCX
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x8]
MOV ECX,dword ptr [RSP + 0x1c]
SUB ECX,0x1
MOVSD XMM0,qword ptr [RSP + 0x20]
LEA RDX,[0x20cac2]
MOV AL,0x1
CALL 0x0010e2d0
MOV RDI,qword ptr [RSP + 0x10]
MOVSXD RAX,dword ptr [RSP + 0x1c]
ADD RDI,RAX
ADD RDI,0x2
CALL 0x0010e850
MOV ECX,EAX
ADD ECX,0x1
MOV RAX,qword ptr [RSP]
MOV dword ptr [RAX],ECX
MOV EAX,dword ptr [RSP + 0x1c]
ADD RSP,0x28
RET
|
int js_ecvt1(int8 param_1,int param_2,char *param_3,size_t param_4,int *param_5)
{
int iVar1;
snprintf(param_3,param_4,"%#.*e",param_1,(ulong)(param_2 - 1));
iVar1 = atoi(param_3 + (long)param_2 + 2);
*param_5 = iVar1 + 1;
return param_2;
}
|
|
19,864
|
maria_rtree_set_key_mbr
|
eloqsql/storage/maria/ma_rt_key.c
|
int maria_rtree_set_key_mbr(MARIA_HA *info, MARIA_KEY *key,
my_off_t child_page)
{
MARIA_PAGE page;
DBUG_ENTER("maria_rtree_set_key_mbr");
if (_ma_fetch_keypage(&page, info, key->keyinfo, child_page,
PAGECACHE_LOCK_LEFT_UNLOCKED,
DFLT_INIT_HITS, info->buff, 0))
DBUG_RETURN(-1);
DBUG_RETURN(maria_rtree_page_mbr(key->keyinfo->seg,
&page, key->data, key->data_length));
}
|
O3
|
c
|
maria_rtree_set_key_mbr:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rcx
movq %rsi, %rbx
movq %rdi, %rsi
movq 0x8(%rbx), %rdx
leaq -0x40(%rbp), %rdi
xorl %r8d, %r8d
movl $0x3, %r9d
pushq $0x0
pushq 0x378(%rsi)
callq 0x58a4e
addq $0x10, %rsp
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testb %cl, %cl
jne 0x6cb74
movq (%rbx), %rdx
movq 0x8(%rbx), %rax
movq 0xc0(%rax), %rdi
movl 0x10(%rbx), %ecx
leaq -0x40(%rbp), %rsi
callq 0x6ef1e
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
nop
|
maria_rtree_set_key_mbr:
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov rcx, rdx
mov rbx, rsi
mov rsi, rdi
mov rdx, [rbx+8]
lea rdi, [rbp+var_40]
xor r8d, r8d
mov r9d, 3
push 0
push qword ptr [rsi+378h]
call _ma_fetch_keypage
add rsp, 10h
mov ecx, eax
mov eax, 0FFFFFFFFh
test cl, cl
jnz short loc_6CB74
mov rdx, [rbx]
mov rax, [rbx+8]
mov rdi, [rax+0C0h]
mov ecx, [rbx+10h]
lea rsi, [rbp+var_40]
call maria_rtree_page_mbr
loc_6CB74:
add rsp, 38h
pop rbx
pop rbp
retn
|
long long maria_rtree_set_key_mbr(long long a1, long long a2, unsigned long long a3)
{
char keypage; // cl
long long result; // rax
_BYTE v5[64]; // [rsp+0h] [rbp-40h] BYREF
keypage = ma_fetch_keypage((long long)v5, a1, *(_QWORD *)(a2 + 8), a3, 0, 3, *(_QWORD *)(a1 + 888));
result = 0xFFFFFFFFLL;
if ( !keypage )
return maria_rtree_page_mbr(*(_QWORD *)(*(_QWORD *)(a2 + 8) + 192LL), v5, *(_QWORD *)a2, *(unsigned int *)(a2 + 16));
return result;
}
|
maria_rtree_set_key_mbr:
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV RCX,RDX
MOV RBX,RSI
MOV RSI,RDI
MOV RDX,qword ptr [RBX + 0x8]
LEA RDI,[RBP + -0x40]
XOR R8D,R8D
MOV R9D,0x3
PUSH 0x0
PUSH qword ptr [RSI + 0x378]
CALL 0x00158a4e
ADD RSP,0x10
MOV ECX,EAX
MOV EAX,0xffffffff
TEST CL,CL
JNZ 0x0016cb74
MOV RDX,qword ptr [RBX]
MOV RAX,qword ptr [RBX + 0x8]
MOV RDI,qword ptr [RAX + 0xc0]
MOV ECX,dword ptr [RBX + 0x10]
LEA RSI,[RBP + -0x40]
CALL 0x0016ef1e
LAB_0016cb74:
ADD RSP,0x38
POP RBX
POP RBP
RET
|
int8 maria_rtree_set_key_mbr(long param_1,int8 *param_2,int8 param_3)
{
char cVar1;
int8 uVar2;
int1 local_48 [56];
cVar1 = _ma_fetch_keypage(local_48,param_1,param_2[1],param_3,0,3,*(int8 *)(param_1 + 0x378)
,0);
uVar2 = 0xffffffff;
if (cVar1 == '\0') {
uVar2 = maria_rtree_page_mbr
(*(int8 *)(param_2[1] + 0xc0),local_48,*param_2,
*(int4 *)(param_2 + 2));
}
return uVar2;
}
|
|
19,865
|
my_hash_sort_simple
|
eloqsql/strings/ctype-simple.c
|
void my_hash_sort_simple(CHARSET_INFO *cs,
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
register const uchar *sort_order=cs->sort_order;
const uchar *end;
uint16 space_weight= sort_order[' '];
/*
Remove all trailing characters that are equal to space.
We have to do this to be able to compare 'A ' and 'A' as identical.
If the key is long enough, cut the trailing spaces (0x20) using an
optimized function implemented in skip_trailing_spaces().
"len > 16" is just some heuristic here.
Calling skip_triling_space() for short values is not desirable,
because its initialization block may be more expensive than the
performance gained.
*/
end= len > 16 ? skip_trailing_space(key, len) : key + len;
/*
We removed all trailing characters that are binary equal to space 0x20.
Now remove all trailing characters that have weights equal to space.
Some 8bit simple collations may have such characters:
- cp1250_general_ci 0xA0 NO-BREAK SPACE == 0x20 SPACE
- cp1251_ukrainian_ci 0x60 GRAVE ACCENT == 0x20 SPACE
- koi8u_general_ci 0x60 GRAVE ACCENT == 0x20 SPACE
*/
for ( ; key < end ; )
{
if (sort_order[*--end] != space_weight)
{
end++;
break;
}
}
my_hash_sort_simple_nopad(cs, key, end - key, nr1, nr2);
}
|
O3
|
c
|
my_hash_sort_simple:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq 0x58(%rdi), %rax
leaq (%rsi,%rdx), %rdi
cmpq $0x11, %rdx
jb 0x70cf9
cmpq $0x15, %rdx
jb 0x70ce4
movq %rdi, %r10
andq $-0x4, %r10
cmpq %rsi, %r10
jbe 0x70ce4
leaq 0x3(%rsi), %r9
andq $-0x4, %r9
movq %rdi, %rdx
movb -0x1(%rdi), %r11b
cmpq %r10, %rdi
jbe 0x70d64
leaq -0x1(%rdx), %rdi
cmpb $0x20, %r11b
je 0x70cc8
jmp 0x70ce7
movq %rdi, %rdx
movq %rdx, %rdi
cmpq %rsi, %rdx
jbe 0x70cf9
leaq -0x1(%rdi), %rdx
cmpb $0x20, -0x1(%rdi)
je 0x70ce7
movb 0x20(%rax), %r9b
movq %rdi, %r11
subq %rsi, %r11
movq %rdi, %rdx
movq %r11, %r10
cmpq %rsi, %rdi
jbe 0x70d20
leaq -0x1(%rdx), %rdi
movzbl -0x1(%rdx), %ebx
leaq -0x1(%r10), %r11
cmpb %r9b, (%rax,%rbx)
je 0x70d03
movq (%rcx), %rdi
movq (%r8), %r9
testq %r10, %r10
jle 0x70d5b
movl %edi, %r10d
andl $0x3f, %r10d
addq %r9, %r10
movzbl (%rsi), %r11d
movzbl (%rax,%r11), %r11d
imulq %r10, %r11
movq %rdi, %r10
shlq $0x8, %r10
addq %r11, %r10
xorq %r10, %rdi
addq $0x3, %r9
incq %rsi
cmpq %rdx, %rsi
jb 0x70d2b
movq %rdi, (%rcx)
movq %r9, (%r8)
popq %rbx
popq %rbp
retq
cmpb $0x20, %r11b
setne %dil
cmpq %r10, %r9
setae %r10b
orb %dil, %r10b
jne 0x70ce7
movq %rdx, %rdi
movq %rdi, %rdx
cmpq %r9, %rdi
jbe 0x70ce7
leaq -0x4(%rdx), %rdi
cmpl $0x20202020, -0x4(%rdx) # imm = 0x20202020
je 0x70d7f
jmp 0x70ce7
|
my_hash_sort_simple:
push rbp
mov rbp, rsp
push rbx
mov rax, [rdi+58h]
lea rdi, [rsi+rdx]
cmp rdx, 11h
jb short loc_70CF9
cmp rdx, 15h
jb short loc_70CE4
mov r10, rdi
and r10, 0FFFFFFFFFFFFFFFCh
cmp r10, rsi
jbe short loc_70CE4
lea r9, [rsi+3]
and r9, 0FFFFFFFFFFFFFFFCh
loc_70CC8:
mov rdx, rdi
mov r11b, [rdi-1]
cmp rdi, r10
jbe loc_70D64
lea rdi, [rdx-1]
cmp r11b, 20h ; ' '
jz short loc_70CC8
jmp short loc_70CE7
loc_70CE4:
mov rdx, rdi
loc_70CE7:
mov rdi, rdx
cmp rdx, rsi
jbe short loc_70CF9
lea rdx, [rdi-1]
cmp byte ptr [rdi-1], 20h ; ' '
jz short loc_70CE7
loc_70CF9:
mov r9b, [rax+20h]
mov r11, rdi
sub r11, rsi
loc_70D03:
mov rdx, rdi
mov r10, r11
cmp rdi, rsi
jbe short loc_70D20
lea rdi, [rdx-1]
movzx ebx, byte ptr [rdx-1]
lea r11, [r10-1]
cmp [rax+rbx], r9b
jz short loc_70D03
loc_70D20:
mov rdi, [rcx]
mov r9, [r8]
test r10, r10
jle short loc_70D5B
loc_70D2B:
mov r10d, edi
and r10d, 3Fh
add r10, r9
movzx r11d, byte ptr [rsi]
movzx r11d, byte ptr [rax+r11]
imul r11, r10
mov r10, rdi
shl r10, 8
add r10, r11
xor rdi, r10
add r9, 3
inc rsi
cmp rsi, rdx
jb short loc_70D2B
loc_70D5B:
mov [rcx], rdi
mov [r8], r9
pop rbx
pop rbp
retn
loc_70D64:
cmp r11b, 20h ; ' '
setnz dil
cmp r9, r10
setnb r10b
or r10b, dil
jnz loc_70CE7
mov rdi, rdx
loc_70D7F:
mov rdx, rdi
cmp rdi, r9
jbe loc_70CE7
lea rdi, [rdx-4]
cmp dword ptr [rdx-4], 20202020h
jz short loc_70D7F
jmp loc_70CE7
|
long long my_hash_sort_simple(long long a1, unsigned __int8 *a2, unsigned long long a3, long long *a4, long long *a5)
{
long long result; // rax
unsigned long long v6; // rdi
unsigned long long v7; // r10
unsigned long long v8; // r9
unsigned __int8 *v9; // rdx
char v10; // r11
long long v11; // r11
unsigned long long v12; // rdx
long long v13; // r10
long long v14; // rdi
long long v15; // r9
result = *(_QWORD *)(a1 + 88);
v6 = (unsigned long long)&a2[a3];
if ( a3 >= 0x11 )
{
if ( a3 < 0x15 || (v7 = v6 & 0xFFFFFFFFFFFFFFFCLL, (v6 & 0xFFFFFFFFFFFFFFFCLL) <= (unsigned long long)a2) )
{
v9 = &a2[a3];
}
else
{
v8 = (unsigned long long)(a2 + 3) & 0xFFFFFFFFFFFFFFFCLL;
while ( 1 )
{
v9 = (unsigned __int8 *)v6;
v10 = *(_BYTE *)(v6 - 1);
if ( v6 <= v7 )
break;
--v6;
if ( v10 != 32 )
goto LABEL_9;
}
if ( v10 == 32 && v8 < v7 )
{
do
{
v9 = (unsigned __int8 *)v6;
if ( v6 <= v8 )
break;
v6 -= 4LL;
}
while ( *((_DWORD *)v9 - 1) == 538976288 );
}
}
do
{
LABEL_9:
v6 = (unsigned long long)v9;
if ( v9 <= a2 )
break;
--v9;
}
while ( *(_BYTE *)(v6 - 1) == 32 );
}
v11 = v6 - (_QWORD)a2;
do
{
v12 = v6;
v13 = v11;
if ( v6 <= (unsigned long long)a2 )
break;
--v6;
--v11;
}
while ( *(_BYTE *)(result + *(unsigned __int8 *)(v12 - 1)) == *(_BYTE *)(result + 32) );
v14 = *a4;
v15 = *a5;
if ( v13 > 0 )
{
do
{
v14 ^= (v15 + (v14 & 0x3F)) * *(unsigned __int8 *)(result + *a2) + (v14 << 8);
v15 += 3LL;
++a2;
}
while ( (unsigned long long)a2 < v12 );
}
*a4 = v14;
*a5 = v15;
return result;
}
|
my_hash_sort_simple:
PUSH RBP
MOV RBP,RSP
PUSH RBX
MOV RAX,qword ptr [RDI + 0x58]
LEA RDI,[RSI + RDX*0x1]
CMP RDX,0x11
JC 0x00170cf9
CMP RDX,0x15
JC 0x00170ce4
MOV R10,RDI
AND R10,-0x4
CMP R10,RSI
JBE 0x00170ce4
LEA R9,[RSI + 0x3]
AND R9,-0x4
LAB_00170cc8:
MOV RDX,RDI
MOV R11B,byte ptr [RDI + -0x1]
CMP RDI,R10
JBE 0x00170d64
LEA RDI,[RDX + -0x1]
CMP R11B,0x20
JZ 0x00170cc8
JMP 0x00170ce7
LAB_00170ce4:
MOV RDX,RDI
LAB_00170ce7:
MOV RDI,RDX
CMP RDX,RSI
JBE 0x00170cf9
LEA RDX,[RDI + -0x1]
CMP byte ptr [RDI + -0x1],0x20
JZ 0x00170ce7
LAB_00170cf9:
MOV R9B,byte ptr [RAX + 0x20]
MOV R11,RDI
SUB R11,RSI
LAB_00170d03:
MOV RDX,RDI
MOV R10,R11
CMP RDI,RSI
JBE 0x00170d20
LEA RDI,[RDX + -0x1]
MOVZX EBX,byte ptr [RDX + -0x1]
LEA R11,[R10 + -0x1]
CMP byte ptr [RAX + RBX*0x1],R9B
JZ 0x00170d03
LAB_00170d20:
MOV RDI,qword ptr [RCX]
MOV R9,qword ptr [R8]
TEST R10,R10
JLE 0x00170d5b
LAB_00170d2b:
MOV R10D,EDI
AND R10D,0x3f
ADD R10,R9
MOVZX R11D,byte ptr [RSI]
MOVZX R11D,byte ptr [RAX + R11*0x1]
IMUL R11,R10
MOV R10,RDI
SHL R10,0x8
ADD R10,R11
XOR RDI,R10
ADD R9,0x3
INC RSI
CMP RSI,RDX
JC 0x00170d2b
LAB_00170d5b:
MOV qword ptr [RCX],RDI
MOV qword ptr [R8],R9
POP RBX
POP RBP
RET
LAB_00170d64:
CMP R11B,0x20
SETNZ DIL
CMP R9,R10
SETNC R10B
OR R10B,DIL
JNZ 0x00170ce7
MOV RDI,RDX
LAB_00170d7f:
MOV RDX,RDI
CMP RDI,R9
JBE 0x00170ce7
LEA RDI,[RDX + -0x4]
CMP dword ptr [RDX + -0x4],0x20202020
JZ 0x00170d7f
JMP 0x00170ce7
|
void my_hash_sort_simple(long param_1,byte *param_2,ulong param_3,ulong *param_4,long *param_5)
{
byte *pbVar1;
long lVar2;
byte *pbVar3;
ulong uVar4;
byte *pbVar5;
long lVar6;
byte *pbVar7;
long lVar8;
lVar2 = *(long *)(param_1 + 0x58);
pbVar5 = param_2 + param_3;
if (param_3 < 0x11) goto LAB_00170cf9;
pbVar3 = pbVar5;
if ((0x14 < param_3) && (pbVar7 = (byte *)((ulong)pbVar5 & 0xfffffffffffffffc), param_2 < pbVar7))
{
do {
pbVar1 = pbVar5 + -1;
pbVar3 = pbVar5;
if (pbVar5 <= pbVar7) {
if ((byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc) < pbVar7 && *pbVar1 == 0x20)
goto LAB_00170d7f;
break;
}
pbVar5 = pbVar5 + -1;
} while (*pbVar1 == 0x20);
}
goto LAB_00170ce7;
while (pbVar7 = pbVar5 + -4, pbVar5 = pbVar5 + -4, *(int *)pbVar7 == 0x20202020) {
LAB_00170d7f:
pbVar3 = pbVar5;
if (pbVar5 <= (byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc)) break;
}
LAB_00170ce7:
do {
pbVar5 = pbVar3;
if (pbVar5 <= param_2) break;
pbVar3 = pbVar5 + -1;
} while (pbVar5[-1] == 0x20);
LAB_00170cf9:
lVar6 = (long)pbVar5 - (long)param_2;
do {
lVar8 = lVar6;
pbVar3 = pbVar5;
if (pbVar3 <= param_2) break;
pbVar5 = pbVar3 + -1;
lVar6 = lVar8 + -1;
} while (*(char *)(lVar2 + (ulong)pbVar3[-1]) == *(char *)(lVar2 + 0x20));
uVar4 = *param_4;
lVar6 = *param_5;
if (0 < lVar8) {
do {
uVar4 = uVar4 ^ uVar4 * 0x100 +
(ulong)*(byte *)(lVar2 + (ulong)*param_2) *
((ulong)((uint)uVar4 & 0x3f) + lVar6);
lVar6 = lVar6 + 3;
param_2 = param_2 + 1;
} while (param_2 < pbVar3);
}
*param_4 = uVar4;
*param_5 = lVar6;
return;
}
|
|
19,866
|
js_function_toString
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_function_toString(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSObject *p;
JSFunctionKindEnum func_kind = JS_FUNC_NORMAL;
if (check_function(ctx, this_val))
return JS_EXCEPTION;
p = JS_VALUE_GET_OBJ(this_val);
if (js_class_has_bytecode(p->class_id)) {
JSFunctionBytecode *b = p->u.func.function_bytecode;
/* `b->source` must be pure ASCII or UTF-8 encoded */
if (b->source)
return JS_NewStringLen(ctx, b->source, b->source_len);
}
{
JSValue name;
const char *pref, *suff;
switch(func_kind) {
default:
case JS_FUNC_NORMAL:
pref = "function ";
break;
case JS_FUNC_GENERATOR:
pref = "function *";
break;
case JS_FUNC_ASYNC:
pref = "async function ";
break;
case JS_FUNC_ASYNC_GENERATOR:
pref = "async function *";
break;
}
suff = "() {\n [native code]\n}";
name = JS_GetProperty(ctx, this_val, JS_ATOM_name);
if (JS_IsUndefined(name))
name = JS_AtomToString(ctx, JS_ATOM_empty_string);
return JS_ConcatString3(ctx, pref, name, suff);
}
}
|
O0
|
c
|
js_function_toString:
subq $0x98, %rsp
movq %rsi, 0x78(%rsp)
movq %rdx, 0x80(%rsp)
movq %rdi, 0x70(%rsp)
movl %ecx, 0x6c(%rsp)
movq %r8, 0x60(%rsp)
movl $0x0, 0x54(%rsp)
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rdx
callq 0x73d70
cmpl $0x0, %eax
je 0xc89e2
movl $0x0, 0x88(%rsp)
movq $0x6, 0x90(%rsp)
jmp 0xc8b61
movq 0x78(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movzwl 0x6(%rax), %edi
callq 0x50530
cmpl $0x0, %eax
je 0xc8a52
movq 0x58(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
cmpq $0x0, 0x88(%rax)
je 0xc8a50
movq 0x70(%rsp), %rdi
movq 0x48(%rsp), %rax
movq 0x88(%rax), %rsi
movq 0x48(%rsp), %rax
movslq 0x74(%rax), %rdx
callq 0x2e560
movq %rax, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
jmp 0xc8b61
jmp 0xc8a52
movl 0x54(%rsp), %eax
movq %rax, (%rsp)
subq $0x3, %rax
ja 0xc8a74
movq (%rsp), %rax
leaq 0x49e61(%rip), %rcx # 0x1128cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xc8a76
leaq 0x4e2d4(%rip), %rax # 0x116d51
movq %rax, 0x30(%rsp)
jmp 0xc8aac
leaq 0x4e2d6(%rip), %rax # 0x116d61
movq %rax, 0x30(%rsp)
jmp 0xc8aac
leaq 0x4e2b2(%rip), %rax # 0x116d4b
movq %rax, 0x30(%rsp)
jmp 0xc8aac
leaq 0x4e2b4(%rip), %rax # 0x116d5b
movq %rax, 0x30(%rsp)
leaq 0x4e2b9(%rip), %rax # 0x116d6c
movq %rax, 0x28(%rsp)
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rdx
movl $0x37, %ecx
callq 0x30070
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x34550
cmpl $0x0, %eax
je 0xc8b33
movq 0x70(%rsp), %rdi
movl $0x2f, %esi
callq 0x2f2f0
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x70(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %r8
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0x75c60
movq %rax, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
movq 0x88(%rsp), %rax
movq 0x90(%rsp), %rdx
addq $0x98, %rsp
retq
nopl (%rax)
|
js_function_toString:
sub rsp, 98h
mov [rsp+98h+var_20], rsi
mov [rsp+98h+var_18], rdx
mov [rsp+98h+var_28], rdi
mov [rsp+98h+var_2C], ecx
mov [rsp+98h+var_38], r8
mov [rsp+98h+var_44], 0
mov rdi, [rsp+98h+var_28]
mov rsi, [rsp+98h+var_20]
mov rdx, [rsp+98h+var_18]
call check_function
cmp eax, 0
jz short loc_C89E2
mov dword ptr [rsp+98h+var_10], 0
mov [rsp+98h+var_8], 6
jmp loc_C8B61
loc_C89E2:
mov rax, [rsp+98h+var_20]
mov [rsp+98h+var_40], rax
mov rax, [rsp+98h+var_40]
movzx edi, word ptr [rax+6]
call js_class_has_bytecode
cmp eax, 0
jz short loc_C8A52
mov rax, [rsp+98h+var_40]
mov rax, [rax+30h]
mov [rsp+98h+var_50], rax
mov rax, [rsp+98h+var_50]
cmp qword ptr [rax+88h], 0
jz short loc_C8A50
mov rdi, [rsp+98h+var_28]
mov rax, [rsp+98h+var_50]
mov rsi, [rax+88h]
mov rax, [rsp+98h+var_50]
movsxd rdx, dword ptr [rax+74h]
call JS_NewStringLen
mov [rsp+98h+var_10], rax
mov [rsp+98h+var_8], rdx
jmp loc_C8B61
loc_C8A50:
jmp short $+2
loc_C8A52:
mov eax, [rsp+98h+var_44]
mov [rsp+98h+var_98], rax
sub rax, 3; switch 4 cases
ja short def_C8A72; jumptable 00000000000C8A72 default case
mov rax, [rsp+98h+var_98]
lea rcx, jpt_C8A72
movsxd rax, ds:(jpt_C8A72 - 1128CCh)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
def_C8A72:
jmp short $+2; jumptable 00000000000C8A72 default case
loc_C8A76:
lea rax, aAsyncFunction+6; jumptable 00000000000C8A72 case 0
mov [rsp+98h+var_68], rax
jmp short loc_C8AAC
loc_C8A84:
lea rax, aAsyncFunction_0+6; jumptable 00000000000C8A72 case 1
mov [rsp+98h+var_68], rax
jmp short loc_C8AAC
loc_C8A92:
lea rax, aAsyncFunction; jumptable 00000000000C8A72 case 2
mov [rsp+98h+var_68], rax
jmp short loc_C8AAC
loc_C8AA0:
lea rax, aAsyncFunction_0; jumptable 00000000000C8A72 case 3
mov [rsp+98h+var_68], rax
loc_C8AAC:
lea rax, aNativeCode; "() {\n [native code]\n}"
mov [rsp+98h+var_70], rax
mov rdi, [rsp+98h+var_28]
mov rsi, [rsp+98h+var_20]
mov rdx, [rsp+98h+var_18]
mov ecx, 37h ; '7'
call JS_GetProperty
mov [rsp+98h+var_80], rax
mov [rsp+98h+var_78], rdx
mov rax, [rsp+98h+var_80]
mov [rsp+98h+var_60], rax
mov rax, [rsp+98h+var_78]
mov [rsp+98h+var_58], rax
mov rdi, [rsp+98h+var_60]
mov rsi, [rsp+98h+var_58]
call JS_IsUndefined_1
cmp eax, 0
jz short loc_C8B33
mov rdi, [rsp+98h+var_28]
mov esi, 2Fh ; '/'
call JS_AtomToString
mov [rsp+98h+var_90], rax
mov [rsp+98h+var_88], rdx
mov rax, [rsp+98h+var_90]
mov [rsp+98h+var_60], rax
mov rax, [rsp+98h+var_88]
mov [rsp+98h+var_58], rax
loc_C8B33:
mov rdi, [rsp+98h+var_28]
mov rsi, [rsp+98h+var_68]
mov r8, [rsp+98h+var_70]
mov rdx, [rsp+98h+var_60]
mov rcx, [rsp+98h+var_58]
call JS_ConcatString3
mov [rsp+98h+var_10], rax
mov [rsp+98h+var_8], rdx
loc_C8B61:
mov rax, [rsp+98h+var_10]
mov rdx, [rsp+98h+var_8]
add rsp, 98h
retn
|
long long js_function_toString(
long long a1,
long long a2,
int a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
long long v11; // rdx
long long v12; // r9
long long v13; // rdx
long long Property; // [rsp+38h] [rbp-60h]
long long v16; // [rsp+40h] [rbp-58h]
long long v17; // [rsp+48h] [rbp-50h]
long long v19; // [rsp+88h] [rbp-10h]
if ( (unsigned int)check_function(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) )
{
LODWORD(v19) = 0;
}
else if ( js_class_has_bytecode(*(unsigned __int16 *)(a2 + 6)) && (v17 = *(_QWORD *)(a2 + 48), *(_QWORD *)(v17 + 136)) )
{
return JS_NewStringLen(a1, *(unsigned __int8 **)(v17 + 136), (unsigned __int8 *)*(int *)(v17 + 116));
}
else
{
Property = JS_GetProperty(a1, a2, a3, 55);
v16 = v11;
if ( JS_IsUndefined_1(Property, v11) )
{
Property = JS_AtomToString(a1, 0x2Fu);
v16 = v13;
}
return JS_ConcatString3(a1, (long long)"function ", Property, v16, (long long)"() {\n [native code]\n}", v12);
}
return v19;
}
|
js_function_toString:
SUB RSP,0x98
MOV qword ptr [RSP + 0x78],RSI
MOV qword ptr [RSP + 0x80],RDX
MOV qword ptr [RSP + 0x70],RDI
MOV dword ptr [RSP + 0x6c],ECX
MOV qword ptr [RSP + 0x60],R8
MOV dword ptr [RSP + 0x54],0x0
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x80]
CALL 0x00173d70
CMP EAX,0x0
JZ 0x001c89e2
MOV dword ptr [RSP + 0x88],0x0
MOV qword ptr [RSP + 0x90],0x6
JMP 0x001c8b61
LAB_001c89e2:
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOVZX EDI,word ptr [RAX + 0x6]
CALL 0x00150530
CMP EAX,0x0
JZ 0x001c8a52
MOV RAX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RSP + 0x48],RAX
MOV RAX,qword ptr [RSP + 0x48]
CMP qword ptr [RAX + 0x88],0x0
JZ 0x001c8a50
MOV RDI,qword ptr [RSP + 0x70]
MOV RAX,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RAX + 0x88]
MOV RAX,qword ptr [RSP + 0x48]
MOVSXD RDX,dword ptr [RAX + 0x74]
CALL 0x0012e560
MOV qword ptr [RSP + 0x88],RAX
MOV qword ptr [RSP + 0x90],RDX
JMP 0x001c8b61
LAB_001c8a50:
JMP 0x001c8a52
LAB_001c8a52:
MOV EAX,dword ptr [RSP + 0x54]
MOV qword ptr [RSP],RAX
SUB RAX,0x3
JA 0x001c8a74
MOV RAX,qword ptr [RSP]
LEA RCX,[0x2128cc]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
LAB_001c8a74:
JMP 0x001c8a76
caseD_0:
LEA RAX,[0x216d51]
MOV qword ptr [RSP + 0x30],RAX
JMP 0x001c8aac
caseD_1:
LEA RAX,[0x216d61]
MOV qword ptr [RSP + 0x30],RAX
JMP 0x001c8aac
caseD_2:
LEA RAX,[0x216d4b]
MOV qword ptr [RSP + 0x30],RAX
JMP 0x001c8aac
caseD_3:
LEA RAX,[0x216d5b]
MOV qword ptr [RSP + 0x30],RAX
LAB_001c8aac:
LEA RAX,[0x216d6c]
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x80]
MOV ECX,0x37
CALL 0x00130070
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x40],RAX
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x40]
CALL 0x00134550
CMP EAX,0x0
JZ 0x001c8b33
MOV RDI,qword ptr [RSP + 0x70]
MOV ESI,0x2f
CALL 0x0012f2f0
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x40],RAX
LAB_001c8b33:
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x30]
MOV R8,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x38]
MOV RCX,qword ptr [RSP + 0x40]
CALL 0x00175c60
MOV qword ptr [RSP + 0x88],RAX
MOV qword ptr [RSP + 0x90],RDX
LAB_001c8b61:
MOV RAX,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x90]
ADD RSP,0x98
RET
|
/* WARNING: Removing unreachable block (ram,0x001c8a74) */
int1 [16] js_function_toString(int8 param_1,long param_2,int8 param_3)
{
long lVar1;
int iVar2;
int1 auVar3 [16];
char *local_68;
int8 local_60;
int8 local_58;
int4 local_10;
int4 uStack_c;
int8 local_8;
iVar2 = check_function(param_1,param_2,param_3);
if (iVar2 == 0) {
iVar2 = js_class_has_bytecode(*(int2 *)(param_2 + 6));
if ((iVar2 == 0) || (lVar1 = *(long *)(param_2 + 0x30), *(long *)(lVar1 + 0x88) == 0)) {
switch((long)&switchD_001c8a72::switchdataD_002128cc +
(long)(int)switchD_001c8a72::switchdataD_002128cc) {
case 0x1c8a76:
local_68 = "function ";
break;
case 0x1c8a84:
local_68 = "function *";
break;
case 0x1c8a92:
local_68 = "async function ";
break;
case 0x1c8aa0:
local_68 = "async function *";
}
auVar3 = JS_GetProperty(param_1,param_2,param_3,0x37);
iVar2 = JS_IsUndefined(auVar3._0_8_,auVar3._8_8_);
if (iVar2 != 0) {
auVar3 = JS_AtomToString(param_1,0x2f);
}
local_58 = auVar3._8_8_;
local_60 = auVar3._0_8_;
auVar3 = JS_ConcatString3(param_1,local_68,local_60,local_58,"() {\n [native code]\n}");
local_8 = auVar3._8_8_;
local_10 = auVar3._0_4_;
uStack_c = auVar3._4_4_;
}
else {
auVar3 = JS_NewStringLen(param_1,*(int8 *)(lVar1 + 0x88),(long)*(int *)(lVar1 + 0x74));
local_8 = auVar3._8_8_;
local_10 = auVar3._0_4_;
uStack_c = auVar3._4_4_;
}
}
else {
local_10 = 0;
local_8 = 6;
}
auVar3._4_4_ = uStack_c;
auVar3._0_4_ = local_10;
auVar3._8_8_ = local_8;
return auVar3;
}
|
|
19,867
|
js_function_toString
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_function_toString(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSObject *p;
JSFunctionKindEnum func_kind = JS_FUNC_NORMAL;
if (check_function(ctx, this_val))
return JS_EXCEPTION;
p = JS_VALUE_GET_OBJ(this_val);
if (js_class_has_bytecode(p->class_id)) {
JSFunctionBytecode *b = p->u.func.function_bytecode;
/* `b->source` must be pure ASCII or UTF-8 encoded */
if (b->source)
return JS_NewStringLen(ctx, b->source, b->source_len);
}
{
JSValue name;
const char *pref, *suff;
switch(func_kind) {
default:
case JS_FUNC_NORMAL:
pref = "function ";
break;
case JS_FUNC_GENERATOR:
pref = "function *";
break;
case JS_FUNC_ASYNC:
pref = "async function ";
break;
case JS_FUNC_ASYNC_GENERATOR:
pref = "async function *";
break;
}
suff = "() {\n [native code]\n}";
name = JS_GetProperty(ctx, this_val, JS_ATOM_name);
if (JS_IsUndefined(name))
name = JS_AtomToString(ctx, JS_ATOM_empty_string);
return JS_ConcatString3(ctx, pref, name, suff);
}
}
|
O2
|
c
|
js_function_toString:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x3d04a
testl %eax, %eax
je 0x63924
pushq $0x6
popq %rdx
xorl %eax, %eax
xorl %r12d, %r12d
jmp 0x639aa
movabsq $-0x100000000, %r12 # imm = 0xFFFFFFFF00000000
movzwl 0x6(%r15), %eax
cmpq $0x38, %rax
ja 0x63967
movabsq $0x110000000012000, %rcx # imm = 0x110000000012000
btq %rax, %rcx
jae 0x63967
movq 0x30(%r15), %rax
movq 0x88(%rax), %rsi
testq %rsi, %rsi
je 0x63967
movslq 0x74(%rax), %rdx
movq %rbx, %rdi
callq 0x1de9a
jmp 0x639a7
pushq $0x37
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1ebf3
movq %rdx, %rcx
cmpl $0x3, %ecx
jne 0x6398e
pushq $0x2f
popq %rsi
movq %rbx, %rdi
callq 0x1e540
movq %rdx, %rcx
leaq 0x28304(%rip), %rsi # 0x8bc99
leaq 0x28307(%rip), %r8 # 0x8bca3
movq %rbx, %rdi
movq %rax, %rdx
callq 0x3d7e0
andq %rax, %r12
movl %eax, %eax
orq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
js_function_toString:
push r15
push r14
push r12
push rbx
push rax
mov r14, rdx
mov r15, rsi
mov rbx, rdi
call check_function
test eax, eax
jz short loc_63924
push 6
pop rdx
xor eax, eax
xor r12d, r12d
jmp loc_639AA
loc_63924:
mov r12, 0FFFFFFFF00000000h
movzx eax, word ptr [r15+6]
cmp rax, 38h ; '8'
ja short loc_63967
mov rcx, 110000000012000h
bt rcx, rax
jnb short loc_63967
mov rax, [r15+30h]
mov rsi, [rax+88h]
test rsi, rsi
jz short loc_63967
movsxd rdx, dword ptr [rax+74h]
mov rdi, rbx
call JS_NewStringLen
jmp short loc_639A7
loc_63967:
push 37h ; '7'
pop rcx
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_GetProperty
mov rcx, rdx
cmp ecx, 3
jnz short loc_6398E
push 2Fh ; '/'
pop rsi
mov rdi, rbx
call JS_AtomToString
mov rcx, rdx
loc_6398E:
lea rsi, aFunction; "function "
lea r8, aNativeCode; "() {\n [native code]\n}"
mov rdi, rbx
mov rdx, rax
call JS_ConcatString3
loc_639A7:
and r12, rax
loc_639AA:
mov eax, eax
or rax, r12
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
unsigned long long js_function_toString(
long long a1,
long long a2,
int a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
int v12; // r15d
long long v13; // rax
unsigned long long v14; // r12
unsigned long long v15; // rax
long long v16; // rcx
long long v17; // rax
char *v18; // rsi
long long Property; // rax
long long v20; // rdx
long long v21; // rcx
long long v22; // rdx
v12 = a2;
if ( (unsigned int)check_function(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) )
{
LODWORD(v13) = 0;
v14 = 0LL;
}
else
{
v15 = *(unsigned __int16 *)(a2 + 6);
if ( v15 <= 0x38
&& (v16 = 0x110000000012000LL, _bittest64(&v16, v15))
&& (v17 = *(_QWORD *)(a2 + 48), (v18 = *(char **)(v17 + 136)) != 0LL) )
{
v13 = JS_NewStringLen(a1, v18, *(int *)(v17 + 116));
}
else
{
Property = JS_GetProperty(a1, v12, a3, 55);
v21 = v20;
if ( (_DWORD)v20 == 3 )
{
Property = JS_AtomToString(a1, 47);
v21 = v22;
}
v13 = JS_ConcatString3(a1, (long long)"function ", Property, v21, (long long)"() {\n [native code]\n}");
}
v14 = v13 & 0xFFFFFFFF00000000LL;
}
return v14 | (unsigned int)v13;
}
|
js_function_toString:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
CALL 0x0013d04a
TEST EAX,EAX
JZ 0x00163924
PUSH 0x6
POP RDX
XOR EAX,EAX
XOR R12D,R12D
JMP 0x001639aa
LAB_00163924:
MOV R12,-0x100000000
MOVZX EAX,word ptr [R15 + 0x6]
CMP RAX,0x38
JA 0x00163967
MOV RCX,0x110000000012000
BT RCX,RAX
JNC 0x00163967
MOV RAX,qword ptr [R15 + 0x30]
MOV RSI,qword ptr [RAX + 0x88]
TEST RSI,RSI
JZ 0x00163967
MOVSXD RDX,dword ptr [RAX + 0x74]
MOV RDI,RBX
CALL 0x0011de9a
JMP 0x001639a7
LAB_00163967:
PUSH 0x37
POP RCX
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x0011ebf3
MOV RCX,RDX
CMP ECX,0x3
JNZ 0x0016398e
PUSH 0x2f
POP RSI
MOV RDI,RBX
CALL 0x0011e540
MOV RCX,RDX
LAB_0016398e:
LEA RSI,[0x18bc99]
LEA R8,[0x18bca3]
MOV RDI,RBX
MOV RDX,RAX
CALL 0x0013d7e0
LAB_001639a7:
AND R12,RAX
LAB_001639aa:
MOV EAX,EAX
OR RAX,R12
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
ulong js_function_toString(int8 param_1,long param_2,int8 param_3)
{
long lVar1;
int iVar2;
ulong uVar3;
ulong uVar4;
int1 auVar5 [16];
iVar2 = check_function();
if (iVar2 != 0) {
uVar3 = 0;
uVar4 = 0;
goto LAB_001639aa;
}
if (((ulong)*(ushort *)(param_2 + 6) < 0x39) &&
((0x110000000012000U >> ((ulong)*(ushort *)(param_2 + 6) & 0x3f) & 1) != 0)) {
lVar1 = *(long *)(*(long *)(param_2 + 0x30) + 0x88);
if (lVar1 == 0) goto LAB_00163967;
uVar3 = JS_NewStringLen(param_1,lVar1,(long)*(int *)(*(long *)(param_2 + 0x30) + 0x74));
}
else {
LAB_00163967:
auVar5 = JS_GetProperty(param_1,param_2,param_3,0x37);
if (auVar5._8_4_ == 3) {
auVar5 = JS_AtomToString(param_1,0x2f);
}
uVar3 = JS_ConcatString3(param_1,"function ",auVar5._0_8_,auVar5._8_8_,
"() {\n [native code]\n}");
}
uVar4 = uVar3 & 0xffffffff00000000;
LAB_001639aa:
return uVar3 & 0xffffffff | uVar4;
}
|
|
19,868
|
inheritance_source_by_id
|
eloqsql/mysys/charset.c
|
static CHARSET_INFO *inheritance_source_by_id(CHARSET_INFO *cs, uint refid)
{
CHARSET_INFO *refcs;
return refid && refid != cs->number &&
(refcs= all_charsets[refid]) &&
(refcs->state & MY_CS_AVAILABLE) ? refcs : NULL;
}
|
O0
|
c
|
inheritance_source_by_id:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x30ec1
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
je 0x30ec1
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x3585e8(%rip), %rax # 0x389480
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x30ec1
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x200, %eax # imm = 0x200
cmpl $0x0, %eax
je 0x30ec1
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x30ec9
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x30ec9
movq -0x20(%rbp), %rax
popq %rbp
retq
nop
|
inheritance_source_by_id:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
cmp [rbp+var_C], 0
jz short loc_30EC1
mov eax, [rbp+var_C]
mov rcx, [rbp+var_8]
cmp eax, [rcx]
jz short loc_30EC1
mov eax, [rbp+var_C]
mov ecx, eax
lea rax, all_charsets
mov rax, [rax+rcx*8]
mov [rbp+var_18], rax
cmp rax, 0
jz short loc_30EC1
mov rax, [rbp+var_18]
mov eax, [rax+0Ch]
and eax, 200h
cmp eax, 0
jz short loc_30EC1
mov rax, [rbp+var_18]
mov [rbp+var_20], rax
jmp short loc_30EC9
loc_30EC1:
xor eax, eax
mov [rbp+var_20], rax
jmp short $+2
loc_30EC9:
mov rax, [rbp+var_20]
pop rbp
retn
|
long long inheritance_source_by_id(_DWORD *a1, int a2)
{
long long v4; // [rsp+8h] [rbp-18h]
if ( a2 && a2 != *a1 && (v4 = all_charsets[a2]) != 0 && (*(_DWORD *)(v4 + 12) & 0x200) != 0 )
return all_charsets[a2];
else
return 0LL;
}
|
inheritance_source_by_id:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
CMP dword ptr [RBP + -0xc],0x0
JZ 0x00130ec1
MOV EAX,dword ptr [RBP + -0xc]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX]
JZ 0x00130ec1
MOV EAX,dword ptr [RBP + -0xc]
MOV ECX,EAX
LEA RAX,[0x489480]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JZ 0x00130ec1
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0xc]
AND EAX,0x200
CMP EAX,0x0
JZ 0x00130ec1
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00130ec9
LAB_00130ec1:
XOR EAX,EAX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00130ec9
LAB_00130ec9:
MOV RAX,qword ptr [RBP + -0x20]
POP RBP
RET
|
long inheritance_source_by_id(uint *param_1,uint param_2)
{
long local_28;
if ((((param_2 == 0) || (param_2 == *param_1)) ||
(local_28 = (&all_charsets)[param_2], local_28 == 0)) ||
((*(uint *)(local_28 + 0xc) & 0x200) == 0)) {
local_28 = 0;
}
return local_28;
}
|
|
19,869
|
minja::TextNode::TextNode(minja::Location const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
monkey531[P]llama/common/minja.hpp
|
TextNode(const Location & location, const std::string& t) : TemplateNode(location), text(t) {}
|
O3
|
cpp
|
minja::TextNode::TextNode(minja::Location const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8c91d(%rip), %r15 # 0x12cfc8
addq $0x10, %r15
movq %r15, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0xa06db
movq 0x8d8b3(%rip), %rcx # 0x12df80
cmpb $0x0, (%rcx)
je 0xa06d7
incl 0x8(%rax)
jmp 0xa06db
lock
incl 0x8(%rax)
movq 0x10(%rsi), %rax
movq %rax, 0x18(%rbx)
leaq 0x8cb2e(%rip), %rax # 0x12d218
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x229dc
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xa0726
callq 0x70324
movq %r14, %rdi
callq 0x1c1e0
|
_ZN5minja8TextNodeC2ERKNS_8LocationERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push rbx
mov rbx, rdi
lea r15, _ZTVN5minja12TemplateNodeE; `vtable for'minja::TemplateNode
add r15, 10h
mov [rdi], r15
mov rax, [rsi]
mov [rdi+8], rax
mov rax, [rsi+8]
mov [rdi+10h], rax
test rax, rax
jz short loc_A06DB
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_A06D7
inc dword ptr [rax+8]
jmp short loc_A06DB
loc_A06D7:
lock inc dword ptr [rax+8]
loc_A06DB:
mov rax, [rsi+10h]
mov [rbx+18h], rax
lea rax, _ZTVN5minja8TextNodeE; `vtable for'minja::TextNode
add rax, 10h
mov [rbx], rax
lea rdi, [rbx+20h]
lea rax, [rbx+30h]
mov [rbx+20h], rax
mov rsi, [rdx]
mov rdx, [rdx+8]
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)
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov [rbx], r15
mov rdi, [rbx+10h]
test rdi, rdi
jz short loc_A0726
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A0726:
mov rdi, r14
call __Unwind_Resume
|
long long minja::TextNode::TextNode(_QWORD *a1, _QWORD *a2, long long a3)
{
long long v3; // rax
*a1 = &`vtable for'minja::TemplateNode + 2;
a1[1] = *a2;
v3 = a2[1];
a1[2] = v3;
if ( v3 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v3 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v3 + 8));
}
a1[3] = a2[2];
*a1 = &`vtable for'minja::TextNode + 2;
a1[4] = a1 + 6;
return std::string::_M_construct<char *>((long long)(a1 + 4), *(_BYTE **)a3, *(_QWORD *)a3 + *(_QWORD *)(a3 + 8));
}
|
TextNode:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
LEA R15,[0x22cfc8]
ADD R15,0x10
MOV qword ptr [RDI],R15
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x8],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],RAX
TEST RAX,RAX
JZ 0x001a06db
MOV RCX,qword ptr [0x0022df80]
CMP byte ptr [RCX],0x0
JZ 0x001a06d7
INC dword ptr [RAX + 0x8]
JMP 0x001a06db
LAB_001a06d7:
INC.LOCK dword ptr [RAX + 0x8]
LAB_001a06db:
MOV RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RBX + 0x18],RAX
LEA RAX,[0x22d218]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
LEA RDI,[RBX + 0x20]
LEA RAX,[RBX + 0x30]
MOV qword ptr [RBX + 0x20],RAX
MOV RSI,qword ptr [RDX]
MOV RDX,qword ptr [RDX + 0x8]
ADD RDX,RSI
LAB_001a0707:
CALL 0x001229dc
LAB_001a070c:
POP RBX
POP R14
POP R15
RET
|
/* minja::TextNode::TextNode(minja::Location const&, std::__cxx11::string const&) */
void __thiscall minja::TextNode::TextNode(TextNode *this,Location *param_1,string *param_2)
{
long lVar1;
*(int ***)this = &PTR___cxa_pure_virtual_0022cfd8;
*(int8 *)(this + 8) = *(int8 *)param_1;
lVar1 = *(long *)(param_1 + 8);
*(long *)(this + 0x10) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_0022df80 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
*(int8 *)(this + 0x18) = *(int8 *)(param_1 + 0x10);
*(int ***)this = &PTR_do_render_0022d228;
*(TextNode **)(this + 0x20) = this + 0x30;
/* try { // try from 001a0707 to 001a070b has its CatchHandler @ 001a0712 */
std::__cxx11::string::_M_construct<char*>
(this + 0x20,*(long *)param_2,*(long *)(param_2 + 8) + *(long *)param_2);
return;
}
|
|
19,870
|
llama_vocab::impl::impl(llama_vocab const&)
|
monkey531[P]llama/src/llama-vocab.cpp
|
impl(const llama_vocab & vocab) : vocab(vocab) {
}
|
O3
|
cpp
|
llama_vocab::impl::impl(llama_vocab const&):
movsd 0x2f72e(%rip), %xmm0 # 0x11a130
movups %xmm0, (%rdi)
movaps 0x2f734(%rip), %xmm0 # 0x11a140
movups %xmm0, 0x10(%rdi)
movdqa 0x2f708(%rip), %xmm0 # 0x11a120
movdqu %xmm0, 0x20(%rdi)
movl $0xd, 0x30(%rdi)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x34(%rdi)
movq $-0x1, 0x44(%rdi)
movabsq $0x1000000000000, %rax # imm = 0x1000000000000
movq %rax, 0x4c(%rdi)
leaq 0x88(%rdi), %rax
movq %rax, 0x58(%rdi)
movl $0x1, %eax
movq %rax, 0x60(%rdi)
pxor %xmm0, %xmm0
movdqu %xmm0, 0x68(%rdi)
movl $0x3f800000, %ecx # imm = 0x3F800000
movl %ecx, 0x78(%rdi)
leaq 0x108(%rdi), %rdx
movdqu %xmm0, 0x80(%rdi)
movdqu %xmm0, 0x90(%rdi)
movdqu %xmm0, 0xa0(%rdi)
movdqu %xmm0, 0xb0(%rdi)
movdqu %xmm0, 0xc0(%rdi)
xorl %r8d, %r8d
movq %r8, 0xd0(%rdi)
movq %rdx, 0xd8(%rdi)
movq %rax, 0xe0(%rdi)
movdqu %xmm0, 0xe8(%rdi)
movl %ecx, 0xf8(%rdi)
movdqu %xmm0, 0x100(%rdi)
leaq 0x118(%rdi), %rax
movl $0x0, 0x118(%rdi)
movq %r8, 0x120(%rdi)
movq %rax, 0x128(%rdi)
movq %rax, 0x130(%rdi)
movq %r8, 0x158(%rdi)
movdqu %xmm0, 0x148(%rdi)
movdqu %xmm0, 0x138(%rdi)
movq %rsi, 0x160(%rdi)
retq
|
_ZN11llama_vocab4implC2ERKS_:
movsd xmm0, cs:qword_11A130
movups xmmword ptr [rdi], xmm0
movaps xmm0, cs:xmmword_11A140
movups xmmword ptr [rdi+10h], xmm0
movdqa xmm0, cs:xmmword_11A120
movdqu xmmword ptr [rdi+20h], xmm0
mov dword ptr [rdi+30h], 0Dh
pcmpeqd xmm0, xmm0
movdqu xmmword ptr [rdi+34h], xmm0
mov qword ptr [rdi+44h], 0FFFFFFFFFFFFFFFFh
mov rax, 1000000000000h
mov [rdi+4Ch], rax
lea rax, [rdi+88h]
mov [rdi+58h], rax
mov eax, 1
mov [rdi+60h], rax
pxor xmm0, xmm0
movdqu xmmword ptr [rdi+68h], xmm0
mov ecx, 3F800000h
mov [rdi+78h], ecx
lea rdx, [rdi+108h]
movdqu xmmword ptr [rdi+80h], xmm0
movdqu xmmword ptr [rdi+90h], xmm0
movdqu xmmword ptr [rdi+0A0h], xmm0
movdqu xmmword ptr [rdi+0B0h], xmm0
movdqu xmmword ptr [rdi+0C0h], xmm0
xor r8d, r8d
mov [rdi+0D0h], r8
mov [rdi+0D8h], rdx
mov [rdi+0E0h], rax
movdqu xmmword ptr [rdi+0E8h], xmm0
mov [rdi+0F8h], ecx
movdqu xmmword ptr [rdi+100h], xmm0
lea rax, [rdi+118h]
mov dword ptr [rdi+118h], 0
mov [rdi+120h], r8
mov [rdi+128h], rax
mov [rdi+130h], rax
mov [rdi+158h], r8
movdqu xmmword ptr [rdi+148h], xmm0
movdqu xmmword ptr [rdi+138h], xmm0
mov [rdi+160h], rsi
retn
|
long long llama_vocab::impl::impl(llama_vocab::impl *this, const llama_vocab *a2)
{
long long result; // rax
*(_OWORD *)this = 0x100000000uLL;
*((_OWORD *)this + 1) = xmmword_11A140;
*((__m128i *)this + 2) = _mm_load_si128((const __m128i *)&xmmword_11A120);
*((_DWORD *)this + 12) = 13;
*(_OWORD *)((char *)this + 52) = -1LL;
*(_QWORD *)((char *)this + 68) = -1LL;
*(_QWORD *)((char *)this + 76) = 0x1000000000000LL;
*((_QWORD *)this + 11) = (char *)this + 136;
*((_QWORD *)this + 12) = 1LL;
*(_OWORD *)((char *)this + 104) = 0LL;
*((_DWORD *)this + 30) = 1065353216;
*((_OWORD *)this + 8) = 0LL;
*((_OWORD *)this + 9) = 0LL;
*((_OWORD *)this + 10) = 0LL;
*((_OWORD *)this + 11) = 0LL;
*((_OWORD *)this + 12) = 0LL;
*((_QWORD *)this + 26) = 0LL;
*((_QWORD *)this + 27) = (char *)this + 264;
*((_QWORD *)this + 28) = 1LL;
*(_OWORD *)((char *)this + 232) = 0LL;
*((_DWORD *)this + 62) = 1065353216;
*((_OWORD *)this + 16) = 0LL;
result = (long long)this + 280;
*((_DWORD *)this + 70) = 0;
*((_QWORD *)this + 36) = 0LL;
*((_QWORD *)this + 37) = (char *)this + 280;
*((_QWORD *)this + 38) = (char *)this + 280;
*((_QWORD *)this + 43) = 0LL;
*(_OWORD *)((char *)this + 328) = 0LL;
*(_OWORD *)((char *)this + 312) = 0LL;
*((_QWORD *)this + 44) = a2;
return result;
}
|
impl:
MOVSD XMM0,qword ptr [0x0021a130]
MOVUPS xmmword ptr [RDI],XMM0
MOVAPS XMM0,xmmword ptr [0x0021a140]
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVDQA XMM0,xmmword ptr [0x0021a120]
MOVDQU xmmword ptr [RDI + 0x20],XMM0
MOV dword ptr [RDI + 0x30],0xd
PCMPEQD XMM0,XMM0
MOVDQU xmmword ptr [RDI + 0x34],XMM0
MOV qword ptr [RDI + 0x44],-0x1
MOV RAX,0x1000000000000
MOV qword ptr [RDI + 0x4c],RAX
LEA RAX,[RDI + 0x88]
MOV qword ptr [RDI + 0x58],RAX
MOV EAX,0x1
MOV qword ptr [RDI + 0x60],RAX
PXOR XMM0,XMM0
MOVDQU xmmword ptr [RDI + 0x68],XMM0
MOV ECX,0x3f800000
MOV dword ptr [RDI + 0x78],ECX
LEA RDX,[RDI + 0x108]
MOVDQU xmmword ptr [RDI + 0x80],XMM0
MOVDQU xmmword ptr [RDI + 0x90],XMM0
MOVDQU xmmword ptr [RDI + 0xa0],XMM0
MOVDQU xmmword ptr [RDI + 0xb0],XMM0
MOVDQU xmmword ptr [RDI + 0xc0],XMM0
XOR R8D,R8D
MOV qword ptr [RDI + 0xd0],R8
MOV qword ptr [RDI + 0xd8],RDX
MOV qword ptr [RDI + 0xe0],RAX
MOVDQU xmmword ptr [RDI + 0xe8],XMM0
MOV dword ptr [RDI + 0xf8],ECX
MOVDQU xmmword ptr [RDI + 0x100],XMM0
LEA RAX,[RDI + 0x118]
MOV dword ptr [RDI + 0x118],0x0
MOV qword ptr [RDI + 0x120],R8
MOV qword ptr [RDI + 0x128],RAX
MOV qword ptr [RDI + 0x130],RAX
MOV qword ptr [RDI + 0x158],R8
MOVDQU xmmword ptr [RDI + 0x148],XMM0
MOVDQU xmmword ptr [RDI + 0x138],XMM0
MOV qword ptr [RDI + 0x160],RSI
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* llama_vocab::impl::impl(llama_vocab const&) */
void __thiscall llama_vocab::impl::impl(impl *this,llama_vocab *param_1)
{
int8 uVar1;
*(int8 *)this = DAT_0021a130;
*(int8 *)(this + 8) = 0;
uVar1 = _UNK_0021a148;
*(int8 *)(this + 0x10) = _DAT_0021a140;
*(int8 *)(this + 0x18) = uVar1;
uVar1 = _UNK_0021a128;
*(int8 *)(this + 0x20) = _DAT_0021a120;
*(int8 *)(this + 0x28) = uVar1;
*(int4 *)(this + 0x30) = 0xd;
*(int4 *)(this + 0x34) = 0xffffffff;
*(int4 *)(this + 0x38) = 0xffffffff;
*(int4 *)(this + 0x3c) = 0xffffffff;
*(int4 *)(this + 0x40) = 0xffffffff;
*(int8 *)(this + 0x44) = 0xffffffffffffffff;
*(int8 *)(this + 0x4c) = 0x1000000000000;
*(impl **)(this + 0x58) = this + 0x88;
*(int8 *)(this + 0x60) = 1;
*(int1 (*) [16])(this + 0x68) = (int1 [16])0x0;
*(int4 *)(this + 0x78) = 0x3f800000;
*(int1 (*) [16])(this + 0x80) = (int1 [16])0x0;
*(int1 (*) [16])(this + 0x90) = (int1 [16])0x0;
*(int1 (*) [16])(this + 0xa0) = (int1 [16])0x0;
*(int1 (*) [16])(this + 0xb0) = (int1 [16])0x0;
*(int1 (*) [16])(this + 0xc0) = (int1 [16])0x0;
*(int8 *)(this + 0xd0) = 0;
*(impl **)(this + 0xd8) = this + 0x108;
*(int8 *)(this + 0xe0) = 1;
*(int1 (*) [16])(this + 0xe8) = (int1 [16])0x0;
*(int4 *)(this + 0xf8) = 0x3f800000;
*(int1 (*) [16])(this + 0x100) = (int1 [16])0x0;
*(int4 *)(this + 0x118) = 0;
*(int8 *)(this + 0x120) = 0;
*(impl **)(this + 0x128) = this + 0x118;
*(impl **)(this + 0x130) = this + 0x118;
*(int8 *)(this + 0x158) = 0;
*(int1 (*) [16])(this + 0x148) = (int1 [16])0x0;
*(int1 (*) [16])(this + 0x138) = (int1 [16])0x0;
*(llama_vocab **)(this + 0x160) = param_1;
return;
}
|
|
19,871
|
ma_apply_redo_index_new_page
|
eloqsql/storage/maria/ma_key_recover.c
|
uint _ma_apply_redo_index_new_page(MARIA_HA *info, LSN lsn,
const uchar *header, uint length)
{
pgcache_page_no_t root_page= page_korr(header);
pgcache_page_no_t free_page= page_korr(header + PAGE_STORE_SIZE);
uint key_nr= key_nr_korr(header + PAGE_STORE_SIZE * 2);
my_bool page_type_flag= header[PAGE_STORE_SIZE * 2 + KEY_NR_STORE_SIZE];
enum pagecache_page_lock unlock_method;
enum pagecache_page_pin unpin_method;
MARIA_PINNED_PAGE page_link;
my_off_t file_size;
uchar *buff;
uint result;
MARIA_SHARE *share= info->s;
DBUG_ENTER("_ma_apply_redo_index_new_page");
DBUG_PRINT("enter", ("root_page: %lu free_page: %lu",
(ulong) root_page, (ulong) free_page));
/* Set header to point at key data */
share->state.changed|= (STATE_CHANGED | STATE_NOT_OPTIMIZED_KEYS |
STATE_NOT_SORTED_PAGES | STATE_NOT_ZEROFILLED |
STATE_NOT_MOVABLE);
header+= PAGE_STORE_SIZE * 2 + KEY_NR_STORE_SIZE + 1;
length-= PAGE_STORE_SIZE * 2 + KEY_NR_STORE_SIZE + 1;
file_size= (my_off_t) (root_page + 1) * share->block_size;
if (cmp_translog_addr(lsn, share->state.is_of_horizon) >= 0)
{
/* free_page is 0 if we shouldn't set key_del */
if (free_page)
{
if (free_page != IMPOSSIBLE_PAGE_NO)
share->state.key_del= (my_off_t) free_page * share->block_size;
else
share->state.key_del= HA_OFFSET_ERROR;
}
if (page_type_flag) /* root page */
share->state.key_root[key_nr]= file_size - share->block_size;
}
if (file_size > share->state.state.key_file_length)
{
share->state.state.key_file_length= file_size;
buff= info->keyread_buff;
info->keyread_buff_used= 1;
unlock_method= PAGECACHE_LOCK_WRITE;
unpin_method= PAGECACHE_PIN;
}
else
{
if (!(buff= pagecache_read(share->pagecache, &share->kfile,
root_page, 0, 0,
PAGECACHE_PLAIN_PAGE, PAGECACHE_LOCK_WRITE,
&page_link.link)))
{
if (my_errno != HA_ERR_FILE_TOO_SHORT &&
my_errno != HA_ERR_WRONG_CRC &&
my_errno != HA_ERR_DECRYPTION_FAILED)
{
result= 1;
_ma_set_fatal_error(info, my_errno);
goto err;
}
buff= pagecache_block_link_to_buffer(page_link.link);
}
else if (lsn_korr(buff) >= lsn)
{
/* Already applied */
check_skipped_lsn(info, lsn_korr(buff), 0, root_page);
result= 0;
goto err;
}
unlock_method= PAGECACHE_LOCK_LEFT_WRITELOCKED;
unpin_method= PAGECACHE_PIN_LEFT_PINNED;
}
/* Write modified page */
bzero(buff, LSN_STORE_SIZE);
memcpy(buff + LSN_STORE_SIZE, header, length);
bzero(buff + LSN_STORE_SIZE + length,
share->max_index_block_size - LSN_STORE_SIZE - length);
bfill(buff + share->block_size - KEYPAGE_CHECKSUM_SIZE,
KEYPAGE_CHECKSUM_SIZE, (uchar) 255);
result= 0;
if (unlock_method == PAGECACHE_LOCK_WRITE &&
pagecache_write(share->pagecache,
&share->kfile, root_page, 0,
buff, PAGECACHE_PLAIN_PAGE,
unlock_method, unpin_method,
PAGECACHE_WRITE_DELAY, &page_link.link,
LSN_IMPOSSIBLE))
result= 1;
/* Mark page to be unlocked and written at _ma_unpin_all_pages() */
page_link.unlock= PAGECACHE_LOCK_WRITE_UNLOCK;
page_link.changed= 1;
push_dynamic(&info->pinned_pages, (void*) &page_link);
DBUG_RETURN(result);
err:
pagecache_unlock_by_link(share->pagecache, page_link.link,
PAGECACHE_LOCK_WRITE_UNLOCK,
PAGECACHE_UNPIN, LSN_IMPOSSIBLE,
LSN_IMPOSSIBLE, 0, FALSE);
DBUG_RETURN(result);
}
|
O0
|
c
|
ma_apply_redo_index_new_page:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movl %ecx, -0x34(%rbp)
movq -0x30(%rbp), %rdi
callq 0x47630
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
addq $0x5, %rdi
callq 0x47630
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movzbl 0xa(%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x30(%rbp), %rax
movb 0xb(%rax), %al
movb %al, -0x4d(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x90(%rbp)
jmp 0x47210
movq -0x90(%rbp), %rax
movl 0x170(%rax), %ecx
orl $0x1b1, %ecx # imm = 0x1B1
movl %ecx, 0x170(%rax)
movq -0x30(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x30(%rbp)
movl -0x34(%rbp), %eax
subl $0xc, %eax
movl %eax, -0x34(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq -0x90(%rbp), %rcx
movl 0x7bc(%rcx), %ecx
imulq %rcx, %rax
movq %rax, -0x78(%rbp)
movq -0x28(%rbp), %rax
movq -0x90(%rbp), %rcx
subq 0x180(%rcx), %rax
cmpq $0x0, %rax
jl 0x472f8
cmpq $0x0, -0x48(%rbp)
je 0x472c7
movabsq $0xffffffffff, %rax # imm = 0xFFFFFFFFFF
cmpq %rax, -0x48(%rbp)
je 0x472b3
movq -0x48(%rbp), %rcx
movq -0x90(%rbp), %rax
movl 0x7bc(%rax), %eax
imulq %rax, %rcx
movq -0x90(%rbp), %rax
movq %rcx, 0x120(%rax)
jmp 0x472c5
movq -0x90(%rbp), %rax
movq $-0x1, 0x120(%rax)
jmp 0x472c7
cmpb $0x0, -0x4d(%rbp)
je 0x472f6
movq -0x78(%rbp), %rdx
movq -0x90(%rbp), %rax
movl 0x7bc(%rax), %eax
subq %rax, %rdx
movq -0x90(%rbp), %rax
movq 0x118(%rax), %rax
movl -0x4c(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
jmp 0x472f8
movq -0x78(%rbp), %rax
movq -0x90(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jbe 0x47345
movq -0x78(%rbp), %rcx
movq -0x90(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rax
movq 0x380(%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rax
movb $0x1, 0x685(%rax)
movl $0x4, -0x54(%rbp)
movl $0x2, -0x58(%rbp)
jmp 0x4748d
movq -0x90(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x90(%rbp), %rsi
addq $0x750, %rsi # imm = 0x750
movq -0x40(%rbp), %rdx
leaq -0x70(%rbp), %rax
xorl %ecx, %ecx
xorl %r8d, %r8d
movl $0x1, %r9d
movl $0x4, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x3f030
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
jne 0x473f5
callq 0xfe880
cmpl $0xaf, (%rax)
je 0x473e3
callq 0xfe880
cmpl $0xb0, (%rax)
je 0x473e3
callq 0xfe880
cmpl $0xc0, (%rax)
je 0x473e3
movl $0x1, -0x84(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0xfe880
movq -0x98(%rbp), %rdi
movl (%rax), %esi
callq 0x45dc0
jmp 0x475d3
movq -0x70(%rbp), %rdi
callq 0x41b80
movq %rax, -0x80(%rbp)
jmp 0x4747f
movq -0x80(%rbp), %rax
movzbl (%rax), %eax
movq -0x80(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x80(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
shlq $0x20, %rax
movq -0x80(%rbp), %rcx
movl 0x3(%rcx), %ecx
orq %rcx, %rax
cmpq -0x28(%rbp), %rax
jl 0x4747d
movq -0x20(%rbp), %rdi
movq -0x80(%rbp), %rax
movzbl (%rax), %eax
movq -0x80(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x80(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
movl %eax, %esi
shlq $0x20, %rsi
movq -0x80(%rbp), %rax
movl 0x3(%rax), %eax
orq %rax, %rsi
movq -0x40(%rbp), %rcx
xorl %edx, %edx
callq 0x35e90
movl $0x0, -0x84(%rbp)
jmp 0x475d3
jmp 0x4747f
movl $0x2, -0x54(%rbp)
movl $0x0, -0x58(%rbp)
movq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x7, %edx
callq 0x2a2c0
movq -0x80(%rbp), %rdi
addq $0x7, %rdi
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %eax
movl %eax, %edx
callq 0x2a0b0
movq -0x80(%rbp), %rdi
addq $0x7, %rdi
movl -0x34(%rbp), %eax
addq %rax, %rdi
movq -0x90(%rbp), %rax
movl 0x7c0(%rax), %eax
subl $0x7, %eax
subl -0x34(%rbp), %eax
movl %eax, %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x2a2c0
movq -0x80(%rbp), %rdi
movq -0x90(%rbp), %rax
movl 0x7bc(%rax), %eax
addq %rax, %rdi
addq $-0x4, %rdi
movl $0xff, %esi
movl $0x4, %edx
callq 0x2a2c0
movl $0x0, -0x84(%rbp)
cmpl $0x4, -0x54(%rbp)
jne 0x475a9
movq -0x90(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x90(%rbp), %rsi
addq $0x750, %rsi # imm = 0x750
movq -0x40(%rbp), %rdx
movq -0x80(%rbp), %r8
movl -0x54(%rbp), %ebx
movl -0x58(%rbp), %r11d
leaq -0x70(%rbp), %r10
movq -0x90(%rbp), %rax
movq 0x600(%rax), %rax
movl 0x80(%rax), %eax
xorl %ecx, %ecx
movl $0x1, %r9d
xorl %r14d, %r14d
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x28(%rsp)
movl %eax, 0x30(%rsp)
callq 0x40730
movsbl %al, %eax
cmpl $0x0, %eax
je 0x475a9
movl $0x1, -0x84(%rbp)
movl $0x6, -0x68(%rbp)
movb $0x1, -0x60(%rbp)
movq -0x20(%rbp), %rdi
addq $0x2e8, %rdi # imm = 0x2E8
leaq -0x70(%rbp), %rsi
callq 0xdc6b0
movl -0x84(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x47616
movq -0x90(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x70(%rbp), %rsi
movl $0x6, %edx
movl $0x3, %ecx
xorl %eax, %eax
movl %eax, %r9d
xorl %eax, %eax
movq %r9, %r8
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x3edd0
movl -0x84(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ma_apply_redo_index_new_page:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 0C0h
mov [rbp+var_20], rdi
mov [rbp+var_28], rsi
mov [rbp+var_30], rdx
mov [rbp+var_34], ecx
mov rdi, [rbp+var_30]
call uint5korr
mov [rbp+var_40], rax
mov rdi, [rbp+var_30]
add rdi, 5
call uint5korr
mov [rbp+var_48], rax
mov rax, [rbp+var_30]
movzx eax, byte ptr [rax+0Ah]
mov [rbp+var_4C], eax
mov rax, [rbp+var_30]
mov al, [rax+0Bh]
mov [rbp+var_4D], al
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_90], rax
jmp short $+2
loc_47210:
mov rax, [rbp+var_90]
mov ecx, [rax+170h]
or ecx, 1B1h
mov [rax+170h], ecx
mov rax, [rbp+var_30]
add rax, 0Ch
mov [rbp+var_30], rax
mov eax, [rbp+var_34]
sub eax, 0Ch
mov [rbp+var_34], eax
mov rax, [rbp+var_40]
add rax, 1
mov rcx, [rbp+var_90]
mov ecx, [rcx+7BCh]
imul rax, rcx
mov [rbp+var_78], rax
mov rax, [rbp+var_28]
mov rcx, [rbp+var_90]
sub rax, [rcx+180h]
cmp rax, 0
jl loc_472F8
cmp [rbp+var_48], 0
jz short loc_472C7
mov rax, 0FFFFFFFFFFh
cmp [rbp+var_48], rax
jz short loc_472B3
mov rcx, [rbp+var_48]
mov rax, [rbp+var_90]
mov eax, [rax+7BCh]
imul rcx, rax
mov rax, [rbp+var_90]
mov [rax+120h], rcx
jmp short loc_472C5
loc_472B3:
mov rax, [rbp+var_90]
mov qword ptr [rax+120h], 0FFFFFFFFFFFFFFFFh
loc_472C5:
jmp short $+2
loc_472C7:
cmp [rbp+var_4D], 0
jz short loc_472F6
mov rdx, [rbp+var_78]
mov rax, [rbp+var_90]
mov eax, [rax+7BCh]
sub rdx, rax
mov rax, [rbp+var_90]
mov rax, [rax+118h]
mov ecx, [rbp+var_4C]
mov [rax+rcx*8], rdx
loc_472F6:
jmp short $+2
loc_472F8:
mov rax, [rbp+var_78]
mov rcx, [rbp+var_90]
cmp rax, [rcx+38h]
jbe short loc_47345
mov rcx, [rbp+var_78]
mov rax, [rbp+var_90]
mov [rax+38h], rcx
mov rax, [rbp+var_20]
mov rax, [rax+380h]
mov [rbp+var_80], rax
mov rax, [rbp+var_20]
mov byte ptr [rax+685h], 1
mov [rbp+var_54], 4
mov [rbp+var_58], 2
jmp loc_4748D
loc_47345:
mov rax, [rbp+var_90]
mov rdi, [rax+600h]
mov rsi, [rbp+var_90]
add rsi, 750h
mov rdx, [rbp+var_40]
lea rax, [rbp+var_70]
xor ecx, ecx
xor r8d, r8d
mov r9d, 1
mov [rsp+0D0h+var_D0], 4
mov [rsp+0D0h+var_C8], rax
call pagecache_read
mov [rbp+var_80], rax
cmp rax, 0
jnz short loc_473F5
call _my_thread_var
cmp dword ptr [rax], 0AFh
jz short loc_473E3
call _my_thread_var
cmp dword ptr [rax], 0B0h
jz short loc_473E3
call _my_thread_var
cmp dword ptr [rax], 0C0h
jz short loc_473E3
mov [rbp+var_84], 1
mov rax, [rbp+var_20]
mov [rbp+var_98], rax
call _my_thread_var
mov rdi, [rbp+var_98]
mov esi, [rax]
call _ma_set_fatal_error
jmp loc_475D3
loc_473E3:
mov rdi, [rbp+var_70]
call pagecache_block_link_to_buffer
mov [rbp+var_80], rax
jmp loc_4747F
loc_473F5:
mov rax, [rbp+var_80]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_80]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_80]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
or eax, ecx
mov eax, eax
shl rax, 20h
mov rcx, [rbp+var_80]
mov ecx, [rcx+3]
or rax, rcx
cmp rax, [rbp+var_28]
jl short loc_4747D
mov rdi, [rbp+var_20]
mov rax, [rbp+var_80]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_80]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_80]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
or eax, ecx
mov eax, eax
mov esi, eax
shl rsi, 20h
mov rax, [rbp+var_80]
mov eax, [rax+3]
or rsi, rax
mov rcx, [rbp+var_40]
xor edx, edx
call check_skipped_lsn
mov [rbp+var_84], 0
jmp loc_475D3
loc_4747D:
jmp short $+2
loc_4747F:
mov [rbp+var_54], 2
mov [rbp+var_58], 0
loc_4748D:
mov rdi, [rbp+var_80]
xor esi, esi
mov edx, 7
call _memset
mov rdi, [rbp+var_80]
add rdi, 7
mov rsi, [rbp+var_30]
mov eax, [rbp+var_34]
mov edx, eax
call _memcpy
mov rdi, [rbp+var_80]
add rdi, 7
mov eax, [rbp+var_34]
add rdi, rax
mov rax, [rbp+var_90]
mov eax, [rax+7C0h]
sub eax, 7
sub eax, [rbp+var_34]
mov eax, eax
mov edx, eax
xor esi, esi
call _memset
mov rdi, [rbp+var_80]
mov rax, [rbp+var_90]
mov eax, [rax+7BCh]
add rdi, rax
add rdi, 0FFFFFFFFFFFFFFFCh
mov esi, 0FFh
mov edx, 4
call _memset
mov [rbp+var_84], 0
cmp [rbp+var_54], 4
jnz loc_475A9
mov rax, [rbp+var_90]
mov rdi, [rax+600h]
mov rsi, [rbp+var_90]
add rsi, 750h
mov rdx, [rbp+var_40]
mov r8, [rbp+var_80]
mov ebx, [rbp+var_54]
mov r11d, [rbp+var_58]
lea r10, [rbp+var_70]
mov rax, [rbp+var_90]
mov rax, [rax+600h]
mov eax, [rax+80h]
xor ecx, ecx
mov r9d, 1
xor r14d, r14d
mov [rsp+0D0h+var_D0], ebx
mov dword ptr [rsp+0D0h+var_C8], r11d
mov [rsp+0D0h+var_C0], 0
mov [rsp+0D0h+var_B8], r10
mov [rsp+0D0h+var_B0], 0
mov [rsp+0D0h+var_A8], 0
mov [rsp+0D0h+var_A0], eax
call pagecache_write_part
movsx eax, al
cmp eax, 0
jz short loc_475A9
mov [rbp+var_84], 1
loc_475A9:
mov [rbp+var_68], 6
mov [rbp+var_60], 1
mov rdi, [rbp+var_20]
add rdi, 2E8h
lea rsi, [rbp+var_70]
call insert_dynamic
mov eax, [rbp+var_84]
mov [rbp+var_14], eax
jmp short loc_47616
loc_475D3:
mov rax, [rbp+var_90]
mov rdi, [rax+600h]
mov rsi, [rbp+var_70]
mov edx, 6
mov ecx, 3
xor eax, eax
mov r9d, eax
xor eax, eax
mov r8, r9
mov [rsp+0D0h+var_D0], 0
mov dword ptr [rsp+0D0h+var_C8], 0
call pagecache_unlock_by_link
mov eax, [rbp+var_84]
mov [rbp+var_14], eax
loc_47616:
mov eax, [rbp+var_14]
add rsp, 0C0h
pop rbx
pop r14
pop rbp
retn
|
long long ma_apply_redo_index_new_page(_QWORD *a1, signed long long a2, long long a3, unsigned int a4)
{
int *v4; // rax
long long v5; // rdx
long long v6; // rcx
long long v7; // r8
int v8; // r9d
_DWORD *v10; // [rsp+38h] [rbp-98h]
long long v11; // [rsp+40h] [rbp-90h]
unsigned int v12; // [rsp+4Ch] [rbp-84h]
BOOL v13; // [rsp+4Ch] [rbp-84h]
unsigned __int16 *v14; // [rsp+50h] [rbp-80h]
unsigned long long v15; // [rsp+58h] [rbp-78h]
long long v16; // [rsp+60h] [rbp-70h] BYREF
int v17; // [rsp+68h] [rbp-68h]
char v18; // [rsp+70h] [rbp-60h]
unsigned int v19; // [rsp+78h] [rbp-58h]
int v20; // [rsp+7Ch] [rbp-54h]
char v21; // [rsp+83h] [rbp-4Dh]
unsigned int v22; // [rsp+84h] [rbp-4Ch]
long long v23; // [rsp+88h] [rbp-48h]
long long v24; // [rsp+90h] [rbp-40h]
unsigned int v25; // [rsp+9Ch] [rbp-34h]
long long v26; // [rsp+A0h] [rbp-30h]
signed long long v27; // [rsp+A8h] [rbp-28h]
_QWORD *v28; // [rsp+B0h] [rbp-20h]
v28 = a1;
v27 = a2;
v26 = a3;
v25 = a4;
v24 = uint5korr(a3);
v23 = uint5korr(v26 + 5);
v22 = *(unsigned __int8 *)(v26 + 10);
v21 = *(_BYTE *)(v26 + 11);
v11 = *a1;
*(_DWORD *)(v11 + 368) |= 0x1B1u;
v26 += 12LL;
v25 -= 12;
v15 = *(unsigned int *)(v11 + 1980) * (v24 + 1);
if ( v27 - *(_QWORD *)(v11 + 384) >= 0 )
{
if ( v23 )
{
if ( v23 == 0xFFFFFFFFFFLL )
*(_QWORD *)(v11 + 288) = -1LL;
else
*(_QWORD *)(v11 + 288) = *(unsigned int *)(v11 + 1980) * v23;
}
if ( v21 )
*(_QWORD *)(*(_QWORD *)(v11 + 280) + 8LL * v22) = v15 - *(unsigned int *)(v11 + 1980);
}
if ( v15 <= *(_QWORD *)(v11 + 56) )
{
v14 = (unsigned __int16 *)pagecache_read(*(_QWORD **)(v11 + 1536), v11 + 1872, v24, 0, 0LL, 1, 4u, (char *)&v16);
if ( v14 )
{
if ( (long long)(*(unsigned int *)((char *)v14 + 3) | ((unsigned long long)((*((unsigned __int8 *)v14 + 2) << 16) | (unsigned int)*v14) << 32)) >= v27 )
{
check_skipped_lsn(
(long long)v28,
*(unsigned int *)((char *)v14 + 3) | ((unsigned long long)((*((unsigned __int8 *)v14 + 2) << 16) | (unsigned int)*v14) << 32),
0,
v24);
v12 = 0;
goto LABEL_22;
}
}
else
{
if ( *(_DWORD *)my_thread_var() != 175 && *(_DWORD *)my_thread_var() != 176 && *(_DWORD *)my_thread_var() != 192 )
{
v12 = 1;
v10 = v28;
v4 = (int *)my_thread_var();
ma_set_fatal_error(v10, *v4, v5, v6, v7, v8);
LABEL_22:
pagecache_unlock_by_link(*(_QWORD **)(v11 + 1536), v16, 6, 3, 0LL, 0LL, 0, 0);
return v12;
}
v14 = (unsigned __int16 *)pagecache_block_link_to_buffer(v16);
}
v20 = 2;
v19 = 0;
memset(v14, 0LL, 7LL);
goto LABEL_19;
}
*(_QWORD *)(v11 + 56) = v15;
v14 = (unsigned __int16 *)v28[112];
*((_BYTE *)v28 + 1669) = 1;
v20 = 4;
v19 = 2;
memset(v14, 0LL, 7LL);
LABEL_19:
memcpy((char *)v14 + 7, v26, v25);
memset((char *)v14 + v25 + 7, 0LL, *(_DWORD *)(v11 + 1984) - 7 - v25);
memset((char *)v14 + *(unsigned int *)(v11 + 1980) - 4, 255LL, 4LL);
v13 = 0;
if ( v20 == 4 )
v13 = pagecache_write_part(
*(_QWORD **)(v11 + 1536),
v11 + 1872,
v24,
0,
(long long)v14,
1u,
4u,
v19,
0,
(char *)&v16,
0LL,
0,
*(_DWORD *)(*(_QWORD *)(v11 + 1536) + 128LL)) != 0;
v17 = 6;
v18 = 1;
insert_dynamic(v28 + 93, &v16);
return v13;
}
|
_ma_apply_redo_index_new_page:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0xc0
MOV qword ptr [RBP + -0x20],RDI
MOV qword ptr [RBP + -0x28],RSI
MOV qword ptr [RBP + -0x30],RDX
MOV dword ptr [RBP + -0x34],ECX
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00147630
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x5
CALL 0x00147630
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX + 0xa]
MOV dword ptr [RBP + -0x4c],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV AL,byte ptr [RAX + 0xb]
MOV byte ptr [RBP + -0x4d],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x90],RAX
JMP 0x00147210
LAB_00147210:
MOV RAX,qword ptr [RBP + -0x90]
MOV ECX,dword ptr [RAX + 0x170]
OR ECX,0x1b1
MOV dword ptr [RAX + 0x170],ECX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0xc
MOV qword ptr [RBP + -0x30],RAX
MOV EAX,dword ptr [RBP + -0x34]
SUB EAX,0xc
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x1
MOV RCX,qword ptr [RBP + -0x90]
MOV ECX,dword ptr [RCX + 0x7bc]
IMUL RAX,RCX
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x90]
SUB RAX,qword ptr [RCX + 0x180]
CMP RAX,0x0
JL 0x001472f8
CMP qword ptr [RBP + -0x48],0x0
JZ 0x001472c7
MOV RAX,0xffffffffff
CMP qword ptr [RBP + -0x48],RAX
JZ 0x001472b3
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x90]
MOV EAX,dword ptr [RAX + 0x7bc]
IMUL RCX,RAX
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RAX + 0x120],RCX
JMP 0x001472c5
LAB_001472b3:
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RAX + 0x120],-0x1
LAB_001472c5:
JMP 0x001472c7
LAB_001472c7:
CMP byte ptr [RBP + -0x4d],0x0
JZ 0x001472f6
MOV RDX,qword ptr [RBP + -0x78]
MOV RAX,qword ptr [RBP + -0x90]
MOV EAX,dword ptr [RAX + 0x7bc]
SUB RDX,RAX
MOV RAX,qword ptr [RBP + -0x90]
MOV RAX,qword ptr [RAX + 0x118]
MOV ECX,dword ptr [RBP + -0x4c]
MOV qword ptr [RAX + RCX*0x8],RDX
LAB_001472f6:
JMP 0x001472f8
LAB_001472f8:
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x90]
CMP RAX,qword ptr [RCX + 0x38]
JBE 0x00147345
MOV RCX,qword ptr [RBP + -0x78]
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RAX + 0x38],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x380]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x685],0x1
MOV dword ptr [RBP + -0x54],0x4
MOV dword ptr [RBP + -0x58],0x2
JMP 0x0014748d
LAB_00147345:
MOV RAX,qword ptr [RBP + -0x90]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x90]
ADD RSI,0x750
MOV RDX,qword ptr [RBP + -0x40]
LEA RAX,[RBP + -0x70]
XOR ECX,ECX
XOR R8D,R8D
MOV R9D,0x1
MOV dword ptr [RSP],0x4
MOV qword ptr [RSP + 0x8],RAX
CALL 0x0013f030
MOV qword ptr [RBP + -0x80],RAX
CMP RAX,0x0
JNZ 0x001473f5
CALL 0x001fe880
CMP dword ptr [RAX],0xaf
JZ 0x001473e3
CALL 0x001fe880
CMP dword ptr [RAX],0xb0
JZ 0x001473e3
CALL 0x001fe880
CMP dword ptr [RAX],0xc0
JZ 0x001473e3
MOV dword ptr [RBP + -0x84],0x1
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x98],RAX
CALL 0x001fe880
MOV RDI,qword ptr [RBP + -0x98]
MOV ESI,dword ptr [RAX]
CALL 0x00145dc0
JMP 0x001475d3
LAB_001473e3:
MOV RDI,qword ptr [RBP + -0x70]
CALL 0x00141b80
MOV qword ptr [RBP + -0x80],RAX
JMP 0x0014747f
LAB_001473f5:
MOV RAX,qword ptr [RBP + -0x80]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x80]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x80]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
OR EAX,ECX
MOV EAX,EAX
SHL RAX,0x20
MOV RCX,qword ptr [RBP + -0x80]
MOV ECX,dword ptr [RCX + 0x3]
OR RAX,RCX
CMP RAX,qword ptr [RBP + -0x28]
JL 0x0014747d
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x80]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x80]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x80]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
OR EAX,ECX
MOV EAX,EAX
MOV ESI,EAX
SHL RSI,0x20
MOV RAX,qword ptr [RBP + -0x80]
MOV EAX,dword ptr [RAX + 0x3]
OR RSI,RAX
MOV RCX,qword ptr [RBP + -0x40]
XOR EDX,EDX
CALL 0x00135e90
MOV dword ptr [RBP + -0x84],0x0
JMP 0x001475d3
LAB_0014747d:
JMP 0x0014747f
LAB_0014747f:
MOV dword ptr [RBP + -0x54],0x2
MOV dword ptr [RBP + -0x58],0x0
LAB_0014748d:
MOV RDI,qword ptr [RBP + -0x80]
XOR ESI,ESI
MOV EDX,0x7
CALL 0x0012a2c0
MOV RDI,qword ptr [RBP + -0x80]
ADD RDI,0x7
MOV RSI,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RBP + -0x34]
MOV EDX,EAX
CALL 0x0012a0b0
MOV RDI,qword ptr [RBP + -0x80]
ADD RDI,0x7
MOV EAX,dword ptr [RBP + -0x34]
ADD RDI,RAX
MOV RAX,qword ptr [RBP + -0x90]
MOV EAX,dword ptr [RAX + 0x7c0]
SUB EAX,0x7
SUB EAX,dword ptr [RBP + -0x34]
MOV EAX,EAX
MOV EDX,EAX
XOR ESI,ESI
CALL 0x0012a2c0
MOV RDI,qword ptr [RBP + -0x80]
MOV RAX,qword ptr [RBP + -0x90]
MOV EAX,dword ptr [RAX + 0x7bc]
ADD RDI,RAX
ADD RDI,-0x4
MOV ESI,0xff
MOV EDX,0x4
CALL 0x0012a2c0
MOV dword ptr [RBP + -0x84],0x0
CMP dword ptr [RBP + -0x54],0x4
JNZ 0x001475a9
MOV RAX,qword ptr [RBP + -0x90]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x90]
ADD RSI,0x750
MOV RDX,qword ptr [RBP + -0x40]
MOV R8,qword ptr [RBP + -0x80]
MOV EBX,dword ptr [RBP + -0x54]
MOV R11D,dword ptr [RBP + -0x58]
LEA R10,[RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x90]
MOV RAX,qword ptr [RAX + 0x600]
MOV EAX,dword ptr [RAX + 0x80]
XOR ECX,ECX
MOV R9D,0x1
XOR R14D,R14D
MOV dword ptr [RSP],EBX
MOV dword ptr [RSP + 0x8],R11D
MOV dword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],R10
MOV qword ptr [RSP + 0x20],0x0
MOV dword ptr [RSP + 0x28],0x0
MOV dword ptr [RSP + 0x30],EAX
CALL 0x00140730
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x001475a9
MOV dword ptr [RBP + -0x84],0x1
LAB_001475a9:
MOV dword ptr [RBP + -0x68],0x6
MOV byte ptr [RBP + -0x60],0x1
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x2e8
LEA RSI,[RBP + -0x70]
CALL 0x001dc6b0
MOV EAX,dword ptr [RBP + -0x84]
MOV dword ptr [RBP + -0x14],EAX
JMP 0x00147616
LAB_001475d3:
MOV RAX,qword ptr [RBP + -0x90]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x70]
MOV EDX,0x6
MOV ECX,0x3
XOR EAX,EAX
MOV R9D,EAX
XOR EAX,EAX
MOV R8,R9
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x8],0x0
CALL 0x0013edd0
MOV EAX,dword ptr [RBP + -0x84]
MOV dword ptr [RBP + -0x14],EAX
LAB_00147616:
MOV EAX,dword ptr [RBP + -0x14]
ADD RSP,0xc0
POP RBX
POP R14
POP RBP
RET
|
int4 _ma_apply_redo_index_new_page(long *param_1,long param_2,long param_3,int param_4)
{
long lVar1;
long *plVar2;
char cVar3;
ulong uVar4;
int *piVar5;
int4 *puVar6;
int8 *puVar7;
int4 local_8c;
int3 *local_88;
int8 local_78;
int4 local_70;
int1 local_68;
int4 local_60;
int local_5c;
char local_55;
uint local_54;
long local_50;
long local_48;
uint local_3c;
void *local_38;
long local_30;
long *local_28;
local_3c = param_4;
local_38 = (void *)param_3;
local_30 = param_2;
local_28 = param_1;
local_48 = uint5korr(param_3);
local_50 = uint5korr((long)local_38 + 5);
local_54 = (uint)*(byte *)((long)local_38 + 10);
local_55 = *(char *)((long)local_38 + 0xb);
lVar1 = *local_28;
*(uint *)(lVar1 + 0x170) = *(uint *)(lVar1 + 0x170) | 0x1b1;
local_38 = (void *)((long)local_38 + 0xc);
local_3c = local_3c - 0xc;
uVar4 = (local_48 + 1) * (ulong)*(uint *)(lVar1 + 0x7bc);
if (-1 < local_30 - *(long *)(lVar1 + 0x180)) {
if (local_50 != 0) {
if (local_50 == 0xffffffffff) {
*(int8 *)(lVar1 + 0x120) = 0xffffffffffffffff;
}
else {
*(ulong *)(lVar1 + 0x120) = local_50 * (ulong)*(uint *)(lVar1 + 0x7bc);
}
}
if (local_55 != '\0') {
*(ulong *)(*(long *)(lVar1 + 0x118) + (ulong)local_54 * 8) = uVar4 - *(uint *)(lVar1 + 0x7bc);
}
}
if (*(ulong *)(lVar1 + 0x38) < uVar4) {
*(ulong *)(lVar1 + 0x38) = uVar4;
local_88 = (int3 *)local_28[0x70];
*(int1 *)((long)local_28 + 0x685) = 1;
local_5c = 4;
local_60 = 2;
}
else {
puVar7 = &local_78;
local_88 = (int3 *)
pagecache_read(*(int8 *)(lVar1 + 0x600),lVar1 + 0x750,local_48,0,0,1,4,puVar7);
if (local_88 == (int3 *)0x0) {
piVar5 = (int *)_my_thread_var();
if (((*piVar5 != 0xaf) && (piVar5 = (int *)_my_thread_var(), *piVar5 != 0xb0)) &&
(piVar5 = (int *)_my_thread_var(), plVar2 = local_28, *piVar5 != 0xc0)) {
local_8c = 1;
puVar6 = (int4 *)_my_thread_var();
_ma_set_fatal_error(plVar2,*puVar6);
LAB_001475d3:
pagecache_unlock_by_link
(*(int8 *)(lVar1 + 0x600),local_78,6,3,0,0,0,
(ulong)puVar7 & 0xffffffff00000000);
return local_8c;
}
local_88 = (int3 *)pagecache_block_link_to_buffer(local_78);
}
else if (local_30 <= (long)(ulong)CONCAT34(*local_88,*(int4 *)((long)local_88 + 3))) {
check_skipped_lsn(local_28,(ulong)CONCAT34(*local_88,*(int4 *)((long)local_88 + 3)),0,
local_48);
local_8c = 0;
goto LAB_001475d3;
}
local_5c = 2;
local_60 = 0;
}
memset(local_88,0,7);
memcpy((void *)((long)local_88 + 7),local_38,(ulong)local_3c);
memset((void *)((long)local_88 + (ulong)local_3c + 7),0,
(ulong)((*(int *)(lVar1 + 0x7c0) + -7) - local_3c));
memset((void *)((long)local_88 + ((ulong)*(uint *)(lVar1 + 0x7bc) - 4)),0xff,4);
local_8c = 0;
if ((local_5c == 4) &&
(cVar3 = pagecache_write_part
(*(int8 *)(lVar1 + 0x600),lVar1 + 0x750,local_48,0,local_88,1,4,
local_60,0,&local_78,0,0,*(int4 *)(*(long *)(lVar1 + 0x600) + 0x80)),
cVar3 != '\0')) {
local_8c = 1;
}
local_70 = 6;
local_68 = 1;
insert_dynamic(local_28 + 0x5d,&local_78);
return local_8c;
}
|
|
19,872
|
find_longest_bitstream
|
eloqsql/storage/maria/ma_packrec.c
|
static uint find_longest_bitstream(uint16 *table, uint16 *end)
{
uint length=1;
uint length2;
if (!(*table & IS_CHAR))
{
uint16 *next= table + *table;
if (next > end || next == table)
{
DBUG_PRINT("error", ("ERROR: illegal pointer in decode tree"));
return OFFSET_TABLE_SIZE;
}
length=find_longest_bitstream(next, end)+1;
}
table++;
if (!(*table & IS_CHAR))
{
uint16 *next= table + *table;
if (next > end || next == table)
{
DBUG_PRINT("error", ("ERROR: illegal pointer in decode tree"));
return OFFSET_TABLE_SIZE;
}
length2= find_longest_bitstream(next, end) + 1;
length=MY_MAX(length,length2);
}
return length;
}
|
O0
|
c
|
find_longest_bitstream:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
andl $0x8000, %eax # imm = 0x8000
cmpl $0x0, %eax
jne 0x4df67
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movzwl (%rcx), %ecx
movslq %ecx, %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0x4df44
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x4df54
jmp 0x4df46
jmp 0x4df48
movl $0x200, -0x4(%rbp) # imm = 0x200
jmp 0x4dff2
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4def0
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
andl $0x8000, %eax # imm = 0x8000
cmpl $0x0, %eax
jne 0x4dfec
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movzwl (%rcx), %ecx
movslq %ecx, %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0x4dfb0
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x4dfbd
jmp 0x4dfb2
jmp 0x4dfb4
movl $0x200, -0x4(%rbp) # imm = 0x200
jmp 0x4dff2
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4def0
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jbe 0x4dfe0
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x4dfe6
movl -0x20(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
find_longest_bitstream:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], 1
mov rax, [rbp+var_10]
movzx eax, word ptr [rax]
and eax, 8000h
cmp eax, 0
jnz short loc_4DF67
mov rax, [rbp+var_10]
mov rcx, [rbp+var_10]
movzx ecx, word ptr [rcx]
movsxd rcx, ecx
shl rcx, 1
add rax, rcx
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
cmp rax, [rbp+var_18]
ja short loc_4DF44
mov rax, [rbp+var_28]
cmp rax, [rbp+var_10]
jnz short loc_4DF54
loc_4DF44:
jmp short $+2
loc_4DF46:
jmp short $+2
loc_4DF48:
mov [rbp+var_4], 200h
jmp loc_4DFF2
loc_4DF54:
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_18]
call find_longest_bitstream
add eax, 1
mov [rbp+var_1C], eax
loc_4DF67:
mov rax, [rbp+var_10]
add rax, 2
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
movzx eax, word ptr [rax]
and eax, 8000h
cmp eax, 0
jnz short loc_4DFEC
mov rax, [rbp+var_10]
mov rcx, [rbp+var_10]
movzx ecx, word ptr [rcx]
movsxd rcx, ecx
shl rcx, 1
add rax, rcx
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
cmp rax, [rbp+var_18]
ja short loc_4DFB0
mov rax, [rbp+var_30]
cmp rax, [rbp+var_10]
jnz short loc_4DFBD
loc_4DFB0:
jmp short $+2
loc_4DFB2:
jmp short $+2
loc_4DFB4:
mov [rbp+var_4], 200h
jmp short loc_4DFF2
loc_4DFBD:
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_18]
call find_longest_bitstream
add eax, 1
mov [rbp+var_20], eax
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_20]
jbe short loc_4DFE0
mov eax, [rbp+var_1C]
mov [rbp+var_34], eax
jmp short loc_4DFE6
loc_4DFE0:
mov eax, [rbp+var_20]
mov [rbp+var_34], eax
loc_4DFE6:
mov eax, [rbp+var_34]
mov [rbp+var_1C], eax
loc_4DFEC:
mov eax, [rbp+var_1C]
mov [rbp+var_4], eax
loc_4DFF2:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
|
long long find_longest_bitstream(unsigned __int16 *a1, unsigned long long a2)
{
unsigned __int16 *v4; // [rsp+10h] [rbp-30h]
unsigned __int16 *v5; // [rsp+18h] [rbp-28h]
unsigned int v6; // [rsp+20h] [rbp-20h]
unsigned int v7; // [rsp+24h] [rbp-1Ch]
unsigned __int16 *v8; // [rsp+30h] [rbp-10h]
v7 = 1;
if ( (*a1 & 0x8000) != 0 )
{
LABEL_6:
v8 = a1 + 1;
if ( (a1[1] & 0x8000) == 0 )
{
v4 = &v8[*v8];
if ( (unsigned long long)v4 > a2 || v4 == v8 )
return 512;
v6 = find_longest_bitstream(v4, a2) + 1;
if ( v7 <= v6 )
return v6;
else
return v7;
}
return v7;
}
v5 = &a1[*a1];
if ( (unsigned long long)v5 <= a2 && v5 != a1 )
{
v7 = find_longest_bitstream(v5, a2) + 1;
goto LABEL_6;
}
return 512;
}
|
find_longest_bitstream:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],0x1
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,word ptr [RAX]
AND EAX,0x8000
CMP EAX,0x0
JNZ 0x0014df67
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,word ptr [RCX]
MOVSXD RCX,ECX
SHL RCX,0x1
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x18]
JA 0x0014df44
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x10]
JNZ 0x0014df54
LAB_0014df44:
JMP 0x0014df46
LAB_0014df46:
JMP 0x0014df48
LAB_0014df48:
MOV dword ptr [RBP + -0x4],0x200
JMP 0x0014dff2
LAB_0014df54:
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0014def0
ADD EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
LAB_0014df67:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,word ptr [RAX]
AND EAX,0x8000
CMP EAX,0x0
JNZ 0x0014dfec
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,word ptr [RCX]
MOVSXD RCX,ECX
SHL RCX,0x1
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x18]
JA 0x0014dfb0
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x10]
JNZ 0x0014dfbd
LAB_0014dfb0:
JMP 0x0014dfb2
LAB_0014dfb2:
JMP 0x0014dfb4
LAB_0014dfb4:
MOV dword ptr [RBP + -0x4],0x200
JMP 0x0014dff2
LAB_0014dfbd:
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0014def0
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x20]
JBE 0x0014dfe0
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x34],EAX
JMP 0x0014dfe6
LAB_0014dfe0:
MOV EAX,dword ptr [RBP + -0x20]
MOV dword ptr [RBP + -0x34],EAX
LAB_0014dfe6:
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x1c],EAX
LAB_0014dfec:
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x4],EAX
LAB_0014dff2:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
uint find_longest_bitstream(ushort *param_1,ushort *param_2)
{
int iVar1;
ushort *puVar2;
uint local_3c;
uint local_24;
local_24 = 1;
if ((*param_1 & 0x8000) == 0) {
puVar2 = param_1 + (int)(uint)*param_1;
if ((param_2 < puVar2) || (puVar2 == param_1)) {
return 0x200;
}
iVar1 = find_longest_bitstream(puVar2,param_2);
local_24 = iVar1 + 1;
}
param_1 = param_1 + 1;
if ((*param_1 & 0x8000) == 0) {
puVar2 = param_1 + (int)(uint)*param_1;
if ((param_2 < puVar2) || (puVar2 == param_1)) {
return 0x200;
}
iVar1 = find_longest_bitstream(puVar2,param_2);
local_3c = iVar1 + 1;
if (local_3c < local_24) {
local_3c = local_24;
}
local_24 = local_3c;
}
return local_24;
}
|
|
19,873
|
translog_recover_page_up_to_sector
|
eloqsql/storage/maria/ma_loghandler.c
|
static my_bool translog_recover_page_up_to_sector(uchar *page, uint16 offset)
{
uint16 chunk_offset= translog_get_first_chunk_offset(page), valid_chunk_end;
DBUG_ENTER("translog_recover_page_up_to_sector");
DBUG_PRINT("enter", ("offset: %u first chunk: %u",
(uint) offset, (uint) chunk_offset));
while (chunk_offset < offset && page[chunk_offset] != TRANSLOG_FILLER)
{
uint16 chunk_length;
if ((chunk_length=
translog_get_total_chunk_length(page, chunk_offset)) == 0)
{
DBUG_PRINT("error", ("cant get chunk length (offset %u)",
(uint) chunk_offset));
DBUG_RETURN(1);
}
DBUG_PRINT("info", ("chunk: offset: %u length %u",
(uint) chunk_offset, (uint) chunk_length));
if (((ulong) chunk_offset) + ((ulong) chunk_length) > TRANSLOG_PAGE_SIZE)
{
DBUG_PRINT("error", ("damaged chunk (offset %u) in trusted area",
(uint) chunk_offset));
DBUG_RETURN(1);
}
chunk_offset+= chunk_length;
}
valid_chunk_end= chunk_offset;
/* end of trusted area - sector parsing */
while (page[chunk_offset] != TRANSLOG_FILLER)
{
uint16 chunk_length;
if ((chunk_length=
translog_get_total_chunk_length(page, chunk_offset)) == 0)
break;
DBUG_PRINT("info", ("chunk: offset: %u length %u",
(uint) chunk_offset, (uint) chunk_length));
if (((ulong) chunk_offset) + ((ulong) chunk_length) >
(uint) (offset + DISK_DRIVE_SECTOR_SIZE))
break;
chunk_offset+= chunk_length;
valid_chunk_end= chunk_offset;
}
DBUG_PRINT("info", ("valid chunk end offset: %u", (uint) valid_chunk_end));
memset(page + valid_chunk_end, TRANSLOG_FILLER,
TRANSLOG_PAGE_SIZE - valid_chunk_end);
DBUG_RETURN(0);
}
|
O0
|
c
|
translog_recover_page_up_to_sector:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8c9b0
movsbl %al, %eax
movw %ax, -0x14(%rbp)
jmp 0x93055
jmp 0x93057
movzwl -0x14(%rbp), %ecx
movzwl -0x12(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x1b(%rbp)
jge 0x9307f
movq -0x10(%rbp), %rax
movzwl -0x14(%rbp), %ecx
movzbl (%rax,%rcx), %eax
cmpl $0xff, %eax
setne %al
movb %al, -0x1b(%rbp)
movb -0x1b(%rbp), %al
testb $0x1, %al
jne 0x93088
jmp 0x930e9
movq -0x10(%rbp), %rdi
movzwl -0x14(%rbp), %esi
callq 0x8c9e0
movw %ax, -0x18(%rbp)
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0x930b0
jmp 0x930a3
jmp 0x930a5
jmp 0x930a7
movb $0x1, -0x1(%rbp)
jmp 0x93187
jmp 0x930b2
jmp 0x930b4
movzwl -0x14(%rbp), %eax
movzwl -0x18(%rbp), %ecx
addq %rcx, %rax
cmpq $0x2000, %rax # imm = 0x2000
jbe 0x930d6
jmp 0x930c9
jmp 0x930cb
jmp 0x930cd
movb $0x1, -0x1(%rbp)
jmp 0x93187
movzwl -0x18(%rbp), %ecx
movzwl -0x14(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x14(%rbp)
jmp 0x93057
movw -0x14(%rbp), %ax
movw %ax, -0x16(%rbp)
movq -0x10(%rbp), %rax
movzwl -0x14(%rbp), %ecx
movzbl (%rax,%rcx), %eax
cmpl $0xff, %eax
je 0x93159
movq -0x10(%rbp), %rdi
movzwl -0x14(%rbp), %esi
callq 0x8c9e0
movw %ax, -0x1a(%rbp)
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0x9311f
jmp 0x93159
jmp 0x93121
jmp 0x93123
movzwl -0x14(%rbp), %eax
movzwl -0x1a(%rbp), %ecx
addq %rcx, %rax
movzwl -0x12(%rbp), %ecx
addl $0x200, %ecx # imm = 0x200
movl %ecx, %ecx
cmpq %rcx, %rax
jbe 0x93141
jmp 0x93159
movzwl -0x1a(%rbp), %ecx
movzwl -0x14(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x14(%rbp)
movw -0x14(%rbp), %ax
movw %ax, -0x16(%rbp)
jmp 0x930f1
jmp 0x9315b
jmp 0x9315d
movq -0x10(%rbp), %rdi
movzwl -0x16(%rbp), %eax
cltq
addq %rax, %rdi
movzwl -0x16(%rbp), %ecx
movl $0x2000, %eax # imm = 0x2000
subl %ecx, %eax
movl %eax, %eax
movl %eax, %edx
movl $0xff, %esi
callq 0x2a2a0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
|
translog_recover_page_up_to_sector:
push rbp
mov rbp, rsp
sub rsp, 20h
mov ax, si
mov [rbp+var_10], rdi
mov [rbp+var_12], ax
mov rdi, [rbp+var_10]
call translog_get_first_chunk_offset
movsx eax, al
mov [rbp+var_14], ax
jmp short $+2
loc_93055:
jmp short $+2
loc_93057:
movzx ecx, [rbp+var_14]
movzx edx, [rbp+var_12]
xor eax, eax
cmp ecx, edx
mov [rbp+var_1B], al
jge short loc_9307F
mov rax, [rbp+var_10]
movzx ecx, [rbp+var_14]
movzx eax, byte ptr [rax+rcx]
cmp eax, 0FFh
setnz al
mov [rbp+var_1B], al
loc_9307F:
mov al, [rbp+var_1B]
test al, 1
jnz short loc_93088
jmp short loc_930E9
loc_93088:
mov rdi, [rbp+var_10]
movzx esi, [rbp+var_14]
call translog_get_total_chunk_length
mov [rbp+var_18], ax
movzx eax, ax
cmp eax, 0
jnz short loc_930B0
jmp short $+2
loc_930A3:
jmp short $+2
loc_930A5:
jmp short $+2
loc_930A7:
mov [rbp+var_1], 1
jmp loc_93187
loc_930B0:
jmp short $+2
loc_930B2:
jmp short $+2
loc_930B4:
movzx eax, [rbp+var_14]
movzx ecx, [rbp+var_18]
add rax, rcx
cmp rax, 2000h
jbe short loc_930D6
jmp short $+2
loc_930C9:
jmp short $+2
loc_930CB:
jmp short $+2
loc_930CD:
mov [rbp+var_1], 1
jmp loc_93187
loc_930D6:
movzx ecx, [rbp+var_18]
movzx eax, [rbp+var_14]
add eax, ecx
mov [rbp+var_14], ax
jmp loc_93057
loc_930E9:
mov ax, [rbp+var_14]
mov [rbp+var_16], ax
loc_930F1:
mov rax, [rbp+var_10]
movzx ecx, [rbp+var_14]
movzx eax, byte ptr [rax+rcx]
cmp eax, 0FFh
jz short loc_93159
mov rdi, [rbp+var_10]
movzx esi, [rbp+var_14]
call translog_get_total_chunk_length
mov [rbp+var_1A], ax
movzx eax, ax
cmp eax, 0
jnz short loc_9311F
jmp short loc_93159
loc_9311F:
jmp short $+2
loc_93121:
jmp short $+2
loc_93123:
movzx eax, [rbp+var_14]
movzx ecx, [rbp+var_1A]
add rax, rcx
movzx ecx, [rbp+var_12]
add ecx, 200h
mov ecx, ecx
cmp rax, rcx
jbe short loc_93141
jmp short loc_93159
loc_93141:
movzx ecx, [rbp+var_1A]
movzx eax, [rbp+var_14]
add eax, ecx
mov [rbp+var_14], ax
mov ax, [rbp+var_14]
mov [rbp+var_16], ax
jmp short loc_930F1
loc_93159:
jmp short $+2
loc_9315B:
jmp short $+2
loc_9315D:
mov rdi, [rbp+var_10]
movzx eax, [rbp+var_16]
cdqe
add rdi, rax
movzx ecx, [rbp+var_16]
mov eax, 2000h
sub eax, ecx
mov eax, eax
mov edx, eax
mov esi, 0FFh
call _memset
mov [rbp+var_1], 0
loc_93187:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
|
char translog_recover_page_up_to_sector(long long a1, unsigned __int16 a2)
{
bool v3; // [rsp+5h] [rbp-1Bh]
unsigned __int16 v4; // [rsp+6h] [rbp-1Ah]
unsigned __int16 total_chunk_length; // [rsp+8h] [rbp-18h]
unsigned __int16 j; // [rsp+Ah] [rbp-16h]
unsigned __int16 i; // [rsp+Ch] [rbp-14h]
for ( i = translog_get_first_chunk_offset(a1); ; i += total_chunk_length )
{
v3 = 0;
if ( i < (int)a2 )
v3 = *(unsigned __int8 *)(a1 + i) != 255;
if ( !v3 )
break;
total_chunk_length = translog_get_total_chunk_length(a1, i);
if ( !total_chunk_length )
return 1;
if ( total_chunk_length + (unsigned long long)i > 0x2000 )
return 1;
}
for ( j = i; *(unsigned __int8 *)(a1 + i) != 255; j = i )
{
v4 = translog_get_total_chunk_length(a1, i);
if ( !v4 || v4 + (unsigned long long)i > (unsigned int)a2 + 512 )
break;
i += v4;
}
memset(j + a1, 255LL, 0x2000 - (unsigned int)j);
return 0;
}
|
translog_recover_page_up_to_sector:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV AX,SI
MOV qword ptr [RBP + -0x10],RDI
MOV word ptr [RBP + -0x12],AX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0018c9b0
MOVSX EAX,AL
MOV word ptr [RBP + -0x14],AX
JMP 0x00193055
LAB_00193055:
JMP 0x00193057
LAB_00193057:
MOVZX ECX,word ptr [RBP + -0x14]
MOVZX EDX,word ptr [RBP + -0x12]
XOR EAX,EAX
CMP ECX,EDX
MOV byte ptr [RBP + -0x1b],AL
JGE 0x0019307f
MOV RAX,qword ptr [RBP + -0x10]
MOVZX ECX,word ptr [RBP + -0x14]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0xff
SETNZ AL
MOV byte ptr [RBP + -0x1b],AL
LAB_0019307f:
MOV AL,byte ptr [RBP + -0x1b]
TEST AL,0x1
JNZ 0x00193088
JMP 0x001930e9
LAB_00193088:
MOV RDI,qword ptr [RBP + -0x10]
MOVZX ESI,word ptr [RBP + -0x14]
CALL 0x0018c9e0
MOV word ptr [RBP + -0x18],AX
MOVZX EAX,AX
CMP EAX,0x0
JNZ 0x001930b0
JMP 0x001930a3
LAB_001930a3:
JMP 0x001930a5
LAB_001930a5:
JMP 0x001930a7
LAB_001930a7:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00193187
LAB_001930b0:
JMP 0x001930b2
LAB_001930b2:
JMP 0x001930b4
LAB_001930b4:
MOVZX EAX,word ptr [RBP + -0x14]
MOVZX ECX,word ptr [RBP + -0x18]
ADD RAX,RCX
CMP RAX,0x2000
JBE 0x001930d6
JMP 0x001930c9
LAB_001930c9:
JMP 0x001930cb
LAB_001930cb:
JMP 0x001930cd
LAB_001930cd:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00193187
LAB_001930d6:
MOVZX ECX,word ptr [RBP + -0x18]
MOVZX EAX,word ptr [RBP + -0x14]
ADD EAX,ECX
MOV word ptr [RBP + -0x14],AX
JMP 0x00193057
LAB_001930e9:
MOV AX,word ptr [RBP + -0x14]
MOV word ptr [RBP + -0x16],AX
LAB_001930f1:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX ECX,word ptr [RBP + -0x14]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0xff
JZ 0x00193159
MOV RDI,qword ptr [RBP + -0x10]
MOVZX ESI,word ptr [RBP + -0x14]
CALL 0x0018c9e0
MOV word ptr [RBP + -0x1a],AX
MOVZX EAX,AX
CMP EAX,0x0
JNZ 0x0019311f
JMP 0x00193159
LAB_0019311f:
JMP 0x00193121
LAB_00193121:
JMP 0x00193123
LAB_00193123:
MOVZX EAX,word ptr [RBP + -0x14]
MOVZX ECX,word ptr [RBP + -0x1a]
ADD RAX,RCX
MOVZX ECX,word ptr [RBP + -0x12]
ADD ECX,0x200
MOV ECX,ECX
CMP RAX,RCX
JBE 0x00193141
JMP 0x00193159
LAB_00193141:
MOVZX ECX,word ptr [RBP + -0x1a]
MOVZX EAX,word ptr [RBP + -0x14]
ADD EAX,ECX
MOV word ptr [RBP + -0x14],AX
MOV AX,word ptr [RBP + -0x14]
MOV word ptr [RBP + -0x16],AX
JMP 0x001930f1
LAB_00193159:
JMP 0x0019315b
LAB_0019315b:
JMP 0x0019315d
LAB_0019315d:
MOV RDI,qword ptr [RBP + -0x10]
MOVZX EAX,word ptr [RBP + -0x16]
CDQE
ADD RDI,RAX
MOVZX ECX,word ptr [RBP + -0x16]
MOV EAX,0x2000
SUB EAX,ECX
MOV EAX,EAX
MOV EDX,EAX
MOV ESI,0xff
CALL 0x0012a2a0
MOV byte ptr [RBP + -0x1],0x0
LAB_00193187:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 translog_recover_page_up_to_sector(long param_1,ushort param_2)
{
char cVar1;
ushort uVar2;
bool bVar3;
ushort local_1c;
cVar1 = translog_get_first_chunk_offset(param_1);
local_1c = (ushort)cVar1;
while( true ) {
bVar3 = false;
if (local_1c < param_2) {
bVar3 = *(char *)(param_1 + (ulong)local_1c) != -1;
}
if (!bVar3) {
for (; ((*(char *)(param_1 + (ulong)local_1c) != -1 &&
(uVar2 = translog_get_total_chunk_length(param_1,local_1c), uVar2 != 0)) &&
((uint)local_1c + (uint)uVar2 <= param_2 + 0x200)); local_1c = local_1c + uVar2) {
}
memset((void *)(param_1 + (int)(uint)local_1c),0xff,(ulong)(0x2000 - local_1c));
return 0;
}
uVar2 = translog_get_total_chunk_length(param_1,local_1c);
if (uVar2 == 0) {
return 1;
}
if (0x2000 < (ulong)local_1c + (ulong)uVar2) break;
local_1c = local_1c + uVar2;
}
return 1;
}
|
|
19,874
|
ftxui::Screen::PixelAt(int, int) const
|
Andrewchistyakov[P]flashcards_lyc/build_O3/_deps/ftxui-src/src/ftxui/screen/screen.cpp
|
const Pixel& Screen::PixelAt(int x, int y) const {
return stencil.Contain(x, y) ? pixels_[y][x] : dev_null_pixel();
}
|
O3
|
cpp
|
ftxui::Screen::PixelAt(int, int) const:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
callq 0x38fb4
testb %al, %al
je 0x398da
movslq %ebp, %rax
movq 0x18(%r14), %rcx
leaq (%rax,%rax,2), %rdx
movslq %ebx, %rax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq (%rcx,%rdx,8), %rax
jmp 0x398e6
callq 0x398eb
leaq 0x20a9a(%rip), %rax # 0x5a380
popq %rbx
popq %r14
popq %rbp
retq
|
_ZNK5ftxui6Screen7PixelAtEii:
push rbp
push r14
push rbx
mov ebp, edx
mov ebx, esi
mov r14, rdi
call _ZNK5ftxui3Box7ContainEii; ftxui::Box::Contain(int,int)
test al, al
jz short loc_398DA
movsxd rax, ebp
mov rcx, [r14+18h]
lea rdx, [rax+rax*2]
movsxd rax, ebx
lea rax, [rax+rax*2]
shl rax, 4
add rax, [rcx+rdx*8]
jmp short loc_398E6
loc_398DA:
call _ZN5ftxui12_GLOBAL__N_114dev_null_pixelEv; ftxui::`anonymous namespace'::dev_null_pixel(void)
lea rax, _ZZN5ftxui12_GLOBAL__N_114dev_null_pixelEvE5pixel; ftxui::`anonymous namespace'::dev_null_pixel(void)::pixel
loc_398E6:
pop rbx
pop r14
pop rbp
retn
|
void * ftxui::Screen::PixelAt(ftxui::Screen *this, int a2, int a3)
{
if ( ftxui::Box::Contain(this, a2, a3) )
return (void *)(*(_QWORD *)(*((_QWORD *)this + 3) + 24LL * a3) + 48LL * a2);
ftxui::`anonymous namespace'::dev_null_pixel(this);
return &ftxui::`anonymous namespace'::dev_null_pixel(void)::pixel;
}
|
PixelAt:
PUSH RBP
PUSH R14
PUSH RBX
MOV EBP,EDX
MOV EBX,ESI
MOV R14,RDI
CALL 0x00138fb4
TEST AL,AL
JZ 0x001398da
MOVSXD RAX,EBP
MOV RCX,qword ptr [R14 + 0x18]
LEA RDX,[RAX + RAX*0x2]
MOVSXD RAX,EBX
LEA RAX,[RAX + RAX*0x2]
SHL RAX,0x4
ADD RAX,qword ptr [RCX + RDX*0x8]
JMP 0x001398e6
LAB_001398da:
CALL 0x001398eb
LEA RAX,[0x15a380]
LAB_001398e6:
POP RBX
POP R14
POP RBP
RET
|
/* ftxui::Screen::PixelAt(int, int) const */
int1 * __thiscall ftxui::Screen::PixelAt(Screen *this,int param_1,int param_2)
{
char cVar1;
int1 *puVar2;
cVar1 = Box::Contain((Box *)this,param_1,param_2);
if (cVar1 == '\0') {
(anonymous_namespace)::dev_null_pixel();
puVar2 = (anonymous_namespace)::dev_null_pixel()::pixel;
}
else {
puVar2 = (int1 *)
((long)param_1 * 0x30 + *(long *)(*(long *)(this + 0x18) + (long)param_2 * 0x18));
}
return puVar2;
}
|
|
19,875
|
get_length
|
eloqsql/strings/my_vsnprintf.c
|
static const char *get_length(const char *fmt, size_t *length, uint *pre_zero)
{
for (; my_isdigit(&my_charset_latin1, *fmt); fmt++)
{
*length= *length * 10 + (uint)(*fmt - '0');
if (!*length)
*pre_zero|= PREZERO_ARG; /* first digit was 0 */
}
return fmt;
}
|
O0
|
c
|
get_length:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x1fefe9(%rip), %rax # 0x273970
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x749e2
movq -0x10(%rbp), %rax
imulq $0xa, (%rax), %rcx
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
movl %eax, %eax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x749d2
movq -0x18(%rbp), %rax
movl (%rax), %ecx
orl $0x4, %ecx
movl %ecx, (%rax)
jmp 0x749d4
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x74980
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
|
get_length:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
loc_74980:
lea rax, my_charset_latin1
mov rax, [rax+40h]
mov rcx, [rbp+var_8]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx+1]
and eax, 4
cmp eax, 0
jz short loc_749E2
mov rax, [rbp+var_10]
imul rcx, [rax], 0Ah
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax]
sub eax, 30h ; '0'
mov eax, eax
add rcx, rax
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_10]
cmp qword ptr [rax], 0
jnz short loc_749D2
mov rax, [rbp+var_18]
mov ecx, [rax]
or ecx, 4
mov [rax], ecx
loc_749D2:
jmp short $+2
loc_749D4:
mov rax, [rbp+var_8]
add rax, 1
mov [rbp+var_8], rax
jmp short loc_74980
loc_749E2:
mov rax, [rbp+var_8]
pop rbp
retn
|
unsigned __int8 * get_length(unsigned __int8 *a1, _QWORD *a2, _DWORD *a3)
{
while ( (*(_BYTE *)(*(_QWORD *)&my_charset_latin1[16] + *a1 + 1LL) & 4) != 0 )
{
*a2 = (unsigned int)((char)*a1 - 48) + 10LL * *a2;
if ( !*a2 )
*a3 |= 4u;
++a1;
}
return a1;
}
|
get_length:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
LAB_00174980:
LEA RAX,[0x373970]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x4
CMP EAX,0x0
JZ 0x001749e2
MOV RAX,qword ptr [RBP + -0x10]
IMUL RCX,qword ptr [RAX],0xa
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX]
SUB EAX,0x30
MOV EAX,EAX
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX],0x0
JNZ 0x001749d2
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX]
OR ECX,0x4
MOV dword ptr [RAX],ECX
LAB_001749d2:
JMP 0x001749d4
LAB_001749d4:
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00174980
LAB_001749e2:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
byte * get_length(byte *param_1,long *param_2,uint *param_3)
{
byte *local_10;
local_10 = param_1;
while ((PTR_ctype_latin1_003739b0[(ulong)*local_10 + 1] & 4) != 0) {
*param_2 = *param_2 * 10 + (ulong)((int)(char)*local_10 - 0x30);
if (*param_2 == 0) {
*param_3 = *param_3 | 4;
}
local_10 = local_10 + 1;
}
return local_10;
}
|
|
19,876
|
my_casedn_utf16
|
eloqsql/strings/ctype-ucs2.c
|
static size_t
my_casedn_utf16(CHARSET_INFO *cs, const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
my_charset_conv_wc_mb wc_mb= cs->cset->wc_mb;
int res;
const char *srcend= src + srclen;
char *dstend= dst + dstlen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(srclen <= dstlen);
while ((src < srcend) &&
(res= mb_wc(cs, &wc, (uchar *) src, (uchar *) srcend)) > 0)
{
my_tolower_utf16(uni_plane, &wc);
if (res != wc_mb(cs, wc, (uchar *) dst, (uchar *) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
}
|
O3
|
c
|
my_casedn_utf16:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
testq %rdx, %rdx
jle 0x4523b
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x78(%rdi), %rax
movq %rax, -0x50(%rbp)
movq 0xb8(%rdi), %rax
movq 0x28(%rax), %rcx
movq %rcx, -0x58(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
leaq (%rsi,%rax), %r14
addq %r15, -0x38(%rbp)
movq %r13, %rdi
leaq -0x40(%rbp), %rsi
movq %r12, %rdx
movq %r14, %rcx
callq *-0x58(%rbp)
testl %eax, %eax
jle 0x4523b
movl %eax, %ebx
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rax
cmpq (%rax), %rsi
ja 0x4521d
movq 0x8(%rax), %rax
movq %rsi, %rcx
shrq $0x8, %rcx
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0x4521d
movzbl %sil, %ecx
leaq (%rcx,%rcx,2), %rcx
movl 0x4(%rax,%rcx,4), %esi
movq %rsi, -0x40(%rbp)
movq %r13, %rdi
movq %r15, %rdx
movq -0x38(%rbp), %rcx
callq *-0x48(%rbp)
cmpl %eax, %ebx
jne 0x4523b
movl %ebx, %eax
addq %rax, %r12
addq %rax, %r15
cmpq %r14, %r12
jb 0x451d6
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_casedn_utf16:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov [rbp+var_38], r8
mov [rbp+var_30], rdx
test rdx, rdx
jle loc_4523B
mov r15, rcx
mov r12, rsi
mov r13, rdi
mov rax, [rdi+78h]
mov [rbp+var_50], rax
mov rax, [rdi+0B8h]
mov rcx, [rax+28h]
mov [rbp+var_58], rcx
mov rax, [rax+30h]
mov [rbp+var_48], rax
mov rax, [rbp+var_30]
lea r14, [rsi+rax]
add [rbp+var_38], r15
loc_451D6:
mov rdi, r13
lea rsi, [rbp+var_40]
mov rdx, r12
mov rcx, r14
call [rbp+var_58]
test eax, eax
jle short loc_4523B
mov ebx, eax
mov rsi, [rbp+var_40]
mov rax, [rbp+var_50]
cmp rsi, [rax]
ja short loc_4521D
mov rax, [rax+8]
mov rcx, rsi
shr rcx, 8
mov rax, [rax+rcx*8]
test rax, rax
jz short loc_4521D
movzx ecx, sil
lea rcx, [rcx+rcx*2]
mov esi, [rax+rcx*4+4]
mov [rbp+var_40], rsi
loc_4521D:
mov rdi, r13
mov rdx, r15
mov rcx, [rbp+var_38]
call [rbp+var_48]
cmp ebx, eax
jnz short loc_4523B
mov eax, ebx
add r12, rax
add r15, rax
cmp r12, r14
jb short loc_451D6
loc_4523B:
mov rax, [rbp+var_30]
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_casedn_utf16(long long a1, unsigned long long a2, long long a3, long long a4, long long a5)
{
long long v5; // r15
unsigned long long v6; // r12
long long v7; // rax
unsigned long long v8; // r14
int v9; // eax
unsigned int v10; // ebx
unsigned long long v11; // rsi
long long v12; // rax
long long ( *v14)(long long, unsigned long long *, unsigned long long, unsigned long long); // [rsp+8h] [rbp-58h]
unsigned long long *v15; // [rsp+10h] [rbp-50h]
unsigned int ( *v16)(long long, unsigned long long, long long, long long); // [rsp+18h] [rbp-48h]
unsigned long long v17; // [rsp+20h] [rbp-40h] BYREF
long long v18; // [rsp+28h] [rbp-38h]
long long v19; // [rsp+30h] [rbp-30h]
v18 = a5;
v19 = a3;
if ( a3 > 0 )
{
v5 = a4;
v6 = a2;
v15 = *(unsigned long long **)(a1 + 120);
v7 = *(_QWORD *)(a1 + 184);
v14 = *(long long ( **)(long long, unsigned long long *, unsigned long long, unsigned long long))(v7 + 40);
v16 = *(unsigned int ( **)(long long, unsigned long long, long long, long long))(v7 + 48);
v8 = a2 + v19;
v18 += a4;
do
{
v9 = v14(a1, &v17, v6, v8);
if ( v9 <= 0 )
break;
v10 = v9;
v11 = v17;
if ( v17 <= *v15 )
{
v12 = *(_QWORD *)(v15[1] + 8 * (v17 >> 8));
if ( v12 )
{
v11 = *(unsigned int *)(v12 + 12LL * (unsigned __int8)v17 + 4);
v17 = v11;
}
}
if ( v10 != v16(a1, v11, v5, v18) )
break;
v6 += v10;
v5 += v10;
}
while ( v6 < v8 );
}
return v19;
}
|
my_casedn_utf16:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],R8
MOV qword ptr [RBP + -0x30],RDX
TEST RDX,RDX
JLE 0x0014523b
MOV R15,RCX
MOV R12,RSI
MOV R13,RDI
MOV RAX,qword ptr [RDI + 0x78]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RDI + 0xb8]
MOV RCX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x58],RCX
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x30]
LEA R14,[RSI + RAX*0x1]
ADD qword ptr [RBP + -0x38],R15
LAB_001451d6:
MOV RDI,R13
LEA RSI,[RBP + -0x40]
MOV RDX,R12
MOV RCX,R14
CALL qword ptr [RBP + -0x58]
TEST EAX,EAX
JLE 0x0014523b
MOV EBX,EAX
MOV RSI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x50]
CMP RSI,qword ptr [RAX]
JA 0x0014521d
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,RSI
SHR RCX,0x8
MOV RAX,qword ptr [RAX + RCX*0x8]
TEST RAX,RAX
JZ 0x0014521d
MOVZX ECX,SIL
LEA RCX,[RCX + RCX*0x2]
MOV ESI,dword ptr [RAX + RCX*0x4 + 0x4]
MOV qword ptr [RBP + -0x40],RSI
LAB_0014521d:
MOV RDI,R13
MOV RDX,R15
MOV RCX,qword ptr [RBP + -0x38]
CALL qword ptr [RBP + -0x48]
CMP EBX,EAX
JNZ 0x0014523b
MOV EAX,EBX
ADD R12,RAX
ADD R15,RAX
CMP R12,R14
JC 0x001451d6
LAB_0014523b:
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_casedn_utf16(long param_1,ulong param_2,long param_3,long param_4,long param_5)
{
ulong uVar1;
ulong *puVar2;
code *pcVar3;
code *pcVar4;
long lVar5;
uint uVar6;
uint uVar7;
ulong local_48;
long local_40;
long local_38;
local_38 = param_3;
if (0 < param_3) {
puVar2 = *(ulong **)(param_1 + 0x78);
pcVar3 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
pcVar4 = *(code **)(*(long *)(param_1 + 0xb8) + 0x30);
uVar1 = param_2 + param_3;
local_40 = param_5 + param_4;
do {
uVar6 = (*pcVar3)(param_1,&local_48,param_2,uVar1);
if ((int)uVar6 < 1) {
return local_38;
}
if ((local_48 <= *puVar2) && (lVar5 = *(long *)(puVar2[1] + (local_48 >> 8) * 8), lVar5 != 0))
{
local_48 = (ulong)*(uint *)(lVar5 + 4 + (local_48 & 0xff) * 0xc);
}
uVar7 = (*pcVar4)(param_1,local_48,param_4,local_40);
if (uVar6 != uVar7) {
return local_38;
}
param_2 = param_2 + uVar6;
param_4 = param_4 + (ulong)uVar6;
} while (param_2 < uVar1);
}
return local_38;
}
|
|
19,877
|
bfdec_rem
|
bluesky950520[P]quickjs/libbf.c
|
int bfdec_rem(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
bf_flags_t flags, int rnd_mode)
{
bfdec_t q_s, *q = &q_s;
int ret;
bfdec_init(r->ctx, q);
ret = bfdec_divrem(q, r, a, b, prec, flags, rnd_mode);
bfdec_delete(q);
return ret;
}
|
O1
|
c
|
bfdec_rem:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %r8d, %eax
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rsi
movq (%rdi), %rdi
leaq 0x10(%rsp), %r14
movq %rdi, (%r14)
movl $0x0, 0x8(%r14)
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
movq %rdi, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movl %r9d, (%rsp)
movq %r14, %rdi
movl %eax, %r9d
callq 0x8f650
movl %eax, %ebx
movq (%r14), %rax
testq %rax, %rax
je 0x8fbee
movq 0x30(%rsp), %rsi
testq %rsi, %rsi
je 0x8fbee
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
|
bfdec_rem:
push r14
push rbx
sub rsp, 38h
mov eax, r8d
mov r8, rcx
mov rcx, rdx
mov rdx, rsi
mov rsi, rdi
mov rdi, [rdi]
lea r14, [rsp+48h+var_38]
mov [r14], rdi
mov dword ptr [r14+8], 0
mov rdi, 8000000000000000h
mov [r14+10h], rdi
xorps xmm0, xmm0
movups xmmword ptr [r14+18h], xmm0
mov [rsp+48h+var_48], r9d
mov rdi, r14
mov r9d, eax
call bfdec_divrem
mov ebx, eax
mov rax, [r14]
test rax, rax
jz short loc_8FBEE
mov rsi, [rsp+48h+var_18]
test rsi, rsi
jz short loc_8FBEE
mov rdi, [rax]
xor edx, edx
call qword ptr [rax+8]
loc_8FBEE:
mov eax, ebx
add rsp, 38h
pop rbx
pop r14
retn
|
long long bfdec_rem(__int128 *a1, long long a2, long long a3, long long a4, unsigned int a5, int a6)
{
unsigned int v6; // ebx
__int128 v8; // [rsp+10h] [rbp-38h] BYREF
unsigned long long v9; // [rsp+20h] [rbp-28h]
__int128 v10; // [rsp+28h] [rbp-20h]
*(_QWORD *)&v8 = *(_QWORD *)a1;
DWORD2(v8) = 0;
v9 = 0x8000000000000000LL;
v10 = 0LL;
v6 = bfdec_divrem(&v8, a1, a2, a3, a4, a5, a6);
if ( (_QWORD)v8 && *((_QWORD *)&v10 + 1) )
(*(void ( **)(_QWORD, _QWORD, _QWORD))(v8 + 8))(*(_QWORD *)v8, *((_QWORD *)&v10 + 1), 0LL);
return v6;
}
| |||
19,878
|
bfdec_rem
|
bluesky950520[P]quickjs/libbf.c
|
int bfdec_rem(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
bf_flags_t flags, int rnd_mode)
{
bfdec_t q_s, *q = &q_s;
int ret;
bfdec_init(r->ctx, q);
ret = bfdec_divrem(q, r, a, b, prec, flags, rnd_mode);
bfdec_delete(q);
return ret;
}
|
O2
|
c
|
bfdec_rem:
pushq %rbp
pushq %rbx
subq $0x38, %rsp
movl %r8d, %eax
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rsi
movq (%rdi), %rdi
leaq 0x10(%rsp), %rbx
movq %rdi, (%rbx)
andl $0x0, 0x8(%rbx)
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
movq %rdi, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movl %r9d, (%rsp)
movq %rbx, %rdi
movl %eax, %r9d
callq 0x779bb
movl %eax, %ebp
movq %rbx, %rdi
callq 0x7145e
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
|
bfdec_rem:
push rbp
push rbx
sub rsp, 38h
mov eax, r8d
mov r8, rcx
mov rcx, rdx
mov rdx, rsi
mov rsi, rdi
mov rdi, [rdi]
lea rbx, [rsp+48h+var_38]
mov [rbx], rdi
and dword ptr [rbx+8], 0
mov rdi, 8000000000000000h
mov [rbx+10h], rdi
xorps xmm0, xmm0
movups xmmword ptr [rbx+18h], xmm0
mov [rsp+48h+var_48], r9d
mov rdi, rbx
mov r9d, eax
call bfdec_divrem
mov ebp, eax
mov rdi, rbx
call bf_delete_0
mov eax, ebp
add rsp, 38h
pop rbx
pop rbp
retn
|
long long bfdec_rem(long long *a1, long long a2, long long a3, long long a4, unsigned int a5, int a6)
{
unsigned int v6; // ebp
long long v8; // [rsp+10h] [rbp-38h] BYREF
int v9; // [rsp+18h] [rbp-30h]
unsigned long long v10; // [rsp+20h] [rbp-28h]
__int128 v11; // [rsp+28h] [rbp-20h]
v8 = *a1;
v9 = 0;
v10 = 0x8000000000000000LL;
v11 = 0LL;
v6 = bfdec_divrem((long long)&v8, (long long)a1, a2, a3, a4, a5, a6);
bf_delete_0(&v8);
return v6;
}
|
bfdec_rem:
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV EAX,R8D
MOV R8,RCX
MOV RCX,RDX
MOV RDX,RSI
MOV RSI,RDI
MOV RDI,qword ptr [RDI]
LEA RBX,[RSP + 0x10]
MOV qword ptr [RBX],RDI
AND dword ptr [RBX + 0x8],0x0
MOV RDI,-0x8000000000000000
MOV qword ptr [RBX + 0x10],RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x18],XMM0
MOV dword ptr [RSP],R9D
MOV RDI,RBX
MOV R9D,EAX
CALL 0x001779bb
MOV EBP,EAX
MOV RDI,RBX
CALL 0x0017145e
MOV EAX,EBP
ADD RSP,0x38
POP RBX
POP RBP
RET
|
int4
bfdec_rem(int8 *param_1,int8 param_2,int8 param_3,int8 param_4,
int4 param_5,int4 param_6)
{
int4 uVar1;
int8 local_38;
int4 local_30;
int8 local_28;
int8 local_20;
int8 uStack_18;
local_38 = *param_1;
local_30 = 0;
local_28 = 0x8000000000000000;
local_20 = 0;
uStack_18 = 0;
uVar1 = bfdec_divrem(&local_38,param_1,param_2,param_3,param_4,param_5,param_6);
bf_delete(&local_38);
return uVar1;
}
|
|
19,879
|
Catch::XmlReporter::sectionEnded(Catch::SectionStats const&)
|
AlayaLite/build_O3/_deps/libcoro-src/test/catch_amalgamated.cpp
|
void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
StreamingReporterBase::sectionEnded( sectionStats );
if ( --m_sectionDepth > 0 ) {
{
XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
e.writeAttribute( "successes"_sr, sectionStats.assertions.passed );
e.writeAttribute( "failures"_sr, sectionStats.assertions.failed );
e.writeAttribute( "expectedFailures"_sr, sectionStats.assertions.failedButOk );
e.writeAttribute( "skipped"_sr, sectionStats.assertions.skipped > 0 );
if ( m_config->showDurations() == ShowDurations::Always )
e.writeAttribute( "durationInSeconds"_sr, sectionStats.durationInSeconds );
}
// Ends assertion tag
m_xml.endElement();
}
}
|
O3
|
cpp
|
Catch::XmlReporter::sectionEnded(Catch::SectionStats const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x80(%rdi), %rax
leaq -0x30(%rax), %rcx
movq %rcx, 0x80(%rdi)
movq -0x30(%rax), %rdi
addq $-0x20, %rax
cmpq %rax, %rdi
je 0x70535
movq (%rax), %rsi
incq %rsi
callq 0x17150
movl 0xe0(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xe0(%r14)
cmpl $0x2, %eax
jge 0x70557
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x28(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x6e311(%rip), %rsi # 0xde879
leaq 0x6e318(%rip), %rdx # 0xde887
leaq 0x18(%rsp), %rdi
callq 0x37312
leaq 0x98(%r14), %r15
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movl $0x3, %edx
callq 0x642cc
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
movl $0x3, %edx
callq 0x64692
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x705bb
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x17150
leaq 0x30(%rbx), %rcx
movq 0x8(%rsp), %rdi
leaq 0x6e2bd(%rip), %rsi # 0xde888
movl $0x9, %edx
callq 0x797f6
leaq 0x38(%rbx), %rcx
movq 0x8(%rsp), %rdi
leaq 0x6cee2(%rip), %rsi # 0xdd4c7
movl $0x8, %edx
callq 0x797f6
leaq 0x40(%rbx), %rcx
movq 0x8(%rsp), %rdi
leaq 0x6e293(%rip), %rsi # 0xde892
movl $0x10, %edx
callq 0x797f6
xorl %r8d, %r8d
cmpq $0x0, 0x48(%rbx)
sete %r8b
movq 0x8(%rsp), %rdi
leaq 0x67bc5(%rip), %rax # 0xd81e6
leaq 0x6a1e3(%rip), %rcx # 0xda80b
cmoveq %rax, %rcx
orq $0x4, %r8
leaq 0x6ddc7(%rip), %rsi # 0xde3fe
movl $0x7, %edx
callq 0x64480
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
cmpl $0x1, %eax
jne 0x7066d
addq $0x50, %rbx
movq 0x8(%rsp), %rdi
leaq 0x6e243(%rip), %rsi # 0xde8a3
movl $0x11, %edx
movq %rbx, %rcx
callq 0x79d92
leaq 0x8(%rsp), %rdi
callq 0x6433c
movq %r15, %rdi
movl $0x3, %esi
callq 0x18cd0
jmp 0x7054b
jmp 0x706bb
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6433c
jmp 0x7069d
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x706c8
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x17150
jmp 0x706c8
movq %rax, %rbx
jmp 0x706c8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6433c
movq %rbx, %rdi
callq 0x17740
|
_ZN5Catch11XmlReporter12sectionEndedERKNS_12SectionStatsE:
push r15
push r14
push r12
push rbx
sub rsp, 38h
mov rbx, rsi
mov r14, rdi
mov rax, [rdi+80h]
lea rcx, [rax-30h]
mov [rdi+80h], rcx
mov rdi, [rax-30h]; void *
add rax, 0FFFFFFFFFFFFFFE0h
cmp rdi, rax
jz short loc_70535
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_70535:
mov eax, [r14+0E0h]
lea ecx, [rax-1]
mov [r14+0E0h], ecx
cmp eax, 2
jge short loc_70557
loc_7054B:
add rsp, 38h
pop rbx
pop r12
pop r14
pop r15
retn
loc_70557:
lea r12, [rsp+58h+var_30]
mov [r12-10h], r12
lea rsi, aOverallresults; "OverallResults"
lea rdx, aOverallresults+0Eh; ""
lea rdi, [rsp+58h+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)
lea r15, [r14+98h]
lea rdi, [rsp+58h+var_50]
mov rsi, r15
mov edx, 3
call _ZN5Catch9XmlWriter13ScopedElementC2EPS0_NS_13XmlFormattingE; Catch::XmlWriter::ScopedElement::ScopedElement(Catch::XmlWriter*,Catch::XmlFormatting)
lea rsi, [rsp+58h+var_40]
mov rdi, r15; this
mov edx, 3
call _ZN5Catch9XmlWriter12startElementERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_13XmlFormattingE; Catch::XmlWriter::startElement(std::string const&,Catch::XmlFormatting)
mov rdi, [rsp+58h+var_40]; void *
cmp rdi, r12
jz short loc_705BB
mov rsi, [rsp+58h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_705BB:
lea rcx, [rbx+30h]
mov rdi, [rsp+58h+var_50]
lea rsi, aSuccesses; "successes"
mov edx, 9
call _ZN5Catch9XmlWriter14writeAttributeImvEERS0_NS_9StringRefERKT_; Catch::XmlWriter::writeAttribute<ulong,void>(Catch::StringRef,ulong const&)
lea rcx, [rbx+38h]
mov rdi, [rsp+58h+var_50]
lea rsi, aNoFailures+4; "failures"
mov edx, 8
call _ZN5Catch9XmlWriter14writeAttributeImvEERS0_NS_9StringRefERKT_; Catch::XmlWriter::writeAttribute<ulong,void>(Catch::StringRef,ulong const&)
lea rcx, [rbx+40h]
mov rdi, [rsp+58h+var_50]
lea rsi, aExpectedfailur; "expectedFailures"
mov edx, 10h
call _ZN5Catch9XmlWriter14writeAttributeImvEERS0_NS_9StringRefERKT_; Catch::XmlWriter::writeAttribute<ulong,void>(Catch::StringRef,ulong const&)
xor r8d, r8d
cmp qword ptr [rbx+48h], 0
setz r8b
mov rdi, [rsp+58h+var_50]
lea rax, aFalse; "false"
lea rcx, aCoroSyncWaitFT+1Ah; "true"
cmovz rcx, rax
or r8, 4
lea rsi, aSkipped; "skipped"
mov edx, 7
call _ZN5Catch9XmlWriter14writeAttributeENS_9StringRefES1_; Catch::XmlWriter::writeAttribute(Catch::StringRef,Catch::StringRef)
mov rdi, [r14+10h]
mov rax, [rdi]
call qword ptr [rax+58h]
cmp eax, 1
jnz short loc_7066D
add rbx, 50h ; 'P'
mov rdi, [rsp+58h+var_50]
lea rsi, aDurationinseco; "durationInSeconds"
mov edx, 11h
mov rcx, rbx
call _ZN5Catch9XmlWriter14writeAttributeIdvEERS0_NS_9StringRefERKT_; Catch::XmlWriter::writeAttribute<double,void>(Catch::StringRef,double const&)
loc_7066D:
lea rdi, [rsp+58h+var_50]; this
call _ZN5Catch9XmlWriter13ScopedElementD2Ev; Catch::XmlWriter::ScopedElement::~ScopedElement()
mov rdi, r15; this
mov esi, 3
call _ZN5Catch9XmlWriter10endElementENS_13XmlFormattingE; Catch::XmlWriter::endElement(Catch::XmlFormatting)
jmp loc_7054B
jmp short loc_706BB
mov rbx, rax
lea rdi, [rsp+arg_0]; this
call _ZN5Catch9XmlWriter13ScopedElementD2Ev; Catch::XmlWriter::ScopedElement::~ScopedElement()
jmp short loc_7069D
mov rbx, rax
loc_7069D:
mov rdi, [rsp+arg_10]; void *
cmp rdi, r12
jz short loc_706C8
mov rsi, [rsp+arg_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_706C8
mov rbx, rax
jmp short loc_706C8
loc_706BB:
mov rbx, rax
lea rdi, [rsp+arg_0]; this
call _ZN5Catch9XmlWriter13ScopedElementD2Ev; Catch::XmlWriter::ScopedElement::~ScopedElement()
loc_706C8:
mov rdi, rbx
call __Unwind_Resume
|
Catch::XmlWriter * Catch::XmlReporter::sectionEnded(long long a1, long long a2)
{
long long v3; // rax
_QWORD *v4; // rdi
_QWORD *v5; // rax
Catch::XmlWriter *result; // rax
int v7; // r8d
int v8; // r9d
int v9; // r8d
int v10; // r9d
int v11; // r8d
int v12; // r9d
char *v13; // rcx
int v14; // r8d
int v15; // r9d
Catch::XmlWriter *v16[2]; // [rsp+8h] [rbp-50h] BYREF
void *v17[2]; // [rsp+18h] [rbp-40h] BYREF
_QWORD v18[6]; // [rsp+28h] [rbp-30h] BYREF
v3 = *(_QWORD *)(a1 + 128);
*(_QWORD *)(a1 + 128) = v3 - 48;
v4 = *(_QWORD **)(v3 - 48);
v5 = (_QWORD *)(v3 - 32);
if ( v4 != v5 )
operator delete(v4, *v5 + 1LL);
result = (Catch::XmlWriter *)*(unsigned int *)(a1 + 224);
*(_DWORD *)(a1 + 224) = (_DWORD)result - 1;
if ( (int)result >= 2 )
{
v17[0] = v18;
std::string::_M_construct<char const*>(v17, "OverallResults", (long long)"");
Catch::XmlWriter::ScopedElement::ScopedElement((long long)v16, a1 + 152, 3);
Catch::XmlWriter::startElement((Catch::XmlWriter *)(a1 + 152), v17, 3);
if ( v17[0] != v18 )
operator delete(v17[0], v18[0] + 1LL);
Catch::XmlWriter::writeAttribute<unsigned long,void>(v16[0], (unsigned int)"successes", 9, a2 + 48, v7, v8);
Catch::XmlWriter::writeAttribute<unsigned long,void>(v16[0], (unsigned int)"failures", 8, a2 + 56, v9, v10);
Catch::XmlWriter::writeAttribute<unsigned long,void>(
v16[0],
(unsigned int)"expectedFailures",
16,
a2 + 64,
v11,
v12);
v13 = "true";
if ( !*(_QWORD *)(a2 + 72) )
v13 = "false";
Catch::XmlWriter::writeAttribute((long long)v16[0], "skipped", 7LL, (long long)v13, (*(_QWORD *)(a2 + 72) == 0LL) | 4LL);
if ( (*(unsigned int ( **)(_QWORD))(**(_QWORD **)(a1 + 16) + 88LL))(*(_QWORD *)(a1 + 16)) == 1 )
Catch::XmlWriter::writeAttribute<double,void>(v16[0], (unsigned int)"durationInSeconds", 17, a2 + 80, v14, v15);
Catch::XmlWriter::ScopedElement::~ScopedElement(v16);
return Catch::XmlWriter::endElement((Catch::XmlWriter *)(a1 + 152), 3);
}
return result;
}
|
sectionEnded:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr [RDI + 0x80]
LEA RCX,[RAX + -0x30]
MOV qword ptr [RDI + 0x80],RCX
MOV RDI,qword ptr [RAX + -0x30]
ADD RAX,-0x20
CMP RDI,RAX
JZ 0x00170535
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x00117150
LAB_00170535:
MOV EAX,dword ptr [R14 + 0xe0]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R14 + 0xe0],ECX
CMP EAX,0x2
JGE 0x00170557
LAB_0017054b:
ADD RSP,0x38
POP RBX
POP R12
POP R14
POP R15
RET
LAB_00170557:
LEA R12,[RSP + 0x28]
MOV qword ptr [R12 + -0x10],R12
LAB_00170561:
LEA RSI,[0x1de879]
LEA RDX,[0x1de887]
LEA RDI,[RSP + 0x18]
CALL 0x00137312
LEA R15,[R14 + 0x98]
LAB_00170580:
LEA RDI,[RSP + 0x8]
MOV RSI,R15
MOV EDX,0x3
CALL 0x001642cc
LAB_00170592:
LEA RSI,[RSP + 0x18]
MOV RDI,R15
MOV EDX,0x3
CALL 0x00164692
MOV RDI,qword ptr [RSP + 0x18]
CMP RDI,R12
JZ 0x001705bb
MOV RSI,qword ptr [RSP + 0x28]
INC RSI
CALL 0x00117150
LAB_001705bb:
LEA RCX,[RBX + 0x30]
MOV RDI,qword ptr [RSP + 0x8]
LAB_001705c4:
LEA RSI,[0x1de888]
MOV EDX,0x9
CALL 0x001797f6
LEA RCX,[RBX + 0x38]
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[0x1dd4c7]
MOV EDX,0x8
CALL 0x001797f6
LEA RCX,[RBX + 0x40]
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[0x1de892]
MOV EDX,0x10
CALL 0x001797f6
XOR R8D,R8D
CMP qword ptr [RBX + 0x48],0x0
SETZ R8B
MOV RDI,qword ptr [RSP + 0x8]
LEA RAX,[0x1d81e6]
LEA RCX,[0x1da80b]
CMOVZ RCX,RAX
OR R8,0x4
LAB_00170630:
LEA RSI,[0x1de3fe]
MOV EDX,0x7
CALL 0x00164480
MOV RDI,qword ptr [R14 + 0x10]
MOV RAX,qword ptr [RDI]
LAB_00170648:
CALL qword ptr [RAX + 0x58]
CMP EAX,0x1
JNZ 0x0017066d
ADD RBX,0x50
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[0x1de8a3]
MOV EDX,0x11
MOV RCX,RBX
CALL 0x00179d92
LAB_0017066d:
LEA RDI,[RSP + 0x8]
CALL 0x0016433c
MOV RDI,R15
MOV ESI,0x3
CALL 0x00118cd0
JMP 0x0017054b
|
/* Catch::XmlReporter::sectionEnded(Catch::SectionStats const&) */
void __thiscall Catch::XmlReporter::sectionEnded(XmlReporter *this,SectionStats *param_1)
{
XmlWriter *pXVar1;
long lVar2;
int iVar3;
char *pcVar4;
XmlWriter *local_50 [2];
long *local_40 [2];
long local_30 [2];
lVar2 = *(long *)(this + 0x80);
*(long *)(this + 0x80) = lVar2 + -0x30;
if (*(long **)(lVar2 + -0x30) != (long *)(lVar2 + -0x20)) {
operator_delete(*(long **)(lVar2 + -0x30),*(long *)(lVar2 + -0x20) + 1);
}
iVar3 = *(int *)(this + 0xe0);
*(int *)(this + 0xe0) = iVar3 + -1;
if (1 < iVar3) {
/* try { // try from 00170561 to 00170578 has its CatchHandler @ 001706b6 */
local_40[0] = local_30;
std::__cxx11::string::_M_construct<char_const*>(local_40,"OverallResults","");
pXVar1 = (XmlWriter *)(this + 0x98);
/* try { // try from 00170580 to 00170591 has its CatchHandler @ 0017069a */
XmlWriter::ScopedElement::ScopedElement((ScopedElement *)local_50,pXVar1,3);
/* try { // try from 00170592 to 001705a3 has its CatchHandler @ 0017068b */
XmlWriter::startElement(pXVar1,local_40,3);
if (local_40[0] != local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
/* try { // try from 001705c4 to 00170608 has its CatchHandler @ 001706bb */
XmlWriter::writeAttribute<unsigned_long,void>(local_50[0],"successes",9,param_1 + 0x30);
XmlWriter::writeAttribute<unsigned_long,void>(local_50[0],"failures",8,param_1 + 0x38);
XmlWriter::writeAttribute<unsigned_long,void>
(local_50[0],"expectedFailures",0x10,param_1 + 0x40);
pcVar4 = "true";
if (*(long *)(param_1 + 0x48) == 0) {
pcVar4 = "false";
}
/* try { // try from 00170630 to 00170640 has its CatchHandler @ 00170689 */
XmlWriter::writeAttribute(local_50[0],"skipped",7,pcVar4,*(long *)(param_1 + 0x48) == 0 | 4);
/* try { // try from 00170648 to 0017066c has its CatchHandler @ 001706bb */
iVar3 = (**(code **)(**(long **)(this + 0x10) + 0x58))();
if (iVar3 == 1) {
XmlWriter::writeAttribute<double,void>(local_50[0],"durationInSeconds",0x11,param_1 + 0x50);
}
XmlWriter::ScopedElement::~ScopedElement((ScopedElement *)local_50);
XmlWriter::endElement(pXVar1,3);
}
return;
}
|
|
19,880
|
TextToLower
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rtext.c
|
const char *TextToLower(const char *text)
{
static char buffer[MAX_TEXT_BUFFER_LENGTH] = { 0 };
memset(buffer, 0, MAX_TEXT_BUFFER_LENGTH);
if (text != NULL)
{
for (int i = 0; (i < MAX_TEXT_BUFFER_LENGTH - 1) && (text[i] != '\0'); i++)
{
if ((text[i] >= 'A') && (text[i] <= 'Z')) buffer[i] = text[i] + 32;
else buffer[i] = text[i];
}
}
return buffer;
}
|
O2
|
c
|
TextToLower:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xc25cf(%rip), %r14 # 0x12fd60
movl $0x400, %edx # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x92c0
testq %rbx, %rbx
je 0x6d7d1
xorl %eax, %eax
cmpq $0x3ff, %rax # imm = 0x3FF
je 0x6d7d1
movb (%rbx,%rax), %cl
testb %cl, %cl
je 0x6d7d1
leal -0x41(%rcx), %edx
movzbl %cl, %esi
orb $0x20, %cl
cmpb $0x1a, %dl
movzbl %cl, %ecx
cmovael %esi, %ecx
movb %cl, (%rax,%r14)
incq %rax
jmp 0x6d7a7
leaq 0xc2588(%rip), %rax # 0x12fd60
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
TextToLower:
push r14
push rbx
push rax
mov rbx, rdi
lea r14, TextToLower_buffer
mov edx, 400h
mov rdi, r14
xor esi, esi
call _memset
test rbx, rbx
jz short loc_6D7D1
xor eax, eax
loc_6D7A7:
cmp rax, 3FFh
jz short loc_6D7D1
mov cl, [rbx+rax]
test cl, cl
jz short loc_6D7D1
lea edx, [rcx-41h]
movzx esi, cl
or cl, 20h
cmp dl, 1Ah
movzx ecx, cl
cmovnb ecx, esi
mov [rax+r14], cl
inc rax
jmp short loc_6D7A7
loc_6D7D1:
lea rax, TextToLower_buffer
add rsp, 8
pop rbx
pop r14
retn
|
_BYTE * TextToLower(long long a1)
{
long long i; // rax
char v2; // cl
unsigned __int8 v3; // dl
char v4; // cl
memset(TextToLower_buffer, 0LL, sizeof(TextToLower_buffer));
if ( a1 )
{
for ( i = 0LL; i != 1023; ++i )
{
v2 = *(_BYTE *)(a1 + i);
if ( !v2 )
break;
v3 = v2 - 65;
v4 = v2 | 0x20;
if ( v3 >= 0x1Au )
v4 = *(_BYTE *)(a1 + i);
TextToLower_buffer[i] = v4;
}
}
return TextToLower_buffer;
}
|
TextToLower:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA R14,[0x22fd60]
MOV EDX,0x400
MOV RDI,R14
XOR ESI,ESI
CALL 0x001092c0
TEST RBX,RBX
JZ 0x0016d7d1
XOR EAX,EAX
LAB_0016d7a7:
CMP RAX,0x3ff
JZ 0x0016d7d1
MOV CL,byte ptr [RBX + RAX*0x1]
TEST CL,CL
JZ 0x0016d7d1
LEA EDX,[RCX + -0x41]
MOVZX ESI,CL
OR CL,0x20
CMP DL,0x1a
MOVZX ECX,CL
CMOVNC ECX,ESI
MOV byte ptr [RAX + R14*0x1],CL
INC RAX
JMP 0x0016d7a7
LAB_0016d7d1:
LEA RAX,[0x22fd60]
ADD RSP,0x8
POP RBX
POP R14
RET
|
int1 * TextToLower(long param_1)
{
byte bVar1;
long lVar2;
byte bVar3;
memset(&TextToLower_buffer,0,0x400);
if (param_1 != 0) {
for (lVar2 = 0; (lVar2 != 0x3ff && (bVar1 = *(byte *)(param_1 + lVar2), bVar1 != 0));
lVar2 = lVar2 + 1) {
bVar3 = bVar1 | 0x20;
if (0x19 < (byte)(bVar1 + 0xbf)) {
bVar3 = bVar1;
}
(&TextToLower_buffer)[lVar2] = bVar3;
}
}
return &TextToLower_buffer;
}
|
|
19,881
|
TextToLower
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rtext.c
|
const char *TextToLower(const char *text)
{
static char buffer[MAX_TEXT_BUFFER_LENGTH] = { 0 };
memset(buffer, 0, MAX_TEXT_BUFFER_LENGTH);
if (text != NULL)
{
for (int i = 0; (i < MAX_TEXT_BUFFER_LENGTH - 1) && (text[i] != '\0'); i++)
{
if ((text[i] >= 'A') && (text[i] <= 'Z')) buffer[i] = text[i] + 32;
else buffer[i] = text[i];
}
}
return buffer;
}
|
O3
|
c
|
TextToLower:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xc36ba(%rip), %r14 # 0x143d40
movl $0x400, %edx # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0xa2d0
testq %rbx, %rbx
je 0x806c4
xorl %eax, %eax
movb (%rbx,%rax), %cl
testb %cl, %cl
je 0x806c4
leal -0x41(%rcx), %edx
movzbl %cl, %esi
orb $0x20, %cl
cmpb $0x1a, %dl
movzbl %cl, %ecx
cmovael %esi, %ecx
movb %cl, (%rax,%r14)
incq %rax
cmpq $0x3ff, %rax # imm = 0x3FF
jne 0x8069c
leaq 0xc3675(%rip), %rax # 0x143d40
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
TextToLower:
push r14
push rbx
push rax
mov rbx, rdi
lea r14, TextToLower_buffer
mov edx, 400h
mov rdi, r14
xor esi, esi
call _memset
test rbx, rbx
jz short loc_806C4
xor eax, eax
loc_8069C:
mov cl, [rbx+rax]
test cl, cl
jz short loc_806C4
lea edx, [rcx-41h]
movzx esi, cl
or cl, 20h
cmp dl, 1Ah
movzx ecx, cl
cmovnb ecx, esi
mov [rax+r14], cl
inc rax
cmp rax, 3FFh
jnz short loc_8069C
loc_806C4:
lea rax, TextToLower_buffer
add rsp, 8
pop rbx
pop r14
retn
|
_BYTE * TextToLower(long long a1)
{
long long i; // rax
char v2; // cl
unsigned __int8 v3; // dl
char v4; // cl
memset(TextToLower_buffer, 0LL, sizeof(TextToLower_buffer));
if ( a1 )
{
for ( i = 0LL; i != 1023; ++i )
{
v2 = *(_BYTE *)(a1 + i);
if ( !v2 )
break;
v3 = v2 - 65;
v4 = v2 | 0x20;
if ( v3 >= 0x1Au )
v4 = *(_BYTE *)(a1 + i);
TextToLower_buffer[i] = v4;
}
}
return TextToLower_buffer;
}
|
TextToLower:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA R14,[0x243d40]
MOV EDX,0x400
MOV RDI,R14
XOR ESI,ESI
CALL 0x0010a2d0
TEST RBX,RBX
JZ 0x001806c4
XOR EAX,EAX
LAB_0018069c:
MOV CL,byte ptr [RBX + RAX*0x1]
TEST CL,CL
JZ 0x001806c4
LEA EDX,[RCX + -0x41]
MOVZX ESI,CL
OR CL,0x20
CMP DL,0x1a
MOVZX ECX,CL
CMOVNC ECX,ESI
MOV byte ptr [RAX + R14*0x1],CL
INC RAX
CMP RAX,0x3ff
JNZ 0x0018069c
LAB_001806c4:
LEA RAX,[0x243d40]
ADD RSP,0x8
POP RBX
POP R14
RET
|
int1 * TextToLower(long param_1)
{
byte bVar1;
long lVar2;
byte bVar3;
memset(&TextToLower_buffer,0,0x400);
if (param_1 != 0) {
lVar2 = 0;
do {
bVar1 = *(byte *)(param_1 + lVar2);
if (bVar1 == 0) {
return &TextToLower_buffer;
}
bVar3 = bVar1 | 0x20;
if (0x19 < (byte)(bVar1 + 0xbf)) {
bVar3 = bVar1;
}
(&TextToLower_buffer)[lVar2] = bVar3;
lVar2 = lVar2 + 1;
} while (lVar2 != 0x3ff);
}
return &TextToLower_buffer;
}
|
|
19,882
|
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [13], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [17]>(char const (&) [13], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [17])
|
llama.cpp/common/json.hpp
|
inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
}
|
O3
|
cpp
|
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [13], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [17]>(char const (&) [13], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [17]):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rbp
movq %rbp, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x20680
movq %rax, %r13
addq 0x8(%r15), %r13
movq %r14, %rdi
callq 0x20680
addq %rax, %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x20e30
movq %rbx, %rdi
movq %r12, %rsi
callq 0x20b50
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x20560
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20b50
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %rbp, %rdi
je 0xbc7f3
movq (%rbp), %rsi
incq %rsi
callq 0x20180
movq %r14, %rdi
callq 0x20b00
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA13_KcS8_RA17_S9_EEET_DpOT0_:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rcx
mov r15, rdx
mov r12, rsi
mov rbx, rdi
lea rbp, [rdi+10h]
mov [rdi], rbp
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rdi, rsi
call _strlen
mov r13, rax
add r13, [r15+8]
mov rdi, r14
call _strlen
add r13, rax
mov rdi, rbx
mov rsi, r13
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rdi, rbx
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [r15]
mov rdx, [r15+8]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
mov rdi, rbx
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, rbp
jz short loc_BC7F3
mov rsi, [rbp+0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_BC7F3:
mov rdi, r14
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[13],std::string,char const(&)[17]>(
long long a1,
long long a2,
_QWORD *a3,
long long a4)
{
long long v6; // r13
long long v7; // rax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v6 = a3[1] + strlen(a2);
v7 = strlen(a4);
std::string::reserve(a1, v7 + v6);
std::string::append(a1, a2);
std::string::append(a1, *a3, a3[1]);
std::string::append(a1, a4);
return a1;
}
|
concat<std::__cxx11::string,char_const(&)[13],std::__cxx11::string,char_const(&)[17]>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RCX
MOV R15,RDX
MOV R12,RSI
MOV RBX,RDI
LEA RBP,[RDI + 0x10]
MOV qword ptr [RDI],RBP
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RDI,RSI
CALL 0x00120680
MOV R13,RAX
ADD R13,qword ptr [R15 + 0x8]
MOV RDI,R14
CALL 0x00120680
ADD R13,RAX
LAB_001bc79a:
MOV RDI,RBX
MOV RSI,R13
CALL 0x00120e30
MOV RDI,RBX
MOV RSI,R12
CALL 0x00120b50
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
MOV RDI,RBX
CALL 0x00120560
MOV RDI,RBX
MOV RSI,R14
CALL 0x00120b50
LAB_001bc7ca:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* std::__cxx11::string nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string, char const
(&) [13], std::__cxx11::string, char const (&) [17]>(char const (&) [13], std::__cxx11::string&&,
char const (&) [17]) */
detail * __thiscall
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[13],std::__cxx11::string,char_const(&)[17]>
(detail *this,char *param_1,string *param_2,char *param_3)
{
*(detail **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (detail)0x0;
strlen(param_1);
strlen(param_3);
/* try { // try from 001bc79a to 001bc7c9 has its CatchHandler @ 001bc7dc */
std::__cxx11::string::reserve((ulong)this);
std::__cxx11::string::append((char *)this);
std::__cxx11::string::append((char *)this,*(ulong *)param_2);
std::__cxx11::string::append((char *)this);
return this;
}
|
|
19,883
|
SettingValue_CheckBox::~SettingValue_CheckBox()
|
untodesu[P]voxelius/game/client/settings.cc
|
virtual ~SettingValue_CheckBox(void) = default;
|
O1
|
cpp
|
SettingValue_CheckBox::~SettingValue_CheckBox():
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xb0, %r14d
leaq (%rbx,%r14), %rax
movq -0x10(%rbx,%r14), %rdi
cmpq %rdi, %rax
je 0x6ba78
movq (%rax), %rsi
incq %rsi
callq 0x268d0
addq $-0x20, %r14
cmpq $0x70, %r14
jne 0x6ba5f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6bd8e
nop
|
_ZN21SettingValue_CheckBoxD2Ev:
push r14
push rbx
push rax
mov rbx, rdi
mov r14d, 0B0h
loc_6BA5F:
lea rax, [rbx+r14]
mov rdi, [rbx+r14-10h]; void *
cmp rax, rdi
jz short loc_6BA78
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_6BA78:
add r14, 0FFFFFFFFFFFFFFE0h
cmp r14, 70h ; 'p'
jnz short loc_6BA5F
mov rdi, rbx; this
add rsp, 8
pop rbx
pop r14
jmp _ZN12SettingValueD2Ev; SettingValue::~SettingValue()
|
void SettingValue_CheckBox::~SettingValue_CheckBox(SettingValue_CheckBox *this)
{
long long i; // r14
char *v3; // rdi
for ( i = 176LL; i != 112; i -= 32LL )
{
v3 = *(char **)((char *)this + i - 16);
if ( (char *)this + i != v3 )
operator delete(v3, *(_QWORD *)((char *)this + i) + 1LL);
}
SettingValue::~SettingValue(this);
}
|
~SettingValue_CheckBox:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R14D,0xb0
LAB_0016ba5f:
LEA RAX,[RBX + R14*0x1]
MOV RDI,qword ptr [RBX + R14*0x1 + -0x10]
CMP RAX,RDI
JZ 0x0016ba78
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x001268d0
LAB_0016ba78:
ADD R14,-0x20
CMP R14,0x70
JNZ 0x0016ba5f
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x0016bd8e
|
/* SettingValue_CheckBox::~SettingValue_CheckBox() */
void __thiscall SettingValue_CheckBox::~SettingValue_CheckBox(SettingValue_CheckBox *this)
{
long lVar1;
lVar1 = 0xb0;
do {
if (this + lVar1 != *(SettingValue_CheckBox **)(this + lVar1 + -0x10)) {
operator_delete(*(SettingValue_CheckBox **)(this + lVar1 + -0x10),*(long *)(this + lVar1) + 1)
;
}
lVar1 = lVar1 + -0x20;
} while (lVar1 != 0x70);
SettingValue::~SettingValue((SettingValue *)this);
return;
}
|
|
19,884
|
Simulator::printStatistics()
|
EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/Simulator.cpp
|
void Simulator::printStatistics() {
printf("------------ STATISTICS -----------\n");
printf("Number of Instructions: %u\n", this->history.instCount);
printf("Number of Cycles: %u\n", this->history.cycleCount);
printf("Avg Cycles per Instrcution: %.4f\n",
(float)this->history.cycleCount / this->history.instCount);
printf("Branch Perdiction Accuacy: %.4f (Strategy: %s)\n",
(float)this->history.predictedBranch /
(this->history.predictedBranch + this->history.unpredictedBranch),
this->branchPredictor->strategyName().c_str());
printf("Number of Control Hazards: %u\n",
this->history.controlHazardCount);
printf("Number of Data Hazards: %u\n", this->history.dataHazardCount);
printf("Number of Memory Hazards: %u\n",
this->history.memoryHazardCount);
printf("-----------------------------------\n");
//this->memory->printStatistics();
}
|
O0
|
cpp
|
Simulator::printStatistics():
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x5f86(%rip), %rdi # 0x29fc0
xorl %eax, %eax
movb %al, 0x7(%rsp)
callq 0x15050
movq 0x8(%rsp), %rcx
movb 0x7(%rsp), %al
movl 0x318(%rcx), %esi
leaq 0x5f8a(%rip), %rdi # 0x29fe5
callq 0x15050
movq 0x8(%rsp), %rcx
movb 0x7(%rsp), %al
movl 0x31c(%rcx), %esi
leaq 0x5f8b(%rip), %rdi # 0x2a001
callq 0x15050
movq 0x8(%rsp), %rcx
movl 0x318(%rcx), %eax
movl 0x31c(%rcx), %ecx
cvtsi2ss %rcx, %xmm0
cvtsi2ss %rax, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x5f72(%rip), %rdi # 0x2a017
movb $0x1, %al
movb %al, 0x23(%rsp)
callq 0x15050
movq 0x8(%rsp), %rax
movl 0x324(%rax), %ecx
movl %ecx, %edx
movl %edx, %ecx
cvtsi2ss %rdx, %xmm0
movl 0x328(%rax), %edx
addl %edx, %ecx
cvtsi2ss %rcx, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x120(%rax), %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x25880
movq 0x10(%rsp), %rdi
callq 0x150c0
movsd 0x18(%rsp), %xmm0
movq %rax, %rsi
movb 0x23(%rsp), %al
leaq 0x5f26(%rip), %rdi # 0x2a039
callq 0x15050
jmp 0x2411a
leaq 0x30(%rsp), %rdi
callq 0x15140
movq 0x8(%rsp), %rax
movl 0x330(%rax), %esi
leaq 0x5f33(%rip), %rdi # 0x2a069
movb $0x0, %al
callq 0x15050
movq 0x8(%rsp), %rax
movl 0x32c(%rax), %esi
leaq 0x5f39(%rip), %rdi # 0x2a088
movb $0x0, %al
callq 0x15050
movq 0x8(%rsp), %rax
movl 0x334(%rax), %esi
leaq 0x5f3c(%rip), %rdi # 0x2a0a4
movb $0x0, %al
callq 0x15050
leaq 0x5e25(%rip), %rdi # 0x29f9b
movb $0x0, %al
callq 0x15050
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x15140
movq 0x28(%rsp), %rdi
callq 0x153a0
nopw %cs:(%rax,%rax)
nop
|
_ZN9Simulator15printStatisticsEv:
sub rsp, 58h
mov [rsp+58h+var_8], rdi
mov rax, [rsp+58h+var_8]
mov [rsp+58h+var_50], rax
lea rdi, aStatistics; "------------ STATISTICS -----------\n"
xor eax, eax
mov [rsp+58h+var_51], al
call _printf
mov rcx, [rsp+58h+var_50]
mov al, [rsp+58h+var_51]
mov esi, [rcx+318h]
lea rdi, aNumberOfInstru; "Number of Instructions: %u\n"
call _printf
mov rcx, [rsp+58h+var_50]
mov al, [rsp+58h+var_51]
mov esi, [rcx+31Ch]
lea rdi, aNumberOfCycles; "Number of Cycles: %u\n"
call _printf
mov rcx, [rsp+58h+var_50]
mov eax, [rcx+318h]
mov ecx, [rcx+31Ch]
cvtsi2ss xmm0, rcx
cvtsi2ss xmm1, rax
divss xmm0, xmm1
cvtss2sd xmm0, xmm0
lea rdi, aAvgCyclesPerIn; "Avg Cycles per Instrcution: %.4f\n"
mov al, 1
mov [rsp+58h+var_35], al
call _printf
mov rax, [rsp+58h+var_50]
mov ecx, [rax+324h]
mov edx, ecx
mov ecx, edx
cvtsi2ss xmm0, rdx
mov edx, [rax+328h]
add ecx, edx
cvtsi2ss xmm1, rcx
divss xmm0, xmm1
cvtss2sd xmm0, xmm0
movsd [rsp+58h+var_40], xmm0
mov rsi, [rax+120h]
lea rdi, [rsp+58h+var_28]
mov [rsp+58h+var_48], rdi
call _ZN15BranchPredictor12strategyNameB5cxx11Ev; BranchPredictor::strategyName(void)
mov rdi, [rsp+58h+var_48]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
movsd xmm0, [rsp+58h+var_40]
mov rsi, rax
mov al, [rsp+58h+var_35]
lea rdi, aBranchPerdicti; "Branch Perdiction Accuacy: %.4f (Strate"...
call _printf
jmp short $+2
loc_2411A:
lea rdi, [rsp+58h+var_28]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rax, [rsp+58h+var_50]
mov esi, [rax+330h]
lea rdi, aNumberOfContro; "Number of Control Hazards: %u\n"
mov al, 0
call _printf
mov rax, [rsp+58h+var_50]
mov esi, [rax+32Ch]
lea rdi, aNumberOfDataHa; "Number of Data Hazards: %u\n"
mov al, 0
call _printf
mov rax, [rsp+58h+var_50]
mov esi, [rax+334h]
lea rdi, aNumberOfMemory; "Number of Memory Hazards: %u\n"
mov al, 0
call _printf
lea rdi, asc_29F9B; "-----------------------------------\n"
mov al, 0
call _printf
add rsp, 58h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_20], rcx
mov [rsp+arg_1C], eax
lea rdi, [rsp+arg_28]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rdi, [rsp+arg_20]
call __Unwind_Resume
|
double Simulator::printStatistics(Simulator *this)
{
int v1; // ecx
float v2; // xmm0_4
int v3; // edx
int v4; // ecx
int v5; // r8d
int v6; // r9d
const char *v7; // rax
double v9; // [rsp+18h] [rbp-40h]
_BYTE v10[32]; // [rsp+30h] [rbp-28h] BYREF
Simulator *v11; // [rsp+50h] [rbp-8h]
v11 = this;
printf("------------ STATISTICS -----------\n");
printf("Number of Instructions: %u\n", *((_DWORD *)this + 198));
printf("Number of Cycles: %u\n", *((_DWORD *)this + 199));
printf("Avg Cycles per Instrcution: %.4f\n", (float)((float)*((int *)this + 199) / (float)*((int *)this + 198)));
v1 = *((_DWORD *)this + 201);
v2 = (float)v1;
v3 = *((_DWORD *)this + 202);
v4 = v3 + v1;
v9 = (float)(v2 / (float)v4);
BranchPredictor::strategyName[abi:cxx11]((unsigned int)v10, *((_QWORD *)this + 36), v3, v4, v5, v6);
v7 = (const char *)std::string::c_str(v10);
printf("Branch Perdiction Accuacy: %.4f (Strategy: %s)\n", v9, v7);
std::string::~string(v10);
printf("Number of Control Hazards: %u\n", *((_DWORD *)this + 204));
printf("Number of Data Hazards: %u\n", *((_DWORD *)this + 203));
printf("Number of Memory Hazards: %u\n", *((_DWORD *)this + 205));
return printf("-----------------------------------\n");
}
|
printStatistics:
SUB RSP,0x58
MOV qword ptr [RSP + 0x50],RDI
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x8],RAX
LEA RDI,[0x129fc0]
XOR EAX,EAX
MOV byte ptr [RSP + 0x7],AL
CALL 0x00115050
MOV RCX,qword ptr [RSP + 0x8]
MOV AL,byte ptr [RSP + 0x7]
MOV ESI,dword ptr [RCX + 0x318]
LEA RDI,[0x129fe5]
CALL 0x00115050
MOV RCX,qword ptr [RSP + 0x8]
MOV AL,byte ptr [RSP + 0x7]
MOV ESI,dword ptr [RCX + 0x31c]
LEA RDI,[0x12a001]
CALL 0x00115050
MOV RCX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RCX + 0x318]
MOV ECX,dword ptr [RCX + 0x31c]
CVTSI2SS XMM0,RCX
CVTSI2SS XMM1,RAX
DIVSS XMM0,XMM1
CVTSS2SD XMM0,XMM0
LEA RDI,[0x12a017]
MOV AL,0x1
MOV byte ptr [RSP + 0x23],AL
CALL 0x00115050
MOV RAX,qword ptr [RSP + 0x8]
MOV ECX,dword ptr [RAX + 0x324]
MOV EDX,ECX
MOV ECX,EDX
CVTSI2SS XMM0,RDX
MOV EDX,dword ptr [RAX + 0x328]
ADD ECX,EDX
CVTSI2SS XMM1,RCX
DIVSS XMM0,XMM1
CVTSS2SD XMM0,XMM0
MOVSD qword ptr [RSP + 0x18],XMM0
MOV RSI,qword ptr [RAX + 0x120]
LEA RDI,[RSP + 0x30]
MOV qword ptr [RSP + 0x10],RDI
CALL 0x00125880
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001150c0
MOVSD XMM0,qword ptr [RSP + 0x18]
MOV RSI,RAX
MOV AL,byte ptr [RSP + 0x23]
LAB_0012410c:
LEA RDI,[0x12a039]
CALL 0x00115050
LAB_00124118:
JMP 0x0012411a
LAB_0012411a:
LEA RDI,[RSP + 0x30]
CALL 0x00115140
MOV RAX,qword ptr [RSP + 0x8]
MOV ESI,dword ptr [RAX + 0x330]
LEA RDI,[0x12a069]
MOV AL,0x0
CALL 0x00115050
MOV RAX,qword ptr [RSP + 0x8]
MOV ESI,dword ptr [RAX + 0x32c]
LEA RDI,[0x12a088]
MOV AL,0x0
CALL 0x00115050
MOV RAX,qword ptr [RSP + 0x8]
MOV ESI,dword ptr [RAX + 0x334]
LEA RDI,[0x12a0a4]
MOV AL,0x0
CALL 0x00115050
LEA RDI,[0x129f9b]
MOV AL,0x0
CALL 0x00115050
ADD RSP,0x58
RET
|
/* Simulator::printStatistics() */
void __thiscall Simulator::printStatistics(Simulator *this)
{
uint uVar1;
int iVar2;
int8 uVar3;
string local_28 [32];
Simulator *local_8;
local_8 = this;
printf("------------ STATISTICS -----------\n");
printf("Number of Instructions: %u\n",(ulong)*(uint *)(this + 0x318));
printf("Number of Cycles: %u\n",(ulong)*(uint *)(this + 0x31c));
printf("Avg Cycles per Instrcution: %.4f\n",
(double)((float)*(uint *)(this + 0x31c) / (float)*(uint *)(this + 0x318)));
uVar1 = *(uint *)(this + 0x324);
iVar2 = *(int *)(this + 0x328);
BranchPredictor::strategyName_abi_cxx11_();
uVar3 = std::__cxx11::string::c_str();
/* try { // try from 0012410c to 00124117 has its CatchHandler @ 00124182 */
printf("Branch Perdiction Accuacy: %.4f (Strategy: %s)\n",
(double)((float)uVar1 / (float)(uVar1 + iVar2)),uVar3);
std::__cxx11::string::~string(local_28);
printf("Number of Control Hazards: %u\n",(ulong)*(uint *)(this + 0x330));
printf("Number of Data Hazards: %u\n",(ulong)*(uint *)(this + 0x32c));
printf("Number of Memory Hazards: %u\n",(ulong)*(uint *)(this + 0x334));
printf("-----------------------------------\n");
return;
}
|
|
19,885
|
Simulator::printStatistics()
|
EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/Simulator.cpp
|
void Simulator::printStatistics() {
printf("------------ STATISTICS -----------\n");
printf("Number of Instructions: %u\n", this->history.instCount);
printf("Number of Cycles: %u\n", this->history.cycleCount);
printf("Avg Cycles per Instrcution: %.4f\n",
(float)this->history.cycleCount / this->history.instCount);
printf("Branch Perdiction Accuacy: %.4f (Strategy: %s)\n",
(float)this->history.predictedBranch /
(this->history.predictedBranch + this->history.unpredictedBranch),
this->branchPredictor->strategyName().c_str());
printf("Number of Control Hazards: %u\n",
this->history.controlHazardCount);
printf("Number of Data Hazards: %u\n", this->history.dataHazardCount);
printf("Number of Memory Hazards: %u\n",
this->history.memoryHazardCount);
printf("-----------------------------------\n");
//this->memory->printStatistics();
}
|
O1
|
cpp
|
Simulator::printStatistics():
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x341d(%rip), %rdi # 0x15ff8
callq 0xb320
movl 0x318(%rbx), %esi
leaq 0x317c(%rip), %rdi # 0x15d69
xorl %eax, %eax
callq 0xb050
movl 0x31c(%rbx), %esi
leaq 0x3184(%rip), %rdi # 0x15d85
xorl %eax, %eax
callq 0xb050
movl 0x31c(%rbx), %eax
cvtsi2ss %rax, %xmm0
movl 0x318(%rbx), %eax
cvtsi2ss %rax, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x316e(%rip), %rdi # 0x15d9b
movb $0x1, %al
callq 0xb050
movl 0x324(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
movl 0x328(%rbx), %ecx
addl %eax, %ecx
xorps %xmm1, %xmm1
cvtsi2ss %rcx, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq 0x120(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x13372
movq (%r14), %rsi
leaq 0x3140(%rip), %rdi # 0x15dbd
movsd (%rsp), %xmm0
movb $0x1, %al
callq 0xb050
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x12c9b
callq 0xb1a0
movl 0x330(%rbx), %esi
leaq 0x3145(%rip), %rdi # 0x15ded
xorl %eax, %eax
callq 0xb050
movl 0x32c(%rbx), %esi
leaq 0x3150(%rip), %rdi # 0x15e0c
xorl %eax, %eax
callq 0xb050
movl 0x334(%rbx), %esi
leaq 0x3158(%rip), %rdi # 0x15e28
xorl %eax, %eax
callq 0xb050
leaq 0x333e(%rip), %rdi # 0x1601c
callq 0xb320
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
|
_ZN9Simulator15printStatisticsEv:
push r14
push rbx
sub rsp, 28h
mov rbx, rdi
lea rdi, aStatistics; "------------ STATISTICS -----------"
call _puts
mov esi, [rbx+318h]
lea rdi, aNumberOfInstru; "Number of Instructions: %u\n"
xor eax, eax
call _printf
mov esi, [rbx+31Ch]
lea rdi, aNumberOfCycles; "Number of Cycles: %u\n"
xor eax, eax
call _printf
mov eax, [rbx+31Ch]
cvtsi2ss xmm0, rax
mov eax, [rbx+318h]
cvtsi2ss xmm1, rax
divss xmm0, xmm1
cvtss2sd xmm0, xmm0
lea rdi, aAvgCyclesPerIn; "Avg Cycles per Instrcution: %.4f\n"
mov al, 1
call _printf
mov eax, [rbx+324h]
xorps xmm0, xmm0
cvtsi2ss xmm0, rax
mov ecx, [rbx+328h]
add ecx, eax
xorps xmm1, xmm1
cvtsi2ss xmm1, rcx
divss xmm0, xmm1
cvtss2sd xmm0, xmm0
movsd [rsp+38h+var_38], xmm0
mov rsi, [rbx+120h]
lea r14, [rsp+38h+var_30]
mov rdi, r14
call _ZN15BranchPredictor12strategyNameB5cxx11Ev; BranchPredictor::strategyName(void)
mov rsi, [r14]
lea rdi, aBranchPerdicti; "Branch Perdiction Accuacy: %.4f (Strate"...
movsd xmm0, [rsp+38h+var_38]
mov al, 1
call _printf
mov rdi, [r14]; void *
lea rax, [rsp+38h+var_20]
cmp rdi, rax
jz short loc_12C9B
call __ZdlPv; operator delete(void *)
loc_12C9B:
mov esi, [rbx+330h]
lea rdi, aNumberOfContro; "Number of Control Hazards: %u\n"
xor eax, eax
call _printf
mov esi, [rbx+32Ch]
lea rdi, aNumberOfDataHa; "Number of Data Hazards: %u\n"
xor eax, eax
call _printf
mov esi, [rbx+334h]
lea rdi, aNumberOfMemory; "Number of Memory Hazards: %u\n"
xor eax, eax
call _printf
lea rdi, asc_1601C; "-----------------------------------"
call _puts
add rsp, 28h
pop rbx
pop r14
retn
|
long long Simulator::printStatistics(Simulator *this)
{
double v3; // [rsp+0h] [rbp-38h]
char *v4; // [rsp+8h] [rbp-30h] BYREF
char v5; // [rsp+18h] [rbp-20h] BYREF
puts("------------ STATISTICS -----------");
printf("Number of Instructions: %u\n", *((_DWORD *)this + 198));
printf("Number of Cycles: %u\n", *((_DWORD *)this + 199));
printf("Avg Cycles per Instrcution: %.4f\n", (float)((float)*((int *)this + 199) / (float)*((int *)this + 198)));
v3 = (float)((float)*((int *)this + 201) / (float)(*((_DWORD *)this + 201) + *((_DWORD *)this + 202)));
BranchPredictor::strategyName[abi:cxx11](&v4, *((_QWORD *)this + 36));
printf("Branch Perdiction Accuacy: %.4f (Strategy: %s)\n", v3, v4);
if ( v4 != &v5 )
operator delete(v4);
printf("Number of Control Hazards: %u\n", *((_DWORD *)this + 204));
printf("Number of Data Hazards: %u\n", *((_DWORD *)this + 203));
printf("Number of Memory Hazards: %u\n", *((_DWORD *)this + 205));
return puts("-----------------------------------");
}
|
printStatistics:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
LEA RDI,[0x115ff8]
CALL 0x0010b320
MOV ESI,dword ptr [RBX + 0x318]
LEA RDI,[0x115d69]
XOR EAX,EAX
CALL 0x0010b050
MOV ESI,dword ptr [RBX + 0x31c]
LEA RDI,[0x115d85]
XOR EAX,EAX
CALL 0x0010b050
MOV EAX,dword ptr [RBX + 0x31c]
CVTSI2SS XMM0,RAX
MOV EAX,dword ptr [RBX + 0x318]
CVTSI2SS XMM1,RAX
DIVSS XMM0,XMM1
CVTSS2SD XMM0,XMM0
LEA RDI,[0x115d9b]
MOV AL,0x1
CALL 0x0010b050
MOV EAX,dword ptr [RBX + 0x324]
XORPS XMM0,XMM0
CVTSI2SS XMM0,RAX
MOV ECX,dword ptr [RBX + 0x328]
ADD ECX,EAX
XORPS XMM1,XMM1
CVTSI2SS XMM1,RCX
DIVSS XMM0,XMM1
CVTSS2SD XMM0,XMM0
MOVSD qword ptr [RSP],XMM0
MOV RSI,qword ptr [RBX + 0x120]
LEA R14,[RSP + 0x8]
MOV RDI,R14
CALL 0x00113372
MOV RSI,qword ptr [R14]
LEA RDI,[0x115dbd]
MOVSD XMM0,qword ptr [RSP]
MOV AL,0x1
CALL 0x0010b050
MOV RDI,qword ptr [R14]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x00112c9b
CALL 0x0010b1a0
LAB_00112c9b:
MOV ESI,dword ptr [RBX + 0x330]
LEA RDI,[0x115ded]
XOR EAX,EAX
CALL 0x0010b050
MOV ESI,dword ptr [RBX + 0x32c]
LEA RDI,[0x115e0c]
XOR EAX,EAX
CALL 0x0010b050
MOV ESI,dword ptr [RBX + 0x334]
LEA RDI,[0x115e28]
XOR EAX,EAX
CALL 0x0010b050
LEA RDI,[0x11601c]
CALL 0x0010b320
ADD RSP,0x28
POP RBX
POP R14
RET
|
/* Simulator::printStatistics() */
void __thiscall Simulator::printStatistics(Simulator *this)
{
uint uVar1;
int iVar2;
int1 *local_30;
int1 local_20 [16];
puts("------------ STATISTICS -----------");
printf("Number of Instructions: %u\n",(ulong)*(uint *)(this + 0x318));
printf("Number of Cycles: %u\n",(ulong)*(uint *)(this + 0x31c));
printf("Avg Cycles per Instrcution: %.4f\n",
(double)((float)*(uint *)(this + 0x31c) / (float)*(uint *)(this + 0x318)));
uVar1 = *(uint *)(this + 0x324);
iVar2 = *(int *)(this + 0x328);
BranchPredictor::strategyName_abi_cxx11_();
printf("Branch Perdiction Accuacy: %.4f (Strategy: %s)\n",
(double)((float)uVar1 / (float)(iVar2 + uVar1)),local_30);
if (local_30 != local_20) {
operator_delete(local_30);
}
printf("Number of Control Hazards: %u\n",(ulong)*(uint *)(this + 0x330));
printf("Number of Data Hazards: %u\n",(ulong)*(uint *)(this + 0x32c));
printf("Number of Memory Hazards: %u\n",(ulong)*(uint *)(this + 0x334));
puts("-----------------------------------");
return;
}
|
|
19,886
|
Simulator::printStatistics()
|
EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/Simulator.cpp
|
void Simulator::printStatistics() {
printf("------------ STATISTICS -----------\n");
printf("Number of Instructions: %u\n", this->history.instCount);
printf("Number of Cycles: %u\n", this->history.cycleCount);
printf("Avg Cycles per Instrcution: %.4f\n",
(float)this->history.cycleCount / this->history.instCount);
printf("Branch Perdiction Accuacy: %.4f (Strategy: %s)\n",
(float)this->history.predictedBranch /
(this->history.predictedBranch + this->history.unpredictedBranch),
this->branchPredictor->strategyName().c_str());
printf("Number of Control Hazards: %u\n",
this->history.controlHazardCount);
printf("Number of Data Hazards: %u\n", this->history.dataHazardCount);
printf("Number of Memory Hazards: %u\n",
this->history.memoryHazardCount);
printf("-----------------------------------\n");
//this->memory->printStatistics();
}
|
O3
|
cpp
|
Simulator::printStatistics():
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x34cb(%rip), %rdi # 0x15ff8
callq 0xb320
movl 0x318(%rbx), %esi
leaq 0x322a(%rip), %rdi # 0x15d69
xorl %eax, %eax
callq 0xb050
movl 0x31c(%rbx), %esi
leaq 0x3232(%rip), %rdi # 0x15d85
xorl %eax, %eax
callq 0xb050
movl 0x31c(%rbx), %eax
cvtsi2ss %rax, %xmm0
movl 0x318(%rbx), %eax
cvtsi2ss %rax, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x321c(%rip), %rdi # 0x15d9b
movb $0x1, %al
callq 0xb050
movl 0x324(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
movl 0x328(%rbx), %ecx
addl %eax, %ecx
xorps %xmm1, %xmm1
cvtsi2ss %rcx, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq 0x120(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x132b8
movq (%r14), %rsi
leaq 0x31ee(%rip), %rdi # 0x15dbd
movsd (%rsp), %xmm0
movb $0x1, %al
callq 0xb050
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x12bed
callq 0xb1a0
movl 0x330(%rbx), %esi
leaq 0x31f3(%rip), %rdi # 0x15ded
xorl %eax, %eax
callq 0xb050
movl 0x32c(%rbx), %esi
leaq 0x31fe(%rip), %rdi # 0x15e0c
xorl %eax, %eax
callq 0xb050
movl 0x334(%rbx), %esi
leaq 0x3206(%rip), %rdi # 0x15e28
xorl %eax, %eax
callq 0xb050
leaq 0x33ec(%rip), %rdi # 0x1601c
callq 0xb320
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
|
_ZN9Simulator15printStatisticsEv:
push r14
push rbx
sub rsp, 28h
mov rbx, rdi
lea rdi, aStatistics; "------------ STATISTICS -----------"
call _puts
mov esi, [rbx+318h]
lea rdi, aNumberOfInstru; "Number of Instructions: %u\n"
xor eax, eax
call _printf
mov esi, [rbx+31Ch]
lea rdi, aNumberOfCycles; "Number of Cycles: %u\n"
xor eax, eax
call _printf
mov eax, [rbx+31Ch]
cvtsi2ss xmm0, rax
mov eax, [rbx+318h]
cvtsi2ss xmm1, rax
divss xmm0, xmm1
cvtss2sd xmm0, xmm0
lea rdi, aAvgCyclesPerIn; "Avg Cycles per Instrcution: %.4f\n"
mov al, 1
call _printf
mov eax, [rbx+324h]
xorps xmm0, xmm0
cvtsi2ss xmm0, rax
mov ecx, [rbx+328h]
add ecx, eax
xorps xmm1, xmm1
cvtsi2ss xmm1, rcx
divss xmm0, xmm1
cvtss2sd xmm0, xmm0
movsd [rsp+38h+var_38], xmm0
mov rsi, [rbx+120h]
lea r14, [rsp+38h+var_30]
mov rdi, r14
call _ZN15BranchPredictor12strategyNameB5cxx11Ev; BranchPredictor::strategyName(void)
mov rsi, [r14]
lea rdi, aBranchPerdicti; "Branch Perdiction Accuacy: %.4f (Strate"...
movsd xmm0, [rsp+38h+var_38]
mov al, 1
call _printf
mov rdi, [r14]; void *
lea rax, [rsp+38h+var_20]
cmp rdi, rax
jz short loc_12BED
call __ZdlPv; operator delete(void *)
loc_12BED:
mov esi, [rbx+330h]
lea rdi, aNumberOfContro; "Number of Control Hazards: %u\n"
xor eax, eax
call _printf
mov esi, [rbx+32Ch]
lea rdi, aNumberOfDataHa; "Number of Data Hazards: %u\n"
xor eax, eax
call _printf
mov esi, [rbx+334h]
lea rdi, aNumberOfMemory; "Number of Memory Hazards: %u\n"
xor eax, eax
call _printf
lea rdi, asc_1601C; "-----------------------------------"
call _puts
add rsp, 28h
pop rbx
pop r14
retn
|
long long Simulator::printStatistics(Simulator *this)
{
double v3; // [rsp+0h] [rbp-38h]
char *v4; // [rsp+8h] [rbp-30h] BYREF
char v5; // [rsp+18h] [rbp-20h] BYREF
puts("------------ STATISTICS -----------");
printf("Number of Instructions: %u\n", *((_DWORD *)this + 198));
printf("Number of Cycles: %u\n", *((_DWORD *)this + 199));
printf("Avg Cycles per Instrcution: %.4f\n", (float)((float)*((int *)this + 199) / (float)*((int *)this + 198)));
v3 = (float)((float)*((int *)this + 201) / (float)(*((_DWORD *)this + 201) + *((_DWORD *)this + 202)));
BranchPredictor::strategyName[abi:cxx11](&v4, *((_QWORD *)this + 36));
printf("Branch Perdiction Accuacy: %.4f (Strategy: %s)\n", v3, v4);
if ( v4 != &v5 )
operator delete(v4);
printf("Number of Control Hazards: %u\n", *((_DWORD *)this + 204));
printf("Number of Data Hazards: %u\n", *((_DWORD *)this + 203));
printf("Number of Memory Hazards: %u\n", *((_DWORD *)this + 205));
return puts("-----------------------------------");
}
|
printStatistics:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
LEA RDI,[0x115ff8]
CALL 0x0010b320
MOV ESI,dword ptr [RBX + 0x318]
LEA RDI,[0x115d69]
XOR EAX,EAX
CALL 0x0010b050
MOV ESI,dword ptr [RBX + 0x31c]
LEA RDI,[0x115d85]
XOR EAX,EAX
CALL 0x0010b050
MOV EAX,dword ptr [RBX + 0x31c]
CVTSI2SS XMM0,RAX
MOV EAX,dword ptr [RBX + 0x318]
CVTSI2SS XMM1,RAX
DIVSS XMM0,XMM1
CVTSS2SD XMM0,XMM0
LEA RDI,[0x115d9b]
MOV AL,0x1
CALL 0x0010b050
MOV EAX,dword ptr [RBX + 0x324]
XORPS XMM0,XMM0
CVTSI2SS XMM0,RAX
MOV ECX,dword ptr [RBX + 0x328]
ADD ECX,EAX
XORPS XMM1,XMM1
CVTSI2SS XMM1,RCX
DIVSS XMM0,XMM1
CVTSS2SD XMM0,XMM0
MOVSD qword ptr [RSP],XMM0
MOV RSI,qword ptr [RBX + 0x120]
LEA R14,[RSP + 0x8]
MOV RDI,R14
CALL 0x001132b8
MOV RSI,qword ptr [R14]
LEA RDI,[0x115dbd]
MOVSD XMM0,qword ptr [RSP]
MOV AL,0x1
CALL 0x0010b050
MOV RDI,qword ptr [R14]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x00112bed
CALL 0x0010b1a0
LAB_00112bed:
MOV ESI,dword ptr [RBX + 0x330]
LEA RDI,[0x115ded]
XOR EAX,EAX
CALL 0x0010b050
MOV ESI,dword ptr [RBX + 0x32c]
LEA RDI,[0x115e0c]
XOR EAX,EAX
CALL 0x0010b050
MOV ESI,dword ptr [RBX + 0x334]
LEA RDI,[0x115e28]
XOR EAX,EAX
CALL 0x0010b050
LEA RDI,[0x11601c]
CALL 0x0010b320
ADD RSP,0x28
POP RBX
POP R14
RET
|
/* Simulator::printStatistics() */
void __thiscall Simulator::printStatistics(Simulator *this)
{
uint uVar1;
int iVar2;
int1 *local_30;
int1 local_20 [16];
puts("------------ STATISTICS -----------");
printf("Number of Instructions: %u\n",(ulong)*(uint *)(this + 0x318));
printf("Number of Cycles: %u\n",(ulong)*(uint *)(this + 0x31c));
printf("Avg Cycles per Instrcution: %.4f\n",
(double)((float)*(uint *)(this + 0x31c) / (float)*(uint *)(this + 0x318)));
uVar1 = *(uint *)(this + 0x324);
iVar2 = *(int *)(this + 0x328);
BranchPredictor::strategyName_abi_cxx11_();
printf("Branch Perdiction Accuacy: %.4f (Strategy: %s)\n",
(double)((float)uVar1 / (float)(iVar2 + uVar1)),local_30);
if (local_30 != local_20) {
operator_delete(local_30);
}
printf("Number of Control Hazards: %u\n",(ulong)*(uint *)(this + 0x330));
printf("Number of Data Hazards: %u\n",(ulong)*(uint *)(this + 0x32c));
printf("Number of Memory Hazards: %u\n",(ulong)*(uint *)(this + 0x334));
puts("-----------------------------------");
return;
}
|
|
19,887
|
LefDefParser::lefwMacroTimingRisesatt1(double, double)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp
|
int
lefwMacroTimingRisesatt1(double min,
double max)
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (!lefwDidInit)
return LEFW_BAD_ORDER;
if (!lefwIsMacroTiming)
return LEFW_BAD_ORDER;
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) " RISESATT1 %.11g %.11g ;\n", min, max);
else
fprintf(lefwFile, " RISESATT1 %.11g %.11g ;\n", min, max);
lefwLines++;
return LEFW_OK;
}
|
O0
|
cpp
|
LefDefParser::lefwMacroTimingRisesatt1(double, double):
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, (%rsp)
leaq 0xb7fa(%rip), %rax # 0x32e00
cmpq $0x0, (%rax)
jne 0x27619
movl $0x1, 0x14(%rsp)
jmp 0x276b6
leaq 0xba34(%rip), %rax # 0x33054
cmpl $0x0, (%rax)
jne 0x27632
movl $0x2, 0x14(%rsp)
jmp 0x276b6
leaq 0xba73(%rip), %rax # 0x330ac
cmpl $0x0, (%rax)
jne 0x27648
movl $0x2, 0x14(%rsp)
jmp 0x276b6
cmpl $0x0, 0xba9d(%rip) # 0x330ec
je 0x27676
leaq 0xb7a8(%rip), %rax # 0x32e00
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
leaq 0x496d(%rip), %rsi # 0x2bfda
movb $0x2, %al
callq 0x289b0
jmp 0x27699
leaq 0xb783(%rip), %rax # 0x32e00
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
leaq 0x4948(%rip), %rsi # 0x2bfda
movb $0x2, %al
callq 0x1100
leaq 0xb9ac(%rip), %rax # 0x3304c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0xb9a0(%rip), %rax # 0x3304c
movl %ecx, (%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
|
_ZN12LefDefParser24lefwMacroTimingRisesatt1Edd:
sub rsp, 18h
movsd [rsp+18h+var_10], xmm0
movsd [rsp+18h+var_18], xmm1
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
cmp qword ptr [rax], 0
jnz short loc_27619
mov [rsp+18h+var_4], 1
jmp loc_276B6
loc_27619:
lea rax, _ZN12LefDefParser11lefwDidInitE; LefDefParser::lefwDidInit
cmp dword ptr [rax], 0
jnz short loc_27632
mov [rsp+18h+var_4], 2
jmp loc_276B6
loc_27632:
lea rax, _ZN12LefDefParser17lefwIsMacroTimingE; LefDefParser::lefwIsMacroTiming
cmp dword ptr [rax], 0
jnz short loc_27648
mov [rsp+18h+var_4], 2
jmp short loc_276B6
loc_27648:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 0; LefDefParser::lefwWriteEncrypt
jz short loc_27676
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+18h+var_10]
movsd xmm1, [rsp+18h+var_18]
lea rsi, aRisesatt111g11; " RISESATT1 %.11g %.11g ;\n"
mov al, 2
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_27699
loc_27676:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+18h+var_10]
movsd xmm1, [rsp+18h+var_18]
lea rsi, aRisesatt111g11; " RISESATT1 %.11g %.11g ;\n"
mov al, 2
call _fprintf
loc_27699:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov [rax], ecx
mov [rsp+18h+var_4], 0
loc_276B6:
mov eax, [rsp+18h+var_4]
add rsp, 18h
retn
|
long long LefDefParser::lefwMacroTimingRisesatt1(
LefDefParser *this,
double a2,
double a3,
long long a4,
int a5,
int a6,
int a7,
int a8)
{
if ( *(_QWORD *)&LefDefParser::lefwFile )
{
if ( LefDefParser::lefwDidInit )
{
if ( LefDefParser::lefwIsMacroTiming )
{
if ( LefDefParser::lefwWriteEncrypt )
LefDefParser::encPrint(
LefDefParser::lefwFile,
(unsigned int)" RISESATT1 %.11g %.11g ;\n",
a5,
a6,
a7,
a8);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " RISESATT1 %.11g %.11g ;\n", a2, a3);
++LefDefParser::lefwLines;
return 0;
}
else
{
return 2;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
|
lefwMacroTimingRisesatt1:
SUB RSP,0x18
MOVSD qword ptr [RSP + 0x8],XMM0
MOVSD qword ptr [RSP],XMM1
LEA RAX,[0x132e00]
CMP qword ptr [RAX],0x0
JNZ 0x00127619
MOV dword ptr [RSP + 0x14],0x1
JMP 0x001276b6
LAB_00127619:
LEA RAX,[0x133054]
CMP dword ptr [RAX],0x0
JNZ 0x00127632
MOV dword ptr [RSP + 0x14],0x2
JMP 0x001276b6
LAB_00127632:
LEA RAX,[0x1330ac]
CMP dword ptr [RAX],0x0
JNZ 0x00127648
MOV dword ptr [RSP + 0x14],0x2
JMP 0x001276b6
LAB_00127648:
CMP dword ptr [0x001330ec],0x0
JZ 0x00127676
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x8]
MOVSD XMM1,qword ptr [RSP]
LEA RSI,[0x12bfda]
MOV AL,0x2
CALL 0x001289b0
JMP 0x00127699
LAB_00127676:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x8]
MOVSD XMM1,qword ptr [RSP]
LEA RSI,[0x12bfda]
MOV AL,0x2
CALL 0x00101100
LAB_00127699:
LEA RAX,[0x13304c]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x13304c]
MOV dword ptr [RAX],ECX
MOV dword ptr [RSP + 0x14],0x0
LAB_001276b6:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x18
RET
|
/* LefDefParser::lefwMacroTimingRisesatt1(double, double) */
int4 LefDefParser::lefwMacroTimingRisesatt1(double param_1,double param_2)
{
int4 local_4;
if (lefwFile == (_IO_FILE *)0x0) {
local_4 = 1;
}
else if (lefwDidInit == 0) {
local_4 = 2;
}
else if (lefwIsMacroTiming == 0) {
local_4 = 2;
}
else {
if (lefwWriteEncrypt == 0) {
fprintf(lefwFile," RISESATT1 %.11g %.11g ;\n",param_1,param_2);
}
else {
encPrint(lefwFile," RISESATT1 %.11g %.11g ;\n",param_1,param_2);
}
lefwLines = lefwLines + 1;
local_4 = 0;
}
return local_4;
}
|
|
19,888
|
LefDefParser::lefwMacroTimingRisesatt1(double, double)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp
|
int
lefwMacroTimingRisesatt1(double min,
double max)
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (!lefwDidInit)
return LEFW_BAD_ORDER;
if (!lefwIsMacroTiming)
return LEFW_BAD_ORDER;
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) " RISESATT1 %.11g %.11g ;\n", min, max);
else
fprintf(lefwFile, " RISESATT1 %.11g %.11g ;\n", min, max);
lefwLines++;
return LEFW_OK;
}
|
O3
|
cpp
|
LefDefParser::lefwMacroTimingRisesatt1(double, double):
leaq 0xcd88(%rip), %rax # 0x24e00
movq (%rax), %rdi
testq %rdi, %rdi
je 0x180b7
leaq 0xcfcd(%rip), %rax # 0x25054
cmpl $0x0, (%rax)
movl $0x2, %eax
je 0x180da
leaq 0xd014(%rip), %rcx # 0x250ac
cmpl $0x0, (%rcx)
je 0x180da
pushq %rax
cmpb $0x1, 0xd047(%rip) # 0x250ec
jne 0x180bd
leaq 0x41e8(%rip), %rsi # 0x1c296
movb $0x2, %al
callq 0x18c35
jmp 0x180cb
movl $0x1, %eax
retq
leaq 0x41d2(%rip), %rsi # 0x1c296
movb $0x2, %al
callq 0x10f0
leaq 0xcf7a(%rip), %rax # 0x2504c
incl (%rax)
xorl %eax, %eax
addq $0x8, %rsp
retq
|
_ZN12LefDefParser24lefwMacroTimingRisesatt1Edd:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
test rdi, rdi
jz short loc_180B7
lea rax, _ZN12LefDefParser11lefwDidInitE; LefDefParser::lefwDidInit
cmp dword ptr [rax], 0
mov eax, 2
jz short locret_180DA
lea rcx, _ZN12LefDefParser17lefwIsMacroTimingE; LefDefParser::lefwIsMacroTiming
cmp dword ptr [rcx], 0
jz short locret_180DA
push rax
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 1; LefDefParser::lefwWriteEncrypt
jnz short loc_180BD
lea rsi, aRisesatt111g11; " RISESATT1 %.11g %.11g ;\n"
mov al, 2
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_180CB
loc_180B7:
mov eax, 1
retn
loc_180BD:
lea rsi, aRisesatt111g11; " RISESATT1 %.11g %.11g ;\n"
mov al, 2
call _fprintf
loc_180CB:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
xor eax, eax
add rsp, 8
locret_180DA:
retn
|
long long LefDefParser::lefwMacroTimingRisesatt1(
LefDefParser *this,
double a2,
double a3,
long long a4,
int a5,
long long a6,
int a7,
int a8)
{
long long result; // rax
if ( !*(_QWORD *)&LefDefParser::lefwFile )
return 1LL;
result = 2LL;
if ( LefDefParser::lefwDidInit && LefDefParser::lefwIsMacroTiming )
{
if ( LefDefParser::lefwWriteEncrypt == 1 )
LefDefParser::encPrint(
LefDefParser::lefwFile,
(unsigned int)" RISESATT1 %.11g %.11g ;\n",
a5,
(unsigned int)&LefDefParser::lefwIsMacroTiming,
a7,
a8);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " RISESATT1 %.11g %.11g ;\n", a2, a3);
++LefDefParser::lefwLines;
return 0LL;
}
return result;
}
|
lefwMacroTimingRisesatt1:
LEA RAX,[0x124e00]
MOV RDI,qword ptr [RAX]
TEST RDI,RDI
JZ 0x001180b7
LEA RAX,[0x125054]
CMP dword ptr [RAX],0x0
MOV EAX,0x2
JZ 0x001180da
LEA RCX,[0x1250ac]
CMP dword ptr [RCX],0x0
JZ 0x001180da
PUSH RAX
CMP byte ptr [0x001250ec],0x1
JNZ 0x001180bd
LEA RSI,[0x11c296]
MOV AL,0x2
CALL 0x00118c35
JMP 0x001180cb
LAB_001180b7:
MOV EAX,0x1
RET
LAB_001180bd:
LEA RSI,[0x11c296]
MOV AL,0x2
CALL 0x001010f0
LAB_001180cb:
LEA RAX,[0x12504c]
INC dword ptr [RAX]
XOR EAX,EAX
ADD RSP,0x8
LAB_001180da:
RET
|
/* LefDefParser::lefwMacroTimingRisesatt1(double, double) */
int8 LefDefParser::lefwMacroTimingRisesatt1(double param_1,double param_2)
{
int8 uVar1;
if (lefwFile != (_IO_FILE *)0x0) {
uVar1 = 2;
if ((lefwDidInit != 0) && (lefwIsMacroTiming != 0)) {
if (lefwWriteEncrypt == '\x01') {
encPrint(lefwFile," RISESATT1 %.11g %.11g ;\n");
}
else {
fprintf(lefwFile," RISESATT1 %.11g %.11g ;\n");
}
lefwLines = lefwLines + 1;
uVar1 = 0;
}
return uVar1;
}
return 1;
}
|
|
19,889
|
OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::Clear()
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/stencilTable.cpp
|
void
StencilTableReal<REAL>::Clear() {
_numControlVertices=0;
_sizes.clear();
_offsets.clear();
_indices.clear();
_weights.clear();
}
|
O1
|
cpp
|
OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::Clear():
movl $0x0, 0x8(%rdi)
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0x71e6b
movq %rax, 0x18(%rdi)
movq 0x28(%rdi), %rax
cmpq %rax, 0x30(%rdi)
je 0x71e79
movq %rax, 0x30(%rdi)
movq 0x40(%rdi), %rax
cmpq %rax, 0x48(%rdi)
je 0x71e87
movq %rax, 0x48(%rdi)
movq 0x58(%rdi), %rax
cmpq %rax, 0x60(%rdi)
je 0x71e95
movq %rax, 0x60(%rdi)
retq
|
_ZN10OpenSubdiv6v3_6_03Far16StencilTableRealIdE5ClearEv:
mov dword ptr [rdi+8], 0
mov rax, [rdi+10h]
cmp [rdi+18h], rax
jz short loc_71E6B
mov [rdi+18h], rax
loc_71E6B:
mov rax, [rdi+28h]
cmp [rdi+30h], rax
jz short loc_71E79
mov [rdi+30h], rax
loc_71E79:
mov rax, [rdi+40h]
cmp [rdi+48h], rax
jz short loc_71E87
mov [rdi+48h], rax
loc_71E87:
mov rax, [rdi+58h]
cmp [rdi+60h], rax
jz short locret_71E95
mov [rdi+60h], rax
locret_71E95:
retn
|
long long OpenSubdiv::v3_6_0::Far::StencilTableReal<double>::Clear(long long a1)
{
long long v1; // rax
long long v2; // rax
long long v3; // rax
long long result; // rax
*(_DWORD *)(a1 + 8) = 0;
v1 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 24) != v1 )
*(_QWORD *)(a1 + 24) = v1;
v2 = *(_QWORD *)(a1 + 40);
if ( *(_QWORD *)(a1 + 48) != v2 )
*(_QWORD *)(a1 + 48) = v2;
v3 = *(_QWORD *)(a1 + 64);
if ( *(_QWORD *)(a1 + 72) != v3 )
*(_QWORD *)(a1 + 72) = v3;
result = *(_QWORD *)(a1 + 88);
if ( *(_QWORD *)(a1 + 96) != result )
*(_QWORD *)(a1 + 96) = result;
return result;
}
|
Clear:
MOV dword ptr [RDI + 0x8],0x0
MOV RAX,qword ptr [RDI + 0x10]
CMP qword ptr [RDI + 0x18],RAX
JZ 0x00171e6b
MOV qword ptr [RDI + 0x18],RAX
LAB_00171e6b:
MOV RAX,qword ptr [RDI + 0x28]
CMP qword ptr [RDI + 0x30],RAX
JZ 0x00171e79
MOV qword ptr [RDI + 0x30],RAX
LAB_00171e79:
MOV RAX,qword ptr [RDI + 0x40]
CMP qword ptr [RDI + 0x48],RAX
JZ 0x00171e87
MOV qword ptr [RDI + 0x48],RAX
LAB_00171e87:
MOV RAX,qword ptr [RDI + 0x58]
CMP qword ptr [RDI + 0x60],RAX
JZ 0x00171e95
MOV qword ptr [RDI + 0x60],RAX
LAB_00171e95:
RET
|
/* OpenSubdiv::v3_6_0::Far::StencilTableReal<double>::Clear() */
void __thiscall
OpenSubdiv::v3_6_0::Far::StencilTableReal<double>::Clear(StencilTableReal<double> *this)
{
*(int4 *)(this + 8) = 0;
if (*(long *)(this + 0x18) != *(long *)(this + 0x10)) {
*(long *)(this + 0x18) = *(long *)(this + 0x10);
}
if (*(long *)(this + 0x30) != *(long *)(this + 0x28)) {
*(long *)(this + 0x30) = *(long *)(this + 0x28);
}
if (*(long *)(this + 0x48) != *(long *)(this + 0x40)) {
*(long *)(this + 0x48) = *(long *)(this + 0x40);
}
if (*(long *)(this + 0x60) != *(long *)(this + 0x58)) {
*(long *)(this + 0x60) = *(long *)(this + 0x58);
}
return;
}
|
|
19,890
|
OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::Clear()
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/stencilTable.cpp
|
void
StencilTableReal<REAL>::Clear() {
_numControlVertices=0;
_sizes.clear();
_offsets.clear();
_indices.clear();
_weights.clear();
}
|
O2
|
cpp
|
OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::Clear():
andl $0x0, 0x8(%rdi)
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0x836c8
movq %rax, 0x18(%rdi)
movq 0x28(%rdi), %rax
cmpq %rax, 0x30(%rdi)
je 0x836d6
movq %rax, 0x30(%rdi)
movq 0x40(%rdi), %rax
cmpq %rax, 0x48(%rdi)
je 0x836e4
movq %rax, 0x48(%rdi)
movq 0x58(%rdi), %rax
cmpq %rax, 0x60(%rdi)
je 0x836f2
movq %rax, 0x60(%rdi)
retq
nop
|
_ZN10OpenSubdiv6v3_6_03Far16StencilTableRealIdE5ClearEv:
and dword ptr [rdi+8], 0
mov rax, [rdi+10h]
cmp [rdi+18h], rax
jz short loc_836C8
mov [rdi+18h], rax
loc_836C8:
mov rax, [rdi+28h]
cmp [rdi+30h], rax
jz short loc_836D6
mov [rdi+30h], rax
loc_836D6:
mov rax, [rdi+40h]
cmp [rdi+48h], rax
jz short loc_836E4
mov [rdi+48h], rax
loc_836E4:
mov rax, [rdi+58h]
cmp [rdi+60h], rax
jz short locret_836F2
mov [rdi+60h], rax
locret_836F2:
retn
|
long long OpenSubdiv::v3_6_0::Far::StencilTableReal<double>::Clear(long long a1)
{
long long v1; // rax
long long v2; // rax
long long v3; // rax
long long result; // rax
*(_DWORD *)(a1 + 8) = 0;
v1 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 24) != v1 )
*(_QWORD *)(a1 + 24) = v1;
v2 = *(_QWORD *)(a1 + 40);
if ( *(_QWORD *)(a1 + 48) != v2 )
*(_QWORD *)(a1 + 48) = v2;
v3 = *(_QWORD *)(a1 + 64);
if ( *(_QWORD *)(a1 + 72) != v3 )
*(_QWORD *)(a1 + 72) = v3;
result = *(_QWORD *)(a1 + 88);
if ( *(_QWORD *)(a1 + 96) != result )
*(_QWORD *)(a1 + 96) = result;
return result;
}
|
Clear:
AND dword ptr [RDI + 0x8],0x0
MOV RAX,qword ptr [RDI + 0x10]
CMP qword ptr [RDI + 0x18],RAX
JZ 0x001836c8
MOV qword ptr [RDI + 0x18],RAX
LAB_001836c8:
MOV RAX,qword ptr [RDI + 0x28]
CMP qword ptr [RDI + 0x30],RAX
JZ 0x001836d6
MOV qword ptr [RDI + 0x30],RAX
LAB_001836d6:
MOV RAX,qword ptr [RDI + 0x40]
CMP qword ptr [RDI + 0x48],RAX
JZ 0x001836e4
MOV qword ptr [RDI + 0x48],RAX
LAB_001836e4:
MOV RAX,qword ptr [RDI + 0x58]
CMP qword ptr [RDI + 0x60],RAX
JZ 0x001836f2
MOV qword ptr [RDI + 0x60],RAX
LAB_001836f2:
RET
|
/* OpenSubdiv::v3_6_0::Far::StencilTableReal<double>::Clear() */
void __thiscall
OpenSubdiv::v3_6_0::Far::StencilTableReal<double>::Clear(StencilTableReal<double> *this)
{
*(int4 *)(this + 8) = 0;
if (*(long *)(this + 0x18) != *(long *)(this + 0x10)) {
*(long *)(this + 0x18) = *(long *)(this + 0x10);
}
if (*(long *)(this + 0x30) != *(long *)(this + 0x28)) {
*(long *)(this + 0x30) = *(long *)(this + 0x28);
}
if (*(long *)(this + 0x48) != *(long *)(this + 0x40)) {
*(long *)(this + 0x48) = *(long *)(this + 0x40);
}
if (*(long *)(this + 0x60) != *(long *)(this + 0x58)) {
*(long *)(this + 0x60) = *(long *)(this + 0x58);
}
return;
}
|
|
19,891
|
OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::Clear()
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/stencilTable.cpp
|
void
StencilTableReal<REAL>::Clear() {
_numControlVertices=0;
_sizes.clear();
_offsets.clear();
_indices.clear();
_weights.clear();
}
|
O3
|
cpp
|
OpenSubdiv::v3_6_0::Far::StencilTableReal<float>::Clear():
movl $0x0, 0x8(%rdi)
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0x7345b
movq %rax, 0x18(%rdi)
movq 0x28(%rdi), %rax
cmpq %rax, 0x30(%rdi)
je 0x73469
movq %rax, 0x30(%rdi)
movq 0x40(%rdi), %rax
cmpq %rax, 0x48(%rdi)
je 0x73477
movq %rax, 0x48(%rdi)
movq 0x58(%rdi), %rax
cmpq %rax, 0x60(%rdi)
je 0x73485
movq %rax, 0x60(%rdi)
retq
|
_ZN10OpenSubdiv6v3_6_03Far16StencilTableRealIdE5ClearEv:
mov dword ptr [rdi+8], 0
mov rax, [rdi+10h]
cmp [rdi+18h], rax
jz short loc_7345B
mov [rdi+18h], rax
loc_7345B:
mov rax, [rdi+28h]
cmp [rdi+30h], rax
jz short loc_73469
mov [rdi+30h], rax
loc_73469:
mov rax, [rdi+40h]
cmp [rdi+48h], rax
jz short loc_73477
mov [rdi+48h], rax
loc_73477:
mov rax, [rdi+58h]
cmp [rdi+60h], rax
jz short locret_73485
mov [rdi+60h], rax
locret_73485:
retn
|
long long OpenSubdiv::v3_6_0::Far::StencilTableReal<double>::Clear(long long a1)
{
long long v1; // rax
long long v2; // rax
long long v3; // rax
long long result; // rax
*(_DWORD *)(a1 + 8) = 0;
v1 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 24) != v1 )
*(_QWORD *)(a1 + 24) = v1;
v2 = *(_QWORD *)(a1 + 40);
if ( *(_QWORD *)(a1 + 48) != v2 )
*(_QWORD *)(a1 + 48) = v2;
v3 = *(_QWORD *)(a1 + 64);
if ( *(_QWORD *)(a1 + 72) != v3 )
*(_QWORD *)(a1 + 72) = v3;
result = *(_QWORD *)(a1 + 88);
if ( *(_QWORD *)(a1 + 96) != result )
*(_QWORD *)(a1 + 96) = result;
return result;
}
|
Clear:
MOV dword ptr [RDI + 0x8],0x0
MOV RAX,qword ptr [RDI + 0x10]
CMP qword ptr [RDI + 0x18],RAX
JZ 0x0017345b
MOV qword ptr [RDI + 0x18],RAX
LAB_0017345b:
MOV RAX,qword ptr [RDI + 0x28]
CMP qword ptr [RDI + 0x30],RAX
JZ 0x00173469
MOV qword ptr [RDI + 0x30],RAX
LAB_00173469:
MOV RAX,qword ptr [RDI + 0x40]
CMP qword ptr [RDI + 0x48],RAX
JZ 0x00173477
MOV qword ptr [RDI + 0x48],RAX
LAB_00173477:
MOV RAX,qword ptr [RDI + 0x58]
CMP qword ptr [RDI + 0x60],RAX
JZ 0x00173485
MOV qword ptr [RDI + 0x60],RAX
LAB_00173485:
RET
|
/* OpenSubdiv::v3_6_0::Far::StencilTableReal<double>::Clear() */
void __thiscall
OpenSubdiv::v3_6_0::Far::StencilTableReal<double>::Clear(StencilTableReal<double> *this)
{
*(int4 *)(this + 8) = 0;
if (*(long *)(this + 0x18) != *(long *)(this + 0x10)) {
*(long *)(this + 0x18) = *(long *)(this + 0x10);
}
if (*(long *)(this + 0x30) != *(long *)(this + 0x28)) {
*(long *)(this + 0x30) = *(long *)(this + 0x28);
}
if (*(long *)(this + 0x48) != *(long *)(this + 0x40)) {
*(long *)(this + 0x48) = *(long *)(this + 0x40);
}
if (*(long *)(this + 0x60) != *(long *)(this + 0x58)) {
*(long *)(this + 0x60) = *(long *)(this + 0x58);
}
return;
}
|
|
19,892
|
ma_compact_keypage
|
eloqsql/storage/maria/ma_page.c
|
my_bool _ma_compact_keypage(MARIA_PAGE *ma_page, TrID min_read_from)
{
MARIA_HA *info= ma_page->info;
MARIA_SHARE *share= info->s;
MARIA_KEY key;
uchar *page, *endpos, *start_of_empty_space;
uint page_flag, nod_flag, saved_space;
my_bool page_has_transid;
DBUG_ENTER("_ma_compact_keypage");
page_flag= ma_page->flag;
if (!(page_flag & KEYPAGE_FLAG_HAS_TRANSID))
DBUG_RETURN(0); /* No transaction id on page */
nod_flag= ma_page->node;
page= ma_page->buff;
endpos= page + ma_page->size;
key.data= info->lastkey_buff;
key.keyinfo= (MARIA_KEYDEF*) ma_page->keyinfo;
page_has_transid= 0;
page+= share->keypage_header + nod_flag;
key.data[0]= 0; /* safety */
start_of_empty_space= 0;
saved_space= 0;
do
{
if (!(page= (*ma_page->keyinfo->skip_key)(&key, 0, 0, page)))
{
DBUG_PRINT("error",("Couldn't find last key: page_pos: %p",
page));
_ma_set_fatal_error(info, HA_ERR_CRASHED);
DBUG_RETURN(1);
}
if (key_has_transid(page-1))
{
uint transid_length;
transid_length= transid_packed_length(page);
if (min_read_from == ~(TrID) 0 ||
min_read_from < transid_get_packed(share, page))
{
page[-1]&= 254; /* Remove transid marker */
transid_length= transid_packed_length(page);
if (start_of_empty_space)
{
/* Move block before the transid up in page */
uint copy_length= (uint) (page - start_of_empty_space) - saved_space;
memmove(start_of_empty_space, start_of_empty_space + saved_space,
copy_length);
start_of_empty_space+= copy_length;
}
else
start_of_empty_space= page;
saved_space+= transid_length;
}
else
page_has_transid= 1; /* At least one id left */
page+= transid_length;
}
page+= nod_flag;
} while (page < endpos);
DBUG_ASSERT(page == endpos);
if (start_of_empty_space)
{
/*
Move last block down
This is always true if any transid was removed
*/
uint copy_length= (uint) (endpos - start_of_empty_space) - saved_space;
if (copy_length)
memmove(start_of_empty_space, start_of_empty_space + saved_space,
copy_length);
ma_page->size= (uint) (start_of_empty_space + copy_length - ma_page->buff);
page_store_size(share, ma_page);
}
if (!page_has_transid)
{
ma_page->flag&= ~KEYPAGE_FLAG_HAS_TRANSID;
_ma_store_keypage_flag(share, ma_page->buff, ma_page->flag);
/* Clear packed transid (in case of zerofill) */
bzero(ma_page->buff + LSN_STORE_SIZE, TRANSID_SIZE);
}
if (share->now_transactional)
{
if (_ma_log_compact_keypage(ma_page, min_read_from))
DBUG_RETURN(1);
}
DBUG_RETURN(0);
}
|
O3
|
c
|
ma_compact_keypage:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
xorl %ecx, %ecx
testb $0x2, 0x2c(%rdi)
je 0x604cf
movq %rsi, %r12
movq %rdi, %r14
movq $0x0, -0x60(%rbp)
movq (%rdi), %rcx
movq (%rcx), %rsi
movl 0x28(%rdi), %edi
movq 0x10(%r14), %rax
movl 0x20(%r14), %r13d
addq %rax, %r13
movq %rcx, -0x70(%rbp)
movq 0x388(%rcx), %rcx
leaq -0xb8(%rbp), %r8
movq %rcx, (%r8)
movq 0x8(%r14), %rdx
movq %rdx, 0x8(%r8)
movq %rsi, -0x58(%rbp)
movl 0x744(%rsi), %r15d
movq %rdi, -0x90(%rbp)
addl %edi, %r15d
addq %rax, %r15
movb $0x0, (%rcx)
movq $0x0, -0x68(%rbp)
xorl %ebx, %ebx
movq %r12, -0x80(%rbp)
movq %r14, -0x78(%rbp)
movq %r13, -0x88(%rbp)
movq 0x8(%r14), %rax
leaq -0xb8(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
callq *0xe8(%rax)
testq %rax, %rax
je 0x603ae
movq %rax, %r15
movb -0x1(%rax), %al
testb $0x1, %al
je 0x60388
cmpq $-0x1, %r12
je 0x60313
movzbl (%r15), %eax
leal -0xf8(%rax), %r13d
cmpl $0xf3, %eax
movl $0x1, %eax
cmovbl %eax, %r13d
movq -0x58(%rbp), %rdi
movq %r15, %rsi
callq 0x61d01
cmpq %r12, %rax
jbe 0x60365
movb -0x1(%r15), %al
andb $-0x2, %al
movb %al, -0x1(%r15)
movzbl (%r15), %eax
leal -0xf8(%rax), %r13d
cmpl $0xf3, %eax
movl $0x1, %eax
cmovbl %eax, %r13d
testq %rbx, %rbx
je 0x6036d
movl %r15d, %r14d
subl %ebx, %r14d
movq -0x60(%rbp), %r12
subl %r12d, %r14d
movl %r12d, %esi
addq %rbx, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2a150
movq %r12, %rax
addq %r14, %rbx
movq -0x78(%rbp), %r14
movq -0x80(%rbp), %r12
jmp 0x60374
movb $0x1, %al
movq %rax, -0x68(%rbp)
jmp 0x6037b
movq %r15, %rbx
movq -0x60(%rbp), %rax
addl %r13d, %eax
movq %rax, -0x60(%rbp)
movl %r13d, %eax
addq %rax, %r15
movq -0x88(%rbp), %r13
addq -0x90(%rbp), %r15
cmpq %r13, %r15
jb 0x602b0
testq %rbx, %rbx
je 0x60400
subl %ebx, %r13d
movq -0x60(%rbp), %rax
subl %eax, %r13d
jne 0x603c3
movl %r13d, %r15d
jmp 0x603d6
movq -0x70(%rbp), %rdi
movl $0x7e, %esi
callq 0x5cab0
movb $0x1, %cl
jmp 0x604cf
movl %eax, %esi
addq %rbx, %rsi
movl %r13d, %r15d
movq %rbx, %rdi
movq %r15, %rdx
callq 0x2a150
addq %r15, %rbx
movq 0x10(%r14), %rax
subq %rax, %rbx
movl %ebx, 0x20(%r14)
movq -0x58(%rbp), %rdx
movl 0x744(%rdx), %ecx
movb %bl, -0x1(%rax,%rcx)
movq 0x10(%r14), %rax
movl 0x744(%rdx), %ecx
movb %bh, -0x2(%rax,%rcx)
cmpb $0x0, -0x68(%rbp)
jne 0x60436
movl 0x2c(%r14), %eax
andl $-0x3, %eax
movl %eax, 0x2c(%r14)
movq 0x10(%r14), %rcx
movq -0x58(%rbp), %rdx
movl 0x744(%rdx), %edx
addl $-0x3, %edx
movb %al, (%rcx,%rdx)
movq 0x10(%r14), %rax
movw $0x0, 0xb(%rax)
movl $0x0, 0x7(%rax)
movq -0x58(%rbp), %rax
cmpb $0x0, 0x7e7(%rax)
je 0x604cd
movq (%r14), %rcx
movq 0x18(%r14), %rax
movq (%rcx), %rdx
movl 0x7bc(%rdx), %esi
xorl %edx, %edx
divq %rsi
leaq -0x50(%rbp), %r10
movl %eax, 0x2(%r10)
shrq $0x20, %rax
movb %al, 0x6(%r10)
movb $0xb, 0x7(%r10)
movl %r12d, 0x8(%r10)
shrq $0x20, %r12
movw %r12w, 0xc(%r10)
leaq -0xf0(%rbp), %rax
movq %r10, 0x20(%rax)
movq $0xe, 0x28(%rax)
movl 0x20(%r14), %edx
movl %edx, 0x24(%r14)
movq 0x8(%rcx), %rdx
subq $0x8, %rsp
leaq -0x98(%rbp), %rdi
movl $0xc, %esi
movl $0xe, %r8d
movl $0x3, %r9d
pushq $0x0
pushq %r10
pushq %rax
callq 0x2b425
addq $0x20, %rsp
movb $0x1, %cl
testb %al, %al
jne 0x604cf
xorl %ecx, %ecx
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x604f2
movl %ecx, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2a280
nop
|
_ma_compact_keypage:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov rax, fs:28h
mov [rbp+var_30], rax
xor ecx, ecx
test byte ptr [rdi+2Ch], 2
jz loc_604CF
mov r12, rsi
mov r14, rdi
mov [rbp+var_60], 0
mov rcx, [rdi]
mov rsi, [rcx]
mov edi, [rdi+28h]
mov rax, [r14+10h]
mov r13d, [r14+20h]
add r13, rax
mov [rbp+var_70], rcx
mov rcx, [rcx+388h]
lea r8, [rbp+var_B8]
mov [r8], rcx
mov rdx, [r14+8]
mov [r8+8], rdx
mov [rbp+var_58], rsi
mov r15d, [rsi+744h]
mov [rbp+var_90], rdi
add r15d, edi
add r15, rax
mov byte ptr [rcx], 0
mov [rbp+var_68], 0
xor ebx, ebx
mov [rbp+var_80], r12
mov [rbp+var_78], r14
mov [rbp+var_88], r13
loc_602B0:
mov rax, [r14+8]
lea rdi, [rbp+var_B8]
xor esi, esi
xor edx, edx
mov rcx, r15
call qword ptr [rax+0E8h]
test rax, rax
jz loc_603AE
mov r15, rax
mov al, [rax-1]
test al, 1
jz loc_60388
cmp r12, 0FFFFFFFFFFFFFFFFh
jz short loc_60313
movzx eax, byte ptr [r15]
lea r13d, [rax-0F8h]
cmp eax, 0F3h
mov eax, 1
cmovb r13d, eax
mov rdi, [rbp+var_58]
mov rsi, r15
call transid_get_packed
cmp rax, r12
jbe short loc_60365
mov al, [r15-1]
loc_60313:
and al, 0FEh
mov [r15-1], al
movzx eax, byte ptr [r15]
lea r13d, [rax-0F8h]
cmp eax, 0F3h
mov eax, 1
cmovb r13d, eax
test rbx, rbx
jz short loc_6036D
mov r14d, r15d
sub r14d, ebx
mov r12, [rbp+var_60]
sub r14d, r12d
mov esi, r12d
add rsi, rbx
mov rdi, rbx
mov rdx, r14
call _memmove
mov rax, r12
add rbx, r14
mov r14, [rbp+var_78]
mov r12, [rbp+var_80]
jmp short loc_60374
loc_60365:
mov al, 1
mov [rbp+var_68], rax
jmp short loc_6037B
loc_6036D:
mov rbx, r15
mov rax, [rbp+var_60]
loc_60374:
add eax, r13d
mov [rbp+var_60], rax
loc_6037B:
mov eax, r13d
add r15, rax
mov r13, [rbp+var_88]
loc_60388:
add r15, [rbp+var_90]
cmp r15, r13
jb loc_602B0
test rbx, rbx
jz short loc_60400
sub r13d, ebx
mov rax, [rbp+var_60]
sub r13d, eax
jnz short loc_603C3
mov r15d, r13d
jmp short loc_603D6
loc_603AE:
mov rdi, [rbp+var_70]
mov esi, 7Eh ; '~'
call _ma_set_fatal_error
mov cl, 1
jmp loc_604CF
loc_603C3:
mov esi, eax
add rsi, rbx
mov r15d, r13d
mov rdi, rbx
mov rdx, r15
call _memmove
loc_603D6:
add rbx, r15
mov rax, [r14+10h]
sub rbx, rax
mov [r14+20h], ebx
mov rdx, [rbp+var_58]
mov ecx, [rdx+744h]
mov [rax+rcx-1], bl
mov rax, [r14+10h]
mov ecx, [rdx+744h]
mov [rax+rcx-2], bh
loc_60400:
cmp byte ptr [rbp+var_68], 0
jnz short loc_60436
mov eax, [r14+2Ch]
and eax, 0FFFFFFFDh
mov [r14+2Ch], eax
mov rcx, [r14+10h]
mov rdx, [rbp+var_58]
mov edx, [rdx+744h]
add edx, 0FFFFFFFDh
mov [rcx+rdx], al
mov rax, [r14+10h]
mov word ptr [rax+0Bh], 0
mov dword ptr [rax+7], 0
loc_60436:
mov rax, [rbp+var_58]
cmp byte ptr [rax+7E7h], 0
jz loc_604CD
mov rcx, [r14]
mov rax, [r14+18h]
mov rdx, [rcx]
mov esi, [rdx+7BCh]
xor edx, edx
div rsi
lea r10, [rbp+var_50]
mov [r10+2], eax
shr rax, 20h
mov [r10+6], al
mov byte ptr [r10+7], 0Bh
mov [r10+8], r12d
shr r12, 20h
mov [r10+0Ch], r12w
lea rax, [rbp+var_F0]
mov [rax+20h], r10
mov qword ptr [rax+28h], 0Eh
mov edx, [r14+20h]
mov [r14+24h], edx
mov rdx, [rcx+8]
sub rsp, 8
lea rdi, [rbp+var_98]
mov esi, 0Ch
mov r8d, 0Eh
mov r9d, 3
push 0
push r10
push rax
call translog_write_record
add rsp, 20h
mov cl, 1
test al, al
jnz short loc_604CF
loc_604CD:
xor ecx, ecx
loc_604CF:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_604F2
mov eax, ecx
add rsp, 0C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_604F2:
call ___stack_chk_fail
|
long long ma_compact_keypage(long long **a1, unsigned long long a2)
{
unsigned int v2; // ecx
long long **v4; // r14
long long *v5; // rcx
long long v6; // rsi
long long v7; // rdi
long long *v8; // rax
unsigned long long v9; // r13
int v10; // r15d
unsigned __int8 *v11; // r15
unsigned __int8 *v12; // rbx
long long v13; // rax
long long v14; // rdx
long long v15; // rcx
long long v16; // r8
int v17; // r9d
unsigned __int8 *v18; // r15
char v19; // al
unsigned int v20; // eax
unsigned int v21; // r13d
unsigned long long packed; // rax
unsigned int v23; // eax
int v24; // r12d
long long v25; // r14
int v26; // eax
unsigned int v27; // r13d
unsigned int v28; // r15d
long long *v29; // rax
unsigned int v30; // ebx
long long v31; // rdx
unsigned int v32; // eax
long long *v33; // rax
long long *v34; // rcx
unsigned long long v35; // rax
char v36; // al
__int128 v38; // [rsp+0h] [rbp-F0h] BYREF
__int16 *v39; // [rsp+20h] [rbp-D0h]
long long v40; // [rsp+28h] [rbp-C8h]
_QWORD v41[4]; // [rsp+38h] [rbp-B8h] BYREF
char v42[8]; // [rsp+58h] [rbp-98h] BYREF
long long v43; // [rsp+60h] [rbp-90h]
unsigned long long v44; // [rsp+68h] [rbp-88h]
unsigned long long v45; // [rsp+70h] [rbp-80h]
long long **v46; // [rsp+78h] [rbp-78h]
long long *v47; // [rsp+80h] [rbp-70h]
unsigned long long v48; // [rsp+88h] [rbp-68h]
long long v49; // [rsp+90h] [rbp-60h]
long long v50; // [rsp+98h] [rbp-58h]
__int16 v51; // [rsp+A0h] [rbp-50h] BYREF
int v52; // [rsp+A2h] [rbp-4Eh]
char v53; // [rsp+A6h] [rbp-4Ah]
char v54; // [rsp+A7h] [rbp-49h]
int v55; // [rsp+A8h] [rbp-48h]
__int16 v56; // [rsp+ACh] [rbp-44h]
unsigned long long v57; // [rsp+C0h] [rbp-30h]
v57 = __readfsqword(0x28u);
v2 = 0;
if ( (*((_BYTE *)a1 + 44) & 2) == 0 )
return v2;
v4 = a1;
v49 = 0LL;
v5 = *a1;
v6 = **a1;
v7 = *((unsigned int *)a1 + 10);
v8 = v4[2];
v9 = (unsigned long long)v8 + *((unsigned int *)v4 + 8);
v47 = v5;
v41[0] = v5[113];
v41[1] = v4[1];
v50 = v6;
v10 = *(_DWORD *)(v6 + 1860);
v43 = v7;
v11 = (unsigned __int8 *)v8 + (unsigned int)(v7 + v10);
*(_BYTE *)v41[0] = 0;
v48 = 0LL;
v12 = 0LL;
v45 = a2;
v46 = v4;
v44 = v9;
do
{
v13 = ((long long ( *)(_QWORD *, _QWORD, _QWORD, unsigned __int8 *))v4[1][29])(v41, 0LL, 0LL, v11);
if ( !v13 )
{
ma_set_fatal_error(v47, 126, v14, v15, v16, v17);
LOBYTE(v2) = 1;
return v2;
}
v18 = (unsigned __int8 *)v13;
v19 = *(_BYTE *)(v13 - 1);
if ( (v19 & 1) != 0 )
{
if ( a2 != -1LL )
{
v20 = *v18;
v21 = v20 - 248;
if ( v20 < 0xF3 )
v21 = 1;
packed = transid_get_packed(v50, v18);
if ( packed <= a2 )
{
LOBYTE(packed) = 1;
v48 = packed;
LABEL_17:
v18 += v21;
v9 = v44;
goto LABEL_18;
}
v19 = *(v18 - 1);
}
*(v18 - 1) = v19 & 0xFE;
v23 = *v18;
v21 = v23 - 248;
if ( v23 < 0xF3 )
v21 = 1;
if ( v12 )
{
v24 = v49;
v25 = (unsigned int)((_DWORD)v18 - (_DWORD)v12 - v49);
memmove(v12, &v12[(unsigned int)v49], v25);
v26 = v24;
v12 += v25;
v4 = v46;
a2 = v45;
}
else
{
v12 = v18;
v26 = v49;
}
v49 = v21 + v26;
goto LABEL_17;
}
LABEL_18:
v11 = &v18[v43];
}
while ( (unsigned long long)v11 < v9 );
if ( v12 )
{
v27 = v9 - (_DWORD)v12 - v49;
if ( v27 )
{
v28 = v27;
memmove(v12, &v12[(unsigned int)v49], v27);
}
else
{
v28 = 0;
}
v29 = v4[2];
v30 = v28 + (_DWORD)v12 - (_DWORD)v29;
*((_DWORD *)v4 + 8) = v30;
v31 = v50;
*((_BYTE *)v29 + *(unsigned int *)(v50 + 1860) - 1) = v30;
*((_BYTE *)v4[2] + *(unsigned int *)(v31 + 1860) - 2) = BYTE1(v30);
}
if ( !(_BYTE)v48 )
{
v32 = *((_DWORD *)v4 + 11) & 0xFFFFFFFD;
*((_DWORD *)v4 + 11) = v32;
*((_BYTE *)v4[2] + (unsigned int)(*(_DWORD *)(v50 + 1860) - 3)) = v32;
v33 = v4[2];
*(_WORD *)((char *)v33 + 11) = 0;
*(_DWORD *)((char *)v33 + 7) = 0;
}
if ( !*(_BYTE *)(v50 + 2023) )
return 0;
v34 = *v4;
v35 = (unsigned long long)v4[3] / *(unsigned int *)(**v4 + 1980);
v52 = v35;
v53 = BYTE4(v35);
v54 = 11;
v55 = a2;
v56 = WORD2(a2);
v39 = &v51;
v40 = 14LL;
*((_DWORD *)v4 + 9) = *((_DWORD *)v4 + 8);
v36 = translog_write_record((unsigned long long)v42, &byte_9[3], v34[1], v34, 0xEu, 3, &v38, &v51, 0LL);
LOBYTE(v2) = 1;
if ( !v36 )
return 0;
return v2;
}
|
_ma_compact_keypage:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
XOR ECX,ECX
TEST byte ptr [RDI + 0x2c],0x2
JZ 0x001604cf
MOV R12,RSI
MOV R14,RDI
MOV qword ptr [RBP + -0x60],0x0
MOV RCX,qword ptr [RDI]
MOV RSI,qword ptr [RCX]
MOV EDI,dword ptr [RDI + 0x28]
MOV RAX,qword ptr [R14 + 0x10]
MOV R13D,dword ptr [R14 + 0x20]
ADD R13,RAX
MOV qword ptr [RBP + -0x70],RCX
MOV RCX,qword ptr [RCX + 0x388]
LEA R8,[RBP + -0xb8]
MOV qword ptr [R8],RCX
MOV RDX,qword ptr [R14 + 0x8]
MOV qword ptr [R8 + 0x8],RDX
MOV qword ptr [RBP + -0x58],RSI
MOV R15D,dword ptr [RSI + 0x744]
MOV qword ptr [RBP + -0x90],RDI
ADD R15D,EDI
ADD R15,RAX
MOV byte ptr [RCX],0x0
MOV qword ptr [RBP + -0x68],0x0
XOR EBX,EBX
MOV qword ptr [RBP + -0x80],R12
MOV qword ptr [RBP + -0x78],R14
MOV qword ptr [RBP + -0x88],R13
LAB_001602b0:
MOV RAX,qword ptr [R14 + 0x8]
LEA RDI,[RBP + -0xb8]
XOR ESI,ESI
XOR EDX,EDX
MOV RCX,R15
CALL qword ptr [RAX + 0xe8]
TEST RAX,RAX
JZ 0x001603ae
MOV R15,RAX
MOV AL,byte ptr [RAX + -0x1]
TEST AL,0x1
JZ 0x00160388
CMP R12,-0x1
JZ 0x00160313
MOVZX EAX,byte ptr [R15]
LEA R13D,[RAX + -0xf8]
CMP EAX,0xf3
MOV EAX,0x1
CMOVC R13D,EAX
MOV RDI,qword ptr [RBP + -0x58]
MOV RSI,R15
CALL 0x00161d01
CMP RAX,R12
JBE 0x00160365
MOV AL,byte ptr [R15 + -0x1]
LAB_00160313:
AND AL,0xfe
MOV byte ptr [R15 + -0x1],AL
MOVZX EAX,byte ptr [R15]
LEA R13D,[RAX + -0xf8]
CMP EAX,0xf3
MOV EAX,0x1
CMOVC R13D,EAX
TEST RBX,RBX
JZ 0x0016036d
MOV R14D,R15D
SUB R14D,EBX
MOV R12,qword ptr [RBP + -0x60]
SUB R14D,R12D
MOV ESI,R12D
ADD RSI,RBX
MOV RDI,RBX
MOV RDX,R14
CALL 0x0012a150
MOV RAX,R12
ADD RBX,R14
MOV R14,qword ptr [RBP + -0x78]
MOV R12,qword ptr [RBP + -0x80]
JMP 0x00160374
LAB_00160365:
MOV AL,0x1
MOV qword ptr [RBP + -0x68],RAX
JMP 0x0016037b
LAB_0016036d:
MOV RBX,R15
MOV RAX,qword ptr [RBP + -0x60]
LAB_00160374:
ADD EAX,R13D
MOV qword ptr [RBP + -0x60],RAX
LAB_0016037b:
MOV EAX,R13D
ADD R15,RAX
MOV R13,qword ptr [RBP + -0x88]
LAB_00160388:
ADD R15,qword ptr [RBP + -0x90]
CMP R15,R13
JC 0x001602b0
TEST RBX,RBX
JZ 0x00160400
SUB R13D,EBX
MOV RAX,qword ptr [RBP + -0x60]
SUB R13D,EAX
JNZ 0x001603c3
MOV R15D,R13D
JMP 0x001603d6
LAB_001603ae:
MOV RDI,qword ptr [RBP + -0x70]
MOV ESI,0x7e
CALL 0x0015cab0
MOV CL,0x1
JMP 0x001604cf
LAB_001603c3:
MOV ESI,EAX
ADD RSI,RBX
MOV R15D,R13D
MOV RDI,RBX
MOV RDX,R15
CALL 0x0012a150
LAB_001603d6:
ADD RBX,R15
MOV RAX,qword ptr [R14 + 0x10]
SUB RBX,RAX
MOV dword ptr [R14 + 0x20],EBX
MOV RDX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RDX + 0x744]
MOV byte ptr [RAX + RCX*0x1 + -0x1],BL
MOV RAX,qword ptr [R14 + 0x10]
MOV ECX,dword ptr [RDX + 0x744]
MOV byte ptr [RAX + RCX*0x1 + -0x2],BH
LAB_00160400:
CMP byte ptr [RBP + -0x68],0x0
JNZ 0x00160436
MOV EAX,dword ptr [R14 + 0x2c]
AND EAX,0xfffffffd
MOV dword ptr [R14 + 0x2c],EAX
MOV RCX,qword ptr [R14 + 0x10]
MOV RDX,qword ptr [RBP + -0x58]
MOV EDX,dword ptr [RDX + 0x744]
ADD EDX,-0x3
MOV byte ptr [RCX + RDX*0x1],AL
MOV RAX,qword ptr [R14 + 0x10]
MOV word ptr [RAX + 0xb],0x0
MOV dword ptr [RAX + 0x7],0x0
LAB_00160436:
MOV RAX,qword ptr [RBP + -0x58]
CMP byte ptr [RAX + 0x7e7],0x0
JZ 0x001604cd
MOV RCX,qword ptr [R14]
MOV RAX,qword ptr [R14 + 0x18]
MOV RDX,qword ptr [RCX]
MOV ESI,dword ptr [RDX + 0x7bc]
XOR EDX,EDX
DIV RSI
LEA R10,[RBP + -0x50]
MOV dword ptr [R10 + 0x2],EAX
SHR RAX,0x20
MOV byte ptr [R10 + 0x6],AL
MOV byte ptr [R10 + 0x7],0xb
MOV dword ptr [R10 + 0x8],R12D
SHR R12,0x20
MOV word ptr [R10 + 0xc],R12W
LEA RAX,[RBP + -0xf0]
MOV qword ptr [RAX + 0x20],R10
MOV qword ptr [RAX + 0x28],0xe
MOV EDX,dword ptr [R14 + 0x20]
MOV dword ptr [R14 + 0x24],EDX
MOV RDX,qword ptr [RCX + 0x8]
SUB RSP,0x8
LEA RDI,[RBP + -0x98]
MOV ESI,0xc
MOV R8D,0xe
MOV R9D,0x3
PUSH 0x0
PUSH R10
PUSH RAX
CALL 0x0012b425
ADD RSP,0x20
MOV CL,0x1
TEST AL,AL
JNZ 0x001604cf
LAB_001604cd:
XOR ECX,ECX
LAB_001604cf:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001604f2
MOV EAX,ECX
ADD RSP,0xc8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001604f2:
CALL 0x0012a280
|
ulong _ma_compact_keypage(long *param_1,ulong param_2)
{
long lVar1;
int1 auVar2 [16];
byte bVar3;
char cVar4;
byte *pbVar5;
ulong uVar6;
long *plVar7;
byte *pbVar8;
int iVar9;
uint uVar10;
byte *pbVar11;
byte *pbVar12;
long in_FS_OFFSET;
int1 local_f8 [32];
int1 *local_d8;
int8 local_d0;
int1 *local_c0;
long local_b8;
int1 local_a0 [8];
ulong local_98;
byte *local_90;
ulong local_88;
long *local_80;
long *local_78;
int8 local_70;
ulong local_68;
long local_60;
int1 local_58 [2];
int4 local_56;
int1 local_52;
int1 local_51;
int4 local_50;
int2 local_4c;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar6 = 0;
if ((*(byte *)((long)param_1 + 0x2c) & 2) != 0) {
local_68 = 0;
local_78 = (long *)*param_1;
local_60 = *local_78;
local_98 = (ulong)*(uint *)(param_1 + 5);
pbVar11 = (byte *)((ulong)*(uint *)(param_1 + 4) + param_1[2]);
local_c0 = (int1 *)local_78[0x71];
local_b8 = param_1[1];
pbVar12 = (byte *)((ulong)(*(int *)(local_60 + 0x744) + *(uint *)(param_1 + 5)) + param_1[2]);
*local_c0 = 0;
local_70 = 0;
pbVar8 = (byte *)0x0;
local_90 = pbVar11;
local_88 = param_2;
local_80 = param_1;
do {
pbVar5 = (byte *)(**(code **)(param_1[1] + 0xe8))(&local_c0,0,0,pbVar12);
if (pbVar5 == (byte *)0x0) {
_ma_set_fatal_error(local_78,0x7e);
uVar6 = CONCAT71((int7)((ulong)pbVar12 >> 8),1);
goto LAB_001604cf;
}
bVar3 = pbVar5[-1];
if ((bVar3 & 1) != 0) {
if (param_2 == 0xffffffffffffffff) {
LAB_00160313:
pbVar5[-1] = bVar3 & 0xfe;
uVar10 = *pbVar5 - 0xf8;
if (*pbVar5 < 0xf3) {
uVar10 = 1;
}
iVar9 = (int)local_68;
pbVar11 = pbVar5;
if (pbVar8 != (byte *)0x0) {
uVar6 = (ulong)(uint)(((int)pbVar5 - (int)pbVar8) - iVar9);
memmove(pbVar8,pbVar8 + (local_68 & 0xffffffff),uVar6);
pbVar11 = pbVar8 + uVar6;
param_2 = local_88;
param_1 = local_80;
}
local_68 = (ulong)(iVar9 + uVar10);
pbVar8 = pbVar11;
}
else {
uVar10 = *pbVar5 - 0xf8;
if (*pbVar5 < 0xf3) {
uVar10 = 1;
}
uVar6 = transid_get_packed(local_60);
if (param_2 < uVar6) {
bVar3 = pbVar5[-1];
goto LAB_00160313;
}
local_70 = CONCAT71((int7)(uVar6 >> 8),1);
}
pbVar5 = pbVar5 + uVar10;
pbVar11 = local_90;
}
pbVar12 = pbVar5 + local_98;
} while (pbVar12 < pbVar11);
if (pbVar8 != (byte *)0x0) {
uVar10 = ((int)pbVar11 - (int)pbVar8) - (int)local_68;
if (uVar10 != 0) {
memmove(pbVar8,pbVar8 + (local_68 & 0xffffffff),(ulong)uVar10);
}
pbVar8 = pbVar8 + ((ulong)uVar10 - param_1[2]);
*(int *)(param_1 + 4) = (int)pbVar8;
*(char *)(param_1[2] + -1 + (ulong)*(uint *)(local_60 + 0x744)) = (char)pbVar8;
*(char *)(param_1[2] + -2 + (ulong)*(uint *)(local_60 + 0x744)) = (char)((ulong)pbVar8 >> 8);
}
if ((char)local_70 == '\0') {
uVar10 = *(uint *)((long)param_1 + 0x2c) & 0xfffffffd;
*(uint *)((long)param_1 + 0x2c) = uVar10;
*(char *)(param_1[2] + (ulong)(*(int *)(local_60 + 0x744) - 3)) = (char)uVar10;
lVar1 = param_1[2];
*(int2 *)(lVar1 + 0xb) = 0;
*(int4 *)(lVar1 + 7) = 0;
}
if (*(char *)(local_60 + 0x7e7) != '\0') {
plVar7 = (long *)*param_1;
auVar2._8_8_ = 0;
auVar2._0_8_ = param_1[3];
auVar2 = auVar2 / ZEXT416(*(uint *)(*plVar7 + 0x7bc));
local_d8 = local_58;
local_56 = auVar2._0_4_;
local_52 = auVar2[4];
local_51 = 0xb;
local_50 = (int4)param_2;
local_4c = (int2)(param_2 >> 0x20);
local_d0 = 0xe;
*(int *)((long)param_1 + 0x24) = (int)param_1[4];
cVar4 = translog_write_record(local_a0,0xc,plVar7[1],plVar7,0xe,3,local_f8,local_d8,0);
uVar6 = CONCAT71((int7)((ulong)plVar7 >> 8),1);
if (cVar4 != '\0') goto LAB_001604cf;
}
uVar6 = 0;
}
LAB_001604cf:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar6 & 0xffffffff;
}
|
|
19,893
|
Catch::Detail::getEnv(char const*)
|
AlayaLite/build_O3/_deps/libcoro-src/test/catch_amalgamated.cpp
|
char const* getEnv( char const* varName ) {
# if defined( _MSC_VER )
# pragma warning( push )
# pragma warning( disable : 4996 ) // use getenv_s instead of getenv
# endif
return std::getenv( varName );
# if defined( _MSC_VER )
# pragma warning( pop )
# endif
}
|
O3
|
cpp
|
Catch::Detail::getEnv(char const*):
jmp 0x17890
|
_ZN5Catch6Detail6getEnvEPKc:
jmp _getenv
|
// attributes: thunk
long long Catch::Detail::getEnv(Catch::Detail *this, const char *a2)
{
return getenv(this);
}
|
getEnv:
JMP 0x00117890
|
/* Catch::Detail::getEnv(char const*) */
void Catch::Detail::getEnv(char *param_1)
{
(*(code *)PTR_getenv_00232448)();
return;
}
|
|
19,894
|
minja::strip(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
monkey531[P]llama/common/minja.hpp
|
static std::string strip(const std::string & s) {
auto start = s.find_first_not_of(" \t\n\r");
if (start == std::string::npos) return "";
auto end = s.find_last_not_of(" \t\n\r");
return s.substr(start, end - start + 1);
}
|
O0
|
cpp
|
minja::strip(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x11b74a(%rip), %rsi # 0x213521
xorl %eax, %eax
movl %eax, %edx
callq 0x59f30
movq %rax, 0x40(%rsp)
cmpq $-0x1, 0x40(%rsp)
jne 0xf7e3a
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5a080
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x110695(%rip), %rsi # 0x2084a2
callq 0x62ae0
jmp 0xf7e14
leaq 0x3f(%rsp), %rdi
callq 0x5a4b0
jmp 0xf7e79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x5a4b0
jmp 0xf7e83
movq 0x48(%rsp), %rdi
leaq 0x11b6db(%rip), %rsi # 0x213521
movq $-0x1, %rdx
callq 0x59ec0
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x20(%rsp), %rcx
subq 0x40(%rsp), %rcx
addq $0x1, %rcx
callq 0x5a0d0
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x59b90
nopl (%rax)
|
_ZN5minjaL5stripERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
sub rsp, 58h
mov [rsp+58h+var_48], rdi
mov rax, rdi
mov [rsp+58h+var_40], rax
mov [rsp+58h+var_8], rdi
mov [rsp+58h+var_10], rsi
mov rdi, [rsp+58h+var_10]
lea rsi, asc_213521; " \t\n\r"
xor eax, eax
mov edx, eax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE17find_first_not_ofEPKcm; std::string::find_first_not_of(char const*,ulong)
mov [rsp+58h+var_18], rax
cmp [rsp+58h+var_18], 0FFFFFFFFFFFFFFFFh
jnz short loc_F7E3A
lea rdi, [rsp+58h+var_19]
mov [rsp+58h+var_50], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdi, [rsp+58h+var_48]
mov rdx, [rsp+58h+var_50]
lea rsi, aTestArgParserT_1+46h; ""
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_F7E14:
lea rdi, [rsp+58h+var_19]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_F7E79
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
lea rdi, [rsp+arg_37]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_F7E83
loc_F7E3A:
mov rdi, [rsp+58h+var_10]
lea rsi, asc_213521; " \t\n\r"
mov rdx, 0FFFFFFFFFFFFFFFFh
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE16find_last_not_ofEPKcm; std::string::find_last_not_of(char const*,ulong)
mov rdi, [rsp+58h+var_48]
mov [rsp+58h+var_38], rax
mov rsi, [rsp+58h+var_10]
mov rdx, [rsp+58h+var_18]
mov rcx, [rsp+58h+var_38]
sub rcx, [rsp+58h+var_18]
add rcx, 1
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
loc_F7E79:
mov rax, [rsp+58h+var_40]
add rsp, 58h
retn
loc_F7E83:
mov rdi, [rsp+arg_28]
call __Unwind_Resume
|
long long minja::strip(long long a1, long long a2)
{
long long last_not_of; // [rsp+20h] [rbp-38h]
char v4; // [rsp+3Fh] [rbp-19h] BYREF
long long first_not_of; // [rsp+40h] [rbp-18h]
long long v6; // [rsp+48h] [rbp-10h]
long long v7; // [rsp+50h] [rbp-8h]
v7 = a1;
v6 = a2;
first_not_of = std::string::find_first_not_of(a2, " \t\n\r", 0LL);
if ( first_not_of == -1 )
{
std::allocator<char>::allocator(&v4, " \t\n\r");
std::string::basic_string<std::allocator<char>>(a1, (long long)"", (long long)&v4);
std::allocator<char>::~allocator(&v4);
}
else
{
last_not_of = std::string::find_last_not_of(v6, " \t\n\r", -1LL);
std::string::substr(a1, v6, first_not_of, last_not_of - first_not_of + 1);
}
return a1;
}
|
strip:
SUB RSP,0x58
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x50],RDI
MOV qword ptr [RSP + 0x48],RSI
MOV RDI,qword ptr [RSP + 0x48]
LEA RSI,[0x313521]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x00159f30
MOV qword ptr [RSP + 0x40],RAX
CMP qword ptr [RSP + 0x40],-0x1
JNZ 0x001f7e3a
LEA RDI,[RSP + 0x3f]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x0015a080
MOV RDI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x8]
LAB_001f7e06:
LEA RSI,[0x3084a2]
CALL 0x00162ae0
LAB_001f7e12:
JMP 0x001f7e14
LAB_001f7e14:
LEA RDI,[RSP + 0x3f]
CALL 0x0015a4b0
JMP 0x001f7e79
LAB_001f7e3a:
MOV RDI,qword ptr [RSP + 0x48]
LEA RSI,[0x313521]
MOV RDX,-0x1
CALL 0x00159ec0
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x20],RAX
MOV RSI,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x40]
MOV RCX,qword ptr [RSP + 0x20]
SUB RCX,qword ptr [RSP + 0x40]
ADD RCX,0x1
CALL 0x0015a0d0
LAB_001f7e79:
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0x58
RET
|
/* minja::strip(std::__cxx11::string const&) */
minja * __thiscall minja::strip(minja *this,string *param_1)
{
allocator local_19;
long local_18;
string *local_10;
minja *local_8;
local_10 = param_1;
local_8 = this;
local_18 = std::__cxx11::string::find_first_not_of((char *)param_1,0x313521);
if (local_18 == -1) {
std::allocator<char>::allocator();
/* try { // try from 001f7e06 to 001f7e11 has its CatchHandler @ 001f7e20 */
std::__cxx11::string::string<std::allocator<char>>((string *)this,"",&local_19);
std::allocator<char>::~allocator((allocator<char> *)&local_19);
}
else {
std::__cxx11::string::find_last_not_of((char *)local_10,0x313521);
std::__cxx11::string::substr((ulong)this,(ulong)local_10);
}
return this;
}
|
|
19,895
|
heap_rkey
|
eloqsql/storage/heap/hp_rkey.c
|
int heap_rkey(HP_INFO *info, uchar *record, int inx, const uchar *key,
key_part_map keypart_map, enum ha_rkey_function find_flag)
{
uchar *pos;
HP_SHARE *share= info->s;
HP_KEYDEF *keyinfo= share->keydef + inx;
DBUG_ENTER("heap_rkey");
DBUG_PRINT("enter",("info: %p inx: %d", info, inx));
if ((uint) inx >= share->keys)
{
DBUG_RETURN(my_errno= HA_ERR_WRONG_INDEX);
}
info->lastinx= inx;
info->current_record= (ulong) ~0L; /* For heap_rrnd() */
info->key_version= info->s->key_version;
if (keyinfo->algorithm == HA_KEY_ALG_BTREE)
{
heap_rb_param custom_arg;
custom_arg.keyseg= info->s->keydef[inx].seg;
custom_arg.key_length= info->lastkey_len=
hp_rb_pack_key(keyinfo, (uchar*) info->lastkey,
(uchar*) key, keypart_map);
custom_arg.search_flag= SEARCH_FIND | SEARCH_SAME;
/* for next rkey() after deletion */
if (find_flag == HA_READ_AFTER_KEY)
info->last_find_flag= HA_READ_KEY_OR_NEXT;
else if (find_flag == HA_READ_BEFORE_KEY)
info->last_find_flag= HA_READ_KEY_OR_PREV;
else
info->last_find_flag= find_flag;
if (!(pos= tree_search_key(&keyinfo->rb_tree, info->lastkey, info->parents,
&info->last_pos, find_flag, &custom_arg)))
{
info->update= HA_STATE_NO_KEY;
DBUG_RETURN(my_errno= HA_ERR_KEY_NOT_FOUND);
}
memcpy(&pos, pos + (*keyinfo->get_key_length)(keyinfo, pos), sizeof(uchar*));
info->current_ptr= pos;
}
else
{
if (!(pos= hp_search(info, share->keydef + inx, key, 0)))
{
info->update= HA_STATE_NO_KEY;
DBUG_RETURN(my_errno);
}
if ((keyinfo->flag & (HA_NOSAME | HA_NULL_PART_KEY)) != HA_NOSAME)
memcpy(info->lastkey, key, (size_t) keyinfo->length);
}
memcpy(record, pos, (size_t) share->reclength);
info->update= HA_STATE_AKTIV;
DBUG_RETURN(0);
}
|
O0
|
c
|
heap_rkey:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x98(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x368, %rcx, %rcx # imm = 0x368
addq %rcx, %rax
movq %rax, -0x50(%rbp)
jmp 0x2bc59
movl -0x1c(%rbp), %eax
movq -0x48(%rbp), %rcx
cmpl 0x100(%rcx), %eax
jb 0x2bc81
jmp 0x2bc6a
callq 0x31370
movl $0x7c, (%rax)
movl $0x7c, -0x4(%rbp)
jmp 0x2be7a
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $-0x1, 0x18(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0xec(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x268(%rax)
movq -0x50(%rbp), %rax
movzbl 0xc(%rax), %eax
cmpl $0x1, %eax
jne 0x2bddc
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x98(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x368, %rcx, %rcx # imm = 0x368
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x29000
movq -0x10(%rbp), %rcx
movl %eax, 0x270(%rcx)
movl %eax, -0x58(%rbp)
movl $0x5, -0x54(%rbp)
cmpl $0x3, -0x34(%rbp)
jne 0x2bd23
movq -0x10(%rbp), %rax
movl $0x1, 0x50(%rax)
jmp 0x2bd42
cmpl $0x4, -0x34(%rbp)
jne 0x2bd36
movq -0x10(%rbp), %rax
movl $0x2, 0x50(%rax)
jmp 0x2bd40
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x50(%rax)
jmp 0x2bd42
movq -0x50(%rbp), %rdi
addq $0xb8, %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
movq -0x10(%rbp), %rdx
addq $0x58, %rdx
movq -0x10(%rbp), %rcx
addq $0x260, %rcx # imm = 0x260
movl -0x34(%rbp), %r8d
leaq -0x60(%rbp), %r9
callq 0x35e70
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x2bda1
movq -0x10(%rbp), %rax
movl $0x40, 0x38(%rax)
callq 0x31370
movl $0x78, (%rax)
movl $0x78, -0x4(%rbp)
jmp 0x2be7a
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rax
movq 0x360(%rax), %rax
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq *%rax
movl %eax, %ecx
movq -0x68(%rbp), %rax
movl %ecx, %ecx
movq (%rax,%rcx), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x2be4f
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rax
movq 0x98(%rax), %rsi
movslq -0x1c(%rbp), %rax
imulq $0x368, %rax, %rax # imm = 0x368
addq %rax, %rsi
movq -0x28(%rbp), %rdx
xorl %ecx, %ecx
callq 0x29380
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x2be25
movq -0x10(%rbp), %rax
movl $0x40, 0x38(%rax)
callq 0x31370
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x2be7a
movq -0x50(%rbp), %rax
movl (%rax), %eax
andl $0x41, %eax
cmpl $0x1, %eax
je 0x2be4d
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x50(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %edx
callq 0x24200
jmp 0x2be4f
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rax
movl 0xf4(%rax), %eax
movl %eax, %edx
callq 0x24200
movq -0x10(%rbp), %rax
movl $0x2, 0x38(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
heap_rkey:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_34], r9d
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_48], rax
mov rax, [rbp+var_48]
mov rax, [rax+98h]
movsxd rcx, [rbp+var_1C]
imul rcx, 368h
add rax, rcx
mov [rbp+var_50], rax
jmp short $+2
loc_2BC59:
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_48]
cmp eax, [rcx+100h]
jb short loc_2BC81
jmp short $+2
loc_2BC6A:
call _my_thread_var
mov dword ptr [rax], 7Ch ; '|'
mov [rbp+var_4], 7Ch ; '|'
jmp loc_2BE7A
loc_2BC81:
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_10]
mov [rax+28h], ecx
mov rax, [rbp+var_10]
mov qword ptr [rax+18h], 0FFFFFFFFFFFFFFFFh
mov rax, [rbp+var_10]
mov rax, [rax]
mov ecx, [rax+0ECh]
mov rax, [rbp+var_10]
mov [rax+268h], ecx
mov rax, [rbp+var_50]
movzx eax, byte ptr [rax+0Ch]
cmp eax, 1
jnz loc_2BDDC
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+98h]
movsxd rcx, [rbp+var_1C]
imul rcx, 368h
add rax, rcx
mov rax, [rax+10h]
mov [rbp+var_60], rax
mov rdi, [rbp+var_50]
mov rax, [rbp+var_10]
mov rsi, [rax+40h]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
call hp_rb_pack_key
mov rcx, [rbp+var_10]
mov [rcx+270h], eax
mov [rbp+var_58], eax
mov [rbp+var_54], 5
cmp [rbp+var_34], 3
jnz short loc_2BD23
mov rax, [rbp+var_10]
mov dword ptr [rax+50h], 1
jmp short loc_2BD42
loc_2BD23:
cmp [rbp+var_34], 4
jnz short loc_2BD36
mov rax, [rbp+var_10]
mov dword ptr [rax+50h], 2
jmp short loc_2BD40
loc_2BD36:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_10]
mov [rax+50h], ecx
loc_2BD40:
jmp short $+2
loc_2BD42:
mov rdi, [rbp+var_50]
add rdi, 0B8h
mov rax, [rbp+var_10]
mov rsi, [rax+40h]
mov rdx, [rbp+var_10]
add rdx, 58h ; 'X'
mov rcx, [rbp+var_10]
add rcx, 260h
mov r8d, [rbp+var_34]
lea r9, [rbp+var_60]
call tree_search_key
mov [rbp+var_40], rax
cmp rax, 0
jnz short loc_2BDA1
mov rax, [rbp+var_10]
mov dword ptr [rax+38h], 40h ; '@'
call _my_thread_var
mov dword ptr [rax], 78h ; 'x'
mov [rbp+var_4], 78h ; 'x'
jmp loc_2BE7A
loc_2BDA1:
mov rax, [rbp+var_40]
mov [rbp+var_68], rax
mov rax, [rbp+var_50]
mov rax, [rax+360h]
mov rdi, [rbp+var_50]
mov rsi, [rbp+var_40]
call rax
mov ecx, eax
mov rax, [rbp+var_68]
mov ecx, ecx
mov rax, [rax+rcx]
mov [rbp+var_40], rax
mov rcx, [rbp+var_40]
mov rax, [rbp+var_10]
mov [rax+8], rcx
jmp short loc_2BE4F
loc_2BDDC:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_48]
mov rsi, [rax+98h]
movsxd rax, [rbp+var_1C]
imul rax, 368h
add rsi, rax
mov rdx, [rbp+var_28]
xor ecx, ecx
call hp_search
mov [rbp+var_40], rax
cmp rax, 0
jnz short loc_2BE25
mov rax, [rbp+var_10]
mov dword ptr [rax+38h], 40h ; '@'
call _my_thread_var
mov eax, [rax]
mov [rbp+var_4], eax
jmp short loc_2BE7A
loc_2BE25:
mov rax, [rbp+var_50]
mov eax, [rax]
and eax, 41h
cmp eax, 1
jz short loc_2BE4D
mov rax, [rbp+var_10]
mov rdi, [rax+40h]
mov rsi, [rbp+var_28]
mov rax, [rbp+var_50]
mov eax, [rax+8]
mov edx, eax
call _memcpy
loc_2BE4D:
jmp short $+2
loc_2BE4F:
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_40]
mov rax, [rbp+var_48]
mov eax, [rax+0F4h]
mov edx, eax
call _memcpy
mov rax, [rbp+var_10]
mov dword ptr [rax+38h], 2
mov [rbp+var_4], 0
loc_2BE7A:
mov eax, [rbp+var_4]
add rsp, 70h
pop rbp
retn
|
long long heap_rkey(
_QWORD *a1,
long long a2,
unsigned int a3,
unsigned __int16 *a4,
unsigned long long a5,
unsigned int a6)
{
unsigned int v6; // eax
long long v8; // [rsp+8h] [rbp-68h]
long long v9; // [rsp+10h] [rbp-60h] BYREF
unsigned int v10; // [rsp+18h] [rbp-58h]
int v11; // [rsp+1Ch] [rbp-54h]
long long v12; // [rsp+20h] [rbp-50h]
long long v13; // [rsp+28h] [rbp-48h]
long long v14; // [rsp+30h] [rbp-40h]
unsigned int v15; // [rsp+3Ch] [rbp-34h]
unsigned long long v16; // [rsp+40h] [rbp-30h]
unsigned __int16 *v17; // [rsp+48h] [rbp-28h]
unsigned int v18; // [rsp+54h] [rbp-1Ch]
long long v19; // [rsp+58h] [rbp-18h]
_QWORD *v20; // [rsp+60h] [rbp-10h]
v20 = a1;
v19 = a2;
v18 = a3;
v17 = a4;
v16 = a5;
v15 = a6;
v13 = *a1;
v12 = 872LL * (int)a3 + *(_QWORD *)(v13 + 152);
if ( a3 < *(_DWORD *)(v13 + 256) )
{
*((_DWORD *)v20 + 10) = v18;
v20[3] = -1LL;
*((_DWORD *)v20 + 154) = *(_DWORD *)(*v20 + 236LL);
if ( *(_BYTE *)(v12 + 12) == 1 )
{
v9 = *(_QWORD *)(872LL * (int)v18 + *(_QWORD *)(*v20 + 152LL) + 16);
v6 = (unsigned int)hp_rb_pack_key(v12, (_BYTE *)v20[8], v17, v16);
*((_DWORD *)v20 + 156) = v6;
v10 = v6;
v11 = 5;
if ( v15 == 3 )
{
*((_DWORD *)v20 + 20) = 1;
}
else if ( v15 == 4 )
{
*((_DWORD *)v20 + 20) = 2;
}
else
{
*((_DWORD *)v20 + 20) = v15;
}
v14 = tree_search_key(v12 + 184, v20[8], v20 + 11, v20 + 76, v15, &v9);
if ( !v14 )
{
*((_DWORD *)v20 + 14) = 64;
*(_DWORD *)my_thread_var() = 120;
return 120;
}
v8 = v14;
v14 = *(_QWORD *)(v8 + (*(unsigned int ( **)(long long, long long))(v12 + 864))(v12, v14));
v20[1] = v14;
}
else
{
v14 = hp_search(v20, 872LL * (int)v18 + *(_QWORD *)(v13 + 152), (long long)v17, 0);
if ( !v14 )
{
*((_DWORD *)v20 + 14) = 64;
return *(unsigned int *)my_thread_var();
}
if ( (*(_DWORD *)v12 & 0x41) != 1 )
memcpy(v20[8], v17, *(unsigned int *)(v12 + 8));
}
memcpy(v19, v14, *(unsigned int *)(v13 + 244));
*((_DWORD *)v20 + 14) = 2;
return 0;
}
*(_DWORD *)my_thread_var() = 124;
return 124;
}
|
heap_rkey:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV dword ptr [RBP + -0x34],R9D
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX + 0x98]
MOVSXD RCX,dword ptr [RBP + -0x1c]
IMUL RCX,RCX,0x368
ADD RAX,RCX
MOV qword ptr [RBP + -0x50],RAX
JMP 0x0012bc59
LAB_0012bc59:
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x48]
CMP EAX,dword ptr [RCX + 0x100]
JC 0x0012bc81
JMP 0x0012bc6a
LAB_0012bc6a:
CALL 0x00131370
MOV dword ptr [RAX],0x7c
MOV dword ptr [RBP + -0x4],0x7c
JMP 0x0012be7a
LAB_0012bc81:
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x28],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],-0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RAX + 0xec]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x268],ECX
MOV RAX,qword ptr [RBP + -0x50]
MOVZX EAX,byte ptr [RAX + 0xc]
CMP EAX,0x1
JNZ 0x0012bddc
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x98]
MOVSXD RCX,dword ptr [RBP + -0x1c]
IMUL RCX,RCX,0x368
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x60],RAX
MOV RDI,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x40]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x00129000
MOV RCX,qword ptr [RBP + -0x10]
MOV dword ptr [RCX + 0x270],EAX
MOV dword ptr [RBP + -0x58],EAX
MOV dword ptr [RBP + -0x54],0x5
CMP dword ptr [RBP + -0x34],0x3
JNZ 0x0012bd23
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x50],0x1
JMP 0x0012bd42
LAB_0012bd23:
CMP dword ptr [RBP + -0x34],0x4
JNZ 0x0012bd36
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x50],0x2
JMP 0x0012bd40
LAB_0012bd36:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x50],ECX
LAB_0012bd40:
JMP 0x0012bd42
LAB_0012bd42:
MOV RDI,qword ptr [RBP + -0x50]
ADD RDI,0xb8
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x40]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,0x58
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,0x260
MOV R8D,dword ptr [RBP + -0x34]
LEA R9,[RBP + -0x60]
CALL 0x00135e70
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,0x0
JNZ 0x0012bda1
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x38],0x40
CALL 0x00131370
MOV dword ptr [RAX],0x78
MOV dword ptr [RBP + -0x4],0x78
JMP 0x0012be7a
LAB_0012bda1:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RAX + 0x360]
MOV RDI,qword ptr [RBP + -0x50]
MOV RSI,qword ptr [RBP + -0x40]
CALL RAX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x68]
MOV ECX,ECX
MOV RAX,qword ptr [RAX + RCX*0x1]
MOV qword ptr [RBP + -0x40],RAX
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x0012be4f
LAB_0012bddc:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RAX + 0x98]
MOVSXD RAX,dword ptr [RBP + -0x1c]
IMUL RAX,RAX,0x368
ADD RSI,RAX
MOV RDX,qword ptr [RBP + -0x28]
XOR ECX,ECX
CALL 0x00129380
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,0x0
JNZ 0x0012be25
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x38],0x40
CALL 0x00131370
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0012be7a
LAB_0012be25:
MOV RAX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RAX]
AND EAX,0x41
CMP EAX,0x1
JZ 0x0012be4d
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RAX + 0x8]
MOV EDX,EAX
CALL 0x00124200
LAB_0012be4d:
JMP 0x0012be4f
LAB_0012be4f:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX + 0xf4]
MOV EDX,EAX
CALL 0x00124200
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x38],0x2
MOV dword ptr [RBP + -0x4],0x0
LAB_0012be7a:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x70
POP RBP
RET
|
int4
heap_rkey(long *param_1,void *param_2,uint param_3,void *param_4,int8 param_5,int param_6)
{
uint uVar1;
int4 *puVar2;
long lVar3;
int8 local_68;
int4 local_60;
int4 local_5c;
uint *local_58;
long local_50;
void *local_48;
int local_3c;
int8 local_38;
void *local_30;
uint local_24;
void *local_20;
long *local_18;
int4 local_c;
local_50 = *param_1;
local_58 = (uint *)(*(long *)(local_50 + 0x98) + (long)(int)param_3 * 0x368);
local_3c = param_6;
local_38 = param_5;
local_30 = param_4;
local_24 = param_3;
local_20 = param_2;
local_18 = param_1;
if (param_3 < *(uint *)(local_50 + 0x100)) {
*(uint *)(param_1 + 5) = param_3;
param_1[3] = -1;
*(int4 *)(param_1 + 0x4d) = *(int4 *)(*param_1 + 0xec);
if ((char)local_58[3] == '\x01') {
local_68 = *(int8 *)(*(long *)(*param_1 + 0x98) + (long)(int)param_3 * 0x368 + 0x10);
local_60 = hp_rb_pack_key(local_58,param_1[8],param_4,param_5);
*(int4 *)(local_18 + 0x4e) = local_60;
local_5c = 5;
if (local_3c == 3) {
*(int4 *)(local_18 + 10) = 1;
}
else if (local_3c == 4) {
*(int4 *)(local_18 + 10) = 2;
}
else {
*(int *)(local_18 + 10) = local_3c;
}
lVar3 = tree_search_key(local_58 + 0x2e,local_18[8],local_18 + 0xb,local_18 + 0x4c,local_3c,
&local_68);
local_48 = (void *)lVar3;
if (lVar3 == 0) {
*(int4 *)(local_18 + 7) = 0x40;
puVar2 = (int4 *)_my_thread_var();
*puVar2 = 0x78;
return 0x78;
}
uVar1 = (**(code **)(local_58 + 0xd8))(local_58,lVar3);
local_48 = *(void **)(lVar3 + (ulong)uVar1);
local_18[1] = (long)local_48;
}
else {
local_48 = (void *)hp_search(param_1,*(long *)(local_50 + 0x98) + (long)(int)param_3 * 0x368,
param_4,0);
if (local_48 == (void *)0x0) {
*(int4 *)(local_18 + 7) = 0x40;
puVar2 = (int4 *)_my_thread_var();
return *puVar2;
}
if ((*local_58 & 0x41) != 1) {
memcpy((void *)local_18[8],local_30,(ulong)local_58[2]);
}
}
memcpy(local_20,local_48,(ulong)*(uint *)(local_50 + 0xf4));
*(int4 *)(local_18 + 7) = 2;
local_c = 0;
}
else {
puVar2 = (int4 *)_my_thread_var();
*puVar2 = 0x7c;
local_c = 0x7c;
}
return local_c;
}
|
|
19,896
|
rw_pr_rdlock
|
eloqsql/mysys/thr_rwlock.c
|
int rw_pr_rdlock(rw_pr_lock_t *rwlock)
{
pthread_mutex_lock(&rwlock->lock);
/*
The fact that we were able to acquire 'lock' mutex means
that there are no active writers and we can acquire rd-lock.
Increment active readers counter to prevent requests for
wr-lock from succeeding and unlock mutex.
*/
rwlock->active_readers++;
pthread_mutex_unlock(&rwlock->lock);
return 0;
}
|
O3
|
c
|
rw_pr_rdlock:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x264d0
incl 0x58(%rbx)
movq %rbx, %rdi
callq 0x26250
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
rw_pr_rdlock:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
call _pthread_mutex_lock
inc dword ptr [rbx+58h]
mov rdi, rbx
call _pthread_mutex_unlock
xor eax, eax
add rsp, 8
pop rbx
pop rbp
retn
|
long long rw_pr_rdlock(long long a1)
{
pthread_mutex_lock(a1);
++*(_DWORD *)(a1 + 88);
pthread_mutex_unlock(a1);
return 0LL;
}
|
rw_pr_rdlock:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x001264d0
INC dword ptr [RBX + 0x58]
MOV RDI,RBX
CALL 0x00126250
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int8 rw_pr_rdlock(pthread_mutex_t *param_1)
{
pthread_mutex_lock(param_1);
*(int *)((long)param_1 + 0x58) = *(int *)((long)param_1 + 0x58) + 1;
pthread_mutex_unlock(param_1);
return 0;
}
|
|
19,897
|
plutovg_canvas_font_metrics
|
dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-canvas.c
|
void plutovg_canvas_font_metrics(const plutovg_canvas_t* canvas, float* ascent, float* descent, float* line_gap, plutovg_rect_t* extents)
{
plutovg_state_t* state = canvas->state;
if(state->font_face && state->font_size > 0.f) {
plutovg_font_face_get_metrics(state->font_face, state->font_size, ascent, descent, line_gap, extents);
return;
}
if(ascent) *ascent = 0.f;
if(descent) *descent = 0.f;
if(line_gap) *line_gap = 0.f;
if(extents) {
extents->x = 0.f;
extents->y = 0.f;
extents->w = 0.f;
extents->h = 0.f;
}
}
|
O0
|
c
|
plutovg_canvas_font_metrics:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x56652
movq -0x30(%rbp), %rax
movss 0x88(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x56652
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x30(%rbp), %rax
movss 0x88(%rax), %xmm0
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x571e0
jmp 0x566be
cmpq $0x0, -0x10(%rbp)
je 0x56664
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x56676
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x56688
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x566be
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rax)
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rax)
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
plutovg_canvas_font_metrics:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_8]
mov rax, [rax+18h]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
cmp qword ptr [rax+8], 0
jz short loc_56652
mov rax, [rbp+var_30]
movss xmm0, dword ptr [rax+88h]
xorps xmm1, xmm1
ucomiss xmm0, xmm1
jbe short loc_56652
mov rax, [rbp+var_30]
mov rdi, [rax+8]
mov rax, [rbp+var_30]
movss xmm0, dword ptr [rax+88h]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
mov r8, [rbp+var_28]
call plutovg_font_face_get_metrics
jmp short loc_566BE
loc_56652:
cmp [rbp+var_10], 0
jz short loc_56664
mov rax, [rbp+var_10]
xorps xmm0, xmm0
movss dword ptr [rax], xmm0
loc_56664:
cmp [rbp+var_18], 0
jz short loc_56676
mov rax, [rbp+var_18]
xorps xmm0, xmm0
movss dword ptr [rax], xmm0
loc_56676:
cmp [rbp+var_20], 0
jz short loc_56688
mov rax, [rbp+var_20]
xorps xmm0, xmm0
movss dword ptr [rax], xmm0
loc_56688:
cmp [rbp+var_28], 0
jz short loc_566BE
mov rax, [rbp+var_28]
xorps xmm0, xmm0
movss dword ptr [rax], xmm0
mov rax, [rbp+var_28]
xorps xmm0, xmm0
movss dword ptr [rax+4], xmm0
mov rax, [rbp+var_28]
xorps xmm0, xmm0
movss dword ptr [rax+8], xmm0
mov rax, [rbp+var_28]
xorps xmm0, xmm0
movss dword ptr [rax+0Ch], xmm0
loc_566BE:
add rsp, 30h
pop rbp
retn
|
long long plutovg_canvas_font_metrics(long long a1, _DWORD *a2, _DWORD *a3, _DWORD *a4, _DWORD *a5)
{
long long result; // rax
long long v6; // [rsp+0h] [rbp-30h]
v6 = *(_QWORD *)(a1 + 24);
result = v6;
if ( *(_QWORD *)(v6 + 8) )
{
result = *(_QWORD *)(a1 + 24);
if ( *(float *)(v6 + 136) > 0.0 )
return plutovg_font_face_get_metrics(*(_QWORD *)(v6 + 8), a2, a3, a4, *(float *)(v6 + 136));
}
if ( a2 )
{
result = (long long)a2;
*a2 = 0;
}
if ( a3 )
{
result = (long long)a3;
*a3 = 0;
}
if ( a4 )
{
result = (long long)a4;
*a4 = 0;
}
if ( a5 )
{
*a5 = 0;
a5[1] = 0;
a5[2] = 0;
result = (long long)a5;
a5[3] = 0;
}
return result;
}
|
plutovg_canvas_font_metrics:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
CMP qword ptr [RAX + 0x8],0x0
JZ 0x00156652
MOV RAX,qword ptr [RBP + -0x30]
MOVSS XMM0,dword ptr [RAX + 0x88]
XORPS XMM1,XMM1
UCOMISS XMM0,XMM1
JBE 0x00156652
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x30]
MOVSS XMM0,dword ptr [RAX + 0x88]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x28]
CALL 0x001571e0
JMP 0x001566be
LAB_00156652:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00156664
MOV RAX,qword ptr [RBP + -0x10]
XORPS XMM0,XMM0
MOVSS dword ptr [RAX],XMM0
LAB_00156664:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00156676
MOV RAX,qword ptr [RBP + -0x18]
XORPS XMM0,XMM0
MOVSS dword ptr [RAX],XMM0
LAB_00156676:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x00156688
MOV RAX,qword ptr [RBP + -0x20]
XORPS XMM0,XMM0
MOVSS dword ptr [RAX],XMM0
LAB_00156688:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x001566be
MOV RAX,qword ptr [RBP + -0x28]
XORPS XMM0,XMM0
MOVSS dword ptr [RAX],XMM0
MOV RAX,qword ptr [RBP + -0x28]
XORPS XMM0,XMM0
MOVSS dword ptr [RAX + 0x4],XMM0
MOV RAX,qword ptr [RBP + -0x28]
XORPS XMM0,XMM0
MOVSS dword ptr [RAX + 0x8],XMM0
MOV RAX,qword ptr [RBP + -0x28]
XORPS XMM0,XMM0
MOVSS dword ptr [RAX + 0xc],XMM0
LAB_001566be:
ADD RSP,0x30
POP RBP
RET
|
void plutovg_canvas_font_metrics
(long param_1,int4 *param_2,int4 *param_3,int4 *param_4,
int4 *param_5)
{
long lVar1;
lVar1 = *(long *)(param_1 + 0x18);
if ((*(long *)(lVar1 + 8) == 0) || (*(float *)(lVar1 + 0x88) <= 0.0)) {
if (param_2 != (int4 *)0x0) {
*param_2 = 0;
}
if (param_3 != (int4 *)0x0) {
*param_3 = 0;
}
if (param_4 != (int4 *)0x0) {
*param_4 = 0;
}
if (param_5 != (int4 *)0x0) {
*param_5 = 0;
param_5[1] = 0;
param_5[2] = 0;
param_5[3] = 0;
}
}
else {
plutovg_font_face_get_metrics
(*(int4 *)(lVar1 + 0x88),*(int8 *)(lVar1 + 8),param_2,param_3,param_4,
param_5);
}
return;
}
|
|
19,898
|
minja::FilterNode::FilterNode(minja::Location const&, std::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::TemplateNode>&&)
|
monkey531[P]llama/common/minja.hpp
|
FilterNode(const Location & location, std::shared_ptr<Expression> && f, std::shared_ptr<TemplateNode> && b)
: TemplateNode(location), filter(std::move(f)), body(std::move(b)) {}
|
O2
|
cpp
|
minja::FilterNode::FilterNode(minja::Location const&, std::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::TemplateNode>&&):
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
callq 0x73924
leaq 0x85512(%rip), %rax # 0xfd508
addq $0x10, %rax
movq %rax, (%r15)
andq $0x0, 0x28(%r15)
movups (%r14), %xmm0
andq $0x0, 0x8(%r14)
movups %xmm0, 0x20(%r15)
andq $0x0, (%r14)
andq $0x0, 0x38(%r15)
movups (%rbx), %xmm0
andq $0x0, 0x8(%rbx)
movups %xmm0, 0x30(%r15)
andq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
|
_ZN5minja10FilterNodeC2ERKNS_8LocationEOSt10shared_ptrINS_10ExpressionEEOS4_INS_12TemplateNodeEE:
push r15
push r14
push rbx
mov rbx, rcx
mov r14, rdx
mov r15, rdi
call _ZN5minja12TemplateNodeC2ERKNS_8LocationE; minja::TemplateNode::TemplateNode(minja::Location const&)
lea rax, _ZTVN5minja10FilterNodeE; `vtable for'minja::FilterNode
add rax, 10h
mov [r15], rax
and qword ptr [r15+28h], 0
movups xmm0, xmmword ptr [r14]
and qword ptr [r14+8], 0
movups xmmword ptr [r15+20h], xmm0
and qword ptr [r14], 0
and qword ptr [r15+38h], 0
movups xmm0, xmmword ptr [rbx]
and qword ptr [rbx+8], 0
movups xmmword ptr [r15+30h], xmm0
and qword ptr [rbx], 0
pop rbx
pop r14
pop r15
retn
|
long long * minja::FilterNode::FilterNode(long long a1, _QWORD *a2, __int128 *a3, __int128 *a4)
{
long long *result; // rax
__int128 v7; // xmm0
__int128 v8; // xmm0
minja::TemplateNode::TemplateNode((_QWORD *)a1, a2);
result = &`vtable for'minja::FilterNode + 2;
*(_QWORD *)a1 = &`vtable for'minja::FilterNode + 2;
*(_QWORD *)(a1 + 40) = 0LL;
v7 = *a3;
*((_QWORD *)a3 + 1) = 0LL;
*(_OWORD *)(a1 + 32) = v7;
*(_QWORD *)a3 = 0LL;
*(_QWORD *)(a1 + 56) = 0LL;
v8 = *a4;
*((_QWORD *)a4 + 1) = 0LL;
*(_OWORD *)(a1 + 48) = v8;
*(_QWORD *)a4 = 0LL;
return result;
}
|
FilterNode:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RCX
MOV R14,RDX
MOV R15,RDI
CALL 0x00173924
LEA RAX,[0x1fd508]
ADD RAX,0x10
MOV qword ptr [R15],RAX
AND qword ptr [R15 + 0x28],0x0
MOVUPS XMM0,xmmword ptr [R14]
AND qword ptr [R14 + 0x8],0x0
MOVUPS xmmword ptr [R15 + 0x20],XMM0
AND qword ptr [R14],0x0
AND qword ptr [R15 + 0x38],0x0
MOVUPS XMM0,xmmword ptr [RBX]
AND qword ptr [RBX + 0x8],0x0
MOVUPS xmmword ptr [R15 + 0x30],XMM0
AND qword ptr [RBX],0x0
POP RBX
POP R14
POP R15
RET
|
/* minja::FilterNode::FilterNode(minja::Location const&, std::shared_ptr<minja::Expression>&&,
std::shared_ptr<minja::TemplateNode>&&) */
void __thiscall
minja::FilterNode::FilterNode
(FilterNode *this,Location *param_1,shared_ptr *param_2,shared_ptr *param_3)
{
int8 uVar1;
TemplateNode::TemplateNode((TemplateNode *)this,param_1);
*(int ***)this = &PTR_do_render_001fd518;
*(int8 *)(this + 0x28) = 0;
uVar1 = *(int8 *)(param_2 + 8);
*(int8 *)(param_2 + 8) = 0;
*(int8 *)(this + 0x20) = *(int8 *)param_2;
*(int8 *)(this + 0x28) = uVar1;
*(int8 *)param_2 = 0;
*(int8 *)(this + 0x38) = 0;
uVar1 = *(int8 *)(param_3 + 8);
*(int8 *)(param_3 + 8) = 0;
*(int8 *)(this + 0x30) = *(int8 *)param_3;
*(int8 *)(this + 0x38) = uVar1;
*(int8 *)param_3 = 0;
return;
}
|
|
19,899
|
bitmap_set_above
|
eloqsql/mysys/my_bitmap.c
|
void bitmap_set_above(MY_BITMAP *map, uint from_byte, uint use_bit)
{
uchar use_byte= use_bit ? 0xff : 0;
uchar *to= (uchar *)map->bitmap + from_byte;
uchar *end= (uchar *)map->bitmap + (map->n_bits+7)/8;
while (to < end)
*to++= use_byte;
}
|
O0
|
c
|
bitmap_set_above:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %edx
xorl %eax, %eax
movl $0xff, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x1c(%rcx), %ecx
addl $0x7, %ecx
shrl $0x3, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0xeed3f
movb -0x11(%rbp), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0xeed1f
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
bitmap_set_above:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
mov edx, [rbp+var_10]
xor eax, eax
mov ecx, 0FFh
cmp edx, 0
cmovnz eax, ecx
mov [rbp+var_11], al
mov rax, [rbp+var_8]
mov rax, [rax]
mov ecx, [rbp+var_C]
add rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_8]
mov rax, [rax]
mov rcx, [rbp+var_8]
mov ecx, [rcx+1Ch]
add ecx, 7
shr ecx, 3
mov ecx, ecx
add rax, rcx
mov [rbp+var_28], rax
loc_EED1F:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jnb short loc_EED3F
mov cl, [rbp+var_11]
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
jmp short loc_EED1F
loc_EED3F:
pop rbp
retn
|
char * bitmap_set_above(long long a1, unsigned int a2, int a3)
{
char v3; // al
char *result; // rax
char *v5; // rax
unsigned long long v6; // [rsp+0h] [rbp-28h]
char *v7; // [rsp+8h] [rbp-20h]
char v8; // [rsp+17h] [rbp-11h]
v3 = 0;
if ( a3 )
v3 = -1;
v8 = v3;
v7 = (char *)(a2 + *(_QWORD *)a1);
v6 = ((unsigned int)(*(_DWORD *)(a1 + 28) + 7) >> 3) + *(_QWORD *)a1;
while ( 1 )
{
result = v7;
if ( (unsigned long long)v7 >= v6 )
break;
v5 = v7++;
*v5 = v8;
}
return result;
}
|
bitmap_set_above:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
MOV EDX,dword ptr [RBP + -0x10]
XOR EAX,EAX
MOV ECX,0xff
CMP EDX,0x0
CMOVNZ EAX,ECX
MOV byte ptr [RBP + -0x11],AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0xc]
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x1c]
ADD ECX,0x7
SHR ECX,0x3
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
LAB_001eed1f:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JNC 0x001eed3f
MOV CL,byte ptr [RBP + -0x11]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
JMP 0x001eed1f
LAB_001eed3f:
POP RBP
RET
|
void bitmap_set_above(long *param_1,uint param_2,int param_3)
{
int iVar1;
long lVar2;
int1 uVar3;
int1 *local_28;
uVar3 = 0;
if (param_3 != 0) {
uVar3 = 0xff;
}
lVar2 = *param_1;
iVar1 = *(int *)((long)param_1 + 0x1c);
local_28 = (int1 *)(*param_1 + (ulong)param_2);
while (local_28 < (int1 *)(lVar2 + (ulong)(iVar1 + 7U >> 3))) {
*local_28 = uVar3;
local_28 = local_28 + 1;
}
return;
}
|
Subsets and Splits
C++ Functions Using STL
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ STL Function Queries
Filters C++ code examples that use standard library containers and algorithms, helping identify common programming patterns and library usage in code generation tasks.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.