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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
25,000 | exp_mont_384 | corpus-core[P]colibri-stateless/build_O3/_deps/blst-src/src/exp.c | static void exp_mont_384(vec384 out, const vec384 inp, const byte *pow,
size_t pow_bits, const vec384 p, limb_t n0)
{
#if 1
vec384 ret;
vec_copy(ret, inp, sizeof(ret)); /* ret = inp^1 */
--pow_bits; /* most significant bit is set, skip over */
while (pow_bits--) {
sqr_mont_384(ret, ret, p, n0);
if (is_bit_set(pow, pow_bits))
mul_mont_384(ret, ret, inp, p, n0);
}
vec_copy(out, ret, sizeof(ret)); /* out = ret */
#else
unsigned int i;
vec384 sqr;
vec_copy(sqr, inp, sizeof(sqr));
for (i = 0; !is_bit_set(pow, i++);)
sqr_mont_384(sqr, sqr, sqr, p, n0);
vec_copy(out, sqr, sizeof(sqr));
for (; i < pow_bits; i++) {
sqr_mont_384(sqr, sqr, sqr, p, n0);
if (is_bit_set(pow, i))
mul_mont_384(out, out, sqr, p, n0);
}
#endif
} | O3 | c | exp_mont_384:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, -0x40(%rbp)
movq %rdi, -0x30(%rbp)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movq %rsi, -0x38(%rbp)
movups 0x20(%rsi), %xmm2
movaps %xmm2, -0x50(%rbp)
movaps %xmm1, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
cmpq $0x1, %rcx
je 0x66905
movq %rcx, %r14
movabsq $-0x760c000300030003, %rbx # imm = 0x89F3FFFCFFFCFFFD
leaq 0x263f3(%rip), %r15 # 0x8cca0
leaq -0x70(%rbp), %r12
leaq -0x2(%r14), %r13
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x74720
movq %r13, %rax
shrq $0x3, %rax
movq -0x40(%rbp), %rcx
movzbl (%rcx,%rax), %eax
andl $0x7, %r13d
xorl %ecx, %ecx
btl %r13d, %eax
setb %cl
testq %rcx, %rcx
je 0x668fc
movq %r12, %rdi
movq %r12, %rsi
movq -0x38(%rbp), %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x74ea0
decq %r14
cmpq $0x1, %r14
jne 0x668b1
movaps -0x70(%rbp), %xmm0
movaps -0x60(%rbp), %xmm1
movaps -0x50(%rbp), %xmm2
movq -0x30(%rbp), %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| exp_mont_384:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov [rbp+var_40], rdx
mov [rbp+var_30], rdi
movups xmm0, xmmword ptr [rsi]
movups xmm1, xmmword ptr [rsi+10h]
mov [rbp+var_38], rsi
movups xmm2, xmmword ptr [rsi+20h]
movaps [rbp+var_50], xmm2
movaps [rbp+var_60], xmm1
movaps [rbp+var_70], xmm0
cmp rcx, 1
jz short loc_66905
mov r14, rcx
mov rbx, 89F3FFFCFFFCFFFDh
lea r15, BLS12_381_P
lea r12, [rbp+var_70]
loc_668B1:
lea r13, [r14-2]
mov rdi, r12
mov rsi, r12
mov rdx, r15
mov rcx, rbx
call sqr_mont_384
mov rax, r13
shr rax, 3
mov rcx, [rbp+var_40]
movzx eax, byte ptr [rcx+rax]
and r13d, 7
xor ecx, ecx
bt eax, r13d
setb cl
test rcx, rcx
jz short loc_668FC
mov rdi, r12
mov rsi, r12
mov rdx, [rbp+var_38]
mov rcx, r15
mov r8, rbx
call mul_mont_384
loc_668FC:
dec r14
cmp r14, 1
jnz short loc_668B1
loc_66905:
movaps xmm0, [rbp+var_70]
movaps xmm1, [rbp+var_60]
movaps xmm2, [rbp+var_50]
mov rax, [rbp+var_30]
movups xmmword ptr [rax+20h], xmm2
movups xmmword ptr [rax+10h], xmm1
movups xmmword ptr [rax], xmm0
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| _OWORD * exp_mont_384(_OWORD *a1, _OWORD *a2, long long a3, long long a4)
{
__int128 v4; // xmm0
__int128 v5; // xmm1
long long i; // r14
int v7; // eax
__int128 v8; // xmm0
__int128 v9; // xmm1
_OWORD *result; // rax
__int128 v11; // [rsp+0h] [rbp-70h] BYREF
__int128 v12; // [rsp+10h] [rbp-60h]
__int128 v13; // [rsp+20h] [rbp-50h]
long long v14; // [rsp+30h] [rbp-40h]
_OWORD *v15; // [rsp+38h] [rbp-38h]
_OWORD *v16; // [rsp+40h] [rbp-30h]
v14 = a3;
v16 = a1;
v4 = *a2;
v5 = a2[1];
v15 = a2;
v13 = a2[2];
v12 = v5;
v11 = v4;
if ( a4 != 1 )
{
for ( i = a4; i != 1; --i )
{
sqr_mont_384(&v11, &v11, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
v7 = *(unsigned __int8 *)(v14 + ((unsigned long long)(i - 2) >> 3));
if ( _bittest(&v7, (i - 2) & 7) )
mul_mont_384(&v11, &v11, v15, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
}
}
v8 = v11;
v9 = v12;
result = v16;
v16[2] = v13;
result[1] = v9;
*result = v8;
return result;
}
| exp_mont_384:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x40],RDX
MOV qword ptr [RBP + -0x30],RDI
MOVUPS XMM0,xmmword ptr [RSI]
MOVUPS XMM1,xmmword ptr [RSI + 0x10]
MOV qword ptr [RBP + -0x38],RSI
MOVUPS XMM2,xmmword ptr [RSI + 0x20]
MOVAPS xmmword ptr [RBP + -0x50],XMM2
MOVAPS xmmword ptr [RBP + -0x60],XMM1
MOVAPS xmmword ptr [RBP + -0x70],XMM0
CMP RCX,0x1
JZ 0x00166905
MOV R14,RCX
MOV RBX,-0x760c000300030003
LEA R15,[0x18cca0]
LEA R12,[RBP + -0x70]
LAB_001668b1:
LEA R13,[R14 + -0x2]
MOV RDI,R12
MOV RSI,R12
MOV RDX,R15
MOV RCX,RBX
CALL 0x00174720
MOV RAX,R13
SHR RAX,0x3
MOV RCX,qword ptr [RBP + -0x40]
MOVZX EAX,byte ptr [RCX + RAX*0x1]
AND R13D,0x7
XOR ECX,ECX
BT EAX,R13D
SETC CL
TEST RCX,RCX
JZ 0x001668fc
MOV RDI,R12
MOV RSI,R12
MOV RDX,qword ptr [RBP + -0x38]
MOV RCX,R15
MOV R8,RBX
CALL 0x00174ea0
LAB_001668fc:
DEC R14
CMP R14,0x1
JNZ 0x001668b1
LAB_00166905:
MOVAPS XMM0,xmmword ptr [RBP + -0x70]
MOVAPS XMM1,xmmword ptr [RBP + -0x60]
MOVAPS XMM2,xmmword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x30]
MOVUPS xmmword ptr [RAX + 0x20],XMM2
MOVUPS xmmword ptr [RAX + 0x10],XMM1
MOVUPS xmmword ptr [RAX],XMM0
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void exp_mont_384(int8 *param_1,int4 *param_2,long param_3,long param_4)
{
int4 local_78;
int4 uStack_74;
int4 uStack_70;
int4 uStack_6c;
int8 local_68;
int8 uStack_60;
int8 local_58;
int8 uStack_50;
long local_48;
int4 *local_40;
int8 *local_38;
local_78 = *param_2;
uStack_74 = param_2[1];
uStack_70 = param_2[2];
uStack_6c = param_2[3];
local_68 = *(int8 *)(param_2 + 4);
uStack_60 = *(int8 *)(param_2 + 6);
local_58 = *(int8 *)(param_2 + 8);
uStack_50 = *(int8 *)(param_2 + 10);
local_38 = param_1;
if (param_4 != 1) {
local_48 = param_3;
local_40 = param_2;
do {
sqr_mont_384(&local_78,&local_78,BLS12_381_P,0x89f3fffcfffcfffd);
if ((*(byte *)(local_48 + (param_4 - 2U >> 3)) >> ((uint)(param_4 - 2U) & 7) & 1) != 0) {
mul_mont_384(&local_78,&local_78,local_40,BLS12_381_P,0x89f3fffcfffcfffd);
}
param_4 = param_4 + -1;
} while (param_4 != 1);
}
local_38[4] = local_58;
local_38[5] = uStack_50;
local_38[2] = local_68;
local_38[3] = uStack_60;
*local_38 = CONCAT44(uStack_74,local_78);
local_38[1] = CONCAT44(uStack_6c,uStack_70);
return;
}
| |
25,001 | lunasvg::parsePaint(std::basic_string_view<char, std::char_traits<char>>, lunasvg::SVGLayoutState const*, lunasvg::Color const&) | dmazzella[P]pylunasvg/lunasvg/source/svglayoutstate.cpp | static Paint parsePaint(std::string_view input, const SVGLayoutState* state, const Color& defaultValue)
{
std::string id;
if(!parseUrlValue(input, id))
return Paint(parseColorOrNone(input, state, defaultValue));
if(skipOptionalSpaces(input))
return Paint(id, parseColorOrNone(input, state, defaultValue));
return Paint(id, Color::Transparent);
} | O0 | cpp | lunasvg::parsePaint(std::basic_string_view<char, std::char_traits<char>>, lunasvg::SVGLayoutState const*, lunasvg::Color const&):
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xb520
movq -0xa0(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x32040
movb %al, -0x91(%rbp)
jmp 0x312d8
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x3134a
jmp 0x312e4
movups -0x18(%rbp), %xmm0
movaps %xmm0, -0x70(%rbp)
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x32280
movl %eax, -0xb4(%rbp)
jmp 0x31309
movq -0xb0(%rbp), %rdi
movl -0xb4(%rbp), %eax
movl %eax, -0x58(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x22ed0
jmp 0x31324
movl $0x1, -0x74(%rbp)
jmp 0x313dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xb7a8
jmp 0x313f6
leaq -0x18(%rbp), %rdi
callq 0x332b0
movb %al, -0xb5(%rbp)
jmp 0x3135b
movb -0xb5(%rbp), %al
testb $0x1, %al
jne 0x31367
jmp 0x313bd
movups -0x18(%rbp), %xmm0
movaps %xmm0, -0x90(%rbp)
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x32280
movl %eax, -0xbc(%rbp)
jmp 0x31395
movq -0xb0(%rbp), %rdi
movl -0xbc(%rbp), %eax
movl %eax, -0x78(%rbp)
leaq -0x48(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0x33320
jmp 0x313b4
movl $0x1, -0x74(%rbp)
jmp 0x313dd
movq -0xb0(%rbp), %rdi
leaq 0x5ad89(%rip), %rdx # 0x8c154
leaq -0x48(%rbp), %rsi
callq 0x33320
jmp 0x313d6
movl $0x1, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xb7a8
movq -0xa8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0xb6c0
nop
| _ZN7lunasvgL10parsePaintESt17basic_string_viewIcSt11char_traitsIcEEPKNS_14SVGLayoutStateERKNS_5ColorE:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov [rbp+var_B0], rdi
mov rax, rdi
mov [rbp+var_A8], rax
mov [rbp+var_8], rdi
mov qword ptr [rbp+var_18], rsi
mov qword ptr [rbp+var_18+8], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
lea rdi, [rbp+var_48]
mov [rbp+var_A0], rdi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov rsi, [rbp+var_A0]
lea rdi, [rbp+var_18]
call _ZN7lunasvgL13parseUrlValueERSt17basic_string_viewIcSt11char_traitsIcEERNSt7__cxx1112basic_stringIcS2_SaIcEEE; lunasvg::parseUrlValue(std::string_view &,std::string &)
mov [rbp+var_91], al
jmp short $+2
loc_312D8:
mov al, [rbp+var_91]
test al, 1
jnz short loc_3134A
jmp short $+2
loc_312E4:
movups xmm0, [rbp+var_18]
movaps [rbp+var_70], xmm0
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
mov rdi, qword ptr [rbp+var_70]
mov rsi, qword ptr [rbp+var_70+8]
call _ZN7lunasvgL16parseColorOrNoneESt17basic_string_viewIcSt11char_traitsIcEEPKNS_14SVGLayoutStateERKNS_5ColorE; lunasvg::parseColorOrNone(std::string_view,lunasvg::SVGLayoutState const*,lunasvg::Color const&)
mov [rbp+var_B4], eax
jmp short $+2
loc_31309:
mov rdi, [rbp+var_B0]; this
mov eax, [rbp+var_B4]
mov [rbp+var_58], eax
lea rsi, [rbp+var_58]; lunasvg::Color *
call _ZN7lunasvg5PaintC2ERKNS_5ColorE; lunasvg::Paint::Paint(lunasvg::Color const&)
jmp short $+2
loc_31324:
mov [rbp+var_74], 1
jmp loc_313DD
mov rcx, rax
mov eax, edx
mov [rbp+var_50], rcx
mov [rbp+var_54], eax
lea rdi, [rbp+var_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp loc_313F6
loc_3134A:
lea rdi, [rbp+var_18]
call _ZN7lunasvg18skipOptionalSpacesERSt17basic_string_viewIcSt11char_traitsIcEE; lunasvg::skipOptionalSpaces(std::string_view &)
mov [rbp+var_B5], al
jmp short $+2
loc_3135B:
mov al, [rbp+var_B5]
test al, 1
jnz short loc_31367
jmp short loc_313BD
loc_31367:
movups xmm0, [rbp+var_18]
movaps [rbp+var_90], xmm0
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
mov rdi, qword ptr [rbp+var_90]
mov rsi, qword ptr [rbp+var_90+8]
call _ZN7lunasvgL16parseColorOrNoneESt17basic_string_viewIcSt11char_traitsIcEEPKNS_14SVGLayoutStateERKNS_5ColorE; lunasvg::parseColorOrNone(std::string_view,lunasvg::SVGLayoutState const*,lunasvg::Color const&)
mov [rbp+var_BC], eax
jmp short $+2
loc_31395:
mov rdi, [rbp+var_B0]
mov eax, [rbp+var_BC]
mov [rbp+var_78], eax
lea rsi, [rbp+var_48]
lea rdx, [rbp+var_78]
call _ZN7lunasvg5PaintC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_5ColorE; lunasvg::Paint::Paint(std::string const&,lunasvg::Color const&)
jmp short $+2
loc_313B4:
mov [rbp+var_74], 1
jmp short loc_313DD
loc_313BD:
mov rdi, [rbp+var_B0]
lea rdx, _ZN7lunasvg5Color11TransparentE; lunasvg::Color::Transparent
lea rsi, [rbp+var_48]
call _ZN7lunasvg5PaintC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_5ColorE; lunasvg::Paint::Paint(std::string const&,lunasvg::Color const&)
jmp short $+2
loc_313D6:
mov [rbp+var_74], 1
loc_313DD:
lea rdi, [rbp+var_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rax, [rbp+var_A8]
add rsp, 0C0h
pop rbp
retn
loc_313F6:
mov rdi, [rbp+var_50]
call __Unwind_Resume
| lunasvg::Paint * lunasvg::parsePaint(lunasvg::Paint *a1, long long a2, long long a3, long long a4, long long a5)
{
int v6; // [rsp+48h] [rbp-78h] BYREF
int v7; // [rsp+4Ch] [rbp-74h]
__int128 v8; // [rsp+50h] [rbp-70h]
int v9; // [rsp+68h] [rbp-58h] BYREF
_BYTE v10[32]; // [rsp+78h] [rbp-48h] BYREF
long long v11; // [rsp+98h] [rbp-28h]
long long v12; // [rsp+A0h] [rbp-20h]
__int128 v13; // [rsp+A8h] [rbp-18h] BYREF
lunasvg::Paint *v14; // [rsp+B8h] [rbp-8h]
v14 = a1;
*(_QWORD *)&v13 = a2;
*((_QWORD *)&v13 + 1) = a3;
v12 = a4;
v11 = a5;
std::string::basic_string(v10);
if ( (lunasvg::parseUrlValue(&v13, v10) & 1) != 0 )
{
if ( (lunasvg::skipOptionalSpaces(&v13) & 1) != 0 )
{
v6 = lunasvg::parseColorOrNone(v13, *((_QWORD *)&v13 + 1), v12, v11);
lunasvg::Paint::Paint(a1, v10, &v6);
}
else
{
lunasvg::Paint::Paint(a1, v10, &lunasvg::Color::Transparent);
}
v7 = 1;
}
else
{
v8 = v13;
v9 = lunasvg::parseColorOrNone(v13, *((_QWORD *)&v13 + 1), v12, v11);
lunasvg::Paint::Paint(a1, (const lunasvg::Color *)&v9);
v7 = 1;
}
std::string::~string(v10);
return a1;
}
| parsePaint:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc0
MOV qword ptr [RBP + -0xb0],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0xa8],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x10],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
LEA RDI,[RBP + -0x48]
MOV qword ptr [RBP + -0xa0],RDI
CALL 0x0010b520
MOV RSI,qword ptr [RBP + -0xa0]
LAB_001312c7:
LEA RDI,[RBP + -0x18]
CALL 0x00132040
MOV byte ptr [RBP + -0x91],AL
JMP 0x001312d8
LAB_001312d8:
MOV AL,byte ptr [RBP + -0x91]
TEST AL,0x1
JNZ 0x0013134a
JMP 0x001312e4
LAB_001312e4:
MOVUPS XMM0,xmmword ptr [RBP + -0x18]
MOVAPS xmmword ptr [RBP + -0x70],XMM0
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x68]
CALL 0x00132280
MOV dword ptr [RBP + -0xb4],EAX
JMP 0x00131309
LAB_00131309:
MOV RDI,qword ptr [RBP + -0xb0]
MOV EAX,dword ptr [RBP + -0xb4]
MOV dword ptr [RBP + -0x58],EAX
LEA RSI,[RBP + -0x58]
CALL 0x00122ed0
JMP 0x00131324
LAB_00131324:
MOV dword ptr [RBP + -0x74],0x1
JMP 0x001313dd
LAB_0013134a:
LEA RDI,[RBP + -0x18]
CALL 0x001332b0
MOV byte ptr [RBP + -0xb5],AL
JMP 0x0013135b
LAB_0013135b:
MOV AL,byte ptr [RBP + -0xb5]
TEST AL,0x1
JNZ 0x00131367
JMP 0x001313bd
LAB_00131367:
MOVUPS XMM0,xmmword ptr [RBP + -0x18]
MOVAPS xmmword ptr [RBP + -0x90],XMM0
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RBP + -0x90]
MOV RSI,qword ptr [RBP + -0x88]
CALL 0x00132280
MOV dword ptr [RBP + -0xbc],EAX
JMP 0x00131395
LAB_00131395:
MOV RDI,qword ptr [RBP + -0xb0]
MOV EAX,dword ptr [RBP + -0xbc]
MOV dword ptr [RBP + -0x78],EAX
LEA RSI,[RBP + -0x48]
LEA RDX,[RBP + -0x78]
CALL 0x00133320
JMP 0x001313b4
LAB_001313b4:
MOV dword ptr [RBP + -0x74],0x1
JMP 0x001313dd
LAB_001313bd:
MOV RDI,qword ptr [RBP + -0xb0]
LEA RDX,[0x18c154]
LEA RSI,[RBP + -0x48]
CALL 0x00133320
LAB_001313d4:
JMP 0x001313d6
LAB_001313d6:
MOV dword ptr [RBP + -0x74],0x1
LAB_001313dd:
LEA RDI,[RBP + -0x48]
CALL 0x0010b7a8
MOV RAX,qword ptr [RBP + -0xa8]
ADD RSP,0xc0
POP RBP
RET
|
/* lunasvg::parsePaint(std::basic_string_view<char, std::char_traits<char> >,
lunasvg::SVGLayoutState const*, lunasvg::Color const&) */
Paint * lunasvg::parsePaint(Paint *param_1,lunasvg *param_2,int8 param_3,int8 param_4,
int8 param_5)
{
byte bVar1;
int4 local_80;
int4 local_7c;
int4 local_78;
int4 uStack_74;
int4 uStack_70;
int4 uStack_6c;
int4 local_60 [4];
string local_50 [32];
int8 local_30;
int8 local_28;
int8 local_20;
int8 uStack_18;
Paint *local_10;
local_30 = param_5;
local_28 = param_4;
local_20 = param_2;
uStack_18 = param_3;
local_10 = param_1;
std::__cxx11::string::string(local_50);
/* try { // try from 001312c7 to 001313d3 has its CatchHandler @ 00131330 */
bVar1 = parseUrlValue((basic_string_view *)&local_20,local_50);
if ((bVar1 & 1) == 0) {
local_78 = (int4)local_20;
uStack_74 = local_20._4_4_;
uStack_70 = (int4)uStack_18;
uStack_6c = uStack_18._4_4_;
local_60[0] = parseColorOrNone(local_20,uStack_18,local_28,local_30);
Paint::Paint(param_1,(Color *)local_60);
}
else {
bVar1 = skipOptionalSpaces((basic_string_view *)&local_20);
if ((bVar1 & 1) == 0) {
Paint::Paint(param_1,local_50,(Color *)&Color::Transparent);
}
else {
local_80 = parseColorOrNone(local_20,uStack_18,local_28,local_30);
Paint::Paint(param_1,local_50,(Color *)&local_80);
}
}
local_7c = 1;
std::__cxx11::string::~string(local_50);
return param_1;
}
| |
25,002 | lunasvg::parsePaint(std::basic_string_view<char, std::char_traits<char>>, lunasvg::SVGLayoutState const*, lunasvg::Color const&) | dmazzella[P]pylunasvg/lunasvg/source/svglayoutstate.cpp | static Paint parsePaint(std::string_view input, const SVGLayoutState* state, const Color& defaultValue)
{
std::string id;
if(!parseUrlValue(input, id))
return Paint(parseColorOrNone(input, state, defaultValue));
if(skipOptionalSpaces(input))
return Paint(id, parseColorOrNone(input, state, defaultValue));
return Paint(id, Color::Transparent);
} | O1 | cpp | lunasvg::parsePaint(std::basic_string_view<char, std::char_traits<char>>, lunasvg::SVGLayoutState const*, lunasvg::Color const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
movq %rsp, %rdi
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x10(%rsp), %rsi
callq 0x16e40
movq (%rsp), %rdi
testb %al, %al
je 0x1696d
testq %rdi, %rdi
setne %al
je 0x16932
movq 0x8(%rsp), %rdx
incq %rdx
decq %rdi
movb $0x1, %al
movabsq $0x100002600, %rcx # imm = 0x100002600
movzbl -0x1(%rdx), %esi
cmpq $0x20, %rsi
ja 0x16932
btq %rsi, %rcx
jae 0x16932
movq %rdx, 0x8(%rsp)
incq %rdx
leaq -0x1(%rdi), %rax
cmpq $-0x1, %rax
setne %al
movq %rdi, (%rsp)
addq $-0x1, %rdi
jb 0x16905
testb $0x1, %al
je 0x16992
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x170ee
movl %eax, %ebp
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xaeea
movl %ebp, 0x20(%rbx)
jmp 0x169ba
movq 0x8(%rsp), %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x170ee
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
jmp 0x169b7
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xaeea
leaq 0x2c7c3(%rip), %rax # 0x43178
movl (%rax), %eax
movl %eax, 0x20(%rbx)
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x169d1
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xa320
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x169e5
jmp 0x169e5
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x169ff
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xa320
movq %rbx, %rdi
callq 0xa5c0
| _ZN7lunasvgL10parsePaintESt17basic_string_viewIcSt11char_traitsIcEEPKNS_14SVGLayoutStateERKNS_5ColorE:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 30h
mov r14, r8
mov r15, rcx
mov rbx, rdi
mov rdi, rsp
mov [rdi], rsi
mov [rdi+8], rdx
lea r12, [rsp+58h+var_38]
mov [r12-10h], r12
mov qword ptr [r12-8], 0
mov byte ptr [r12], 0
lea rsi, [rsp+58h+var_48]
call _ZN7lunasvgL13parseUrlValueERSt17basic_string_viewIcSt11char_traitsIcEERNSt7__cxx1112basic_stringIcS2_SaIcEEE; lunasvg::parseUrlValue(std::string_view &,std::string &)
mov rdi, [rsp+58h+var_58]
test al, al
jz loc_1696D
test rdi, rdi
setnz al
jz short loc_16932
mov rdx, [rsp+58h+var_50]
inc rdx
dec rdi
mov al, 1
mov rcx, 100002600h
loc_16905:
movzx esi, byte ptr [rdx-1]
cmp rsi, 20h ; ' '
ja short loc_16932
bt rcx, rsi
jnb short loc_16932
mov [rsp+58h+var_50], rdx
inc rdx
lea rax, [rdi-1]
cmp rax, 0FFFFFFFFFFFFFFFFh
setnz al
mov [rsp+58h+var_58], rdi
add rdi, 0FFFFFFFFFFFFFFFFh
jb short loc_16905
loc_16932:
test al, 1
jz short loc_16992
mov rdi, [rsp+58h+var_58]
mov rsi, [rsp+58h+var_50]
mov rdx, r15
mov rcx, r14
call _ZN7lunasvgL16parseColorOrNoneESt17basic_string_viewIcSt11char_traitsIcEEPKNS_14SVGLayoutStateERKNS_5ColorE; lunasvg::parseColorOrNone(std::string_view,lunasvg::SVGLayoutState const*,lunasvg::Color const&)
mov ebp, eax
lea rax, [rbx+10h]
mov [rbx], rax
mov rsi, [rsp+58h+var_48]
mov rdx, [rsp+58h+var_40]
add rdx, rsi
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov [rbx+20h], ebp
jmp short loc_169BA
loc_1696D:
mov rsi, [rsp+58h+var_50]
mov rdx, r15
mov rcx, r14
call _ZN7lunasvgL16parseColorOrNoneESt17basic_string_viewIcSt11char_traitsIcEEPKNS_14SVGLayoutStateERKNS_5ColorE; lunasvg::parseColorOrNone(std::string_view,lunasvg::SVGLayoutState const*,lunasvg::Color const&)
lea rcx, [rbx+10h]
mov [rbx], rcx
mov qword ptr [rbx+8], 0
mov byte ptr [rbx+10h], 0
jmp short loc_169B7
loc_16992:
lea rax, [rbx+10h]
mov [rbx], rax
mov rsi, [rsp+58h+var_48]
mov rdx, [rsp+58h+var_40]
add rdx, rsi
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rax, _ZN7lunasvg5Color11TransparentE; lunasvg::Color::Transparent
mov eax, [rax]
loc_169B7:
mov [rbx+20h], eax
loc_169BA:
mov rdi, [rsp+58h+var_48]; void *
cmp rdi, r12
jz short loc_169D1
mov rsi, [rsp+58h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_169D1:
mov rax, rbx
add rsp, 30h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
jmp short loc_169E5
jmp short $+2
loc_169E5:
mov rbx, rax
mov rdi, [rsp+arg_8]; void *
cmp rdi, r12
jz short loc_169FF
mov rsi, [rsp+arg_18]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_169FF:
mov rdi, rbx
call __Unwind_Resume
| long long lunasvg::parsePaint(long long a1, long long a2, long long a3, long long a4, long long a5)
{
bool v8; // al
long long v9; // rdx
long long v10; // rdi
long long v11; // rcx
unsigned long long v12; // rsi
int v14; // ebp
int v15; // eax
long long v17; // [rsp+0h] [rbp-58h] BYREF
long long v18; // [rsp+8h] [rbp-50h]
void *v19; // [rsp+10h] [rbp-48h] BYREF
long long v20; // [rsp+18h] [rbp-40h]
_QWORD v21[7]; // [rsp+20h] [rbp-38h] BYREF
v17 = a2;
v18 = a3;
v19 = v21;
v20 = 0LL;
LOBYTE(v21[0]) = 0;
if ( (unsigned __int8)lunasvg::parseUrlValue(&v17, &v19) )
{
v8 = v17 != 0;
if ( v17 )
{
v9 = v18 + 1;
v10 = v17 - 1;
v8 = 1;
v11 = 0x100002600LL;
do
{
v12 = *(unsigned __int8 *)(v9 - 1);
if ( v12 > 0x20 )
break;
if ( !_bittest64(&v11, v12) )
break;
v18 = v9++;
v8 = v10 != 0;
v17 = v10;
}
while ( v10-- != 0 );
}
if ( v8 )
{
v14 = lunasvg::parseColorOrNone(v17, v18, a4, a5);
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char *>((_QWORD *)a1, v19, (long long)v19 + v20);
*(_DWORD *)(a1 + 32) = v14;
goto LABEL_12;
}
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char *>((_QWORD *)a1, v19, (long long)v19 + v20);
v15 = lunasvg::Color::Transparent;
}
else
{
v15 = lunasvg::parseColorOrNone(v17, v18, a4, a5);
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
}
*(_DWORD *)(a1 + 32) = v15;
LABEL_12:
if ( v19 != v21 )
operator delete(v19, v21[0] + 1LL);
return a1;
}
| parsePaint:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x30
MOV R14,R8
MOV R15,RCX
MOV RBX,RDI
MOV RDI,RSP
MOV qword ptr [RDI],RSI
MOV qword ptr [RDI + 0x8],RDX
LEA R12,[RSP + 0x20]
MOV qword ptr [R12 + -0x10],R12
MOV qword ptr [R12 + -0x8],0x0
MOV byte ptr [R12],0x0
LAB_001168d0:
LEA RSI,[RSP + 0x10]
CALL 0x00116e40
MOV RDI,qword ptr [RSP]
TEST AL,AL
JZ 0x0011696d
TEST RDI,RDI
SETNZ AL
JZ 0x00116932
MOV RDX,qword ptr [RSP + 0x8]
INC RDX
DEC RDI
MOV AL,0x1
MOV RCX,0x100002600
LAB_00116905:
MOVZX ESI,byte ptr [RDX + -0x1]
CMP RSI,0x20
JA 0x00116932
BT RCX,RSI
JNC 0x00116932
MOV qword ptr [RSP + 0x8],RDX
INC RDX
LEA RAX,[RDI + -0x1]
CMP RAX,-0x1
SETNZ AL
MOV qword ptr [RSP],RDI
ADD RDI,-0x1
JC 0x00116905
LAB_00116932:
TEST AL,0x1
JZ 0x00116992
MOV RDI,qword ptr [RSP]
MOV RSI,qword ptr [RSP + 0x8]
LAB_0011693f:
MOV RDX,R15
MOV RCX,R14
CALL 0x001170ee
MOV EBP,EAX
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x18]
ADD RDX,RSI
MOV RDI,RBX
CALL 0x0010aeea
MOV dword ptr [RBX + 0x20],EBP
JMP 0x001169ba
LAB_0011696d:
MOV RSI,qword ptr [RSP + 0x8]
LAB_00116972:
MOV RDX,R15
MOV RCX,R14
CALL 0x001170ee
LEA RCX,[RBX + 0x10]
MOV qword ptr [RBX],RCX
MOV qword ptr [RBX + 0x8],0x0
MOV byte ptr [RBX + 0x10],0x0
JMP 0x001169b7
LAB_00116992:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x18]
ADD RDX,RSI
LAB_001169a6:
MOV RDI,RBX
CALL 0x0010aeea
LAB_001169ae:
LEA RAX,[0x143178]
MOV EAX,dword ptr [RAX]
LAB_001169b7:
MOV dword ptr [RBX + 0x20],EAX
LAB_001169ba:
MOV RDI,qword ptr [RSP + 0x10]
CMP RDI,R12
JZ 0x001169d1
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x0010a320
LAB_001169d1:
MOV RAX,RBX
ADD RSP,0x30
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* lunasvg::parsePaint(std::basic_string_view<char, std::char_traits<char> >,
lunasvg::SVGLayoutState const*, lunasvg::Color const&) */
long * lunasvg::parsePaint(long *param_1,lunasvg *param_2,byte *param_3,int8 param_4,
int8 param_5)
{
char cVar1;
int4 uVar2;
byte *pbVar3;
lunasvg *plVar4;
bool bVar5;
lunasvg *local_58;
byte *local_50;
int1 *local_48;
long local_40;
int1 local_38;
int7 uStack_37;
local_40 = 0;
local_38 = 0;
/* try { // try from 001168d0 to 001168d9 has its CatchHandler @ 001169e5 */
local_58 = param_2;
local_50 = param_3;
local_48 = &local_38;
cVar1 = parseUrlValue((basic_string_view *)&local_58,(string *)&local_48);
if (cVar1 == '\0') {
/* try { // try from 00116972 to 0011697c has its CatchHandler @ 001169e3 */
uVar2 = parseColorOrNone(local_58,local_50,param_4,param_5);
*param_1 = (long)(param_1 + 2);
param_1[1] = 0;
*(int1 *)(param_1 + 2) = 0;
}
else {
bVar5 = local_58 != (lunasvg *)0x0;
if (bVar5) {
bVar5 = true;
do {
plVar4 = local_58 + -1;
pbVar3 = local_50 + 1;
if ((0x20 < (ulong)*local_50) || ((0x100002600U >> ((ulong)*local_50 & 0x3f) & 1) == 0))
break;
bVar5 = local_58 != (lunasvg *)0x1;
local_58 = plVar4;
local_50 = pbVar3;
} while (plVar4 != (lunasvg *)0x0);
}
if (bVar5) {
/* try { // try from 0011693f to 00116967 has its CatchHandler @ 001169e1 */
uVar2 = parseColorOrNone(local_58,local_50,param_4,param_5);
*param_1 = (long)(param_1 + 2);
std::__cxx11::string::_M_construct<char*>(param_1,local_48,local_48 + local_40);
*(int4 *)(param_1 + 4) = uVar2;
goto LAB_001169ba;
}
*param_1 = (long)(param_1 + 2);
/* try { // try from 001169a6 to 001169ad has its CatchHandler @ 001169e5 */
std::__cxx11::string::_M_construct<char*>(param_1,local_48,local_48 + local_40);
uVar2 = Color::Transparent;
}
*(int4 *)(param_1 + 4) = uVar2;
LAB_001169ba:
if (local_48 != &local_38) {
operator_delete(local_48,CONCAT71(uStack_37,local_38) + 1);
}
return param_1;
}
| |
25,003 | BC_add_object_ref1 | bluesky950520[P]quickjs/quickjs.c | static int BC_add_object_ref1(BCReaderState *s, JSObject *p)
{
if (s->allow_reference) {
if (js_resize_array(s->ctx, (void *)&s->objects,
sizeof(s->objects[0]),
&s->objects_size, s->objects_count + 1))
return -1;
s->objects[s->objects_count++] = p;
}
return 0;
} | O1 | c | BC_add_object_ref1:
xorl %eax, %eax
cmpb $0x0, 0x36(%rdi)
je 0x470c9
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x40(%rdi), %r8d
cmpl %r8d, 0x44(%rdi)
jle 0x470ca
movq 0x38(%r14), %rax
movslq 0x40(%r14), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x40(%r14)
movq %rbx, (%rax,%rcx,8)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x38(%r14), %rsi
leaq 0x44(%r14), %rcx
incl %r8d
movq (%r14), %rdi
movl $0x8, %edx
callq 0x434ef
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x470c2
jmp 0x470ad
| BC_add_object_ref1:
xor eax, eax
cmp byte ptr [rdi+36h], 0
jz short locret_470C9
push r14
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov r8d, [rdi+40h]
cmp [rdi+44h], r8d
jle short loc_470CA
loc_470AD:
mov rax, [r14+38h]
movsxd rcx, dword ptr [r14+40h]
lea edx, [rcx+1]
mov [r14+40h], edx
mov [rax+rcx*8], rbx
xor eax, eax
loc_470C2:
add rsp, 8
pop rbx
pop r14
locret_470C9:
retn
loc_470CA:
lea rsi, [r14+38h]
lea rcx, [r14+44h]
inc r8d
mov rdi, [r14]
mov edx, 8
call js_realloc_array
mov ecx, eax
mov eax, 0FFFFFFFFh
test ecx, ecx
jnz short loc_470C2
jmp short loc_470AD
| long long BC_add_object_ref1(long long a1, long long a2)
{
long long result; // rax
int v3; // r8d
long long v4; // rax
long long v5; // rcx
int v6; // ecx
result = 0LL;
if ( *(_BYTE *)(a1 + 54) )
{
v3 = *(_DWORD *)(a1 + 64);
if ( *(_DWORD *)(a1 + 68) > v3
|| (v6 = js_realloc_array(*(_QWORD *)a1, (long long *)(a1 + 56), 8u, (_DWORD *)(a1 + 68), v3 + 1),
result = 0xFFFFFFFFLL,
!v6) )
{
v4 = *(_QWORD *)(a1 + 56);
v5 = *(int *)(a1 + 64);
*(_DWORD *)(a1 + 64) = v5 + 1;
*(_QWORD *)(v4 + 8 * v5) = a2;
return 0LL;
}
}
return result;
}
| BC_add_object_ref1:
XOR EAX,EAX
CMP byte ptr [RDI + 0x36],0x0
JZ 0x001470c9
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV R8D,dword ptr [RDI + 0x40]
CMP dword ptr [RDI + 0x44],R8D
JLE 0x001470ca
LAB_001470ad:
MOV RAX,qword ptr [R14 + 0x38]
MOVSXD RCX,dword ptr [R14 + 0x40]
LEA EDX,[RCX + 0x1]
MOV dword ptr [R14 + 0x40],EDX
MOV qword ptr [RAX + RCX*0x8],RBX
XOR EAX,EAX
LAB_001470c2:
ADD RSP,0x8
POP RBX
POP R14
LAB_001470c9:
RET
LAB_001470ca:
LEA RSI,[R14 + 0x38]
LEA RCX,[R14 + 0x44]
INC R8D
MOV RDI,qword ptr [R14]
MOV EDX,0x8
CALL 0x001434ef
MOV ECX,EAX
MOV EAX,0xffffffff
TEST ECX,ECX
JNZ 0x001470c2
JMP 0x001470ad
|
int8 BC_add_object_ref1(int8 *param_1,int8 param_2)
{
int iVar1;
int8 in_R9;
if (*(char *)((long)param_1 + 0x36) != '\0') {
if ((*(int *)((long)param_1 + 0x44) <= *(int *)(param_1 + 8)) &&
(iVar1 = js_realloc_array(*param_1,param_1 + 7,8,(long)param_1 + 0x44,
*(int *)(param_1 + 8) + 1,in_R9,0), iVar1 != 0)) {
return 0xffffffff;
}
iVar1 = *(int *)(param_1 + 8);
*(int *)(param_1 + 8) = iVar1 + 1;
*(int8 *)(param_1[7] + (long)iVar1 * 8) = param_2;
}
return 0;
}
| |
25,004 | BC_add_object_ref1 | bluesky950520[P]quickjs/quickjs.c | static int BC_add_object_ref1(BCReaderState *s, JSObject *p)
{
if (s->allow_reference) {
if (js_resize_array(s->ctx, (void *)&s->objects,
sizeof(s->objects[0]),
&s->objects_size, s->objects_count + 1))
return -1;
s->objects[s->objects_count++] = p;
}
return 0;
} | O2 | c | BC_add_object_ref1:
pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
cmpb $0x0, 0x36(%rdi)
je 0x3d494
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
leaq 0x38(%r15), %rsi
leaq 0x44(%r15), %rcx
movl 0x40(%r15), %r8d
incl %r8d
pushq $0x8
popq %rdx
callq 0x3b0ef
testl %eax, %eax
je 0x3d481
pushq $-0x1
popq %rbx
jmp 0x3d494
movq 0x38(%r15), %rax
movslq 0x40(%r15), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x40(%r15)
movq %r14, (%rax,%rcx,8)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
| BC_add_object_ref1:
push r15
push r14
push rbx
xor ebx, ebx
cmp byte ptr [rdi+36h], 0
jz short loc_3D494
mov r14, rsi
mov r15, rdi
mov rdi, [rdi]
lea rsi, [r15+38h]
lea rcx, [r15+44h]
mov r8d, [r15+40h]
inc r8d
push 8
pop rdx
call js_resize_array
test eax, eax
jz short loc_3D481
push 0FFFFFFFFFFFFFFFFh
pop rbx
jmp short loc_3D494
loc_3D481:
mov rax, [r15+38h]
movsxd rcx, dword ptr [r15+40h]
lea edx, [rcx+1]
mov [r15+40h], edx
mov [rax+rcx*8], r14
loc_3D494:
mov eax, ebx
pop rbx
pop r14
pop r15
retn
| long long BC_add_object_ref1(long long a1, long long a2)
{
unsigned int v2; // ebx
long long v3; // rax
long long v4; // rcx
v2 = 0;
if ( *(_BYTE *)(a1 + 54) )
{
if ( (unsigned int)js_resize_array(*(_QWORD *)a1, a1 + 56, 8LL, (_DWORD *)(a1 + 68), *(_DWORD *)(a1 + 64) + 1) )
{
return (unsigned int)-1;
}
else
{
v3 = *(_QWORD *)(a1 + 56);
v4 = *(int *)(a1 + 64);
*(_DWORD *)(a1 + 64) = v4 + 1;
*(_QWORD *)(v3 + 8 * v4) = a2;
}
}
return v2;
}
| BC_add_object_ref1:
PUSH R15
PUSH R14
PUSH RBX
XOR EBX,EBX
CMP byte ptr [RDI + 0x36],0x0
JZ 0x0013d494
MOV R14,RSI
MOV R15,RDI
MOV RDI,qword ptr [RDI]
LEA RSI,[R15 + 0x38]
LEA RCX,[R15 + 0x44]
MOV R8D,dword ptr [R15 + 0x40]
INC R8D
PUSH 0x8
POP RDX
CALL 0x0013b0ef
TEST EAX,EAX
JZ 0x0013d481
PUSH -0x1
POP RBX
JMP 0x0013d494
LAB_0013d481:
MOV RAX,qword ptr [R15 + 0x38]
MOVSXD RCX,dword ptr [R15 + 0x40]
LEA EDX,[RCX + 0x1]
MOV dword ptr [R15 + 0x40],EDX
MOV qword ptr [RAX + RCX*0x8],R14
LAB_0013d494:
MOV EAX,EBX
POP RBX
POP R14
POP R15
RET
|
int4 BC_add_object_ref1(int8 *param_1,int8 param_2)
{
int iVar1;
int4 uVar2;
uVar2 = 0;
if (*(char *)((long)param_1 + 0x36) != '\0') {
iVar1 = js_resize_array(*param_1,param_1 + 7,8,(long)param_1 + 0x44,*(int *)(param_1 + 8) + 1);
if (iVar1 == 0) {
iVar1 = *(int *)(param_1 + 8);
*(int *)(param_1 + 8) = iVar1 + 1;
*(int8 *)(param_1[7] + (long)iVar1 * 8) = param_2;
}
else {
uVar2 = 0xffffffff;
}
}
return uVar2;
}
| |
25,005 | facebook::yoga::Style::computePadding(facebook::yoga::PhysicalEdge, facebook::yoga::Direction) const | yoga-mod/yoga/../yoga/style/Style.h | Style::Length computePadding(PhysicalEdge edge, Direction direction) const {
switch (edge) {
case PhysicalEdge::Left:
return computeLeftEdge(padding_, direction);
case PhysicalEdge::Top:
return computeTopEdge(padding_);
case PhysicalEdge::Right:
return computeRightEdge(padding_, direction);
case PhysicalEdge::Bottom:
return computeBottomEdge(padding_);
}
fatalWithMessage("Invalid physical edge");
} | O3 | c | facebook::yoga::Style::computePadding(facebook::yoga::PhysicalEdge, facebook::yoga::Direction) const:
pushq %rbp
movq %rsp, %rbp
cmpl $0x3, %esi
ja 0x7964f
movl %esi, %eax
leaq 0x320e94(%rip), %rcx # 0x39a498
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x30(%rdi), %rsi
movzbl %dl, %edx
callq 0x7965c
jmp 0x7963d
leaq 0x30(%rdi), %rsi
movzbl %dl, %edx
callq 0x796ec
jmp 0x7963d
leaq 0x30(%rdi), %rsi
callq 0x79740
jmp 0x7963d
leaq 0x30(%rdi), %rsi
callq 0x796ae
movabsq $0xffffffffff, %rcx # imm = 0xFFFFFFFFFF
andq %rax, %rcx
movq %rcx, %rax
popq %rbp
retq
leaq 0x320f51(%rip), %rdi # 0x39a5a7
callq 0x3710e2
nop
| _ZNK8facebook4yoga5Style14computePaddingENS0_12PhysicalEdgeENS0_9DirectionE:
push rbp
mov rbp, rsp
cmp esi, 3; switch 4 cases
ja short def_7960B; jumptable 000000000007960B default case
mov eax, esi
lea rcx, jpt_7960B
movsxd rax, ds:(jpt_7960B - 39A498h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_7960D:
lea rsi, [rdi+30h]; jumptable 000000000007960B case 0
movzx edx, dl
call _ZNK8facebook4yoga5Style15computeLeftEdgeERKSt5arrayINS0_16StyleValueHandleELm9EENS0_9DirectionE; facebook::yoga::Style::computeLeftEdge(std::array<facebook::yoga::StyleValueHandle,9ul> const&,facebook::yoga::Direction)
jmp short loc_7963D
loc_7961B:
lea rsi, [rdi+30h]; jumptable 000000000007960B case 2
movzx edx, dl
call _ZNK8facebook4yoga5Style16computeRightEdgeERKSt5arrayINS0_16StyleValueHandleELm9EENS0_9DirectionE; facebook::yoga::Style::computeRightEdge(std::array<facebook::yoga::StyleValueHandle,9ul> const&,facebook::yoga::Direction)
jmp short loc_7963D
loc_79629:
lea rsi, [rdi+30h]; jumptable 000000000007960B case 3
call _ZNK8facebook4yoga5Style17computeBottomEdgeERKSt5arrayINS0_16StyleValueHandleELm9EE; facebook::yoga::Style::computeBottomEdge(std::array<facebook::yoga::StyleValueHandle,9ul> const&)
jmp short loc_7963D
loc_79634:
lea rsi, [rdi+30h]; jumptable 000000000007960B case 1
call _ZNK8facebook4yoga5Style14computeTopEdgeERKSt5arrayINS0_16StyleValueHandleELm9EE; facebook::yoga::Style::computeTopEdge(std::array<facebook::yoga::StyleValueHandle,9ul> const&)
loc_7963D:
mov rcx, 0FFFFFFFFFFh
and rcx, rax
mov rax, rcx
pop rbp
retn
def_7960B:
lea rdi, aInvalidPhysica; jumptable 000000000007960B default case
call _ZN8facebook4yoga16fatalWithMessageEPKc; facebook::yoga::fatalWithMessage(char const*)
| long long facebook::yoga::Style::computePadding(long long a1, const char *a2, unsigned __int8 a3)
{
long long v3; // rax
switch ( (int)a2 )
{
case 0:
v3 = facebook::yoga::Style::computeLeftEdge(a1, a1 + 48, a3);
break;
case 1:
v3 = facebook::yoga::Style::computeTopEdge(a1, a1 + 48);
break;
case 2:
v3 = facebook::yoga::Style::computeRightEdge(a1, a1 + 48, a3);
break;
case 3:
v3 = facebook::yoga::Style::computeBottomEdge(a1, a1 + 48);
break;
default:
facebook::yoga::fatalWithMessage((facebook::yoga *)"Invalid physical edge", a2);
}
return v3 & 0xFFFFFFFFFFLL;
}
| computePadding:
PUSH RBP
MOV RBP,RSP
CMP ESI,0x3
JA 0x0017964f
MOV EAX,ESI
LEA RCX,[0x49a498]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
LEA RSI,[RDI + 0x30]
MOVZX EDX,DL
CALL 0x0017965c
JMP 0x0017963d
caseD_2:
LEA RSI,[RDI + 0x30]
MOVZX EDX,DL
CALL 0x001796ec
JMP 0x0017963d
caseD_3:
LEA RSI,[RDI + 0x30]
CALL 0x00179740
JMP 0x0017963d
caseD_1:
LEA RSI,[RDI + 0x30]
CALL 0x001796ae
LAB_0017963d:
MOV RCX,0xffffffffff
AND RCX,RAX
MOV RAX,RCX
POP RBP
RET
default:
LEA RDI,[0x49a5a7]
CALL 0x004710e2
|
/* facebook::yoga::Style::computePadding(facebook::yoga::PhysicalEdge, facebook::yoga::Direction)
const */
ulong __thiscall
facebook::yoga::Style::computePadding(Style *this,int4 param_2,int1 param_3)
{
ulong uVar1;
switch(param_2) {
case 0:
uVar1 = computeLeftEdge(this,this + 0x30,param_3);
break;
case 1:
uVar1 = computeTopEdge(this,(array *)(this + 0x30));
break;
case 2:
uVar1 = computeRightEdge(this,this + 0x30,param_3);
break;
case 3:
uVar1 = computeBottomEdge(this,(array *)(this + 0x30));
break;
default:
/* WARNING: Subroutine does not return */
fatalWithMessage("Invalid physical edge");
}
return uVar1 & 0xffffffffff;
}
| |
25,006 | intx::internal::udivrem_knuth(unsigned long*, unsigned long*, int, unsigned long const*, int) | corpus-core[P]colibri-stateless/build_O3/_deps/intx-src/include/intx/intx.hpp | inline void udivrem_knuth(
uint64_t q[], uint64_t u[], int ulen, const uint64_t d[], int dlen) noexcept
{
INTX_REQUIRE(dlen >= 3);
INTX_REQUIRE(ulen >= dlen);
const auto divisor = uint128{d[dlen - 2], d[dlen - 1]};
const auto reciprocal = reciprocal_3by2(divisor);
for (int j = ulen - dlen - 1; j >= 0; --j)
{
const auto u2 = u[j + dlen];
const auto u1 = u[j + dlen - 1];
const auto u0 = u[j + dlen - 2];
uint64_t qhat{};
if (INTX_UNLIKELY((uint128{u1, u2}) == divisor)) // Division overflows.
{
qhat = ~uint64_t{0};
u[j + dlen] = u2 - submul(&u[j], &u[j], d, dlen, qhat);
}
else
{
uint128 rhat;
std::tie(qhat, rhat) = udivrem_3by2(u2, u1, u0, divisor, reciprocal);
bool carry{};
const auto overflow = submul(&u[j], &u[j], d, dlen - 2, qhat);
std::tie(u[j + dlen - 2], carry) = subc(rhat[0], overflow);
std::tie(u[j + dlen - 1], carry) = subc(rhat[1], carry);
if (INTX_UNLIKELY(carry))
{
--qhat;
u[j + dlen - 1] += divisor[1] + add(&u[j], &u[j], d, dlen - 1);
}
}
q[j] = qhat; // Store quotient digit.
}
} | O3 | cpp | intx::internal::udivrem_knuth(unsigned long*, unsigned long*, int, unsigned long const*, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, 0x38(%rsp)
movq %rdi, 0x50(%rsp)
cmpl $0x2, %r8d
jle 0x3e492
movl %r8d, %ebx
movl %edx, %r12d
cmpl %r8d, %edx
jl 0x3e4b1
movq %rcx, %r14
leal -0x2(%rbx), %r15d
movq (%rcx,%r15,8), %r13
leal -0x1(%rbx), %eax
movq %rax, 0x40(%rsp)
movq (%rcx,%rax,8), %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0x3e4d0
movq %rax, 0x48(%rsp)
movq %rbx, 0x30(%rsp)
movl %ebx, %eax
notl %eax
addl %r12d, %eax
js 0x3e483
movq %r13, %r11
movl %eax, %r10d
movl 0x30(%rsp), %eax
movq 0x38(%rsp), %rcx
leaq (%rcx,%rax,8), %r9
leaq (%rcx,%r10,8), %r13
leaq 0x10(%rsp), %rbx
movq %r11, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq -0x8(%r9,%r10,8), %r8
movq (%r9,%r10,8), %rsi
movq %r8, %rax
xorq %r11, %rax
movq %rsi, %rcx
xorq %rbp, %rcx
orq %rax, %rcx
movq 0x38(%rsp), %rax
leaq (%rax,%r10,8), %rdi
movq %r10, 0x28(%rsp)
je 0x3e415
movq %rsi, %rax
mulq 0x48(%rsp)
movq %rax, %rcx
movq %rdx, %r12
xorl %r9d, %r9d
addq %r8, %rcx
movq 0x18(%rsp), %rax
movq -0x10(%rax,%r10,8), %r10
adcq %rsi, %r12
movq %r12, %rax
imulq %rbp, %rax
subq %rax, %r8
movq %r12, %rax
mulq %r11
movq %r9, 0x8(%rsp)
movq %r9, 0x10(%rsp)
movb $0x1, %sil
leaq 0x8(%rsp), %r11
movzbl %r9b, %r9d
btl $0x0, %r9d
sbbq %rax, %r10
setb %r9b
movq %r10, (%r11)
movq %rdx, %rax
movq %r8, %r10
movq %rbx, %r11
testb $0x1, %sil
movl $0x0, %esi
jne 0x3e294
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %rax
xorl %edx, %edx
movq %rdx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movb $0x1, %sil
movq 0x20(%rsp), %r11
movq %r11, %r9
leaq 0x8(%rsp), %r10
movzbl %dl, %edx
btl $0x0, %edx
sbbq %r9, %r8
setb %dl
movq %r8, (%r10)
movq %rbp, %r9
movq %rax, %r8
movq %rbx, %r10
testb $0x1, %sil
movl $0x0, %esi
jne 0x3e2e1
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %rsi
cmpq %rcx, %rsi
jae 0x3e319
incq %r12
jmp 0x3e35c
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movb $0x1, %cl
movq %r11, %rdx
leaq 0x8(%rsp), %r9
movzbl %al, %eax
btl $0x0, %eax
adcq %r8, %rdx
setb %al
movq %rdx, (%r9)
movq %rbp, %rdx
movq %rsi, %r8
movq %rbx, %r9
testb $0x1, %cl
movl $0x0, %ecx
jne 0x3e32f
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %rsi
cmpq %r11, %r8
movq %rsi, %rax
sbbq %rbp, %rax
jb 0x3e3ad
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movb $0x1, %cl
movq %r11, %rdx
leaq 0x8(%rsp), %r9
movzbl %al, %eax
btl $0x0, %eax
sbbq %rdx, %r8
setb %al
movq %r8, (%r9)
movq %rbp, %rdx
movq %rsi, %r8
movq %rbx, %r9
testb $0x1, %cl
movl $0x0, %ecx
jne 0x3e37d
incq %r12
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %rsi
xorl %ecx, %ecx
xorl %eax, %eax
movq (%r13,%rcx,8), %r9
xorl %r10d, %r10d
subq %rax, %r9
setb %r10b
movq %r12, %rax
mulq (%r14,%rcx,8)
subq %rax, %r9
movq %r9, (%r13,%rcx,8)
movq %r10, %rax
adcq %rdx, %rax
incq %rcx
cmpq %rcx, %r15
jne 0x3e3b1
subq %rax, %r8
movq 0x28(%rsp), %rdx
movq 0x18(%rsp), %r9
movq %r8, -0x10(%r9,%rdx,8)
sbbq $0x0, %rsi
movq %rsi, -0x8(%r9,%rdx,8)
jb 0x3e451
movq 0x50(%rsp), %rax
movq %r12, (%rax,%rdx,8)
leaq -0x1(%rdx), %r10
addq $-0x8, %r13
testl %edx, %edx
jg 0x3e225
jmp 0x3e483
movq $-0x1, %r12
movq %rdi, %rsi
movq %r14, %rdx
movq 0x30(%rsp), %rcx
movq $-0x1, %r8
callq 0x3e62a
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %r11
movq %rbp, %rcx
subq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax,%rdx,8)
movq %rax, %r9
jmp 0x3e3fa
decq %r12
movq %rdi, %rsi
movq %r14, %rdx
movq 0x40(%rsp), %rcx
callq 0x3e682
movq 0x18(%rsp), %r9
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %r11
movzbl %al, %eax
addq %rbp, %rax
addq %rax, -0x8(%r9,%rdx,8)
jmp 0x3e3fa
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x43885(%rip), %rdi # 0x81d1e
leaq 0x4370e(%rip), %rsi # 0x81bae
leaq 0x43881(%rip), %rcx # 0x81d28
movl $0x68e, %edx # imm = 0x68E
callq 0x21130
leaq 0x438c7(%rip), %rdi # 0x81d7f
leaq 0x436ef(%rip), %rsi # 0x81bae
leaq 0x43862(%rip), %rcx # 0x81d28
movl $0x68f, %edx # imm = 0x68F
callq 0x21130
| _ZN4intx8internal13udivrem_knuthEPmS1_iPKmi:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov [rsp+88h+var_50], rsi
mov [rsp+88h+var_38], rdi
cmp r8d, 2
jle loc_3E492
mov ebx, r8d
mov r12d, edx
cmp edx, r8d
jl loc_3E4B1
mov r14, rcx
lea r15d, [rbx-2]
mov r13, [rcx+r15*8]
lea eax, [rbx-1]
mov [rsp+88h+var_48], rax
mov rbp, [rcx+rax*8]
mov rdi, r13
mov rsi, rbp
call _ZN4intx15reciprocal_3by2ENS_4uintILj128EEE; intx::reciprocal_3by2(intx::uint<128u>)
mov [rsp+88h+var_40], rax
mov [rsp+88h+var_58], rbx
mov eax, ebx
not eax
add eax, r12d
js loc_3E483
mov r11, r13
mov r10d, eax
mov eax, dword ptr [rsp+88h+var_58]
mov rcx, [rsp+88h+var_50]
lea r9, [rcx+rax*8]; unsigned __int64
lea r13, [rcx+r10*8]
lea rbx, [rsp+88h+var_78]
mov [rsp+88h+var_68], r11
mov [rsp+88h+var_70], r9
loc_3E225:
mov r8, [r9+r10*8-8]
mov rsi, [r9+r10*8]
mov rax, r8
xor rax, r11
mov rcx, rsi
xor rcx, rbp
or rcx, rax
mov rax, [rsp+88h+var_50]
lea rdi, [rax+r10*8]; this
mov [rsp+88h+var_60], r10
jz loc_3E415
mov rax, rsi
mul [rsp+88h+var_40]
mov rcx, rax
mov r12, rdx
xor r9d, r9d
add rcx, r8
mov rax, [rsp+88h+var_70]
mov r10, [rax+r10*8-10h]
adc r12, rsi
mov rax, r12
imul rax, rbp
sub r8, rax
mov rax, r12
mul r11
mov [rsp+88h+var_80], r9
mov [rsp+88h+var_78], r9
mov sil, 1
lea r11, [rsp+88h+var_80]
loc_3E294:
movzx r9d, r9b
bt r9d, 0
sbb r10, rax
setb r9b
mov [r11], r10
mov rax, rdx
mov r10, r8
mov r11, rbx
test sil, 1
mov esi, 0
jnz short loc_3E294
mov r8, [rsp+88h+var_80]
mov rax, [rsp+88h+var_78]
xor edx, edx
mov [rsp+88h+var_80], rdx
mov [rsp+88h+var_78], rdx
mov sil, 1
mov r11, [rsp+88h+var_68]
mov r9, r11
lea r10, [rsp+88h+var_80]
loc_3E2E1:
movzx edx, dl
bt edx, 0
sbb r8, r9
setb dl
mov [r10], r8
mov r9, rbp
mov r8, rax
mov r10, rbx
test sil, 1
mov esi, 0
jnz short loc_3E2E1
mov r8, [rsp+88h+var_80]
mov rsi, [rsp+88h+var_78]
cmp rsi, rcx
jnb short loc_3E319
inc r12
jmp short loc_3E35C
loc_3E319:
xor eax, eax
mov [rsp+88h+var_80], rax
mov [rsp+88h+var_78], rax
mov cl, 1
mov rdx, r11
lea r9, [rsp+88h+var_80]
loc_3E32F:
movzx eax, al
bt eax, 0
adc rdx, r8
setb al
mov [r9], rdx
mov rdx, rbp
mov r8, rsi
mov r9, rbx
test cl, 1
mov ecx, 0
jnz short loc_3E32F
mov r8, [rsp+88h+var_80]
mov rsi, [rsp+88h+var_78]
loc_3E35C:
cmp r8, r11
mov rax, rsi
sbb rax, rbp
jb short loc_3E3AD
xor eax, eax
mov [rsp+88h+var_80], rax
mov [rsp+88h+var_78], rax
mov cl, 1
mov rdx, r11
lea r9, [rsp+88h+var_80]
loc_3E37D:
movzx eax, al
bt eax, 0
sbb r8, rdx
setb al
mov [r9], r8
mov rdx, rbp
mov r8, rsi
mov r9, rbx
test cl, 1
mov ecx, 0
jnz short loc_3E37D
inc r12
mov r8, [rsp+88h+var_80]
mov rsi, [rsp+88h+var_78]
loc_3E3AD:
xor ecx, ecx
xor eax, eax
loc_3E3B1:
mov r9, [r13+rcx*8+0]
xor r10d, r10d
sub r9, rax
setb r10b
mov rax, r12
mul qword ptr [r14+rcx*8]
sub r9, rax
mov [r13+rcx*8+0], r9
mov rax, r10
adc rax, rdx
inc rcx
cmp r15, rcx
jnz short loc_3E3B1
sub r8, rax; int
mov rdx, [rsp+88h+var_60]
mov r9, [rsp+88h+var_70]
mov [r9+rdx*8-10h], r8
sbb rsi, 0
mov [r9+rdx*8-8], rsi
jb short loc_3E451
loc_3E3FA:
mov rax, [rsp+88h+var_38]
mov [rax+rdx*8], r12
lea r10, [rdx-1]
add r13, 0FFFFFFFFFFFFFFF8h
test edx, edx
jg loc_3E225
jmp short loc_3E483
loc_3E415:
mov r12, 0FFFFFFFFFFFFFFFFh
mov rsi, rdi; unsigned __int64 *
mov rdx, r14; unsigned __int64 *
mov rcx, [rsp+88h+var_58]; unsigned __int64 *
mov r8, 0FFFFFFFFFFFFFFFFh; int
call _ZN4intx8internal6submulEPmPKmS3_im; intx::internal::submul(ulong *,ulong const*,ulong const*,int,ulong)
mov rdx, [rsp+88h+var_60]
mov r11, [rsp+88h+var_68]
mov rcx, rbp
sub rcx, rax
mov rax, [rsp+88h+var_70]
mov [rax+rdx*8], rcx
mov r9, rax
jmp short loc_3E3FA
loc_3E451:
dec r12
mov rsi, rdi; unsigned __int64 *
mov rdx, r14; unsigned __int64 *
mov rcx, [rsp+88h+var_48]; unsigned __int64 *
call _ZN4intx8internal3addEPmPKmS3_i; intx::internal::add(ulong *,ulong const*,ulong const*,int)
mov r9, [rsp+88h+var_70]
mov rdx, [rsp+88h+var_60]
mov r11, [rsp+88h+var_68]
movzx eax, al
add rax, rbp
add [r9+rdx*8-8], rax
jmp loc_3E3FA
loc_3E483:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3E492:
lea rdi, aDlen3; "dlen >= 3"
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidIntxIntern; "void intx::internal::udivrem_knuth(uint"...
mov edx, 68Eh
call ___assert_fail
loc_3E4B1:
lea rdi, aUlenDlen; "ulen >= dlen"
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidIntxIntern; "void intx::internal::udivrem_knuth(uint"...
mov edx, 68Fh
call ___assert_fail
| intx::internal * intx::internal::udivrem_knuth(
intx::internal *this,
unsigned long long *a2,
unsigned long long *a3,
const unsigned long long *a4,
const unsigned long long *a5)
{
unsigned long long *v5; // rbx
int v6; // r12d
long long v8; // r15
unsigned long long v9; // r13
unsigned long long v10; // rbp
intx::internal *result; // rax
unsigned long long v12; // r11
long long v13; // r10
unsigned long long v14; // r9
unsigned long long *v15; // r13
unsigned long long v16; // r8
unsigned long long v17; // rsi
intx::internal *v18; // rdi
bool v19; // r9
long long v20; // r12
unsigned __int128 v21; // kr00_16
unsigned long long v22; // r10
unsigned long long v23; // r8
unsigned __int128 v24; // rax
char v25; // si
unsigned long long *v26; // r11
bool v27; // cf
unsigned long long v28; // r10
bool v29; // zf
unsigned long long v30; // r8
unsigned long long v31; // rax
bool v32; // dl
char v33; // si
unsigned long long v34; // r9
unsigned long long *v35; // r10
unsigned long long v36; // r8
unsigned long long v37; // r8
unsigned long long v38; // rsi
char v39; // al
char v40; // cl
unsigned long long v41; // rdx
unsigned long long *v42; // r9
unsigned long long v43; // rdx
bool v44; // al
char v45; // cl
unsigned long long v46; // rdx
unsigned long long *v47; // r9
unsigned long long v48; // r8
long long v49; // rcx
unsigned long long v50; // rax
unsigned long long v51; // r9
unsigned long long v52; // r9
unsigned __int128 v53; // rax
unsigned long long v54; // r8
long long v55; // rdx
long long v56; // rax
unsigned long long v57; // rcx
unsigned long long v58; // rax
unsigned __int8 v59; // al
unsigned long long v60; // [rsp+8h] [rbp-80h] BYREF
unsigned long long v61; // [rsp+10h] [rbp-78h] BYREF
unsigned long long v62; // [rsp+18h] [rbp-70h]
unsigned long long v63; // [rsp+20h] [rbp-68h]
long long v64; // [rsp+28h] [rbp-60h]
unsigned long long *v65; // [rsp+30h] [rbp-58h]
unsigned long long *v66; // [rsp+38h] [rbp-50h]
unsigned long long *v67; // [rsp+40h] [rbp-48h]
long long v68; // [rsp+48h] [rbp-40h]
intx::internal *v69; // [rsp+50h] [rbp-38h]
v66 = a2;
v69 = this;
if ( (int)a5 <= 2 )
__assert_fail(
"dlen >= 3",
"/workspace/llm4binary/github/2025_star3/corpus-core[P]colibri-stateless/build_O3/_deps/intx-src/include/intx/intx.hpp",
1678LL,
"void intx::internal::udivrem_knuth(uint64_t *, uint64_t *, int, const uint64_t *, int)");
v5 = (unsigned long long *)(unsigned int)a5;
v6 = (int)a3;
if ( (int)a3 < (int)a5 )
__assert_fail(
"ulen >= dlen",
"/workspace/llm4binary/github/2025_star3/corpus-core[P]colibri-stateless/build_O3/_deps/intx-src/include/intx/intx.hpp",
1679LL,
"void intx::internal::udivrem_knuth(uint64_t *, uint64_t *, int, const uint64_t *, int)");
v8 = (unsigned int)((_DWORD)a5 - 2);
v9 = a4[v8];
v67 = (unsigned long long *)(unsigned int)((_DWORD)a5 - 1);
v10 = a4[(_QWORD)v67];
v68 = intx::reciprocal_3by2(v9, v10);
v65 = v5;
result = (intx::internal *)(unsigned int)(v6 + ~(_DWORD)v5);
if ( v6 + ~(_DWORD)v5 >= 0 )
{
v12 = v9;
v13 = (unsigned int)result;
v14 = (unsigned long long)&v66[(unsigned int)v65];
v15 = &v66[(unsigned int)result];
v63 = v12;
v62 = v14;
do
{
v16 = *(_QWORD *)(v14 + 8 * v13 - 8);
v17 = *(_QWORD *)(v14 + 8 * v13);
v18 = (intx::internal *)&v66[v13];
v64 = v13;
if ( v12 ^ v16 | v10 ^ v17 )
{
v19 = 0;
v22 = *(_QWORD *)(v62 + 8 * v13 - 16);
v21 = __PAIR128__(v17, v16) + (unsigned long long)v68 * (unsigned __int128)v17;
v20 = *((_QWORD *)&v21 + 1);
v23 = v16 - v10 * *((_QWORD *)&v21 + 1);
v24 = v12 * (unsigned __int128)*((unsigned long long *)&v21 + 1);
v60 = 0LL;
v61 = 0LL;
v25 = 1;
v26 = &v60;
do
{
v27 = v22 < v19 + (unsigned long long)v24;
v28 = v22 - (v19 + (_QWORD)v24);
v19 = v27;
*v26 = v28;
*(_QWORD *)&v24 = *((_QWORD *)&v24 + 1);
v22 = v23;
v26 = &v61;
v29 = (v25 & 1) == 0;
v25 = 0;
}
while ( !v29 );
v30 = v60;
v31 = v61;
v32 = 0;
v60 = 0LL;
v61 = 0LL;
v33 = 1;
v12 = v63;
v34 = v63;
v35 = &v60;
do
{
v27 = v30 < v32 + v34;
v36 = v30 - (v32 + v34);
v32 = v27;
*v35 = v36;
v34 = v10;
v30 = v31;
v35 = &v61;
v29 = (v33 & 1) == 0;
v33 = 0;
}
while ( !v29 );
v37 = v60;
v38 = v61;
if ( v61 >= (unsigned long long)v21 )
{
v39 = 0;
v60 = 0LL;
v61 = 0LL;
v40 = 1;
v41 = v12;
v42 = &v60;
do
{
v27 = __CFADD__((v39 & 1) != 0, v41);
v43 = ((v39 & 1) != 0) + v41;
v39 = v27 | __CFADD__(v37, v43);
*v42 = v37 + v43;
v41 = v10;
v37 = v38;
v42 = &v61;
v29 = (v40 & 1) == 0;
v40 = 0;
}
while ( !v29 );
v37 = v60;
v38 = v61;
}
else
{
v20 = *((_QWORD *)&v21 + 1) + 1LL;
}
if ( __PAIR128__(v38, v37) >= __PAIR128__(v10, v12) )
{
v44 = 0;
v60 = 0LL;
v61 = 0LL;
v45 = 1;
v46 = v12;
v47 = &v60;
do
{
v27 = v37 < v44 + v46;
v48 = v37 - (v44 + v46);
v44 = v27;
*v47 = v48;
v46 = v10;
v37 = v38;
v47 = &v61;
v29 = (v45 & 1) == 0;
v45 = 0;
}
while ( !v29 );
++v20;
v37 = v60;
v38 = v61;
}
v49 = 0LL;
v50 = 0LL;
do
{
v51 = v15[v49];
v27 = v51 < v50;
v52 = v51 - v50;
v53 = a4[v49] * (unsigned __int128)(unsigned long long)v20;
v15[v49] = v52 - v53;
v50 = *((_QWORD *)&v53 + 1) + (v52 < (unsigned long long)v53) + (unsigned long long)v27;
++v49;
}
while ( v8 != v49 );
v27 = v37 < v50;
v54 = v37 - v50;
v55 = v64;
v14 = v62;
*(_QWORD *)(v62 + 8 * v64 - 16) = v54;
*(_QWORD *)(v14 + 8 * v55 - 8) = v38 - v27;
if ( v38 < v27 )
{
--v20;
v59 = intx::internal::add(v18, (unsigned long long *)v18, a4, v67, v54);
v14 = v62;
v55 = v64;
v12 = v63;
*(_QWORD *)(v62 + 8 * v64 - 8) += v10 + v59;
}
}
else
{
v20 = -1LL;
v56 = intx::internal::submul(v18, &v66[v13], a4, v65, -1, v14);
v55 = v64;
v12 = v63;
v57 = v10 - v56;
v58 = v62;
*(_QWORD *)(v62 + 8 * v64) = v57;
v14 = v58;
}
result = v69;
*((_QWORD *)v69 + v55) = v20;
v13 = v55 - 1;
--v15;
}
while ( (int)v55 > 0 );
}
return result;
}
| udivrem_knuth:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RSP + 0x38],RSI
MOV qword ptr [RSP + 0x50],RDI
CMP R8D,0x2
JLE 0x0013e492
MOV EBX,R8D
MOV R12D,EDX
CMP EDX,R8D
JL 0x0013e4b1
MOV R14,RCX
LEA R15D,[RBX + -0x2]
MOV R13,qword ptr [RCX + R15*0x8]
LEA EAX,[RBX + -0x1]
MOV qword ptr [RSP + 0x40],RAX
MOV RBP,qword ptr [RCX + RAX*0x8]
MOV RDI,R13
MOV RSI,RBP
CALL 0x0013e4d0
MOV qword ptr [RSP + 0x48],RAX
MOV qword ptr [RSP + 0x30],RBX
MOV EAX,EBX
NOT EAX
ADD EAX,R12D
JS 0x0013e483
MOV R11,R13
MOV R10D,EAX
MOV EAX,dword ptr [RSP + 0x30]
MOV RCX,qword ptr [RSP + 0x38]
LEA R9,[RCX + RAX*0x8]
LEA R13,[RCX + R10*0x8]
LEA RBX,[RSP + 0x10]
MOV qword ptr [RSP + 0x20],R11
MOV qword ptr [RSP + 0x18],R9
LAB_0013e225:
MOV R8,qword ptr [R9 + R10*0x8 + -0x8]
MOV RSI,qword ptr [R9 + R10*0x8]
MOV RAX,R8
XOR RAX,R11
MOV RCX,RSI
XOR RCX,RBP
OR RCX,RAX
MOV RAX,qword ptr [RSP + 0x38]
LEA RDI,[RAX + R10*0x8]
MOV qword ptr [RSP + 0x28],R10
JZ 0x0013e415
MOV RAX,RSI
MUL qword ptr [RSP + 0x48]
MOV RCX,RAX
MOV R12,RDX
XOR R9D,R9D
ADD RCX,R8
MOV RAX,qword ptr [RSP + 0x18]
MOV R10,qword ptr [RAX + R10*0x8 + -0x10]
ADC R12,RSI
MOV RAX,R12
IMUL RAX,RBP
SUB R8,RAX
MOV RAX,R12
MUL R11
MOV qword ptr [RSP + 0x8],R9
MOV qword ptr [RSP + 0x10],R9
MOV SIL,0x1
LEA R11,[RSP + 0x8]
LAB_0013e294:
MOVZX R9D,R9B
BT R9D,0x0
SBB R10,RAX
SETC R9B
MOV qword ptr [R11],R10
MOV RAX,RDX
MOV R10,R8
MOV R11,RBX
TEST SIL,0x1
MOV ESI,0x0
JNZ 0x0013e294
MOV R8,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x10]
XOR EDX,EDX
MOV qword ptr [RSP + 0x8],RDX
MOV qword ptr [RSP + 0x10],RDX
MOV SIL,0x1
MOV R11,qword ptr [RSP + 0x20]
MOV R9,R11
LEA R10,[RSP + 0x8]
LAB_0013e2e1:
MOVZX EDX,DL
BT EDX,0x0
SBB R8,R9
SETC DL
MOV qword ptr [R10],R8
MOV R9,RBP
MOV R8,RAX
MOV R10,RBX
TEST SIL,0x1
MOV ESI,0x0
JNZ 0x0013e2e1
MOV R8,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x10]
CMP RSI,RCX
JNC 0x0013e319
INC R12
JMP 0x0013e35c
LAB_0013e319:
XOR EAX,EAX
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RAX
MOV CL,0x1
MOV RDX,R11
LEA R9,[RSP + 0x8]
LAB_0013e32f:
MOVZX EAX,AL
BT EAX,0x0
ADC RDX,R8
SETC AL
MOV qword ptr [R9],RDX
MOV RDX,RBP
MOV R8,RSI
MOV R9,RBX
TEST CL,0x1
MOV ECX,0x0
JNZ 0x0013e32f
MOV R8,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x10]
LAB_0013e35c:
CMP R8,R11
MOV RAX,RSI
SBB RAX,RBP
JC 0x0013e3ad
XOR EAX,EAX
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RAX
MOV CL,0x1
MOV RDX,R11
LEA R9,[RSP + 0x8]
LAB_0013e37d:
MOVZX EAX,AL
BT EAX,0x0
SBB R8,RDX
SETC AL
MOV qword ptr [R9],R8
MOV RDX,RBP
MOV R8,RSI
MOV R9,RBX
TEST CL,0x1
MOV ECX,0x0
JNZ 0x0013e37d
INC R12
MOV R8,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x10]
LAB_0013e3ad:
XOR ECX,ECX
XOR EAX,EAX
LAB_0013e3b1:
MOV R9,qword ptr [R13 + RCX*0x8]
XOR R10D,R10D
SUB R9,RAX
SETC R10B
MOV RAX,R12
MUL qword ptr [R14 + RCX*0x8]
SUB R9,RAX
MOV qword ptr [R13 + RCX*0x8],R9
MOV RAX,R10
ADC RAX,RDX
INC RCX
CMP R15,RCX
JNZ 0x0013e3b1
SUB R8,RAX
MOV RDX,qword ptr [RSP + 0x28]
MOV R9,qword ptr [RSP + 0x18]
MOV qword ptr [R9 + RDX*0x8 + -0x10],R8
SBB RSI,0x0
MOV qword ptr [R9 + RDX*0x8 + -0x8],RSI
JC 0x0013e451
LAB_0013e3fa:
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RAX + RDX*0x8],R12
LEA R10,[RDX + -0x1]
ADD R13,-0x8
TEST EDX,EDX
JG 0x0013e225
JMP 0x0013e483
LAB_0013e415:
MOV R12,-0x1
MOV RSI,RDI
MOV RDX,R14
MOV RCX,qword ptr [RSP + 0x30]
MOV R8,-0x1
CALL 0x0013e62a
MOV RDX,qword ptr [RSP + 0x28]
MOV R11,qword ptr [RSP + 0x20]
MOV RCX,RBP
SUB RCX,RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + RDX*0x8],RCX
MOV R9,RAX
JMP 0x0013e3fa
LAB_0013e451:
DEC R12
MOV RSI,RDI
MOV RDX,R14
MOV RCX,qword ptr [RSP + 0x40]
CALL 0x0013e682
MOV R9,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x28]
MOV R11,qword ptr [RSP + 0x20]
MOVZX EAX,AL
ADD RAX,RBP
ADD qword ptr [R9 + RDX*0x8 + -0x8],RAX
JMP 0x0013e3fa
LAB_0013e483:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013e492:
LEA RDI,[0x181d1e]
LEA RSI,[0x181bae]
LEA RCX,[0x181d28]
MOV EDX,0x68e
CALL 0x00121130
LAB_0013e4b1:
LEA RDI,[0x181d7f]
LEA RSI,[0x181bae]
LEA RCX,[0x181d28]
MOV EDX,0x68f
CALL 0x00121130
|
/* intx::internal::udivrem_knuth(unsigned long*, unsigned long*, int, unsigned long const*, int) */
void intx::internal::udivrem_knuth
(ulong *param_1,ulong *param_2,int param_3,ulong *param_4,int param_5)
{
ulong *puVar1;
intx *piVar2;
int1 auVar3 [16];
int1 auVar4 [16];
int1 auVar5 [16];
int1 auVar6 [16];
int1 auVar7 [16];
int1 auVar8 [16];
int1 auVar9 [16];
intx *piVar10;
bool bVar11;
byte bVar12;
uint uVar13;
ulong uVar14;
intx *piVar15;
long lVar16;
ulong uVar17;
int iVar18;
intx *piVar19;
bool bVar20;
intx *piVar21;
intx *piVar22;
intx **ppiVar23;
ulong uVar24;
ulong uVar25;
ulong *puVar26;
bool bVar27;
intx *local_80;
intx *local_78;
ulong *local_70;
intx *local_68;
ulong local_60;
ulong local_58;
ulong *local_50;
ulong local_48;
ulong local_40;
ulong *local_38;
local_50 = param_2;
local_38 = param_1;
if (param_5 < 3) {
/* WARNING: Subroutine does not return */
__assert_fail("dlen >= 3",
"/workspace/llm4binary/github/2025_star3/corpus-core[P]colibri-stateless/build_O3/_deps/intx-src/include/intx/intx.hpp"
,0x68e,
"void intx::internal::udivrem_knuth(uint64_t *, uint64_t *, int, const uint64_t *, int)"
);
}
if (param_3 < param_5) {
/* WARNING: Subroutine does not return */
__assert_fail("ulen >= dlen",
"/workspace/llm4binary/github/2025_star3/corpus-core[P]colibri-stateless/build_O3/_deps/intx-src/include/intx/intx.hpp"
,0x68f,
"void intx::internal::udivrem_knuth(uint64_t *, uint64_t *, int, const uint64_t *, int)"
);
}
piVar15 = (intx *)param_4[param_5 - 2];
local_48 = (ulong)(param_5 - 1);
piVar2 = (intx *)param_4[local_48];
local_40 = reciprocal_3by2(piVar15,piVar2);
uVar13 = ~param_5 + param_3;
if (-1 < (int)uVar13) {
local_70 = local_50 + (uint)param_5;
puVar26 = local_50 + uVar13;
local_60 = (ulong)uVar13;
local_68 = piVar15;
local_58 = (ulong)(uint)param_5;
do {
piVar15 = (intx *)local_70[local_60 - 1];
piVar21 = (intx *)local_70[local_60];
auVar9._8_8_ = piVar21;
auVar9._0_8_ = piVar15;
puVar1 = local_50 + local_60;
if (piVar21 == piVar2 && piVar15 == local_68) {
uVar25 = 0xffffffffffffffff;
lVar16 = submul(puVar1,puVar1,param_4,(int)local_58,0xffffffffffffffff);
local_70[local_60] = (long)piVar2 - lVar16;
}
else {
auVar3._8_8_ = 0;
auVar3._0_8_ = piVar21;
auVar6._8_8_ = 0;
auVar6._0_8_ = local_40;
bVar27 = false;
auVar9 = auVar3 * auVar6 + auVar9;
uVar25 = auVar9._8_8_;
auVar4._8_8_ = 0;
auVar4._0_8_ = uVar25;
auVar7._8_8_ = 0;
auVar7._0_8_ = local_68;
local_80 = (intx *)0x0;
local_78 = (intx *)0x0;
uVar17 = SUB168(auVar4 * auVar7,0);
uVar14 = local_70[local_60 - 2];
ppiVar23 = &local_80;
bVar11 = true;
do {
bVar20 = bVar11;
uVar24 = (ulong)bVar27;
bVar27 = uVar14 < uVar17 || uVar14 - uVar17 < uVar24;
*ppiVar23 = (intx *)((uVar14 - uVar17) - uVar24);
piVar19 = local_78;
piVar21 = local_80;
uVar17 = SUB168(auVar4 * auVar7,8);
uVar14 = (long)piVar15 - uVar25 * (long)piVar2;
ppiVar23 = &local_78;
bVar11 = false;
} while (bVar20);
bVar27 = false;
local_80 = (intx *)0x0;
local_78 = (intx *)0x0;
piVar15 = local_68;
ppiVar23 = &local_80;
bVar11 = true;
do {
bVar20 = bVar11;
uVar17 = (ulong)bVar27;
bVar27 = piVar21 < piVar15 || (ulong)((long)piVar21 - (long)piVar15) < uVar17;
*ppiVar23 = (intx *)(((long)piVar21 - (long)piVar15) - uVar17);
piVar10 = local_78;
piVar22 = local_80;
piVar21 = piVar19;
piVar15 = piVar2;
ppiVar23 = &local_78;
bVar11 = false;
} while (bVar20);
if (local_78 < auVar9._0_8_) {
uVar25 = uVar25 + 1;
}
else {
bVar27 = false;
local_80 = (intx *)0x0;
local_78 = (intx *)0x0;
piVar15 = local_68;
ppiVar23 = &local_80;
bVar11 = true;
do {
bVar20 = bVar11;
uVar17 = (ulong)bVar27;
bVar27 = CARRY8((ulong)piVar15,(ulong)piVar22) ||
CARRY8((ulong)(piVar15 + (long)piVar22),uVar17);
*ppiVar23 = piVar15 + (long)piVar22 + uVar17;
piVar15 = piVar2;
piVar22 = piVar10;
ppiVar23 = &local_78;
bVar11 = false;
} while (bVar20);
}
piVar21 = local_78;
piVar15 = local_80;
if (piVar2 <= local_78 &&
(ulong)(local_80 < local_68) <= (ulong)((long)local_78 - (long)piVar2)) {
bVar27 = false;
local_80 = (intx *)0x0;
local_78 = (intx *)0x0;
piVar19 = local_68;
ppiVar23 = &local_80;
bVar11 = true;
do {
bVar20 = bVar11;
uVar17 = (ulong)bVar27;
bVar27 = piVar15 < piVar19 || (ulong)((long)piVar15 - (long)piVar19) < uVar17;
*ppiVar23 = (intx *)(((long)piVar15 - (long)piVar19) - uVar17);
piVar19 = piVar2;
piVar15 = piVar21;
ppiVar23 = &local_78;
bVar11 = false;
} while (bVar20);
uVar25 = uVar25 + 1;
}
uVar17 = 0;
piVar15 = (intx *)0x0;
do {
piVar21 = (intx *)puVar26[uVar17];
uVar24 = (long)piVar21 - (long)piVar15;
auVar5._8_8_ = 0;
auVar5._0_8_ = uVar25;
auVar8._8_8_ = 0;
auVar8._0_8_ = param_4[uVar17];
uVar14 = SUB168(auVar5 * auVar8,0);
puVar26[uVar17] = uVar24 - uVar14;
piVar15 = (intx *)((ulong)(piVar21 < piVar15) + SUB168(auVar5 * auVar8,8) +
(ulong)(uVar24 < uVar14));
uVar17 = uVar17 + 1;
} while (param_5 - 2 != uVar17);
local_70[local_60 - 2] = (long)local_80 - (long)piVar15;
local_70[local_60 - 1] = (long)local_78 - (long)(ulong)(local_80 < piVar15);
if (local_78 < (intx *)(ulong)(local_80 < piVar15)) {
uVar25 = uVar25 - 1;
bVar12 = add(puVar1,puVar1,param_4,(int)local_48);
local_70[local_60 - 1] = (ulong)(piVar2 + local_70[local_60 - 1] + (ulong)bVar12);
}
}
local_38[local_60] = uVar25;
puVar26 = puVar26 + -1;
iVar18 = (int)local_60;
local_60 = local_60 - 1;
} while (0 < iVar18);
}
return;
}
| |
25,007 | tree_delete | eloqsql/mysys/tree.c | int tree_delete(TREE *tree, void *key, uint key_size, void *custom_arg)
{
int cmp,remove_colour;
TREE_ELEMENT *element,***parent, ***org_parent, *nod;
if (!tree->with_delete)
return 1; /* not allowed */
parent= tree->parents;
*parent= &tree->root; element= tree->root;
for (;;)
{
if (element == &null_element)
return 1; /* Was not in tree */
if ((cmp = (*tree->compare)(custom_arg, ELEMENT_KEY(tree,element),
key)) == 0)
break;
if (cmp < 0)
{
*++parent= &element->right; element= element->right;
}
else
{
*++parent = &element->left; element= element->left;
}
}
if (element->left == &null_element)
{
(**parent)=element->right;
remove_colour= element->colour;
}
else if (element->right == &null_element)
{
(**parent)=element->left;
remove_colour= element->colour;
}
else
{
org_parent= parent;
*++parent= &element->right; nod= element->right;
while (nod->left != &null_element)
{
*++parent= &nod->left; nod= nod->left;
}
(**parent)=nod->right; /* unlink nod from tree */
remove_colour= nod->colour;
org_parent[0][0]=nod; /* put y in place of element */
org_parent[1]= &nod->right;
nod->left=element->left;
nod->right=element->right;
nod->colour=element->colour;
}
if (remove_colour == BLACK)
rb_delete_fixup(tree,parent);
if (tree->free)
(*tree->free)(ELEMENT_KEY(tree,element), free_free, tree->custom_arg);
tree->allocated-= sizeof(TREE_ELEMENT) + tree->size_of_element + key_size;
my_free(element);
tree->elements_in_tree--;
return 0;
} | O3 | c | tree_delete:
movl $0x1, %eax
cmpb $0x0, 0x278(%rdi)
je 0xa7e49
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r13
movq %rdi, %rcx
movq %rdi, 0x8(%rdi)
movq (%rdi), %r15
leaq 0x2e1102(%rip), %rbx # 0x388c00
cmpq %rbx, %r15
je 0xa7e3b
movq %rsi, %r14
movl %edx, -0x34(%rbp)
leaq 0x10(%rcx), %r12
movq %rcx, -0x30(%rbp)
movl 0x208(%rcx), %esi
testq %rsi, %rsi
je 0xa7b25
addq %r15, %rsi
jmp 0xa7b29
movq 0x18(%r15), %rsi
movq %r13, %rdi
movq %r14, %rdx
callq *0x228(%rcx)
testl %eax, %eax
je 0xa7b5e
shrl $0x1f, %eax
leaq (%r15,%rax,8), %rax
movq %rax, (%r12)
movq (%rax), %r15
addq $0x8, %r12
cmpq %rbx, %r15
movq -0x30(%rbp), %rcx
jne 0xa7b15
movl $0x1, %eax
jmp 0xa7e3b
movq (%r15), %rcx
movq 0x8(%r15), %rdx
leaq -0x8(%r12), %rax
cmpq %rbx, %rcx
movq -0x30(%rbp), %r9
je 0xa7ba0
cmpq %rbx, %rdx
je 0xa7ba8
leaq 0x8(%r15), %rdx
movq %rdx, (%r12)
movq (%rdx), %rcx
cmpq %rbx, (%rcx)
je 0xa7bb4
movq %r12, %rax
movq %rcx, %rdx
movq %rcx, 0x8(%rax)
addq $0x8, %rax
movq (%rcx), %rcx
cmpq %rbx, (%rcx)
jne 0xa7b8b
jmp 0xa7bb7
movq (%rax), %rcx
movq %rdx, (%rcx)
jmp 0xa7bae
movq (%rax), %rdx
movq %rcx, (%rdx)
movl 0x10(%r15), %edx
jmp 0xa7bf5
movq %r12, %rax
leaq 0x8(%rcx), %rsi
movq 0x8(%rcx), %rdi
movq %rdi, (%rdx)
movl 0x10(%rcx), %edx
movq -0x8(%r12), %rdi
movq %rcx, (%rdi)
movq %rsi, (%r12)
movq (%r15), %rsi
movq %rsi, (%rcx)
movq 0x8(%r15), %rsi
movq %rsi, 0x8(%rcx)
movl $0x80000000, %esi # imm = 0x80000000
andl 0x10(%r15), %esi
movl $0x7fffffff, %edi # imm = 0x7FFFFFFF
andl 0x10(%rcx), %edi
orl %esi, %edi
movl %edi, 0x10(%rcx)
testl %edx, %edx
movl -0x34(%rbp), %r14d
jns 0xa7dd0
movq (%rax), %rcx
movq (%rcx), %rsi
cmpq (%r9), %rsi
je 0xa7cfc
cmpl $0x0, 0x10(%rsi)
jns 0xa7cfc
movq -0x8(%rax), %rcx
movq (%rcx), %rcx
movq (%rcx), %rdx
cmpq %rdx, %rsi
je 0xa7c88
movl 0x10(%rdx), %esi
testl %esi, %esi
js 0xa7c68
orl $0x80000000, %esi # imm = 0x80000000
movl %esi, 0x10(%rdx)
andb $0x7f, 0x13(%rcx)
movq -0x8(%rax), %rsi
movq (%rcx), %rdi
movq 0x8(%rdi), %r8
movq %r8, (%rcx)
movq %rdi, (%rsi)
movq %rcx, 0x8(%rdi)
addq $0x8, %rdx
movq %rdx, (%rax)
leaq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
addq $0x8, %rax
movq (%rcx), %rdx
movq (%rdx), %r8
movq 0x8(%rdx), %rsi
movl 0x10(%rsi), %edi
movl 0x10(%r8), %r8d
testl %edi, %edi
jns 0xa7d04
testl %r8d, %r8d
js 0xa7ce3
jmp 0xa7d2a
movq 0x8(%rcx), %rdx
movl 0x10(%rdx), %esi
testl %esi, %esi
js 0xa7cc4
orl $0x80000000, %esi # imm = 0x80000000
movl %esi, 0x10(%rdx)
andb $0x7f, 0x13(%rcx)
movq -0x8(%rax), %rsi
movq 0x8(%rcx), %rdi
movq (%rdi), %r8
movq %r8, 0x8(%rcx)
movq %rdi, (%rsi)
movq %rcx, (%rdi)
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
addq $0x8, %rax
movq 0x8(%rcx), %rdx
movq (%rdx), %rsi
movq 0x8(%rdx), %r8
movl 0x10(%rsi), %edi
movl 0x10(%r8), %r8d
testl %edi, %edi
jns 0xa7d66
testl %r8d, %r8d
jns 0xa7d8e
andb $0x7f, 0x13(%rdx)
addq $-0x8, %rax
movq %rcx, %rsi
cmpq (%r9), %rcx
jne 0xa7c10
jmp 0xa7dcc
movq %rsi, %rcx
jmp 0xa7dcc
testl %r8d, %r8d
jns 0xa7d2a
orl $0x80000000, %edi # imm = 0x80000000
movl %edi, 0x10(%rsi)
andb $0x7f, 0x13(%rdx)
movq 0x8(%rdx), %rsi
movq (%rsi), %rdi
movq %rdi, 0x8(%rdx)
movq %rsi, (%rcx)
movq %rdx, (%rsi)
movq (%rcx), %rdx
movl $0x80000000, %esi # imm = 0x80000000
movl 0x10(%rcx), %edi
andl %esi, %edi
movl $0x7fffffff, %r8d # imm = 0x7FFFFFFF
andl 0x10(%rdx), %r8d
orl %edi, %r8d
movl %r8d, 0x10(%rdx)
orb $-0x80, 0x13(%rcx)
movq (%rdx), %rdx
orl %esi, 0x10(%rdx)
movq -0x8(%rax), %rdx
movq (%rcx), %rsi
leaq 0x8(%rsi), %rax
movq 0x8(%rsi), %rdi
movq %rdi, (%rcx)
movq %rsi, (%rdx)
jmp 0xa7dc6
testl %r8d, %r8d
jns 0xa7d8e
orl $0x80000000, %edi # imm = 0x80000000
movl %edi, 0x10(%rsi)
andb $0x7f, 0x13(%rdx)
movq (%rdx), %rsi
movq 0x8(%rsi), %rdi
movq %rdi, (%rdx)
movq %rsi, 0x8(%rcx)
movq %rdx, 0x8(%rsi)
movq 0x8(%rcx), %rdx
movl $0x80000000, %esi # imm = 0x80000000
movl 0x10(%rcx), %edi
andl %esi, %edi
movl $0x7fffffff, %r8d # imm = 0x7FFFFFFF
andl 0x10(%rdx), %r8d
orl %edi, %r8d
movl %r8d, 0x10(%rdx)
orb $-0x80, 0x13(%rcx)
movq 0x8(%rdx), %rdx
orl %esi, 0x10(%rdx)
movq -0x8(%rax), %rdx
movq 0x8(%rcx), %rax
movq (%rax), %rsi
movq %rsi, 0x8(%rcx)
movq %rax, (%rdx)
movq %rcx, (%rax)
movq (%r9), %rcx
orb $-0x80, 0x13(%rcx)
movq 0x280(%r9), %rax
testq %rax, %rax
je 0xa7e03
movl 0x208(%r9), %edi
testq %rdi, %rdi
je 0xa7ded
addq %r15, %rdi
jmp 0xa7df1
movq 0x18(%r15), %rdi
movq 0x230(%r9), %rdx
movl $0x1, %esi
callq *%rax
movq -0x30(%rbp), %r9
movl 0x210(%r9), %eax
movl %r14d, %ecx
addq %rax, %rcx
movq 0x220(%r9), %rax
negq %rcx
addq %rcx, %rax
addq $-0x18, %rax
movq %rax, 0x220(%r9)
movq %r15, %rdi
movq %r9, %rbx
callq 0xa2e9e
decl 0x20c(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| tree_delete:
mov eax, 1
cmp byte ptr [rdi+278h], 0
jz locret_A7E49
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r13, rcx
mov rcx, rdi
mov [rdi+8], rdi
mov r15, [rdi]
lea rbx, null_element
cmp r15, rbx
jz loc_A7E3B
mov r14, rsi
mov [rbp-34h], edx
lea r12, [rcx+10h]
mov [rbp-30h], rcx
loc_A7B15:
mov esi, [rcx+208h]
test rsi, rsi
jz short loc_A7B25
add rsi, r15
jmp short loc_A7B29
loc_A7B25:
mov rsi, [r15+18h]
loc_A7B29:
mov rdi, r13
mov rdx, r14
call qword ptr [rcx+228h]
test eax, eax
jz short loc_A7B5E
shr eax, 1Fh
lea rax, [r15+rax*8]
mov [r12], rax
mov r15, [rax]
add r12, 8
cmp r15, rbx
mov rcx, [rbp-30h]
jnz short loc_A7B15
mov eax, 1
jmp loc_A7E3B
loc_A7B5E:
mov rcx, [r15]
mov rdx, [r15+8]
lea rax, [r12-8]
cmp rcx, rbx
mov r9, [rbp-30h]
jz short loc_A7BA0
cmp rdx, rbx
jz short loc_A7BA8
lea rdx, [r15+8]
mov [r12], rdx
mov rcx, [rdx]
cmp [rcx], rbx
jz short loc_A7BB4
mov rax, r12
loc_A7B8B:
mov rdx, rcx
mov [rax+8], rcx
add rax, 8
mov rcx, [rcx]
cmp [rcx], rbx
jnz short loc_A7B8B
jmp short loc_A7BB7
loc_A7BA0:
mov rcx, [rax]
mov [rcx], rdx
jmp short loc_A7BAE
loc_A7BA8:
mov rdx, [rax]
mov [rdx], rcx
loc_A7BAE:
mov edx, [r15+10h]
jmp short loc_A7BF5
loc_A7BB4:
mov rax, r12
loc_A7BB7:
lea rsi, [rcx+8]
mov rdi, [rcx+8]
mov [rdx], rdi
mov edx, [rcx+10h]
mov rdi, [r12-8]
mov [rdi], rcx
mov [r12], rsi
mov rsi, [r15]
mov [rcx], rsi
mov rsi, [r15+8]
mov [rcx+8], rsi
mov esi, 80000000h
and esi, [r15+10h]
mov edi, 7FFFFFFFh
and edi, [rcx+10h]
or edi, esi
mov [rcx+10h], edi
loc_A7BF5:
test edx, edx
mov r14d, [rbp-34h]
jns loc_A7DD0
mov rcx, [rax]
mov rsi, [rcx]
cmp rsi, [r9]
jz loc_A7CFC
loc_A7C10:
cmp dword ptr [rsi+10h], 0
jns loc_A7CFC
mov rcx, [rax-8]
mov rcx, [rcx]
mov rdx, [rcx]
cmp rsi, rdx
jz short loc_A7C88
mov esi, [rdx+10h]
test esi, esi
js short loc_A7C68
or esi, 80000000h
mov [rdx+10h], esi
and byte ptr [rcx+13h], 7Fh
mov rsi, [rax-8]
mov rdi, [rcx]
mov r8, [rdi+8]
mov [rcx], r8
mov [rsi], rdi
mov [rdi+8], rcx
add rdx, 8
mov [rax], rdx
lea rdx, [rcx+8]
mov [rax+8], rdx
add rax, 8
mov rdx, [rcx]
loc_A7C68:
mov r8, [rdx]
mov rsi, [rdx+8]
mov edi, [rsi+10h]
mov r8d, [r8+10h]
test edi, edi
jns loc_A7D04
test r8d, r8d
js short loc_A7CE3
jmp loc_A7D2A
loc_A7C88:
mov rdx, [rcx+8]
mov esi, [rdx+10h]
test esi, esi
js short loc_A7CC4
or esi, 80000000h
mov [rdx+10h], esi
and byte ptr [rcx+13h], 7Fh
mov rsi, [rax-8]
mov rdi, [rcx+8]
mov r8, [rdi]
mov [rcx+8], r8
mov [rsi], rdi
mov [rdi], rcx
mov [rax], rdx
mov [rax+8], rcx
add rax, 8
mov rdx, [rcx+8]
loc_A7CC4:
mov rsi, [rdx]
mov r8, [rdx+8]
mov edi, [rsi+10h]
mov r8d, [r8+10h]
test edi, edi
jns loc_A7D66
test r8d, r8d
jns loc_A7D8E
loc_A7CE3:
and byte ptr [rdx+13h], 7Fh
add rax, 0FFFFFFFFFFFFFFF8h
mov rsi, rcx
cmp rcx, [r9]
jnz loc_A7C10
jmp loc_A7DCC
loc_A7CFC:
mov rcx, rsi
jmp loc_A7DCC
loc_A7D04:
test r8d, r8d
jns short loc_A7D2A
or edi, 80000000h
mov [rsi+10h], edi
and byte ptr [rdx+13h], 7Fh
mov rsi, [rdx+8]
mov rdi, [rsi]
mov [rdx+8], rdi
mov [rcx], rsi
mov [rsi], rdx
mov rdx, [rcx]
loc_A7D2A:
mov esi, 80000000h
mov edi, [rcx+10h]
and edi, esi
mov r8d, 7FFFFFFFh
and r8d, [rdx+10h]
or r8d, edi
mov [rdx+10h], r8d
or byte ptr [rcx+13h], 80h
mov rdx, [rdx]
or [rdx+10h], esi
mov rdx, [rax-8]
mov rsi, [rcx]
lea rax, [rsi+8]
mov rdi, [rsi+8]
mov [rcx], rdi
mov [rdx], rsi
jmp short loc_A7DC6
loc_A7D66:
test r8d, r8d
jns short loc_A7D8E
or edi, 80000000h
mov [rsi+10h], edi
and byte ptr [rdx+13h], 7Fh
mov rsi, [rdx]
mov rdi, [rsi+8]
mov [rdx], rdi
mov [rcx+8], rsi
mov [rsi+8], rdx
mov rdx, [rcx+8]
loc_A7D8E:
mov esi, 80000000h
mov edi, [rcx+10h]
and edi, esi
mov r8d, 7FFFFFFFh
and r8d, [rdx+10h]
or r8d, edi
mov [rdx+10h], r8d
or byte ptr [rcx+13h], 80h
mov rdx, [rdx+8]
or [rdx+10h], esi
mov rdx, [rax-8]
mov rax, [rcx+8]
mov rsi, [rax]
mov [rcx+8], rsi
mov [rdx], rax
loc_A7DC6:
mov [rax], rcx
mov rcx, [r9]
loc_A7DCC:
or byte ptr [rcx+13h], 80h
loc_A7DD0:
mov rax, [r9+280h]
test rax, rax
jz short loc_A7E03
mov edi, [r9+208h]
test rdi, rdi
jz short loc_A7DED
add rdi, r15
jmp short loc_A7DF1
loc_A7DED:
mov rdi, [r15+18h]
loc_A7DF1:
mov rdx, [r9+230h]
mov esi, 1
call rax
mov r9, [rbp-30h]
loc_A7E03:
mov eax, [r9+210h]
mov ecx, r14d
add rcx, rax
mov rax, [r9+220h]
neg rcx
add rax, rcx
add rax, 0FFFFFFFFFFFFFFE8h
mov [r9+220h], rax
mov rdi, r15
mov rbx, r9
call my_free
dec dword ptr [rbx+20Ch]
xor eax, eax
loc_A7E3B:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
locret_A7E49:
retn
| long long tree_delete(char **a1, long long a2, unsigned int a3, long long a4)
{
long long result; // rax
char **v6; // rcx
char *v7; // r15
void ***i; // r12
char *v10; // rsi
unsigned int v11; // eax
void **v12; // rax
void *v13; // rdx
void ***v14; // rax
char **v15; // r9
_QWORD *v16; // rdx
char *v17; // rcx
int v18; // edx
int *v19; // rsi
int *v20; // rcx
long long v21; // rdx
int v22; // esi
_QWORD *v23; // rsi
long long v24; // rdi
long long v25; // rsi
int v26; // edi
int v27; // r8d
int v28; // esi
int ***v29; // rsi
int **v30; // rdi
int v31; // edi
int v32; // r8d
_QWORD *v33; // rsi
_QWORD *v34; // rdx
long long v35; // rsi
int **v36; // rax
_QWORD *v37; // rsi
int ***v38; // rdx
char *v39; // rax
char *v40; // rdi
char **v41; // rbx
result = 1LL;
if ( !*((_BYTE *)a1 + 632) )
return result;
v6 = a1;
a1[1] = (char *)a1;
v7 = *a1;
if ( *a1 == (char *)&null_element )
return result;
for ( i = (void ***)(a1 + 2); ; ++i )
{
v10 = *((_DWORD *)v6 + 130) ? &v7[*((unsigned int *)v6 + 130)] : (char *)*((_QWORD *)v7 + 3);
v11 = ((long long ( *)(long long, char *, long long))v6[69])(a4, v10, a2);
if ( !v11 )
break;
v12 = (void **)&v7[8 * (v11 >> 31)];
*i = v12;
v7 = (char *)*v12;
v6 = a1;
if ( *v12 == &null_element )
return 1LL;
}
v13 = (void *)*((_QWORD *)v7 + 1);
v14 = i - 1;
v15 = a1;
if ( *(_UNKNOWN **)v7 == &null_element )
{
**v14 = v13;
}
else
{
if ( v13 != &null_element )
{
v16 = v7 + 8;
*i = (void **)(v7 + 8);
v17 = (char *)*((_QWORD *)v7 + 1);
if ( *(_UNKNOWN **)v17 == &null_element )
{
v14 = i;
}
else
{
v14 = i;
do
{
v16 = v17;
v14[1] = (void **)v17;
++v14;
v17 = *(char **)v17;
}
while ( *(_UNKNOWN **)v17 != &null_element );
}
*v16 = *((_QWORD *)v17 + 1);
v18 = *((_DWORD *)v17 + 4);
**(i - 1) = v17;
*i = (void **)(v17 + 8);
*(_QWORD *)v17 = *(_QWORD *)v7;
*((_QWORD *)v17 + 1) = *((_QWORD *)v7 + 1);
*((_DWORD *)v17 + 4) = *((_DWORD *)v7 + 4) & 0x80000000 | *((_DWORD *)v17 + 4) & 0x7FFFFFFF;
goto LABEL_21;
}
**v14 = *(void **)v7;
}
v18 = *((_DWORD *)v7 + 4);
LABEL_21:
if ( v18 < 0 )
{
v19 = (int *)**v14;
if ( v19 != (int *)*a1 )
{
while ( v19[4] < 0 )
{
v20 = (int *)**(v14 - 1);
v21 = *(_QWORD *)v20;
if ( v19 == *(int **)v20 )
{
v21 = *((_QWORD *)v20 + 1);
v28 = *(_DWORD *)(v21 + 16);
if ( v28 >= 0 )
{
*(_DWORD *)(v21 + 16) = v28 | 0x80000000;
*((_BYTE *)v20 + 19) &= ~0x80u;
v29 = (int ***)*(v14 - 1);
v30 = (int **)*((_QWORD *)v20 + 1);
*((_QWORD *)v20 + 1) = *v30;
*v29 = v30;
*v30 = v20;
*v14 = (void **)v21;
v14[1] = (void **)v20;
++v14;
v21 = *((_QWORD *)v20 + 1);
}
v31 = *(_DWORD *)(*(_QWORD *)v21 + 16LL);
v32 = *(_DWORD *)(*(_QWORD *)(v21 + 8) + 16LL);
if ( v31 >= 0 )
{
if ( v32 < 0 )
{
*(_DWORD *)(*(_QWORD *)v21 + 16LL) = v31 | 0x80000000;
*(_BYTE *)(v21 + 19) &= ~0x80u;
v37 = *(_QWORD **)v21;
*(_QWORD *)v21 = *(_QWORD *)(*(_QWORD *)v21 + 8LL);
*((_QWORD *)v20 + 1) = v37;
v37[1] = v21;
v21 = *((_QWORD *)v20 + 1);
}
LABEL_42:
*(_DWORD *)(v21 + 16) = v20[4] & 0x80000000 | *(_DWORD *)(v21 + 16) & 0x7FFFFFFF;
*((_BYTE *)v20 + 19) |= 0x80u;
*(_DWORD *)(*(_QWORD *)(v21 + 8) + 16LL) |= 0x80000000;
v38 = (int ***)*(v14 - 1);
v36 = (int **)*((_QWORD *)v20 + 1);
*((_QWORD *)v20 + 1) = *v36;
*v38 = v36;
LABEL_43:
*v36 = v20;
v20 = (int *)*a1;
goto LABEL_44;
}
if ( v32 >= 0 )
goto LABEL_42;
}
else
{
v22 = *(_DWORD *)(v21 + 16);
if ( v22 >= 0 )
{
*(_DWORD *)(v21 + 16) = v22 | 0x80000000;
*((_BYTE *)v20 + 19) &= ~0x80u;
v23 = *(v14 - 1);
v24 = *(_QWORD *)v20;
*(_QWORD *)v20 = *(_QWORD *)(*(_QWORD *)v20 + 8LL);
*v23 = v24;
*(_QWORD *)(v24 + 8) = v20;
*v14 = (void **)(v21 + 8);
v14[1] = (void **)(v20 + 2);
++v14;
v21 = *(_QWORD *)v20;
}
v25 = *(_QWORD *)(v21 + 8);
v26 = *(_DWORD *)(v25 + 16);
v27 = *(_DWORD *)(*(_QWORD *)v21 + 16LL);
if ( v26 >= 0 )
{
if ( v27 < 0 )
{
*(_DWORD *)(v25 + 16) = v26 | 0x80000000;
*(_BYTE *)(v21 + 19) &= ~0x80u;
v33 = *(_QWORD **)(v21 + 8);
*(_QWORD *)(v21 + 8) = *v33;
*(_QWORD *)v20 = v33;
*v33 = v21;
v21 = *(_QWORD *)v20;
}
LABEL_39:
*(_DWORD *)(v21 + 16) = v20[4] & 0x80000000 | *(_DWORD *)(v21 + 16) & 0x7FFFFFFF;
*((_BYTE *)v20 + 19) |= 0x80u;
*(_DWORD *)(*(_QWORD *)v21 + 16LL) |= 0x80000000;
v34 = *(v14 - 1);
v35 = *(_QWORD *)v20;
v36 = (int **)(*(_QWORD *)v20 + 8LL);
*(_QWORD *)v20 = *v36;
*v34 = v35;
goto LABEL_43;
}
if ( v27 >= 0 )
goto LABEL_39;
}
*(_BYTE *)(v21 + 19) &= ~0x80u;
--v14;
v19 = v20;
if ( v20 == (int *)*a1 )
goto LABEL_44;
}
}
v20 = v19;
LABEL_44:
*((_BYTE *)v20 + 19) |= 0x80u;
}
v39 = a1[80];
if ( v39 )
{
if ( *((_DWORD *)a1 + 130) )
v40 = &v7[*((unsigned int *)a1 + 130)];
else
v40 = (char *)*((_QWORD *)v7 + 3);
((void ( *)(char *, long long, char *))v39)(v40, 1LL, a1[70]);
v15 = a1;
}
v15[68] = &v15[68][-*((unsigned int *)v15 + 132) - (unsigned long long)a3 - 24];
v41 = v15;
my_free((long long)v7);
--*((_DWORD *)v41 + 131);
return 0LL;
}
| tree_delete:
MOV EAX,0x1
CMP byte ptr [RDI + 0x278],0x0
JZ 0x001a7e49
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R13,RCX
MOV RCX,RDI
MOV qword ptr [RDI + 0x8],RDI
MOV R15,qword ptr [RDI]
LEA RBX,[0x488c00]
CMP R15,RBX
JZ 0x001a7e3b
MOV R14,RSI
MOV dword ptr [RBP + -0x34],EDX
LEA R12,[RCX + 0x10]
MOV qword ptr [RBP + -0x30],RCX
LAB_001a7b15:
MOV ESI,dword ptr [RCX + 0x208]
TEST RSI,RSI
JZ 0x001a7b25
ADD RSI,R15
JMP 0x001a7b29
LAB_001a7b25:
MOV RSI,qword ptr [R15 + 0x18]
LAB_001a7b29:
MOV RDI,R13
MOV RDX,R14
CALL qword ptr [RCX + 0x228]
TEST EAX,EAX
JZ 0x001a7b5e
SHR EAX,0x1f
LEA RAX,[R15 + RAX*0x8]
MOV qword ptr [R12],RAX
MOV R15,qword ptr [RAX]
ADD R12,0x8
CMP R15,RBX
MOV RCX,qword ptr [RBP + -0x30]
JNZ 0x001a7b15
MOV EAX,0x1
JMP 0x001a7e3b
LAB_001a7b5e:
MOV RCX,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
LEA RAX,[R12 + -0x8]
CMP RCX,RBX
MOV R9,qword ptr [RBP + -0x30]
JZ 0x001a7ba0
CMP RDX,RBX
JZ 0x001a7ba8
LEA RDX,[R15 + 0x8]
MOV qword ptr [R12],RDX
MOV RCX,qword ptr [RDX]
CMP qword ptr [RCX],RBX
JZ 0x001a7bb4
MOV RAX,R12
LAB_001a7b8b:
MOV RDX,RCX
MOV qword ptr [RAX + 0x8],RCX
ADD RAX,0x8
MOV RCX,qword ptr [RCX]
CMP qword ptr [RCX],RBX
JNZ 0x001a7b8b
JMP 0x001a7bb7
LAB_001a7ba0:
MOV RCX,qword ptr [RAX]
MOV qword ptr [RCX],RDX
JMP 0x001a7bae
LAB_001a7ba8:
MOV RDX,qword ptr [RAX]
MOV qword ptr [RDX],RCX
LAB_001a7bae:
MOV EDX,dword ptr [R15 + 0x10]
JMP 0x001a7bf5
LAB_001a7bb4:
MOV RAX,R12
LAB_001a7bb7:
LEA RSI,[RCX + 0x8]
MOV RDI,qword ptr [RCX + 0x8]
MOV qword ptr [RDX],RDI
MOV EDX,dword ptr [RCX + 0x10]
MOV RDI,qword ptr [R12 + -0x8]
MOV qword ptr [RDI],RCX
MOV qword ptr [R12],RSI
MOV RSI,qword ptr [R15]
MOV qword ptr [RCX],RSI
MOV RSI,qword ptr [R15 + 0x8]
MOV qword ptr [RCX + 0x8],RSI
MOV ESI,0x80000000
AND ESI,dword ptr [R15 + 0x10]
MOV EDI,0x7fffffff
AND EDI,dword ptr [RCX + 0x10]
OR EDI,ESI
MOV dword ptr [RCX + 0x10],EDI
LAB_001a7bf5:
TEST EDX,EDX
MOV R14D,dword ptr [RBP + -0x34]
JNS 0x001a7dd0
MOV RCX,qword ptr [RAX]
MOV RSI,qword ptr [RCX]
CMP RSI,qword ptr [R9]
JZ 0x001a7cfc
LAB_001a7c10:
CMP dword ptr [RSI + 0x10],0x0
JNS 0x001a7cfc
MOV RCX,qword ptr [RAX + -0x8]
MOV RCX,qword ptr [RCX]
MOV RDX,qword ptr [RCX]
CMP RSI,RDX
JZ 0x001a7c88
MOV ESI,dword ptr [RDX + 0x10]
TEST ESI,ESI
JS 0x001a7c68
OR ESI,0x80000000
MOV dword ptr [RDX + 0x10],ESI
AND byte ptr [RCX + 0x13],0x7f
MOV RSI,qword ptr [RAX + -0x8]
MOV RDI,qword ptr [RCX]
MOV R8,qword ptr [RDI + 0x8]
MOV qword ptr [RCX],R8
MOV qword ptr [RSI],RDI
MOV qword ptr [RDI + 0x8],RCX
ADD RDX,0x8
MOV qword ptr [RAX],RDX
LEA RDX,[RCX + 0x8]
MOV qword ptr [RAX + 0x8],RDX
ADD RAX,0x8
MOV RDX,qword ptr [RCX]
LAB_001a7c68:
MOV R8,qword ptr [RDX]
MOV RSI,qword ptr [RDX + 0x8]
MOV EDI,dword ptr [RSI + 0x10]
MOV R8D,dword ptr [R8 + 0x10]
TEST EDI,EDI
JNS 0x001a7d04
TEST R8D,R8D
JS 0x001a7ce3
JMP 0x001a7d2a
LAB_001a7c88:
MOV RDX,qword ptr [RCX + 0x8]
MOV ESI,dword ptr [RDX + 0x10]
TEST ESI,ESI
JS 0x001a7cc4
OR ESI,0x80000000
MOV dword ptr [RDX + 0x10],ESI
AND byte ptr [RCX + 0x13],0x7f
MOV RSI,qword ptr [RAX + -0x8]
MOV RDI,qword ptr [RCX + 0x8]
MOV R8,qword ptr [RDI]
MOV qword ptr [RCX + 0x8],R8
MOV qword ptr [RSI],RDI
MOV qword ptr [RDI],RCX
MOV qword ptr [RAX],RDX
MOV qword ptr [RAX + 0x8],RCX
ADD RAX,0x8
MOV RDX,qword ptr [RCX + 0x8]
LAB_001a7cc4:
MOV RSI,qword ptr [RDX]
MOV R8,qword ptr [RDX + 0x8]
MOV EDI,dword ptr [RSI + 0x10]
MOV R8D,dword ptr [R8 + 0x10]
TEST EDI,EDI
JNS 0x001a7d66
TEST R8D,R8D
JNS 0x001a7d8e
LAB_001a7ce3:
AND byte ptr [RDX + 0x13],0x7f
ADD RAX,-0x8
MOV RSI,RCX
CMP RCX,qword ptr [R9]
JNZ 0x001a7c10
JMP 0x001a7dcc
LAB_001a7cfc:
MOV RCX,RSI
JMP 0x001a7dcc
LAB_001a7d04:
TEST R8D,R8D
JNS 0x001a7d2a
OR EDI,0x80000000
MOV dword ptr [RSI + 0x10],EDI
AND byte ptr [RDX + 0x13],0x7f
MOV RSI,qword ptr [RDX + 0x8]
MOV RDI,qword ptr [RSI]
MOV qword ptr [RDX + 0x8],RDI
MOV qword ptr [RCX],RSI
MOV qword ptr [RSI],RDX
MOV RDX,qword ptr [RCX]
LAB_001a7d2a:
MOV ESI,0x80000000
MOV EDI,dword ptr [RCX + 0x10]
AND EDI,ESI
MOV R8D,0x7fffffff
AND R8D,dword ptr [RDX + 0x10]
OR R8D,EDI
MOV dword ptr [RDX + 0x10],R8D
OR byte ptr [RCX + 0x13],0x80
MOV RDX,qword ptr [RDX]
OR dword ptr [RDX + 0x10],ESI
MOV RDX,qword ptr [RAX + -0x8]
MOV RSI,qword ptr [RCX]
LEA RAX,[RSI + 0x8]
MOV RDI,qword ptr [RSI + 0x8]
MOV qword ptr [RCX],RDI
MOV qword ptr [RDX],RSI
JMP 0x001a7dc6
LAB_001a7d66:
TEST R8D,R8D
JNS 0x001a7d8e
OR EDI,0x80000000
MOV dword ptr [RSI + 0x10],EDI
AND byte ptr [RDX + 0x13],0x7f
MOV RSI,qword ptr [RDX]
MOV RDI,qword ptr [RSI + 0x8]
MOV qword ptr [RDX],RDI
MOV qword ptr [RCX + 0x8],RSI
MOV qword ptr [RSI + 0x8],RDX
MOV RDX,qword ptr [RCX + 0x8]
LAB_001a7d8e:
MOV ESI,0x80000000
MOV EDI,dword ptr [RCX + 0x10]
AND EDI,ESI
MOV R8D,0x7fffffff
AND R8D,dword ptr [RDX + 0x10]
OR R8D,EDI
MOV dword ptr [RDX + 0x10],R8D
OR byte ptr [RCX + 0x13],0x80
MOV RDX,qword ptr [RDX + 0x8]
OR dword ptr [RDX + 0x10],ESI
MOV RDX,qword ptr [RAX + -0x8]
MOV RAX,qword ptr [RCX + 0x8]
MOV RSI,qword ptr [RAX]
MOV qword ptr [RCX + 0x8],RSI
MOV qword ptr [RDX],RAX
LAB_001a7dc6:
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [R9]
LAB_001a7dcc:
OR byte ptr [RCX + 0x13],0x80
LAB_001a7dd0:
MOV RAX,qword ptr [R9 + 0x280]
TEST RAX,RAX
JZ 0x001a7e03
MOV EDI,dword ptr [R9 + 0x208]
TEST RDI,RDI
JZ 0x001a7ded
ADD RDI,R15
JMP 0x001a7df1
LAB_001a7ded:
MOV RDI,qword ptr [R15 + 0x18]
LAB_001a7df1:
MOV RDX,qword ptr [R9 + 0x230]
MOV ESI,0x1
CALL RAX
MOV R9,qword ptr [RBP + -0x30]
LAB_001a7e03:
MOV EAX,dword ptr [R9 + 0x210]
MOV ECX,R14D
ADD RCX,RAX
MOV RAX,qword ptr [R9 + 0x220]
NEG RCX
ADD RAX,RCX
ADD RAX,-0x18
MOV qword ptr [R9 + 0x220],RAX
MOV RDI,R15
MOV RBX,R9
CALL 0x001a2e9e
DEC dword ptr [RBX + 0x20c]
XOR EAX,EAX
LAB_001a7e3b:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
LAB_001a7e49:
RET
|
int8 tree_delete(long *param_1,int8 param_2,uint param_3,int8 param_4)
{
int iVar1;
int8 *puVar2;
uint uVar3;
long *plVar4;
long *plVar5;
long *plVar6;
long *plVar7;
long lVar8;
long *plVar9;
if ((char)param_1[0x4f] == '\0') {
return 1;
}
param_1[1] = (long)param_1;
plVar9 = (long *)*param_1;
if (plVar9 == (long *)null_element) {
return 1;
}
plVar6 = param_1 + 2;
while( true ) {
if ((ulong)*(uint *)(param_1 + 0x41) == 0) {
lVar8 = plVar9[3];
}
else {
lVar8 = (ulong)*(uint *)(param_1 + 0x41) + (long)plVar9;
}
uVar3 = (*(code *)param_1[0x45])(param_4,lVar8,param_2);
if (uVar3 == 0) break;
*plVar6 = (long)(plVar9 + (uVar3 >> 0x1f));
plVar9 = (long *)plVar9[uVar3 >> 0x1f];
plVar6 = plVar6 + 1;
if (plVar9 == (long *)null_element) {
return 1;
}
}
plVar4 = plVar6 + -1;
if ((int1 *)*plVar9 == null_element) {
*(int1 **)*plVar4 = (int1 *)plVar9[1];
}
else {
if ((int1 *)plVar9[1] != null_element) {
plVar7 = plVar9 + 1;
*plVar6 = (long)plVar7;
plVar5 = (long *)*plVar7;
plVar4 = plVar6;
if ((int1 *)*plVar5 != null_element) {
do {
plVar7 = plVar5;
plVar4[1] = (long)plVar7;
plVar4 = plVar4 + 1;
plVar5 = (long *)*plVar7;
} while ((int1 *)*plVar5 != null_element);
}
*plVar7 = plVar5[1];
iVar1 = (int)plVar5[2];
*(long **)plVar6[-1] = plVar5;
*plVar6 = (long)(plVar5 + 1);
*plVar5 = *plVar9;
plVar5[1] = plVar9[1];
*(uint *)(plVar5 + 2) =
*(uint *)(plVar5 + 2) & 0x7fffffff | *(uint *)(plVar9 + 2) & 0x80000000;
goto LAB_001a7bf5;
}
*(int1 **)*plVar4 = (int1 *)*plVar9;
}
iVar1 = (int)plVar9[2];
LAB_001a7bf5:
if (iVar1 < 0) {
plVar6 = *(long **)*plVar4;
plVar7 = plVar6;
if (plVar6 != (long *)*param_1) {
do {
plVar6 = plVar7;
if (-1 < (int)plVar7[2]) break;
plVar6 = *(long **)plVar4[-1];
plVar5 = (long *)*plVar6;
if (plVar7 == plVar5) {
plVar5 = (long *)plVar6[1];
if (-1 < (int)*(uint *)(plVar5 + 2)) {
*(uint *)(plVar5 + 2) = *(uint *)(plVar5 + 2) | 0x80000000;
*(byte *)((long)plVar6 + 0x13) = *(byte *)((long)plVar6 + 0x13) & 0x7f;
puVar2 = (int8 *)plVar4[-1];
plVar7 = (long *)plVar6[1];
plVar6[1] = *plVar7;
*puVar2 = plVar7;
*plVar7 = (long)plVar6;
*plVar4 = (long)plVar5;
plVar4[1] = (long)plVar6;
plVar4 = plVar4 + 1;
plVar5 = (long *)plVar6[1];
}
uVar3 = *(uint *)(*plVar5 + 0x10);
if ((int)uVar3 < 0) {
if (*(int *)(plVar5[1] + 0x10) < 0) goto LAB_001a7ce3;
}
else if (*(int *)(plVar5[1] + 0x10) < 0) {
*(uint *)(*plVar5 + 0x10) = uVar3 | 0x80000000;
*(byte *)((long)plVar5 + 0x13) = *(byte *)((long)plVar5 + 0x13) & 0x7f;
lVar8 = *plVar5;
*plVar5 = *(long *)(lVar8 + 8);
plVar6[1] = lVar8;
*(long **)(lVar8 + 8) = plVar5;
plVar5 = (long *)plVar6[1];
}
*(uint *)(plVar5 + 2) =
*(uint *)(plVar5 + 2) & 0x7fffffff | *(uint *)(plVar6 + 2) & 0x80000000;
*(byte *)((long)plVar6 + 0x13) = *(byte *)((long)plVar6 + 0x13) | 0x80;
*(uint *)(plVar5[1] + 0x10) = *(uint *)(plVar5[1] + 0x10) | 0x80000000;
plVar7 = (long *)plVar4[-1];
plVar4 = (long *)plVar6[1];
plVar6[1] = *plVar4;
*plVar7 = (long)plVar4;
LAB_001a7dc6:
*plVar4 = (long)plVar6;
plVar6 = (long *)*param_1;
break;
}
if (-1 < (int)*(uint *)(plVar5 + 2)) {
*(uint *)(plVar5 + 2) = *(uint *)(plVar5 + 2) | 0x80000000;
*(byte *)((long)plVar6 + 0x13) = *(byte *)((long)plVar6 + 0x13) & 0x7f;
plVar7 = (long *)plVar4[-1];
lVar8 = *plVar6;
*plVar6 = *(long *)(lVar8 + 8);
*plVar7 = lVar8;
*(long **)(lVar8 + 8) = plVar6;
*plVar4 = (long)(plVar5 + 1);
plVar4[1] = (long)(plVar6 + 1);
plVar4 = plVar4 + 1;
plVar5 = (long *)*plVar6;
}
uVar3 = *(uint *)(plVar5[1] + 0x10);
if (-1 < (int)uVar3) {
if (*(int *)(*plVar5 + 0x10) < 0) {
*(uint *)(plVar5[1] + 0x10) = uVar3 | 0x80000000;
*(byte *)((long)plVar5 + 0x13) = *(byte *)((long)plVar5 + 0x13) & 0x7f;
plVar7 = (long *)plVar5[1];
plVar5[1] = *plVar7;
*plVar6 = (long)plVar7;
*plVar7 = (long)plVar5;
plVar5 = (long *)*plVar6;
}
LAB_001a7d2a:
*(uint *)(plVar5 + 2) =
*(uint *)(plVar5 + 2) & 0x7fffffff | *(uint *)(plVar6 + 2) & 0x80000000;
*(byte *)((long)plVar6 + 0x13) = *(byte *)((long)plVar6 + 0x13) | 0x80;
*(uint *)(*plVar5 + 0x10) = *(uint *)(*plVar5 + 0x10) | 0x80000000;
plVar7 = (long *)plVar4[-1];
lVar8 = *plVar6;
plVar4 = (long *)(lVar8 + 8);
*plVar6 = *(long *)(lVar8 + 8);
*plVar7 = lVar8;
goto LAB_001a7dc6;
}
if (-1 < *(int *)(*plVar5 + 0x10)) goto LAB_001a7d2a;
LAB_001a7ce3:
*(byte *)((long)plVar5 + 0x13) = *(byte *)((long)plVar5 + 0x13) & 0x7f;
plVar4 = plVar4 + -1;
plVar7 = plVar6;
} while (plVar6 != (long *)*param_1);
}
*(byte *)((long)plVar6 + 0x13) = *(byte *)((long)plVar6 + 0x13) | 0x80;
}
if ((code *)param_1[0x50] != (code *)0x0) {
if ((ulong)*(uint *)(param_1 + 0x41) == 0) {
lVar8 = plVar9[3];
}
else {
lVar8 = (ulong)*(uint *)(param_1 + 0x41) + (long)plVar9;
}
(*(code *)param_1[0x50])(lVar8,1,param_1[0x46]);
}
param_1[0x44] = (param_1[0x44] - ((ulong)param_3 + (ulong)*(uint *)(param_1 + 0x42))) + -0x18;
my_free(plVar9);
*(int *)((long)param_1 + 0x20c) = *(int *)((long)param_1 + 0x20c) + -1;
return 0;
}
| |
25,008 | js_inner_module_evaluation | bluesky950520[P]quickjs/quickjs.c | static int js_inner_module_evaluation(JSContext *ctx, JSModuleDef *m,
int index, JSModuleDef **pstack_top,
JSValue *pvalue)
{
JSModuleDef *m1;
int i;
if (js_check_stack_overflow(ctx->rt, 0)) {
JS_ThrowStackOverflow(ctx);
*pvalue = JS_GetException(ctx);
return -1;
}
#ifdef DUMP_MODULE_RESOLVE
if (check_dump_flag(ctx->rt, DUMP_MODULE_RESOLVE)) {
char buf1[ATOM_GET_STR_BUF_SIZE];
printf("js_inner_module_evaluation '%s':\n", JS_AtomGetStr(ctx, buf1, sizeof(buf1), m->module_name));
}
#endif
if (m->status == JS_MODULE_STATUS_EVALUATING_ASYNC ||
m->status == JS_MODULE_STATUS_EVALUATED) {
if (m->eval_has_exception) {
*pvalue = JS_DupValue(ctx, m->eval_exception);
return -1;
} else {
*pvalue = JS_UNDEFINED;
return index;
}
}
if (m->status == JS_MODULE_STATUS_EVALUATING) {
*pvalue = JS_UNDEFINED;
return index;
}
assert(m->status == JS_MODULE_STATUS_LINKED);
m->status = JS_MODULE_STATUS_EVALUATING;
m->dfs_index = index;
m->dfs_ancestor_index = index;
m->pending_async_dependencies = 0;
index++;
/* push 'm' on stack */
m->stack_prev = *pstack_top;
*pstack_top = m;
for(i = 0; i < m->req_module_entries_count; i++) {
JSReqModuleEntry *rme = &m->req_module_entries[i];
m1 = rme->module;
index = js_inner_module_evaluation(ctx, m1, index, pstack_top, pvalue);
if (index < 0)
return -1;
assert(m1->status == JS_MODULE_STATUS_EVALUATING ||
m1->status == JS_MODULE_STATUS_EVALUATING_ASYNC ||
m1->status == JS_MODULE_STATUS_EVALUATED);
if (m1->status == JS_MODULE_STATUS_EVALUATING) {
m->dfs_ancestor_index = min_int(m->dfs_ancestor_index,
m1->dfs_ancestor_index);
} else {
m1 = m1->cycle_root;
assert(m1->status == JS_MODULE_STATUS_EVALUATING_ASYNC ||
m1->status == JS_MODULE_STATUS_EVALUATED);
if (m1->eval_has_exception) {
*pvalue = JS_DupValue(ctx, m1->eval_exception);
return -1;
}
}
if (m1->async_evaluation) {
m->pending_async_dependencies++;
if (js_resize_array(ctx, (void **)&m1->async_parent_modules, sizeof(m1->async_parent_modules[0]), &m1->async_parent_modules_size, m1->async_parent_modules_count + 1)) {
*pvalue = JS_GetException(ctx);
return -1;
}
m1->async_parent_modules[m1->async_parent_modules_count++] = m;
}
}
if (m->pending_async_dependencies > 0) {
assert(!m->async_evaluation);
m->async_evaluation = TRUE;
m->async_evaluation_timestamp =
ctx->rt->module_async_evaluation_next_timestamp++;
} else if (m->has_tla) {
assert(!m->async_evaluation);
m->async_evaluation = TRUE;
m->async_evaluation_timestamp =
ctx->rt->module_async_evaluation_next_timestamp++;
js_execute_async_module(ctx, m);
} else {
if (js_execute_sync_module(ctx, m, pvalue) < 0)
return -1;
}
assert(m->dfs_ancestor_index <= m->dfs_index);
if (m->dfs_index == m->dfs_ancestor_index) {
for(;;) {
/* pop m1 from stack */
m1 = *pstack_top;
*pstack_top = m1->stack_prev;
if (!m1->async_evaluation) {
m1->status = JS_MODULE_STATUS_EVALUATED;
} else {
m1->status = JS_MODULE_STATUS_EVALUATING_ASYNC;
}
/* spec bug: cycle_root must be assigned before the test */
m1->cycle_root = m;
if (m1 == m)
break;
}
}
*pvalue = JS_UNDEFINED;
return index;
} | O1 | c | js_inner_module_evaluation:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rax
cmpq %rbp, 0xe8(%rax)
jbe 0x44adc
leaq 0x5a530(%rip), %rsi # 0x9efd6
movq %r14, %rdi
xorl %eax, %eax
callq 0x20add
movq 0x18(%r14), %rcx
movq 0xf0(%rcx), %rdx
movq 0xf8(%rcx), %rax
movl $0x0, 0xf0(%rcx)
movq $0x4, 0xf8(%rcx)
movq %rdx, (%rbx)
jmp 0x44b23
movl %edx, %r9d
movq %rsi, %r15
movl 0x80(%rsi), %eax
movl %eax, %esi
shrl $0x18, %esi
leal -0x4(%rsi), %edx
cmpl $0x2, %edx
jae 0x44b2e
cmpb $0x0, 0xf0(%r15)
je 0x44d53
movq 0xf8(%r15), %rcx
movq 0x100(%r15), %rax
movq %rcx, -0x40(%rbp)
cmpl $-0x9, %eax
jb 0x44b20
movq -0x40(%rbp), %rdx
incl (%rdx)
movq %rcx, (%rbx)
movl $0xffffffff, %r9d # imm = 0xFFFFFFFF
jmp 0x44d5e
cmpl $0x3, %esi
je 0x44d53
movq %rbx, -0x30(%rbp)
andl $0xffffff, %eax # imm = 0xFFFFFF
orl $0x3000000, %eax # imm = 0x3000000
movl %eax, 0x80(%r15)
movl %r9d, 0x84(%r15)
movl %r9d, 0x88(%r15)
movl $0x0, 0xa8(%r15)
incl %r9d
movq (%rcx), %rax
movq %rax, 0x90(%r15)
movq %r15, (%rcx)
cmpl $0x0, 0x20(%r15)
jle 0x44caf
movl $0x8, %r12d
xorl %r13d, %r13d
movq %r14, -0x38(%rbp)
movq 0x18(%r15), %rax
movq (%rax,%r12), %rbx
movq %r14, %rdi
movq %rbx, %rsi
movl %r9d, %edx
movq %rcx, %r14
movq -0x30(%rbp), %r8
callq 0x44a7b
testl %eax, %eax
js 0x44d74
movl %eax, %r9d
movzbl 0x83(%rbx), %eax
shll $0x18, %eax
cmpl $0x3000000, %eax # imm = 0x3000000
jne 0x44be1
movl 0x88(%r15), %eax
movl 0x88(%rbx), %ecx
cmpl %ecx, %eax
cmovll %eax, %ecx
movl %ecx, 0x88(%r15)
jmp 0x44bf5
movq 0xb8(%rbx), %rbx
cmpb $0x0, 0xf0(%rbx)
jne 0x44d7c
movq %r14, %rcx
cmpl $0x0, 0xac(%rbx)
je 0x44c33
incl 0xa8(%r15)
movl 0xa0(%rbx), %r8d
cmpl %r8d, 0xa4(%rbx)
jle 0x44c4d
movq 0x98(%rbx), %rax
movslq 0xa0(%rbx), %rsi
leal 0x1(%rsi), %edx
movl %edx, 0xa0(%rbx)
movq %r15, (%rax,%rsi,8)
incq %r13
movslq 0x20(%r15), %rax
addq $0x10, %r12
cmpq %rax, %r13
movq -0x38(%rbp), %r14
jl 0x44b8d
jmp 0x44caf
leaq 0x98(%rbx), %rsi
leaq 0xa4(%rbx), %rcx
incl %r8d
movq -0x38(%rbp), %rdi
movl $0x8, %edx
movl %r9d, -0x44(%rbp)
callq 0x434ef
movl -0x44(%rbp), %r9d
movq %r14, %rcx
testl %eax, %eax
je 0x44c18
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rcx
movq 0xf0(%rcx), %rdx
movq 0xf8(%rcx), %rax
movl $0x0, 0xf0(%rcx)
movq $0x4, 0xf8(%rcx)
movq -0x30(%rbp), %rbx
jmp 0x44ad7
cmpl $0x0, 0xa8(%r15)
jle 0x44ce7
movl $0x1, 0xac(%r15)
movq 0x18(%r14), %rax
movq 0x158(%rax), %rsi
leaq 0x1(%rsi), %rdx
movq %rdx, 0x158(%rax)
movq %rsi, 0xb0(%r15)
movq -0x30(%rbp), %rbx
jmp 0x44d17
movq %r14, %rdi
movl %r9d, %r12d
movq %rcx, %r14
cmpb $0x0, 0x80(%r15)
movq -0x30(%rbp), %rbx
jne 0x44da2
movq %r15, %rsi
movq %rbx, %rdx
callq 0x44ddd
testl %eax, %eax
movq %r14, %rcx
movl %r12d, %r9d
js 0x44d74
movl 0x84(%r15), %eax
cmpl 0x88(%r15), %eax
jne 0x44d53
movq (%rcx), %rax
movq 0x90(%rax), %rdx
movq %rdx, (%rcx)
cmpl $0x0, 0xac(%rax)
sete %dl
orb $0x4, %dl
movb %dl, 0x83(%rax)
movq %r15, 0xb8(%rax)
cmpq %r15, %rax
jne 0x44d27
movl $0x0, (%rbx)
movl $0x3, %eax
movq %rax, 0x8(%rbx)
movl %r9d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %r9d # imm = 0xFFFFFFFF
jmp 0x44d62
movq 0xf8(%rbx), %rcx
movq 0x100(%rbx), %rax
movq %rcx, -0x40(%rbp)
cmpl $-0x9, %eax
jb 0x44d99
movq -0x40(%rbp), %rdx
incl (%rdx)
movq -0x30(%rbp), %rbx
jmp 0x44b20
movl $0x1, 0xac(%r15)
movq 0x18(%rdi), %rax
movq 0x158(%rax), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x158(%rax)
movq %rcx, 0xb0(%r15)
movq %r15, %rsi
callq 0x110af
movq %r14, %rcx
movl %r12d, %r9d
jmp 0x44d17
| js_inner_module_evaluation:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, r8
mov r14, rdi
mov rax, [rdi+18h]
cmp [rax+0E8h], rbp
jbe short loc_44ADC
lea rsi, aMaximumCallSta; "Maximum call stack size exceeded"
mov rdi, r14
xor eax, eax
call JS_ThrowRangeError
mov rcx, [r14+18h]
mov rdx, [rcx+0F0h]
mov rax, [rcx+0F8h]
mov dword ptr [rcx+0F0h], 0
mov qword ptr [rcx+0F8h], 4
loc_44AD7:
mov [rbx], rdx
jmp short loc_44B23
loc_44ADC:
mov r9d, edx
mov r15, rsi
mov eax, [rsi+80h]
mov esi, eax
shr esi, 18h
lea edx, [rsi-4]
cmp edx, 2
jnb short loc_44B2E
cmp byte ptr [r15+0F0h], 0
jz loc_44D53
mov rcx, [r15+0F8h]
mov rax, [r15+100h]
mov [rbp+var_40], rcx
cmp eax, 0FFFFFFF7h
jb short loc_44B20
mov rdx, [rbp+var_40]
inc dword ptr [rdx]
loc_44B20:
mov [rbx], rcx
loc_44B23:
mov r9d, 0FFFFFFFFh
jmp loc_44D5E
loc_44B2E:
cmp esi, 3
jz loc_44D53
mov [rbp+var_30], rbx
and eax, 0FFFFFFh
or eax, 3000000h
mov [r15+80h], eax
mov [r15+84h], r9d
mov [r15+88h], r9d
mov dword ptr [r15+0A8h], 0
inc r9d
mov rax, [rcx]
mov [r15+90h], rax
mov [rcx], r15
cmp dword ptr [r15+20h], 0
jle loc_44CAF
mov r12d, 8
xor r13d, r13d
mov [rbp+var_38], r14
loc_44B8D:
mov rax, [r15+18h]
mov rbx, [rax+r12]
mov rdi, r14
mov rsi, rbx
mov edx, r9d
mov r14, rcx
mov r8, [rbp+var_30]
call js_inner_module_evaluation
test eax, eax
js loc_44D74
mov r9d, eax
movzx eax, byte ptr [rbx+83h]
shl eax, 18h
cmp eax, 3000000h
jnz short loc_44BE1
mov eax, [r15+88h]
mov ecx, [rbx+88h]
cmp eax, ecx
cmovl ecx, eax
mov [r15+88h], ecx
jmp short loc_44BF5
loc_44BE1:
mov rbx, [rbx+0B8h]
cmp byte ptr [rbx+0F0h], 0
jnz loc_44D7C
loc_44BF5:
mov rcx, r14
cmp dword ptr [rbx+0ACh], 0
jz short loc_44C33
inc dword ptr [r15+0A8h]
mov r8d, [rbx+0A0h]
cmp [rbx+0A4h], r8d
jle short loc_44C4D
loc_44C18:
mov rax, [rbx+98h]
movsxd rsi, dword ptr [rbx+0A0h]
lea edx, [rsi+1]
mov [rbx+0A0h], edx
mov [rax+rsi*8], r15
loc_44C33:
inc r13
movsxd rax, dword ptr [r15+20h]
add r12, 10h
cmp r13, rax
mov r14, [rbp+var_38]
jl loc_44B8D
jmp short loc_44CAF
loc_44C4D:
lea rsi, [rbx+98h]
lea rcx, [rbx+0A4h]
inc r8d
mov rdi, [rbp+var_38]
mov edx, 8
mov [rbp+var_44], r9d
call js_realloc_array
mov r9d, [rbp+var_44]
mov rcx, r14
test eax, eax
jz short loc_44C18
mov rax, [rbp+var_38]
mov rcx, [rax+18h]
mov rdx, [rcx+0F0h]
mov rax, [rcx+0F8h]
mov dword ptr [rcx+0F0h], 0
mov qword ptr [rcx+0F8h], 4
mov rbx, [rbp+var_30]
jmp loc_44AD7
loc_44CAF:
cmp dword ptr [r15+0A8h], 0
jle short loc_44CE7
mov dword ptr [r15+0ACh], 1
mov rax, [r14+18h]
mov rsi, [rax+158h]
lea rdx, [rsi+1]
mov [rax+158h], rdx
mov [r15+0B0h], rsi
mov rbx, [rbp+var_30]
jmp short loc_44D17
loc_44CE7:
mov rdi, r14
mov r12d, r9d
mov r14, rcx
cmp byte ptr [r15+80h], 0
mov rbx, [rbp+var_30]
jnz loc_44DA2
mov rsi, r15
mov rdx, rbx
call js_execute_sync_module
test eax, eax
mov rcx, r14
mov r9d, r12d
js short loc_44D74
loc_44D17:
mov eax, [r15+84h]
cmp eax, [r15+88h]
jnz short loc_44D53
loc_44D27:
mov rax, [rcx]
mov rdx, [rax+90h]
mov [rcx], rdx
cmp dword ptr [rax+0ACh], 0
setz dl
or dl, 4
mov [rax+83h], dl
mov [rax+0B8h], r15
cmp rax, r15
jnz short loc_44D27
loc_44D53:
mov dword ptr [rbx], 0
mov eax, 3
loc_44D5E:
mov [rbx+8], rax
loc_44D62:
mov eax, r9d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_44D74:
mov r9d, 0FFFFFFFFh
jmp short loc_44D62
loc_44D7C:
mov rcx, [rbx+0F8h]
mov rax, [rbx+100h]
mov [rbp+var_40], rcx
cmp eax, 0FFFFFFF7h
jb short loc_44D99
mov rdx, [rbp+var_40]
inc dword ptr [rdx]
loc_44D99:
mov rbx, [rbp+var_30]
jmp loc_44B20
loc_44DA2:
mov dword ptr [r15+0ACh], 1
mov rax, [rdi+18h]
mov rcx, [rax+158h]
lea rdx, [rcx+1]
mov [rax+158h], rdx
mov [r15+0B0h], rcx
mov rsi, r15
call js_execute_async_module
mov rcx, r14
mov r9d, r12d
jmp loc_44D17
| long long js_inner_module_evaluation(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
_QWORD *v14; // rbx
long long v15; // r14
long long v16; // rcx
long long v17; // rdx
long long v18; // rax
unsigned int v19; // r9d
unsigned int v21; // eax
long long v22; // rcx
long long v23; // r12
long long v24; // r13
long long v25; // rbx
long long v26; // rdi
long long v27; // r14
int v28; // eax
int v29; // ecx
int v30; // r8d
long long v31; // rax
long long v32; // rsi
int v33; // eax
long long v34; // rcx
long long v35; // rax
long long v36; // rsi
long long v37; // rdi
unsigned int v38; // r12d
long long v39; // r14
int v40; // eax
long long v41; // rax
long long v43; // rax
long long v44; // rcx
char v45; // [rsp+0h] [rbp-50h]
unsigned int v46; // [rsp+Ch] [rbp-44h]
long long savedregs; // [rsp+50h] [rbp+0h] BYREF
v14 = (_QWORD *)a5;
v15 = a1;
if ( *(_QWORD *)(*(_QWORD *)(a1 + 24) + 232LL) <= (unsigned long long)&savedregs )
{
v19 = a3;
v21 = *(_DWORD *)(a2 + 128);
if ( HIBYTE(v21) - 4 < 2u )
{
if ( *(_BYTE *)(a2 + 240) )
{
v22 = *(_QWORD *)(a2 + 248);
v18 = *(_QWORD *)(a2 + 256);
if ( (unsigned int)v18 >= 0xFFFFFFF7 )
++**(_DWORD **)(a2 + 248);
LABEL_8:
*v14 = v22;
goto LABEL_9;
}
LABEL_32:
*(_DWORD *)v14 = 0;
v18 = 3LL;
goto LABEL_33;
}
if ( HIBYTE(v21) == 3 )
goto LABEL_32;
*(_DWORD *)(a2 + 128) = v21 & 0xFFFFFF | 0x3000000;
*(_DWORD *)(a2 + 132) = a3;
*(_DWORD *)(a2 + 136) = a3;
*(_DWORD *)(a2 + 168) = 0;
v19 = a3 + 1;
*(_QWORD *)(a2 + 144) = *(_QWORD *)a4;
*(_QWORD *)a4 = a2;
if ( *(int *)(a2 + 32) > 0 )
{
v23 = 8LL;
v24 = 0LL;
do
{
v25 = *(_QWORD *)(*(_QWORD *)(a2 + 24) + v23);
v26 = v15;
v27 = a4;
v28 = js_inner_module_evaluation(v26, v25, v19, a4, a5);
if ( v28 < 0 )
return (unsigned int)-1;
v19 = v28;
if ( *(unsigned __int8 *)(v25 + 131) << 24 == 50331648 )
{
v29 = *(_DWORD *)(v25 + 136);
if ( *(_DWORD *)(a2 + 136) < v29 )
v29 = *(_DWORD *)(a2 + 136);
*(_DWORD *)(a2 + 136) = v29;
}
else
{
v25 = *(_QWORD *)(v25 + 184);
if ( *(_BYTE *)(v25 + 240) )
{
v22 = *(_QWORD *)(v25 + 248);
v18 = *(_QWORD *)(v25 + 256);
if ( (unsigned int)v18 >= 0xFFFFFFF7 )
++**(_DWORD **)(v25 + 248);
v14 = (_QWORD *)a5;
goto LABEL_8;
}
}
a4 = v27;
if ( *(_DWORD *)(v25 + 172) )
{
++*(_DWORD *)(a2 + 168);
v30 = *(_DWORD *)(v25 + 160);
if ( *(_DWORD *)(v25 + 164) <= v30 )
{
v46 = v28;
v33 = js_realloc_array(a1, (long long *)(v25 + 152), 8u, (_DWORD *)(v25 + 164), v30 + 1);
v19 = v46;
a4 = v27;
if ( v33 )
{
v34 = *(_QWORD *)(a1 + 24);
v17 = *(_QWORD *)(v34 + 240);
v18 = *(_QWORD *)(v34 + 248);
*(_DWORD *)(v34 + 240) = 0;
*(_QWORD *)(v34 + 248) = 4LL;
v14 = (_QWORD *)a5;
goto LABEL_3;
}
}
v31 = *(_QWORD *)(v25 + 152);
v32 = *(int *)(v25 + 160);
*(_DWORD *)(v25 + 160) = v32 + 1;
*(_QWORD *)(v31 + 8 * v32) = a2;
}
++v24;
v23 += 16LL;
v15 = a1;
}
while ( v24 < *(int *)(a2 + 32) );
}
if ( *(int *)(a2 + 168) <= 0 )
{
v37 = v15;
v38 = v19;
v39 = a4;
v14 = (_QWORD *)a5;
if ( *(_BYTE *)(a2 + 128) )
{
*(_DWORD *)(a2 + 172) = 1;
v43 = *(_QWORD *)(v37 + 24);
v44 = *(_QWORD *)(v43 + 344);
*(_QWORD *)(v43 + 344) = v44 + 1;
*(_QWORD *)(a2 + 176) = v44;
js_execute_async_module(v37, a2);
a4 = v39;
v19 = v38;
}
else
{
v40 = js_execute_sync_module(v37, a2, a5);
a4 = v39;
v19 = v38;
if ( v40 < 0 )
return (unsigned int)-1;
}
}
else
{
*(_DWORD *)(a2 + 172) = 1;
v35 = *(_QWORD *)(v15 + 24);
v36 = *(_QWORD *)(v35 + 344);
*(_QWORD *)(v35 + 344) = v36 + 1;
*(_QWORD *)(a2 + 176) = v36;
v14 = (_QWORD *)a5;
}
if ( *(_DWORD *)(a2 + 132) == *(_DWORD *)(a2 + 136) )
{
do
{
v41 = *(_QWORD *)a4;
*(_QWORD *)a4 = *(_QWORD *)(*(_QWORD *)a4 + 144LL);
*(_BYTE *)(v41 + 131) = (*(_DWORD *)(v41 + 172) == 0) | 4;
*(_QWORD *)(v41 + 184) = a2;
}
while ( v41 != a2 );
}
goto LABEL_32;
}
JS_ThrowRangeError(
a1,
(long long)"Maximum call stack size exceeded",
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v45);
v16 = *(_QWORD *)(a1 + 24);
v17 = *(_QWORD *)(v16 + 240);
v18 = *(_QWORD *)(v16 + 248);
*(_DWORD *)(v16 + 240) = 0;
*(_QWORD *)(v16 + 248) = 4LL;
LABEL_3:
*v14 = v17;
LABEL_9:
v19 = -1;
LABEL_33:
v14[1] = v18;
return v19;
}
| js_inner_module_evaluation:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,R8
MOV R14,RDI
MOV RAX,qword ptr [RDI + 0x18]
CMP qword ptr [RAX + 0xe8],RBP
JBE 0x00144adc
LEA RSI,[0x19efd6]
MOV RDI,R14
XOR EAX,EAX
CALL 0x00120add
MOV RCX,qword ptr [R14 + 0x18]
MOV RDX,qword ptr [RCX + 0xf0]
MOV RAX,qword ptr [RCX + 0xf8]
MOV dword ptr [RCX + 0xf0],0x0
MOV qword ptr [RCX + 0xf8],0x4
LAB_00144ad7:
MOV qword ptr [RBX],RDX
JMP 0x00144b23
LAB_00144adc:
MOV R9D,EDX
MOV R15,RSI
MOV EAX,dword ptr [RSI + 0x80]
MOV ESI,EAX
SHR ESI,0x18
LEA EDX,[RSI + -0x4]
CMP EDX,0x2
JNC 0x00144b2e
CMP byte ptr [R15 + 0xf0],0x0
JZ 0x00144d53
MOV RCX,qword ptr [R15 + 0xf8]
MOV RAX,qword ptr [R15 + 0x100]
MOV qword ptr [RBP + -0x40],RCX
CMP EAX,-0x9
JC 0x00144b20
MOV RDX,qword ptr [RBP + -0x40]
INC dword ptr [RDX]
LAB_00144b20:
MOV qword ptr [RBX],RCX
LAB_00144b23:
MOV R9D,0xffffffff
JMP 0x00144d5e
LAB_00144b2e:
CMP ESI,0x3
JZ 0x00144d53
MOV qword ptr [RBP + -0x30],RBX
AND EAX,0xffffff
OR EAX,0x3000000
MOV dword ptr [R15 + 0x80],EAX
MOV dword ptr [R15 + 0x84],R9D
MOV dword ptr [R15 + 0x88],R9D
MOV dword ptr [R15 + 0xa8],0x0
INC R9D
MOV RAX,qword ptr [RCX]
MOV qword ptr [R15 + 0x90],RAX
MOV qword ptr [RCX],R15
CMP dword ptr [R15 + 0x20],0x0
JLE 0x00144caf
MOV R12D,0x8
XOR R13D,R13D
MOV qword ptr [RBP + -0x38],R14
LAB_00144b8d:
MOV RAX,qword ptr [R15 + 0x18]
MOV RBX,qword ptr [RAX + R12*0x1]
MOV RDI,R14
MOV RSI,RBX
MOV EDX,R9D
MOV R14,RCX
MOV R8,qword ptr [RBP + -0x30]
CALL 0x00144a7b
TEST EAX,EAX
JS 0x00144d74
MOV R9D,EAX
MOVZX EAX,byte ptr [RBX + 0x83]
SHL EAX,0x18
CMP EAX,0x3000000
JNZ 0x00144be1
MOV EAX,dword ptr [R15 + 0x88]
MOV ECX,dword ptr [RBX + 0x88]
CMP EAX,ECX
CMOVL ECX,EAX
MOV dword ptr [R15 + 0x88],ECX
JMP 0x00144bf5
LAB_00144be1:
MOV RBX,qword ptr [RBX + 0xb8]
CMP byte ptr [RBX + 0xf0],0x0
JNZ 0x00144d7c
LAB_00144bf5:
MOV RCX,R14
CMP dword ptr [RBX + 0xac],0x0
JZ 0x00144c33
INC dword ptr [R15 + 0xa8]
MOV R8D,dword ptr [RBX + 0xa0]
CMP dword ptr [RBX + 0xa4],R8D
JLE 0x00144c4d
LAB_00144c18:
MOV RAX,qword ptr [RBX + 0x98]
MOVSXD RSI,dword ptr [RBX + 0xa0]
LEA EDX,[RSI + 0x1]
MOV dword ptr [RBX + 0xa0],EDX
MOV qword ptr [RAX + RSI*0x8],R15
LAB_00144c33:
INC R13
MOVSXD RAX,dword ptr [R15 + 0x20]
ADD R12,0x10
CMP R13,RAX
MOV R14,qword ptr [RBP + -0x38]
JL 0x00144b8d
JMP 0x00144caf
LAB_00144c4d:
LEA RSI,[RBX + 0x98]
LEA RCX,[RBX + 0xa4]
INC R8D
MOV RDI,qword ptr [RBP + -0x38]
MOV EDX,0x8
MOV dword ptr [RBP + -0x44],R9D
CALL 0x001434ef
MOV R9D,dword ptr [RBP + -0x44]
MOV RCX,R14
TEST EAX,EAX
JZ 0x00144c18
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RAX + 0x18]
MOV RDX,qword ptr [RCX + 0xf0]
MOV RAX,qword ptr [RCX + 0xf8]
MOV dword ptr [RCX + 0xf0],0x0
MOV qword ptr [RCX + 0xf8],0x4
MOV RBX,qword ptr [RBP + -0x30]
JMP 0x00144ad7
LAB_00144caf:
CMP dword ptr [R15 + 0xa8],0x0
JLE 0x00144ce7
MOV dword ptr [R15 + 0xac],0x1
MOV RAX,qword ptr [R14 + 0x18]
MOV RSI,qword ptr [RAX + 0x158]
LEA RDX,[RSI + 0x1]
MOV qword ptr [RAX + 0x158],RDX
MOV qword ptr [R15 + 0xb0],RSI
MOV RBX,qword ptr [RBP + -0x30]
JMP 0x00144d17
LAB_00144ce7:
MOV RDI,R14
MOV R12D,R9D
MOV R14,RCX
CMP byte ptr [R15 + 0x80],0x0
MOV RBX,qword ptr [RBP + -0x30]
JNZ 0x00144da2
MOV RSI,R15
MOV RDX,RBX
CALL 0x00144ddd
TEST EAX,EAX
MOV RCX,R14
MOV R9D,R12D
JS 0x00144d74
LAB_00144d17:
MOV EAX,dword ptr [R15 + 0x84]
CMP EAX,dword ptr [R15 + 0x88]
JNZ 0x00144d53
LAB_00144d27:
MOV RAX,qword ptr [RCX]
MOV RDX,qword ptr [RAX + 0x90]
MOV qword ptr [RCX],RDX
CMP dword ptr [RAX + 0xac],0x0
SETZ DL
OR DL,0x4
MOV byte ptr [RAX + 0x83],DL
MOV qword ptr [RAX + 0xb8],R15
CMP RAX,R15
JNZ 0x00144d27
LAB_00144d53:
MOV dword ptr [RBX],0x0
MOV EAX,0x3
LAB_00144d5e:
MOV qword ptr [RBX + 0x8],RAX
LAB_00144d62:
MOV EAX,R9D
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00144d74:
MOV R9D,0xffffffff
JMP 0x00144d62
LAB_00144d7c:
MOV RCX,qword ptr [RBX + 0xf8]
MOV RAX,qword ptr [RBX + 0x100]
MOV qword ptr [RBP + -0x40],RCX
CMP EAX,-0x9
JC 0x00144d99
MOV RDX,qword ptr [RBP + -0x40]
INC dword ptr [RDX]
LAB_00144d99:
MOV RBX,qword ptr [RBP + -0x30]
JMP 0x00144b20
LAB_00144da2:
MOV dword ptr [R15 + 0xac],0x1
MOV RAX,qword ptr [RDI + 0x18]
MOV RCX,qword ptr [RAX + 0x158]
LEA RDX,[RCX + 0x1]
MOV qword ptr [RAX + 0x158],RDX
MOV qword ptr [R15 + 0xb0],RCX
MOV RSI,R15
CALL 0x001110af
MOV RCX,R14
MOV R9D,R12D
JMP 0x00144d17
|
int js_inner_module_evaluation
(long param_1,long param_2,int param_3,long *param_4,int8 *param_5)
{
int iVar1;
int8 uVar2;
int *piVar3;
int8 uVar4;
long lVar5;
uint uVar6;
long lVar7;
long lVar8;
if (&stack0xfffffffffffffff8 < *(int1 **)(*(long *)(param_1 + 0x18) + 0xe8)) {
JS_ThrowRangeError(param_1,"Maximum call stack size exceeded");
lVar7 = *(long *)(param_1 + 0x18);
uVar4 = *(int8 *)(lVar7 + 0xf0);
uVar2 = *(int8 *)(lVar7 + 0xf8);
*(int4 *)(lVar7 + 0xf0) = 0;
*(int8 *)(lVar7 + 0xf8) = 4;
LAB_00144ad7:
*param_5 = uVar4;
LAB_00144b23:
param_3 = -1;
}
else {
uVar6 = *(uint *)(param_2 + 0x80) >> 0x18;
if (uVar6 - 4 < 2) {
if (*(char *)(param_2 + 0xf0) != '\0') {
piVar3 = *(int **)(param_2 + 0xf8);
uVar2 = *(int8 *)(param_2 + 0x100);
if (0xfffffff6 < (uint)uVar2) {
*piVar3 = *piVar3 + 1;
}
LAB_00144b20:
*param_5 = piVar3;
goto LAB_00144b23;
}
}
else if (uVar6 != 3) {
*(uint *)(param_2 + 0x80) = *(uint *)(param_2 + 0x80) & 0xffffff | 0x3000000;
*(int *)(param_2 + 0x84) = param_3;
*(int *)(param_2 + 0x88) = param_3;
*(int4 *)(param_2 + 0xa8) = 0;
param_3 = param_3 + 1;
*(long *)(param_2 + 0x90) = *param_4;
*param_4 = param_2;
if (0 < *(int *)(param_2 + 0x20)) {
lVar7 = 8;
lVar8 = 0;
do {
lVar5 = *(long *)(*(long *)(param_2 + 0x18) + lVar7);
param_3 = js_inner_module_evaluation(param_1,lVar5,param_3,param_4,param_5);
if (param_3 < 0) {
return -1;
}
if (*(char *)(lVar5 + 0x83) == '\x03') {
iVar1 = *(int *)(lVar5 + 0x88);
if (*(int *)(param_2 + 0x88) < *(int *)(lVar5 + 0x88)) {
iVar1 = *(int *)(param_2 + 0x88);
}
*(int *)(param_2 + 0x88) = iVar1;
}
else {
lVar5 = *(long *)(lVar5 + 0xb8);
if (*(char *)(lVar5 + 0xf0) != '\0') {
piVar3 = *(int **)(lVar5 + 0xf8);
uVar2 = *(int8 *)(lVar5 + 0x100);
if (0xfffffff6 < (uint)uVar2) {
*piVar3 = *piVar3 + 1;
}
goto LAB_00144b20;
}
}
if (*(int *)(lVar5 + 0xac) != 0) {
*(int *)(param_2 + 0xa8) = *(int *)(param_2 + 0xa8) + 1;
if ((*(int *)(lVar5 + 0xa4) <= *(int *)(lVar5 + 0xa0)) &&
(iVar1 = js_realloc_array(param_1,lVar5 + 0x98,8,lVar5 + 0xa4,
*(int *)(lVar5 + 0xa0) + 1), iVar1 != 0)) {
lVar7 = *(long *)(param_1 + 0x18);
uVar4 = *(int8 *)(lVar7 + 0xf0);
uVar2 = *(int8 *)(lVar7 + 0xf8);
*(int4 *)(lVar7 + 0xf0) = 0;
*(int8 *)(lVar7 + 0xf8) = 4;
goto LAB_00144ad7;
}
iVar1 = *(int *)(lVar5 + 0xa0);
*(int *)(lVar5 + 0xa0) = iVar1 + 1;
*(long *)(*(long *)(lVar5 + 0x98) + (long)iVar1 * 8) = param_2;
}
lVar8 = lVar8 + 1;
lVar7 = lVar7 + 0x10;
} while (lVar8 < *(int *)(param_2 + 0x20));
}
if (*(int *)(param_2 + 0xa8) < 1) {
if (*(char *)(param_2 + 0x80) == '\0') {
iVar1 = js_execute_sync_module(param_1,param_2,param_5);
if (iVar1 < 0) {
return -1;
}
}
else {
*(int4 *)(param_2 + 0xac) = 1;
lVar7 = *(long *)(*(long *)(param_1 + 0x18) + 0x158);
*(long *)(*(long *)(param_1 + 0x18) + 0x158) = lVar7 + 1;
*(long *)(param_2 + 0xb0) = lVar7;
js_execute_async_module(param_1,param_2);
}
}
else {
*(int4 *)(param_2 + 0xac) = 1;
lVar7 = *(long *)(*(long *)(param_1 + 0x18) + 0x158);
*(long *)(*(long *)(param_1 + 0x18) + 0x158) = lVar7 + 1;
*(long *)(param_2 + 0xb0) = lVar7;
}
if (*(int *)(param_2 + 0x84) == *(int *)(param_2 + 0x88)) {
do {
lVar7 = *param_4;
*param_4 = *(long *)(lVar7 + 0x90);
*(byte *)(lVar7 + 0x83) = *(int *)(lVar7 + 0xac) == 0 | 4;
*(long *)(lVar7 + 0xb8) = param_2;
} while (lVar7 != param_2);
}
}
*(int4 *)param_5 = 0;
uVar2 = 3;
}
param_5[1] = uVar2;
return param_3;
}
| |
25,009 | js_inner_module_evaluation | bluesky950520[P]quickjs/quickjs.c | static int js_inner_module_evaluation(JSContext *ctx, JSModuleDef *m,
int index, JSModuleDef **pstack_top,
JSValue *pvalue)
{
JSModuleDef *m1;
int i;
if (js_check_stack_overflow(ctx->rt, 0)) {
JS_ThrowStackOverflow(ctx);
*pvalue = JS_GetException(ctx);
return -1;
}
#ifdef DUMP_MODULE_RESOLVE
if (check_dump_flag(ctx->rt, DUMP_MODULE_RESOLVE)) {
char buf1[ATOM_GET_STR_BUF_SIZE];
printf("js_inner_module_evaluation '%s':\n", JS_AtomGetStr(ctx, buf1, sizeof(buf1), m->module_name));
}
#endif
if (m->status == JS_MODULE_STATUS_EVALUATING_ASYNC ||
m->status == JS_MODULE_STATUS_EVALUATED) {
if (m->eval_has_exception) {
*pvalue = JS_DupValue(ctx, m->eval_exception);
return -1;
} else {
*pvalue = JS_UNDEFINED;
return index;
}
}
if (m->status == JS_MODULE_STATUS_EVALUATING) {
*pvalue = JS_UNDEFINED;
return index;
}
assert(m->status == JS_MODULE_STATUS_LINKED);
m->status = JS_MODULE_STATUS_EVALUATING;
m->dfs_index = index;
m->dfs_ancestor_index = index;
m->pending_async_dependencies = 0;
index++;
/* push 'm' on stack */
m->stack_prev = *pstack_top;
*pstack_top = m;
for(i = 0; i < m->req_module_entries_count; i++) {
JSReqModuleEntry *rme = &m->req_module_entries[i];
m1 = rme->module;
index = js_inner_module_evaluation(ctx, m1, index, pstack_top, pvalue);
if (index < 0)
return -1;
assert(m1->status == JS_MODULE_STATUS_EVALUATING ||
m1->status == JS_MODULE_STATUS_EVALUATING_ASYNC ||
m1->status == JS_MODULE_STATUS_EVALUATED);
if (m1->status == JS_MODULE_STATUS_EVALUATING) {
m->dfs_ancestor_index = min_int(m->dfs_ancestor_index,
m1->dfs_ancestor_index);
} else {
m1 = m1->cycle_root;
assert(m1->status == JS_MODULE_STATUS_EVALUATING_ASYNC ||
m1->status == JS_MODULE_STATUS_EVALUATED);
if (m1->eval_has_exception) {
*pvalue = JS_DupValue(ctx, m1->eval_exception);
return -1;
}
}
if (m1->async_evaluation) {
m->pending_async_dependencies++;
if (js_resize_array(ctx, (void **)&m1->async_parent_modules, sizeof(m1->async_parent_modules[0]), &m1->async_parent_modules_size, m1->async_parent_modules_count + 1)) {
*pvalue = JS_GetException(ctx);
return -1;
}
m1->async_parent_modules[m1->async_parent_modules_count++] = m;
}
}
if (m->pending_async_dependencies > 0) {
assert(!m->async_evaluation);
m->async_evaluation = TRUE;
m->async_evaluation_timestamp =
ctx->rt->module_async_evaluation_next_timestamp++;
} else if (m->has_tla) {
assert(!m->async_evaluation);
m->async_evaluation = TRUE;
m->async_evaluation_timestamp =
ctx->rt->module_async_evaluation_next_timestamp++;
js_execute_async_module(ctx, m);
} else {
if (js_execute_sync_module(ctx, m, pvalue) < 0)
return -1;
}
assert(m->dfs_ancestor_index <= m->dfs_index);
if (m->dfs_index == m->dfs_ancestor_index) {
for(;;) {
/* pop m1 from stack */
m1 = *pstack_top;
*pstack_top = m1->stack_prev;
if (!m1->async_evaluation) {
m1->status = JS_MODULE_STATUS_EVALUATED;
} else {
m1->status = JS_MODULE_STATUS_EVALUATING_ASYNC;
}
/* spec bug: cycle_root must be assigned before the test */
m1->cycle_root = m;
if (m1 == m)
break;
}
}
*pvalue = JS_UNDEFINED;
return index;
} | O2 | c | js_inner_module_evaluation:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rdi, %r12
movq 0x18(%rdi), %rax
cmpq %rbp, 0xe8(%rax)
jbe 0x3c5aa
movq %r12, %rdi
callq 0x35d91
movq 0x18(%r12), %rcx
movq 0xf0(%rcx), %rdx
movq 0xf8(%rcx), %rax
andl $0x0, 0xf0(%rcx)
movq $0x4, 0xf8(%rcx)
movq %rdx, (%rbx)
jmp 0x3c5e5
movl %edx, %r14d
movq %rsi, %r15
movl 0x80(%rsi), %eax
movl %eax, %esi
shrl $0x18, %esi
leal -0x4(%rsi), %edx
cmpl $0x2, %edx
jae 0x3c5eb
cmpb $0x0, 0xf0(%r15)
je 0x3c5f0
movq 0xf8(%r15), %rcx
movq 0x100(%r15), %rax
cmpl $-0x9, %eax
jb 0x3c5e2
incl (%rcx)
movq %rcx, (%rbx)
pushq $-0x1
popq %r14
jmp 0x3c5f6
cmpl $0x3, %esi
jne 0x3c60c
andl $0x0, (%rbx)
pushq $0x3
popq %rax
movq %rax, 0x8(%rbx)
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, -0x30(%rbp)
movq %rbx, -0x38(%rbp)
andl $0xffffff, %eax # imm = 0xFFFFFF
orl $0x3000000, %eax # imm = 0x3000000
movl %eax, 0x80(%r15)
movl %r14d, 0x84(%r15)
movl %r14d, 0x88(%r15)
andl $0x0, 0xa8(%r15)
incl %r14d
movq (%rcx), %rax
movq %rax, 0x90(%r15)
movq %rcx, -0x40(%rbp)
movq %r15, (%rcx)
pushq $0x8
popq %r12
xorl %r13d, %r13d
movslq 0x20(%r15), %rax
cmpq %rax, %r13
jge 0x3c72c
movq 0x18(%r15), %rax
movq (%rax,%r12), %rbx
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
movl %r14d, %edx
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0x3c554
testl %eax, %eax
js 0x3c773
movl %eax, %r14d
movzbl 0x83(%rbx), %eax
shll $0x18, %eax
cmpl $0x3000000, %eax # imm = 0x3000000
jne 0x3c6b9
movl 0x88(%r15), %eax
movl 0x88(%rbx), %ecx
cmpl %ecx, %eax
cmovll %eax, %ecx
movl %ecx, 0x88(%r15)
jmp 0x3c6cd
movq 0xb8(%rbx), %rbx
cmpb $0x0, 0xf0(%rbx)
jne 0x3c7ac
cmpl $0x0, 0xac(%rbx)
je 0x3c720
incl 0xa8(%r15)
leaq 0x98(%rbx), %rsi
leaq 0xa4(%rbx), %rcx
movl 0xa0(%rbx), %r8d
incl %r8d
movq -0x30(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x3b0ef
testl %eax, %eax
jne 0x3c77b
movq 0x98(%rbx), %rax
movslq 0xa0(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0xa0(%rbx)
movq %r15, (%rax,%rcx,8)
incq %r13
addq $0x10, %r12
jmp 0x3c656
cmpl $0x0, 0xa8(%r15)
jle 0x3c7ca
movl $0x1, 0xac(%r15)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x158(%rax), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x158(%rax)
movq %rcx, 0xb0(%r15)
movq -0x38(%rbp), %rbx
movq -0x40(%rbp), %r12
jmp 0x3c82c
pushq $-0x1
popq %rax
jmp 0x3c5fd
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
movq 0xf0(%rcx), %rdx
movq 0xf8(%rcx), %rax
andl $0x0, 0xf0(%rcx)
movq $0x4, 0xf8(%rcx)
movq -0x38(%rbp), %rbx
jmp 0x3c5a5
movq 0xf8(%rbx), %rcx
movq 0x100(%rbx), %rax
cmpl $-0x9, %eax
jb 0x3c7c1
incl (%rcx)
movq -0x38(%rbp), %rbx
jmp 0x3c5e2
cmpb $0x0, 0x80(%r15)
movq -0x38(%rbp), %rbx
movq -0x40(%rbp), %r12
je 0x3c812
movl $0x1, 0xac(%r15)
movq -0x30(%rbp), %rdi
movq 0x18(%rdi), %rax
movq 0x158(%rax), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x158(%rax)
movq %rcx, 0xb0(%r15)
movq %r15, %rsi
callq 0x3c873
jmp 0x3c82c
movq -0x30(%rbp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3c994
testl %eax, %eax
pushq $-0x1
popq %rax
js 0x3c5fd
movl 0x84(%r15), %eax
cmpl 0x88(%r15), %eax
jne 0x3c5f0
movq (%r12), %rax
movq 0x90(%rax), %rcx
movq %rcx, (%r12)
cmpl $0x0, 0xac(%rax)
sete %cl
orb $0x4, %cl
movb %cl, 0x83(%rax)
movq %r15, 0xb8(%rax)
cmpq %r15, %rax
jne 0x3c840
jmp 0x3c5f0
| js_inner_module_evaluation:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, r8
mov r12, rdi
mov rax, [rdi+18h]
cmp [rax+0E8h], rbp
jbe short loc_3C5AA
mov rdi, r12
call JS_ThrowStackOverflow
mov rcx, [r12+18h]
mov rdx, [rcx+0F0h]
mov rax, [rcx+0F8h]
and dword ptr [rcx+0F0h], 0
mov qword ptr [rcx+0F8h], 4
loc_3C5A5:
mov [rbx], rdx
jmp short loc_3C5E5
loc_3C5AA:
mov r14d, edx
mov r15, rsi
mov eax, [rsi+80h]
mov esi, eax
shr esi, 18h
lea edx, [rsi-4]
cmp edx, 2
jnb short loc_3C5EB
cmp byte ptr [r15+0F0h], 0
jz short loc_3C5F0
mov rcx, [r15+0F8h]
mov rax, [r15+100h]
cmp eax, 0FFFFFFF7h
jb short loc_3C5E2
inc dword ptr [rcx]
loc_3C5E2:
mov [rbx], rcx
loc_3C5E5:
push 0FFFFFFFFFFFFFFFFh
pop r14
jmp short loc_3C5F6
loc_3C5EB:
cmp esi, 3
jnz short loc_3C60C
loc_3C5F0:
and dword ptr [rbx], 0
push 3
pop rax
loc_3C5F6:
mov [rbx+8], rax
mov eax, r14d
loc_3C5FD:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3C60C:
mov [rbp+var_30], r12
mov [rbp+var_38], rbx
and eax, 0FFFFFFh
or eax, 3000000h
mov [r15+80h], eax
mov [r15+84h], r14d
mov [r15+88h], r14d
and dword ptr [r15+0A8h], 0
inc r14d
mov rax, [rcx]
mov [r15+90h], rax
mov [rbp+var_40], rcx
mov [rcx], r15
push 8
pop r12
xor r13d, r13d
loc_3C656:
movsxd rax, dword ptr [r15+20h]
cmp r13, rax
jge loc_3C72C
mov rax, [r15+18h]
mov rbx, [rax+r12]
mov rdi, [rbp+var_30]
mov rsi, rbx
mov edx, r14d
mov rcx, [rbp+var_40]
mov r8, [rbp+var_38]
call js_inner_module_evaluation
test eax, eax
js loc_3C773
mov r14d, eax
movzx eax, byte ptr [rbx+83h]
shl eax, 18h
cmp eax, 3000000h
jnz short loc_3C6B9
mov eax, [r15+88h]
mov ecx, [rbx+88h]
cmp eax, ecx
cmovl ecx, eax
mov [r15+88h], ecx
jmp short loc_3C6CD
loc_3C6B9:
mov rbx, [rbx+0B8h]
cmp byte ptr [rbx+0F0h], 0
jnz loc_3C7AC
loc_3C6CD:
cmp dword ptr [rbx+0ACh], 0
jz short loc_3C720
inc dword ptr [r15+0A8h]
lea rsi, [rbx+98h]
lea rcx, [rbx+0A4h]
mov r8d, [rbx+0A0h]
inc r8d
mov rdi, [rbp+var_30]
push 8
pop rdx
call js_resize_array
test eax, eax
jnz short loc_3C77B
mov rax, [rbx+98h]
movsxd rcx, dword ptr [rbx+0A0h]
lea edx, [rcx+1]
mov [rbx+0A0h], edx
mov [rax+rcx*8], r15
loc_3C720:
inc r13
add r12, 10h
jmp loc_3C656
loc_3C72C:
cmp dword ptr [r15+0A8h], 0
jle loc_3C7CA
mov dword ptr [r15+0ACh], 1
mov rax, [rbp+var_30]
mov rax, [rax+18h]
mov rcx, [rax+158h]
lea rdx, [rcx+1]
mov [rax+158h], rdx
mov [r15+0B0h], rcx
mov rbx, [rbp+var_38]
mov r12, [rbp+var_40]
jmp loc_3C82C
loc_3C773:
push 0FFFFFFFFFFFFFFFFh
pop rax
jmp loc_3C5FD
loc_3C77B:
mov rax, [rbp+var_30]
mov rcx, [rax+18h]
mov rdx, [rcx+0F0h]
mov rax, [rcx+0F8h]
and dword ptr [rcx+0F0h], 0
mov qword ptr [rcx+0F8h], 4
mov rbx, [rbp+var_38]
jmp loc_3C5A5
loc_3C7AC:
mov rcx, [rbx+0F8h]
mov rax, [rbx+100h]
cmp eax, 0FFFFFFF7h
jb short loc_3C7C1
inc dword ptr [rcx]
loc_3C7C1:
mov rbx, [rbp+var_38]
jmp loc_3C5E2
loc_3C7CA:
cmp byte ptr [r15+80h], 0
mov rbx, [rbp+var_38]
mov r12, [rbp+var_40]
jz short loc_3C812
mov dword ptr [r15+0ACh], 1
mov rdi, [rbp+var_30]
mov rax, [rdi+18h]
mov rcx, [rax+158h]
lea rdx, [rcx+1]
mov [rax+158h], rdx
mov [r15+0B0h], rcx
mov rsi, r15
call js_execute_async_module
jmp short loc_3C82C
loc_3C812:
mov rdi, [rbp+var_30]
mov rsi, r15
mov rdx, rbx
call js_execute_sync_module
test eax, eax
push 0FFFFFFFFFFFFFFFFh
pop rax
js loc_3C5FD
loc_3C82C:
mov eax, [r15+84h]
cmp eax, [r15+88h]
jnz loc_3C5F0
loc_3C840:
mov rax, [r12]
mov rcx, [rax+90h]
mov [r12], rcx
cmp dword ptr [rax+0ACh], 0
setz cl
or cl, 4
mov [rax+83h], cl
mov [rax+0B8h], r15
cmp rax, r15
jnz short loc_3C840
jmp loc_3C5F0
| long long js_inner_module_evaluation(
long long a1,
long long a2,
long long a3,
long long *a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
_QWORD *v14; // rbx
long long v15; // rcx
long long v16; // rdx
long long v17; // rax
unsigned int v18; // r14d
unsigned int v19; // eax
_DWORD *v20; // rcx
long long result; // rax
long long v22; // r12
long long i; // r13
long long v24; // rbx
int v25; // eax
int v26; // ecx
long long v27; // rax
long long v28; // rcx
long long v29; // rax
long long v30; // rcx
long long *v31; // r12
long long v32; // rcx
long long v33; // rax
long long v34; // rcx
bool v35; // sf
long long v36; // rax
char v37; // [rsp+0h] [rbp-40h]
long long savedregs; // [rsp+40h] [rbp+0h] BYREF
v14 = (_QWORD *)a5;
if ( *(_QWORD *)(*(_QWORD *)(a1 + 24) + 232LL) <= (unsigned long long)&savedregs )
{
v18 = a3;
v19 = *(_DWORD *)(a2 + 128);
if ( HIBYTE(v19) - 4 >= 2u )
{
if ( HIBYTE(v19) != 3 )
{
*(_DWORD *)(a2 + 128) = v19 & 0xFFFFFF | 0x3000000;
*(_DWORD *)(a2 + 132) = a3;
*(_DWORD *)(a2 + 136) = a3;
*(_DWORD *)(a2 + 168) = 0;
v18 = a3 + 1;
*(_QWORD *)(a2 + 144) = *a4;
*a4 = a2;
v22 = 8LL;
for ( i = 0LL; i < *(int *)(a2 + 32); ++i )
{
v24 = *(_QWORD *)(*(_QWORD *)(a2 + 24) + v22);
v25 = js_inner_module_evaluation(a1, v24, v18, a4, a5);
if ( v25 < 0 )
return -1LL;
v18 = v25;
if ( *(unsigned __int8 *)(v24 + 131) << 24 == 50331648 )
{
v26 = *(_DWORD *)(v24 + 136);
if ( *(_DWORD *)(a2 + 136) < v26 )
v26 = *(_DWORD *)(a2 + 136);
*(_DWORD *)(a2 + 136) = v26;
}
else
{
v24 = *(_QWORD *)(v24 + 184);
if ( *(_BYTE *)(v24 + 240) )
{
v20 = *(_DWORD **)(v24 + 248);
v17 = *(_QWORD *)(v24 + 256);
if ( (unsigned int)v17 >= 0xFFFFFFF7 )
++*v20;
v14 = (_QWORD *)a5;
goto LABEL_8;
}
}
if ( *(_DWORD *)(v24 + 172) )
{
++*(_DWORD *)(a2 + 168);
if ( (unsigned int)js_resize_array(a1, v24 + 152, 8LL, (_DWORD *)(v24 + 164), *(_DWORD *)(v24 + 160) + 1) )
{
v32 = *(_QWORD *)(a1 + 24);
v16 = *(_QWORD *)(v32 + 240);
v17 = *(_QWORD *)(v32 + 248);
*(_DWORD *)(v32 + 240) = 0;
*(_QWORD *)(v32 + 248) = 4LL;
v14 = (_QWORD *)a5;
goto LABEL_3;
}
v27 = *(_QWORD *)(v24 + 152);
v28 = *(int *)(v24 + 160);
*(_DWORD *)(v24 + 160) = v28 + 1;
*(_QWORD *)(v27 + 8 * v28) = a2;
}
v22 += 16LL;
}
if ( *(int *)(a2 + 168) <= 0 )
{
v14 = (_QWORD *)a5;
v31 = a4;
if ( *(_BYTE *)(a2 + 128) )
{
*(_DWORD *)(a2 + 172) = 1;
v33 = *(_QWORD *)(a1 + 24);
v34 = *(_QWORD *)(v33 + 344);
*(_QWORD *)(v33 + 344) = v34 + 1;
*(_QWORD *)(a2 + 176) = v34;
js_execute_async_module(a1, a2);
}
else
{
v35 = (int)js_execute_sync_module(a1, a2, a5) < 0;
result = -1LL;
if ( v35 )
return result;
}
}
else
{
*(_DWORD *)(a2 + 172) = 1;
v29 = *(_QWORD *)(a1 + 24);
v30 = *(_QWORD *)(v29 + 344);
*(_QWORD *)(v29 + 344) = v30 + 1;
*(_QWORD *)(a2 + 176) = v30;
v14 = (_QWORD *)a5;
v31 = a4;
}
if ( *(_DWORD *)(a2 + 132) == *(_DWORD *)(a2 + 136) )
{
do
{
v36 = *v31;
*v31 = *(_QWORD *)(*v31 + 144);
*(_BYTE *)(v36 + 131) = (*(_DWORD *)(v36 + 172) == 0) | 4;
*(_QWORD *)(v36 + 184) = a2;
}
while ( v36 != a2 );
}
}
}
else if ( *(_BYTE *)(a2 + 240) )
{
v20 = *(_DWORD **)(a2 + 248);
v17 = *(_QWORD *)(a2 + 256);
if ( (unsigned int)v17 >= 0xFFFFFFF7 )
++*v20;
LABEL_8:
*v14 = v20;
goto LABEL_9;
}
*(_DWORD *)v14 = 0;
v17 = 3LL;
goto LABEL_12;
}
JS_ThrowStackOverflow(a1, a7, a8, a9, a10, a11, a12, a13, a14, a2, a3, (long long)a4, a5, a6, v37);
v15 = *(_QWORD *)(a1 + 24);
v16 = *(_QWORD *)(v15 + 240);
v17 = *(_QWORD *)(v15 + 248);
*(_DWORD *)(v15 + 240) = 0;
*(_QWORD *)(v15 + 248) = 4LL;
LABEL_3:
*v14 = v16;
LABEL_9:
v18 = -1;
LABEL_12:
v14[1] = v17;
return v18;
}
| js_inner_module_evaluation:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,R8
MOV R12,RDI
MOV RAX,qword ptr [RDI + 0x18]
CMP qword ptr [RAX + 0xe8],RBP
JBE 0x0013c5aa
MOV RDI,R12
CALL 0x00135d91
MOV RCX,qword ptr [R12 + 0x18]
MOV RDX,qword ptr [RCX + 0xf0]
MOV RAX,qword ptr [RCX + 0xf8]
AND dword ptr [RCX + 0xf0],0x0
MOV qword ptr [RCX + 0xf8],0x4
LAB_0013c5a5:
MOV qword ptr [RBX],RDX
JMP 0x0013c5e5
LAB_0013c5aa:
MOV R14D,EDX
MOV R15,RSI
MOV EAX,dword ptr [RSI + 0x80]
MOV ESI,EAX
SHR ESI,0x18
LEA EDX,[RSI + -0x4]
CMP EDX,0x2
JNC 0x0013c5eb
CMP byte ptr [R15 + 0xf0],0x0
JZ 0x0013c5f0
MOV RCX,qword ptr [R15 + 0xf8]
MOV RAX,qword ptr [R15 + 0x100]
CMP EAX,-0x9
JC 0x0013c5e2
INC dword ptr [RCX]
LAB_0013c5e2:
MOV qword ptr [RBX],RCX
LAB_0013c5e5:
PUSH -0x1
POP R14
JMP 0x0013c5f6
LAB_0013c5eb:
CMP ESI,0x3
JNZ 0x0013c60c
LAB_0013c5f0:
AND dword ptr [RBX],0x0
PUSH 0x3
POP RAX
LAB_0013c5f6:
MOV qword ptr [RBX + 0x8],RAX
MOV EAX,R14D
LAB_0013c5fd:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013c60c:
MOV qword ptr [RBP + -0x30],R12
MOV qword ptr [RBP + -0x38],RBX
AND EAX,0xffffff
OR EAX,0x3000000
MOV dword ptr [R15 + 0x80],EAX
MOV dword ptr [R15 + 0x84],R14D
MOV dword ptr [R15 + 0x88],R14D
AND dword ptr [R15 + 0xa8],0x0
INC R14D
MOV RAX,qword ptr [RCX]
MOV qword ptr [R15 + 0x90],RAX
MOV qword ptr [RBP + -0x40],RCX
MOV qword ptr [RCX],R15
PUSH 0x8
POP R12
XOR R13D,R13D
LAB_0013c656:
MOVSXD RAX,dword ptr [R15 + 0x20]
CMP R13,RAX
JGE 0x0013c72c
MOV RAX,qword ptr [R15 + 0x18]
MOV RBX,qword ptr [RAX + R12*0x1]
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,RBX
MOV EDX,R14D
MOV RCX,qword ptr [RBP + -0x40]
MOV R8,qword ptr [RBP + -0x38]
CALL 0x0013c554
TEST EAX,EAX
JS 0x0013c773
MOV R14D,EAX
MOVZX EAX,byte ptr [RBX + 0x83]
SHL EAX,0x18
CMP EAX,0x3000000
JNZ 0x0013c6b9
MOV EAX,dword ptr [R15 + 0x88]
MOV ECX,dword ptr [RBX + 0x88]
CMP EAX,ECX
CMOVL ECX,EAX
MOV dword ptr [R15 + 0x88],ECX
JMP 0x0013c6cd
LAB_0013c6b9:
MOV RBX,qword ptr [RBX + 0xb8]
CMP byte ptr [RBX + 0xf0],0x0
JNZ 0x0013c7ac
LAB_0013c6cd:
CMP dword ptr [RBX + 0xac],0x0
JZ 0x0013c720
INC dword ptr [R15 + 0xa8]
LEA RSI,[RBX + 0x98]
LEA RCX,[RBX + 0xa4]
MOV R8D,dword ptr [RBX + 0xa0]
INC R8D
MOV RDI,qword ptr [RBP + -0x30]
PUSH 0x8
POP RDX
CALL 0x0013b0ef
TEST EAX,EAX
JNZ 0x0013c77b
MOV RAX,qword ptr [RBX + 0x98]
MOVSXD RCX,dword ptr [RBX + 0xa0]
LEA EDX,[RCX + 0x1]
MOV dword ptr [RBX + 0xa0],EDX
MOV qword ptr [RAX + RCX*0x8],R15
LAB_0013c720:
INC R13
ADD R12,0x10
JMP 0x0013c656
LAB_0013c72c:
CMP dword ptr [R15 + 0xa8],0x0
JLE 0x0013c7ca
MOV dword ptr [R15 + 0xac],0x1
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RAX + 0x158]
LEA RDX,[RCX + 0x1]
MOV qword ptr [RAX + 0x158],RDX
MOV qword ptr [R15 + 0xb0],RCX
MOV RBX,qword ptr [RBP + -0x38]
MOV R12,qword ptr [RBP + -0x40]
JMP 0x0013c82c
LAB_0013c773:
PUSH -0x1
POP RAX
JMP 0x0013c5fd
LAB_0013c77b:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RAX + 0x18]
MOV RDX,qword ptr [RCX + 0xf0]
MOV RAX,qword ptr [RCX + 0xf8]
AND dword ptr [RCX + 0xf0],0x0
MOV qword ptr [RCX + 0xf8],0x4
MOV RBX,qword ptr [RBP + -0x38]
JMP 0x0013c5a5
LAB_0013c7ac:
MOV RCX,qword ptr [RBX + 0xf8]
MOV RAX,qword ptr [RBX + 0x100]
CMP EAX,-0x9
JC 0x0013c7c1
INC dword ptr [RCX]
LAB_0013c7c1:
MOV RBX,qword ptr [RBP + -0x38]
JMP 0x0013c5e2
LAB_0013c7ca:
CMP byte ptr [R15 + 0x80],0x0
MOV RBX,qword ptr [RBP + -0x38]
MOV R12,qword ptr [RBP + -0x40]
JZ 0x0013c812
MOV dword ptr [R15 + 0xac],0x1
MOV RDI,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RDI + 0x18]
MOV RCX,qword ptr [RAX + 0x158]
LEA RDX,[RCX + 0x1]
MOV qword ptr [RAX + 0x158],RDX
MOV qword ptr [R15 + 0xb0],RCX
MOV RSI,R15
CALL 0x0013c873
JMP 0x0013c82c
LAB_0013c812:
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,R15
MOV RDX,RBX
CALL 0x0013c994
TEST EAX,EAX
PUSH -0x1
POP RAX
JS 0x0013c5fd
LAB_0013c82c:
MOV EAX,dword ptr [R15 + 0x84]
CMP EAX,dword ptr [R15 + 0x88]
JNZ 0x0013c5f0
LAB_0013c840:
MOV RAX,qword ptr [R12]
MOV RCX,qword ptr [RAX + 0x90]
MOV qword ptr [R12],RCX
CMP dword ptr [RAX + 0xac],0x0
SETZ CL
OR CL,0x4
MOV byte ptr [RAX + 0x83],CL
MOV qword ptr [RAX + 0xb8],R15
CMP RAX,R15
JNZ 0x0013c840
JMP 0x0013c5f0
|
ulong js_inner_module_evaluation
(long param_1,long param_2,uint param_3,long *param_4,int8 *param_5)
{
int iVar1;
int8 uVar2;
int *piVar3;
int8 uVar4;
long lVar5;
uint uVar6;
long lVar7;
long lVar8;
if (&stack0xfffffffffffffff8 < *(int1 **)(*(long *)(param_1 + 0x18) + 0xe8)) {
JS_ThrowStackOverflow(param_1);
lVar7 = *(long *)(param_1 + 0x18);
uVar4 = *(int8 *)(lVar7 + 0xf0);
uVar2 = *(int8 *)(lVar7 + 0xf8);
*(int4 *)(lVar7 + 0xf0) = 0;
*(int8 *)(lVar7 + 0xf8) = 4;
LAB_0013c5a5:
*param_5 = uVar4;
LAB_0013c5e5:
param_3 = 0xffffffff;
}
else {
uVar6 = *(uint *)(param_2 + 0x80) >> 0x18;
if (uVar6 - 4 < 2) {
if (*(char *)(param_2 + 0xf0) != '\0') {
piVar3 = *(int **)(param_2 + 0xf8);
uVar2 = *(int8 *)(param_2 + 0x100);
if (0xfffffff6 < (uint)uVar2) {
*piVar3 = *piVar3 + 1;
}
LAB_0013c5e2:
*param_5 = piVar3;
goto LAB_0013c5e5;
}
}
else if (uVar6 != 3) {
*(uint *)(param_2 + 0x80) = *(uint *)(param_2 + 0x80) & 0xffffff | 0x3000000;
*(uint *)(param_2 + 0x84) = param_3;
*(uint *)(param_2 + 0x88) = param_3;
*(int4 *)(param_2 + 0xa8) = 0;
param_3 = param_3 + 1;
*(long *)(param_2 + 0x90) = *param_4;
*param_4 = param_2;
lVar7 = 8;
for (lVar8 = 0; lVar8 < *(int *)(param_2 + 0x20); lVar8 = lVar8 + 1) {
lVar5 = *(long *)(*(long *)(param_2 + 0x18) + lVar7);
param_3 = js_inner_module_evaluation(param_1,lVar5,param_3,param_4,param_5);
if ((int)param_3 < 0) {
return 0xffffffffffffffff;
}
if (*(char *)(lVar5 + 0x83) == '\x03') {
iVar1 = *(int *)(lVar5 + 0x88);
if (*(int *)(param_2 + 0x88) < *(int *)(lVar5 + 0x88)) {
iVar1 = *(int *)(param_2 + 0x88);
}
*(int *)(param_2 + 0x88) = iVar1;
}
else {
lVar5 = *(long *)(lVar5 + 0xb8);
if (*(char *)(lVar5 + 0xf0) != '\0') {
piVar3 = *(int **)(lVar5 + 0xf8);
uVar2 = *(int8 *)(lVar5 + 0x100);
if (0xfffffff6 < (uint)uVar2) {
*piVar3 = *piVar3 + 1;
}
goto LAB_0013c5e2;
}
}
if (*(int *)(lVar5 + 0xac) != 0) {
*(int *)(param_2 + 0xa8) = *(int *)(param_2 + 0xa8) + 1;
iVar1 = js_resize_array(param_1,lVar5 + 0x98,8,lVar5 + 0xa4,*(int *)(lVar5 + 0xa0) + 1);
if (iVar1 != 0) {
lVar7 = *(long *)(param_1 + 0x18);
uVar4 = *(int8 *)(lVar7 + 0xf0);
uVar2 = *(int8 *)(lVar7 + 0xf8);
*(int4 *)(lVar7 + 0xf0) = 0;
*(int8 *)(lVar7 + 0xf8) = 4;
goto LAB_0013c5a5;
}
iVar1 = *(int *)(lVar5 + 0xa0);
*(int *)(lVar5 + 0xa0) = iVar1 + 1;
*(long *)(*(long *)(lVar5 + 0x98) + (long)iVar1 * 8) = param_2;
}
lVar7 = lVar7 + 0x10;
}
if (*(int *)(param_2 + 0xa8) < 1) {
if (*(char *)(param_2 + 0x80) == '\0') {
iVar1 = js_execute_sync_module(param_1,param_2,param_5);
if (iVar1 < 0) {
return 0xffffffffffffffff;
}
}
else {
*(int4 *)(param_2 + 0xac) = 1;
lVar7 = *(long *)(*(long *)(param_1 + 0x18) + 0x158);
*(long *)(*(long *)(param_1 + 0x18) + 0x158) = lVar7 + 1;
*(long *)(param_2 + 0xb0) = lVar7;
js_execute_async_module(param_1,param_2);
}
}
else {
*(int4 *)(param_2 + 0xac) = 1;
lVar7 = *(long *)(*(long *)(param_1 + 0x18) + 0x158);
*(long *)(*(long *)(param_1 + 0x18) + 0x158) = lVar7 + 1;
*(long *)(param_2 + 0xb0) = lVar7;
}
if (*(int *)(param_2 + 0x84) == *(int *)(param_2 + 0x88)) {
do {
lVar7 = *param_4;
*param_4 = *(long *)(lVar7 + 0x90);
*(byte *)(lVar7 + 0x83) = *(int *)(lVar7 + 0xac) == 0 | 4;
*(long *)(lVar7 + 0xb8) = param_2;
} while (lVar7 != param_2);
}
}
*(int4 *)param_5 = 0;
uVar2 = 3;
}
param_5[1] = uVar2;
return (ulong)param_3;
}
| |
25,010 | minja::SetTemplateNode::SetTemplateNode(minja::Location const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<minja::TemplateNode>&&) | monkey531[P]llama/common/minja.hpp | SetTemplateNode(const Location & location, const std::string & name, std::shared_ptr<TemplateNode> && tv)
: TemplateNode(location), name(name), template_value(std::move(tv)) {} | O3 | cpp | minja::SetTemplateNode::SetTemplateNode(minja::Location const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<minja::TemplateNode>&&):
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x8c27c(%rip), %r15 # 0x12ffc8
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 0xa3d7c
movq 0x8d212(%rip), %rcx # 0x130f80
cmpb $0x0, (%rcx)
je 0xa3d78
incl 0x8(%rax)
jmp 0xa3d7c
lock
incl 0x8(%rax)
movq 0x10(%rsi), %rax
movq %rax, 0x18(%rbx)
leaq 0x8c63d(%rip), %rax # 0x1303c8
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 0x28a54
xorl %eax, %eax
movq %rax, 0x48(%rbx)
movups (%r14), %xmm0
movq %rax, 0x8(%r14)
movups %xmm0, 0x40(%rbx)
movq %rax, (%r14)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xa3ddc
callq 0x33c02
movq %r14, %rdi
callq 0x1bff0
| _ZN5minja15SetTemplateNodeC2ERKNS_8LocationERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEOSt10shared_ptrINS_12TemplateNodeEE:
push r15
push r14
push rbx
mov r14, rcx
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_A3D7C
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_A3D78
inc dword ptr [rax+8]
jmp short loc_A3D7C
loc_A3D78:
lock inc dword ptr [rax+8]
loc_A3D7C:
mov rax, [rsi+10h]
mov [rbx+18h], rax
lea rax, _ZTVN5minja15SetTemplateNodeE; `vtable for'minja::SetTemplateNode
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)
xor eax, eax
mov [rbx+48h], rax
movups xmm0, xmmword ptr [r14]
mov [r14+8], rax
movups xmmword ptr [rbx+40h], xmm0
mov [r14], rax
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov [rbx], r15
mov rdi, [rbx+10h]
test rdi, rdi
jz short loc_A3DDC
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A3DDC:
mov rdi, r14
call __Unwind_Resume
| long long minja::SetTemplateNode::SetTemplateNode(long long a1, _QWORD *a2, long long a3, __int128 *a4)
{
long long v5; // rax
long long result; // rax
__int128 v7; // xmm0
*(_QWORD *)a1 = &`vtable for'minja::TemplateNode + 2;
*(_QWORD *)(a1 + 8) = *a2;
v5 = a2[1];
*(_QWORD *)(a1 + 16) = v5;
if ( v5 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v5 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v5 + 8));
}
*(_QWORD *)(a1 + 24) = a2[2];
*(_QWORD *)a1 = &`vtable for'minja::SetTemplateNode + 2;
*(_QWORD *)(a1 + 32) = a1 + 48;
std::string::_M_construct<char *>(a1 + 32, *(_BYTE **)a3, *(_QWORD *)a3 + *(_QWORD *)(a3 + 8));
result = 0LL;
*(_QWORD *)(a1 + 72) = 0LL;
v7 = *a4;
*((_QWORD *)a4 + 1) = 0LL;
*(_OWORD *)(a1 + 64) = v7;
*(_QWORD *)a4 = 0LL;
return result;
}
| SetTemplateNode:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RCX
MOV RBX,RDI
LEA R15,[0x22ffc8]
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 0x001a3d7c
MOV RCX,qword ptr [0x00230f80]
CMP byte ptr [RCX],0x0
JZ 0x001a3d78
INC dword ptr [RAX + 0x8]
JMP 0x001a3d7c
LAB_001a3d78:
INC.LOCK dword ptr [RAX + 0x8]
LAB_001a3d7c:
MOV RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RBX + 0x18],RAX
LEA RAX,[0x2303c8]
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_001a3da8:
CALL 0x00128a54
LAB_001a3dad:
XOR EAX,EAX
MOV qword ptr [RBX + 0x48],RAX
MOVUPS XMM0,xmmword ptr [R14]
MOV qword ptr [R14 + 0x8],RAX
MOVUPS xmmword ptr [RBX + 0x40],XMM0
MOV qword ptr [R14],RAX
POP RBX
POP R14
POP R15
RET
|
/* minja::SetTemplateNode::SetTemplateNode(minja::Location const&, std::__cxx11::string const&,
std::shared_ptr<minja::TemplateNode>&&) */
void __thiscall
minja::SetTemplateNode::SetTemplateNode
(SetTemplateNode *this,Location *param_1,string *param_2,shared_ptr *param_3)
{
long lVar1;
int8 uVar2;
*(int ***)this = &PTR___cxa_pure_virtual_0022ffd8;
*(int8 *)(this + 8) = *(int8 *)param_1;
lVar1 = *(long *)(param_1 + 8);
*(long *)(this + 0x10) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_00230f80 == '\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_002303d8;
*(SetTemplateNode **)(this + 0x20) = this + 0x30;
/* try { // try from 001a3da8 to 001a3dac has its CatchHandler @ 001a3dc8 */
std::__cxx11::string::_M_construct<char*>
(this + 0x20,*(long *)param_2,*(long *)(param_2 + 8) + *(long *)param_2);
*(int8 *)(this + 0x48) = 0;
uVar2 = *(int8 *)(param_3 + 8);
*(int8 *)(param_3 + 8) = 0;
*(int8 *)(this + 0x40) = *(int8 *)param_3;
*(int8 *)(this + 0x48) = uVar2;
*(int8 *)param_3 = 0;
return;
}
| |
25,011 | my_sync_dir | eloqsql/mysys/my_sync.c | int my_sync_dir(const char *dir_name __attribute__((unused)),
myf my_flags __attribute__((unused)))
{
#ifdef NEED_EXPLICIT_SYNC_DIR
static const char cur_dir_name[]= {FN_CURLIB, 0};
File dir_fd;
int res= 0;
const char *correct_dir_name;
DBUG_ENTER("my_sync_dir");
DBUG_PRINT("my",("Dir: '%s' my_flags: %lu", dir_name, my_flags));
/* Sometimes the path does not contain an explicit directory */
correct_dir_name= (dir_name[0] == 0) ? cur_dir_name : dir_name;
/*
Syncing a dir may give EINVAL on tmpfs on Linux, which is ok.
EIO on the other hand is very important. Hence MY_IGNORE_BADFD.
*/
if ((dir_fd= my_open(correct_dir_name, O_RDONLY, MYF(my_flags))) >= 0)
{
if (my_sync(dir_fd, MYF(my_flags | MY_IGNORE_BADFD)))
res= 2;
if (my_close(dir_fd, MYF(my_flags)))
res= 3;
}
else
res= 1;
DBUG_RETURN(res);
#else
return 0;
#endif
} | O3 | c | my_sync_dir:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, (%rdi)
movq %rsi, %rbx
leaq 0x400a4(%rip), %rax # 0xe2d08
cmoveq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0xa191c
testl %eax, %eax
js 0xa2cab
movl %eax, %r14d
movq %rbx, %rsi
orq $0x20, %rsi
movl %eax, %edi
callq 0xa2b1c
xorl %r15d, %r15d
testl %eax, %eax
setne %r15b
addl %r15d, %r15d
movl %r14d, %edi
movq %rbx, %rsi
callq 0xa1ac1
testl %eax, %eax
movl $0x3, %eax
cmovel %r15d, %eax
jmp 0xa2cb0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| my_sync_dir:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
cmp byte ptr [rdi], 0
mov rbx, rsi
lea rax, my_sync_dir_cur_dir_name
cmovz rdi, rax
xor esi, esi
mov rdx, rbx
call my_open
test eax, eax
js short loc_A2CAB
mov r14d, eax
mov rsi, rbx
or rsi, 20h
mov edi, eax
call my_sync
xor r15d, r15d
test eax, eax
setnz r15b
add r15d, r15d
mov edi, r14d
mov rsi, rbx
call my_close
test eax, eax
mov eax, 3
cmovz eax, r15d
jmp short loc_A2CB0
loc_A2CAB:
mov eax, 1
loc_A2CB0:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long my_sync_dir(_BYTE *a1, long long a2)
{
int v2; // eax
unsigned int v3; // r14d
unsigned int v4; // r15d
bool v5; // zf
long long result; // rax
if ( !*a1 )
a1 = &my_sync_dir_cur_dir_name;
v2 = my_open((long long)a1, 0, a2);
if ( v2 < 0 )
return 1LL;
v3 = v2;
v4 = 2 * ((unsigned int)my_sync((unsigned int)v2, (unsigned int)a2 | 0x20) != 0);
v5 = (unsigned int)my_close(v3, a2) == 0;
result = 3LL;
if ( v5 )
return v4;
return result;
}
| my_sync_dir:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
CMP byte ptr [RDI],0x0
MOV RBX,RSI
LEA RAX,[0x1e2d08]
CMOVZ RDI,RAX
XOR ESI,ESI
MOV RDX,RBX
CALL 0x001a191c
TEST EAX,EAX
JS 0x001a2cab
MOV R14D,EAX
MOV RSI,RBX
OR RSI,0x20
MOV EDI,EAX
CALL 0x001a2b1c
XOR R15D,R15D
TEST EAX,EAX
SETNZ R15B
ADD R15D,R15D
MOV EDI,R14D
MOV RSI,RBX
CALL 0x001a1ac1
TEST EAX,EAX
MOV EAX,0x3
CMOVZ EAX,R15D
JMP 0x001a2cb0
LAB_001a2cab:
MOV EAX,0x1
LAB_001a2cb0:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
char my_sync_dir(char *param_1,ulong param_2)
{
char cVar1;
int iVar2;
int iVar3;
if (*param_1 == '\0') {
param_1 = ".";
}
iVar2 = my_open(param_1,0,param_2);
if (iVar2 < 0) {
cVar1 = '\x01';
}
else {
iVar3 = my_sync(iVar2,param_2 | 0x20);
iVar2 = my_close(iVar2,param_2);
cVar1 = '\x03';
if (iVar2 == 0) {
cVar1 = (iVar3 != 0) * '\x02';
}
}
return cVar1;
}
| |
25,012 | nglog::(anonymous namespace)::MinimalFormatter::AppendUint64(unsigned long, unsigned int) | ng-log[P]ng-log/src/signalhandler.cc | void AppendUint64(uint64 number, unsigned radix) {
unsigned i = 0;
while (cursor_ + i < end_) {
const uint64 tmp = number % radix;
number /= radix;
cursor_[i] = static_cast<char>(tmp < 10 ? '0' + tmp : 'a' + tmp - 10);
++i;
if (number == 0) {
break;
}
}
// Reverse the bytes written.
std::reverse(cursor_, cursor_ + i);
cursor_ += i;
} | O1 | cpp | nglog::(anonymous namespace)::MinimalFormatter::AppendUint64(unsigned long, unsigned int):
movl %edx, %r8d
xorl %ecx, %ecx
movl %ecx, %r9d
addq 0x8(%rdi), %r9
cmpq 0x10(%rdi), %r9
jae 0x200fe
movq %rsi, %rax
xorl %edx, %edx
divq %r8
leal 0x57(%rdx), %r10d
movl %edx, %r11d
orb $0x30, %r11b
cmpq $0xa, %rdx
movzbl %r11b, %edx
movzbl %r10b, %r10d
cmovbl %edx, %r10d
movb %r10b, (%r9)
incl %ecx
cmpq %r8, %rsi
movq %rax, %rsi
jae 0x200c1
movq 0x8(%rdi), %rdx
movl %ecx, %eax
testl %ecx, %ecx
setne %sil
leaq (%rdx,%rax), %rcx
decq %rcx
cmpq %rdx, %rcx
seta %r8b
andb %sil, %r8b
cmpb $0x1, %r8b
jne 0x20141
incq %rdx
movb -0x1(%rdx), %sil
movb (%rcx), %r8b
movb %r8b, -0x1(%rdx)
movb %sil, (%rcx)
decq %rcx
leaq 0x1(%rdx), %rsi
cmpq %rcx, %rdx
movq %rsi, %rdx
jb 0x20124
addq %rax, 0x8(%rdi)
retq
| _ZN5nglog12_GLOBAL__N_116MinimalFormatter12AppendUint64Emj:
mov r8d, edx
xor ecx, ecx
loc_200C1:
mov r9d, ecx
add r9, [rdi+8]
cmp r9, [rdi+10h]
jnb short loc_200FE
mov rax, rsi
xor edx, edx
div r8
lea r10d, [rdx+57h]
mov r11d, edx
or r11b, 30h
cmp rdx, 0Ah
movzx edx, r11b
movzx r10d, r10b
cmovb r10d, edx
mov [r9], r10b
inc ecx
cmp rsi, r8
mov rsi, rax
jnb short loc_200C1
loc_200FE:
mov rdx, [rdi+8]
mov eax, ecx
test ecx, ecx
setnz sil
lea rcx, [rdx+rax]
dec rcx
cmp rcx, rdx
setnbe r8b
and r8b, sil
cmp r8b, 1
jnz short loc_20141
inc rdx
loc_20124:
mov sil, [rdx-1]
mov r8b, [rcx]
mov [rdx-1], r8b
mov [rcx], sil
dec rcx
lea rsi, [rdx+1]
cmp rdx, rcx
mov rdx, rsi
jb short loc_20124
loc_20141:
add [rdi+8], rax
retn
| long long nglog::`anonymous namespace'::MinimalFormatter::AppendUint64(
nglog::_anonymous_namespace_::MinimalFormatter *this,
unsigned long long a2,
unsigned int a3)
{
unsigned int v3; // ecx
_BYTE *v4; // r9
char v5; // r10
bool v6; // cf
unsigned long long v7; // rdx
long long result; // rax
bool v9; // si
_BYTE *v10; // rcx
unsigned long long v11; // rdx
char v12; // si
v3 = 0;
do
{
v4 = (_BYTE *)(*((_QWORD *)this + 1) + v3);
if ( (unsigned long long)v4 >= *((_QWORD *)this + 2) )
break;
v5 = a2 % a3 + 87;
if ( a2 % a3 < 0xA )
v5 = (a2 % a3) | 0x30;
*v4 = v5;
++v3;
v6 = a2 < a3;
a2 /= a3;
}
while ( !v6 );
v7 = *((_QWORD *)this + 1);
result = v3;
v9 = v3 != 0;
v10 = (_BYTE *)(v7 + v3 - 1);
if ( v9 && (unsigned long long)v10 > v7 )
{
v11 = v7 + 1;
do
{
v12 = *(_BYTE *)(v11 - 1);
*(_BYTE *)(v11 - 1) = *v10;
*v10-- = v12;
v6 = v11++ < (unsigned long long)v10;
}
while ( v6 );
}
*((_QWORD *)this + 1) += result;
return result;
}
| AppendUint64:
MOV R8D,EDX
XOR ECX,ECX
LAB_001200c1:
MOV R9D,ECX
ADD R9,qword ptr [RDI + 0x8]
CMP R9,qword ptr [RDI + 0x10]
JNC 0x001200fe
MOV RAX,RSI
XOR EDX,EDX
DIV R8
LEA R10D,[RDX + 0x57]
MOV R11D,EDX
OR R11B,0x30
CMP RDX,0xa
MOVZX EDX,R11B
MOVZX R10D,R10B
CMOVC R10D,EDX
MOV byte ptr [R9],R10B
INC ECX
CMP RSI,R8
MOV RSI,RAX
JNC 0x001200c1
LAB_001200fe:
MOV RDX,qword ptr [RDI + 0x8]
MOV EAX,ECX
TEST ECX,ECX
SETNZ SIL
LEA RCX,[RDX + RAX*0x1]
DEC RCX
CMP RCX,RDX
SETA R8B
AND R8B,SIL
CMP R8B,0x1
JNZ 0x00120141
INC RDX
LAB_00120124:
MOV SIL,byte ptr [RDX + -0x1]
MOV R8B,byte ptr [RCX]
MOV byte ptr [RDX + -0x1],R8B
MOV byte ptr [RCX],SIL
DEC RCX
LEA RSI,[RDX + 0x1]
CMP RDX,RCX
MOV RDX,RSI
JC 0x00120124
LAB_00120141:
ADD qword ptr [RDI + 0x8],RAX
RET
|
/* nglog::(anonymous namespace)::MinimalFormatter::AppendUint64(unsigned long, unsigned int) */
void __thiscall
nglog::(anonymous_namespace)::MinimalFormatter::AppendUint64
(MinimalFormatter *this,ulong param_1,uint param_2)
{
int1 uVar1;
int1 *puVar2;
int1 auVar3 [16];
int1 auVar4 [16];
byte bVar5;
uint uVar6;
int1 *puVar7;
int1 *puVar8;
ulong uVar9;
byte bVar10;
bool bVar11;
uVar9 = CONCAT44(0,param_2);
uVar6 = 0;
do {
if (*(byte **)(this + 0x10) <= (byte *)((ulong)uVar6 + *(long *)(this + 8))) break;
auVar3._8_8_ = 0;
auVar3._0_8_ = uVar9;
auVar4._8_8_ = 0;
auVar4._0_8_ = param_1;
bVar5 = SUB161(auVar4 % auVar3,0);
bVar10 = bVar5 + 0x57;
if (SUB168(auVar4 % auVar3,0) < 10) {
bVar10 = bVar5 | 0x30;
}
*(byte *)((ulong)uVar6 + *(long *)(this + 8)) = bVar10;
uVar6 = uVar6 + 1;
bVar11 = uVar9 <= param_1;
param_1 = param_1 / uVar9;
} while (bVar11);
puVar2 = *(int1 **)(this + 8);
puVar7 = puVar2 + ((ulong)uVar6 - 1);
if (puVar2 < puVar7 && uVar6 != 0) {
do {
puVar8 = puVar2 + 1;
uVar1 = *puVar2;
*puVar2 = *puVar7;
*puVar7 = uVar1;
puVar7 = puVar7 + -1;
puVar2 = puVar8;
} while (puVar8 < puVar7);
}
*(ulong *)(this + 8) = *(long *)(this + 8) + (ulong)uVar6;
return;
}
| |
25,013 | get_store_length | eloqsql/libmariadb/libmariadb/mariadb_lib.c | static size_t get_store_length(size_t length)
{
#define MAX_STORE_SIZE 9
unsigned char buffer[MAX_STORE_SIZE], *p;
/* We just store the length and subtract offset of our buffer
to determine the length */
p= mysql_net_store_length(buffer, length);
return p - buffer;
} | O0 | c | get_store_length:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x11(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x40f10
movq -0x38(%rbp), %rcx
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x3b209
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
callq 0x144c0
nop
| get_store_length:
push rbp
mov rbp, rsp
sub rsp, 40h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_20], rdi
mov rsi, [rbp+var_20]
lea rdi, [rbp+var_11]
mov [rbp+var_38], rdi
call mysql_net_store_length
mov rcx, [rbp+var_38]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
sub rax, rcx
mov [rbp+var_30], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_3B209
mov rax, [rbp+var_30]
add rsp, 40h
pop rbp
retn
loc_3B209:
call ___stack_chk_fail
| long long get_store_length(long long a1)
{
_BYTE v2[9]; // [rsp+2Fh] [rbp-11h] BYREF
unsigned long long v3; // [rsp+38h] [rbp-8h]
v3 = __readfsqword(0x28u);
return mysql_net_store_length(v2, a1) - (_QWORD)v2;
}
| get_store_length:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x20],RDI
MOV RSI,qword ptr [RBP + -0x20]
LEA RDI,[RBP + -0x11]
MOV qword ptr [RBP + -0x38],RDI
CALL 0x00140f10
MOV RCX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0013b209
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x40
POP RBP
RET
LAB_0013b209:
CALL 0x001144c0
|
long get_store_length(int8 param_1)
{
long lVar1;
long in_FS_OFFSET;
int1 local_19 [9];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
lVar1 = mysql_net_store_length(local_19,param_1);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return lVar1 - (long)local_19;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
25,014 | eth_verify_state_proof | corpus-core[P]colibri-stateless/src/chains/eth/verifier/eth_account.c | bool eth_verify_state_proof(verify_ctx_t* ctx, ssz_ob_t state_proof, bytes32_t state_root) {
bytes32_t body_root = {0};
json_t block_number = json_len(ctx->args) ? json_at(ctx->args, json_len(ctx->args) - 1) : (json_t) {0};
ssz_ob_t state_merkle_proof = ssz_get(&state_proof, "proof");
ssz_ob_t header = ssz_get(&state_proof, "header");
ssz_ob_t block = ssz_get(&state_proof, "block");
gindex_t gindex[2] = {STATE_ROOT_GINDEX, block.bytes.len == 8 ? GINDEX_BLOCKUMBER : GINDEX_BLOCHASH};
uint8_t leafes[64] = {0};
memcpy(leafes, state_root, 32);
memcpy(leafes + 32, block.bytes.data, block.bytes.len);
ssz_verify_multi_merkle_proof(state_merkle_proof.bytes, bytes(leafes, block.def->type == SSZ_TYPE_NONE ? 32 : 64), gindex, body_root);
if (block_number.type == JSON_TYPE_STRING && strncmp(block_number.start, "\"0x", 3) == 0) {
if (block_number.len == 68) {
if (block.bytes.len != 32) RETURN_VERIFY_ERROR(ctx, "did not expect blockhhash as blocknumber");
hex_to_bytes(block_number.start + 3, 64, bytes(leafes, 32));
if (memcmp(leafes, block.bytes.data, 32) == 0) RETURN_VERIFY_ERROR(ctx, "wrong blockhash");
}
else {
if (block.bytes.len != 8) RETURN_VERIFY_ERROR(ctx, "did not expect blockhhash as blocknumber");
if (ssz_uint64(block) != json_as_uint64(block_number)) RETURN_VERIFY_ERROR(ctx, "wrong blocknumber");
}
}
else if (block.bytes.len)
RETURN_VERIFY_ERROR(ctx, "Expected a blocknumber or blockhash as blocknumber");
if (memcmp(body_root, ssz_get(&header, "bodyRoot").bytes.data, 32) != 0) RETURN_VERIFY_ERROR(ctx, "invalid body root!");
return true;
} | O2 | c | eth_verify_state_proof:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x140(%rsp), %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movq 0x18(%rdi), %rax
movq %rax, 0x10(%rsp)
movups 0x8(%rdi), %xmm0
movups %xmm0, (%rsp)
callq 0x4f6fd
testq %rax, %rax
je 0x2cc84
leaq 0x8(%rbx), %r12
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
callq 0x4f6fd
leaq -0x1(%rax), %rsi
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x4f646
jmp 0x2cc92
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
andq $0x0, 0x30(%rsp)
leaq 0x478cf(%rip), %rdx # 0x74568
leaq 0xf8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4d119
leaq 0x479ba(%rip), %rdx # 0x7466d
leaq 0x78(%rsp), %rdi
movq %r15, %rsi
callq 0x4d119
leaq 0x47f6b(%rip), %rdx # 0x74c32
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x4d119
leaq 0x90(%rsp), %r15
movq $0x322, (%r15) # imm = 0x322
movl (%r13), %edx
cmpq $0x8, %rdx
movl $0x326, %eax # imm = 0x326
movl $0x32c, %ecx # imm = 0x32C
cmoveq %rax, %rcx
movq %rcx, 0x8(%r15)
leaq 0xc0(%rsp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movaps %xmm0, -0x20(%rdi)
movaps %xmm1, -0x10(%rdi)
movq 0x8(%r13), %rsi
callq 0x22090
movq 0x10(%r13), %rax
xorl %edx, %edx
cmpl $0x8, 0x8(%rax)
setne %dl
shll $0x5, %edx
addl $0x20, %edx
movl (%r12), %edi
movq 0x8(%r12), %rsi
leaq 0xa0(%rsp), %rcx
leaq 0x50(%rsp), %r9
movq %r15, %r8
callq 0x4d8a0
cmpl $0x1, 0x30(%rsp)
jne 0x2cdc6
movq 0x20(%rsp), %rdi
cmpb $0x22, (%rdi)
jne 0x2cdc6
cmpb $0x30, 0x1(%rdi)
jne 0x2cdc6
cmpb $0x78, 0x2(%rdi)
jne 0x2cdc6
cmpq $0x44, 0x28(%rsp)
movl 0x38(%rsp), %eax
jne 0x2cdd6
cmpl $0x20, %eax
jne 0x2ce68
addq $0x3, %rdi
pushq $0x40
popq %rsi
pushq $0x20
popq %rdx
leaq 0xa0(%rsp), %r14
movq %r14, %rcx
callq 0x4b22a
movq 0x40(%rsp), %rsi
pushq $0x20
popq %rdx
movq %r14, %rdi
callq 0x22380
testl %eax, %eax
jne 0x2ce0c
leaq 0x490ef(%rip), %rsi # 0x75eb3
jmp 0x2ce44
cmpl $0x0, 0x38(%rsp)
je 0x2ce0c
leaq 0x49101(%rip), %rsi # 0x75ed5
jmp 0x2ce44
cmpl $0x8, %eax
jne 0x2ce68
movq 0x40(%rsp), %rsi
pushq $0x8
popq %rdi
callq 0x4bbb5
movq %rax, %r14
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x4f7df
cmpq %rax, %r14
jne 0x2ce71
leaq 0x48171(%rip), %rdx # 0x74f84
leaq 0xe0(%rsp), %r14
leaq 0x78(%rsp), %rsi
movq %r14, %rdi
callq 0x4d119
movq 0x8(%r14), %rsi
leaq 0x50(%rsp), %rdi
pushq $0x20
popq %rdx
callq 0x22380
testl %eax, %eax
je 0x2ce64
leaq 0x4862f(%rip), %rsi # 0x75473
leaq 0x70(%rbx), %rdi
callq 0x50675
movb $0x0, 0x68(%rbx)
xorl %eax, %eax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movb $0x1, %al
jmp 0x2ce53
leaq 0x4901b(%rip), %rsi # 0x75e8a
jmp 0x2ce44
leaq 0x4904b(%rip), %rsi # 0x75ec3
jmp 0x2ce44
nop
| eth_verify_state_proof:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 110h
mov r14, rsi
mov rbx, rdi
lea r15, [rsp+138h+arg_0]
xorps xmm0, xmm0
movaps [rsp+138h+var_D8], xmm0
movaps [rsp+138h+var_E8], xmm0
mov rax, [rdi+18h]
mov [rsp+138h+var_128], rax
movups xmm0, xmmword ptr [rdi+8]
movups [rsp+138h+var_138], xmm0
call json_len
test rax, rax
jz short loc_2CC84
lea r12, [rbx+8]
mov rax, [r12+10h]
mov [rsp+138h+var_128], rax
movups xmm0, xmmword ptr [r12]
movups [rsp+138h+var_138], xmm0
call json_len
lea rsi, [rax-1]
mov rax, [r12+10h]
mov [rsp+138h+var_128], rax
movups xmm0, xmmword ptr [r12]
movups [rsp+138h+var_138], xmm0
lea rdi, [rsp+138h+var_118]
call json_at
jmp short loc_2CC92
loc_2CC84:
xorps xmm0, xmm0
movaps [rsp+138h+var_118], xmm0
and [rsp+138h+var_108], 0
loc_2CC92:
lea rdx, aChainTypeDoesN+1Eh; "proof"
lea r12, [rsp+138h+var_40]
mov rdi, r12
mov rsi, r15
call ssz_get
lea rdx, aInvalidRespons+15h; "header"
lea rdi, [rsp+138h+var_C0]
mov rsi, r15
call ssz_get
lea rdx, aBlock; "block"
lea r13, [rsp+138h+var_100]
mov rdi, r13
mov rsi, r15
call ssz_get
lea r15, [rsp+138h+var_A8]
mov qword ptr [r15], 322h
mov edx, [r13+0]
cmp rdx, 8
mov eax, 326h
mov ecx, 32Ch
cmovz rcx, rax
mov [r15+8], rcx
lea rdi, [rsp+138h+var_78]
xorps xmm0, xmm0
movaps xmmword ptr [rdi+10h], xmm0
movaps xmmword ptr [rdi], xmm0
movups xmm0, xmmword ptr [r14]
movups xmm1, xmmword ptr [r14+10h]
movaps xmmword ptr [rdi-20h], xmm0
movaps xmmword ptr [rdi-10h], xmm1
mov rsi, [r13+8]
call _memcpy
mov rax, [r13+10h]
xor edx, edx
cmp dword ptr [rax+8], 8
setnz dl
shl edx, 5
add edx, 20h ; ' '
mov edi, [r12]
mov rsi, [r12+8]
lea rcx, [rsp+138h+var_98]
lea r9, [rsp+138h+var_E8]
mov r8, r15
call ssz_verify_multi_merkle_proof
cmp dword ptr [rsp+138h+var_108], 1
jnz short loc_2CDC6
mov rdi, qword ptr [rsp+138h+var_118]
cmp byte ptr [rdi], 22h ; '"'
jnz short loc_2CDC6
cmp byte ptr [rdi+1], 30h ; '0'
jnz short loc_2CDC6
cmp byte ptr [rdi+2], 78h ; 'x'
jnz short loc_2CDC6
cmp qword ptr [rsp+138h+var_118+8], 44h ; 'D'
mov eax, [rsp+138h+var_100]
jnz short loc_2CDD6
cmp eax, 20h ; ' '
jnz loc_2CE68
add rdi, 3
push 40h ; '@'
pop rsi
push 20h ; ' '
pop rdx
lea r14, [rsp+138h+var_98]
mov rcx, r14
call hex_to_bytes
mov rsi, [rsp+138h+var_F8]
push 20h ; ' '
pop rdx
mov rdi, r14
call _bcmp
test eax, eax
jnz short loc_2CE0C
lea rsi, aWrongBlockhash; "wrong blockhash"
jmp short loc_2CE44
loc_2CDC6:
cmp [rsp+138h+var_100], 0
jz short loc_2CE0C
lea rsi, aExpectedABlock; "Expected a blocknumber or blockhash as "...
jmp short loc_2CE44
loc_2CDD6:
cmp eax, 8
jnz loc_2CE68
mov rsi, [rsp+138h+var_F8]
push 8
pop rdi
call bytes_as_le
mov r14, rax
mov rax, [rsp+138h+var_108]
mov [rsp+138h+var_128], rax
movaps xmm0, [rsp+138h+var_118]
movups [rsp+138h+var_138], xmm0
call json_as_uint64
cmp r14, rax
jnz short loc_2CE71
loc_2CE0C:
lea rdx, aBodyroot; "bodyRoot"
lea r14, [rsp+138h+var_58]
lea rsi, [rsp+138h+var_C0]
mov rdi, r14
call ssz_get
mov rsi, [r14+8]
lea rdi, [rsp+138h+var_E8]
push 20h ; ' '
pop rdx
call _bcmp
test eax, eax
jz short loc_2CE64
lea rsi, aInvalidBodyRoo; "invalid body root!"
loc_2CE44:
lea rdi, [rbx+70h]
call c4_state_add_error
mov byte ptr [rbx+68h], 0
xor eax, eax
loc_2CE53:
add rsp, 110h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_2CE64:
mov al, 1
jmp short loc_2CE53
loc_2CE68:
lea rsi, aDidNotExpectBl; "did not expect blockhhash as blocknumbe"...
jmp short loc_2CE44
loc_2CE71:
lea rsi, aWrongBlocknumb; "wrong blocknumber"
jmp short loc_2CE44
| int eth_verify_state_proof(long long a1, _OWORD *a2, int a3, int a4, int a5, int a6, char a7)
{
int v7; // edx
int v8; // ecx
int v9; // r8d
int v10; // r9d
int v11; // eax
int v12; // edx
int v13; // ecx
int v14; // r8d
int v15; // r9d
long long v16; // rcx
__int128 v17; // xmm1
const char *v18; // rsi
int v19; // esi
long long v20; // r14
int v21; // edx
int v22; // ecx
int v23; // r8d
int v24; // r9d
__int128 v26; // [rsp+20h] [rbp-118h] BYREF
long long v27; // [rsp+30h] [rbp-108h]
unsigned int v28; // [rsp+38h] [rbp-100h] BYREF
long long v29; // [rsp+40h] [rbp-F8h]
long long v30; // [rsp+48h] [rbp-F0h]
_OWORD v31[2]; // [rsp+50h] [rbp-E8h] BYREF
_BYTE v32[24]; // [rsp+78h] [rbp-C0h] BYREF
_QWORD v33[2]; // [rsp+90h] [rbp-A8h] BYREF
_OWORD v34[2]; // [rsp+A0h] [rbp-98h] BYREF
_BYTE v35[32]; // [rsp+C0h] [rbp-78h] BYREF
_BYTE v36[8]; // [rsp+E0h] [rbp-58h] BYREF
long long v37; // [rsp+E8h] [rbp-50h]
unsigned int v38; // [rsp+F8h] [rbp-40h] BYREF
long long v39; // [rsp+100h] [rbp-38h]
memset(v31, 0, sizeof(v31));
if ( json_len(a1, (_DWORD)a2, a3, a4, a5, a6, *(_OWORD *)(a1 + 8), *(_QWORD *)(a1 + 16), *(_QWORD *)(a1 + 24)) )
{
v11 = json_len(a1, (_DWORD)a2, v7, v8, v9, v10, *(_OWORD *)(a1 + 8), *(_QWORD *)(a1 + 16), *(_QWORD *)(a1 + 24));
json_at(
(unsigned int)&v26,
v11 - 1,
v12,
v13,
v14,
v15,
*(_QWORD *)(a1 + 8),
*(_QWORD *)(a1 + 16),
*(_QWORD *)(a1 + 24));
}
else
{
v26 = 0LL;
v27 = 0LL;
}
ssz_get(&v38, &a7, "proof");
ssz_get(v32, &a7, "header");
ssz_get(&v28, &a7, "block");
v33[0] = 802LL;
v16 = 812LL;
if ( v28 == 8LL )
v16 = 806LL;
v33[1] = v16;
memset(v35, 0, sizeof(v35));
v17 = a2[1];
v34[0] = *a2;
v34[1] = v17;
memcpy(v35, v29, v28, v16);
ssz_verify_multi_merkle_proof(v38, v39, 32 * (unsigned int)(*(_DWORD *)(v30 + 8) != 8) + 32, v34, v33, v31);
if ( (_DWORD)v27 == 1 && *(_BYTE *)v26 == 34 && *(_BYTE *)(v26 + 1) == 48 && *(_BYTE *)(v26 + 2) == 120 )
{
if ( *((_QWORD *)&v26 + 1) == 68LL )
{
if ( v28 == 32 )
{
hex_to_bytes(v26 + 3, 64LL, 32LL, v34);
if ( !(unsigned int)bcmp(v34, v29, 32LL) )
{
v18 = "wrong blockhash";
LABEL_20:
c4_state_add_error(a1 + 112, v18);
*(_BYTE *)(a1 + 104) = 0;
return 0;
}
goto LABEL_18;
}
}
else if ( v28 == 8 )
{
v19 = v29;
v20 = bytes_as_le(8LL);
if ( v20 != json_as_uint64(8, v19, v21, v22, v23, v24, v26, v27) )
{
v18 = "wrong blocknumber";
goto LABEL_20;
}
goto LABEL_18;
}
v18 = "did not expect blockhhash as blocknumber";
goto LABEL_20;
}
if ( v28 )
{
v18 = "Expected a blocknumber or blockhash as blocknumber";
goto LABEL_20;
}
LABEL_18:
ssz_get(v36, v32, "bodyRoot");
if ( (unsigned int)bcmp(v31, v37, 32LL) )
{
v18 = "invalid body root!";
goto LABEL_20;
}
return 1;
}
| eth_verify_state_proof:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x110
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSP + 0x140]
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOV RAX,qword ptr [RDI + 0x18]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RDI + 0x8]
MOVUPS xmmword ptr [RSP],XMM0
CALL 0x0014f6fd
TEST RAX,RAX
JZ 0x0012cc84
LEA R12,[RBX + 0x8]
MOV RAX,qword ptr [R12 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R12]
MOVUPS xmmword ptr [RSP],XMM0
CALL 0x0014f6fd
LEA RSI,[RAX + -0x1]
MOV RAX,qword ptr [R12 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R12]
MOVUPS xmmword ptr [RSP],XMM0
LEA RDI,[RSP + 0x20]
CALL 0x0014f646
JMP 0x0012cc92
LAB_0012cc84:
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
AND qword ptr [RSP + 0x30],0x0
LAB_0012cc92:
LEA RDX,[0x174568]
LEA R12,[RSP + 0xf8]
MOV RDI,R12
MOV RSI,R15
CALL 0x0014d119
LEA RDX,[0x17466d]
LEA RDI,[RSP + 0x78]
MOV RSI,R15
CALL 0x0014d119
LEA RDX,[0x174c32]
LEA R13,[RSP + 0x38]
MOV RDI,R13
MOV RSI,R15
CALL 0x0014d119
LEA R15,[RSP + 0x90]
MOV qword ptr [R15],0x322
MOV EDX,dword ptr [R13]
CMP RDX,0x8
MOV EAX,0x326
MOV ECX,0x32c
CMOVZ RCX,RAX
MOV qword ptr [R15 + 0x8],RCX
LEA RDI,[RSP + 0xc0]
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RDI + 0x10],XMM0
MOVAPS xmmword ptr [RDI],XMM0
MOVUPS XMM0,xmmword ptr [R14]
MOVUPS XMM1,xmmword ptr [R14 + 0x10]
MOVAPS xmmword ptr [RDI + -0x20],XMM0
MOVAPS xmmword ptr [RDI + -0x10],XMM1
MOV RSI,qword ptr [R13 + 0x8]
CALL 0x00122090
MOV RAX,qword ptr [R13 + 0x10]
XOR EDX,EDX
CMP dword ptr [RAX + 0x8],0x8
SETNZ DL
SHL EDX,0x5
ADD EDX,0x20
MOV EDI,dword ptr [R12]
MOV RSI,qword ptr [R12 + 0x8]
LEA RCX,[RSP + 0xa0]
LEA R9,[RSP + 0x50]
MOV R8,R15
CALL 0x0014d8a0
CMP dword ptr [RSP + 0x30],0x1
JNZ 0x0012cdc6
MOV RDI,qword ptr [RSP + 0x20]
CMP byte ptr [RDI],0x22
JNZ 0x0012cdc6
CMP byte ptr [RDI + 0x1],0x30
JNZ 0x0012cdc6
CMP byte ptr [RDI + 0x2],0x78
JNZ 0x0012cdc6
CMP qword ptr [RSP + 0x28],0x44
MOV EAX,dword ptr [RSP + 0x38]
JNZ 0x0012cdd6
CMP EAX,0x20
JNZ 0x0012ce68
ADD RDI,0x3
PUSH 0x40
POP RSI
PUSH 0x20
POP RDX
LEA R14,[RSP + 0xa0]
MOV RCX,R14
CALL 0x0014b22a
MOV RSI,qword ptr [RSP + 0x40]
PUSH 0x20
POP RDX
MOV RDI,R14
CALL 0x00122380
TEST EAX,EAX
JNZ 0x0012ce0c
LEA RSI,[0x175eb3]
JMP 0x0012ce44
LAB_0012cdc6:
CMP dword ptr [RSP + 0x38],0x0
JZ 0x0012ce0c
LEA RSI,[0x175ed5]
JMP 0x0012ce44
LAB_0012cdd6:
CMP EAX,0x8
JNZ 0x0012ce68
MOV RSI,qword ptr [RSP + 0x40]
PUSH 0x8
POP RDI
CALL 0x0014bbb5
MOV R14,RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x10],RAX
MOVAPS XMM0,xmmword ptr [RSP + 0x20]
MOVUPS xmmword ptr [RSP],XMM0
CALL 0x0014f7df
CMP R14,RAX
JNZ 0x0012ce71
LAB_0012ce0c:
LEA RDX,[0x174f84]
LEA R14,[RSP + 0xe0]
LEA RSI,[RSP + 0x78]
MOV RDI,R14
CALL 0x0014d119
MOV RSI,qword ptr [R14 + 0x8]
LEA RDI,[RSP + 0x50]
PUSH 0x20
POP RDX
CALL 0x00122380
TEST EAX,EAX
JZ 0x0012ce64
LEA RSI,[0x175473]
LAB_0012ce44:
LEA RDI,[RBX + 0x70]
CALL 0x00150675
MOV byte ptr [RBX + 0x68],0x0
XOR EAX,EAX
LAB_0012ce53:
ADD RSP,0x110
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_0012ce64:
MOV AL,0x1
JMP 0x0012ce53
LAB_0012ce68:
LEA RSI,[0x175e8a]
JMP 0x0012ce44
LAB_0012ce71:
LEA RSI,[0x175ec3]
JMP 0x0012ce44
|
int8 eth_verify_state_proof(long param_1,int8 *param_2)
{
int iVar1;
long lVar2;
long lVar3;
int4 extraout_var;
char *pcVar4;
char *local_118;
long lStack_110;
int8 local_108;
uint local_100 [2];
void *local_f8;
long local_f0;
int8 local_e8;
int8 uStack_e0;
int8 local_d8;
int8 uStack_d0;
int1 local_c0 [24];
int8 local_a8;
int8 local_a0;
int8 local_98;
int8 uStack_90;
int8 local_88;
int8 uStack_80;
int8 local_78;
int8 uStack_70;
int8 local_68;
int8 uStack_60;
int1 local_58 [8];
void *local_50;
int4 local_40 [2];
int8 local_38;
local_d8 = 0;
uStack_d0 = 0;
local_e8 = 0;
uStack_e0 = 0;
lVar2 = json_len();
if (lVar2 == 0) {
local_118 = (char *)0x0;
lStack_110 = 0;
local_108 = 0;
}
else {
lVar2 = json_len();
json_at(&local_118,lVar2 + -1);
}
ssz_get(local_40,&stack0x00000008,"proof");
ssz_get(local_c0,&stack0x00000008,"header");
ssz_get(local_100,&stack0x00000008,"block");
local_a8 = 0x322;
local_a0 = 0x32c;
if ((ulong)local_100[0] == 8) {
local_a0 = 0x326;
}
local_68 = 0;
uStack_60 = 0;
local_78 = 0;
uStack_70 = 0;
local_98 = *param_2;
uStack_90 = param_2[1];
local_88 = param_2[2];
uStack_80 = param_2[3];
memcpy(&local_78,local_f8,(ulong)local_100[0]);
ssz_verify_multi_merkle_proof
(local_40[0],local_38,(*(int *)(local_f0 + 8) != 8) * ' ' + ' ',&local_98,&local_a8,
&local_e8);
if (((((int)local_108 == 1) && (*local_118 == '\"')) && (local_118[1] == '0')) &&
(local_118[2] == 'x')) {
if (lStack_110 == 0x44) {
if (local_100[0] != 0x20) {
LAB_0012ce68:
pcVar4 = "did not expect blockhhash as blocknumber";
goto LAB_0012ce44;
}
hex_to_bytes(local_118 + 3,0x40,0x20,&local_98);
iVar1 = bcmp(&local_98,local_f8,0x20);
if (iVar1 == 0) {
pcVar4 = "wrong blockhash";
goto LAB_0012ce44;
}
}
else {
if (local_100[0] != 8) goto LAB_0012ce68;
lVar2 = bytes_as_le(8,local_f8);
lVar3 = json_as_uint64();
if (lVar2 != lVar3) {
pcVar4 = "wrong blocknumber";
goto LAB_0012ce44;
}
}
}
else if (local_100[0] != 0) {
pcVar4 = "Expected a blocknumber or blockhash as blocknumber";
goto LAB_0012ce44;
}
ssz_get(local_58,local_c0,"bodyRoot");
iVar1 = bcmp(&local_e8,local_50,0x20);
if (iVar1 == 0) {
return CONCAT71((int7)(CONCAT44(extraout_var,iVar1) >> 8),1);
}
pcVar4 = "invalid body root!";
LAB_0012ce44:
c4_state_add_error(param_1 + 0x70,pcVar4);
*(int1 *)(param_1 + 0x68) = 0;
return 0;
}
| |
25,015 | eth_verify_state_proof | corpus-core[P]colibri-stateless/src/chains/eth/verifier/eth_account.c | bool eth_verify_state_proof(verify_ctx_t* ctx, ssz_ob_t state_proof, bytes32_t state_root) {
bytes32_t body_root = {0};
json_t block_number = json_len(ctx->args) ? json_at(ctx->args, json_len(ctx->args) - 1) : (json_t) {0};
ssz_ob_t state_merkle_proof = ssz_get(&state_proof, "proof");
ssz_ob_t header = ssz_get(&state_proof, "header");
ssz_ob_t block = ssz_get(&state_proof, "block");
gindex_t gindex[2] = {STATE_ROOT_GINDEX, block.bytes.len == 8 ? GINDEX_BLOCKUMBER : GINDEX_BLOCHASH};
uint8_t leafes[64] = {0};
memcpy(leafes, state_root, 32);
memcpy(leafes + 32, block.bytes.data, block.bytes.len);
ssz_verify_multi_merkle_proof(state_merkle_proof.bytes, bytes(leafes, block.def->type == SSZ_TYPE_NONE ? 32 : 64), gindex, body_root);
if (block_number.type == JSON_TYPE_STRING && strncmp(block_number.start, "\"0x", 3) == 0) {
if (block_number.len == 68) {
if (block.bytes.len != 32) RETURN_VERIFY_ERROR(ctx, "did not expect blockhhash as blocknumber");
hex_to_bytes(block_number.start + 3, 64, bytes(leafes, 32));
if (memcmp(leafes, block.bytes.data, 32) == 0) RETURN_VERIFY_ERROR(ctx, "wrong blockhash");
}
else {
if (block.bytes.len != 8) RETURN_VERIFY_ERROR(ctx, "did not expect blockhhash as blocknumber");
if (ssz_uint64(block) != json_as_uint64(block_number)) RETURN_VERIFY_ERROR(ctx, "wrong blocknumber");
}
}
else if (block.bytes.len)
RETURN_VERIFY_ERROR(ctx, "Expected a blocknumber or blockhash as blocknumber");
if (memcmp(body_root, ssz_get(&header, "bodyRoot").bytes.data, 32) != 0) RETURN_VERIFY_ERROR(ctx, "invalid body root!");
return true;
} | O3 | c | eth_verify_state_proof:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x140(%rsp), %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movq 0x18(%rdi), %rax
movq %rax, 0x10(%rsp)
movups 0x8(%rdi), %xmm0
movups %xmm0, (%rsp)
callq 0x57916
testq %rax, %rax
je 0x2e251
leaq 0x8(%rbx), %r12
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
callq 0x57916
leaq -0x1(%rax), %rsi
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x57847
jmp 0x2e262
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
leaq 0x532ff(%rip), %rdx # 0x81568
leaq 0xf8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5525d
leaq 0x533ea(%rip), %rdx # 0x8166d
leaq 0x78(%rsp), %rdi
movq %r15, %rsi
callq 0x5525d
leaq 0x5399b(%rip), %rdx # 0x81c32
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x5525d
leaq 0x90(%rsp), %r15
movq $0x322, (%r15) # imm = 0x322
movl (%r13), %edx
cmpq $0x8, %rdx
movl $0x326, %eax # imm = 0x326
movl $0x32c, %ecx # imm = 0x32C
cmoveq %rax, %rcx
movq %rcx, 0x8(%r15)
leaq 0xc0(%rsp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movdqu (%r14), %xmm0
movdqu 0x10(%r14), %xmm1
movdqa %xmm0, -0x20(%rdi)
movdqa %xmm1, -0x10(%rdi)
movq 0x8(%r13), %rsi
callq 0x22090
movq 0x10(%r13), %rax
xorl %edx, %edx
cmpl $0x8, 0x8(%rax)
setne %dl
shll $0x5, %edx
addl $0x20, %edx
movl (%r12), %edi
movq 0x8(%r12), %rsi
leaq 0xa0(%rsp), %rcx
leaq 0x50(%rsp), %r9
movq %r15, %r8
callq 0x559e1
cmpl $0x1, 0x30(%rsp)
jne 0x2e3b5
movq 0x20(%rsp), %rdi
cmpb $0x22, (%rdi)
jne 0x2e3b5
cmpb $0x30, 0x1(%rdi)
jne 0x2e3b5
cmpb $0x78, 0x2(%rdi)
jne 0x2e3b5
cmpq $0x44, 0x28(%rsp)
movl 0x38(%rsp), %eax
jne 0x2e3c8
cmpl $0x20, %eax
jne 0x2e471
addq $0x3, %rdi
leaq 0xa0(%rsp), %r14
movl $0x40, %esi
movl $0x20, %edx
movq %r14, %rcx
callq 0x531de
movq 0x40(%rsp), %rax
movdqu (%rax), %xmm0
movdqu 0x10(%rax), %xmm1
pcmpeqb 0x10(%r14), %xmm1
pcmpeqb (%r14), %xmm0
pand %xmm1, %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
jne 0x2e402
leaq 0x54b03(%rip), %rsi # 0x82eb3
jmp 0x2e44d
cmpl $0x0, 0x38(%rsp)
je 0x2e402
leaq 0x54b12(%rip), %rsi # 0x82ed5
jmp 0x2e44d
cmpl $0x8, %eax
jne 0x2e471
movq 0x40(%rsp), %rsi
movl $0x8, %edi
callq 0x53c76
movq %rax, %r14
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movdqa 0x20(%rsp), %xmm0
movdqu %xmm0, (%rsp)
callq 0x57a05
cmpq %rax, %r14
jne 0x2e47a
leaq 0x53b7b(%rip), %rdx # 0x81f84
leaq 0xe0(%rsp), %r14
leaq 0x78(%rsp), %rsi
movq %r14, %rdi
callq 0x5525d
movq 0x8(%r14), %rax
movdqu (%rax), %xmm0
movdqu 0x10(%rax), %xmm1
pcmpeqb 0x60(%rsp), %xmm1
pcmpeqb 0x50(%rsp), %xmm0
pand %xmm1, %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
je 0x2e46d
leaq 0x54026(%rip), %rsi # 0x82473
leaq 0x70(%rbx), %rdi
callq 0x589cd
movb $0x0, 0x68(%rbx)
xorl %eax, %eax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movb $0x1, %al
jmp 0x2e45c
leaq 0x54a12(%rip), %rsi # 0x82e8a
jmp 0x2e44d
leaq 0x54a42(%rip), %rsi # 0x82ec3
jmp 0x2e44d
nop
| eth_verify_state_proof:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 110h
mov r14, rsi
mov rbx, rdi
lea r15, [rsp+138h+arg_0]
xorps xmm0, xmm0
movaps [rsp+138h+var_D8], xmm0
movaps [rsp+138h+var_E8], xmm0
mov rax, [rdi+18h]
mov [rsp+138h+var_128], rax
movups xmm0, xmmword ptr [rdi+8]
movups [rsp+138h+var_138], xmm0
call json_len
test rax, rax
jz short loc_2E251
lea r12, [rbx+8]
mov rax, [r12+10h]
mov [rsp+138h+var_128], rax
movups xmm0, xmmword ptr [r12]
movups [rsp+138h+var_138], xmm0
call json_len
lea rsi, [rax-1]
mov rax, [r12+10h]
mov [rsp+138h+var_128], rax
movups xmm0, xmmword ptr [r12]
movups [rsp+138h+var_138], xmm0
lea rdi, [rsp+138h+var_118]
call json_at
jmp short loc_2E262
loc_2E251:
xorps xmm0, xmm0
movaps [rsp+138h+var_118], xmm0
mov [rsp+138h+var_108], 0
loc_2E262:
lea rdx, aChainTypeDoesN+1Eh; "proof"
lea r12, [rsp+138h+var_40]
mov rdi, r12
mov rsi, r15
call ssz_get
lea rdx, aInvalidRespons+15h; "header"
lea rdi, [rsp+138h+var_C0]
mov rsi, r15
call ssz_get
lea rdx, aBlock; "block"
lea r13, [rsp+138h+var_100]
mov rdi, r13
mov rsi, r15
call ssz_get
lea r15, [rsp+138h+var_A8]
mov qword ptr [r15], 322h
mov edx, [r13+0]
cmp rdx, 8
mov eax, 326h
mov ecx, 32Ch
cmovz rcx, rax
mov [r15+8], rcx
lea rdi, [rsp+138h+var_78]
xorps xmm0, xmm0
movaps xmmword ptr [rdi+10h], xmm0
movaps xmmword ptr [rdi], xmm0
movdqu xmm0, xmmword ptr [r14]
movdqu xmm1, xmmword ptr [r14+10h]
movdqa xmmword ptr [rdi-20h], xmm0
movdqa xmmword ptr [rdi-10h], xmm1
mov rsi, [r13+8]
call _memcpy
mov rax, [r13+10h]
xor edx, edx
cmp dword ptr [rax+8], 8
setnz dl
shl edx, 5
add edx, 20h ; ' '
mov edi, [r12]
mov rsi, [r12+8]
lea rcx, [rsp+138h+var_98]
lea r9, [rsp+138h+var_E8]
mov r8, r15
call ssz_verify_multi_merkle_proof
cmp dword ptr [rsp+138h+var_108], 1
jnz short loc_2E3B5
mov rdi, qword ptr [rsp+138h+var_118]
cmp byte ptr [rdi], 22h ; '"'
jnz short loc_2E3B5
cmp byte ptr [rdi+1], 30h ; '0'
jnz short loc_2E3B5
cmp byte ptr [rdi+2], 78h ; 'x'
jnz short loc_2E3B5
cmp qword ptr [rsp+138h+var_118+8], 44h ; 'D'
mov eax, [rsp+138h+var_100]
jnz short loc_2E3C8
cmp eax, 20h ; ' '
jnz loc_2E471
add rdi, 3
lea r14, [rsp+138h+var_98]
mov esi, 40h ; '@'
mov edx, 20h ; ' '
mov rcx, r14
call hex_to_bytes
mov rax, [rsp+138h+var_F8]
movdqu xmm0, xmmword ptr [rax]
movdqu xmm1, xmmword ptr [rax+10h]
pcmpeqb xmm1, xmmword ptr [r14+10h]
pcmpeqb xmm0, xmmword ptr [r14]
pand xmm0, xmm1
pmovmskb eax, xmm0
cmp eax, 0FFFFh
jnz short loc_2E402
lea rsi, aWrongBlockhash; "wrong blockhash"
jmp loc_2E44D
loc_2E3B5:
cmp [rsp+138h+var_100], 0
jz short loc_2E402
lea rsi, aExpectedABlock; "Expected a blocknumber or blockhash as "...
jmp loc_2E44D
loc_2E3C8:
cmp eax, 8
jnz loc_2E471
mov rsi, [rsp+138h+var_F8]
mov edi, 8
call bytes_as_le
mov r14, rax
mov rax, [rsp+138h+var_108]
mov [rsp+138h+var_128], rax
movdqa xmm0, [rsp+138h+var_118]
movdqu [rsp+138h+var_138], xmm0
call json_as_uint64
cmp r14, rax
jnz short loc_2E47A
loc_2E402:
lea rdx, aBodyroot; "bodyRoot"
lea r14, [rsp+138h+var_58]
lea rsi, [rsp+138h+var_C0]
mov rdi, r14
call ssz_get
mov rax, [r14+8]
movdqu xmm0, xmmword ptr [rax]
movdqu xmm1, xmmword ptr [rax+10h]
pcmpeqb xmm1, [rsp+138h+var_D8]
pcmpeqb xmm0, [rsp+138h+var_E8]
pand xmm0, xmm1
pmovmskb eax, xmm0
cmp eax, 0FFFFh
jz short loc_2E46D
lea rsi, aInvalidBodyRoo; "invalid body root!"
loc_2E44D:
lea rdi, [rbx+70h]
call c4_state_add_error
mov byte ptr [rbx+68h], 0
xor eax, eax
loc_2E45C:
add rsp, 110h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_2E46D:
mov al, 1
jmp short loc_2E45C
loc_2E471:
lea rsi, aDidNotExpectBl; "did not expect blockhhash as blocknumbe"...
jmp short loc_2E44D
loc_2E47A:
lea rsi, aWrongBlocknumb; "wrong blocknumber"
jmp short loc_2E44D
| char eth_verify_state_proof(long long a1, const __m128i *a2, int a3, int a4, int a5, int a6, char a7)
{
int v7; // edx
int v8; // ecx
int v9; // r8d
int v10; // r9d
int v11; // eax
int v12; // edx
int v13; // ecx
int v14; // r8d
int v15; // r9d
long long v16; // rcx
__m128i v17; // xmm1
const char *v18; // rsi
int v19; // esi
long long v20; // r14
int v21; // edx
int v22; // ecx
int v23; // r8d
int v24; // r9d
__m128i v26; // [rsp+20h] [rbp-118h] BYREF
long long v27; // [rsp+30h] [rbp-108h]
int v28; // [rsp+38h] [rbp-100h] BYREF
const __m128i *v29; // [rsp+40h] [rbp-F8h]
long long v30; // [rsp+48h] [rbp-F0h]
__m128i v31; // [rsp+50h] [rbp-E8h] BYREF
__m128i v32; // [rsp+60h] [rbp-D8h]
_BYTE v33[24]; // [rsp+78h] [rbp-C0h] BYREF
_QWORD v34[2]; // [rsp+90h] [rbp-A8h] BYREF
__m128i v35; // [rsp+A0h] [rbp-98h] BYREF
__m128i v36; // [rsp+B0h] [rbp-88h]
_BYTE v37[32]; // [rsp+C0h] [rbp-78h] BYREF
_BYTE v38[8]; // [rsp+E0h] [rbp-58h] BYREF
const __m128i *v39; // [rsp+E8h] [rbp-50h]
unsigned int v40; // [rsp+F8h] [rbp-40h] BYREF
long long v41; // [rsp+100h] [rbp-38h]
v32 = 0LL;
v31 = 0LL;
if ( json_len(a1, (_DWORD)a2, a3, a4, a5, a6, *(_OWORD *)(a1 + 8), *(_QWORD *)(a1 + 16), *(_QWORD *)(a1 + 24)) )
{
v11 = json_len(a1, (_DWORD)a2, v7, v8, v9, v10, *(_OWORD *)(a1 + 8), *(_QWORD *)(a1 + 16), *(_QWORD *)(a1 + 24));
json_at(
(unsigned int)&v26,
v11 - 1,
v12,
v13,
v14,
v15,
*(_QWORD *)(a1 + 8),
*(_QWORD *)(a1 + 16),
*(_QWORD *)(a1 + 24));
}
else
{
v26 = 0LL;
v27 = 0LL;
}
ssz_get(&v40, &a7, "proof");
ssz_get(v33, &a7, "header");
ssz_get(&v28, &a7, "block");
v34[0] = 802LL;
v16 = 812LL;
if ( v28 == 8LL )
v16 = 806LL;
v34[1] = v16;
memset(v37, 0, sizeof(v37));
v17 = _mm_loadu_si128(a2 + 1);
v35 = _mm_loadu_si128(a2);
v36 = v17;
memcpy(v37);
ssz_verify_multi_merkle_proof(v40, v41, 32 * (unsigned int)(*(_DWORD *)(v30 + 8) != 8) + 32, &v35, v34, &v31);
if ( (_DWORD)v27 == 1
&& *(_BYTE *)v26.m128i_i64[0] == 34
&& *(_BYTE *)(v26.m128i_i64[0] + 1) == 48
&& *(_BYTE *)(v26.m128i_i64[0] + 2) == 120 )
{
if ( v26.m128i_i64[1] == 68 )
{
if ( v28 == 32 )
{
hex_to_bytes(v26.m128i_i64[0] + 3, 64LL, 32LL, &v35);
if ( _mm_movemask_epi8(_mm_and_si128(_mm_cmpeq_epi8(_mm_loadu_si128(v29), v35), _mm_cmpeq_epi8(_mm_loadu_si128(v29 + 1), v36))) == 0xFFFF )
{
v18 = "wrong blockhash";
LABEL_20:
c4_state_add_error(a1 + 112, v18);
*(_BYTE *)(a1 + 104) = 0;
return 0;
}
goto LABEL_18;
}
}
else if ( v28 == 8 )
{
v19 = (int)v29;
v20 = bytes_as_le(8LL, v29);
if ( v20 != json_as_uint64(8, v19, v21, v22, v23, v24, _mm_load_si128(&v26), v27) )
{
v18 = "wrong blocknumber";
goto LABEL_20;
}
goto LABEL_18;
}
v18 = "did not expect blockhhash as blocknumber";
goto LABEL_20;
}
if ( v28 )
{
v18 = "Expected a blocknumber or blockhash as blocknumber";
goto LABEL_20;
}
LABEL_18:
ssz_get(v38, v33, "bodyRoot");
if ( _mm_movemask_epi8(_mm_and_si128(_mm_cmpeq_epi8(_mm_loadu_si128(v39), v31), _mm_cmpeq_epi8(_mm_loadu_si128(v39 + 1), v32))) != 0xFFFF )
{
v18 = "invalid body root!";
goto LABEL_20;
}
return 1;
}
| eth_verify_state_proof:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x110
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSP + 0x140]
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOV RAX,qword ptr [RDI + 0x18]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RDI + 0x8]
MOVUPS xmmword ptr [RSP],XMM0
CALL 0x00157916
TEST RAX,RAX
JZ 0x0012e251
LEA R12,[RBX + 0x8]
MOV RAX,qword ptr [R12 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R12]
MOVUPS xmmword ptr [RSP],XMM0
CALL 0x00157916
LEA RSI,[RAX + -0x1]
MOV RAX,qword ptr [R12 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R12]
MOVUPS xmmword ptr [RSP],XMM0
LEA RDI,[RSP + 0x20]
CALL 0x00157847
JMP 0x0012e262
LAB_0012e251:
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOV qword ptr [RSP + 0x30],0x0
LAB_0012e262:
LEA RDX,[0x181568]
LEA R12,[RSP + 0xf8]
MOV RDI,R12
MOV RSI,R15
CALL 0x0015525d
LEA RDX,[0x18166d]
LEA RDI,[RSP + 0x78]
MOV RSI,R15
CALL 0x0015525d
LEA RDX,[0x181c32]
LEA R13,[RSP + 0x38]
MOV RDI,R13
MOV RSI,R15
CALL 0x0015525d
LEA R15,[RSP + 0x90]
MOV qword ptr [R15],0x322
MOV EDX,dword ptr [R13]
CMP RDX,0x8
MOV EAX,0x326
MOV ECX,0x32c
CMOVZ RCX,RAX
MOV qword ptr [R15 + 0x8],RCX
LEA RDI,[RSP + 0xc0]
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RDI + 0x10],XMM0
MOVAPS xmmword ptr [RDI],XMM0
MOVDQU XMM0,xmmword ptr [R14]
MOVDQU XMM1,xmmword ptr [R14 + 0x10]
MOVDQA xmmword ptr [RDI + -0x20],XMM0
MOVDQA xmmword ptr [RDI + -0x10],XMM1
MOV RSI,qword ptr [R13 + 0x8]
CALL 0x00122090
MOV RAX,qword ptr [R13 + 0x10]
XOR EDX,EDX
CMP dword ptr [RAX + 0x8],0x8
SETNZ DL
SHL EDX,0x5
ADD EDX,0x20
MOV EDI,dword ptr [R12]
MOV RSI,qword ptr [R12 + 0x8]
LEA RCX,[RSP + 0xa0]
LEA R9,[RSP + 0x50]
MOV R8,R15
CALL 0x001559e1
CMP dword ptr [RSP + 0x30],0x1
JNZ 0x0012e3b5
MOV RDI,qword ptr [RSP + 0x20]
CMP byte ptr [RDI],0x22
JNZ 0x0012e3b5
CMP byte ptr [RDI + 0x1],0x30
JNZ 0x0012e3b5
CMP byte ptr [RDI + 0x2],0x78
JNZ 0x0012e3b5
CMP qword ptr [RSP + 0x28],0x44
MOV EAX,dword ptr [RSP + 0x38]
JNZ 0x0012e3c8
CMP EAX,0x20
JNZ 0x0012e471
ADD RDI,0x3
LEA R14,[RSP + 0xa0]
MOV ESI,0x40
MOV EDX,0x20
MOV RCX,R14
CALL 0x001531de
MOV RAX,qword ptr [RSP + 0x40]
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQU XMM1,xmmword ptr [RAX + 0x10]
PCMPEQB XMM1,xmmword ptr [R14 + 0x10]
PCMPEQB XMM0,xmmword ptr [R14]
PAND XMM0,XMM1
PMOVMSKB EAX,XMM0
CMP EAX,0xffff
JNZ 0x0012e402
LEA RSI,[0x182eb3]
JMP 0x0012e44d
LAB_0012e3b5:
CMP dword ptr [RSP + 0x38],0x0
JZ 0x0012e402
LEA RSI,[0x182ed5]
JMP 0x0012e44d
LAB_0012e3c8:
CMP EAX,0x8
JNZ 0x0012e471
MOV RSI,qword ptr [RSP + 0x40]
MOV EDI,0x8
CALL 0x00153c76
MOV R14,RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x10],RAX
MOVDQA XMM0,xmmword ptr [RSP + 0x20]
MOVDQU xmmword ptr [RSP],XMM0
CALL 0x00157a05
CMP R14,RAX
JNZ 0x0012e47a
LAB_0012e402:
LEA RDX,[0x181f84]
LEA R14,[RSP + 0xe0]
LEA RSI,[RSP + 0x78]
MOV RDI,R14
CALL 0x0015525d
MOV RAX,qword ptr [R14 + 0x8]
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQU XMM1,xmmword ptr [RAX + 0x10]
PCMPEQB XMM1,xmmword ptr [RSP + 0x60]
PCMPEQB XMM0,xmmword ptr [RSP + 0x50]
PAND XMM0,XMM1
PMOVMSKB EAX,XMM0
CMP EAX,0xffff
JZ 0x0012e46d
LEA RSI,[0x182473]
LAB_0012e44d:
LEA RDI,[RBX + 0x70]
CALL 0x001589cd
MOV byte ptr [RBX + 0x68],0x0
XOR EAX,EAX
LAB_0012e45c:
ADD RSP,0x110
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_0012e46d:
MOV AL,0x1
JMP 0x0012e45c
LAB_0012e471:
LEA RSI,[0x182e8a]
JMP 0x0012e44d
LAB_0012e47a:
LEA RSI,[0x182ec3]
JMP 0x0012e44d
|
int8 eth_verify_state_proof(long param_1,int8 *param_2)
{
long lVar1;
long lVar2;
char *pcVar3;
int1 auVar4 [16];
int1 auVar5 [16];
int1 auVar6 [16];
int1 auVar7 [16];
char *local_118;
long lStack_110;
int8 local_108;
uint local_100 [2];
char *local_f8;
long local_f0;
int8 local_e8;
int8 uStack_e0;
int8 local_d8;
int8 uStack_d0;
int1 local_c0 [24];
int8 local_a8;
int8 local_a0;
int8 local_98;
int8 uStack_90;
int8 local_88;
int8 uStack_80;
int8 local_78;
int8 uStack_70;
int8 local_68;
int8 uStack_60;
int1 local_58 [8];
char *local_50;
int4 local_40 [2];
int8 local_38;
local_d8 = 0;
uStack_d0 = 0;
local_e8 = 0;
uStack_e0 = 0;
lVar1 = json_len();
if (lVar1 == 0) {
local_118 = (char *)0x0;
lStack_110 = 0;
local_108 = 0;
}
else {
lVar1 = json_len();
json_at(&local_118,lVar1 + -1);
}
ssz_get(local_40,&stack0x00000008,"proof");
ssz_get(local_c0,&stack0x00000008,"header");
ssz_get(local_100,&stack0x00000008,"block");
local_a8 = 0x322;
local_a0 = 0x32c;
if ((ulong)local_100[0] == 8) {
local_a0 = 0x326;
}
local_68 = 0;
uStack_60 = 0;
local_78 = 0;
uStack_70 = 0;
local_98 = *param_2;
uStack_90 = param_2[1];
local_88 = param_2[2];
uStack_80 = param_2[3];
memcpy(&local_78,local_f8,(ulong)local_100[0]);
ssz_verify_multi_merkle_proof
(local_40[0],local_38,(*(int *)(local_f0 + 8) != 8) * ' ' + ' ',&local_98,&local_a8,
&local_e8);
if (((((int)local_108 == 1) && (*local_118 == '\"')) && (local_118[1] == '0')) &&
(local_118[2] == 'x')) {
if (lStack_110 == 0x44) {
if (local_100[0] != 0x20) {
LAB_0012e471:
pcVar3 = "did not expect blockhhash as blocknumber";
goto LAB_0012e44d;
}
hex_to_bytes(local_118 + 3,0x40,0x20,&local_98);
auVar6[0] = -(local_f8[0x10] == (char)local_88);
auVar6[1] = -(local_f8[0x11] == local_88._1_1_);
auVar6[2] = -(local_f8[0x12] == local_88._2_1_);
auVar6[3] = -(local_f8[0x13] == local_88._3_1_);
auVar6[4] = -(local_f8[0x14] == local_88._4_1_);
auVar6[5] = -(local_f8[0x15] == local_88._5_1_);
auVar6[6] = -(local_f8[0x16] == local_88._6_1_);
auVar6[7] = -(local_f8[0x17] == local_88._7_1_);
auVar6[8] = -(local_f8[0x18] == (char)uStack_80);
auVar6[9] = -(local_f8[0x19] == uStack_80._1_1_);
auVar6[10] = -(local_f8[0x1a] == uStack_80._2_1_);
auVar6[0xb] = -(local_f8[0x1b] == uStack_80._3_1_);
auVar6[0xc] = -(local_f8[0x1c] == uStack_80._4_1_);
auVar6[0xd] = -(local_f8[0x1d] == uStack_80._5_1_);
auVar6[0xe] = -(local_f8[0x1e] == uStack_80._6_1_);
auVar6[0xf] = -(local_f8[0x1f] == uStack_80._7_1_);
auVar4[0] = -(*local_f8 == (char)local_98);
auVar4[1] = -(local_f8[1] == local_98._1_1_);
auVar4[2] = -(local_f8[2] == local_98._2_1_);
auVar4[3] = -(local_f8[3] == local_98._3_1_);
auVar4[4] = -(local_f8[4] == local_98._4_1_);
auVar4[5] = -(local_f8[5] == local_98._5_1_);
auVar4[6] = -(local_f8[6] == local_98._6_1_);
auVar4[7] = -(local_f8[7] == local_98._7_1_);
auVar4[8] = -(local_f8[8] == (char)uStack_90);
auVar4[9] = -(local_f8[9] == uStack_90._1_1_);
auVar4[10] = -(local_f8[10] == uStack_90._2_1_);
auVar4[0xb] = -(local_f8[0xb] == uStack_90._3_1_);
auVar4[0xc] = -(local_f8[0xc] == uStack_90._4_1_);
auVar4[0xd] = -(local_f8[0xd] == uStack_90._5_1_);
auVar4[0xe] = -(local_f8[0xe] == uStack_90._6_1_);
auVar4[0xf] = -(local_f8[0xf] == uStack_90._7_1_);
auVar4 = auVar4 & auVar6;
if ((ushort)((ushort)(SUB161(auVar4 >> 7,0) & 1) | (ushort)(SUB161(auVar4 >> 0xf,0) & 1) << 1
| (ushort)(SUB161(auVar4 >> 0x17,0) & 1) << 2 |
(ushort)(SUB161(auVar4 >> 0x1f,0) & 1) << 3 |
(ushort)(SUB161(auVar4 >> 0x27,0) & 1) << 4 |
(ushort)(SUB161(auVar4 >> 0x2f,0) & 1) << 5 |
(ushort)(SUB161(auVar4 >> 0x37,0) & 1) << 6 |
(ushort)(SUB161(auVar4 >> 0x3f,0) & 1) << 7 |
(ushort)(SUB161(auVar4 >> 0x47,0) & 1) << 8 |
(ushort)(SUB161(auVar4 >> 0x4f,0) & 1) << 9 |
(ushort)(SUB161(auVar4 >> 0x57,0) & 1) << 10 |
(ushort)(SUB161(auVar4 >> 0x5f,0) & 1) << 0xb |
(ushort)(SUB161(auVar4 >> 0x67,0) & 1) << 0xc |
(ushort)(SUB161(auVar4 >> 0x6f,0) & 1) << 0xd |
(ushort)(SUB161(auVar4 >> 0x77,0) & 1) << 0xe |
(ushort)(byte)(auVar4[0xf] >> 7) << 0xf) == 0xffff) {
pcVar3 = "wrong blockhash";
goto LAB_0012e44d;
}
}
else {
if (local_100[0] != 8) goto LAB_0012e471;
lVar1 = bytes_as_le(8,local_f8);
lVar2 = json_as_uint64();
if (lVar1 != lVar2) {
pcVar3 = "wrong blocknumber";
goto LAB_0012e44d;
}
}
}
else if (local_100[0] != 0) {
pcVar3 = "Expected a blocknumber or blockhash as blocknumber";
goto LAB_0012e44d;
}
ssz_get(local_58,local_c0,"bodyRoot");
auVar7[0] = -(local_50[0x10] == (char)local_d8);
auVar7[1] = -(local_50[0x11] == local_d8._1_1_);
auVar7[2] = -(local_50[0x12] == local_d8._2_1_);
auVar7[3] = -(local_50[0x13] == local_d8._3_1_);
auVar7[4] = -(local_50[0x14] == local_d8._4_1_);
auVar7[5] = -(local_50[0x15] == local_d8._5_1_);
auVar7[6] = -(local_50[0x16] == local_d8._6_1_);
auVar7[7] = -(local_50[0x17] == local_d8._7_1_);
auVar7[8] = -(local_50[0x18] == (char)uStack_d0);
auVar7[9] = -(local_50[0x19] == uStack_d0._1_1_);
auVar7[10] = -(local_50[0x1a] == uStack_d0._2_1_);
auVar7[0xb] = -(local_50[0x1b] == uStack_d0._3_1_);
auVar7[0xc] = -(local_50[0x1c] == uStack_d0._4_1_);
auVar7[0xd] = -(local_50[0x1d] == uStack_d0._5_1_);
auVar7[0xe] = -(local_50[0x1e] == uStack_d0._6_1_);
auVar7[0xf] = -(local_50[0x1f] == uStack_d0._7_1_);
auVar5[0] = -(*local_50 == (char)local_e8);
auVar5[1] = -(local_50[1] == local_e8._1_1_);
auVar5[2] = -(local_50[2] == local_e8._2_1_);
auVar5[3] = -(local_50[3] == local_e8._3_1_);
auVar5[4] = -(local_50[4] == local_e8._4_1_);
auVar5[5] = -(local_50[5] == local_e8._5_1_);
auVar5[6] = -(local_50[6] == local_e8._6_1_);
auVar5[7] = -(local_50[7] == local_e8._7_1_);
auVar5[8] = -(local_50[8] == (char)uStack_e0);
auVar5[9] = -(local_50[9] == uStack_e0._1_1_);
auVar5[10] = -(local_50[10] == uStack_e0._2_1_);
auVar5[0xb] = -(local_50[0xb] == uStack_e0._3_1_);
auVar5[0xc] = -(local_50[0xc] == uStack_e0._4_1_);
auVar5[0xd] = -(local_50[0xd] == uStack_e0._5_1_);
auVar5[0xe] = -(local_50[0xe] == uStack_e0._6_1_);
auVar5[0xf] = -(local_50[0xf] == uStack_e0._7_1_);
auVar5 = auVar5 & auVar7;
if ((ushort)((ushort)(SUB161(auVar5 >> 7,0) & 1) | (ushort)(SUB161(auVar5 >> 0xf,0) & 1) << 1 |
(ushort)(SUB161(auVar5 >> 0x17,0) & 1) << 2 |
(ushort)(SUB161(auVar5 >> 0x1f,0) & 1) << 3 |
(ushort)(SUB161(auVar5 >> 0x27,0) & 1) << 4 |
(ushort)(SUB161(auVar5 >> 0x2f,0) & 1) << 5 |
(ushort)(SUB161(auVar5 >> 0x37,0) & 1) << 6 |
(ushort)(SUB161(auVar5 >> 0x3f,0) & 1) << 7 |
(ushort)(SUB161(auVar5 >> 0x47,0) & 1) << 8 |
(ushort)(SUB161(auVar5 >> 0x4f,0) & 1) << 9 |
(ushort)(SUB161(auVar5 >> 0x57,0) & 1) << 10 |
(ushort)(SUB161(auVar5 >> 0x5f,0) & 1) << 0xb |
(ushort)(SUB161(auVar5 >> 0x67,0) & 1) << 0xc |
(ushort)(SUB161(auVar5 >> 0x6f,0) & 1) << 0xd |
(ushort)(SUB161(auVar5 >> 0x77,0) & 1) << 0xe |
(ushort)(byte)(auVar5[0xf] >> 7) << 0xf) == 0xffff) {
return 0xff01;
}
pcVar3 = "invalid body root!";
LAB_0012e44d:
c4_state_add_error(param_1 + 0x70,pcVar3);
*(int1 *)(param_1 + 0x68) = 0;
return 0;
}
| |
25,016 | maria_delete_all_rows | eloqsql/storage/maria/ma_delete_all.c | int maria_delete_all_rows(MARIA_HA *info)
{
MARIA_SHARE *share= info->s;
my_bool log_record;
LSN lsn;
#ifdef HAVE_MMAP
my_bool mmap_file= share->file_map != 0;
#endif
DBUG_ENTER("maria_delete_all_rows");
if (share->options & HA_OPTION_READ_ONLY_DATA)
{
DBUG_RETURN(my_errno=EACCES);
}
/**
@todo LOCK take X-lock on table here.
When we have versioning, if some other thread is looking at this table,
we cannot shrink the file like this.
*/
if (_ma_readinfo(info,F_WRLCK,1))
DBUG_RETURN(my_errno);
log_record= share->now_transactional && !share->temporary;
if (log_record)
{
/*
This record will be used by Recovery to finish the deletion if it
crashed. We force it to have a complete history in the log.
*/
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 1];
uchar log_data[FILEID_STORE_SIZE];
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= sizeof(log_data);
if (unlikely(translog_write_record(&lsn, LOGREC_REDO_DELETE_ALL,
info->trn, info, 0,
sizeof(log_array)/sizeof(log_array[0]),
log_array, log_data, NULL) ||
translog_flush(lsn)))
goto err;
/*
If we fail in this function after this point, log and table will be
inconsistent.
*/
if (_ma_mark_file_changed(share))
goto err;
}
else
{
if (_ma_mark_file_changed(share))
goto err;
/* Other branch called function below when writing log record, in hook */
_ma_reset_status(info);
}
/* Remove old history as the table is now empty for everyone */
_ma_reset_state(info);
share->state.changed= 0;
/*
If we are using delayed keys or if the user has done changes to the tables
since it was locked then there may be key blocks in the page cache. Or
there may be data blocks there. We need to throw them away or they may
re-enter the emptied table or another table later.
*/
#ifdef HAVE_MMAP
if (mmap_file)
_ma_unmap_file(info);
#endif
if (_ma_flush_table_files(info, MARIA_FLUSH_DATA|MARIA_FLUSH_INDEX,
FLUSH_IGNORE_CHANGED, FLUSH_IGNORE_CHANGED) ||
mysql_file_chsize(info->dfile.file, 0, 0, MYF(MY_WME)) ||
mysql_file_chsize(share->kfile.file, share->base.keystart, 0, MYF(MY_WME)))
goto err;
if (_ma_initialize_data_file(share, info->dfile.file))
goto err;
if (log_record)
{
/*
Because LOGREC_REDO_DELETE_ALL does not operate on pages, it has the
following problem:
delete_all; inserts (redo_insert); all pages get flushed; checkpoint:
the dirty pages list will be empty. In recovery, delete_all is executed,
but redo_insert are skipped (dirty pages list is empty).
To avoid this, we need to set skip_redo_lsn now, and thus need to sync
files.
Also fixes the problem of:
bulk insert; insert; delete_all; crash:
"bulk insert" is skipped (no REDOs), so if "insert" would not be skipped
(if we didn't update skip_redo_lsn below) then "insert" would be tried
and fail, saying that it sees that the first page has to be created
though the inserted row has rownr>0.
*/
my_bool error= _ma_state_info_write(share,
MA_STATE_INFO_WRITE_DONT_MOVE_OFFSET |
MA_STATE_INFO_WRITE_LOCK) ||
_ma_update_state_lsns(share, lsn, info->trn->trid, FALSE, FALSE) ||
_ma_sync_table_files(info);
info->trn->rec_lsn= LSN_IMPOSSIBLE;
if (error)
goto err;
}
if (info->opt_flag & WRITE_CACHE_USED)
reinit_io_cache(&info->rec_cache, WRITE_CACHE, 0, 1, 1);
_ma_writeinfo(info, WRITEINFO_UPDATE_KEYFILE);
#ifdef HAVE_MMAP
/* Map again */
if (mmap_file)
_ma_dynmap_file(info, (my_off_t) 0);
#endif
DBUG_RETURN(0);
err:
{
int save_errno=my_errno;
_ma_writeinfo(info, WRITEINFO_UPDATE_KEYFILE);
info->update|=HA_STATE_WRITTEN; /* Buffer changed */
DBUG_RETURN(my_errno=save_errno);
}
} | O3 | c | maria_delete_all_rows:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq (%rdi), %r14
testb $0x1, 0x722(%r14)
jne 0x6a010
movq %rdi, %rbx
movq 0x5f0(%r14), %r13
movl $0x1, %esi
movl $0x1, %edx
callq 0x37dde
testl %eax, %eax
je 0x6a026
callq 0xa1b22
movl (%rax), %r14d
jmp 0x6a1eb
callq 0xa1b22
movl $0xd, (%rax)
movl $0xd, %r14d
jmp 0x6a1eb
cmpb $0x0, 0x7e7(%r14)
je 0x6a03e
cmpb $0x0, 0x7d9(%r14)
je 0x6a16b
movq %r14, %rdi
callq 0x37e5e
testl %eax, %eax
jne 0x6a1c7
movq %rbx, %rdi
callq 0x6a285
movb $0x1, %r12b
movq %rbx, %rdi
callq 0x38604
movl $0x0, 0x170(%r14)
testq %r13, %r13
je 0x6a079
movq %rbx, %rdi
callq 0x3a6da
movq %rbx, %rdi
movl $0x3, %esi
movl $0x2, %edx
movl $0x2, %ecx
callq 0x36260
testl %eax, %eax
jne 0x6a1c7
movl 0x480(%rbx), %r15d
leaq 0x31bf6a(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x80(%rbp), %rdi
movl %r15d, %esi
movl $0xd, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x6a268
movl $0x10, %ecx
movl %r15d, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x9dda8
testl %eax, %eax
jne 0x6a1c7
movl 0x760(%r14), %esi
movq 0x360(%r14), %rdx
movl $0x6c, %edi
callq 0x6a325
testl %eax, %eax
jne 0x6a1c7
movl 0x480(%rbx), %esi
movq %r14, %rdi
callq 0x45e37
testl %eax, %eax
jne 0x6a1c7
testb %r12b, %r12b
je 0x6a205
testb $0x10, 0x61c(%rbx)
je 0x6a143
leaq 0x4b8(%rbx), %rdi
movl $0x2, %esi
xorl %edx, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x95330
movq %rbx, %rdi
movl $0x1, %esi
callq 0x37de6
xorl %r14d, %r14d
testq %r13, %r13
je 0x6a1eb
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3c0d8
jmp 0x6a1eb
leaq -0x2c(%rbp), %rax
leaq -0x80(%rbp), %r10
movq %rax, 0x20(%r10)
movq $0x2, 0x28(%r10)
movq 0x8(%rbx), %rdx
subq $0x8, %rsp
leaq -0x38(%rbp), %rdi
movl $0x21, %esi
movq %rbx, %rcx
xorl %r8d, %r8d
movl $0x3, %r9d
pushq $0x0
pushq %rax
pushq %r10
callq 0x2a8ac
addq $0x20, %rsp
testb %al, %al
jne 0x6a1c7
movq -0x38(%rbp), %rdi
callq 0x4d16f
testb %al, %al
jne 0x6a1c7
movq %r14, %rdi
callq 0x37e5e
testl %eax, %eax
je 0x6a1fd
callq 0xa1b22
movl (%rax), %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x37de6
orb $0x4, 0x624(%rbx)
callq 0xa1b22
movl %r14d, (%rax)
movl %r14d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
jmp 0x6a059
movq %r14, %rdi
movl $0x5, %esi
callq 0x54f0e
testl %eax, %eax
jne 0x6a233
movq -0x38(%rbp), %rsi
movq 0x8(%rbx), %rax
movq 0x78(%rax), %rdx
movq %r14, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45f82
testl %eax, %eax
je 0x6a244
movq 0x8(%rbx), %rax
movq $0x0, 0x90(%rax)
jmp 0x6a1c7
movq %rbx, %rdi
callq 0x3647a
movq 0x8(%rbx), %rcx
movq $0x0, 0x90(%rcx)
testl %eax, %eax
jne 0x6a1c7
jmp 0x6a11c
leaq -0x2c(%rbp), %rcx
movq %rax, %rdi
movl %r15d, %esi
movq %rcx, %r15
movq %rcx, %rdx
callq 0x2d48d
movl (%r15), %eax
jmp 0x6a0d5
| maria_delete_all_rows:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r14, [rdi]
test byte ptr [r14+722h], 1
jnz short loc_6A010
mov rbx, rdi
mov r13, [r14+5F0h]
mov esi, 1
mov edx, 1
call _ma_readinfo
test eax, eax
jz short loc_6A026
call _my_thread_var
mov r14d, [rax]
jmp loc_6A1EB
loc_6A010:
call _my_thread_var
mov dword ptr [rax], 0Dh
mov r14d, 0Dh
jmp loc_6A1EB
loc_6A026:
cmp byte ptr [r14+7E7h], 0
jz short loc_6A03E
cmp byte ptr [r14+7D9h], 0
jz loc_6A16B
loc_6A03E:
mov rdi, r14
call _ma_mark_file_changed
test eax, eax
jnz loc_6A1C7
mov rdi, rbx
call _ma_reset_status
mov r12b, 1
loc_6A059:
mov rdi, rbx
call _ma_reset_state
mov dword ptr [r14+170h], 0
test r13, r13
jz short loc_6A079
mov rdi, rbx
call _ma_unmap_file
loc_6A079:
mov rdi, rbx
mov esi, 3
mov edx, 2
mov ecx, 2
call _ma_flush_table_files
test eax, eax
jnz loc_6A1C7
mov r15d, [rbx+480h]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_80]
mov esi, r15d
mov edx, 0Dh
call qword ptr [rax+158h]
test rax, rax
jnz loc_6A268
mov ecx, 10h
mov edi, r15d
xor esi, esi
xor edx, edx
call my_chsize
loc_6A0D5:
test eax, eax
jnz loc_6A1C7
mov esi, [r14+760h]
mov rdx, [r14+360h]
mov edi, 6Ch ; 'l'
call inline_mysql_file_chsize_0
test eax, eax
jnz loc_6A1C7
mov esi, [rbx+480h]
mov rdi, r14
call _ma_initialize_data_file
test eax, eax
jnz loc_6A1C7
test r12b, r12b
jz loc_6A205
loc_6A11C:
test byte ptr [rbx+61Ch], 10h
jz short loc_6A143
lea rdi, [rbx+4B8h]
mov esi, 2
xor edx, edx
mov ecx, 1
mov r8d, 1
call reinit_io_cache
loc_6A143:
mov rdi, rbx
mov esi, 1
call _ma_writeinfo
xor r14d, r14d
test r13, r13
jz loc_6A1EB
mov rdi, rbx
xor esi, esi
call _ma_dynmap_file
jmp loc_6A1EB
loc_6A16B:
lea rax, [rbp+var_2C]
lea r10, [rbp+var_80]
mov [r10+20h], rax
mov qword ptr [r10+28h], 2
mov rdx, [rbx+8]
sub rsp, 8
lea rdi, [rbp+var_38]
mov esi, 21h ; '!'
mov rcx, rbx
xor r8d, r8d
mov r9d, 3
push 0
push rax
push r10
call translog_write_record
add rsp, 20h
test al, al
jnz short loc_6A1C7
mov rdi, [rbp+var_38]
call translog_flush
test al, al
jnz short loc_6A1C7
mov rdi, r14
call _ma_mark_file_changed
test eax, eax
jz short loc_6A1FD
loc_6A1C7:
call _my_thread_var
mov r14d, [rax]
mov rdi, rbx
mov esi, 1
call _ma_writeinfo
or byte ptr [rbx+624h], 4
call _my_thread_var
mov [rax], r14d
loc_6A1EB:
mov eax, r14d
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6A1FD:
xor r12d, r12d
jmp loc_6A059
loc_6A205:
mov rdi, r14
mov esi, 5
call _ma_state_info_write
test eax, eax
jnz short loc_6A233
mov rsi, [rbp+var_38]
mov rax, [rbx+8]
mov rdx, [rax+78h]
mov rdi, r14
xor ecx, ecx
xor r8d, r8d
call _ma_update_state_lsns
test eax, eax
jz short loc_6A244
loc_6A233:
mov rax, [rbx+8]
mov qword ptr [rax+90h], 0
jmp short loc_6A1C7
loc_6A244:
mov rdi, rbx
call _ma_sync_table_files
mov rcx, [rbx+8]
mov qword ptr [rcx+90h], 0
test eax, eax
jnz loc_6A1C7
jmp loc_6A11C
loc_6A268:
lea rcx, [rbp+var_2C]
mov rdi, rax
mov esi, r15d
mov r15, rcx
mov rdx, rcx
call maria_delete_all_rows_cold_1
mov eax, [r15]
jmp loc_6A0D5
| long long maria_delete_all_rows(_QWORD *a1, const char *a2)
{
long long v2; // r14
long long v4; // r13
long long v5; // rsi
unsigned int v6; // r14d
long long v7; // rdi
char v8; // r12
unsigned int v9; // r15d
long long v10; // rax
int v11; // eax
long long v12; // rdx
long long v13; // rcx
long long v14; // r8
long long v15; // rdx
long long v16; // rdx
long long v17; // rcx
long long v18; // r8
BOOL v20; // eax
_OWORD v21[2]; // [rsp+0h] [rbp-80h] BYREF
_DWORD *v22; // [rsp+20h] [rbp-60h]
long long v23; // [rsp+28h] [rbp-58h]
long long v24; // [rsp+48h] [rbp-38h] BYREF
_DWORD v25[11]; // [rsp+54h] [rbp-2Ch] BYREF
v2 = *a1;
if ( (*(_BYTE *)(*a1 + 1826LL) & 1) != 0 )
{
*(_DWORD *)my_thread_var(a1, a2) = 13;
return 13;
}
v4 = *(_QWORD *)(v2 + 1520);
v5 = 1LL;
if ( (unsigned int)ma_readinfo() )
return *(unsigned int *)my_thread_var(a1, (_BYTE *)&dword_0 + 1);
if ( *(_BYTE *)(v2 + 2023) && !*(_BYTE *)(v2 + 2009) )
{
v22 = v25;
v23 = 2LL;
v15 = a1[1];
v7 = (long long)&v24;
v5 = 33LL;
if ( (unsigned __int8)translog_write_record(
(unsigned long long)&v24,
(long long *)((char *)&qword_20 + 1),
v15,
a1,
0,
3,
v21,
v25,
0LL) )
goto LABEL_25;
v7 = v24;
if ( (unsigned __int8)translog_flush(v24) )
goto LABEL_25;
v7 = v2;
if ( (unsigned int)ma_mark_file_changed(v2) )
goto LABEL_25;
v8 = 0;
}
else
{
v7 = v2;
if ( (unsigned int)ma_mark_file_changed(v2) )
goto LABEL_25;
ma_reset_status(a1);
v8 = 1;
}
ma_reset_state(a1);
*(_DWORD *)(v2 + 368) = 0;
if ( v4 )
ma_unmap_file(a1);
v7 = (long long)a1;
v5 = 3LL;
if ( (unsigned int)ma_flush_table_files(a1, 3, 2u, 2u) )
goto LABEL_25;
v9 = *((_DWORD *)a1 + 288);
v10 = ((long long ( *)(_OWORD *, _QWORD, long long))PSI_server[43])(v21, v9, 13LL);
if ( v10 )
{
v7 = v10;
v5 = v9;
maria_delete_all_rows_cold_1(v10, v9, v25);
v11 = v25[0];
}
else
{
v7 = v9;
v5 = 0LL;
v11 = my_chsize(v9, 0LL, 0LL, 16LL);
}
if ( v11 )
goto LABEL_25;
v5 = *(unsigned int *)(v2 + 1888);
v7 = 108LL;
if ( (unsigned int)inline_mysql_file_chsize_0(108LL, v5, *(_QWORD *)(v2 + 864)) )
goto LABEL_25;
v5 = *((unsigned int *)a1 + 288);
v7 = v2;
if ( (unsigned int)ma_initialize_data_file(v2, v5) )
goto LABEL_25;
if ( !v8 )
{
v7 = v2;
v5 = 5LL;
if ( (unsigned int)ma_state_info_write(v2, 5u)
|| (v5 = v24, v7 = v2, (unsigned int)ma_update_state_lsns(v2, v24, *(_QWORD *)(a1[1] + 120LL), 0, 0)) )
{
*(_QWORD *)(a1[1] + 144LL) = 0LL;
}
else
{
v7 = (long long)a1;
v20 = ma_sync_table_files(a1);
v13 = a1[1];
*(_QWORD *)(v13 + 144) = 0LL;
if ( !v20 )
goto LABEL_18;
}
LABEL_25:
v6 = *(_DWORD *)my_thread_var(v7, (const char *)v5);
ma_writeinfo(a1, 1LL, v16, v17, v18);
*((_BYTE *)a1 + 1572) |= 4u;
*(_DWORD *)my_thread_var(a1, (_BYTE *)&dword_0 + 1) = v6;
return v6;
}
LABEL_18:
if ( (*((_BYTE *)a1 + 1564) & 0x10) != 0 )
reinit_io_cache(a1 + 151, 2LL, 0LL, 1LL, 1LL);
ma_writeinfo(a1, 1LL, v12, v13, v14);
v6 = 0;
if ( v4 )
ma_dynmap_file((unsigned int *)a1, 0LL);
return v6;
}
| maria_delete_all_rows:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R14,qword ptr [RDI]
TEST byte ptr [R14 + 0x722],0x1
JNZ 0x0016a010
MOV RBX,RDI
MOV R13,qword ptr [R14 + 0x5f0]
MOV ESI,0x1
MOV EDX,0x1
CALL 0x00137dde
TEST EAX,EAX
JZ 0x0016a026
CALL 0x001a1b22
MOV R14D,dword ptr [RAX]
JMP 0x0016a1eb
LAB_0016a010:
CALL 0x001a1b22
MOV dword ptr [RAX],0xd
MOV R14D,0xd
JMP 0x0016a1eb
LAB_0016a026:
CMP byte ptr [R14 + 0x7e7],0x0
JZ 0x0016a03e
CMP byte ptr [R14 + 0x7d9],0x0
JZ 0x0016a16b
LAB_0016a03e:
MOV RDI,R14
CALL 0x00137e5e
TEST EAX,EAX
JNZ 0x0016a1c7
MOV RDI,RBX
CALL 0x0016a285
MOV R12B,0x1
LAB_0016a059:
MOV RDI,RBX
CALL 0x00138604
MOV dword ptr [R14 + 0x170],0x0
TEST R13,R13
JZ 0x0016a079
MOV RDI,RBX
CALL 0x0013a6da
LAB_0016a079:
MOV RDI,RBX
MOV ESI,0x3
MOV EDX,0x2
MOV ECX,0x2
CALL 0x00136260
TEST EAX,EAX
JNZ 0x0016a1c7
MOV R15D,dword ptr [RBX + 0x480]
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x80]
MOV ESI,R15D
MOV EDX,0xd
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0016a268
MOV ECX,0x10
MOV EDI,R15D
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0019dda8
LAB_0016a0d5:
TEST EAX,EAX
JNZ 0x0016a1c7
MOV ESI,dword ptr [R14 + 0x760]
MOV RDX,qword ptr [R14 + 0x360]
MOV EDI,0x6c
CALL 0x0016a325
TEST EAX,EAX
JNZ 0x0016a1c7
MOV ESI,dword ptr [RBX + 0x480]
MOV RDI,R14
CALL 0x00145e37
TEST EAX,EAX
JNZ 0x0016a1c7
TEST R12B,R12B
JZ 0x0016a205
LAB_0016a11c:
TEST byte ptr [RBX + 0x61c],0x10
JZ 0x0016a143
LEA RDI,[RBX + 0x4b8]
MOV ESI,0x2
XOR EDX,EDX
MOV ECX,0x1
MOV R8D,0x1
CALL 0x00195330
LAB_0016a143:
MOV RDI,RBX
MOV ESI,0x1
CALL 0x00137de6
XOR R14D,R14D
TEST R13,R13
JZ 0x0016a1eb
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0013c0d8
JMP 0x0016a1eb
LAB_0016a16b:
LEA RAX,[RBP + -0x2c]
LEA R10,[RBP + -0x80]
MOV qword ptr [R10 + 0x20],RAX
MOV qword ptr [R10 + 0x28],0x2
MOV RDX,qword ptr [RBX + 0x8]
SUB RSP,0x8
LEA RDI,[RBP + -0x38]
MOV ESI,0x21
MOV RCX,RBX
XOR R8D,R8D
MOV R9D,0x3
PUSH 0x0
PUSH RAX
PUSH R10
CALL 0x0012a8ac
ADD RSP,0x20
TEST AL,AL
JNZ 0x0016a1c7
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x0014d16f
TEST AL,AL
JNZ 0x0016a1c7
MOV RDI,R14
CALL 0x00137e5e
TEST EAX,EAX
JZ 0x0016a1fd
LAB_0016a1c7:
CALL 0x001a1b22
MOV R14D,dword ptr [RAX]
MOV RDI,RBX
MOV ESI,0x1
CALL 0x00137de6
OR byte ptr [RBX + 0x624],0x4
CALL 0x001a1b22
MOV dword ptr [RAX],R14D
LAB_0016a1eb:
MOV EAX,R14D
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016a1fd:
XOR R12D,R12D
JMP 0x0016a059
LAB_0016a205:
MOV RDI,R14
MOV ESI,0x5
CALL 0x00154f0e
TEST EAX,EAX
JNZ 0x0016a233
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBX + 0x8]
MOV RDX,qword ptr [RAX + 0x78]
MOV RDI,R14
XOR ECX,ECX
XOR R8D,R8D
CALL 0x00145f82
TEST EAX,EAX
JZ 0x0016a244
LAB_0016a233:
MOV RAX,qword ptr [RBX + 0x8]
MOV qword ptr [RAX + 0x90],0x0
JMP 0x0016a1c7
LAB_0016a244:
MOV RDI,RBX
CALL 0x0013647a
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RCX + 0x90],0x0
TEST EAX,EAX
JNZ 0x0016a1c7
JMP 0x0016a11c
LAB_0016a268:
LEA RCX,[RBP + -0x2c]
MOV RDI,RAX
MOV ESI,R15D
MOV R15,RCX
MOV RDX,RCX
CALL 0x0012d48d
MOV EAX,dword ptr [R15]
JMP 0x0016a0d5
|
int4 maria_delete_all_rows(long *param_1)
{
int4 uVar1;
long lVar2;
long lVar3;
bool bVar4;
char cVar5;
int iVar6;
int4 *puVar7;
long lVar8;
int1 local_88 [32];
int *local_68;
int8 local_60;
int8 local_40;
int local_34;
lVar2 = *param_1;
if ((*(byte *)(lVar2 + 0x722) & 1) != 0) {
puVar7 = (int4 *)_my_thread_var();
*puVar7 = 0xd;
return 0xd;
}
lVar3 = *(long *)(lVar2 + 0x5f0);
iVar6 = _ma_readinfo(param_1,1,1);
if (iVar6 != 0) {
puVar7 = (int4 *)_my_thread_var();
return *puVar7;
}
if ((*(char *)(lVar2 + 0x7e7) == '\0') || (*(char *)(lVar2 + 0x7d9) != '\0')) {
iVar6 = _ma_mark_file_changed(lVar2);
if (iVar6 != 0) goto LAB_0016a1c7;
_ma_reset_status(param_1);
bVar4 = true;
}
else {
local_68 = &local_34;
local_60 = 2;
cVar5 = translog_write_record(&local_40,0x21,param_1[1],param_1,0,3,local_88,local_68,0);
if (((cVar5 != '\0') || (cVar5 = translog_flush(local_40), cVar5 != '\0')) ||
(iVar6 = _ma_mark_file_changed(lVar2), iVar6 != 0)) goto LAB_0016a1c7;
bVar4 = false;
}
_ma_reset_state(param_1);
*(int4 *)(lVar2 + 0x170) = 0;
if (lVar3 != 0) {
_ma_unmap_file(param_1);
}
iVar6 = _ma_flush_table_files(param_1,3,2,2);
if (iVar6 == 0) {
uVar1 = (int4)param_1[0x90];
lVar8 = (**(code **)(PSI_server + 0x158))(local_88,uVar1,0xd);
if (lVar8 == 0) {
local_34 = my_chsize(uVar1,0,0,0x10);
}
else {
maria_delete_all_rows_cold_1(lVar8,uVar1,&local_34);
}
if (((local_34 == 0) &&
(iVar6 = inline_mysql_file_chsize
(0x6c,*(int4 *)(lVar2 + 0x760),*(int8 *)(lVar2 + 0x360)),
iVar6 == 0)) && (iVar6 = _ma_initialize_data_file(lVar2,(int)param_1[0x90]), iVar6 == 0)) {
if (bVar4) {
LAB_0016a11c:
if ((*(byte *)((long)param_1 + 0x61c) & 0x10) != 0) {
reinit_io_cache(param_1 + 0x97,2,0,1,1);
}
_ma_writeinfo(param_1,1);
if (lVar3 == 0) {
return 0;
}
_ma_dynmap_file(param_1,0);
return 0;
}
iVar6 = _ma_state_info_write(lVar2,5);
if ((iVar6 == 0) &&
(iVar6 = _ma_update_state_lsns(lVar2,local_40,*(int8 *)(param_1[1] + 0x78),0,0),
iVar6 == 0)) {
iVar6 = _ma_sync_table_files(param_1);
*(int8 *)(param_1[1] + 0x90) = 0;
if (iVar6 == 0) goto LAB_0016a11c;
}
else {
*(int8 *)(param_1[1] + 0x90) = 0;
}
}
}
LAB_0016a1c7:
puVar7 = (int4 *)_my_thread_var();
uVar1 = *puVar7;
_ma_writeinfo(param_1,1);
*(byte *)((long)param_1 + 0x624) = *(byte *)((long)param_1 + 0x624) | 4;
puVar7 = (int4 *)_my_thread_var();
*puVar7 = uVar1;
return uVar1;
}
| |
25,017 | ggml_compute_forward_soft_max_back_f32 | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c | static void ggml_compute_forward_soft_max_back_f32(
const struct ggml_compute_params * params,
struct ggml_tensor * dst) {
const struct ggml_tensor * src0 = dst->src[0];
const struct ggml_tensor * src1 = dst->src[1];
GGML_ASSERT(ggml_is_contiguous(src0));
GGML_ASSERT(ggml_is_contiguous(src1));
GGML_ASSERT(ggml_is_contiguous(dst));
GGML_ASSERT(ggml_are_same_shape(src0, dst));
GGML_ASSERT(ggml_are_same_shape(src1, dst));
// TODO: handle transposed/permuted matrices
const int ith = params->ith;
const int nth = params->nth;
const int nc = src0->ne[0];
const int nr = ggml_nrows(src0);
// rows per thread
const int dr = (nr + nth - 1)/nth;
// row range for this thread
const int ir0 = dr*ith;
const int ir1 = MIN(ir0 + dr, nr);
for (int i1 = ir0; i1 < ir1; i1++) {
float *dy = (float *)((char *) src0->data + i1*src0->nb[1]);
float *y = (float *)((char *) src1->data + i1*src1->nb[1]);
float *dx = (float *)((char *) dst->data + i1*dst->nb[1]);
#ifndef NDEBUG
for (int i = 0; i < nc; ++i) {
//printf("p[%d] = %f\n", i, p[i]);
assert(!isnan(dy[i]));
assert(!isnan(y[i]));
}
#endif
// Jii = yi - yi*yi
// Jij = -yi*yj
// J = diag(y)-y.T*y
// dx = J * dy
// dxk = sum_i(Jki * dyi)
// dxk = sum_i(-yk*yi * dyi) - (-yk*yk)*dyk + (yk - yk*yk)*dyk
// dxk = sum_i(-yk*yi * dyi) + yk*yk*dyk + yk*dyk - yk*yk*dyk
// dxk = sum_i(-yk*yi * dyi) + yk*dyk
// dxk = -yk * sum_i(yi * dyi) + yk*dyk
// dxk = -yk * dot(y, dy) + yk*dyk
// dxk = yk * (- dot(y, dy) + dyk)
// dxk = yk * (dyk - dot(y, dy))
//
// post-order:
// dot_y_dy := dot(y, dy)
// dx := dy
// dx := dx - dot_y_dy
// dx := dx * y
// linear runtime, no additional memory
float dot_y_dy = 0;
ggml_vec_dot_f32 (nc, &dot_y_dy, 0, y, 0, dy, 0, 1);
ggml_vec_cpy_f32 (nc, dx, dy);
ggml_vec_acc1_f32(nc, dx, -dot_y_dy);
ggml_vec_mul_f32 (nc, dx, dx, y);
#ifndef NDEBUG
for (int i = 0; i < nc; ++i) {
assert(!isnan(dx[i]));
assert(!isinf(dx[i]));
}
#endif
}
} | O0 | c | ggml_compute_forward_soft_max_back_f32:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd280
testb $0x1, %al
jne 0x2f50f
leaq 0x4466d(%rip), %rdi # 0x73b62
movl $0x22d6, %esi # imm = 0x22D6
leaq 0x446c0(%rip), %rdx # 0x73bc1
leaq 0x44d7a(%rip), %rcx # 0x74282
movb $0x0, %al
callq 0xe270
movq -0x20(%rbp), %rdi
callq 0xd280
testb $0x1, %al
jne 0x2f53d
leaq 0x4463f(%rip), %rdi # 0x73b62
movl $0x22d7, %esi # imm = 0x22D7
leaq 0x44692(%rip), %rdx # 0x73bc1
leaq 0x45d84(%rip), %rcx # 0x752ba
movb $0x0, %al
callq 0xe270
movq -0x10(%rbp), %rdi
callq 0xd280
testb $0x1, %al
jne 0x2f56b
leaq 0x44611(%rip), %rdi # 0x73b62
movl $0x22d8, %esi # imm = 0x22D8
leaq 0x44664(%rip), %rdx # 0x73bc1
leaq 0x45a30(%rip), %rcx # 0x74f94
movb $0x0, %al
callq 0xe270
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe260
testb $0x1, %al
jne 0x2f59d
leaq 0x445df(%rip), %rdi # 0x73b62
movl $0x22d9, %esi # imm = 0x22D9
leaq 0x44632(%rip), %rdx # 0x73bc1
leaq 0x44d24(%rip), %rcx # 0x742ba
movb $0x0, %al
callq 0xe270
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe260
testb $0x1, %al
jne 0x2f5cf
leaq 0x445ad(%rip), %rdi # 0x73b62
movl $0x22da, %esi # imm = 0x22DA
leaq 0x44600(%rip), %rdx # 0x73bc1
leaq 0x45d0b(%rip), %rcx # 0x752d3
movb $0x0, %al
callq 0xe270
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
callq 0xdc20
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
addl -0x28(%rbp), %eax
subl $0x1, %eax
cltd
idivl -0x28(%rbp)
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
imull -0x24(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
addl -0x34(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x2f629
movl -0x38(%rbp), %eax
addl -0x34(%rbp), %eax
movl %eax, -0x68(%rbp)
jmp 0x2f62f
movl -0x30(%rbp), %eax
movl %eax, -0x68(%rbp)
movl -0x68(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jge 0x2f88f
movq -0x18(%rbp), %rax
movq 0xf8(%rax), %rax
movslq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rdx
imulq 0x38(%rdx), %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq 0xf8(%rax), %rax
movslq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rdx
imulq 0x38(%rdx), %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movslq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rdx
imulq 0x38(%rdx), %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x2f739
movq -0x48(%rbp), %rax
movslq -0x5c(%rbp), %rcx
vmovss (%rax,%rcx,4), %xmm0
vucomiss %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x2f6d1
jmp 0x2f6f0
leaq 0x45c1a(%rip), %rdi # 0x752f2
leaq 0x44483(%rip), %rsi # 0x73b62
movl $0x22f3, %edx # imm = 0x22F3
leaq 0x45c15(%rip), %rcx # 0x75300
callq 0xd690
movq -0x50(%rbp), %rax
movslq -0x5c(%rbp), %rcx
vmovss (%rax,%rcx,4), %xmm0
vucomiss %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x2f70a
jmp 0x2f729
leaq 0x45c55(%rip), %rdi # 0x75366
leaq 0x4444a(%rip), %rsi # 0x73b62
movl $0x22f4, %edx # imm = 0x22F4
leaq 0x45bdc(%rip), %rcx # 0x75300
callq 0xd690
jmp 0x2f72b
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x2f6ab
vpxor %xmm0, %xmm0, %xmm0
vmovss %xmm0, -0x60(%rbp)
movl -0x2c(%rbp), %edi
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %r9
leaq -0x60(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
movq $0x0, (%rsp)
movl $0x1, 0x8(%rsp)
callq 0x12020
movl -0x2c(%rbp), %edi
movq -0x58(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x27660
movl -0x2c(%rbp), %edi
movq -0x58(%rbp), %rsi
vmovss -0x60(%rbp), %xmm0
vmovd %xmm0, %eax
xorl $0x80000000, %eax # imm = 0x80000000
vmovd %eax, %xmm0
callq 0x233b0
movl -0x2c(%rbp), %edi
movq -0x58(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rcx
callq 0x24920
movl $0x0, -0x64(%rbp)
movl -0x64(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x2f87f
movq -0x58(%rbp), %rax
movslq -0x64(%rbp), %rcx
vmovss (%rax,%rcx,4), %xmm0
vucomiss %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x2f7dd
jmp 0x2f7fc
leaq 0x45b8f(%rip), %rdi # 0x75373
leaq 0x44377(%rip), %rsi # 0x73b62
movl $0x2313, %edx # imm = 0x2313
leaq 0x45b09(%rip), %rcx # 0x75300
callq 0xd690
movq -0x58(%rbp), %rax
movslq -0x64(%rbp), %rcx
vmovss (%rax,%rcx,4), %xmm1
vmovaps %xmm1, %xmm0
vpbroadcastd 0x442ca(%rip), %xmm2 # 0x73ae0
vpand %xmm2, %xmm0, %xmm0
vmovd %xmm1, %edx
movl $0x1, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl $0x0, %edx
cmovll %eax, %ecx
vmovss 0x442a6(%rip), %xmm1 # 0x73adc
xorl %eax, %eax
vucomiss %xmm1, %xmm0
setnp %sil
sete %dl
testb %sil, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
jne 0x2f850
jmp 0x2f86f
leaq 0x45b2a(%rip), %rdi # 0x75381
leaq 0x44304(%rip), %rsi # 0x73b62
movl $0x2314, %edx # imm = 0x2314
leaq 0x45a96(%rip), %rcx # 0x75300
callq 0xd690
jmp 0x2f871
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x2f7b7
jmp 0x2f881
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x2f63b
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| ggml_compute_forward_soft_max_back_f32:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov rax, [rax+98h]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov rax, [rax+0A0h]
mov [rbp+var_20], rax
mov rdi, [rbp+var_18]
call _ggml_is_contiguous
test al, 1
jnz short loc_2F50F
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov esi, 22D6h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlIsContiguo_1+1Bh; "ggml_is_contiguous(src0)"
mov al, 0
call _ggml_abort
loc_2F50F:
mov rdi, [rbp+var_20]
call _ggml_is_contiguous
test al, 1
jnz short loc_2F53D
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov esi, 22D7h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlIsContiguo_6; "ggml_is_contiguous(src1)"
mov al, 0
call _ggml_abort
loc_2F53D:
mov rdi, [rbp+var_10]
call _ggml_is_contiguous
test al, 1
jnz short loc_2F56B
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov esi, 22D8h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlIsContiguo_5; "ggml_is_contiguous(dst)"
mov al, 0
call _ggml_abort
loc_2F56B:
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_10]
call _ggml_are_same_shape
test al, 1
jnz short loc_2F59D
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov esi, 22D9h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlCanRepeatS+1Fh; "ggml_are_same_shape(src0, dst)"
mov al, 0
call _ggml_abort
loc_2F59D:
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_10]
call _ggml_are_same_shape
test al, 1
jnz short loc_2F5CF
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov esi, 22DAh
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlAreSameSha_3; "ggml_are_same_shape(src1, dst)"
mov al, 0
call _ggml_abort
loc_2F5CF:
mov rax, [rbp+var_8]
mov eax, [rax]
mov [rbp+var_24], eax
mov rax, [rbp+var_8]
mov eax, [rax+4]
mov [rbp+var_28], eax
mov rax, [rbp+var_18]
mov rax, [rax+10h]
mov [rbp+var_2C], eax
mov rdi, [rbp+var_18]
call _ggml_nrows
mov [rbp+var_30], eax
mov eax, [rbp+var_30]
add eax, [rbp+var_28]
sub eax, 1
cdq
idiv [rbp+var_28]
mov [rbp+var_34], eax
mov eax, [rbp+var_34]
imul eax, [rbp+var_24]
mov [rbp+var_38], eax
mov eax, [rbp+var_38]
add eax, [rbp+var_34]
cmp eax, [rbp+var_30]
jge short loc_2F629
mov eax, [rbp+var_38]
add eax, [rbp+var_34]
mov [rbp+var_68], eax
jmp short loc_2F62F
loc_2F629:
mov eax, [rbp+var_30]
mov [rbp+var_68], eax
loc_2F62F:
mov eax, [rbp+var_68]
mov [rbp+var_3C], eax
mov eax, [rbp+var_38]
mov [rbp+var_40], eax
loc_2F63B:
mov eax, [rbp+var_40]
cmp eax, [rbp+var_3C]
jge loc_2F88F
mov rax, [rbp+var_18]
mov rax, [rax+0F8h]
movsxd rcx, [rbp+var_40]
mov rdx, [rbp+var_18]
imul rcx, [rdx+38h]
add rax, rcx
mov [rbp+var_48], rax
mov rax, [rbp+var_20]
mov rax, [rax+0F8h]
movsxd rcx, [rbp+var_40]
mov rdx, [rbp+var_20]
imul rcx, [rdx+38h]
add rax, rcx
mov [rbp+var_50], rax
mov rax, [rbp+var_10]
mov rax, [rax+0F8h]
movsxd rcx, [rbp+var_40]
mov rdx, [rbp+var_10]
imul rcx, [rdx+38h]
add rax, rcx
mov [rbp+var_58], rax
mov [rbp+var_5C], 0
loc_2F6AB:
mov eax, [rbp+var_5C]
cmp eax, [rbp+var_2C]
jge loc_2F739
mov rax, [rbp+var_48]
movsxd rcx, [rbp+var_5C]
vmovss xmm0, dword ptr [rax+rcx*4]
vucomiss xmm0, xmm0
setp al
test al, 1
jnz short loc_2F6D1
jmp short loc_2F6F0
loc_2F6D1:
lea rdi, aIsnanDyI; "!isnan(dy[i])"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 22F3h
lea rcx, aVoidGgmlComput_20; "void ggml_compute_forward_soft_max_back"...
call ___assert_fail
loc_2F6F0:
mov rax, [rbp+var_50]
movsxd rcx, [rbp+var_5C]
vmovss xmm0, dword ptr [rax+rcx*4]
vucomiss xmm0, xmm0
setp al
test al, 1
jnz short loc_2F70A
jmp short loc_2F729
loc_2F70A:
lea rdi, aIsnanYI; "!isnan(y[i])"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 22F4h
lea rcx, aVoidGgmlComput_20; "void ggml_compute_forward_soft_max_back"...
call ___assert_fail
loc_2F729:
jmp short $+2
loc_2F72B:
mov eax, [rbp+var_5C]
add eax, 1
mov [rbp+var_5C], eax
jmp loc_2F6AB
loc_2F739:
vpxor xmm0, xmm0, xmm0
vmovss [rbp+var_60], xmm0
mov edi, [rbp+var_2C]
mov rcx, [rbp+var_50]
mov r9, [rbp+var_48]
lea rsi, [rbp+var_60]
xor eax, eax
mov r8d, eax
mov rdx, r8
mov [rsp+80h+var_80], 0
mov [rsp+80h+var_78], 1
call ggml_vec_dot_f32
mov edi, [rbp+var_2C]
mov rsi, [rbp+var_58]
mov rdx, [rbp+var_48]
call ggml_vec_cpy_f32
mov edi, [rbp+var_2C]
mov rsi, [rbp+var_58]
vmovss xmm0, [rbp+var_60]
vmovd eax, xmm0
xor eax, 80000000h
vmovd xmm0, eax
call ggml_vec_acc1_f32
mov edi, [rbp+var_2C]
mov rsi, [rbp+var_58]
mov rdx, [rbp+var_58]
mov rcx, [rbp+var_50]
call ggml_vec_mul_f32
mov [rbp+var_64], 0
loc_2F7B7:
mov eax, [rbp+var_64]
cmp eax, [rbp+var_2C]
jge loc_2F87F
mov rax, [rbp+var_58]
movsxd rcx, [rbp+var_64]
vmovss xmm0, dword ptr [rax+rcx*4]
vucomiss xmm0, xmm0
setp al
test al, 1
jnz short loc_2F7DD
jmp short loc_2F7FC
loc_2F7DD:
lea rdi, aIsnanDxI; "!isnan(dx[i])"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 2313h
lea rcx, aVoidGgmlComput_20; "void ggml_compute_forward_soft_max_back"...
call ___assert_fail
loc_2F7FC:
mov rax, [rbp+var_58]
movsxd rcx, [rbp+var_64]
vmovss xmm1, dword ptr [rax+rcx*4]
vmovaps xmm0, xmm1
vpbroadcastd xmm2, cs:dword_73AE0
vpand xmm0, xmm0, xmm2
vmovd edx, xmm1
mov ecx, 1
mov eax, 0FFFFFFFFh
cmp edx, 0
cmovl ecx, eax
vmovss xmm1, cs:dword_73ADC
xor eax, eax
vucomiss xmm0, xmm1
setnp sil
setz dl
test dl, sil
cmovnz eax, ecx
cmp eax, 0
jnz short loc_2F850
jmp short loc_2F86F
loc_2F850:
lea rdi, aIsinfDxI; "!isinf(dx[i])"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 2314h
lea rcx, aVoidGgmlComput_20; "void ggml_compute_forward_soft_max_back"...
call ___assert_fail
loc_2F86F:
jmp short $+2
loc_2F871:
mov eax, [rbp+var_64]
add eax, 1
mov [rbp+var_64], eax
jmp loc_2F7B7
loc_2F87F:
jmp short $+2
loc_2F881:
mov eax, [rbp+var_40]
add eax, 1
mov [rbp+var_40], eax
jmp loc_2F63B
loc_2F88F:
add rsp, 80h
pop rbp
retn
| long long ggml_compute_forward_soft_max_back_f32(int *a1, long long a2, __m128 _XMM0)
{
long long result; // rax
int v21; // ecx
int v23; // eax
int v24; // [rsp+18h] [rbp-68h]
int k; // [rsp+1Ch] [rbp-64h]
int v26; // [rsp+20h] [rbp-60h] BYREF
int j; // [rsp+24h] [rbp-5Ch]
long long v28; // [rsp+28h] [rbp-58h]
long long v29; // [rsp+30h] [rbp-50h]
long long v30; // [rsp+38h] [rbp-48h]
int i; // [rsp+40h] [rbp-40h]
int v32; // [rsp+44h] [rbp-3Ch]
int v33; // [rsp+48h] [rbp-38h]
int v34; // [rsp+4Ch] [rbp-34h]
int v35; // [rsp+50h] [rbp-30h]
int v36; // [rsp+54h] [rbp-2Ch]
int v37; // [rsp+58h] [rbp-28h]
int v38; // [rsp+5Ch] [rbp-24h]
long long v39; // [rsp+60h] [rbp-20h]
_QWORD *v40; // [rsp+68h] [rbp-18h]
long long v41; // [rsp+70h] [rbp-10h]
int *v42; // [rsp+78h] [rbp-8h]
v42 = a1;
v41 = a2;
v40 = *(_QWORD **)(a2 + 152);
v39 = *(_QWORD *)(a2 + 160);
if ( (ggml_is_contiguous(v40) & 1) == 0 )
*(double *)_XMM0.m128_u64 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
8918LL,
"GGML_ASSERT(%s) failed",
"ggml_is_contiguous(src0)");
if ( (ggml_is_contiguous(v39) & 1) == 0 )
*(double *)_XMM0.m128_u64 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
8919LL,
"GGML_ASSERT(%s) failed",
"ggml_is_contiguous(src1)");
if ( (ggml_is_contiguous(v41) & 1) == 0 )
*(double *)_XMM0.m128_u64 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
8920LL,
"GGML_ASSERT(%s) failed",
"ggml_is_contiguous(dst)");
if ( (ggml_are_same_shape(v40, v41) & 1) == 0 )
*(double *)_XMM0.m128_u64 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
8921LL,
"GGML_ASSERT(%s) failed",
"ggml_are_same_shape(src0, dst)");
if ( (ggml_are_same_shape(v39, v41) & 1) == 0 )
*(double *)_XMM0.m128_u64 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
8922LL,
"GGML_ASSERT(%s) failed",
"ggml_are_same_shape(src1, dst)");
v38 = *v42;
v37 = v42[1];
v36 = v40[2];
v35 = ggml_nrows(v40);
v34 = (v37 + v35 - 1) / v37;
v33 = v38 * v34;
if ( v34 + v38 * v34 >= v35 )
v24 = v35;
else
v24 = v34 + v33;
v32 = v24;
for ( i = v33; ; ++i )
{
result = (unsigned int)i;
if ( i >= v32 )
break;
v30 = v40[7] * i + v40[31];
v29 = *(_QWORD *)(v39 + 56) * i + *(_QWORD *)(v39 + 248);
v28 = *(_QWORD *)(v41 + 56) * i + *(_QWORD *)(v41 + 248);
for ( j = 0; j < v36; ++j )
{
_RAX = v30;
_RCX = j;
__asm
{
vmovss xmm0, dword ptr [rax+rcx*4]
vucomiss xmm0, xmm0
}
if ( __SETP__(j, v36) )
__assert_fail(
"!isnan(dy[i])",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
8947LL,
"void ggml_compute_forward_soft_max_back_f32(const struct ggml_compute_params *, struct ggml_tensor *)");
_RAX = v29;
_RCX = j;
__asm
{
vmovss xmm0, dword ptr [rax+rcx*4]
vucomiss xmm0, xmm0
}
if ( __SETP__(__SETP__(j, v36), 0) )
__assert_fail(
"!isnan(y[i])",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
8948LL,
"void ggml_compute_forward_soft_max_back_f32(const struct ggml_compute_params *, struct ggml_tensor *)");
}
__asm
{
vpxor xmm0, xmm0, xmm0
vmovss [rbp+var_60], xmm0
}
ggml_vec_dot_f32(v36, (long long)&v26, 0LL, v29, 0LL, v30, _XMM0, 0LL, 1);
ggml_vec_cpy_f32(v36, v28, v30);
__asm
{
vmovss xmm0, [rbp+var_60]
vmovd eax, xmm0
}
_EAX ^= 0x80000000;
__asm { vmovd xmm0, eax }
ggml_vec_acc1_f32(v36, v28, _XMM0);
ggml_vec_mul_f32(v36, v28, v28);
for ( k = 0; k < v36; ++k )
{
_RAX = v28;
_RCX = k;
__asm
{
vmovss xmm0, dword ptr [rax+rcx*4]
vucomiss xmm0, xmm0
}
if ( __SETP__(k, v36) )
__assert_fail(
"!isnan(dx[i])",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
8979LL,
"void ggml_compute_forward_soft_max_back_f32(const struct ggml_compute_params *, struct ggml_tensor *)");
_RAX = v28;
_RCX = k;
__asm
{
vmovss xmm1, dword ptr [rax+rcx*4]
vmovaps xmm0, xmm1
vpbroadcastd xmm2, cs:dword_73AE0
vpand xmm0, xmm0, xmm2
vmovd edx, xmm1
}
v21 = 1;
if ( _EDX < 0 )
v21 = -1;
__asm { vmovss xmm1, cs:dword_73ADC }
v23 = 0;
__asm { vucomiss xmm0, xmm1 }
if ( !__SETP__(0, 0) )
v23 = v21;
if ( v23 )
__assert_fail(
"!isinf(dx[i])",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
8980LL,
"void ggml_compute_forward_soft_max_back_f32(const struct ggml_compute_params *, struct ggml_tensor *)");
}
}
return result;
}
| ggml_compute_forward_soft_max_back_f32:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x98]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xa0]
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0010d280
TEST AL,0x1
JNZ 0x0012f50f
LEA RDI,[0x173b62]
MOV ESI,0x22d6
LEA RDX,[0x173bc1]
LEA RCX,[0x174282]
MOV AL,0x0
CALL 0x0010e270
LAB_0012f50f:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x0010d280
TEST AL,0x1
JNZ 0x0012f53d
LEA RDI,[0x173b62]
MOV ESI,0x22d7
LEA RDX,[0x173bc1]
LEA RCX,[0x1752ba]
MOV AL,0x0
CALL 0x0010e270
LAB_0012f53d:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0010d280
TEST AL,0x1
JNZ 0x0012f56b
LEA RDI,[0x173b62]
MOV ESI,0x22d8
LEA RDX,[0x173bc1]
LEA RCX,[0x174f94]
MOV AL,0x0
CALL 0x0010e270
LAB_0012f56b:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x0010e260
TEST AL,0x1
JNZ 0x0012f59d
LEA RDI,[0x173b62]
MOV ESI,0x22d9
LEA RDX,[0x173bc1]
LEA RCX,[0x1742ba]
MOV AL,0x0
CALL 0x0010e270
LAB_0012f59d:
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x0010e260
TEST AL,0x1
JNZ 0x0012f5cf
LEA RDI,[0x173b62]
MOV ESI,0x22da
LEA RDX,[0x173bc1]
LEA RCX,[0x1752d3]
MOV AL,0x0
CALL 0x0010e270
LAB_0012f5cf:
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RBP + -0x28],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x10]
MOV dword ptr [RBP + -0x2c],EAX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0010dc20
MOV dword ptr [RBP + -0x30],EAX
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,dword ptr [RBP + -0x28]
SUB EAX,0x1
CDQ
IDIV dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x34]
IMUL EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x38],EAX
MOV EAX,dword ptr [RBP + -0x38]
ADD EAX,dword ptr [RBP + -0x34]
CMP EAX,dword ptr [RBP + -0x30]
JGE 0x0012f629
MOV EAX,dword ptr [RBP + -0x38]
ADD EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x68],EAX
JMP 0x0012f62f
LAB_0012f629:
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x68],EAX
LAB_0012f62f:
MOV EAX,dword ptr [RBP + -0x68]
MOV dword ptr [RBP + -0x3c],EAX
MOV EAX,dword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x40],EAX
LAB_0012f63b:
MOV EAX,dword ptr [RBP + -0x40]
CMP EAX,dword ptr [RBP + -0x3c]
JGE 0x0012f88f
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0xf8]
MOVSXD RCX,dword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x18]
IMUL RCX,qword ptr [RDX + 0x38]
ADD RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0xf8]
MOVSXD RCX,dword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x20]
IMUL RCX,qword ptr [RDX + 0x38]
ADD RAX,RCX
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xf8]
MOVSXD RCX,dword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x10]
IMUL RCX,qword ptr [RDX + 0x38]
ADD RAX,RCX
MOV qword ptr [RBP + -0x58],RAX
MOV dword ptr [RBP + -0x5c],0x0
LAB_0012f6ab:
MOV EAX,dword ptr [RBP + -0x5c]
CMP EAX,dword ptr [RBP + -0x2c]
JGE 0x0012f739
MOV RAX,qword ptr [RBP + -0x48]
MOVSXD RCX,dword ptr [RBP + -0x5c]
VMOVSS XMM0,dword ptr [RAX + RCX*0x4]
VUCOMISS XMM0,XMM0
SETP AL
TEST AL,0x1
JNZ 0x0012f6d1
JMP 0x0012f6f0
LAB_0012f6d1:
LEA RDI,[0x1752f2]
LEA RSI,[0x173b62]
MOV EDX,0x22f3
LEA RCX,[0x175300]
CALL 0x0010d690
LAB_0012f6f0:
MOV RAX,qword ptr [RBP + -0x50]
MOVSXD RCX,dword ptr [RBP + -0x5c]
VMOVSS XMM0,dword ptr [RAX + RCX*0x4]
VUCOMISS XMM0,XMM0
SETP AL
TEST AL,0x1
JNZ 0x0012f70a
JMP 0x0012f729
LAB_0012f70a:
LEA RDI,[0x175366]
LEA RSI,[0x173b62]
MOV EDX,0x22f4
LEA RCX,[0x175300]
CALL 0x0010d690
LAB_0012f729:
JMP 0x0012f72b
LAB_0012f72b:
MOV EAX,dword ptr [RBP + -0x5c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x5c],EAX
JMP 0x0012f6ab
LAB_0012f739:
VPXOR XMM0,XMM0,XMM0
VMOVSS dword ptr [RBP + -0x60],XMM0
MOV EDI,dword ptr [RBP + -0x2c]
MOV RCX,qword ptr [RBP + -0x50]
MOV R9,qword ptr [RBP + -0x48]
LEA RSI,[RBP + -0x60]
XOR EAX,EAX
MOV R8D,EAX
MOV RDX,R8
MOV qword ptr [RSP],0x0
MOV dword ptr [RSP + 0x8],0x1
CALL 0x00112020
MOV EDI,dword ptr [RBP + -0x2c]
MOV RSI,qword ptr [RBP + -0x58]
MOV RDX,qword ptr [RBP + -0x48]
CALL 0x00127660
MOV EDI,dword ptr [RBP + -0x2c]
MOV RSI,qword ptr [RBP + -0x58]
VMOVSS XMM0,dword ptr [RBP + -0x60]
VMOVD EAX,XMM0
XOR EAX,0x80000000
VMOVD XMM0,EAX
CALL 0x001233b0
MOV EDI,dword ptr [RBP + -0x2c]
MOV RSI,qword ptr [RBP + -0x58]
MOV RDX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x50]
CALL 0x00124920
MOV dword ptr [RBP + -0x64],0x0
LAB_0012f7b7:
MOV EAX,dword ptr [RBP + -0x64]
CMP EAX,dword ptr [RBP + -0x2c]
JGE 0x0012f87f
MOV RAX,qword ptr [RBP + -0x58]
MOVSXD RCX,dword ptr [RBP + -0x64]
VMOVSS XMM0,dword ptr [RAX + RCX*0x4]
VUCOMISS XMM0,XMM0
SETP AL
TEST AL,0x1
JNZ 0x0012f7dd
JMP 0x0012f7fc
LAB_0012f7dd:
LEA RDI,[0x175373]
LEA RSI,[0x173b62]
MOV EDX,0x2313
LEA RCX,[0x175300]
CALL 0x0010d690
LAB_0012f7fc:
MOV RAX,qword ptr [RBP + -0x58]
MOVSXD RCX,dword ptr [RBP + -0x64]
VMOVSS XMM1,dword ptr [RAX + RCX*0x4]
VMOVAPS XMM0,XMM1
VPBROADCASTD XMM2,dword ptr [0x00173ae0]
VPAND XMM0,XMM0,XMM2
VMOVD EDX,XMM1
MOV ECX,0x1
MOV EAX,0xffffffff
CMP EDX,0x0
CMOVL ECX,EAX
VMOVSS XMM1,dword ptr [0x00173adc]
XOR EAX,EAX
VUCOMISS XMM0,XMM1
SETNP SIL
SETZ DL
TEST DL,SIL
CMOVNZ EAX,ECX
CMP EAX,0x0
JNZ 0x0012f850
JMP 0x0012f86f
LAB_0012f850:
LEA RDI,[0x175381]
LEA RSI,[0x173b62]
MOV EDX,0x2314
LEA RCX,[0x175300]
CALL 0x0010d690
LAB_0012f86f:
JMP 0x0012f871
LAB_0012f871:
MOV EAX,dword ptr [RBP + -0x64]
ADD EAX,0x1
MOV dword ptr [RBP + -0x64],EAX
JMP 0x0012f7b7
LAB_0012f87f:
JMP 0x0012f881
LAB_0012f881:
MOV EAX,dword ptr [RBP + -0x40]
ADD EAX,0x1
MOV dword ptr [RBP + -0x40],EAX
JMP 0x0012f63b
LAB_0012f88f:
ADD RSP,0x80
POP RBP
RET
|
void ggml_compute_forward_soft_max_back_f32(int *param_1,long param_2)
{
uint uVar1;
int iVar2;
ulong uVar3;
int iVar4;
int1 auVar5 [16];
int local_70;
int local_6c;
uint local_68;
int local_64;
long local_60;
long local_58;
long local_50;
int local_48;
int local_44;
int local_40;
int local_3c;
int local_38;
int local_34;
int local_30;
int local_2c;
long local_28;
long local_20;
long local_18;
int *local_10;
local_20 = *(long *)(param_2 + 0x98);
local_28 = *(long *)(param_2 + 0xa0);
local_18 = param_2;
local_10 = param_1;
uVar3 = ggml_is_contiguous(local_20);
if ((uVar3 & 1) == 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0x22d6,"GGML_ASSERT(%s) failed","ggml_is_contiguous(src0)");
}
uVar3 = ggml_is_contiguous(local_28);
if ((uVar3 & 1) == 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0x22d7,"GGML_ASSERT(%s) failed","ggml_is_contiguous(src1)");
}
uVar3 = ggml_is_contiguous(local_18);
if ((uVar3 & 1) == 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0x22d8,"GGML_ASSERT(%s) failed","ggml_is_contiguous(dst)");
}
uVar3 = ggml_are_same_shape(local_20,local_18);
if ((uVar3 & 1) == 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0x22d9,"GGML_ASSERT(%s) failed","ggml_are_same_shape(src0, dst)");
}
uVar3 = ggml_are_same_shape(local_28,local_18);
if ((uVar3 & 1) == 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0x22da,"GGML_ASSERT(%s) failed","ggml_are_same_shape(src1, dst)");
}
local_2c = *local_10;
local_30 = local_10[1];
local_34 = (int)*(int8 *)(local_20 + 0x10);
local_38 = ggml_nrows(local_20);
local_3c = (local_38 + local_30 + -1) / local_30;
local_48 = local_3c * local_2c;
local_70 = local_38;
if (local_48 + local_3c < local_38) {
local_70 = local_48 + local_3c;
}
local_44 = local_70;
local_40 = local_48;
do {
if (local_44 <= local_48) {
return;
}
local_50 = *(long *)(local_20 + 0xf8) + (long)local_48 * *(long *)(local_20 + 0x38);
local_58 = *(long *)(local_28 + 0xf8) + (long)local_48 * *(long *)(local_28 + 0x38);
local_60 = *(long *)(local_18 + 0xf8) + (long)local_48 * *(long *)(local_18 + 0x38);
for (local_64 = 0; local_64 < local_34; local_64 = local_64 + 1) {
if (NAN(*(float *)(local_50 + (long)local_64 * 4))) {
/* WARNING: Subroutine does not return */
__assert_fail("!isnan(dy[i])",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0x22f3,
"void ggml_compute_forward_soft_max_back_f32(const struct ggml_compute_params *, struct ggml_tensor *)"
);
}
if (NAN(*(float *)(local_58 + (long)local_64 * 4))) {
/* WARNING: Subroutine does not return */
__assert_fail("!isnan(y[i])",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0x22f4,
"void ggml_compute_forward_soft_max_back_f32(const struct ggml_compute_params *, struct ggml_tensor *)"
);
}
}
local_68 = 0;
ggml_vec_dot_f32(local_34,&local_68,0,local_58,0,local_50,0,1);
ggml_vec_cpy_f32(local_34,local_60,local_50);
ggml_vec_acc1_f32(local_68 ^ 0x80000000,local_34,local_60);
ggml_vec_mul_f32(local_34,local_60,local_60,local_58);
for (local_6c = 0; local_6c < local_34; local_6c = local_6c + 1) {
if (NAN(*(float *)(local_60 + (long)local_6c * 4))) {
/* WARNING: Subroutine does not return */
__assert_fail("!isnan(dx[i])",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0x2313,
"void ggml_compute_forward_soft_max_back_f32(const struct ggml_compute_params *, struct ggml_tensor *)"
);
}
uVar1 = *(uint *)(local_60 + (long)local_6c * 4);
auVar5._4_4_ = DAT_00173ae0;
auVar5._0_4_ = DAT_00173ae0;
auVar5._8_4_ = DAT_00173ae0;
auVar5._12_4_ = DAT_00173ae0;
auVar5 = vpand_avx(ZEXT416(uVar1),auVar5);
iVar4 = 1;
if ((int)uVar1 < 0) {
iVar4 = -1;
}
iVar2 = 0;
if (auVar5._0_4_ == DAT_00173adc) {
iVar2 = iVar4;
}
if (iVar2 != 0) {
/* WARNING: Subroutine does not return */
__assert_fail("!isinf(dx[i])",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0x2314,
"void ggml_compute_forward_soft_max_back_f32(const struct ggml_compute_params *, struct ggml_tensor *)"
);
}
}
local_48 = local_48 + 1;
} while( true );
}
| |
25,018 | pvio_socket_keepalive | eloqsql/libmariadb/plugins/pvio/pvio_socket.c | int pvio_socket_keepalive(MARIADB_PVIO *pvio)
{
int opt= 1;
struct st_pvio_socket *csock= NULL;
if (!pvio || !pvio->data)
return 1;
csock= (struct st_pvio_socket *)pvio->data;
return setsockopt(csock->socket, SOL_SOCKET, SO_KEEPALIVE,
#ifndef _WIN32
(const void *)&opt, sizeof(opt));
#else
(char *)&opt, (int)sizeof(opt));
#endif
} | O3 | c | pvio_socket_keepalive:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, -0x4(%rbp)
movl $0x1, %eax
testq %rdi, %rdi
je 0x5e217
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x5e217
movl (%rcx), %edi
leaq -0x4(%rbp), %rcx
movl $0x1, %esi
movl $0x9, %edx
movl $0x4, %r8d
callq 0x37120
addq $0x10, %rsp
popq %rbp
retq
| pvio_socket_keepalive:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_4], 1
mov eax, 1
test rdi, rdi
jz short loc_5E217
mov rcx, [rdi]
test rcx, rcx
jz short loc_5E217
mov edi, [rcx]
lea rcx, [rbp+var_4]
mov esi, 1
mov edx, 9
mov r8d, 4
call _setsockopt
loc_5E217:
add rsp, 10h
pop rbp
retn
| long long pvio_socket_keepalive(_QWORD *a1)
{
long long result; // rax
int v2; // [rsp+Ch] [rbp-4h] BYREF
v2 = 1;
result = 1LL;
if ( a1 )
{
if ( *a1 )
return setsockopt(*(unsigned int *)*a1, 1LL, 9LL, &v2, 4LL);
}
return result;
}
| pvio_socket_keepalive:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV dword ptr [RBP + -0x4],0x1
MOV EAX,0x1
TEST RDI,RDI
JZ 0x0015e217
MOV RCX,qword ptr [RDI]
TEST RCX,RCX
JZ 0x0015e217
MOV EDI,dword ptr [RCX]
LEA RCX,[RBP + -0x4]
MOV ESI,0x1
MOV EDX,0x9
MOV R8D,0x4
CALL 0x00137120
LAB_0015e217:
ADD RSP,0x10
POP RBP
RET
|
int pvio_socket_keepalive(int8 *param_1)
{
int iVar1;
int4 local_c;
local_c = 1;
iVar1 = 1;
if ((param_1 != (int8 *)0x0) && ((int *)*param_1 != (int *)0x0)) {
iVar1 = setsockopt(*(int *)*param_1,1,9,&local_c,4);
}
return iVar1;
}
| |
25,019 | my_suspend_hook | eloqsql/libmariadb/libmariadb/mariadb_lib.c | static void
my_suspend_hook(my_bool suspend, void *data)
{
struct my_hook_data *hook_data= (struct my_hook_data *)data;
if (suspend)
{
hook_data->orig_pvio= hook_data->orig_mysql->net.pvio;
hook_data->orig_mysql->net.pvio= hook_data->new_mysql->net.pvio;
}
else
hook_data->orig_mysql->net.pvio= hook_data->orig_pvio;
} | O0 | c | my_suspend_hook:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpb $0x0, -0x1(%rbp)
je 0x1d715
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
jmp 0x1d727
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| my_suspend_hook:
push rbp
mov rbp, rsp
mov al, dil
mov [rbp+var_1], al
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov [rbp+var_18], rax
cmp [rbp+var_1], 0
jz short loc_1D715
mov rax, [rbp+var_18]
mov rax, [rax]
mov rcx, [rax]
mov rax, [rbp+var_18]
mov [rax+10h], rcx
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov rcx, [rax]
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rax], rcx
jmp short loc_1D727
loc_1D715:
mov rax, [rbp+var_18]
mov rcx, [rax+10h]
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rax], rcx
loc_1D727:
pop rbp
retn
| _QWORD * my_suspend_hook(char a1, long long a2)
{
long long v2; // rcx
_QWORD *result; // rax
if ( a1 )
{
*(_QWORD *)(a2 + 16) = **(_QWORD **)a2;
v2 = **(_QWORD **)(a2 + 8);
}
else
{
v2 = *(_QWORD *)(a2 + 16);
}
result = *(_QWORD **)a2;
**(_QWORD **)a2 = v2;
return result;
}
| my_suspend_hook:
PUSH RBP
MOV RBP,RSP
MOV AL,DIL
MOV byte ptr [RBP + -0x1],AL
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x18],RAX
CMP byte ptr [RBP + -0x1],0x0
JZ 0x0011d715
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX],RCX
JMP 0x0011d727
LAB_0011d715:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX],RCX
LAB_0011d727:
POP RBP
RET
|
void my_suspend_hook(char param_1,int8 *param_2)
{
if (param_1 == '\0') {
*(int8 *)*param_2 = param_2[2];
}
else {
param_2[2] = *(int8 *)*param_2;
*(int8 *)*param_2 = *(int8 *)param_2[1];
}
return;
}
| |
25,020 | l_find(LF_SLIST**, charset_info_st const*, unsigned int, unsigned char const*, unsigned long, CURSOR*, LF_PINS*, char (*)(void*, void*)) | eloqsql/mysys/lf_hash.cc | static int l_find(LF_SLIST **head, CHARSET_INFO *cs, uint32 hashnr,
const uchar *key, size_t keylen, CURSOR *cursor, LF_PINS *pins,
my_hash_walk_action callback)
{
uint32 cur_hashnr;
const uchar *cur_key;
size_t cur_keylen;
intptr link;
DBUG_ASSERT(!cs || !callback); /* should not be set both */
DBUG_ASSERT(!keylen || !callback); /* should not be set both */
retry:
cursor->prev= (intptr *) my_assume_aligned<sizeof(intptr)>(head);
do { /* PTR() isn't necessary below, head is a dummy node */
cursor->curr= my_assume_aligned<sizeof(LF_SLIST *)>((LF_SLIST *)(*cursor->prev));
lf_pin(pins, 1, cursor->curr);
} while (my_atomic_loadptr(
(void **)my_assume_aligned<sizeof(LF_SLIST *)>(cursor->prev))
!= cursor->curr && LF_BACKOFF());
for (;;)
{
if (unlikely(!cursor->curr))
return 0; /* end of the list */
cur_hashnr= cursor->curr->hashnr;
cur_keylen= cursor->curr->keylen;
/* The key element needs to be aligned, not necessary what it points to */
my_assume_aligned<sizeof(const uchar *)>(&cursor->curr->key);
cur_key= (const uchar *) my_atomic_loadptr_explicit((void **) &cursor->curr->key,
MY_MEMORY_ORDER_ACQUIRE);
do {
/* attempting to my_assume_aligned onlink below broke the implementation */
link= (intptr) my_atomic_loadptr_explicit((void **) &cursor->curr->link,
MY_MEMORY_ORDER_RELAXED);
cursor->next= my_assume_aligned<sizeof(LF_SLIST *)>(PTR(link));
lf_pin(pins, 0, cursor->next);
} while (link != (intptr) my_atomic_loadptr((void *volatile *) &cursor->curr->link)
&& LF_BACKOFF());
if (!DELETED(link))
{
if (unlikely(callback))
{
if (cur_hashnr & 1 && callback(cursor->curr + 1, (void*)key))
return 1;
}
else if (cur_hashnr >= hashnr)
{
int r= 1;
if (cur_hashnr > hashnr ||
(r= my_strnncoll(cs, cur_key, cur_keylen, key, keylen)) >= 0)
return !r;
}
cursor->prev= &(cursor->curr->link);
if (!(cur_hashnr & 1)) /* dummy node */
head= (LF_SLIST **)cursor->prev;
lf_pin(pins, 2, cursor->curr);
}
else
{
/*
we found a deleted node - be nice, help the other thread
and remove this deleted node
*/
if (my_atomic_casptr((void **) cursor->prev,
(void **) &cursor->curr, cursor->next) && LF_BACKOFF())
lf_alloc_free(pins, cursor->curr);
else
goto retry;
}
cursor->curr= cursor->next;
lf_pin(pins, 1, cursor->curr);
}
} | O0 | cpp | l_find(LF_SLIST**, charset_info_st const*, unsigned int, unsigned char const*, unsigned long, CURSOR*, LF_PINS*, char (*)(void*, void*)):
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
jmp 0xfdbfc
jmp 0xfdbfe
jmp 0xfdc00
jmp 0xfdc02
movq -0x10(%rbp), %rdi
callq 0xfe030
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0xfe040
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xfdc31
jmp 0xfdc33
movq 0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
xchgq %rax, 0x8(%rcx)
jmp 0xfdc4d
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0xfe050
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rcx
movq -0x38(%rbp), %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0xb1(%rbp)
je 0xfdc87
callq 0xfe060
cmpl $0x0, %eax
setne %al
movb %al, -0xb1(%rbp)
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0xfdc15
jmp 0xfdc93
movq -0x38(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xfdcb7
movl $0x0, -0x4(%rbp)
jmp 0xfdf61
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x18(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x8, %rdi
callq 0xfe0a0
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
andq $-0x2, %rdi
callq 0xfe040
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xfdd2f
jmp 0xfdd31
movq 0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
xchgq %rax, (%rcx)
jmp 0xfdd4a
movq -0x58(%rbp), %rcx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0xb2(%rbp)
je 0xfdd85
callq 0xfe060
cmpl $0x0, %eax
setne %al
movb %al, -0xb2(%rbp)
movb -0xb2(%rbp), %al
testb $0x1, %al
jne 0xfdcfe
movq -0x58(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0xfde97
cmpq $0x0, 0x18(%rbp)
je 0xfdddf
movl -0x3c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xfdddd
movq 0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movq 0x8(%rcx), %rdi
addq $0x20, %rdi
movq -0x28(%rbp), %rsi
callq *%rax
cmpb $0x0, %al
je 0xfdddd
movl $0x1, -0x4(%rbp)
jmp 0xfdf61
jmp 0xfde49
movl -0x3c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jb 0xfde47
movl $0x1, -0x8c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
ja 0xfde2c
movq -0x18(%rbp), %rax
movq 0xc0(%rax), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
xorl %r9d, %r9d
callq *%rax
movl %eax, -0x8c(%rbp)
cmpl $0x0, %eax
jl 0xfde45
cmpl $0x0, -0x8c(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0xfdf61
jmp 0xfde47
jmp 0xfde49
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movl -0x3c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xfde6e
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xfde70
jmp 0xfde72
jmp 0xfde74
movq 0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
xchgq %rax, 0x10(%rcx)
jmp 0xfdf2a
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0xd0(%rbp)
movq (%rax), %rcx
movq 0x10(%rax), %rdx
movq %rdx, -0xa0(%rbp)
movq 0x8(%rax), %rax
movq -0xa0(%rbp), %rdx
lock
cmpxchgq %rdx, (%rcx)
movq %rax, %rcx
sete %al
movb %al, -0xc1(%rbp)
movq %rcx, -0xc0(%rbp)
testb $0x1, %al
jne 0xfdeef
movq -0xd0(%rbp), %rax
movq -0xc0(%rbp), %rcx
movq %rcx, (%rax)
movb -0xc1(%rbp), %al
andb $0x1, %al
movb %al, -0xa1(%rbp)
testb $0x1, -0xa1(%rbp)
je 0xfdf23
callq 0xfe060
cmpl $0x0, %eax
je 0xfdf23
movq 0x10(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xfc160
jmp 0xfdf28
jmp 0xfdc02
jmp 0xfdf2a
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xfdf3c
jmp 0xfdf3e
movq 0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
xchgq %rax, 0x8(%rcx)
jmp 0xfdc93
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
| _ZL6l_findPP8LF_SLISTPK15charset_info_stjPKhmP6CURSORP7LF_PINSPFcPvSB_E:
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov rax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
jmp short $+2
loc_FDBFC:
jmp short $+2
loc_FDBFE:
jmp short $+2
loc_FDC00:
jmp short $+2
loc_FDC02:
mov rdi, [rbp+var_10]
call _ZL17my_assume_alignedILm8EPP8LF_SLISTET0_S3_; my_assume_aligned<8ul,LF_SLIST **>(LF_SLIST **)
mov rcx, rax
mov rax, [rbp+var_38]
mov [rax], rcx
loc_FDC15:
mov rax, [rbp+var_38]
mov rax, [rax]
mov rdi, [rax]
call _ZL17my_assume_alignedILm8EP8LF_SLISTET0_S2_; my_assume_aligned<8ul,LF_SLIST *>(LF_SLIST *)
mov rcx, rax
mov rax, [rbp+var_38]
mov [rax+8], rcx
jmp short $+2
loc_FDC31:
jmp short $+2
loc_FDC33:
mov rcx, [rbp+arg_0]
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov [rbp+var_60], rax
mov rax, [rbp+var_60]
xchg rax, [rcx+8]
jmp short $+2
loc_FDC4D:
mov rax, [rbp+var_38]
mov rdi, [rax]
call _ZL17my_assume_alignedILm8EPmET0_S1_; my_assume_aligned<8ul,ulong *>(ulong *)
mov rax, [rax]
mov [rbp+var_68], rax
mov rcx, [rbp+var_68]
mov rdx, [rbp+var_38]
xor eax, eax
cmp rcx, [rdx+8]
mov [rbp+var_B1], al
jz short loc_FDC87
call _ZL10LF_BACKOFFv; LF_BACKOFF(void)
cmp eax, 0
setnz al
mov [rbp+var_B1], al
loc_FDC87:
mov al, [rbp+var_B1]
test al, 1
jnz short loc_FDC15
jmp short $+2
loc_FDC93:
mov rax, [rbp+var_38]
cmp qword ptr [rax+8], 0
setnz al
xor al, 0FFh
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_FDCB7
mov [rbp+var_4], 0
jmp loc_FDF61
loc_FDCB7:
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov eax, [rax+18h]
mov [rbp+var_3C], eax
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov rax, [rax+10h]
mov [rbp+var_50], rax
mov rax, [rbp+var_38]
mov rdi, [rax+8]
add rdi, 8
call _ZL17my_assume_alignedILm8EPPKhET0_S3_; my_assume_aligned<8ul,uchar const**>(uchar const**)
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov rax, [rax+8]
mov [rbp+var_70], rax
mov rax, [rbp+var_70]
mov [rbp+var_48], rax
loc_FDCFE:
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov rax, [rax]
mov [rbp+var_78], rax
mov rax, [rbp+var_78]
mov [rbp+var_58], rax
mov rdi, [rbp+var_58]
and rdi, 0FFFFFFFFFFFFFFFEh
call _ZL17my_assume_alignedILm8EP8LF_SLISTET0_S2_; my_assume_aligned<8ul,LF_SLIST *>(LF_SLIST *)
mov rcx, rax
mov rax, [rbp+var_38]
mov [rax+10h], rcx
jmp short $+2
loc_FDD2F:
jmp short $+2
loc_FDD31:
mov rcx, [rbp+arg_0]
mov rax, [rbp+var_38]
mov rax, [rax+10h]
mov [rbp+var_80], rax
mov rax, [rbp+var_80]
xchg rax, [rcx]
jmp short $+2
loc_FDD4A:
mov rcx, [rbp+var_58]
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov rax, [rax]
mov [rbp+var_88], rax
mov rdx, [rbp+var_88]
xor eax, eax
cmp rcx, rdx
mov [rbp+var_B2], al
jz short loc_FDD85
call _ZL10LF_BACKOFFv; LF_BACKOFF(void)
cmp eax, 0
setnz al
mov [rbp+var_B2], al
loc_FDD85:
mov al, [rbp+var_B2]
test al, 1
jnz loc_FDCFE
mov rax, [rbp+var_58]
and rax, 1
cmp rax, 0
jnz loc_FDE97
cmp [rbp+arg_8], 0
jz short loc_FDDDF
mov eax, [rbp+var_3C]
and eax, 1
cmp eax, 0
jz short loc_FDDDD
mov rax, [rbp+arg_8]
mov rcx, [rbp+var_38]
mov rdi, [rcx+8]
add rdi, 20h ; ' '
mov rsi, [rbp+var_28]
call rax
cmp al, 0
jz short loc_FDDDD
mov [rbp+var_4], 1
jmp loc_FDF61
loc_FDDDD:
jmp short loc_FDE49
loc_FDDDF:
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_1C]
jb short loc_FDE47
mov [rbp+var_8C], 1
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_1C]
ja short loc_FDE2C
mov rax, [rbp+var_18]
mov rax, [rax+0C0h]
mov rax, [rax+8]
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_48]
mov rdx, [rbp+var_50]
mov rcx, [rbp+var_28]
mov r8, [rbp+var_30]
xor r9d, r9d
call rax
mov [rbp+var_8C], eax
cmp eax, 0
jl short loc_FDE45
loc_FDE2C:
cmp [rbp+var_8C], 0
setnz al
xor al, 0FFh
and al, 1
movzx eax, al
mov [rbp+var_4], eax
jmp loc_FDF61
loc_FDE45:
jmp short $+2
loc_FDE47:
jmp short $+2
loc_FDE49:
mov rax, [rbp+var_38]
mov rcx, [rax+8]
mov rax, [rbp+var_38]
mov [rax], rcx
mov eax, [rbp+var_3C]
and eax, 1
cmp eax, 0
jnz short loc_FDE6E
mov rax, [rbp+var_38]
mov rax, [rax]
mov [rbp+var_10], rax
loc_FDE6E:
jmp short $+2
loc_FDE70:
jmp short $+2
loc_FDE72:
jmp short $+2
loc_FDE74:
mov rcx, [rbp+arg_0]
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov [rbp+var_98], rax
mov rax, [rbp+var_98]
xchg rax, [rcx+10h]
jmp loc_FDF2A
loc_FDE97:
mov rax, [rbp+var_38]
mov rcx, rax
add rcx, 8
mov [rbp+var_D0], rcx
mov rcx, [rax]
mov rdx, [rax+10h]
mov [rbp+var_A0], rdx
mov rax, [rax+8]
mov rdx, [rbp+var_A0]
lock cmpxchg [rcx], rdx
mov rcx, rax
setz al
mov [rbp+var_C1], al
mov [rbp+var_C0], rcx
test al, 1
jnz short loc_FDEEF
mov rax, [rbp+var_D0]
mov rcx, [rbp+var_C0]
mov [rax], rcx
loc_FDEEF:
mov al, [rbp+var_C1]
and al, 1
mov [rbp+var_A1], al
test [rbp+var_A1], 1
jz short loc_FDF23
call _ZL10LF_BACKOFFv; LF_BACKOFF(void)
cmp eax, 0
jz short loc_FDF23
mov rdi, [rbp+arg_0]
mov rax, [rbp+var_38]
mov rsi, [rax+8]
call lf_pinbox_free
jmp short loc_FDF28
loc_FDF23:
jmp loc_FDC02
loc_FDF28:
jmp short $+2
loc_FDF2A:
mov rax, [rbp+var_38]
mov rcx, [rax+10h]
mov rax, [rbp+var_38]
mov [rax+8], rcx
jmp short $+2
loc_FDF3C:
jmp short $+2
loc_FDF3E:
mov rcx, [rbp+arg_0]
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov [rbp+var_B0], rax
mov rax, [rbp+var_B0]
xchg rax, [rcx+8]
jmp loc_FDC93
loc_FDF61:
mov eax, [rbp+var_4]
add rsp, 0D0h
pop rbp
retn
| _BOOL8 l_find(
volatile signed long long *a1,
long long a2,
unsigned int a3,
long long a4,
long long a5,
volatile signed long long **a6,
volatile long long *a7,
unsigned __int8 ( *a8)(volatile signed long long *, long long))
{
signed long long v8; // rtt
signed long long v9; // rcx
bool v11; // [rsp+Fh] [rbp-C1h]
bool v12; // [rsp+1Eh] [rbp-B2h]
bool v13; // [rsp+1Fh] [rbp-B1h]
int v14; // [rsp+44h] [rbp-8Ch]
long long v15; // [rsp+78h] [rbp-58h]
long long v16; // [rsp+80h] [rbp-50h]
long long v17; // [rsp+88h] [rbp-48h]
unsigned int v18; // [rsp+94h] [rbp-3Ch]
LABEL_1:
*a6 = (volatile signed long long *)my_assume_aligned<8ul,LF_SLIST **>(a1);
do
{
a6[1] = (volatile signed long long *)my_assume_aligned<8ul,LF_SLIST *>(**a6);
_InterlockedExchange64(a7 + 1, (long long)a6[1]);
v13 = 0;
if ( *(volatile signed long long **)my_assume_aligned<8ul,unsigned long *>(*a6) != a6[1] )
v13 = (unsigned int)LF_BACKOFF() != 0;
}
while ( v13 );
while ( 1 )
{
if ( !a6[1] )
return 0;
v18 = *((_DWORD *)a6[1] + 6);
v16 = *((_QWORD *)a6[1] + 2);
my_assume_aligned<8ul,unsigned char const**>(a6[1] + 1);
v17 = *((_QWORD *)a6[1] + 1);
do
{
v15 = *a6[1];
a6[2] = (volatile signed long long *)my_assume_aligned<8ul,LF_SLIST *>(v15 & 0xFFFFFFFFFFFFFFFELL);
_InterlockedExchange64(a7, (long long)a6[2]);
v12 = 0;
if ( v15 != *a6[1] )
v12 = (unsigned int)LF_BACKOFF() != 0;
}
while ( v12 );
if ( (v15 & 1) == 0 )
break;
v8 = (signed long long)a6[1];
v9 = _InterlockedCompareExchange64(*a6, (signed long long)a6[2], v8);
v11 = v8 == v9;
if ( v8 != v9 )
a6[1] = (volatile signed long long *)v9;
if ( !v11 || !(unsigned int)LF_BACKOFF() )
goto LABEL_1;
lf_pinbox_free((long long)a7, (const char *)a6[1]);
LABEL_30:
a6[1] = a6[2];
_InterlockedExchange64(a7 + 1, (long long)a6[1]);
}
if ( a8 )
{
if ( (v18 & 1) != 0 && a8(a6[1] + 4, a4) )
return 1;
goto LABEL_21;
}
if ( v18 < a3
|| (v14 = 1, v18 <= a3)
&& (v14 = (*(long long ( **)(long long, long long, long long, long long, long long, _QWORD))(*(_QWORD *)(a2 + 192)
+ 8LL))(
a2,
v17,
v16,
a4,
a5,
0LL),
v14 < 0) )
{
LABEL_21:
*a6 = a6[1];
if ( (v18 & 1) == 0 )
a1 = *a6;
_InterlockedExchange64(a7 + 2, (long long)a6[1]);
goto LABEL_30;
}
return v14 == 0;
}
| l_find:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV RAX,qword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
JMP 0x001fdbfc
LAB_001fdbfc:
JMP 0x001fdbfe
LAB_001fdbfe:
JMP 0x001fdc00
LAB_001fdc00:
JMP 0x001fdc02
LAB_001fdc02:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001fe030
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
LAB_001fdc15:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX]
CALL 0x001fe040
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x001fdc31
LAB_001fdc31:
JMP 0x001fdc33
LAB_001fdc33:
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x60]
XCHG qword ptr [RCX + 0x8],RAX
JMP 0x001fdc4d
LAB_001fdc4d:
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RAX]
CALL 0x001fe050
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x68],RAX
MOV RCX,qword ptr [RBP + -0x68]
MOV RDX,qword ptr [RBP + -0x38]
XOR EAX,EAX
CMP RCX,qword ptr [RDX + 0x8]
MOV byte ptr [RBP + -0xb1],AL
JZ 0x001fdc87
CALL 0x001fe060
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0xb1],AL
LAB_001fdc87:
MOV AL,byte ptr [RBP + -0xb1]
TEST AL,0x1
JNZ 0x001fdc15
JMP 0x001fdc93
LAB_001fdc93:
MOV RAX,qword ptr [RBP + -0x38]
CMP qword ptr [RAX + 0x8],0x0
SETNZ AL
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x001fdcb7
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001fdf61
LAB_001fdcb7:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV EAX,dword ptr [RAX + 0x18]
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RAX + 0x8]
ADD RDI,0x8
CALL 0x001fe0a0
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x48],RAX
LAB_001fdcfe:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x58],RAX
MOV RDI,qword ptr [RBP + -0x58]
AND RDI,-0x2
CALL 0x001fe040
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x001fdd2f
LAB_001fdd2f:
JMP 0x001fdd31
LAB_001fdd31:
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x80]
XCHG qword ptr [RCX],RAX
JMP 0x001fdd4a
LAB_001fdd4a:
MOV RCX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x88],RAX
MOV RDX,qword ptr [RBP + -0x88]
XOR EAX,EAX
CMP RCX,RDX
MOV byte ptr [RBP + -0xb2],AL
JZ 0x001fdd85
CALL 0x001fe060
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0xb2],AL
LAB_001fdd85:
MOV AL,byte ptr [RBP + -0xb2]
TEST AL,0x1
JNZ 0x001fdcfe
MOV RAX,qword ptr [RBP + -0x58]
AND RAX,0x1
CMP RAX,0x0
JNZ 0x001fde97
CMP qword ptr [RBP + 0x18],0x0
JZ 0x001fdddf
MOV EAX,dword ptr [RBP + -0x3c]
AND EAX,0x1
CMP EAX,0x0
JZ 0x001fdddd
MOV RAX,qword ptr [RBP + 0x18]
MOV RCX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RCX + 0x8]
ADD RDI,0x20
MOV RSI,qword ptr [RBP + -0x28]
CALL RAX
CMP AL,0x0
JZ 0x001fdddd
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001fdf61
LAB_001fdddd:
JMP 0x001fde49
LAB_001fdddf:
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [RBP + -0x1c]
JC 0x001fde47
MOV dword ptr [RBP + -0x8c],0x1
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [RBP + -0x1c]
JA 0x001fde2c
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x30]
XOR R9D,R9D
CALL RAX
MOV dword ptr [RBP + -0x8c],EAX
CMP EAX,0x0
JL 0x001fde45
LAB_001fde2c:
CMP dword ptr [RBP + -0x8c],0x0
SETNZ AL
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001fdf61
LAB_001fde45:
JMP 0x001fde47
LAB_001fde47:
JMP 0x001fde49
LAB_001fde49:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
MOV EAX,dword ptr [RBP + -0x3c]
AND EAX,0x1
CMP EAX,0x0
JNZ 0x001fde6e
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
LAB_001fde6e:
JMP 0x001fde70
LAB_001fde70:
JMP 0x001fde72
LAB_001fde72:
JMP 0x001fde74
LAB_001fde74:
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0x98]
XCHG qword ptr [RCX + 0x10],RAX
JMP 0x001fdf2a
LAB_001fde97:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,RAX
ADD RCX,0x8
MOV qword ptr [RBP + -0xd0],RCX
MOV RCX,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0xa0],RDX
MOV RAX,qword ptr [RAX + 0x8]
MOV RDX,qword ptr [RBP + -0xa0]
CMPXCHG.LOCK qword ptr [RCX],RDX
MOV RCX,RAX
SETZ AL
MOV byte ptr [RBP + -0xc1],AL
MOV qword ptr [RBP + -0xc0],RCX
TEST AL,0x1
JNZ 0x001fdeef
MOV RAX,qword ptr [RBP + -0xd0]
MOV RCX,qword ptr [RBP + -0xc0]
MOV qword ptr [RAX],RCX
LAB_001fdeef:
MOV AL,byte ptr [RBP + -0xc1]
AND AL,0x1
MOV byte ptr [RBP + -0xa1],AL
TEST byte ptr [RBP + -0xa1],0x1
JZ 0x001fdf23
CALL 0x001fe060
CMP EAX,0x0
JZ 0x001fdf23
MOV RDI,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x001fc160
JMP 0x001fdf28
LAB_001fdf23:
JMP 0x001fdc02
LAB_001fdf28:
JMP 0x001fdf2a
LAB_001fdf2a:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x001fdf3c
LAB_001fdf3c:
JMP 0x001fdf3e
LAB_001fdf3e:
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0xb0],RAX
MOV RAX,qword ptr [RBP + -0xb0]
XCHG qword ptr [RCX + 0x8],RAX
JMP 0x001fdc93
LAB_001fdf61:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0xd0
POP RBP
RET
|
/* l_find(LF_SLIST**, charset_info_st const*, unsigned int, unsigned char const*, unsigned long,
CURSOR*, LF_PINS*, char (*)(void*, void*)) */
byte l_find(LF_SLIST **param_1,charset_info_st *param_2,uint param_3,uchar *param_4,ulong param_5,
CURSOR *param_6,LF_PINS *param_7,_func_char_void_ptr_void_ptr *param_8)
{
uint uVar1;
int8 uVar2;
int8 uVar3;
ulong uVar4;
long lVar5;
char cVar6;
int iVar7;
LF_SLIST **ppLVar8;
LF_SLIST *pLVar9;
ulong *puVar10;
long lVar11;
bool bVar12;
int local_94;
LF_SLIST **local_18;
local_18 = param_1;
LAB_001fdc02:
ppLVar8 = my_assume_aligned<8ul,LF_SLIST**>(local_18);
*(LF_SLIST ***)param_6 = ppLVar8;
do {
pLVar9 = my_assume_aligned<8ul,LF_SLIST*>((LF_SLIST *)**(int8 **)param_6);
*(LF_SLIST **)(param_6 + 8) = pLVar9;
LOCK();
*(int8 *)(param_7 + 8) = *(int8 *)(param_6 + 8);
UNLOCK();
puVar10 = my_assume_aligned<8ul,unsigned_long*>(*(ulong **)param_6);
bVar12 = false;
if (*puVar10 != *(ulong *)(param_6 + 8)) {
iVar7 = LF_BACKOFF();
bVar12 = iVar7 != 0;
}
} while (bVar12);
do {
if (*(long *)(param_6 + 8) == 0) {
return 0;
}
uVar1 = *(uint *)(*(long *)(param_6 + 8) + 0x18);
uVar2 = *(int8 *)(*(long *)(param_6 + 8) + 0x10);
my_assume_aligned<8ul,unsigned_char_const**>((uchar **)(*(long *)(param_6 + 8) + 8));
uVar3 = *(int8 *)(*(long *)(param_6 + 8) + 8);
do {
uVar4 = **(ulong **)(param_6 + 8);
pLVar9 = my_assume_aligned<8ul,LF_SLIST*>((LF_SLIST *)(uVar4 & 0xfffffffffffffffe));
*(LF_SLIST **)(param_6 + 0x10) = pLVar9;
LOCK();
*(int8 *)param_7 = *(int8 *)(param_6 + 0x10);
UNLOCK();
bVar12 = false;
if (uVar4 != **(ulong **)(param_6 + 8)) {
iVar7 = LF_BACKOFF();
bVar12 = iVar7 != 0;
}
} while (bVar12);
if ((uVar4 & 1) == 0) {
if (param_8 == (_func_char_void_ptr_void_ptr *)0x0) {
if ((param_3 <= uVar1) &&
((local_94 = 1, param_3 < uVar1 ||
(local_94 = (**(code **)(*(long *)(param_2 + 0xc0) + 8))
(param_2,uVar3,uVar2,param_4,param_5,0), -1 < local_94)))) {
return (local_94 != 0 ^ 0xffU) & 1;
}
}
else if (((uVar1 & 1) != 0) &&
(cVar6 = (*param_8)((void *)(*(long *)(param_6 + 8) + 0x20),param_4), cVar6 != '\0'))
{
return 1;
}
*(int8 *)param_6 = *(int8 *)(param_6 + 8);
if ((uVar1 & 1) == 0) {
local_18 = *(LF_SLIST ***)param_6;
}
LOCK();
*(int8 *)(param_7 + 0x10) = *(int8 *)(param_6 + 8);
UNLOCK();
}
else {
lVar5 = *(long *)(param_6 + 8);
LOCK();
lVar11 = **(long **)param_6;
bVar12 = lVar5 == lVar11;
if (bVar12) {
**(long **)param_6 = *(long *)(param_6 + 0x10);
lVar11 = lVar5;
}
UNLOCK();
if (!bVar12) {
*(long *)(param_6 + 8) = lVar11;
goto LAB_001fdc02;
}
iVar7 = LF_BACKOFF();
if (iVar7 == 0) goto LAB_001fdc02;
lf_pinbox_free(param_7,*(int8 *)(param_6 + 8));
}
*(int8 *)(param_6 + 8) = *(int8 *)(param_6 + 0x10);
LOCK();
*(int8 *)(param_7 + 8) = *(int8 *)(param_6 + 8);
UNLOCK();
} while( true );
}
| |
25,021 | google::protobuf::DelocalizeRadix(char*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/stubs/strutil.cc | void DelocalizeRadix(char* buffer) {
// Fast check: if the buffer has a normal decimal point, assume no
// translation is needed.
if (strchr(buffer, '.') != nullptr) return;
// Find the first unknown character.
while (IsValidFloatChar(*buffer)) ++buffer;
if (*buffer == '\0') {
// No radix character found.
return;
}
// We are now pointing at the locale-specific radix character. Replace it
// with '.'.
*buffer = '.';
++buffer;
if (!IsValidFloatChar(*buffer) && *buffer != '\0') {
// It appears the radix was a multi-byte character. We need to remove the
// extra bytes.
char* target = buffer;
do { ++buffer; } while (!IsValidFloatChar(*buffer) && *buffer != '\0');
memmove(target, buffer, strlen(buffer) + 1);
}
} | O0 | cpp | google::protobuf::DelocalizeRadix(char*):
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2e, %esi
callq 0x13170
cmpq $0x0, %rax
je 0x2a3e3
jmp 0x2a4d0
jmp 0x2a3e5
movq 0x20(%rsp), %rax
movsbl (%rax), %edi
callq 0x2a4e0
testb $0x1, %al
jne 0x2a3f8
jmp 0x2a408
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x2a3e5
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x2a41a
jmp 0x2a4d0
movq 0x20(%rsp), %rax
movb $0x2e, (%rax)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movsbl (%rax), %edi
callq 0x2a4e0
testb $0x1, %al
jne 0x2a4d0
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2a4d0
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movsbl (%rax), %edi
callq 0x2a4e0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x2a496
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x2a45c
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x131b0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x136e0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZN6google8protobuf15DelocalizeRadixEPc:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov rdi, [rsp+28h+var_8]
mov esi, 2Eh ; '.'; char
call _strchr
cmp rax, 0
jz short loc_2A3E3
jmp loc_2A4D0
loc_2A3E3:
jmp short $+2
loc_2A3E5:
mov rax, [rsp+28h+var_8]
movsx edi, byte ptr [rax]; this
call _ZN6google8protobufL16IsValidFloatCharEc; google::protobuf::IsValidFloatChar(char)
test al, 1
jnz short loc_2A3F8
jmp short loc_2A408
loc_2A3F8:
mov rax, [rsp+28h+var_8]
add rax, 1
mov [rsp+28h+var_8], rax
jmp short loc_2A3E5
loc_2A408:
mov rax, [rsp+28h+var_8]
movsx eax, byte ptr [rax]
cmp eax, 0
jnz short loc_2A41A
jmp loc_2A4D0
loc_2A41A:
mov rax, [rsp+28h+var_8]
mov byte ptr [rax], 2Eh ; '.'
mov rax, [rsp+28h+var_8]
add rax, 1
mov [rsp+28h+var_8], rax
mov rax, [rsp+28h+var_8]
movsx edi, byte ptr [rax]; this
call _ZN6google8protobufL16IsValidFloatCharEc; google::protobuf::IsValidFloatChar(char)
test al, 1
jnz loc_2A4D0
mov rax, [rsp+28h+var_8]
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_2A4D0
mov rax, [rsp+28h+var_8]
mov [rsp+28h+var_10], rax
loc_2A45C:
mov rax, [rsp+28h+var_8]
add rax, 1
mov [rsp+28h+var_8], rax
mov rax, [rsp+28h+var_8]
movsx edi, byte ptr [rax]; this
call _ZN6google8protobufL16IsValidFloatCharEc; google::protobuf::IsValidFloatChar(char)
mov cl, al
xor eax, eax
test cl, 1
mov [rsp+28h+var_11], al
jnz short loc_2A496
mov rax, [rsp+28h+var_8]
movsx eax, byte ptr [rax]
cmp eax, 0
setnz al
mov [rsp+28h+var_11], al
loc_2A496:
mov al, [rsp+28h+var_11]
test al, 1
jnz short loc_2A45C
mov rax, [rsp+28h+var_10]
mov [rsp+28h+var_28], rax
mov rax, [rsp+28h+var_8]
mov [rsp+28h+var_20], rax
mov rdi, [rsp+28h+var_8]
call _strlen
mov rdi, [rsp+28h+var_28]
mov rsi, [rsp+28h+var_20]
mov rdx, rax
add rdx, 1
call _memmove
loc_2A4D0:
add rsp, 28h
retn
| long long google::protobuf::DelocalizeRadix(google::protobuf *this, char *a2)
{
long long result; // rax
long long v3; // rax
bool v4; // [rsp+17h] [rbp-11h]
_BYTE *v5; // [rsp+18h] [rbp-10h]
google::protobuf *v6; // [rsp+20h] [rbp-8h]
_BYTE *v7; // [rsp+20h] [rbp-8h]
v6 = this;
result = strchr(this, 46LL);
if ( !result )
{
while ( (google::protobuf::IsValidFloatChar((google::protobuf *)(unsigned int)*(char *)v6, 46) & 1) != 0 )
v6 = (google::protobuf *)((char *)v6 + 1);
result = (unsigned int)*(char *)v6;
if ( *(_BYTE *)v6 )
{
*(_BYTE *)v6 = 46;
v7 = (char *)v6 + 1;
result = google::protobuf::IsValidFloatChar((google::protobuf *)(unsigned int)(char)*v7, 46);
if ( (result & 1) == 0 )
{
result = (unsigned int)(char)*v7;
if ( *v7 )
{
v5 = v7;
do
{
++v7;
v4 = 0;
if ( (google::protobuf::IsValidFloatChar((google::protobuf *)(unsigned int)(char)*v7, 46) & 1) == 0 )
v4 = *v7 != 0;
}
while ( v4 );
v3 = strlen(v7);
return memmove(v5, v7, v3 + 1);
}
}
}
}
return result;
}
| DelocalizeRadix:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV RDI,qword ptr [RSP + 0x20]
MOV ESI,0x2e
CALL 0x00113170
CMP RAX,0x0
JZ 0x0012a3e3
JMP 0x0012a4d0
LAB_0012a3e3:
JMP 0x0012a3e5
LAB_0012a3e5:
MOV RAX,qword ptr [RSP + 0x20]
MOVSX EDI,byte ptr [RAX]
CALL 0x0012a4e0
TEST AL,0x1
JNZ 0x0012a3f8
JMP 0x0012a408
LAB_0012a3f8:
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,0x1
MOV qword ptr [RSP + 0x20],RAX
JMP 0x0012a3e5
LAB_0012a408:
MOV RAX,qword ptr [RSP + 0x20]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JNZ 0x0012a41a
JMP 0x0012a4d0
LAB_0012a41a:
MOV RAX,qword ptr [RSP + 0x20]
MOV byte ptr [RAX],0x2e
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,0x1
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOVSX EDI,byte ptr [RAX]
CALL 0x0012a4e0
TEST AL,0x1
JNZ 0x0012a4d0
MOV RAX,qword ptr [RSP + 0x20]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x0012a4d0
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x18],RAX
LAB_0012a45c:
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,0x1
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOVSX EDI,byte ptr [RAX]
CALL 0x0012a4e0
MOV CL,AL
XOR EAX,EAX
TEST CL,0x1
MOV byte ptr [RSP + 0x17],AL
JNZ 0x0012a496
MOV RAX,qword ptr [RSP + 0x20]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RSP + 0x17],AL
LAB_0012a496:
MOV AL,byte ptr [RSP + 0x17]
TEST AL,0x1
JNZ 0x0012a45c
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x001131b0
MOV RDI,qword ptr [RSP]
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,RAX
ADD RDX,0x1
CALL 0x001136e0
LAB_0012a4d0:
ADD RSP,0x28
RET
|
/* google::protobuf::DelocalizeRadix(char*) */
void google::protobuf::DelocalizeRadix(char *param_1)
{
uint uVar1;
char *pcVar2;
ulong uVar3;
size_t sVar4;
bool bVar5;
char *local_8;
pcVar2 = strchr(param_1,0x2e);
local_8 = param_1;
if (pcVar2 == (char *)0x0) {
while (uVar3 = IsValidFloatChar(*local_8), (uVar3 & 1) != 0) {
local_8 = local_8 + 1;
}
if (*local_8 != '\0') {
*local_8 = '.';
pcVar2 = local_8 + 1;
uVar3 = IsValidFloatChar(*pcVar2);
if (((uVar3 & 1) == 0) && (local_8 = pcVar2, *pcVar2 != '\0')) {
do {
local_8 = local_8 + 1;
uVar1 = IsValidFloatChar(*local_8);
bVar5 = false;
if ((uVar1 & 1) == 0) {
bVar5 = *local_8 != '\0';
}
} while (bVar5);
sVar4 = strlen(local_8);
memmove(pcVar2,local_8,sVar4 + 1);
}
}
}
return;
}
| |
25,022 | 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 0x244c0
incl 0x58(%rbx)
movq %rbx, %rdi
callq 0x24210
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 0x001244c0
INC dword ptr [RBX + 0x58]
MOV RDI,RBX
CALL 0x00124210
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;
}
| |
25,023 | YAML::detail::node_data::compute_map_size() const | aimrt_mujoco_sim/_deps/yaml-cpp-src/src/node_data.cpp | void node_data::compute_map_size() const {
auto it = m_undefinedPairs.begin();
while (it != m_undefinedPairs.end()) {
auto jt = std::next(it);
if (it->first->is_defined() && it->second->is_defined())
m_undefinedPairs.erase(it);
it = jt;
}
} | O3 | cpp | YAML::detail::node_data::compute_map_size() const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x98(%rdi), %r15
movq 0x98(%rdi), %r12
cmpq %r15, %r12
je 0x61306
movq %rdi, %rbx
movq %r12, %r14
movq (%r12), %r12
movq 0x10(%r14), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpb $0x1, (%rax)
jne 0x61301
movq 0x18(%r14), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpb $0x1, (%rax)
jne 0x61301
decq 0xa8(%rbx)
movq %r14, %rdi
callq 0x2dfc0
movl $0x20, %esi
movq %r14, %rdi
callq 0x2d2d0
cmpq %r15, %r12
jne 0x612c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| _ZNK4YAML6detail9node_data16compute_map_sizeEv:
push r15
push r14
push r12
push rbx
push rax
lea r15, [rdi+98h]
mov r12, [rdi+98h]
cmp r12, r15
jz short loc_61306
mov rbx, rdi
loc_612C0:
mov r14, r12
mov r12, [r12]
mov rax, [r14+10h]
mov rax, [rax]
mov rax, [rax]
cmp byte ptr [rax], 1
jnz short loc_61301
mov rax, [r14+18h]
mov rax, [rax]
mov rax, [rax]
cmp byte ptr [rax], 1
jnz short loc_61301
dec qword ptr [rbx+0A8h]
mov rdi, r14; this
call __ZNSt8__detail15_List_node_base9_M_unhookEv; std::__detail::_List_node_base::_M_unhook(void)
mov esi, 20h ; ' '; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_61301:
cmp r12, r15
jnz short loc_612C0
loc_61306:
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| void YAML::detail::node_data::compute_map_size(YAML::detail::node_data *this)
{
YAML::detail::node_data *v1; // r12
YAML::detail::node_data *v2; // r14
v1 = (YAML::detail::node_data *)*((_QWORD *)this + 19);
while ( v1 != (YAML::detail::node_data *)((char *)this + 152) )
{
v2 = v1;
v1 = *(YAML::detail::node_data **)v1;
if ( ****((_BYTE ****)v2 + 2) == 1 && ****((_BYTE ****)v2 + 3) == 1 )
{
--*((_QWORD *)this + 21);
std::__detail::_List_node_base::_M_unhook(v2);
operator delete(v2, 0x20uLL);
}
}
}
| compute_map_size:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
LEA R15,[RDI + 0x98]
MOV R12,qword ptr [RDI + 0x98]
CMP R12,R15
JZ 0x00161306
MOV RBX,RDI
LAB_001612c0:
MOV R14,R12
MOV R12,qword ptr [R12]
MOV RAX,qword ptr [R14 + 0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX]
CMP byte ptr [RAX],0x1
JNZ 0x00161301
MOV RAX,qword ptr [R14 + 0x18]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX]
CMP byte ptr [RAX],0x1
JNZ 0x00161301
DEC qword ptr [RBX + 0xa8]
MOV RDI,R14
CALL 0x0012dfc0
MOV ESI,0x20
MOV RDI,R14
CALL 0x0012d2d0
LAB_00161301:
CMP R12,R15
JNZ 0x001612c0
LAB_00161306:
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* YAML::detail::node_data::compute_map_size() const */
void __thiscall YAML::detail::node_data::compute_map_size(node_data *this)
{
node_data *pnVar1;
node_data *pnVar2;
pnVar1 = *(node_data **)(this + 0x98);
while (pnVar2 = pnVar1, pnVar2 != this + 0x98) {
pnVar1 = *(node_data **)pnVar2;
if ((**(char **)**(int8 **)(pnVar2 + 0x10) == '\x01') &&
(**(char **)**(int8 **)(pnVar2 + 0x18) == '\x01')) {
*(long *)(this + 0xa8) = *(long *)(this + 0xa8) + -1;
std::__detail::_List_node_base::_M_unhook();
operator_delete(pnVar2,0x20);
}
}
return;
}
| |
25,024 | mysql_stat | eloqsql/libmariadb/libmariadb/mariadb_lib.c | char * STDCALL
mysql_stat(MYSQL *mysql)
{
if (ma_simple_command(mysql, COM_STATISTICS,0,0,0,0))
return mysql->net.last_error;
mysql->net.read_pos[mysql->packet_length]=0; /* End of stat string */
if (!mysql->net.read_pos[0])
{
SET_CLIENT_ERROR(mysql, CR_WRONG_HOST_INFO , SQLSTATE_UNKNOWN, 0);
return mysql->net.last_error;
}
return((char*) mysql->net.read_pos);
} | O0 | c | mysql_stat:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x9, %esi
xorl %eax, %eax
movl %eax, %r9d
xorl %r8d, %r8d
movq %r9, %rdx
movq %r9, %rcx
callq 0x1c930
cmpl $0x0, %eax
je 0x26180
movq -0x10(%rbp), %rax
addq $0x97, %rax
movq %rax, -0x8(%rbp)
jmp 0x26225
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x358(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpb $0x0, (%rax)
jne 0x26219
jmp 0x261a6
movq -0x10(%rbp), %rax
movl $0x7d9, 0x90(%rax) # imm = 0x7D9
movq -0x10(%rbp), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x4107a(%rip), %rax # 0x67240
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13210
movq -0x10(%rbp), %rax
movb $0x0, 0x29c(%rax)
movq -0x10(%rbp), %rdi
addq $0x97, %rdi
leaq 0x41060(%rip), %rax # 0x67250
movq 0x48(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13210
movq -0x10(%rbp), %rax
movb $0x0, 0x296(%rax)
movq -0x10(%rbp), %rax
addq $0x97, %rax
movq %rax, -0x8(%rbp)
jmp 0x26225
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
| mysql_stat:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_10], rdi
mov rdi, [rbp+var_10]
mov esi, 9
xor eax, eax
mov r9d, eax
xor r8d, r8d
mov rdx, r9
mov rcx, r9
call ma_simple_command
cmp eax, 0
jz short loc_26180
mov rax, [rbp+var_10]
add rax, 97h
mov [rbp+var_8], rax
jmp loc_26225
loc_26180:
mov rax, [rbp+var_10]
mov rax, [rax+20h]
mov rcx, [rbp+var_10]
mov rcx, [rcx+358h]
mov byte ptr [rax+rcx], 0
mov rax, [rbp+var_10]
mov rax, [rax+20h]
cmp byte ptr [rax], 0
jnz short loc_26219
jmp short $+2
loc_261A6:
mov rax, [rbp+var_10]
mov dword ptr [rax+90h], 7D9h
mov rdi, [rbp+var_10]
add rdi, 297h
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+29Ch], 0
mov rdi, [rbp+var_10]
add rdi, 97h
lea rax, client_errors
mov rsi, [rax+48h]
mov edx, 1FFh
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+296h], 0
mov rax, [rbp+var_10]
add rax, 97h
mov [rbp+var_8], rax
jmp short loc_26225
loc_26219:
mov rax, [rbp+var_10]
mov rax, [rax+20h]
mov [rbp+var_8], rax
loc_26225:
mov rax, [rbp+var_8]
add rsp, 10h
pop rbp
retn
| long long mysql_stat(long long a1)
{
if ( (unsigned int)ma_simple_command(a1, 9u, 0LL, 0LL, 0, 0LL) )
return a1 + 151;
*(_BYTE *)(*(_QWORD *)(a1 + 32) + *(_QWORD *)(a1 + 856)) = 0;
if ( **(_BYTE **)(a1 + 32) )
return *(_QWORD *)(a1 + 32);
*(_DWORD *)(a1 + 144) = 2009;
strncpy(a1 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 668) = 0;
strncpy(a1 + 151, client_errors[9], 511LL);
*(_BYTE *)(a1 + 662) = 0;
return a1 + 151;
}
| mysql_stat:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x10],RDI
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x9
XOR EAX,EAX
MOV R9D,EAX
XOR R8D,R8D
MOV RDX,R9
MOV RCX,R9
CALL 0x0011c930
CMP EAX,0x0
JZ 0x00126180
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x97
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00126225
LAB_00126180:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x358]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
CMP byte ptr [RAX],0x0
JNZ 0x00126219
JMP 0x001261a6
LAB_001261a6:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x90],0x7d9
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x297
LEA RAX,[0x167240]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x29c],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x97
LEA RAX,[0x167250]
MOV RSI,qword ptr [RAX + 0x48]
MOV EDX,0x1ff
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x296],0x0
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x97
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00126225
LAB_00126219:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RBP + -0x8],RAX
LAB_00126225:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x10
POP RBP
RET
|
long mysql_stat(long param_1)
{
int iVar1;
int8 local_10;
iVar1 = ma_simple_command(param_1,9,0,0,0);
if (iVar1 == 0) {
*(int1 *)(*(long *)(param_1 + 0x20) + *(long *)(param_1 + 0x358)) = 0;
if (**(char **)(param_1 + 0x20) == '\0') {
*(int4 *)(param_1 + 0x90) = 0x7d9;
strncpy((char *)(param_1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x29c) = 0;
strncpy((char *)(param_1 + 0x97),PTR_s_Wrong_host_info_00167298,0x1ff);
*(int1 *)(param_1 + 0x296) = 0;
local_10 = param_1 + 0x97;
}
else {
local_10 = *(long *)(param_1 + 0x20);
}
}
else {
local_10 = param_1 + 0x97;
}
return local_10;
}
| |
25,025 | testing::internal::InternalRunDeathTestFlag::~InternalRunDeathTestFlag() | AlayaLite/build_O3/_deps/googletest-src/googletest/include/gtest/internal/gtest-death-test-internal.h | ~InternalRunDeathTestFlag() {
if (write_fd_ >= 0) posix::Close(write_fd_);
} | O3 | c | testing::internal::InternalRunDeathTestFlag::~InternalRunDeathTestFlag():
pushq %rbx
movq %rdi, %rbx
movl 0x28(%rdi), %edi
testl %edi, %edi
js 0x7b0a6
callq 0x11290
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x7b0be
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x11120
popq %rbx
retq
movq %rax, %rdi
callq 0x18a8f
| _ZN7testing8internal24InternalRunDeathTestFlagD2Ev:
push rbx
mov rbx, rdi
mov edi, [rdi+28h]
test edi, edi
js short loc_7B0A6
call _close
loc_7B0A6:
mov rdi, [rbx]; void *
add rbx, 10h
cmp rdi, rbx
jz short loc_7B0BE
mov rsi, [rbx]
inc rsi; unsigned __int64
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
loc_7B0BE:
pop rbx
retn
mov rdi, rax
call __clang_call_terminate
| void testing::internal::InternalRunDeathTestFlag::~InternalRunDeathTestFlag(void **this)
{
long long v2; // rdi
_QWORD *v3; // rdi
_QWORD *v4; // rbx
v2 = *((unsigned int *)this + 10);
if ( (int)v2 >= 0 )
close(v2);
v3 = *this;
v4 = this + 2;
if ( v3 != v4 )
operator delete(v3, *v4 + 1LL);
}
| ~InternalRunDeathTestFlag:
PUSH RBX
MOV RBX,RDI
MOV EDI,dword ptr [RDI + 0x28]
TEST EDI,EDI
JS 0x0017b0a6
LAB_0017b0a1:
CALL 0x00111290
LAB_0017b0a6:
MOV RDI,qword ptr [RBX]
ADD RBX,0x10
CMP RDI,RBX
JZ 0x0017b0be
MOV RSI,qword ptr [RBX]
INC RSI
POP RBX
JMP 0x00111120
LAB_0017b0be:
POP RBX
RET
|
/* testing::internal::InternalRunDeathTestFlag::~InternalRunDeathTestFlag() */
void __thiscall
testing::internal::InternalRunDeathTestFlag::~InternalRunDeathTestFlag
(InternalRunDeathTestFlag *this)
{
if (-1 < *(int *)(this + 0x28)) {
/* try { // try from 0017b0a1 to 0017b0a5 has its CatchHandler @ 0017b0c0 */
close(*(int *)(this + 0x28));
}
if (*(InternalRunDeathTestFlag **)this != this + 0x10) {
operator_delete(*(InternalRunDeathTestFlag **)this,*(long *)(this + 0x10) + 1);
return;
}
return;
}
| |
25,026 | strlength | eloqsql/mysys/mf_format.c | size_t strlength(const char *str)
{
reg1 const char * pos;
reg2 const char * found;
DBUG_ENTER("strlength");
pos= found= str;
while (*pos)
{
if (*pos != ' ')
{
while (*++pos && *pos != ' ') {};
if (!*pos)
{
found=pos; /* String ends here */
break;
}
}
found=pos;
while (*++pos == ' ') {};
}
DBUG_RETURN((size_t) (found - str));
} | O3 | c | strlength:
pushq %rbp
movq %rsp, %rbp
movb (%rdi), %dl
movq %rdi, %rax
movq %rdi, %rcx
cmpb $0x20, %dl
je 0xb4c5d
movzbl %dl, %edx
testl %edx, %edx
je 0xb4c76
movzbl 0x1(%rcx), %eax
incq %rcx
testl %eax, %eax
je 0xb4c73
cmpl $0x20, %eax
jne 0xb4c4d
movq %rcx, %rsi
movb 0x1(%rsi), %dl
incq %rsi
cmpb $0x20, %dl
je 0xb4c60
movq %rcx, %rax
movq %rsi, %rcx
jmp 0xb4c41
movq %rcx, %rax
subq %rdi, %rax
popq %rbp
retq
nop
| strlength:
push rbp
mov rbp, rsp
mov dl, [rdi]
mov rax, rdi
mov rcx, rdi
loc_B4C41:
cmp dl, 20h ; ' '
jz short loc_B4C5D
movzx edx, dl
test edx, edx
jz short loc_B4C76
loc_B4C4D:
movzx eax, byte ptr [rcx+1]
inc rcx
test eax, eax
jz short loc_B4C73
cmp eax, 20h ; ' '
jnz short loc_B4C4D
loc_B4C5D:
mov rsi, rcx
loc_B4C60:
mov dl, [rsi+1]
inc rsi
cmp dl, 20h ; ' '
jz short loc_B4C60
mov rax, rcx
mov rcx, rsi
jmp short loc_B4C41
loc_B4C73:
mov rax, rcx
loc_B4C76:
sub rax, rdi
pop rbp
retn
| long long strlength(_BYTE *a1)
{
char v1; // dl
_BYTE *v2; // rax
_BYTE *v3; // rcx
int v4; // eax
_BYTE *v5; // rsi
v1 = *a1;
v2 = a1;
v3 = a1;
while ( v1 == 32 )
{
LABEL_6:
v5 = v3;
do
v1 = *++v5;
while ( v1 == 32 );
v2 = v3;
v3 = v5;
}
if ( v1 )
{
while ( 1 )
{
v4 = (unsigned __int8)*++v3;
if ( !v4 )
break;
if ( v4 == 32 )
goto LABEL_6;
}
v2 = v3;
}
return v2 - a1;
}
| strlength:
PUSH RBP
MOV RBP,RSP
MOV DL,byte ptr [RDI]
MOV RAX,RDI
MOV RCX,RDI
LAB_001b4c41:
CMP DL,0x20
JZ 0x001b4c5d
MOVZX EDX,DL
TEST EDX,EDX
JZ 0x001b4c76
LAB_001b4c4d:
MOVZX EAX,byte ptr [RCX + 0x1]
INC RCX
TEST EAX,EAX
JZ 0x001b4c73
CMP EAX,0x20
JNZ 0x001b4c4d
LAB_001b4c5d:
MOV RSI,RCX
LAB_001b4c60:
MOV DL,byte ptr [RSI + 0x1]
INC RSI
CMP DL,0x20
JZ 0x001b4c60
MOV RAX,RCX
MOV RCX,RSI
JMP 0x001b4c41
LAB_001b4c73:
MOV RAX,RCX
LAB_001b4c76:
SUB RAX,RDI
POP RBP
RET
|
long strlength(char *param_1)
{
char *pcVar1;
char *pcVar2;
char *pcVar3;
char cVar4;
char *pcVar5;
cVar4 = *param_1;
pcVar3 = param_1;
pcVar5 = param_1;
do {
pcVar2 = pcVar5;
if (cVar4 != ' ') {
if (cVar4 == '\0') {
LAB_001b4c76:
return (long)pcVar3 - (long)param_1;
}
do {
pcVar1 = pcVar5 + 1;
pcVar3 = pcVar5 + 1;
if (*pcVar1 == '\0') goto LAB_001b4c76;
pcVar5 = pcVar3;
pcVar2 = pcVar3;
} while (*pcVar1 != ' ');
}
do {
pcVar3 = pcVar2;
cVar4 = pcVar5[1];
pcVar5 = pcVar5 + 1;
pcVar2 = pcVar3;
} while (cVar4 == ' ');
} while( true );
}
| |
25,027 | check_mb_eucjpms | eloqsql/libmariadb/libmariadb/ma_charset.c | static unsigned int check_mb_eucjpms(const char *start, const char *end)
{
if (*((uchar *)start) < 0x80) {
return 0; /* invalid eucjpms character */
}
if (valid_eucjpms(start[0]) && (end - start) > 1 && valid_eucjpms(start[1])) {
return 2;
}
if (valid_eucjpms_ss2(start[0]) && (end - start) > 1 && valid_eucjpms_kata(start[1])) {
return 2;
}
if (valid_eucjpms_ss3(start[0]) && (end - start) > 2 && valid_eucjpms(start[1]) &&
valid_eucjpms(start[2])) {
return 2;
}
return 0;
} | O0 | c | check_mb_eucjpms:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x80, %eax
jge 0x5e096
movl $0x0, -0x4(%rbp)
jmp 0x5e1dd
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0xff, %eax
cmpl $0xa1, %eax
jl 0x5e101
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0xff, %eax
cmpl $0xfe, %eax
jg 0x5e101
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0x1, %rax
jle 0x5e101
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
andl $0xff, %eax
cmpl $0xa1, %eax
jl 0x5e101
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
andl $0xff, %eax
cmpl $0xfe, %eax
jg 0x5e101
movl $0x2, -0x4(%rbp)
jmp 0x5e1dd
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0xff, %eax
cmpl $0x8e, %eax
jne 0x5e159
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0x1, %rax
jle 0x5e159
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
andl $0xff, %eax
cmpl $0xa1, %eax
jl 0x5e159
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
andl $0xff, %eax
cmpl $0xdf, %eax
jg 0x5e159
movl $0x2, -0x4(%rbp)
jmp 0x5e1dd
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0xff, %eax
cmpl $0x8f, %eax
jne 0x5e1d6
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0x2, %rax
jle 0x5e1d6
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
andl $0xff, %eax
cmpl $0xa1, %eax
jl 0x5e1d6
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
andl $0xff, %eax
cmpl $0xfe, %eax
jg 0x5e1d6
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
andl $0xff, %eax
cmpl $0xa1, %eax
jl 0x5e1d6
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
andl $0xff, %eax
cmpl $0xfe, %eax
jg 0x5e1d6
movl $0x2, -0x4(%rbp)
jmp 0x5e1dd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| check_mb_eucjpms:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
cmp eax, 80h
jge short loc_5E096
mov [rbp+var_4], 0
jmp loc_5E1DD
loc_5E096:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
and eax, 0FFh
cmp eax, 0A1h
jl short loc_5E101
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
and eax, 0FFh
cmp eax, 0FEh
jg short loc_5E101
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
sub rax, rcx
cmp rax, 1
jle short loc_5E101
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax+1]
and eax, 0FFh
cmp eax, 0A1h
jl short loc_5E101
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax+1]
and eax, 0FFh
cmp eax, 0FEh
jg short loc_5E101
mov [rbp+var_4], 2
jmp loc_5E1DD
loc_5E101:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
and eax, 0FFh
cmp eax, 8Eh
jnz short loc_5E159
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
sub rax, rcx
cmp rax, 1
jle short loc_5E159
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax+1]
and eax, 0FFh
cmp eax, 0A1h
jl short loc_5E159
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax+1]
and eax, 0FFh
cmp eax, 0DFh
jg short loc_5E159
mov [rbp+var_4], 2
jmp loc_5E1DD
loc_5E159:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
and eax, 0FFh
cmp eax, 8Fh
jnz short loc_5E1D6
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
sub rax, rcx
cmp rax, 2
jle short loc_5E1D6
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax+1]
and eax, 0FFh
cmp eax, 0A1h
jl short loc_5E1D6
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax+1]
and eax, 0FFh
cmp eax, 0FEh
jg short loc_5E1D6
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax+2]
and eax, 0FFh
cmp eax, 0A1h
jl short loc_5E1D6
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax+2]
and eax, 0FFh
cmp eax, 0FEh
jg short loc_5E1D6
mov [rbp+var_4], 2
jmp short loc_5E1DD
loc_5E1D6:
mov [rbp+var_4], 0
loc_5E1DD:
mov eax, [rbp+var_4]
pop rbp
retn
| long long check_mb_eucjpms(unsigned __int8 *a1, long long a2)
{
if ( *a1 >= 0x80u )
{
if ( *a1 < 0xA1u || *a1 == 255 || a2 - (long long)a1 <= 1 || a1[1] < 0xA1u || a1[1] == 255 )
{
if ( *a1 == 142 && a2 - (long long)a1 > 1 && a1[1] >= 0xA1u && a1[1] <= 0xDFu )
{
return 2;
}
else if ( *a1 != 143 || a2 - (long long)a1 <= 2 || a1[1] < 0xA1u || a1[1] == 255 || a1[2] < 0xA1u || a1[2] == 255 )
{
return 0;
}
else
{
return 2;
}
}
else
{
return 2;
}
}
else
{
return 0;
}
}
| check_mb_eucjpms:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x80
JGE 0x0015e096
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0015e1dd
LAB_0015e096:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
AND EAX,0xff
CMP EAX,0xa1
JL 0x0015e101
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
AND EAX,0xff
CMP EAX,0xfe
JG 0x0015e101
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,RCX
CMP RAX,0x1
JLE 0x0015e101
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX + 0x1]
AND EAX,0xff
CMP EAX,0xa1
JL 0x0015e101
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX + 0x1]
AND EAX,0xff
CMP EAX,0xfe
JG 0x0015e101
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0015e1dd
LAB_0015e101:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
AND EAX,0xff
CMP EAX,0x8e
JNZ 0x0015e159
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,RCX
CMP RAX,0x1
JLE 0x0015e159
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX + 0x1]
AND EAX,0xff
CMP EAX,0xa1
JL 0x0015e159
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX + 0x1]
AND EAX,0xff
CMP EAX,0xdf
JG 0x0015e159
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0015e1dd
LAB_0015e159:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
AND EAX,0xff
CMP EAX,0x8f
JNZ 0x0015e1d6
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,RCX
CMP RAX,0x2
JLE 0x0015e1d6
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX + 0x1]
AND EAX,0xff
CMP EAX,0xa1
JL 0x0015e1d6
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX + 0x1]
AND EAX,0xff
CMP EAX,0xfe
JG 0x0015e1d6
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX + 0x2]
AND EAX,0xff
CMP EAX,0xa1
JL 0x0015e1d6
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX + 0x2]
AND EAX,0xff
CMP EAX,0xfe
JG 0x0015e1d6
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0015e1dd
LAB_0015e1d6:
MOV dword ptr [RBP + -0x4],0x0
LAB_0015e1dd:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 check_mb_eucjpms(byte *param_1,long param_2)
{
int4 local_c;
if (*param_1 < 0x80) {
local_c = 0;
}
else if ((((*param_1 < 0xa1) || (0xfe < *param_1)) || (param_2 - (long)param_1 < 2)) ||
((param_1[1] < 0xa1 || (0xfe < param_1[1])))) {
if (((*param_1 == 0x8e) && ((1 < param_2 - (long)param_1 && (0xa0 < param_1[1])))) &&
(param_1[1] < 0xe0)) {
local_c = 2;
}
else if (((((*param_1 == 0x8f) && (2 < param_2 - (long)param_1)) && (0xa0 < param_1[1])) &&
((param_1[1] < 0xff && (0xa0 < param_1[2])))) && (param_1[2] < 0xff)) {
local_c = 2;
}
else {
local_c = 0;
}
}
else {
local_c = 2;
}
return local_c;
}
| |
25,028 | ma_init_dynamic_string | eloqsql/libmariadb/libmariadb/ma_string.c | my_bool ma_init_dynamic_string(DYNAMIC_STRING *str, const char *init_str,
size_t init_alloc, size_t alloc_increment)
{
uint length;
if (!alloc_increment)
alloc_increment=128;
length=1;
if (init_str && (length= (uint) strlen(init_str)+1) < init_alloc)
init_alloc=((length+alloc_increment-1)/alloc_increment)*alloc_increment;
if (!init_alloc)
init_alloc=alloc_increment;
if (!(str->str=(char*) malloc(init_alloc)))
return(TRUE);
str->length=length-1;
if (init_str)
memcpy(str->str,init_str,length);
str->max_length=init_alloc;
str->alloc_increment=alloc_increment;
return(FALSE);
} | O3 | c | ma_init_dynamic_string:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rcx, %rcx
movl $0x80, %r13d
cmovneq %rcx, %r13
testq %rsi, %rsi
je 0x27b08
movq %r15, %rdi
callq 0x131c0
movq %rax, %r12
incl %r12d
cmpq %r14, %r12
jae 0x27b0e
leaq (%r12,%r13), %r14
decq %r14
movq %r14, %rax
xorl %edx, %edx
divq %r13
subq %rdx, %r14
jmp 0x27b0e
movl $0x1, %r12d
testq %r14, %r14
cmoveq %r13, %r14
movq %r14, %rdi
callq 0x13610
movq %rax, (%rbx)
testq %rax, %rax
je 0x27b4d
leal -0x1(%r12), %ecx
movq %rcx, 0x8(%rbx)
testq %r15, %r15
je 0x27b41
movl %r12d, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x13390
movq %r14, 0x10(%rbx)
movq %r13, 0x18(%rbx)
xorl %eax, %eax
jmp 0x27b4f
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ma_init_dynamic_string:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdx
mov r15, rsi
mov rbx, rdi
test rcx, rcx
mov r13d, 80h
cmovnz r13, rcx
test rsi, rsi
jz short loc_27B08
mov rdi, r15
call _strlen
mov r12, rax
inc r12d
cmp r12, r14
jnb short loc_27B0E
lea r14, [r12+r13]
dec r14
mov rax, r14
xor edx, edx
div r13
sub r14, rdx
jmp short loc_27B0E
loc_27B08:
mov r12d, 1
loc_27B0E:
test r14, r14
cmovz r14, r13
mov rdi, r14
call _malloc
mov [rbx], rax
test rax, rax
jz short loc_27B4D
lea ecx, [r12-1]
mov [rbx+8], rcx
test r15, r15
jz short loc_27B41
mov edx, r12d
mov rdi, rax
mov rsi, r15
call _memcpy
loc_27B41:
mov [rbx+10h], r14
mov [rbx+18h], r13
xor eax, eax
jmp short loc_27B4F
loc_27B4D:
mov al, 1
loc_27B4F:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ma_init_dynamic_string(long long *a1, long long a2, unsigned long long a3, unsigned long long a4)
{
unsigned long long v5; // r13
unsigned long long v6; // r12
long long v7; // rax
v5 = 128LL;
if ( a4 )
v5 = a4;
if ( a2 )
{
v6 = (unsigned int)strlen(a2) + 1;
if ( v6 < a3 )
a3 = v6 + v5 - 1 - (v6 + v5 - 1) % v5;
}
else
{
LODWORD(v6) = 1;
}
if ( !a3 )
a3 = v5;
v7 = malloc(a3);
*a1 = v7;
if ( !v7 )
return 1LL;
a1[1] = (unsigned int)(v6 - 1);
if ( a2 )
memcpy(v7, a2, (unsigned int)v6);
a1[2] = a3;
a1[3] = v5;
return 0LL;
}
| ma_init_dynamic_string:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
TEST RCX,RCX
MOV R13D,0x80
CMOVNZ R13,RCX
TEST RSI,RSI
JZ 0x00127b08
MOV RDI,R15
CALL 0x001131c0
MOV R12,RAX
INC R12D
CMP R12,R14
JNC 0x00127b0e
LEA R14,[R12 + R13*0x1]
DEC R14
MOV RAX,R14
XOR EDX,EDX
DIV R13
SUB R14,RDX
JMP 0x00127b0e
LAB_00127b08:
MOV R12D,0x1
LAB_00127b0e:
TEST R14,R14
CMOVZ R14,R13
MOV RDI,R14
CALL 0x00113610
MOV qword ptr [RBX],RAX
TEST RAX,RAX
JZ 0x00127b4d
LEA ECX,[R12 + -0x1]
MOV qword ptr [RBX + 0x8],RCX
TEST R15,R15
JZ 0x00127b41
MOV EDX,R12D
MOV RDI,RAX
MOV RSI,R15
CALL 0x00113390
LAB_00127b41:
MOV qword ptr [RBX + 0x10],R14
MOV qword ptr [RBX + 0x18],R13
XOR EAX,EAX
JMP 0x00127b4f
LAB_00127b4d:
MOV AL,0x1
LAB_00127b4f:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 ma_init_dynamic_string(int8 *param_1,char *param_2,ulong param_3,ulong param_4)
{
size_t sVar1;
void *__dest;
int8 uVar2;
ulong uVar3;
uVar3 = 0x80;
if (param_4 != 0) {
uVar3 = param_4;
}
if (param_2 == (char *)0x0) {
sVar1 = 1;
}
else {
sVar1 = strlen(param_2);
sVar1 = (size_t)((int)sVar1 + 1);
if (sVar1 < param_3) {
param_3 = (sVar1 + uVar3) - 1;
param_3 = param_3 - param_3 % uVar3;
}
}
if (param_3 == 0) {
param_3 = uVar3;
}
__dest = malloc(param_3);
*param_1 = __dest;
if (__dest == (void *)0x0) {
uVar2 = 1;
}
else {
param_1[1] = (ulong)((int)sVar1 - 1);
if (param_2 != (char *)0x0) {
memcpy(__dest,param_2,sVar1);
}
param_1[2] = param_3;
param_1[3] = uVar3;
uVar2 = 0;
}
return uVar2;
}
| |
25,029 | allocate_small | seiftnesse[P]memoryallocator/src/custom_alloc_small.c | void *allocate_small(size_t size) {
if (size > SMALL_ALLOCATION_THRESHOLD) {
HEAP_LOG("Size %zu exceeds small allocation threshold\n", size);
return NULL;
}
HEAP_LOG("Small allocation requested: %zu bytes\n", size);
// Find a free block in the bitmap
int blocks_needed = (size + SMALL_BLOCK_SIZE - 1) / SMALL_BLOCK_SIZE;
int consecutive_blocks = 0;
int start_block = -1;
for (int i = 0; i < SMALL_POOL_SIZE / SMALL_BLOCK_SIZE; i++) {
int bitmap_index = i / 32;
int bit_index = i % 32;
if (!(small_block_bitmap[bitmap_index] & (1 << bit_index))) {
// This block is free
if (consecutive_blocks == 0) {
start_block = i;
}
consecutive_blocks++;
if (consecutive_blocks >= blocks_needed) {
// We found enough consecutive blocks
for (int j = 0; j < blocks_needed; j++) {
int block = start_block + j;
int bmap_idx = block / 32;
int bit_idx = block % 32;
small_block_bitmap[bmap_idx] |= (1 << bit_idx);
}
// Update stats
allocation_stats.small_pool_used += blocks_needed * SMALL_BLOCK_SIZE;
update_stats_allocate(blocks_needed * SMALL_BLOCK_SIZE);
void *result = &small_pool[start_block * SMALL_BLOCK_SIZE];
HEAP_LOG("Small allocation succeeded: %p, blocks=%d, total_size=%zu\n",
result, blocks_needed, blocks_needed * SMALL_BLOCK_SIZE);
return result;
}
} else {
// This block is used, reset counter
consecutive_blocks = 0;
}
}
HEAP_LOG("Small allocation failed: no suitable blocks available for %zu bytes\n", size);
return NULL;
} | O3 | c | allocate_small:
xorl %eax, %eax
cmpq $0x100, %rdi # imm = 0x100
ja 0x2535
pushq %rbx
movq %rdi, %rcx
addq $0x1f, %rdi
movq %rdi, %rdx
shrq $0x5, %rdx
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
leaq 0x4102c52(%rip), %rsi # 0x4105100
xorl %r8d, %r8d
xorl %r9d, %r9d
movl %r9d, %r10d
shrl $0x5, %r10d
movl (%rsi,%r10,4), %r11d
xorl %r10d, %r10d
btl %r9d, %r11d
jae 0x24cd
movl %r10d, %r8d
jmp 0x24dc
testl %r8d, %r8d
cmovel %r9d, %ebx
incl %r8d
cmpl %edx, %r8d
jge 0x24ea
incl %r9d
cmpl $0x8000, %r9d # imm = 0x8000
jne 0x24b4
jmp 0x2534
testq %rcx, %rcx
je 0x2511
movl %ebx, %ecx
leal 0x1f(%rcx), %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
sarl $0x5, %eax
movl $0x1, %r8d
shll %cl, %r8d
cltq
orl %r8d, (%rsi,%rax,4)
incl %ecx
decl %edx
jne 0x24f1
andl $0x3e0, %edi # imm = 0x3E0
leaq 0x4103be2(%rip), %rax # 0x4106100
addq %rdi, 0x28(%rax)
callq 0x2e01
shll $0x5, %ebx
movslq %ebx, %rax
addq 0x2a9c(%rip), %rax # 0x4fd0
popq %rbx
retq
| allocate_small:
xor eax, eax
cmp rdi, 100h
ja locret_2535
push rbx
mov rcx, rdi
add rdi, 1Fh
mov rdx, rdi
shr rdx, 5
mov ebx, 0FFFFFFFFh
lea rsi, small_block_bitmap
xor r8d, r8d
xor r9d, r9d
loc_24B4:
mov r10d, r9d
shr r10d, 5
mov r11d, [rsi+r10*4]
xor r10d, r10d
bt r11d, r9d
jnb short loc_24CD
mov r8d, r10d
jmp short loc_24DC
loc_24CD:
test r8d, r8d
cmovz ebx, r9d
inc r8d
cmp r8d, edx
jge short loc_24EA
loc_24DC:
inc r9d
cmp r9d, 8000h
jnz short loc_24B4
jmp short loc_2534
loc_24EA:
test rcx, rcx
jz short loc_2511
mov ecx, ebx
loc_24F1:
lea eax, [rcx+1Fh]
test ecx, ecx
cmovns eax, ecx
sar eax, 5
mov r8d, 1
shl r8d, cl
cdqe
or [rsi+rax*4], r8d
inc ecx
dec edx
jnz short loc_24F1
loc_2511:
and edi, 3E0h
lea rax, allocation_stats
add [rax+28h], rdi
call update_stats_allocate
shl ebx, 5
movsxd rax, ebx
add rax, cs:small_pool_ptr
loc_2534:
pop rbx
locret_2535:
retn
| char * allocate_small(unsigned long long a1)
{
char *result; // rax
unsigned long long v3; // rdi
unsigned long long v4; // rdx
int v5; // ebx
int v6; // r8d
unsigned int v7; // r9d
int v8; // r11d
int v9; // ecx
unsigned long long v10; // rdi
result = 0LL;
if ( a1 > 0x100 )
return result;
v3 = a1 + 31;
v4 = v3 >> 5;
v5 = -1;
v6 = 0;
v7 = 0;
while ( 1 )
{
v8 = small_block_bitmap[v7 >> 5];
if ( !_bittest(&v8, v7) )
break;
v6 = 0;
LABEL_8:
if ( ++v7 == 0x8000 )
return result;
}
if ( !v6 )
v5 = v7;
if ( ++v6 < (int)v4 )
goto LABEL_8;
if ( a1 )
{
v9 = v5;
do
{
small_block_bitmap[v9 / 32] |= 1 << v9;
++v9;
LODWORD(v4) = v4 - 1;
}
while ( (_DWORD)v4 );
}
v10 = v3 & 0x3E0;
*(&allocation_stats + 5) += v10;
update_stats_allocate(v10);
return (char *)&small_pool + 32 * v5;
}
| allocate_small:
XOR EAX,EAX
CMP RDI,0x100
JA 0x00102535
PUSH RBX
MOV RCX,RDI
ADD RDI,0x1f
MOV RDX,RDI
SHR RDX,0x5
MOV EBX,0xffffffff
LEA RSI,[0x4205100]
XOR R8D,R8D
XOR R9D,R9D
LAB_001024b4:
MOV R10D,R9D
SHR R10D,0x5
MOV R11D,dword ptr [RSI + R10*0x4]
XOR R10D,R10D
BT R11D,R9D
JNC 0x001024cd
MOV R8D,R10D
JMP 0x001024dc
LAB_001024cd:
TEST R8D,R8D
CMOVZ EBX,R9D
INC R8D
CMP R8D,EDX
JGE 0x001024ea
LAB_001024dc:
INC R9D
CMP R9D,0x8000
JNZ 0x001024b4
JMP 0x00102534
LAB_001024ea:
TEST RCX,RCX
JZ 0x00102511
MOV ECX,EBX
LAB_001024f1:
LEA EAX,[RCX + 0x1f]
TEST ECX,ECX
CMOVNS EAX,ECX
SAR EAX,0x5
MOV R8D,0x1
SHL R8D,CL
CDQE
OR dword ptr [RSI + RAX*0x4],R8D
INC ECX
DEC EDX
JNZ 0x001024f1
LAB_00102511:
AND EDI,0x3e0
LEA RAX,[0x4206100]
ADD qword ptr [RAX + 0x28],RDI
CALL 0x00102e01
SHL EBX,0x5
MOVSXD RAX,EBX
ADD RAX,qword ptr [0x00104fd0]
LAB_00102534:
POP RBX
LAB_00102535:
RET
|
int * allocate_small(ulong param_1)
{
int iVar1;
int iVar2;
ulong uVar3;
int iVar4;
ulong uVar5;
uint uVar6;
ulong uVar7;
if (param_1 < 0x101) {
uVar3 = param_1 + 0x1f >> 5;
uVar5 = 0xffffffff;
iVar4 = 0;
uVar7 = 0;
do {
iVar1 = 0;
if (((uint)(&small_block_bitmap)[uVar7 >> 5] >> ((uint)uVar7 & 0x1f) & 1) == 0) {
if (iVar4 == 0) {
uVar5 = uVar7;
}
iVar1 = iVar4 + 1;
if ((int)uVar3 <= iVar4 + 1) {
iVar4 = (int)uVar5;
if (param_1 != 0) {
do {
iVar1 = (int)uVar5;
iVar2 = iVar1 + 0x1f;
if (-1 < iVar1) {
iVar2 = iVar1;
}
(&small_block_bitmap)[iVar2 >> 5] =
(&small_block_bitmap)[iVar2 >> 5] | 1 << ((byte)uVar5 & 0x1f);
uVar5 = (ulong)(iVar1 + 1);
uVar6 = (int)uVar3 - 1;
uVar3 = (ulong)uVar6;
} while (uVar6 != 0);
}
DAT_04206128 = DAT_04206128 + (ulong)((uint)(param_1 + 0x1f) & 0x3e0);
update_stats_allocate();
return PTR_small_pool_00104fd0 + (iVar4 << 5);
}
}
iVar4 = iVar1;
uVar6 = (uint)uVar7 + 1;
uVar7 = (ulong)uVar6;
} while (uVar6 != 0x8000);
}
return (int *)0x0;
}
| |
25,030 | psi_cond_wait | eloqsql/mysys/my_thr_init.c | ATTRIBUTE_COLD int psi_cond_wait(mysql_cond_t *that, mysql_mutex_t *mutex,
const char *file, uint line)
{
PSI_cond_locker_state state;
PSI_cond_locker *locker= PSI_COND_CALL(start_cond_wait)
(&state, that->m_psi, mutex->m_psi, PSI_COND_WAIT, file, line);
int result= my_cond_wait(&that->m_cond, &mutex->m_mutex);
if (locker)
PSI_COND_CALL(end_cond_wait)(locker, result);
return result;
} | O3 | c | psi_cond_wait:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %ecx, %r9d
movq %rdx, %r8
movq %rsi, %r14
movq %rdi, %r15
leaq 0x3330cf(%rip), %r12 # 0x36ffe8
movq (%r12), %rax
movq 0x30(%rdi), %rsi
movq 0x40(%r14), %rdx
leaq -0x58(%rbp), %rdi
xorl %ecx, %ecx
callq *0x1c0(%rax)
movq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3a5c0
movl %eax, %r14d
testq %rbx, %rbx
je 0x3cf57
movq (%r12), %rax
movq %rbx, %rdi
movl %r14d, %esi
callq *0x1c8(%rax)
movl %r14d, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| psi_cond_wait:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 40h
mov r9d, ecx
mov r8, rdx
mov r14, rsi
mov r15, rdi
lea r12, PSI_server
mov rax, [r12]
mov rsi, [rdi+30h]
mov rdx, [r14+40h]
lea rdi, [rbp+var_58]
xor ecx, ecx
call qword ptr [rax+1C0h]
mov rbx, rax
mov rdi, r15
mov rsi, r14
call _pthread_cond_wait
mov r14d, eax
test rbx, rbx
jz short loc_3CF57
mov rax, [r12]
mov rdi, rbx
mov esi, r14d
call qword ptr [rax+1C8h]
loc_3CF57:
mov eax, r14d
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long psi_cond_wait(long long a1, long long a2, long long a3, unsigned int a4)
{
long long v4; // rbx
unsigned int v5; // r14d
_BYTE v7[88]; // [rsp+8h] [rbp-58h] BYREF
v4 = (*((long long ( **)(_BYTE *, _QWORD, _QWORD, _QWORD, long long, _QWORD))PSI_server + 56))(
v7,
*(_QWORD *)(a1 + 48),
*(_QWORD *)(a2 + 64),
0LL,
a3,
a4);
v5 = pthread_cond_wait(a1, a2);
if ( v4 )
(*((void ( **)(long long, _QWORD))PSI_server + 57))(v4, v5);
return v5;
}
| psi_cond_wait:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV R9D,ECX
MOV R8,RDX
MOV R14,RSI
MOV R15,RDI
LEA R12,[0x46ffe8]
MOV RAX,qword ptr [R12]
MOV RSI,qword ptr [RDI + 0x30]
MOV RDX,qword ptr [R14 + 0x40]
LEA RDI,[RBP + -0x58]
XOR ECX,ECX
CALL qword ptr [RAX + 0x1c0]
MOV RBX,RAX
MOV RDI,R15
MOV RSI,R14
CALL 0x0013a5c0
MOV R14D,EAX
TEST RBX,RBX
JZ 0x0013cf57
MOV RAX,qword ptr [R12]
MOV RDI,RBX
MOV ESI,R14D
CALL qword ptr [RAX + 0x1c8]
LAB_0013cf57:
MOV EAX,R14D
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int psi_cond_wait(pthread_cond_t *param_1,pthread_mutex_t *param_2,int8 param_3,
int4 param_4)
{
int iVar1;
long lVar2;
int1 local_60 [56];
lVar2 = (**(code **)(PSI_server + 0x1c0))
(local_60,param_1[1].__align,*(int8 *)((long)param_2 + 0x40),0,param_3,
param_4);
iVar1 = pthread_cond_wait(param_1,param_2);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x1c8))(lVar2,iVar1);
}
return iVar1;
}
| |
25,031 | postprocess_cpu_params(cpu_params&, cpu_params const*) | monkey531[P]llama/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 0x4d482
testq %rsi, %rsi
je 0x4d47b
movl $0x214, %edx # imm = 0x214
movq %rbx, %rdi
callq 0x19620
jmp 0x4d482
callq 0x4d26e
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 0x4d48f
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 0x4d4fc
cmpl (%rbx), %ebp
jge 0x4d4fc
leaq 0x9bd4f(%rip), %rax # 0xe9220
cmpl $0x0, (%rax)
js 0x4d4fc
callq 0x874d7
movl (%rbx), %r8d
leaq 0x665e2(%rip), %rdx # 0xb3ac7
movq %rax, %rdi
movl $0x3, %esi
movl %ebp, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x87574
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_4D482
test rsi, rsi
jz short loc_4D47B
mov edx, 214h
mov rdi, rbx
call _memcpy
jmp short loc_4D482
loc_4D47B:
call _Z16cpu_get_num_mathv; cpu_get_num_math(void)
mov [rbx], eax
loc_4D482:
pxor xmm1, xmm1
mov eax, 4
pxor xmm0, xmm0
loc_4D48F:
movd xmm2, dword ptr [rbx+rax]
punpcklbw xmm2, xmm1
punpcklwd xmm2, xmm1
paddd xmm0, xmm2
add rax, 4
cmp rax, 204h
jnz short loc_4D48F
pshufd xmm1, xmm0, 0EEh
paddd xmm1, xmm0
pshufd xmm0, xmm1, 55h ; 'U'
paddd xmm0, xmm1
movd ebp, xmm0
test ebp, ebp
jz short loc_4D4FC
cmp ebp, [rbx]
jge short loc_4D4FC
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_4D4FC
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_4D4FC:
add rsp, 8
pop rbx
pop rbp
retn
| int * postprocess_cpu_params(int *a1, long long a2, long long a3, long long a4, long long a5, long long a6, char a7)
{
int *result; // rax
__m128i v8; // xmm0
__m128i v9; // xmm1
int v10; // ebp
int v11; // eax
int v12; // r9d
if ( *a1 < 0 )
{
if ( a2 )
memcpy(a1, a2, 532LL);
else
*a1 = cpu_get_num_math();
}
result = (_DWORD *)&byte_4;
v8 = 0LL;
do
v8 = _mm_add_epi32(
v8,
_mm_unpacklo_epi16(
_mm_unpacklo_epi8(_mm_cvtsi32_si128(*(int *)((char *)result++ + (_QWORD)a1)), (__m128i)0LL),
(__m128i)0LL));
while ( result != &dword_204 );
v9 = _mm_add_epi32(_mm_shuffle_epi32(v8, 238), v8);
v10 = _mm_cvtsi128_si32(_mm_add_epi32(_mm_shuffle_epi32(v9, 85), v9));
if ( v10 && v10 < *a1 )
{
result = (int *)&common_log_verbosity_thold;
if ( common_log_verbosity_thold >= 0 )
{
v11 = common_log_main();
return (int *)common_log_add(
v11,
3,
(unsigned int)"Not enough set bits in CPU mask (%d) to satisfy requested thread count: %d\n",
v10,
*a1,
v12,
a7);
}
}
return result;
}
| postprocess_cpu_params:
PUSH RBP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CMP dword ptr [RDI],0x0
JNS 0x0014d482
TEST RSI,RSI
JZ 0x0014d47b
MOV EDX,0x214
MOV RDI,RBX
CALL 0x00119620
JMP 0x0014d482
LAB_0014d47b:
CALL 0x0014d26e
MOV dword ptr [RBX],EAX
LAB_0014d482:
PXOR XMM1,XMM1
MOV EAX,0x4
PXOR XMM0,XMM0
LAB_0014d48f:
MOVD XMM2,dword ptr [RBX + RAX*0x1]
PUNPCKLBW XMM2,XMM1
PUNPCKLWD XMM2,XMM1
PADDD XMM0,XMM2
ADD RAX,0x4
CMP RAX,0x204
JNZ 0x0014d48f
PSHUFD XMM1,XMM0,0xee
PADDD XMM1,XMM0
PSHUFD XMM0,XMM1,0x55
PADDD XMM0,XMM1
MOVD EBP,XMM0
TEST EBP,EBP
JZ 0x0014d4fc
CMP EBP,dword ptr [RBX]
JGE 0x0014d4fc
LEA RAX,[0x1e9220]
CMP dword ptr [RAX],0x0
JS 0x0014d4fc
CALL 0x001874d7
MOV R8D,dword ptr [RBX]
LEA RDX,[0x1b3ac7]
MOV RDI,RAX
MOV ESI,0x3
MOV ECX,EBP
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x00187574
LAB_0014d4fc:
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;
}
| |
25,032 | ma_bitmap_create_first | eloqsql/storage/maria/ma_bitmap.c | int _ma_bitmap_create_first(MARIA_SHARE *share)
{
uint block_size= share->bitmap.block_size;
File file= share->bitmap.file.file;
uchar marker[CRC_SIZE];
/*
Next write operation of the page will write correct CRC
if it is needed
*/
int4store(marker, MARIA_NO_CRC_BITMAP_PAGE);
if (mysql_file_chsize(file, block_size - sizeof(marker),
0, MYF(MY_WME)) ||
my_pwrite(file, marker, sizeof(marker),
block_size - sizeof(marker),
MYF(MY_NABP | MY_WME)))
return 1;
share->state.state.data_file_length= block_size;
_ma_bitmap_delete_all(share);
return 0;
} | O3 | c | ma_bitmap_create_first:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movl 0xa60(%rdi), %r14d
movl 0xb44(%rdi), %r13d
movl $0xfffffffe, -0x34(%rbp) # imm = 0xFFFFFFFE
leaq -0x4(%r13), %r15
leaq 0x3314be(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x80(%rbp), %rdi
movl %r14d, %esi
movl $0xd, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x54bd7
movl $0x10, %ecx
movl %r14d, %edi
movq %r15, %rsi
xorl %edx, %edx
callq 0x9dd74
movl $0x1, %r12d
testl %eax, %eax
jne 0x54bb6
leaq -0x34(%rbp), %rsi
movl $0x4, %edx
movl $0x14, %r8d
movl %r14d, %edi
movq %r15, %rcx
callq 0xa095e
testq %rax, %rax
jne 0x54bb6
movq %r13, 0x40(%rbx)
movq %rbx, %rdi
callq 0x52ec4
xorl %r12d, %r12d
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x54bf2
movl %r12d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x38(%rbp), %r12
movq %rax, %rdi
movq %r15, %rsi
movl %r14d, %edx
movq %r12, %rcx
callq 0x2c7ee
movl (%r12), %eax
jmp 0x54b7e
callq 0x29260
| _ma_bitmap_create_first:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov r14d, [rdi+0A60h]
mov r13d, [rdi+0B44h]
mov [rbp+var_34], 0FFFFFFFEh
lea r15, [r13-4]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_80]
mov esi, r14d
mov edx, 0Dh
call qword ptr [rax+158h]
test rax, rax
jnz short loc_54BD7
mov ecx, 10h
mov edi, r14d
mov rsi, r15
xor edx, edx
call my_chsize
loc_54B7E:
mov r12d, 1
test eax, eax
jnz short loc_54BB6
lea rsi, [rbp+var_34]
mov edx, 4
mov r8d, 14h
mov edi, r14d
mov rcx, r15
call my_pwrite
test rax, rax
jnz short loc_54BB6
mov [rbx+40h], r13
mov rdi, rbx
call _ma_bitmap_delete_all
xor r12d, r12d
loc_54BB6:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_54BF2
mov eax, r12d
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_54BD7:
lea r12, [rbp+var_38]
mov rdi, rax
mov rsi, r15
mov edx, r14d
mov rcx, r12
call _ma_bitmap_create_first_cold_1
mov eax, [r12]
jmp short loc_54B7E
loc_54BF2:
call ___stack_chk_fail
| long long ma_bitmap_create_first(long long a1)
{
unsigned int v1; // r14d
long long v2; // r13
long long v3; // rax
int v4; // eax
unsigned int v5; // r12d
_BYTE v7[72]; // [rsp+0h] [rbp-80h] BYREF
int v8; // [rsp+48h] [rbp-38h] BYREF
int v9; // [rsp+4Ch] [rbp-34h] BYREF
unsigned long long v10; // [rsp+50h] [rbp-30h]
v10 = __readfsqword(0x28u);
v1 = *(_DWORD *)(a1 + 2656);
v2 = *(unsigned int *)(a1 + 2884);
v9 = -2;
v3 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v7, v1, 13LL);
if ( v3 )
{
ma_bitmap_create_first_cold_1(v3, v2 - 4, v1, &v8);
v4 = v8;
}
else
{
v4 = my_chsize(v1, v2 - 4, 0LL, 16LL);
}
v5 = 1;
if ( !v4 && !my_pwrite(v1, &v9, 4LL, v2 - 4, 20LL) )
{
*(_QWORD *)(a1 + 64) = v2;
ma_bitmap_delete_all(a1);
return 0;
}
return v5;
}
| _ma_bitmap_create_first:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R14D,dword ptr [RDI + 0xa60]
MOV R13D,dword ptr [RDI + 0xb44]
MOV dword ptr [RBP + -0x34],0xfffffffe
LEA R15,[R13 + -0x4]
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x80]
MOV ESI,R14D
MOV EDX,0xd
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00154bd7
MOV ECX,0x10
MOV EDI,R14D
MOV RSI,R15
XOR EDX,EDX
CALL 0x0019dd74
LAB_00154b7e:
MOV R12D,0x1
TEST EAX,EAX
JNZ 0x00154bb6
LEA RSI,[RBP + -0x34]
MOV EDX,0x4
MOV R8D,0x14
MOV EDI,R14D
MOV RCX,R15
CALL 0x001a095e
TEST RAX,RAX
JNZ 0x00154bb6
MOV qword ptr [RBX + 0x40],R13
MOV RDI,RBX
CALL 0x00152ec4
XOR R12D,R12D
LAB_00154bb6:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00154bf2
MOV EAX,R12D
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00154bd7:
LEA R12,[RBP + -0x38]
MOV RDI,RAX
MOV RSI,R15
MOV EDX,R14D
MOV RCX,R12
CALL 0x0012c7ee
MOV EAX,dword ptr [R12]
JMP 0x00154b7e
LAB_00154bf2:
CALL 0x00129260
|
/* WARNING: Type propagation algorithm not settling */
int8 _ma_bitmap_create_first(long param_1)
{
int4 uVar1;
uint uVar2;
long lVar3;
long lVar4;
int8 uVar5;
long in_FS_OFFSET;
int1 local_88 [72];
int local_40 [2];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar1 = *(int4 *)(param_1 + 0xa60);
uVar2 = *(uint *)(param_1 + 0xb44);
local_40[1] = 0xfffffffe;
lVar4 = (ulong)uVar2 - 4;
lVar3 = (**(code **)(PSI_server + 0x158))(local_88,uVar1,0xd);
if (lVar3 == 0) {
local_40[0] = my_chsize(uVar1,lVar4,0,0x10);
}
else {
_ma_bitmap_create_first_cold_1(lVar3,lVar4,uVar1,local_40);
}
uVar5 = 1;
if (local_40[0] == 0) {
lVar4 = my_pwrite(uVar1,local_40 + 1,4,lVar4,0x14);
if (lVar4 == 0) {
*(ulong *)(param_1 + 0x40) = (ulong)uVar2;
_ma_bitmap_delete_all(param_1);
uVar5 = 0;
}
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return uVar5;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
25,033 | ftxui::(anonymous namespace)::ExecuteSignalHandlers() | Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/component/screen_interactive.cpp | void ExecuteSignalHandlers() {
int signal_exit_count = g_signal_exit_count.exchange(0);
while (signal_exit_count--) {
ScreenInteractive::Private::Signal(*g_active_screen, SIGABRT);
}
#if !defined(_WIN32)
int signal_stop_count = g_signal_stop_count.exchange(0);
while (signal_stop_count--) {
ScreenInteractive::Private::Signal(*g_active_screen, SIGTSTP);
}
int signal_resize_count = g_signal_resize_count.exchange(0);
while (signal_resize_count--) {
ScreenInteractive::Private::Signal(*g_active_screen, SIGWINCH);
}
#endif
} | O1 | cpp | ftxui::(anonymous namespace)::ExecuteSignalHandlers():
pushq %rbp
pushq %rbx
pushq %rax
xorl %ebx, %ebx
xorl %ebp, %ebp
xchgl %ebp, 0x2c281(%rip) # 0x5b2c8
testl %ebp, %ebp
je 0x2f054
callq 0x2ee95
decl %ebp
jne 0x2f04b
xchgl %ebx, 0x2c272(%rip) # 0x5b2cc
testl %ebx, %ebx
je 0x2f073
movq 0x2c25b(%rip), %rdi # 0x5b2c0
movl $0x14, %esi
callq 0x30350
decl %ebx
jne 0x2f05e
xorl %ebx, %ebx
xchgl %ebx, 0x2c255(%rip) # 0x5b2d0
testl %ebx, %ebx
je 0x2f094
movq 0x2c23a(%rip), %rdi # 0x5b2c0
movl $0x1c, %esi
callq 0x30350
decl %ebx
jne 0x2f07f
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
| _ZN5ftxui12_GLOBAL__N_121ExecuteSignalHandlersEv:
push rbp
push rbx
push rax
xor ebx, ebx
xor ebp, ebp
xchg ebp, cs:_ZN5ftxui12_GLOBAL__N_119g_signal_exit_countE; ftxui::`anonymous namespace'::g_signal_exit_count
test ebp, ebp
jz short loc_2F054
loc_2F04B:
call _ZN5ftxui12_GLOBAL__N_16OnExitEv; ftxui::`anonymous namespace'::OnExit(void)
dec ebp
jnz short loc_2F04B
loc_2F054:
xchg ebx, cs:_ZN5ftxui12_GLOBAL__N_119g_signal_stop_countE; ftxui::`anonymous namespace'::g_signal_stop_count
test ebx, ebx
jz short loc_2F073
loc_2F05E:
mov rdi, cs:_ZN5ftxui12_GLOBAL__N_115g_active_screenE; this
mov esi, 14h; int
call _ZN5ftxui17ScreenInteractive6SignalEi; ftxui::ScreenInteractive::Signal(int)
dec ebx
jnz short loc_2F05E
loc_2F073:
xor ebx, ebx
xchg ebx, cs:_ZN5ftxui12_GLOBAL__N_121g_signal_resize_countE; ftxui::`anonymous namespace'::g_signal_resize_count
test ebx, ebx
jz short loc_2F094
loc_2F07F:
mov rdi, cs:_ZN5ftxui12_GLOBAL__N_115g_active_screenE; this
mov esi, 1Ch; int
call _ZN5ftxui17ScreenInteractive6SignalEi; ftxui::ScreenInteractive::Signal(int)
dec ebx
jnz short loc_2F07F
loc_2F094:
add rsp, 8
pop rbx
pop rbp
retn
| long long ftxui::`anonymous namespace'::ExecuteSignalHandlers(ftxui::_anonymous_namespace_ *this)
{
__int32 i; // ebp
long long result; // rax
__int32 j; // ebx
__int32 k; // ebx
for ( i = _InterlockedExchange(&ftxui::`anonymous namespace'::g_signal_exit_count, 0); i; --i )
result = ftxui::`anonymous namespace'::OnExit(this);
for ( j = _InterlockedExchange(&ftxui::`anonymous namespace'::g_signal_stop_count, 0); j; --j )
result = ftxui::ScreenInteractive::Signal(ftxui::`anonymous namespace'::g_active_screen, 20);
for ( k = _InterlockedExchange(&ftxui::`anonymous namespace'::g_signal_resize_count, 0); k; --k )
result = ftxui::ScreenInteractive::Signal(ftxui::`anonymous namespace'::g_active_screen, 28);
return result;
}
| ExecuteSignalHandlers:
PUSH RBP
PUSH RBX
PUSH RAX
XOR EBX,EBX
XOR EBP,EBP
XCHG dword ptr [0x0015b2c8],EBP
TEST EBP,EBP
JZ 0x0012f054
LAB_0012f04b:
CALL 0x0012ee95
DEC EBP
JNZ 0x0012f04b
LAB_0012f054:
XCHG dword ptr [0x0015b2cc],EBX
TEST EBX,EBX
JZ 0x0012f073
LAB_0012f05e:
MOV RDI,qword ptr [0x0015b2c0]
MOV ESI,0x14
CALL 0x00130350
DEC EBX
JNZ 0x0012f05e
LAB_0012f073:
XOR EBX,EBX
XCHG dword ptr [0x0015b2d0],EBX
TEST EBX,EBX
JZ 0x0012f094
LAB_0012f07f:
MOV RDI,qword ptr [0x0015b2c0]
MOV ESI,0x1c
CALL 0x00130350
DEC EBX
JNZ 0x0012f07f
LAB_0012f094:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
/* ftxui::(anonymous namespace)::ExecuteSignalHandlers() */
void ftxui::(anonymous_namespace)::ExecuteSignalHandlers(void)
{
int iVar1;
int iVar2;
iVar2 = g_signal_exit_count;
LOCK();
g_signal_exit_count = 0;
UNLOCK();
if (iVar2 != 0) {
do {
OnExit();
iVar2 = iVar2 + -1;
} while (iVar2 != 0);
}
iVar2 = g_signal_stop_count;
LOCK();
g_signal_stop_count = 0;
UNLOCK();
iVar1 = g_signal_resize_count;
for (; iVar2 != 0; iVar2 = iVar2 + -1) {
g_signal_resize_count = iVar1;
ScreenInteractive::Signal(g_active_screen,0x14);
iVar1 = g_signal_resize_count;
}
LOCK();
g_signal_resize_count = 0;
UNLOCK();
for (; iVar1 != 0; iVar1 = iVar1 + -1) {
ScreenInteractive::Signal(g_active_screen,0x1c);
}
return;
}
| |
25,034 | js_date_parse_isostring | bluesky950520[P]quickjs/quickjs.c | static BOOL js_date_parse_isostring(const uint8_t *sp, int fields[9], BOOL *is_local) {
int sgn, i, p = 0;
/* initialize fields to the beginning of the Epoch */
for (i = 0; i < 9; i++) {
fields[i] = (i == 2);
}
*is_local = FALSE;
/* year is either yyyy digits or [+-]yyyyyy */
sgn = sp[p];
if (sgn == '-' || sgn == '+') {
p++;
if (!string_get_digits(sp, &p, &fields[0], 6, 6))
return FALSE;
if (sgn == '-') {
if (fields[0] == 0)
return FALSE; // reject -000000
fields[0] = -fields[0];
}
} else {
if (!string_get_digits(sp, &p, &fields[0], 4, 4))
return FALSE;
}
if (string_skip_char(sp, &p, '-')) {
if (!string_get_digits(sp, &p, &fields[1], 2, 2)) /* month */
return FALSE;
if (fields[1] < 1)
return FALSE;
fields[1] -= 1;
if (string_skip_char(sp, &p, '-')) {
if (!string_get_digits(sp, &p, &fields[2], 2, 2)) /* day */
return FALSE;
if (fields[2] < 1)
return FALSE;
}
}
if (string_skip_char(sp, &p, 'T')) {
*is_local = TRUE;
if (!string_get_digits(sp, &p, &fields[3], 2, 2) /* hour */
|| !string_skip_char(sp, &p, ':')
|| !string_get_digits(sp, &p, &fields[4], 2, 2)) { /* minute */
fields[3] = 100; // reject unconditionally
return TRUE;
}
if (string_skip_char(sp, &p, ':')) {
if (!string_get_digits(sp, &p, &fields[5], 2, 2)) /* second */
return FALSE;
string_get_milliseconds(sp, &p, &fields[6]);
}
}
/* parse the time zone offset if present: [+-]HH:mm or [+-]HHmm */
if (sp[p]) {
*is_local = FALSE;
if (!string_get_tzoffset(sp, &p, &fields[8], TRUE))
return FALSE;
}
/* error if extraneous characters */
return sp[p] == '\0';
} | O0 | c | js_date_parse_isostring:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x10(%rsp)
cmpl $0x9, 0x10(%rsp)
jge 0x9fee1
cmpl $0x2, 0x10(%rsp)
sete %al
andb $0x1, %al
movzbl %al, %edx
movq 0x20(%rsp), %rax
movslq 0x10(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x9feb3
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
movq 0x28(%rsp), %rax
movslq 0xc(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, 0x14(%rsp)
cmpl $0x2d, 0x14(%rsp)
je 0x9ff0c
cmpl $0x2b, 0x14(%rsp)
jne 0x9ff76
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0xc(%rsp), %rsi
movl $0x6, %r8d
movl %r8d, %ecx
callq 0xa08e0
cmpl $0x0, %eax
jne 0x9ff46
movl $0x0, 0x34(%rsp)
jmp 0xa01f7
cmpl $0x2d, 0x14(%rsp)
jne 0x9ff74
movq 0x20(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x9ff64
movl $0x0, 0x34(%rsp)
jmp 0xa01f7
movq 0x20(%rsp), %rax
xorl %ecx, %ecx
subl (%rax), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
jmp 0x9ffa7
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0xc(%rsp), %rsi
movl $0x4, %r8d
movl %r8d, %ecx
callq 0xa08e0
cmpl $0x0, %eax
jne 0x9ffa5
movl $0x0, 0x34(%rsp)
jmp 0xa01f7
jmp 0x9ffa7
movq 0x28(%rsp), %rdi
leaq 0xc(%rsp), %rsi
movl $0x2d, %edx
callq 0xa09b0
cmpl $0x0, %eax
je 0xa0085
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
addq $0x4, %rdx
leaq 0xc(%rsp), %rsi
movl $0x2, %r8d
movl %r8d, %ecx
callq 0xa08e0
cmpl $0x0, %eax
jne 0x9fff7
movl $0x0, 0x34(%rsp)
jmp 0xa01f7
movq 0x20(%rsp), %rax
cmpl $0x1, 0x4(%rax)
jge 0xa000f
movl $0x0, 0x34(%rsp)
jmp 0xa01f7
movq 0x20(%rsp), %rax
movl 0x4(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq 0x28(%rsp), %rdi
leaq 0xc(%rsp), %rsi
movl $0x2d, %edx
callq 0xa09b0
cmpl $0x0, %eax
je 0xa0083
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
addq $0x8, %rdx
leaq 0xc(%rsp), %rsi
movl $0x2, %r8d
movl %r8d, %ecx
callq 0xa08e0
cmpl $0x0, %eax
jne 0xa0069
movl $0x0, 0x34(%rsp)
jmp 0xa01f7
movq 0x20(%rsp), %rax
cmpl $0x1, 0x8(%rax)
jge 0xa0081
movl $0x0, 0x34(%rsp)
jmp 0xa01f7
jmp 0xa0083
jmp 0xa0085
movq 0x28(%rsp), %rdi
leaq 0xc(%rsp), %rsi
movl $0x54, %edx
callq 0xa09b0
cmpl $0x0, %eax
je 0xa0191
movq 0x18(%rsp), %rax
movl $0x1, (%rax)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
addq $0xc, %rdx
leaq 0xc(%rsp), %rsi
movl $0x2, %r8d
movl %r8d, %ecx
callq 0xa08e0
cmpl $0x0, %eax
je 0xa0112
movq 0x28(%rsp), %rdi
leaq 0xc(%rsp), %rsi
movl $0x3a, %edx
callq 0xa09b0
cmpl $0x0, %eax
je 0xa0112
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
addq $0x10, %rdx
leaq 0xc(%rsp), %rsi
movl $0x2, %r8d
movl %r8d, %ecx
callq 0xa08e0
cmpl $0x0, %eax
jne 0xa012b
movq 0x20(%rsp), %rax
movl $0x64, 0xc(%rax)
movl $0x1, 0x34(%rsp)
jmp 0xa01f7
movq 0x28(%rsp), %rdi
leaq 0xc(%rsp), %rsi
movl $0x3a, %edx
callq 0xa09b0
cmpl $0x0, %eax
je 0xa018f
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
addq $0x14, %rdx
leaq 0xc(%rsp), %rsi
movl $0x2, %r8d
movl %r8d, %ecx
callq 0xa08e0
cmpl $0x0, %eax
jne 0xa0177
movl $0x0, 0x34(%rsp)
jmp 0xa01f7
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
addq $0x18, %rdx
leaq 0xc(%rsp), %rsi
callq 0xa0a00
jmp 0xa0191
movq 0x28(%rsp), %rax
movslq 0xc(%rsp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xa01da
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
addq $0x20, %rdx
leaq 0xc(%rsp), %rsi
movl $0x1, %ecx
callq 0xa0b00
cmpl $0x0, %eax
jne 0xa01d8
movl $0x0, 0x34(%rsp)
jmp 0xa01f7
jmp 0xa01da
movq 0x28(%rsp), %rax
movslq 0xc(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
| js_date_parse_isostring:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_18], rsi
mov [rsp+38h+var_20], rdx
mov [rsp+38h+var_2C], 0
mov [rsp+38h+var_28], 0
loc_9FEB3:
cmp [rsp+38h+var_28], 9
jge short loc_9FEE1
cmp [rsp+38h+var_28], 2
setz al
and al, 1
movzx edx, al
mov rax, [rsp+38h+var_18]
movsxd rcx, [rsp+38h+var_28]
mov [rax+rcx*4], edx
mov eax, [rsp+38h+var_28]
add eax, 1
mov [rsp+38h+var_28], eax
jmp short loc_9FEB3
loc_9FEE1:
mov rax, [rsp+38h+var_20]
mov dword ptr [rax], 0
mov rax, [rsp+38h+var_10]
movsxd rcx, [rsp+38h+var_2C]
movzx eax, byte ptr [rax+rcx]
mov [rsp+38h+var_24], eax
cmp [rsp+38h+var_24], 2Dh ; '-'
jz short loc_9FF0C
cmp [rsp+38h+var_24], 2Bh ; '+'
jnz short loc_9FF76
loc_9FF0C:
mov eax, [rsp+38h+var_2C]
add eax, 1
mov [rsp+38h+var_2C], eax
mov rdi, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_18]
lea rsi, [rsp+38h+var_2C]
mov r8d, 6
mov ecx, r8d
call string_get_digits
cmp eax, 0
jnz short loc_9FF46
mov [rsp+38h+var_4], 0
jmp loc_A01F7
loc_9FF46:
cmp [rsp+38h+var_24], 2Dh ; '-'
jnz short loc_9FF74
mov rax, [rsp+38h+var_18]
cmp dword ptr [rax], 0
jnz short loc_9FF64
mov [rsp+38h+var_4], 0
jmp loc_A01F7
loc_9FF64:
mov rax, [rsp+38h+var_18]
xor ecx, ecx
sub ecx, [rax]
mov rax, [rsp+38h+var_18]
mov [rax], ecx
loc_9FF74:
jmp short loc_9FFA7
loc_9FF76:
mov rdi, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_18]
lea rsi, [rsp+38h+var_2C]
mov r8d, 4
mov ecx, r8d
call string_get_digits
cmp eax, 0
jnz short loc_9FFA5
mov [rsp+38h+var_4], 0
jmp loc_A01F7
loc_9FFA5:
jmp short $+2
loc_9FFA7:
mov rdi, [rsp+38h+var_10]
lea rsi, [rsp+38h+var_2C]
mov edx, 2Dh ; '-'
call string_skip_char
cmp eax, 0
jz loc_A0085
mov rdi, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_18]
add rdx, 4
lea rsi, [rsp+38h+var_2C]
mov r8d, 2
mov ecx, r8d
call string_get_digits
cmp eax, 0
jnz short loc_9FFF7
mov [rsp+38h+var_4], 0
jmp loc_A01F7
loc_9FFF7:
mov rax, [rsp+38h+var_18]
cmp dword ptr [rax+4], 1
jge short loc_A000F
mov [rsp+38h+var_4], 0
jmp loc_A01F7
loc_A000F:
mov rax, [rsp+38h+var_18]
mov ecx, [rax+4]
sub ecx, 1
mov [rax+4], ecx
mov rdi, [rsp+38h+var_10]
lea rsi, [rsp+38h+var_2C]
mov edx, 2Dh ; '-'
call string_skip_char
cmp eax, 0
jz short loc_A0083
mov rdi, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_18]
add rdx, 8
lea rsi, [rsp+38h+var_2C]
mov r8d, 2
mov ecx, r8d
call string_get_digits
cmp eax, 0
jnz short loc_A0069
mov [rsp+38h+var_4], 0
jmp loc_A01F7
loc_A0069:
mov rax, [rsp+38h+var_18]
cmp dword ptr [rax+8], 1
jge short loc_A0081
mov [rsp+38h+var_4], 0
jmp loc_A01F7
loc_A0081:
jmp short $+2
loc_A0083:
jmp short $+2
loc_A0085:
mov rdi, [rsp+38h+var_10]
lea rsi, [rsp+38h+var_2C]
mov edx, 54h ; 'T'
call string_skip_char
cmp eax, 0
jz loc_A0191
mov rax, [rsp+38h+var_20]
mov dword ptr [rax], 1
mov rdi, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_18]
add rdx, 0Ch
lea rsi, [rsp+38h+var_2C]
mov r8d, 2
mov ecx, r8d
call string_get_digits
cmp eax, 0
jz short loc_A0112
mov rdi, [rsp+38h+var_10]
lea rsi, [rsp+38h+var_2C]
mov edx, 3Ah ; ':'
call string_skip_char
cmp eax, 0
jz short loc_A0112
mov rdi, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_18]
add rdx, 10h
lea rsi, [rsp+38h+var_2C]
mov r8d, 2
mov ecx, r8d
call string_get_digits
cmp eax, 0
jnz short loc_A012B
loc_A0112:
mov rax, [rsp+38h+var_18]
mov dword ptr [rax+0Ch], 64h ; 'd'
mov [rsp+38h+var_4], 1
jmp loc_A01F7
loc_A012B:
mov rdi, [rsp+38h+var_10]
lea rsi, [rsp+38h+var_2C]
mov edx, 3Ah ; ':'
call string_skip_char
cmp eax, 0
jz short loc_A018F
mov rdi, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_18]
add rdx, 14h
lea rsi, [rsp+38h+var_2C]
mov r8d, 2
mov ecx, r8d
call string_get_digits
cmp eax, 0
jnz short loc_A0177
mov [rsp+38h+var_4], 0
jmp loc_A01F7
loc_A0177:
mov rdi, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_18]
add rdx, 18h
lea rsi, [rsp+38h+var_2C]
call string_get_milliseconds
loc_A018F:
jmp short $+2
loc_A0191:
mov rax, [rsp+38h+var_10]
movsxd rcx, [rsp+38h+var_2C]
cmp byte ptr [rax+rcx], 0
jz short loc_A01DA
mov rax, [rsp+38h+var_20]
mov dword ptr [rax], 0
mov rdi, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_18]
add rdx, 20h ; ' '
lea rsi, [rsp+38h+var_2C]
mov ecx, 1
call string_get_tzoffset
cmp eax, 0
jnz short loc_A01D8
mov [rsp+38h+var_4], 0
jmp short loc_A01F7
loc_A01D8:
jmp short $+2
loc_A01DA:
mov rax, [rsp+38h+var_10]
movsxd rcx, [rsp+38h+var_2C]
movzx eax, byte ptr [rax+rcx]
cmp eax, 0
setz al
and al, 1
movzx eax, al
mov [rsp+38h+var_4], eax
loc_A01F7:
mov eax, [rsp+38h+var_4]
add rsp, 38h
retn
| _BOOL8 js_date_parse_isostring(long long a1, _DWORD *a2, _DWORD *a3)
{
int v4; // [rsp+Ch] [rbp-2Ch] BYREF
int i; // [rsp+10h] [rbp-28h]
int v6; // [rsp+14h] [rbp-24h]
_DWORD *v7; // [rsp+18h] [rbp-20h]
_DWORD *v8; // [rsp+20h] [rbp-18h]
long long v9; // [rsp+28h] [rbp-10h]
v9 = a1;
v8 = a2;
v7 = a3;
v4 = 0;
for ( i = 0; i < 9; ++i )
v8[i] = i == 2;
*v7 = 0;
v6 = *(unsigned __int8 *)(v9 + v4);
if ( v6 == 45 || v6 == 43 )
{
++v4;
if ( !(unsigned int)string_get_digits(v9, &v4, v8, 6LL) )
return 0;
if ( v6 == 45 )
{
if ( !*v8 )
return 0;
*v8 = -*v8;
}
}
else if ( !(unsigned int)string_get_digits(v9, &v4, v8, 4LL) )
{
return 0;
}
if ( (unsigned int)string_skip_char(v9, &v4, 45LL) )
{
if ( !(unsigned int)string_get_digits(v9, &v4, v8 + 1, 2LL) )
return 0;
if ( (int)v8[1] < 1 )
return 0;
--v8[1];
if ( (unsigned int)string_skip_char(v9, &v4, 45LL) )
{
if ( !(unsigned int)string_get_digits(v9, &v4, v8 + 2, 2LL) )
return 0;
if ( (int)v8[2] < 1 )
return 0;
}
}
if ( (unsigned int)string_skip_char(v9, &v4, 84LL) )
{
*v7 = 1;
if ( !(unsigned int)string_get_digits(v9, &v4, v8 + 3, 2LL)
|| !(unsigned int)string_skip_char(v9, &v4, 58LL)
|| !(unsigned int)string_get_digits(v9, &v4, v8 + 4, 2LL) )
{
v8[3] = 100;
return 1;
}
if ( (unsigned int)string_skip_char(v9, &v4, 58LL) )
{
if ( !(unsigned int)string_get_digits(v9, &v4, v8 + 5, 2LL) )
return 0;
string_get_milliseconds(v9, &v4, v8 + 6);
}
}
if ( !*(_BYTE *)(v9 + v4) )
return *(unsigned __int8 *)(v9 + v4) == 0;
*v7 = 0;
return (unsigned int)string_get_tzoffset(v9, &v4, v8 + 8, 1LL) && *(unsigned __int8 *)(v9 + v4) == 0;
}
| js_date_parse_isostring:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RSI
MOV qword ptr [RSP + 0x18],RDX
MOV dword ptr [RSP + 0xc],0x0
MOV dword ptr [RSP + 0x10],0x0
LAB_0019feb3:
CMP dword ptr [RSP + 0x10],0x9
JGE 0x0019fee1
CMP dword ptr [RSP + 0x10],0x2
SETZ AL
AND AL,0x1
MOVZX EDX,AL
MOV RAX,qword ptr [RSP + 0x20]
MOVSXD RCX,dword ptr [RSP + 0x10]
MOV dword ptr [RAX + RCX*0x4],EDX
MOV EAX,dword ptr [RSP + 0x10]
ADD EAX,0x1
MOV dword ptr [RSP + 0x10],EAX
JMP 0x0019feb3
LAB_0019fee1:
MOV RAX,qword ptr [RSP + 0x18]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RSP + 0x28]
MOVSXD RCX,dword ptr [RSP + 0xc]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RSP + 0x14],EAX
CMP dword ptr [RSP + 0x14],0x2d
JZ 0x0019ff0c
CMP dword ptr [RSP + 0x14],0x2b
JNZ 0x0019ff76
LAB_0019ff0c:
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
MOV RDI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
LEA RSI,[RSP + 0xc]
MOV R8D,0x6
MOV ECX,R8D
CALL 0x001a08e0
CMP EAX,0x0
JNZ 0x0019ff46
MOV dword ptr [RSP + 0x34],0x0
JMP 0x001a01f7
LAB_0019ff46:
CMP dword ptr [RSP + 0x14],0x2d
JNZ 0x0019ff74
MOV RAX,qword ptr [RSP + 0x20]
CMP dword ptr [RAX],0x0
JNZ 0x0019ff64
MOV dword ptr [RSP + 0x34],0x0
JMP 0x001a01f7
LAB_0019ff64:
MOV RAX,qword ptr [RSP + 0x20]
XOR ECX,ECX
SUB ECX,dword ptr [RAX]
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RAX],ECX
LAB_0019ff74:
JMP 0x0019ffa7
LAB_0019ff76:
MOV RDI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
LEA RSI,[RSP + 0xc]
MOV R8D,0x4
MOV ECX,R8D
CALL 0x001a08e0
CMP EAX,0x0
JNZ 0x0019ffa5
MOV dword ptr [RSP + 0x34],0x0
JMP 0x001a01f7
LAB_0019ffa5:
JMP 0x0019ffa7
LAB_0019ffa7:
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[RSP + 0xc]
MOV EDX,0x2d
CALL 0x001a09b0
CMP EAX,0x0
JZ 0x001a0085
MOV RDI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
ADD RDX,0x4
LEA RSI,[RSP + 0xc]
MOV R8D,0x2
MOV ECX,R8D
CALL 0x001a08e0
CMP EAX,0x0
JNZ 0x0019fff7
MOV dword ptr [RSP + 0x34],0x0
JMP 0x001a01f7
LAB_0019fff7:
MOV RAX,qword ptr [RSP + 0x20]
CMP dword ptr [RAX + 0x4],0x1
JGE 0x001a000f
MOV dword ptr [RSP + 0x34],0x0
JMP 0x001a01f7
LAB_001a000f:
MOV RAX,qword ptr [RSP + 0x20]
MOV ECX,dword ptr [RAX + 0x4]
SUB ECX,0x1
MOV dword ptr [RAX + 0x4],ECX
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[RSP + 0xc]
MOV EDX,0x2d
CALL 0x001a09b0
CMP EAX,0x0
JZ 0x001a0083
MOV RDI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
ADD RDX,0x8
LEA RSI,[RSP + 0xc]
MOV R8D,0x2
MOV ECX,R8D
CALL 0x001a08e0
CMP EAX,0x0
JNZ 0x001a0069
MOV dword ptr [RSP + 0x34],0x0
JMP 0x001a01f7
LAB_001a0069:
MOV RAX,qword ptr [RSP + 0x20]
CMP dword ptr [RAX + 0x8],0x1
JGE 0x001a0081
MOV dword ptr [RSP + 0x34],0x0
JMP 0x001a01f7
LAB_001a0081:
JMP 0x001a0083
LAB_001a0083:
JMP 0x001a0085
LAB_001a0085:
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[RSP + 0xc]
MOV EDX,0x54
CALL 0x001a09b0
CMP EAX,0x0
JZ 0x001a0191
MOV RAX,qword ptr [RSP + 0x18]
MOV dword ptr [RAX],0x1
MOV RDI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
ADD RDX,0xc
LEA RSI,[RSP + 0xc]
MOV R8D,0x2
MOV ECX,R8D
CALL 0x001a08e0
CMP EAX,0x0
JZ 0x001a0112
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[RSP + 0xc]
MOV EDX,0x3a
CALL 0x001a09b0
CMP EAX,0x0
JZ 0x001a0112
MOV RDI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
ADD RDX,0x10
LEA RSI,[RSP + 0xc]
MOV R8D,0x2
MOV ECX,R8D
CALL 0x001a08e0
CMP EAX,0x0
JNZ 0x001a012b
LAB_001a0112:
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RAX + 0xc],0x64
MOV dword ptr [RSP + 0x34],0x1
JMP 0x001a01f7
LAB_001a012b:
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[RSP + 0xc]
MOV EDX,0x3a
CALL 0x001a09b0
CMP EAX,0x0
JZ 0x001a018f
MOV RDI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
ADD RDX,0x14
LEA RSI,[RSP + 0xc]
MOV R8D,0x2
MOV ECX,R8D
CALL 0x001a08e0
CMP EAX,0x0
JNZ 0x001a0177
MOV dword ptr [RSP + 0x34],0x0
JMP 0x001a01f7
LAB_001a0177:
MOV RDI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
ADD RDX,0x18
LEA RSI,[RSP + 0xc]
CALL 0x001a0a00
LAB_001a018f:
JMP 0x001a0191
LAB_001a0191:
MOV RAX,qword ptr [RSP + 0x28]
MOVSXD RCX,dword ptr [RSP + 0xc]
CMP byte ptr [RAX + RCX*0x1],0x0
JZ 0x001a01da
MOV RAX,qword ptr [RSP + 0x18]
MOV dword ptr [RAX],0x0
MOV RDI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
ADD RDX,0x20
LEA RSI,[RSP + 0xc]
MOV ECX,0x1
CALL 0x001a0b00
CMP EAX,0x0
JNZ 0x001a01d8
MOV dword ptr [RSP + 0x34],0x0
JMP 0x001a01f7
LAB_001a01d8:
JMP 0x001a01da
LAB_001a01da:
MOV RAX,qword ptr [RSP + 0x28]
MOVSXD RCX,dword ptr [RSP + 0xc]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RSP + 0x34],EAX
LAB_001a01f7:
MOV EAX,dword ptr [RSP + 0x34]
ADD RSP,0x38
RET
|
bool js_date_parse_isostring(byte *param_1,int *param_2,int4 *param_3)
{
int iVar1;
int local_2c;
int local_28;
uint local_24;
int4 *local_20;
int *local_18;
byte *local_10;
local_2c = 0;
for (local_28 = 0; local_28 < 9; local_28 = local_28 + 1) {
param_2[local_28] = (uint)(local_28 == 2);
}
*param_3 = 0;
local_24 = (uint)*param_1;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
if ((local_24 == 0x2d) || (local_24 == 0x2b)) {
local_2c = 1;
iVar1 = string_get_digits(param_1,&local_2c,param_2);
if (iVar1 == 0) {
return false;
}
if (local_24 == 0x2d) {
if (*local_18 == 0) {
return false;
}
*local_18 = -*local_18;
}
}
else {
iVar1 = string_get_digits(param_1,&local_2c,param_2,4);
if (iVar1 == 0) {
return false;
}
}
iVar1 = string_skip_char(local_10,&local_2c,0x2d);
if (iVar1 != 0) {
iVar1 = string_get_digits(local_10,&local_2c,local_18 + 1,2);
if (iVar1 == 0) {
return false;
}
if (local_18[1] < 1) {
return false;
}
local_18[1] = local_18[1] + -1;
iVar1 = string_skip_char(local_10,&local_2c,0x2d);
if (iVar1 != 0) {
iVar1 = string_get_digits(local_10,&local_2c,local_18 + 2,2);
if (iVar1 == 0) {
return false;
}
if (local_18[2] < 1) {
return false;
}
}
}
iVar1 = string_skip_char(local_10,&local_2c,0x54);
if (iVar1 != 0) {
*local_20 = 1;
iVar1 = string_get_digits(local_10,&local_2c,local_18 + 3,2);
if (((iVar1 == 0) || (iVar1 = string_skip_char(local_10,&local_2c,0x3a), iVar1 == 0)) ||
(iVar1 = string_get_digits(local_10,&local_2c,local_18 + 4,2), iVar1 == 0)) {
local_18[3] = 100;
return true;
}
iVar1 = string_skip_char(local_10,&local_2c,0x3a);
if (iVar1 != 0) {
iVar1 = string_get_digits(local_10,&local_2c,local_18 + 5,2);
if (iVar1 == 0) {
return false;
}
string_get_milliseconds(local_10,&local_2c,local_18 + 6);
}
}
if (local_10[local_2c] != 0) {
*local_20 = 0;
iVar1 = string_get_tzoffset(local_10,&local_2c,local_18 + 8,1);
if (iVar1 == 0) {
return false;
}
}
return local_10[local_2c] == 0;
}
| |
25,035 | getopt_double | eloqsql/mysys/my_getopt.c | static double getopt_double(char *arg, const struct my_option *optp, int *err)
{
double num;
int error;
char *end= arg + 1000; /* Big enough as *arg is \0 terminated */
num= my_strtod(arg, &end, &error);
if (end[0] != 0 || error)
{
my_getopt_error_reporter(ERROR_LEVEL,
"Invalid decimal value for option '%s'\n", optp->name);
*err= EXIT_ARGUMENT_INVALID;
return 0.0;
}
return getopt_double_limit_value(num, optp, NULL);
} | O0 | c | getopt_double:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x3e8, %rax # imm = 0x3E8
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0x142150
movsd %xmm0, -0x28(%rbp)
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xc0dfa
cmpl $0x0, -0x2c(%rbp)
je 0xc0e2c
leaq 0x2408ef(%rip), %rax # 0x3016f0
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rdx
xorl %edi, %edi
leaq 0xad311(%rip), %rsi # 0x16e125
movb $0x0, %al
callq *%rcx
movq -0x20(%rbp), %rax
movl $0xd, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xc0e43
movsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xbfcd0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nop
| getopt_double:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
add rax, 3E8h
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_38]
lea rdx, [rbp+var_2C]
call my_strtod
movsd [rbp+var_28], xmm0
mov rax, [rbp+var_38]
movsx eax, byte ptr [rax]
cmp eax, 0
jnz short loc_C0DFA
cmp [rbp+var_2C], 0
jz short loc_C0E2C
loc_C0DFA:
lea rax, my_getopt_error_reporter
mov rcx, [rax]
mov rax, [rbp+var_18]
mov rdx, [rax]
xor edi, edi
lea rsi, aInvalidDecimal; "Invalid decimal value for option '%s'\n"
mov al, 0
call rcx
mov rax, [rbp+var_20]
mov dword ptr [rax], 0Dh
xorps xmm0, xmm0
movsd [rbp+var_8], xmm0
jmp short loc_C0E43
loc_C0E2C:
movsd xmm0, [rbp+var_28]
mov rdi, [rbp+var_18]
xor eax, eax
mov esi, eax
call getopt_double_limit_value
movsd [rbp+var_8], xmm0
loc_C0E43:
movsd xmm0, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| double getopt_double(long long a1, const char **a2, _DWORD *a3)
{
_BYTE *v4; // [rsp+8h] [rbp-38h] BYREF
int v5; // [rsp+14h] [rbp-2Ch] BYREF
double v6; // [rsp+18h] [rbp-28h]
_DWORD *v7; // [rsp+20h] [rbp-20h]
const char **v8; // [rsp+28h] [rbp-18h]
long long v9; // [rsp+30h] [rbp-10h]
v9 = a1;
v8 = a2;
v7 = a3;
v4 = (_BYTE *)(a1 + 1000);
v6 = my_strtod(a1, &v4, &v5);
if ( !*v4 && !v5 )
return getopt_double_limit_value(v8, 0LL, v6);
my_getopt_error_reporter(0, (long long)"Invalid decimal value for option '%s'\n", *v8);
*v7 = 13;
return 0.0;
}
| getopt_double:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x3e8
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x38]
LEA RDX,[RBP + -0x2c]
CALL 0x00242150
MOVSD qword ptr [RBP + -0x28],XMM0
MOV RAX,qword ptr [RBP + -0x38]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JNZ 0x001c0dfa
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x001c0e2c
LAB_001c0dfa:
LEA RAX,[0x4016f0]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RAX]
XOR EDI,EDI
LEA RSI,[0x26e125]
MOV AL,0x0
CALL RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0xd
XORPS XMM0,XMM0
MOVSD qword ptr [RBP + -0x8],XMM0
JMP 0x001c0e43
LAB_001c0e2c:
MOVSD XMM0,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RBP + -0x18]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x001bfcd0
MOVSD qword ptr [RBP + -0x8],XMM0
LAB_001c0e43:
MOVSD XMM0,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
int8 getopt_double(long param_1,int8 *param_2,int4 *param_3)
{
char *local_40;
int local_34;
int8 local_30;
int4 *local_28;
int8 *local_20;
long local_18;
int8 local_10;
local_40 = (char *)(param_1 + 1000);
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
local_30 = my_strtod(param_1,&local_40,&local_34);
if ((*local_40 == '\0') && (local_34 == 0)) {
local_10 = getopt_double_limit_value(local_30,local_20,0);
}
else {
(*(code *)my_getopt_error_reporter)(0,"Invalid decimal value for option \'%s\'\n",*local_20);
*local_28 = 0xd;
local_10 = 0;
}
return local_10;
}
| |
25,036 | mp_mul | bluesky950520[P]quickjs/libbf.c | int mp_mul(bf_context_t *s, limb_t *result,
const limb_t *op1, limb_t op1_size,
const limb_t *op2, limb_t op2_size)
{
#ifdef USE_FFT_MUL
if (unlikely(bf_min(op1_size, op2_size) >= FFT_MUL_THRESHOLD)) {
bf_t r_s, *r = &r_s;
r->tab = result;
/* XXX: optimize memory usage in API */
if (fft_mul(s, r, (limb_t *)op1, op1_size,
(limb_t *)op2, op2_size, FFT_MUL_R_NORESIZE))
return -1;
} else
#endif
{
mp_mul_basecase(result, op1, op1_size, op2, op2_size);
}
return 0;
} | O2 | c | mp_mul:
subq $0x38, %rsp
cmpq %r9, %rcx
movq %r9, %rax
cmovlq %rcx, %rax
cmpq $0x64, %rax
jge 0x73b09
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movq %r9, %r8
callq 0x740a1
xorl %eax, %eax
addq $0x38, %rsp
retq
leaq 0x10(%rsp), %rax
movq %rsi, 0x20(%rax)
movl $0x4, (%rsp)
movq %rax, %rsi
callq 0x73b2a
testl %eax, %eax
je 0x73b02
pushq $-0x1
popq %rax
jmp 0x73b04
| mp_mul:
sub rsp, 38h
cmp rcx, r9
mov rax, r9
cmovl rax, rcx
cmp rax, 64h ; 'd'
jge short loc_73B09
mov rdi, rsi
mov rsi, rdx
mov rdx, rcx
mov rcx, r8
mov r8, r9
call mp_mul_basecase
loc_73B02:
xor eax, eax
loc_73B04:
add rsp, 38h
retn
loc_73B09:
lea rax, [rsp+38h+var_28]
mov [rax+20h], rsi
mov [rsp+38h+var_38], 4
mov rsi, rax
call fft_mul
test eax, eax
jz short loc_73B02
push 0FFFFFFFFFFFFFFFFh
pop rax
jmp short loc_73B04
| long long mp_mul(int a1, long long a2, long long a3, long long a4, long long a5, long long a6)
{
long long v6; // rax
char v8; // [rsp+10h] [rbp-28h] BYREF
long long v9; // [rsp+30h] [rbp-8h]
v6 = a6;
if ( a4 < a6 )
v6 = a4;
if ( v6 < 100 )
{
mp_mul_basecase(a2, a3, a4, a5, a6);
return 0LL;
}
v9 = a2;
if ( !(unsigned int)fft_mul(a1, (unsigned int)&v8, a3, a4, a5, a6, 4) )
return 0LL;
return -1LL;
}
| mp_mul:
SUB RSP,0x38
CMP RCX,R9
MOV RAX,R9
CMOVL RAX,RCX
CMP RAX,0x64
JGE 0x00173b09
MOV RDI,RSI
MOV RSI,RDX
MOV RDX,RCX
MOV RCX,R8
MOV R8,R9
CALL 0x001740a1
LAB_00173b02:
XOR EAX,EAX
LAB_00173b04:
ADD RSP,0x38
RET
LAB_00173b09:
LEA RAX,[RSP + 0x10]
MOV qword ptr [RAX + 0x20],RSI
MOV dword ptr [RSP],0x4
MOV RSI,RAX
CALL 0x00173b2a
TEST EAX,EAX
JZ 0x00173b02
PUSH -0x1
POP RAX
JMP 0x00173b04
|
int8
mp_mul(int8 param_1,int8 param_2,int8 param_3,long param_4,int8 param_5,
long param_6)
{
int iVar1;
long lVar2;
int1 local_28 [32];
int8 local_8;
lVar2 = param_6;
if (param_4 < param_6) {
lVar2 = param_4;
}
if (lVar2 < 100) {
mp_mul_basecase(param_2,param_3,param_4,param_5,param_6);
}
else {
local_8 = param_2;
iVar1 = fft_mul(param_1,local_28);
if (iVar1 != 0) {
return 0xffffffffffffffff;
}
}
return 0;
}
| |
25,037 | async_func_mark | bluesky950520[P]quickjs/quickjs.c | static void async_func_mark(JSRuntime *rt, JSAsyncFunctionState *s,
JS_MarkFunc *mark_func)
{
JSStackFrame *sf;
JSValue *sp;
sf = &s->frame;
JS_MarkValue(rt, sf->cur_func, mark_func);
JS_MarkValue(rt, s->this_val, mark_func);
if (sf->cur_sp) {
/* if the function is running, cur_sp is not known so we
cannot mark the stack. Marking the variables is not needed
because a running function cannot be part of a removable
cycle */
for(sp = sf->arg_buf; sp < sf->cur_sp; sp++)
JS_MarkValue(rt, *sp, mark_func);
}
} | O1 | c | async_func_mark:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0xfffffffe, %r12d # imm = 0xFFFFFFFE
movsd 0x20(%rsi), %xmm0
movl 0x28(%rsi), %eax
movsd %xmm0, 0x8(%rsp)
andl $-0x2, %eax
cmpl %r12d, %eax
jne 0x3b60d
movq 0x8(%rsp), %rsi
movq %r15, %rdi
callq *%rbx
movsd (%r14), %xmm0
movl 0x8(%r14), %eax
movsd %xmm0, 0x8(%rsp)
andl $-0x2, %eax
cmpl %r12d, %eax
jne 0x3b62e
movq 0x8(%rsp), %rsi
movq %r15, %rdi
callq *%rbx
cmpq $0x0, 0x60(%r14)
je 0x3b667
movq 0x30(%r14), %r13
cmpq 0x60(%r14), %r13
jae 0x3b667
movsd (%r13), %xmm0
movl 0x8(%r13), %eax
movsd %xmm0, 0x8(%rsp)
andl $-0x2, %eax
cmpl %r12d, %eax
jne 0x3b661
movq 0x8(%rsp), %rsi
movq %r15, %rdi
callq *%rbx
addq $0x10, %r13
jmp 0x3b639
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| async_func_mark:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov r12d, 0FFFFFFFEh
movsd xmm0, qword ptr [rsi+20h]
mov eax, [rsi+28h]
movsd [rsp+38h+var_30], xmm0
and eax, 0FFFFFFFEh
cmp eax, r12d
jnz short loc_3B60D
mov rsi, [rsp+38h+var_30]
mov rdi, r15
call rbx
loc_3B60D:
movsd xmm0, qword ptr [r14]
mov eax, [r14+8]
movsd [rsp+38h+var_30], xmm0
and eax, 0FFFFFFFEh
cmp eax, r12d
jnz short loc_3B62E
mov rsi, [rsp+38h+var_30]
mov rdi, r15
call rbx
loc_3B62E:
cmp qword ptr [r14+60h], 0
jz short loc_3B667
mov r13, [r14+30h]
loc_3B639:
cmp r13, [r14+60h]
jnb short loc_3B667
movsd xmm0, qword ptr [r13+0]
mov eax, [r13+8]
movsd [rsp+38h+var_30], xmm0
and eax, 0FFFFFFFEh
cmp eax, r12d
jnz short loc_3B661
mov rsi, [rsp+38h+var_30]
mov rdi, r15
call rbx
loc_3B661:
add r13, 10h
jmp short loc_3B639
loc_3B667:
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| long long async_func_mark(long long a1, long long a2, void ( *a3)(long long, _QWORD))
{
long long result; // rax
unsigned long long i; // r13
if ( (*(_DWORD *)(a2 + 40) & 0xFFFFFFFE) == 0xFFFFFFFE )
a3(a1, *(_QWORD *)(a2 + 32));
result = *(_DWORD *)(a2 + 8) & 0xFFFFFFFE;
if ( (_DWORD)result == -2 )
result = ((long long ( *)(long long, _QWORD))a3)(a1, *(_QWORD *)a2);
if ( *(_QWORD *)(a2 + 96) )
{
for ( i = *(_QWORD *)(a2 + 48); i < *(_QWORD *)(a2 + 96); i += 16LL )
{
result = *(_DWORD *)(i + 8) & 0xFFFFFFFE;
if ( (_DWORD)result == -2 )
result = ((long long ( *)(long long, _QWORD))a3)(a1, *(_QWORD *)i);
}
}
return result;
}
| async_func_mark:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV R12D,0xfffffffe
MOVSD XMM0,qword ptr [RSI + 0x20]
MOV EAX,dword ptr [RSI + 0x28]
MOVSD qword ptr [RSP + 0x8],XMM0
AND EAX,0xfffffffe
CMP EAX,R12D
JNZ 0x0013b60d
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,R15
CALL RBX
LAB_0013b60d:
MOVSD XMM0,qword ptr [R14]
MOV EAX,dword ptr [R14 + 0x8]
MOVSD qword ptr [RSP + 0x8],XMM0
AND EAX,0xfffffffe
CMP EAX,R12D
JNZ 0x0013b62e
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,R15
CALL RBX
LAB_0013b62e:
CMP qword ptr [R14 + 0x60],0x0
JZ 0x0013b667
MOV R13,qword ptr [R14 + 0x30]
LAB_0013b639:
CMP R13,qword ptr [R14 + 0x60]
JNC 0x0013b667
MOVSD XMM0,qword ptr [R13]
MOV EAX,dword ptr [R13 + 0x8]
MOVSD qword ptr [RSP + 0x8],XMM0
AND EAX,0xfffffffe
CMP EAX,R12D
JNZ 0x0013b661
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,R15
CALL RBX
LAB_0013b661:
ADD R13,0x10
JMP 0x0013b639
LAB_0013b667:
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
void async_func_mark(int8 param_1,int8 *param_2,code *param_3)
{
int8 *puVar1;
if ((*(uint *)(param_2 + 5) & 0xfffffffe) == 0xfffffffe) {
(*param_3)(param_1,param_2[4]);
}
if ((*(uint *)(param_2 + 1) & 0xfffffffe) == 0xfffffffe) {
(*param_3)(param_1,*param_2);
}
if (param_2[0xc] != 0) {
for (puVar1 = (int8 *)param_2[6]; puVar1 < (int8 *)param_2[0xc]; puVar1 = puVar1 + 2
) {
if ((*(uint *)(puVar1 + 1) & 0xfffffffe) == 0xfffffffe) {
(*param_3)(param_1,*puVar1);
}
}
}
return;
}
| |
25,038 | async_func_mark | bluesky950520[P]quickjs/quickjs.c | static void async_func_mark(JSRuntime *rt, JSAsyncFunctionState *s,
JS_MarkFunc *mark_func)
{
JSStackFrame *sf;
JSValue *sp;
sf = &s->frame;
JS_MarkValue(rt, sf->cur_func, mark_func);
JS_MarkValue(rt, s->this_val, mark_func);
if (sf->cur_sp) {
/* if the function is running, cur_sp is not known so we
cannot mark the stack. Marking the variables is not needed
because a running function cannot be part of a removable
cycle */
for(sp = sf->arg_buf; sp < sf->cur_sp; sp++)
JS_MarkValue(rt, *sp, mark_func);
}
} | O2 | c | async_func_mark:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0xfffffffe, %r12d # imm = 0xFFFFFFFE
movl 0x28(%rsi), %eax
andl $-0x2, %eax
cmpl %r12d, %eax
jne 0x3438a
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq *%rbx
movl 0x8(%r14), %eax
andl $-0x2, %eax
cmpl %r12d, %eax
jne 0x3439e
movq (%r14), %rsi
movq %r15, %rdi
callq *%rbx
movq 0x60(%r14), %rax
testq %rax, %rax
je 0x343cf
movq 0x30(%r14), %r13
cmpq %rax, %r13
jae 0x343cf
movl 0x8(%r13), %ecx
andl $-0x2, %ecx
cmpl %r12d, %ecx
jne 0x343c9
movq (%r13), %rsi
movq %r15, %rdi
callq *%rbx
movq 0x60(%r14), %rax
addq $0x10, %r13
jmp 0x343ab
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| async_func_mark:
push r15
push r14
push r13
push r12
push rbx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov r12d, 0FFFFFFFEh
mov eax, [rsi+28h]
and eax, 0FFFFFFFEh
cmp eax, r12d
jnz short loc_3438A
mov rsi, [r14+20h]
mov rdi, r15
call rbx
loc_3438A:
mov eax, [r14+8]
and eax, 0FFFFFFFEh
cmp eax, r12d
jnz short loc_3439E
mov rsi, [r14]
mov rdi, r15
call rbx
loc_3439E:
mov rax, [r14+60h]
test rax, rax
jz short loc_343CF
mov r13, [r14+30h]
loc_343AB:
cmp r13, rax
jnb short loc_343CF
mov ecx, [r13+8]
and ecx, 0FFFFFFFEh
cmp ecx, r12d
jnz short loc_343C9
mov rsi, [r13+0]
mov rdi, r15
call rbx
mov rax, [r14+60h]
loc_343C9:
add r13, 10h
jmp short loc_343AB
loc_343CF:
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| unsigned long long async_func_mark(long long a1, long long a2, void ( *a3)(long long, _QWORD))
{
unsigned long long result; // rax
unsigned long long i; // r13
if ( (*(_DWORD *)(a2 + 40) & 0xFFFFFFFE) == 0xFFFFFFFE )
a3(a1, *(_QWORD *)(a2 + 32));
if ( (*(_DWORD *)(a2 + 8) & 0xFFFFFFFE) == 0xFFFFFFFE )
a3(a1, *(_QWORD *)a2);
result = *(_QWORD *)(a2 + 96);
if ( result )
{
for ( i = *(_QWORD *)(a2 + 48); i < result; i += 16LL )
{
if ( (*(_DWORD *)(i + 8) & 0xFFFFFFFE) == 0xFFFFFFFE )
{
a3(a1, *(_QWORD *)i);
result = *(_QWORD *)(a2 + 96);
}
}
}
return result;
}
| async_func_mark:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV R12D,0xfffffffe
MOV EAX,dword ptr [RSI + 0x28]
AND EAX,0xfffffffe
CMP EAX,R12D
JNZ 0x0013438a
MOV RSI,qword ptr [R14 + 0x20]
MOV RDI,R15
CALL RBX
LAB_0013438a:
MOV EAX,dword ptr [R14 + 0x8]
AND EAX,0xfffffffe
CMP EAX,R12D
JNZ 0x0013439e
MOV RSI,qword ptr [R14]
MOV RDI,R15
CALL RBX
LAB_0013439e:
MOV RAX,qword ptr [R14 + 0x60]
TEST RAX,RAX
JZ 0x001343cf
MOV R13,qword ptr [R14 + 0x30]
LAB_001343ab:
CMP R13,RAX
JNC 0x001343cf
MOV ECX,dword ptr [R13 + 0x8]
AND ECX,0xfffffffe
CMP ECX,R12D
JNZ 0x001343c9
MOV RSI,qword ptr [R13]
MOV RDI,R15
CALL RBX
MOV RAX,qword ptr [R14 + 0x60]
LAB_001343c9:
ADD R13,0x10
JMP 0x001343ab
LAB_001343cf:
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
void async_func_mark(int8 param_1,int8 *param_2,code *param_3)
{
int8 *puVar1;
int8 *puVar2;
if ((*(uint *)(param_2 + 5) & 0xfffffffe) == 0xfffffffe) {
(*param_3)(param_1,param_2[4]);
}
if ((*(uint *)(param_2 + 1) & 0xfffffffe) == 0xfffffffe) {
(*param_3)(param_1,*param_2);
}
puVar1 = (int8 *)param_2[0xc];
if (puVar1 != (int8 *)0x0) {
for (puVar2 = (int8 *)param_2[6]; puVar2 < puVar1; puVar2 = puVar2 + 2) {
if ((*(uint *)(puVar2 + 1) & 0xfffffffe) == 0xfffffffe) {
(*param_3)(param_1,*puVar2);
puVar1 = (int8 *)param_2[0xc];
}
}
}
return;
}
| |
25,039 | check_mb_euckr | eloqsql/libmariadb/libmariadb/ma_charset.c | static unsigned int check_mb_euckr(const char *start, const char *end)
{
if (end - start <= 1) {
return 0; /* invalid length */
}
if (*(uchar *)start < 0x80) {
return 0; /* invalid euckr character */
}
if (valid_euckr(start[1])) {
return 2;
}
return 0;
} | O0 | c | check_mb_euckr:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0x1, %rax
jg 0x47486
movl $0x0, -0x4(%rbp)
jmp 0x474cd
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x80, %eax
jge 0x4749d
movl $0x0, -0x4(%rbp)
jmp 0x474cd
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %ecx
movl $0xa1, %eax
cmpl %ecx, %eax
jg 0x474c6
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xfe, %eax
jg 0x474c6
movl $0x2, -0x4(%rbp)
jmp 0x474cd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| check_mb_euckr:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
sub rax, rcx
cmp rax, 1
jg short loc_47486
mov [rbp+var_4], 0
jmp short loc_474CD
loc_47486:
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
cmp eax, 80h
jge short loc_4749D
mov [rbp+var_4], 0
jmp short loc_474CD
loc_4749D:
mov rax, [rbp+var_10]
movzx ecx, byte ptr [rax+1]
mov eax, 0A1h
cmp eax, ecx
jg short loc_474C6
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+1]
cmp eax, 0FEh
jg short loc_474C6
mov [rbp+var_4], 2
jmp short loc_474CD
loc_474C6:
mov [rbp+var_4], 0
loc_474CD:
mov eax, [rbp+var_4]
pop rbp
retn
| long long check_mb_euckr(unsigned __int8 *a1, long long a2)
{
if ( a2 - (long long)a1 > 1 )
{
if ( *a1 >= 0x80u )
{
if ( a1[1] < 0xA1u || a1[1] == 255 )
return 0;
else
return 2;
}
else
{
return 0;
}
}
else
{
return 0;
}
}
| check_mb_euckr:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,RCX
CMP RAX,0x1
JG 0x00147486
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001474cd
LAB_00147486:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x80
JGE 0x0014749d
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001474cd
LAB_0014749d:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RAX + 0x1]
MOV EAX,0xa1
CMP EAX,ECX
JG 0x001474c6
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xfe
JG 0x001474c6
MOV dword ptr [RBP + -0x4],0x2
JMP 0x001474cd
LAB_001474c6:
MOV dword ptr [RBP + -0x4],0x0
LAB_001474cd:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 check_mb_euckr(byte *param_1,long param_2)
{
int4 local_c;
if (param_2 - (long)param_1 < 2) {
local_c = 0;
}
else if (*param_1 < 0x80) {
local_c = 0;
}
else if ((param_1[1] < 0xa1) || (0xfe < param_1[1])) {
local_c = 0;
}
else {
local_c = 2;
}
return local_c;
}
| |
25,040 | my_reverse_bits(unsigned int) | eloqsql/include/my_bit.h | static inline uint32 my_reverse_bits(uint32 key)
{
return
((uint32)_my_bits_reverse_table[ key & 255] << 24) |
((uint32)_my_bits_reverse_table[(key>> 8) & 255] << 16) |
((uint32)_my_bits_reverse_table[(key>>16) & 255] << 8) |
(uint32)_my_bits_reverse_table[(key>>24) ];
} | O0 | c | my_reverse_bits(unsigned int):
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0xff, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x57936(%rip), %rax # 0xb69d0
movzbl (%rax,%rcx), %eax
shll $0x18, %eax
movl -0x4(%rbp), %ecx
shrl $0x8, %ecx
andl $0xff, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x57918(%rip), %rcx # 0xb69d0
movzbl (%rcx,%rdx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
shrl $0x10, %ecx
andl $0xff, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x578f8(%rip), %rcx # 0xb69d0
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
shrl $0x18, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x578de(%rip), %rcx # 0xb69d0
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
popq %rbp
retq
nopw (%rax,%rax)
| _ZL15my_reverse_bitsj:
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
and eax, 0FFh
mov eax, eax
mov ecx, eax
lea rax, _my_bits_reverse_table
movzx eax, byte ptr [rax+rcx]
shl eax, 18h
mov ecx, [rbp+var_4]
shr ecx, 8
and ecx, 0FFh
mov ecx, ecx
mov edx, ecx
lea rcx, _my_bits_reverse_table
movzx ecx, byte ptr [rcx+rdx]
shl ecx, 10h
or eax, ecx
mov ecx, [rbp+var_4]
shr ecx, 10h
and ecx, 0FFh
mov ecx, ecx
mov edx, ecx
lea rcx, _my_bits_reverse_table
movzx ecx, byte ptr [rcx+rdx]
shl ecx, 8
or eax, ecx
mov ecx, [rbp+var_4]
shr ecx, 18h
mov ecx, ecx
mov edx, ecx
lea rcx, _my_bits_reverse_table
movzx ecx, byte ptr [rcx+rdx]
or eax, ecx
pop rbp
retn
| long long my_reverse_bits(unsigned int a1)
{
return my_bits_reverse_table[HIBYTE(a1)] | (my_bits_reverse_table[BYTE2(a1)] << 8) | (my_bits_reverse_table[BYTE1(a1)] << 16) | (my_bits_reverse_table[(unsigned __int8)a1] << 24);
}
| my_reverse_bits:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0xff
MOV EAX,EAX
MOV ECX,EAX
LEA RAX,[0x1b69d0]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
SHL EAX,0x18
MOV ECX,dword ptr [RBP + -0x4]
SHR ECX,0x8
AND ECX,0xff
MOV ECX,ECX
MOV EDX,ECX
LEA RCX,[0x1b69d0]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
SHL ECX,0x10
OR EAX,ECX
MOV ECX,dword ptr [RBP + -0x4]
SHR ECX,0x10
AND ECX,0xff
MOV ECX,ECX
MOV EDX,ECX
LEA RCX,[0x1b69d0]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
SHL ECX,0x8
OR EAX,ECX
MOV ECX,dword ptr [RBP + -0x4]
SHR ECX,0x18
MOV ECX,ECX
MOV EDX,ECX
LEA RCX,[0x1b69d0]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
OR EAX,ECX
POP RBP
RET
|
/* my_reverse_bits(unsigned int) */
uint my_reverse_bits(uint param_1)
{
return (uint)(byte)_my_bits_reverse_table[param_1 & 0xff] << 0x18 |
(uint)(byte)_my_bits_reverse_table[param_1 >> 8 & 0xff] << 0x10 |
(uint)(byte)_my_bits_reverse_table[param_1 >> 0x10 & 0xff] << 8 |
(uint)(byte)_my_bits_reverse_table[param_1 >> 0x18];
}
| |
25,041 | my_charpos_mb | eloqsql/strings/ctype-mb.c | size_t my_charpos_mb(CHARSET_INFO *cs __attribute__((unused)),
const char *pos, const char *end, size_t length)
{
const char *start= pos;
while (length && pos < end)
{
uint mb_len;
pos+= (mb_len= my_ismbchar(cs, pos, end)) ? mb_len : 1;
length--;
}
return (size_t) (length ? end+2-start : pos-start);
} | O3 | c | my_charpos_mb:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbx
testq %rcx, %rcx
setne %cl
sete %al
cmpq %rdx, %rsi
setae %dl
orb %al, %dl
movq %rsi, -0x30(%rbp)
movq %rsi, %rax
jne 0x3b2ae
movq %rdi, %r12
decq %r15
movl $0x1, %r14d
movq -0x30(%rbp), %rax
movq %rax, %r13
movq 0xb8(%r12), %rax
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq *0xc0(%rax)
cmpl $0x2, %eax
cmovbl %r14d, %eax
cmovll %r14d, %eax
addq %r13, %rax
addq $-0x1, %r15
setb %cl
jae 0x3b2ae
cmpq %rbx, %rax
jb 0x3b278
addq $0x2, %rbx
testb %cl, %cl
cmoveq %rax, %rbx
subq -0x30(%rbp), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_charpos_mb:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rcx
mov rbx, rdx
test rcx, rcx
setnz cl
setz al
cmp rsi, rdx
setnb dl
or dl, al
mov [rbp+var_30], rsi
mov rax, rsi
jnz short loc_3B2AE
mov r12, rdi
dec r15
mov r14d, 1
mov rax, [rbp+var_30]
loc_3B278:
mov r13, rax
mov rax, [r12+0B8h]
mov rdi, r12
mov rsi, r13
mov rdx, rbx
call qword ptr [rax+0C0h]
cmp eax, 2
cmovb eax, r14d
cmovl eax, r14d
add rax, r13
add r15, 0FFFFFFFFFFFFFFFFh
setb cl
jnb short loc_3B2AE
cmp rax, rbx
jb short loc_3B278
loc_3B2AE:
add rbx, 2
test cl, cl
cmovz rbx, rax
sub rbx, [rbp+var_30]
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long my_charpos_mb(long long a1, unsigned long long a2, unsigned long long a3, long long a4)
{
long long v4; // r15
bool v6; // zf
unsigned long long v7; // rax
long long v8; // r15
unsigned long long v9; // r13
long long v10; // rax
bool v11; // cc
bool v12; // cf
unsigned long long v13; // rbx
v4 = a4;
v6 = a4 == 0;
LOBYTE(a4) = a4 != 0;
v7 = a2;
if ( !v6 && a2 < a3 )
{
v8 = v4 - 1;
v7 = a2;
do
{
v9 = v7;
v10 = (*(long long ( **)(long long, unsigned long long, unsigned long long, long long))(*(_QWORD *)(a1 + 184)
+ 192LL))(
a1,
v7,
a3,
a4);
v11 = (int)v10 < 2;
if ( (unsigned int)v10 < 2 )
v10 = 1LL;
if ( v11 )
v10 = 1LL;
v7 = v9 + v10;
v12 = v8-- != 0;
LOBYTE(a4) = v12;
}
while ( v12 && v7 < a3 );
}
v13 = a3 + 2;
if ( !(_BYTE)a4 )
v13 = v7;
return v13 - a2;
}
| my_charpos_mb:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RCX
MOV RBX,RDX
TEST RCX,RCX
SETNZ CL
SETZ AL
CMP RSI,RDX
SETNC DL
OR DL,AL
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,RSI
JNZ 0x0013b2ae
MOV R12,RDI
DEC R15
MOV R14D,0x1
MOV RAX,qword ptr [RBP + -0x30]
LAB_0013b278:
MOV R13,RAX
MOV RAX,qword ptr [R12 + 0xb8]
MOV RDI,R12
MOV RSI,R13
MOV RDX,RBX
CALL qword ptr [RAX + 0xc0]
CMP EAX,0x2
CMOVC EAX,R14D
CMOVL EAX,R14D
ADD RAX,R13
ADD R15,-0x1
SETC CL
JNC 0x0013b2ae
CMP RAX,RBX
JC 0x0013b278
LAB_0013b2ae:
ADD RBX,0x2
TEST CL,CL
CMOVZ RBX,RAX
SUB RBX,qword ptr [RBP + -0x30]
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_charpos_mb(long param_1,ulong param_2,ulong param_3,long param_4)
{
uint uVar1;
ulong uVar2;
ulong uVar3;
bool bVar4;
bVar4 = param_4 != 0;
uVar3 = param_2;
if (param_2 < param_3 && bVar4) {
do {
param_4 = param_4 + -1;
uVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))(param_1,uVar3,param_3);
uVar2 = (ulong)uVar1;
if (uVar1 < 2) {
uVar2 = 1;
}
if ((int)uVar1 < 2) {
uVar2 = 1;
}
uVar3 = uVar2 + uVar3;
bVar4 = param_4 != 0;
} while ((bVar4) && (uVar3 < param_3));
}
uVar2 = param_3 + 2;
if (!bVar4) {
uVar2 = uVar3;
}
return uVar2 - param_2;
}
| |
25,042 | ma_scan_init_block_record | eloqsql/storage/maria/ma_blockrec.c | my_bool _ma_scan_init_block_record(MARIA_HA *info)
{
MARIA_SHARE *share= info->s;
myf flag= MY_WME | (share->temporary ? MY_THREAD_SPECIFIC : 0);
DBUG_ENTER("_ma_scan_init_block_record");
DBUG_ASSERT(info->dfile.file == share->bitmap.file.file);
/*
bitmap_buff may already be allocated if this is the second call to
rnd_init() without a rnd_end() in between, see sql/handler.h
*/
if (!(info->scan.bitmap_buff ||
((info->scan.bitmap_buff=
(uchar *) my_malloc(PSI_INSTRUMENT_ME, share->block_size * 2,
flag)))))
DBUG_RETURN(1);
info->scan.page_buff= info->scan.bitmap_buff + share->block_size;
info->scan.bitmap_end= info->scan.bitmap_buff + share->bitmap.max_total_size;
/* Set scan variables to get _ma_scan_block() to start with reading bitmap */
info->scan.number_of_rows= 0;
info->scan.bitmap_pos= info->scan.bitmap_end;
info->scan.bitmap_page= (pgcache_page_no_t) 0 - share->bitmap.pages_covered;
info->scan.max_page= share->state.state.data_file_length / share->block_size;
/*
We need to flush what's in memory (bitmap.map) to page cache otherwise, as
we are going to read bitmaps from page cache in table scan (see
_ma_scan_block_record()), we may miss recently inserted rows (bitmap page
in page cache would be too old).
*/
DBUG_RETURN(_ma_bitmap_flush(info->s));
} | O0 | c | ma_scan_init_block_record:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl 0x7d9(%rax), %edx
xorl %eax, %eax
movl $0x10000, %ecx # imm = 0x10000
cmpl $0x0, %edx
cmovnel %ecx, %eax
orl $0x10, %eax
movl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x77f9a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x220(%rax)
jne 0x77fdf
movq -0x18(%rbp), %rax
movl 0x7bc(%rax), %eax
shll %eax
movl %eax, %eax
movl %eax, %esi
movq -0x20(%rbp), %rdx
xorl %edi, %edi
callq 0xf2e30
movq -0x10(%rbp), %rcx
movq %rax, 0x220(%rcx)
cmpq $0x0, %rax
jne 0x77fdf
jmp 0x77fd6
movb $0x1, -0x1(%rbp)
jmp 0x78095
movq -0x10(%rbp), %rax
movq 0x220(%rax), %rcx
movq -0x18(%rbp), %rax
movl 0x7bc(%rax), %eax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x238(%rax)
movq -0x10(%rbp), %rax
movq 0x220(%rax), %rcx
movq -0x18(%rbp), %rax
movl 0xb3c(%rax), %eax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x230(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x268(%rax)
movq -0x10(%rbp), %rax
movq 0x230(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x228(%rax)
movq -0x18(%rbp), %rax
xorl %ecx, %ecx
subq 0xb48(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x250(%rax)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
movl 0x7bc(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x258(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3cb70
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nop
| _ma_scan_init_block_record:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
movsx edx, byte ptr [rax+7D9h]
xor eax, eax
mov ecx, offset stru_10000
cmp edx, 0
cmovnz eax, ecx
or eax, 10h
mov eax, eax
mov [rbp+var_20], rax
jmp short $+2
loc_77F9A:
mov rax, [rbp+var_10]
cmp qword ptr [rax+220h], 0
jnz short loc_77FDF
mov rax, [rbp+var_18]
mov eax, [rax+7BCh]
shl eax, 1
mov eax, eax
mov esi, eax
mov rdx, [rbp+var_20]
xor edi, edi
call my_malloc
mov rcx, [rbp+var_10]
mov [rcx+220h], rax
cmp rax, 0
jnz short loc_77FDF
jmp short $+2
loc_77FD6:
mov [rbp+var_1], 1
jmp loc_78095
loc_77FDF:
mov rax, [rbp+var_10]
mov rcx, [rax+220h]
mov rax, [rbp+var_18]
mov eax, [rax+7BCh]
add rcx, rax
mov rax, [rbp+var_10]
mov [rax+238h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+220h]
mov rax, [rbp+var_18]
mov eax, [rax+0B3Ch]
add rcx, rax
mov rax, [rbp+var_10]
mov [rax+230h], rcx
mov rax, [rbp+var_10]
mov dword ptr [rax+268h], 0
mov rax, [rbp+var_10]
mov rcx, [rax+230h]
mov rax, [rbp+var_10]
mov [rax+228h], rcx
mov rax, [rbp+var_18]
xor ecx, ecx
sub rcx, [rax+0B48h]
mov rax, [rbp+var_10]
mov [rax+250h], rcx
mov rax, [rbp+var_18]
mov rax, [rax+40h]
mov rcx, [rbp+var_18]
mov ecx, [rcx+7BCh]
xor edx, edx
div rcx
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+258h], rcx
mov rax, [rbp+var_10]
mov rdi, [rax]
call _ma_bitmap_flush
mov [rbp+var_1], al
loc_78095:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char ma_scan_init_block_record(long long *a1)
{
unsigned int v1; // eax
long long v2; // rax
long long v4; // [rsp+8h] [rbp-18h]
v4 = *a1;
v1 = 0;
if ( *(_BYTE *)(*a1 + 2009) )
v1 = (unsigned int)&stru_10000;
if ( !a1[68] )
{
v2 = my_malloc(0LL, (unsigned int)(2 * *(_DWORD *)(v4 + 1980)), v1 | 0x10);
a1[68] = v2;
if ( !v2 )
return 1;
}
a1[71] = *(unsigned int *)(v4 + 1980) + a1[68];
a1[70] = *(unsigned int *)(v4 + 2876) + a1[68];
*((_DWORD *)a1 + 154) = 0;
a1[69] = a1[70];
a1[74] = -*(_QWORD *)(v4 + 2888);
a1[75] = *(_QWORD *)(v4 + 64) / (unsigned long long)*(unsigned int *)(v4 + 1980);
return ma_bitmap_flush(*a1);
}
| _ma_scan_init_block_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVSX EDX,byte ptr [RAX + 0x7d9]
XOR EAX,EAX
MOV ECX,0x10000
CMP EDX,0x0
CMOVNZ EAX,ECX
OR EAX,0x10
MOV EAX,EAX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00177f9a
LAB_00177f9a:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x220],0x0
JNZ 0x00177fdf
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x7bc]
SHL EAX,0x1
MOV EAX,EAX
MOV ESI,EAX
MOV RDX,qword ptr [RBP + -0x20]
XOR EDI,EDI
CALL 0x001f2e30
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x220],RAX
CMP RAX,0x0
JNZ 0x00177fdf
JMP 0x00177fd6
LAB_00177fd6:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00178095
LAB_00177fdf:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x220]
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x7bc]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x238],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x220]
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0xb3c]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x230],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x268],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x230]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x228],RCX
MOV RAX,qword ptr [RBP + -0x18]
XOR ECX,ECX
SUB RCX,qword ptr [RAX + 0xb48]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x250],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RCX + 0x7bc]
XOR EDX,EDX
DIV RCX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x258],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x0013cb70
MOV byte ptr [RBP + -0x1],AL
LAB_00178095:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 _ma_scan_init_block_record(long *param_1)
{
long lVar1;
int1 uVar2;
uint uVar3;
long lVar4;
lVar1 = *param_1;
uVar3 = 0;
if (*(char *)(lVar1 + 0x7d9) != '\0') {
uVar3 = 0x10000;
}
if (param_1[0x44] == 0) {
lVar4 = my_malloc(0,*(int *)(lVar1 + 0x7bc) << 1,uVar3 | 0x10);
param_1[0x44] = lVar4;
if (lVar4 == 0) {
return 1;
}
}
param_1[0x47] = param_1[0x44] + (ulong)*(uint *)(lVar1 + 0x7bc);
param_1[0x46] = param_1[0x44] + (ulong)*(uint *)(lVar1 + 0xb3c);
*(int4 *)(param_1 + 0x4d) = 0;
param_1[0x45] = param_1[0x46];
param_1[0x4a] = -*(long *)(lVar1 + 0xb48);
param_1[0x4b] = *(ulong *)(lVar1 + 0x40) / (ulong)*(uint *)(lVar1 + 0x7bc);
uVar2 = _ma_bitmap_flush(*param_1);
return uVar2;
}
| |
25,043 | ma_scan_init_block_record | eloqsql/storage/maria/ma_blockrec.c | my_bool _ma_scan_init_block_record(MARIA_HA *info)
{
MARIA_SHARE *share= info->s;
myf flag= MY_WME | (share->temporary ? MY_THREAD_SPECIFIC : 0);
DBUG_ENTER("_ma_scan_init_block_record");
DBUG_ASSERT(info->dfile.file == share->bitmap.file.file);
/*
bitmap_buff may already be allocated if this is the second call to
rnd_init() without a rnd_end() in between, see sql/handler.h
*/
if (!(info->scan.bitmap_buff ||
((info->scan.bitmap_buff=
(uchar *) my_malloc(PSI_INSTRUMENT_ME, share->block_size * 2,
flag)))))
DBUG_RETURN(1);
info->scan.page_buff= info->scan.bitmap_buff + share->block_size;
info->scan.bitmap_end= info->scan.bitmap_buff + share->bitmap.max_total_size;
/* Set scan variables to get _ma_scan_block() to start with reading bitmap */
info->scan.number_of_rows= 0;
info->scan.bitmap_pos= info->scan.bitmap_end;
info->scan.bitmap_page= (pgcache_page_no_t) 0 - share->bitmap.pages_covered;
info->scan.max_page= share->state.state.data_file_length / share->block_size;
/*
We need to flush what's in memory (bitmap.map) to page cache otherwise, as
we are going to read bitmaps from page cache in table scan (see
_ma_scan_block_record()), we may miss recently inserted rows (bitmap page
in page cache would be too old).
*/
DBUG_RETURN(_ma_bitmap_flush(info->s));
} | O3 | c | ma_scan_init_block_record:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x220(%rdi), %rax
movq %r14, %rdi
testq %rax, %rax
jne 0x5e0bd
xorl %edx, %edx
cmpb $0x0, 0x7d9(%r14)
setne %dl
shll $0x10, %edx
orq $0x10, %rdx
movl 0x7bc(%r14), %esi
addl %esi, %esi
xorl %edi, %edi
callq 0x9f6e1
movq %rax, 0x220(%rbx)
testq %rax, %rax
je 0x5e120
movq (%rbx), %rdi
movl 0x7bc(%r14), %ecx
addq %rax, %rcx
movq %rcx, 0x238(%rbx)
movl 0xb3c(%r14), %ecx
addq %rax, %rcx
movq %rcx, 0x230(%rbx)
movl $0x0, 0x268(%rbx)
movq %rcx, 0x228(%rbx)
xorl %eax, %eax
subq 0xb48(%r14), %rax
movq %rax, 0x250(%rbx)
movq 0x40(%r14), %rax
movl 0x7bc(%r14), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, 0x258(%rbx)
popq %rbx
popq %r14
popq %rbp
jmp 0x3bbdd
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
| _ma_scan_init_block_record:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
mov r14, [rdi]
mov rax, [rdi+220h]
mov rdi, r14
test rax, rax
jnz short loc_5E0BD
xor edx, edx
cmp byte ptr [r14+7D9h], 0
setnz dl
shl edx, 10h
or rdx, 10h
mov esi, [r14+7BCh]
add esi, esi
xor edi, edi
call my_malloc
mov [rbx+220h], rax
test rax, rax
jz short loc_5E120
mov rdi, [rbx]
loc_5E0BD:
mov ecx, [r14+7BCh]
add rcx, rax
mov [rbx+238h], rcx
mov ecx, [r14+0B3Ch]
add rcx, rax
mov [rbx+230h], rcx
mov dword ptr [rbx+268h], 0
mov [rbx+228h], rcx
xor eax, eax
sub rax, [r14+0B48h]
mov [rbx+250h], rax
mov rax, [r14+40h]
mov ecx, [r14+7BCh]
xor edx, edx
div rcx
mov [rbx+258h], rax
pop rbx
pop r14
pop rbp
jmp _ma_bitmap_flush
loc_5E120:
mov al, 1
pop rbx
pop r14
pop rbp
retn
| long long ma_scan_init_block_record(long long a1)
{
long long v2; // r14
long long v3; // rax
long long v4; // rdi
long long v5; // rcx
v2 = *(_QWORD *)a1;
v3 = *(_QWORD *)(a1 + 544);
v4 = *(_QWORD *)a1;
if ( v3 )
goto LABEL_4;
v3 = my_malloc(
0LL,
(unsigned int)(2 * *(_DWORD *)(v2 + 1980)),
((unsigned __int8)(*(_BYTE *)(v2 + 2009) != 0) << 16) | 0x10LL);
*(_QWORD *)(a1 + 544) = v3;
if ( v3 )
{
v4 = *(_QWORD *)a1;
LABEL_4:
*(_QWORD *)(a1 + 568) = v3 + *(unsigned int *)(v2 + 1980);
v5 = v3 + *(unsigned int *)(v2 + 2876);
*(_QWORD *)(a1 + 560) = v5;
*(_DWORD *)(a1 + 616) = 0;
*(_QWORD *)(a1 + 552) = v5;
*(_QWORD *)(a1 + 592) = -*(_QWORD *)(v2 + 2888);
*(_QWORD *)(a1 + 600) = *(_QWORD *)(v2 + 64) / (unsigned long long)*(unsigned int *)(v2 + 1980);
return ma_bitmap_flush(v4);
}
return 1LL;
}
| _ma_scan_init_block_record:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV R14,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x220]
MOV RDI,R14
TEST RAX,RAX
JNZ 0x0015e0bd
XOR EDX,EDX
CMP byte ptr [R14 + 0x7d9],0x0
SETNZ DL
SHL EDX,0x10
OR RDX,0x10
MOV ESI,dword ptr [R14 + 0x7bc]
ADD ESI,ESI
XOR EDI,EDI
CALL 0x0019f6e1
MOV qword ptr [RBX + 0x220],RAX
TEST RAX,RAX
JZ 0x0015e120
MOV RDI,qword ptr [RBX]
LAB_0015e0bd:
MOV ECX,dword ptr [R14 + 0x7bc]
ADD RCX,RAX
MOV qword ptr [RBX + 0x238],RCX
MOV ECX,dword ptr [R14 + 0xb3c]
ADD RCX,RAX
MOV qword ptr [RBX + 0x230],RCX
MOV dword ptr [RBX + 0x268],0x0
MOV qword ptr [RBX + 0x228],RCX
XOR EAX,EAX
SUB RAX,qword ptr [R14 + 0xb48]
MOV qword ptr [RBX + 0x250],RAX
MOV RAX,qword ptr [R14 + 0x40]
MOV ECX,dword ptr [R14 + 0x7bc]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBX + 0x258],RAX
POP RBX
POP R14
POP RBP
JMP 0x0013bbdd
LAB_0015e120:
MOV AL,0x1
POP RBX
POP R14
POP RBP
RET
|
int8 _ma_scan_init_block_record(long *param_1)
{
long lVar1;
long lVar2;
int8 uVar3;
long lVar4;
lVar1 = *param_1;
lVar2 = param_1[0x44];
lVar4 = lVar1;
if (lVar2 == 0) {
lVar2 = my_malloc(0,*(int *)(lVar1 + 0x7bc) * 2,
(ulong)(*(char *)(lVar1 + 0x7d9) != '\0') << 0x10 | 0x10);
param_1[0x44] = lVar2;
if (lVar2 == 0) {
return 1;
}
lVar4 = *param_1;
}
param_1[0x47] = (ulong)*(uint *)(lVar1 + 0x7bc) + lVar2;
lVar2 = (ulong)*(uint *)(lVar1 + 0xb3c) + lVar2;
param_1[0x46] = lVar2;
*(int4 *)(param_1 + 0x4d) = 0;
param_1[0x45] = lVar2;
param_1[0x4a] = -*(long *)(lVar1 + 0xb48);
param_1[0x4b] = *(ulong *)(lVar1 + 0x40) / (ulong)*(uint *)(lVar1 + 0x7bc);
uVar3 = _ma_bitmap_flush(lVar4);
return uVar3;
}
| |
25,044 | 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&) | monkey531[P]llama/common/json.hpp | static diyfp mul(const diyfp& x, const diyfp& y) noexcept
{
static_assert(kPrecision == 64, "internal error");
// Computes:
// f = round((x.f * y.f) / 2^q)
// e = x.e + y.e + q
// Emulate the 64-bit * 64-bit multiplication:
//
// p = u * v
// = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
// = (u_lo v_lo ) + 2^32 ((u_lo v_hi ) + (u_hi v_lo )) + 2^64 (u_hi v_hi )
// = (p0 ) + 2^32 ((p1 ) + (p2 )) + 2^64 (p3 )
// = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3 )
// = (p0_lo ) + 2^32 (p0_hi + p1_lo + p2_lo ) + 2^64 (p1_hi + p2_hi + p3)
// = (p0_lo ) + 2^32 (Q ) + 2^64 (H )
// = (p0_lo ) + 2^32 (Q_lo + 2^32 Q_hi ) + 2^64 (H )
//
// (Since Q might be larger than 2^32 - 1)
//
// = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
//
// (Q_hi + H does not overflow a 64-bit int)
//
// = p_lo + 2^64 p_hi
const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
const std::uint64_t u_hi = x.f >> 32u;
const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
const std::uint64_t v_hi = y.f >> 32u;
const std::uint64_t p0 = u_lo * v_lo;
const std::uint64_t p1 = u_lo * v_hi;
const std::uint64_t p2 = u_hi * v_lo;
const std::uint64_t p3 = u_hi * v_hi;
const std::uint64_t p0_hi = p0 >> 32u;
const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
const std::uint64_t p1_hi = p1 >> 32u;
const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
const std::uint64_t p2_hi = p2 >> 32u;
std::uint64_t Q = p0_hi + p1_lo + p2_lo;
// The full product might now be computed as
//
// p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
// p_lo = p0_lo + (Q << 32)
//
// But in this particular case here, the full p_lo is not required.
// Effectively we only need to add the highest bit in p_lo to p_hi (and
// Q_hi + 1 does not overflow).
Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up
const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
return {h, x.e + y.e + 64};
} | O3 | cpp | 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&):
movq (%rdi), %rax
movl %eax, %ecx
shrq $0x20, %rax
movq (%rsi), %r8
movl %r8d, %edx
shrq $0x20, %r8
movq %rdx, %r9
imulq %rcx, %r9
imulq %r8, %rcx
imulq %rax, %rdx
imulq %rax, %r8
shrq $0x20, %r9
movl %ecx, %r10d
addq %r9, %r10
shrq $0x20, %rcx
movl %edx, %eax
addq %r10, %rax
shrq $0x20, %rdx
addq %r8, %rdx
addq %rcx, %rdx
subq $-0x80000000, %rax # imm = 0x80000000
shrq $0x20, %rax
addq %rdx, %rax
movl 0x8(%rdi), %ecx
movl 0x8(%rsi), %edx
addl %ecx, %edx
addl $0x40, %edx
retq
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3mulERKS3_S5_:
mov rax, [rdi]
mov ecx, eax
shr rax, 20h
mov r8, [rsi]
mov edx, r8d
shr r8, 20h
mov r9, rdx
imul r9, rcx
imul rcx, r8
imul rdx, rax
imul r8, rax
shr r9, 20h
mov r10d, ecx
add r10, r9
shr rcx, 20h
mov eax, edx
add rax, r10
shr rdx, 20h
add rdx, r8
add rdx, rcx
sub rax, 0FFFFFFFF80000000h
shr rax, 20h
add rax, rdx
mov ecx, [rdi+8]
mov edx, [rsi+8]
add edx, ecx
add edx, 40h ; '@'
retn
| unsigned long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(_QWORD *a1, _QWORD *a2)
{
long long v2; // rcx
v2 = (unsigned int)*a1;
return ((unsigned long long)(HIDWORD(*a2) * v2) >> 32)
+ HIDWORD(*a1) * HIDWORD(*a2)
+ ((HIDWORD(*a1) * (unsigned long long)(unsigned int)*a2) >> 32)
+ ((((v2 * (unsigned long long)(unsigned int)*a2) >> 32)
+ (unsigned int)(HIDWORD(*a2) * v2)
+ (unsigned int)(HIDWORD(*a1) * *a2)
+ 0x80000000) >> 32);
}
| mul:
MOV RAX,qword ptr [RDI]
MOV ECX,EAX
SHR RAX,0x20
MOV R8,qword ptr [RSI]
MOV EDX,R8D
SHR R8,0x20
MOV R9,RDX
IMUL R9,RCX
IMUL RCX,R8
IMUL RDX,RAX
IMUL R8,RAX
SHR R9,0x20
MOV R10D,ECX
ADD R10,R9
SHR RCX,0x20
MOV EAX,EDX
ADD RAX,R10
SHR RDX,0x20
ADD RDX,R8
ADD RDX,RCX
SUB RAX,-0x80000000
SHR RAX,0x20
ADD RAX,RDX
MOV ECX,dword ptr [RDI + 0x8]
MOV EDX,dword ptr [RSI + 0x8]
ADD EDX,ECX
ADD EDX,0x40
RET
|
/* 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&) */
int1 [16]
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(diyfp *param_1,diyfp *param_2)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
ulong uVar6;
int1 auVar7 [16];
uVar2 = *(ulong *)param_1 & 0xffffffff;
uVar1 = *(ulong *)param_1 >> 0x20;
uVar4 = *(ulong *)param_2 & 0xffffffff;
uVar6 = *(ulong *)param_2 >> 0x20;
uVar3 = uVar2 * uVar6;
uVar5 = uVar4 * uVar1;
auVar7._0_8_ = ((uVar5 & 0xffffffff) + (uVar3 & 0xffffffff) + (uVar4 * uVar2 >> 0x20) + 0x80000000
>> 0x20) + (uVar5 >> 0x20) + uVar6 * uVar1 + (uVar3 >> 0x20);
auVar7._8_4_ = *(int *)(param_2 + 8) + *(int *)(param_1 + 8) + 0x40;
auVar7._12_4_ = 0;
return auVar7;
}
| |
25,045 | nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::erase(__gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>>, __gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>>) | llama.cpp/common/./json.hpp | iterator erase(iterator first, iterator last)
{
if (first == last)
{
return first;
}
const auto elements_affected = std::distance(first, last);
const auto offset = std::distance(Container::begin(), first);
// This is the start situation. We need to delete elements_affected
// elements (3 in this example: e, f, g), and need to return an
// iterator past the last deleted element (h in this example).
// Note that offset is the distance from the start of the vector
// to first. We will need this later.
// [ a, b, c, d, e, f, g, h, i, j ]
// ^ ^
// first last
// Since we cannot move const Keys, we re-construct them in place.
// We start at first and re-construct (viz. copy) the elements from
// the back of the vector. Example for first iteration:
// ,--------.
// v | destroy e and re-construct with h
// [ a, b, c, d, e, f, g, h, i, j ]
// ^ ^
// it it + elements_affected
for (auto it = first; std::next(it, elements_affected) != Container::end(); ++it)
{
it->~value_type(); // destroy but keep allocation
new (&*it) value_type{std::move(*std::next(it, elements_affected))}; // "move" next element to it
}
// [ a, b, c, d, h, i, j, h, i, j ]
// ^ ^
// first last
// remove the unneeded elements at the end of the vector
Container::resize(this->size() - static_cast<size_type>(elements_affected));
// [ a, b, c, d, h, i, j ]
// ^ ^
// first last
// first is now pointing past the last deleted element, but we cannot
// use this iterator, because it may have been invalidated by the
// resize call. Instead, we can return begin() + offset.
return Container::begin() + offset;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::erase(__gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>>, __gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>>):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
cmpq %rdx, %rsi
je 0x86c04
movq %rdx, %r15
movq %rdi, %r14
movq %rdx, %rax
subq %rbx, %rax
sarq $0x4, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
movq %rax, 0x10(%rsp)
movq (%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rbx), %rbp
movq %rdx, %r12
negq %r12
cmpq 0x8(%r14), %r15
je 0x86bd4
leaq 0x10(%rbp), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x4adea
movq %r13, %rdi
callq 0x4b6f6
movq -0x10(%rbp), %rdi
cmpq %rdi, %rbp
je 0x86bba
movq (%rbp), %rsi
incq %rsi
callq 0x251b0
leaq -0x10(%rbp), %rdi
movq %r15, %rsi
callq 0x86c16
addq $0x30, %r15
addq $0x30, %rbp
addq $-0x30, %r12
jmp 0x86b89
subq 0x8(%rsp), %rbx
addq (%r14), %r12
negq %r12
sarq $0x4, %r12
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r12
subq 0x10(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x86c6e
addq (%r14), %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _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_EEESP_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rsi
cmp rsi, rdx
jz loc_86C04
mov r15, rdx
mov r14, rdi
mov rax, rdx
sub rax, rbx
sar rax, 4
mov rcx, 0AAAAAAAAAAAAAAABh
imul rax, rcx
mov [rsp+48h+var_38], rax
mov rax, [rdi]
mov [rsp+48h+var_40], rax
lea rbp, [rbx+10h]
mov r12, rdx
neg r12
loc_86B89:
cmp r15, [r14+8]
jz short loc_86BD4
lea r13, [rbp+10h]
mov rdi, r13
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r13
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rbp-10h]; void *
cmp rbp, rdi
jz short loc_86BBA
mov rsi, [rbp+0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_86BBA:
lea rdi, [rbp-10h]
mov rsi, r15
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEEC2EOSG_; 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>>::pair(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>>&&)
add r15, 30h ; '0'
add rbp, 30h ; '0'
add r12, 0FFFFFFFFFFFFFFD0h
jmp short loc_86B89
loc_86BD4:
sub rbx, [rsp+48h+var_40]
add r12, [r14]
neg r12
sar r12, 4
mov rax, 0AAAAAAAAAAAAAAABh
imul r12, rax
sub r12, [rsp+48h+var_38]
mov rdi, r14
mov rsi, r12
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE6resizeEm; 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>>>::resize(ulong)
add rbx, [r14]
loc_86C04:
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::erase(
long long *a1,
long long a2,
long long a3)
{
long long v3; // rbx
long long v4; // r15
char *v6; // rbp
long long v7; // r12
char *v8; // rdi
long long v10; // [rsp+8h] [rbp-40h]
unsigned long long v11; // [rsp+10h] [rbp-38h]
v3 = a2;
if ( a2 != a3 )
{
v4 = a3;
v11 = 0xAAAAAAAAAAAAAAABLL * ((a3 - a2) >> 4);
v10 = *a1;
v6 = (char *)(a2 + 16);
v7 = -a3;
while ( v4 != a1[1] )
{
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(v6 + 16);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v6 + 16);
v8 = (char *)*((_QWORD *)v6 - 2);
if ( v6 != v8 )
operator delete(v8, *(_QWORD *)v6 + 1LL);
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>>::pair(
v6 - 16,
v4);
v4 += 48LL;
v6 += 48;
v7 -= 48LL;
}
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>>>::resize(
a1,
0xAAAAAAAAAAAAAAABLL * (-(*a1 + v7) >> 4) - v11);
return *a1 + a2 - v10;
}
return v3;
}
| erase:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RSI
CMP RSI,RDX
JZ 0x00186c04
MOV R15,RDX
MOV R14,RDI
MOV RAX,RDX
SUB RAX,RBX
SAR RAX,0x4
MOV RCX,-0x5555555555555555
IMUL RAX,RCX
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RDI]
MOV qword ptr [RSP + 0x8],RAX
LEA RBP,[RBX + 0x10]
MOV R12,RDX
NEG R12
LAB_00186b89:
CMP R15,qword ptr [R14 + 0x8]
JZ 0x00186bd4
LEA R13,[RBP + 0x10]
MOV RDI,R13
XOR ESI,ESI
CALL 0x0014adea
MOV RDI,R13
CALL 0x0014b6f6
MOV RDI,qword ptr [RBP + -0x10]
CMP RBP,RDI
JZ 0x00186bba
MOV RSI,qword ptr [RBP]
INC RSI
CALL 0x001251b0
LAB_00186bba:
LEA RDI,[RBP + -0x10]
MOV RSI,R15
CALL 0x00186c16
ADD R15,0x30
ADD RBP,0x30
ADD R12,-0x30
JMP 0x00186b89
LAB_00186bd4:
SUB RBX,qword ptr [RSP + 0x8]
ADD R12,qword ptr [R14]
NEG R12
SAR R12,0x4
MOV RAX,-0x5555555555555555
IMUL R12,RAX
SUB R12,qword ptr [RSP + 0x10]
MOV RDI,R14
MOV RSI,R12
CALL 0x00186c6e
ADD RBX,qword ptr [R14]
LAB_00186c04:
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::string,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > > >::erase(__gnu_cxx::__normal_iterator<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> >*, std::vector<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> >, 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> > > > >, __gnu_cxx::__normal_iterator<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> >*, std::vector<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> >, 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> > > > >) */
pair * __thiscall
nlohmann::json_abi_v3_11_3::
ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::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>>>>
*this,pair *param_2,pair *param_3)
{
long lVar1;
long lVar2;
pair *ppVar3;
long lVar4;
if (param_2 != param_3) {
lVar2 = (long)param_3 - (long)param_2;
lVar1 = *(long *)this;
ppVar3 = param_2 + 0x10;
lVar4 = -(long)param_3;
for (; param_3 != *(pair **)(this + 8); param_3 = param_3 + 0x30) {
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)(ppVar3 + 0x10),0));
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)(ppVar3 + 0x10));
if (ppVar3 != *(pair **)(ppVar3 + -0x10)) {
operator_delete(*(pair **)(ppVar3 + -0x10),*(long *)ppVar3 + 1);
}
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>>
::pair((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>>
*)(ppVar3 + -0x10),param_3);
ppVar3 = ppVar3 + 0x30;
lVar4 = lVar4 + -0x30;
}
std::
vector<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>>,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>>>>
::resize((vector<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>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*)this,(-(lVar4 + *(long *)this) >> 4) * -0x5555555555555555 +
(lVar2 >> 4) * 0x5555555555555555);
param_2 = param_2 + (*(long *)this - lVar1);
}
return param_2;
}
| |
25,046 | mark_object | eloqsql/strings/json_lib.c | static int mark_object(json_engine_t *j)
{
j->state= JST_OBJ_START;
if (++j->stack_p < JSON_DEPTH_LIMIT)
{
j->stack[j->stack_p]= JST_OBJ_CONT;
return 0;
}
j->s.error= JE_DEPTH;
return 1;
} | O0 | c | mark_object:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x2, 0x34(%rax)
movq -0x10(%rbp), %rcx
movl 0xe4(%rcx), %eax
addl $0x1, %eax
movl %eax, 0xe4(%rcx)
cmpl $0x20, %eax
jge 0x2923b
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0xe4(%rcx), %rcx
movl $0x7, 0x64(%rax,%rcx,4)
movl $0x0, -0x4(%rbp)
jmp 0x2924d
movq -0x10(%rbp), %rax
movl $0xfffffff9, 0x18(%rax) # imm = 0xFFFFFFF9
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| mark_object:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov dword ptr [rax+34h], 2
mov rcx, [rbp+var_10]
mov eax, [rcx+0E4h]
add eax, 1
mov [rcx+0E4h], eax
cmp eax, 20h ; ' '
jge short loc_2923B
mov rax, [rbp+var_10]
mov rcx, [rbp+var_10]
movsxd rcx, dword ptr [rcx+0E4h]
mov dword ptr [rax+rcx*4+64h], 7
mov [rbp+var_4], 0
jmp short loc_2924D
loc_2923B:
mov rax, [rbp+var_10]
mov dword ptr [rax+18h], 0FFFFFFF9h
mov [rbp+var_4], 1
loc_2924D:
mov eax, [rbp+var_4]
pop rbp
retn
| long long mark_object(_DWORD *a1)
{
int v1; // eax
a1[13] = 2;
v1 = a1[57] + 1;
a1[57] = v1;
if ( v1 >= 32 )
{
a1[6] = -7;
return 1;
}
else
{
a1[a1[57] + 25] = 7;
return 0;
}
}
| mark_object:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x34],0x2
MOV RCX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RCX + 0xe4]
ADD EAX,0x1
MOV dword ptr [RCX + 0xe4],EAX
CMP EAX,0x20
JGE 0x0012923b
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RCX + 0xe4]
MOV dword ptr [RAX + RCX*0x4 + 0x64],0x7
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0012924d
LAB_0012923b:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x18],0xfffffff9
MOV dword ptr [RBP + -0x4],0x1
LAB_0012924d:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
bool mark_object(long param_1)
{
int iVar1;
*(int4 *)(param_1 + 0x34) = 2;
iVar1 = *(int *)(param_1 + 0xe4) + 1;
*(int *)(param_1 + 0xe4) = iVar1;
if (0x1f < iVar1) {
*(int4 *)(param_1 + 0x18) = 0xfffffff9;
}
else {
*(int4 *)(param_1 + 100 + (long)*(int *)(param_1 + 0xe4) * 4) = 7;
}
return 0x1f < iVar1;
}
| |
25,047 | ma_uniquedef_write | eloqsql/storage/maria/ma_open.c | my_bool _ma_uniquedef_write(File file, MARIA_UNIQUEDEF *def)
{
uchar buff[MARIA_UNIQUEDEF_SIZE];
uchar *ptr=buff;
mi_int2store(ptr,def->keysegs); ptr+=2;
*ptr++= (uchar) def->key;
*ptr++ = (uchar) def->null_are_equal;
return mysql_file_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
} | O0 | c | ma_uniquedef_write:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0xc(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x24(%rbp)
movb -0x24(%rbp), %dl
movq -0x20(%rbp), %rax
movb %dl, 0x1(%rax)
movb -0x23(%rbp), %dl
movq -0x20(%rbp), %rax
movb %dl, (%rax)
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movb 0x2(%rax), %dl
movq -0x20(%rbp), %rax
movq %rax, %rsi
incq %rsi
movq %rsi, -0x20(%rbp)
movb %dl, (%rax)
movq -0x18(%rbp), %rax
movb 0x3(%rax), %dl
movq -0x20(%rbp), %rax
movq %rax, %rsi
incq %rsi
movq %rsi, -0x20(%rbp)
movb %dl, (%rax)
movl -0x10(%rbp), %edx
movq -0x20(%rbp), %r8
subq %rcx, %r8
leaq 0xea025(%rip), %rdi # 0x1528f1
movl $0x759, %esi # imm = 0x759
movl $0x4, %r9d
callq 0x67410
testq %rax, %rax
setne %al
movb %al, -0x25(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x68900
movb -0x25(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
callq 0x2a270
nopw %cs:(%rax,%rax)
| _ma_uniquedef_write:
push rbp
mov rbp, rsp
sub rsp, 30h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_10], edi
mov [rbp+var_18], rsi
lea rcx, [rbp+var_C]
mov [rbp+var_20], rcx
mov rax, [rbp+var_18]
movzx eax, word ptr [rax]
mov [rbp+var_24], eax
mov dl, byte ptr [rbp+var_24]
mov rax, [rbp+var_20]
mov [rax+1], dl
mov dl, byte ptr [rbp+var_24+1]
mov rax, [rbp+var_20]
mov [rax], dl
mov rax, [rbp+var_20]
add rax, 2
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
mov dl, [rax+2]
mov rax, [rbp+var_20]
mov rsi, rax
inc rsi
mov [rbp+var_20], rsi
mov [rax], dl
mov rax, [rbp+var_18]
mov dl, [rax+3]
mov rax, [rbp+var_20]
mov rsi, rax
inc rsi
mov [rbp+var_20], rsi
mov [rax], dl
mov edx, [rbp+var_10]
mov r8, [rbp+var_20]
sub r8, rcx
lea rdi, aWorkspaceLlm4b_14; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 759h
mov r9d, 4
call inline_mysql_file_write_0
test rax, rax
setnz al
mov [rbp+var_25], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_68900
mov al, [rbp+var_25]
add rsp, 30h
pop rbp
retn
loc_68900:
call ___stack_chk_fail
| bool ma_uniquedef_write(unsigned int a1, unsigned __int16 *a2)
{
unsigned __int16 v2; // kr00_2
_BYTE v4[4]; // [rsp+24h] [rbp-Ch] BYREF
unsigned long long v5; // [rsp+28h] [rbp-8h] BYREF
v5 = __readfsqword(0x28u);
v2 = *a2;
v4[0] = HIBYTE(*a2);
v4[1] = v2;
v4[2] = *((_BYTE *)a2 + 2);
v4[3] = *((_BYTE *)a2 + 3);
return inline_mysql_file_write_0(
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_open.c",
0x759u,
a1,
(long long)v4,
(char *)&v5 - v4,
4LL) != 0;
}
| _ma_uniquedef_write:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x10],EDI
MOV qword ptr [RBP + -0x18],RSI
LEA RCX,[RBP + -0xc]
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX]
MOV dword ptr [RBP + -0x24],EAX
MOV DL,byte ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x1],DL
MOV DL,byte ptr [RBP + -0x23]
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],DL
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV DL,byte ptr [RAX + 0x2]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,RAX
INC RSI
MOV qword ptr [RBP + -0x20],RSI
MOV byte ptr [RAX],DL
MOV RAX,qword ptr [RBP + -0x18]
MOV DL,byte ptr [RAX + 0x3]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,RAX
INC RSI
MOV qword ptr [RBP + -0x20],RSI
MOV byte ptr [RAX],DL
MOV EDX,dword ptr [RBP + -0x10]
MOV R8,qword ptr [RBP + -0x20]
SUB R8,RCX
LEA RDI,[0x2528f1]
MOV ESI,0x759
MOV R9D,0x4
CALL 0x00167410
TEST RAX,RAX
SETNZ AL
MOV byte ptr [RBP + -0x25],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00168900
MOV AL,byte ptr [RBP + -0x25]
ADD RSP,0x30
POP RBP
RET
LAB_00168900:
CALL 0x0012a270
|
int8 _ma_uniquedef_write(int4 param_1,int2 *param_2)
{
long lVar1;
long in_FS_OFFSET;
int1 local_2c;
int1 uStack_2b;
int1 local_14;
int1 local_13;
int1 local_12;
int1 local_11;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_2c = (int1)*param_2;
local_13 = local_2c;
uStack_2b = (int1)((ushort)*param_2 >> 8);
local_14 = uStack_2b;
local_12 = *(int1 *)(param_2 + 1);
local_11 = *(int1 *)((long)param_2 + 3);
lVar1 = inline_mysql_file_write
("/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_open.c",0x759,
param_1,&local_14,(long)&local_10 - (long)&local_14,4);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),lVar1 != 0);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
25,048 | reset_simple_key_cache_counters | eloqsql/mysys/mf_keycache.c | static
int reset_simple_key_cache_counters(const char *name __attribute__((unused)),
SIMPLE_KEY_CACHE_CB *keycache)
{
DBUG_ENTER("reset_simple_key_cache_counters");
if (!keycache->key_cache_inited)
{
DBUG_PRINT("info", ("Key cache %s not initialized.", name));
DBUG_RETURN(0);
}
DBUG_PRINT("info", ("Resetting counters for key cache %s.", name));
keycache->global_blocks_changed= 0; /* Key_blocks_not_flushed */
keycache->global_cache_r_requests= 0; /* Key_read_requests */
keycache->global_cache_read= 0; /* Key_reads */
keycache->global_cache_w_requests= 0; /* Key_write_requests */
keycache->global_cache_write= 0; /* Key_writes */
DBUG_RETURN(0);
} | O3 | c | reset_simple_key_cache_counters:
pushq %rbp
movq %rsp, %rbp
cmpb $0x0, (%rsi)
je 0x99b66
xorps %xmm0, %xmm0
movups %xmm0, 0x148(%rsi)
movups %xmm0, 0x138(%rsi)
movq $0x0, 0x158(%rsi)
xorl %eax, %eax
popq %rbp
retq
| reset_simple_key_cache_counters:
push rbp
mov rbp, rsp
cmp byte ptr [rsi], 0
jz short loc_99B66
xorps xmm0, xmm0
movups xmmword ptr [rsi+148h], xmm0
movups xmmword ptr [rsi+138h], xmm0
mov qword ptr [rsi+158h], 0
loc_99B66:
xor eax, eax
pop rbp
retn
| long long reset_simple_key_cache_counters(long long a1, long long a2)
{
if ( *(_BYTE *)a2 )
{
*(_OWORD *)(a2 + 328) = 0LL;
*(_OWORD *)(a2 + 312) = 0LL;
*(_QWORD *)(a2 + 344) = 0LL;
}
return 0LL;
}
| reset_simple_key_cache_counters:
PUSH RBP
MOV RBP,RSP
CMP byte ptr [RSI],0x0
JZ 0x00199b66
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSI + 0x148],XMM0
MOVUPS xmmword ptr [RSI + 0x138],XMM0
MOV qword ptr [RSI + 0x158],0x0
LAB_00199b66:
XOR EAX,EAX
POP RBP
RET
|
int8 reset_simple_key_cache_counters(int8 param_1,char *param_2)
{
if (*param_2 != '\0') {
param_2[0x148] = '\0';
param_2[0x149] = '\0';
param_2[0x14a] = '\0';
param_2[0x14b] = '\0';
param_2[0x14c] = '\0';
param_2[0x14d] = '\0';
param_2[0x14e] = '\0';
param_2[0x14f] = '\0';
param_2[0x150] = '\0';
param_2[0x151] = '\0';
param_2[0x152] = '\0';
param_2[0x153] = '\0';
param_2[0x154] = '\0';
param_2[0x155] = '\0';
param_2[0x156] = '\0';
param_2[0x157] = '\0';
param_2[0x138] = '\0';
param_2[0x139] = '\0';
param_2[0x13a] = '\0';
param_2[0x13b] = '\0';
param_2[0x13c] = '\0';
param_2[0x13d] = '\0';
param_2[0x13e] = '\0';
param_2[0x13f] = '\0';
param_2[0x140] = '\0';
param_2[0x141] = '\0';
param_2[0x142] = '\0';
param_2[0x143] = '\0';
param_2[0x144] = '\0';
param_2[0x145] = '\0';
param_2[0x146] = '\0';
param_2[0x147] = '\0';
param_2[0x158] = '\0';
param_2[0x159] = '\0';
param_2[0x15a] = '\0';
param_2[0x15b] = '\0';
param_2[0x15c] = '\0';
param_2[0x15d] = '\0';
param_2[0x15e] = '\0';
param_2[0x15f] = '\0';
}
return 0;
}
| |
25,049 | ma_set_fatal_error | eloqsql/storage/maria/ma_info.c | void _ma_set_fatal_error(MARIA_HA *info, int error)
{
MARIA_SHARE *share= info->s;
_ma_print_error(info, error,
(share->state.changed & STATE_CRASHED_PRINTED) == 0);
maria_mark_crashed_share(share);
share->state.changed|= STATE_CRASHED_PRINTED;
my_errno= error;
DBUG_ASSERT(!maria_assert_if_crashed_table);
} | O0 | c | ma_set_fatal_error:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rax
movl 0x170(%rax), %eax
andl $0x800, %eax # imm = 0x800
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movsbl %al, %edx
callq 0x43cb0
movq -0x18(%rbp), %rax
movl 0x170(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x170(%rax)
jmp 0x43db8
jmp 0x43dba
movq -0x18(%rbp), %rax
movl 0x170(%rax), %ecx
orl $0x800, %ecx # imm = 0x800
movl %ecx, 0x170(%rax)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0xf6050
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x43de2
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ma_set_fatal_error:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov rax, [rbp+var_18]
mov eax, [rax+170h]
and eax, 800h
cmp eax, 0
setz al
and al, 1
movzx eax, al
movsx edx, al
call _ma_print_error
mov rax, [rbp+var_18]
mov ecx, [rax+170h]
or ecx, 2
mov [rax+170h], ecx
jmp short $+2
loc_43DB8:
jmp short $+2
loc_43DBA:
mov rax, [rbp+var_18]
mov ecx, [rax+170h]
or ecx, 800h
mov [rax+170h], ecx
mov eax, [rbp+var_C]
mov [rbp+var_1C], eax
call _my_thread_var
mov ecx, [rbp+var_1C]
mov [rax], ecx
jmp short $+2
loc_43DE2:
add rsp, 20h
pop rbp
retn
| int * ma_set_fatal_error(_DWORD *a1, int a2, long long a3, long long a4, long long a5, int a6)
{
int *result; // rax
long long v7; // [rsp+8h] [rbp-18h]
v7 = *(_QWORD *)a1;
ma_print_error(a1, a2, (*(_DWORD *)(*(_QWORD *)a1 + 368LL) & 0x800) == 0, a4, a5, a6);
*(_DWORD *)(v7 + 368) |= 2u;
*(_DWORD *)(v7 + 368) |= 0x800u;
result = (int *)my_thread_var();
*result = a2;
return result;
}
| _ma_set_fatal_error:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x170]
AND EAX,0x800
CMP EAX,0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
MOVSX EDX,AL
CALL 0x00143cb0
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX + 0x170]
OR ECX,0x2
MOV dword ptr [RAX + 0x170],ECX
JMP 0x00143db8
LAB_00143db8:
JMP 0x00143dba
LAB_00143dba:
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX + 0x170]
OR ECX,0x800
MOV dword ptr [RAX + 0x170],ECX
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x1c],EAX
CALL 0x001f6050
MOV ECX,dword ptr [RBP + -0x1c]
MOV dword ptr [RAX],ECX
JMP 0x00143de2
LAB_00143de2:
ADD RSP,0x20
POP RBP
RET
|
void _ma_set_fatal_error(long *param_1,int4 param_2)
{
long lVar1;
int4 *puVar2;
lVar1 = *param_1;
_ma_print_error(param_1,param_2,(*(uint *)(lVar1 + 0x170) & 0x800) == 0);
*(uint *)(lVar1 + 0x170) = *(uint *)(lVar1 + 0x170) | 2;
*(uint *)(lVar1 + 0x170) = *(uint *)(lVar1 + 0x170) | 0x800;
puVar2 = (int4 *)_my_thread_var();
*puVar2 = param_2;
return;
}
| |
25,050 | my_strnncollsp_8bit_bin | eloqsql/strings/ctype-bin.c | static int my_strnncollsp_8bit_bin(CHARSET_INFO * cs __attribute__((unused)),
const uchar *a, size_t a_length,
const uchar *b, size_t b_length)
{
const uchar *end;
size_t length;
end= a + (length= MY_MIN(a_length, b_length));
while (a < end)
{
if (*a++ != *b++)
return ((int) a[-1] - (int) b[-1]);
}
return a_length == b_length ? 0 :
a_length < b_length ?
-my_strnncollsp_padspace_bin(b, b_length - length) :
my_strnncollsp_padspace_bin(a, a_length - length);
} | O3 | c | my_strnncollsp_8bit_bin:
pushq %rbp
movq %rsp, %rbp
cmpq %r8, %rdx
movq %r8, %rdi
cmovbq %rdx, %rdi
leaq (%rsi,%rdi), %r9
cmpq %r9, %rsi
jae 0x37e6d
movzbl (%rsi), %eax
incq %rsi
movzbl (%rcx), %r10d
incq %rcx
cmpb %r10b, %al
je 0x37e51
subl %r10d, %eax
jmp 0x37e74
xorl %eax, %eax
cmpq %r8, %rdx
jne 0x37e76
popq %rbp
retq
jae 0x37e93
subq %rdi, %r8
je 0x37e74
xorl %edx, %edx
xorl %eax, %eax
cmpb $0x20, (%rcx,%rdx)
jb 0x37eae
jne 0x37eb5
incq %rdx
cmpq %rdx, %r8
jne 0x37e81
jmp 0x37e74
subq %rdi, %rdx
je 0x37e74
xorl %ecx, %ecx
xorl %eax, %eax
cmpb $0x20, (%rsi,%rcx)
jb 0x37eb5
jne 0x37eae
incq %rcx
cmpq %rcx, %rdx
jne 0x37e9c
jmp 0x37e74
movl $0x1, %eax
jmp 0x37e74
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x37e74
| my_strnncollsp_8bit_bin:
push rbp
mov rbp, rsp
cmp rdx, r8
mov rdi, r8
cmovb rdi, rdx
lea r9, [rsi+rdi]
loc_37E51:
cmp rsi, r9
jnb short loc_37E6D
movzx eax, byte ptr [rsi]
inc rsi
movzx r10d, byte ptr [rcx]
inc rcx
cmp al, r10b
jz short loc_37E51
sub eax, r10d
jmp short loc_37E74
loc_37E6D:
xor eax, eax
cmp rdx, r8
jnz short loc_37E76
loc_37E74:
pop rbp
retn
loc_37E76:
jnb short loc_37E93
sub r8, rdi
jz short loc_37E74
xor edx, edx
xor eax, eax
loc_37E81:
cmp byte ptr [rcx+rdx], 20h ; ' '
jb short loc_37EAE
jnz short loc_37EB5
inc rdx
cmp r8, rdx
jnz short loc_37E81
jmp short loc_37E74
loc_37E93:
sub rdx, rdi
jz short loc_37E74
xor ecx, ecx
xor eax, eax
loc_37E9C:
cmp byte ptr [rsi+rcx], 20h ; ' '
jb short loc_37EB5
jnz short loc_37EAE
inc rcx
cmp rdx, rcx
jnz short loc_37E9C
jmp short loc_37E74
loc_37EAE:
mov eax, 1
jmp short loc_37E74
loc_37EB5:
mov eax, 0FFFFFFFFh
jmp short loc_37E74
| long long my_strnncollsp_8bit_bin(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned __int8 *a4,
unsigned long long a5)
{
unsigned long long v5; // rdi
unsigned __int8 *v6; // r9
int v7; // eax
int v8; // r10d
long long result; // rax
unsigned long long v10; // r8
long long v11; // rdx
unsigned long long v12; // rdx
long long v13; // rcx
v5 = a5;
if ( a3 < a5 )
v5 = a3;
v6 = &a2[v5];
while ( a2 < v6 )
{
v7 = *a2++;
v8 = *a4++;
if ( (_BYTE)v7 != (_BYTE)v8 )
return (unsigned int)(v7 - v8);
}
result = 0LL;
if ( a3 != a5 )
{
if ( a3 >= a5 )
{
v12 = a3 - v5;
if ( v12 )
{
v13 = 0LL;
result = 0LL;
while ( a2[v13] >= 0x20u )
{
if ( a2[v13] != 32 )
return 1LL;
if ( v12 == ++v13 )
return result;
}
return 0xFFFFFFFFLL;
}
}
else
{
v10 = a5 - v5;
if ( v10 )
{
v11 = 0LL;
result = 0LL;
while ( a4[v11] >= 0x20u )
{
if ( a4[v11] != 32 )
return 0xFFFFFFFFLL;
if ( v10 == ++v11 )
return result;
}
return 1LL;
}
}
}
return result;
}
| my_strnncollsp_8bit_bin:
PUSH RBP
MOV RBP,RSP
CMP RDX,R8
MOV RDI,R8
CMOVC RDI,RDX
LEA R9,[RSI + RDI*0x1]
LAB_00137e51:
CMP RSI,R9
JNC 0x00137e6d
MOVZX EAX,byte ptr [RSI]
INC RSI
MOVZX R10D,byte ptr [RCX]
INC RCX
CMP AL,R10B
JZ 0x00137e51
SUB EAX,R10D
JMP 0x00137e74
LAB_00137e6d:
XOR EAX,EAX
CMP RDX,R8
JNZ 0x00137e76
LAB_00137e74:
POP RBP
RET
LAB_00137e76:
JNC 0x00137e93
SUB R8,RDI
JZ 0x00137e74
XOR EDX,EDX
XOR EAX,EAX
LAB_00137e81:
CMP byte ptr [RCX + RDX*0x1],0x20
JC 0x00137eae
JNZ 0x00137eb5
INC RDX
CMP R8,RDX
JNZ 0x00137e81
JMP 0x00137e74
LAB_00137e93:
SUB RDX,RDI
JZ 0x00137e74
XOR ECX,ECX
XOR EAX,EAX
LAB_00137e9c:
CMP byte ptr [RSI + RCX*0x1],0x20
JC 0x00137eb5
JNZ 0x00137eae
INC RCX
CMP RDX,RCX
JNZ 0x00137e9c
JMP 0x00137e74
LAB_00137eae:
MOV EAX,0x1
JMP 0x00137e74
LAB_00137eb5:
MOV EAX,0xffffffff
JMP 0x00137e74
|
int my_strnncollsp_8bit_bin
(int8 param_1,byte *param_2,ulong param_3,byte *param_4,ulong param_5)
{
byte *pbVar1;
byte bVar2;
byte bVar3;
long lVar4;
ulong uVar5;
uVar5 = param_5;
if (param_3 < param_5) {
uVar5 = param_3;
}
pbVar1 = param_2 + uVar5;
while (param_2 < pbVar1) {
bVar2 = *param_2;
param_2 = param_2 + 1;
bVar3 = *param_4;
param_4 = param_4 + 1;
if (bVar2 != bVar3) {
return (uint)bVar2 - (uint)bVar3;
}
}
if (param_3 == param_5) {
return 0;
}
if (param_3 < param_5) {
if (param_5 == uVar5) {
return 0;
}
lVar4 = 0;
while( true ) {
if (param_4[lVar4] < 0x20) {
return 1;
}
if (param_4[lVar4] != 0x20) break;
lVar4 = lVar4 + 1;
if (param_5 - uVar5 == lVar4) {
return 0;
}
}
return -1;
}
if (param_3 != uVar5) {
lVar4 = 0;
while( true ) {
if (param_2[lVar4] < 0x20) {
return -1;
}
if (param_2[lVar4] != 0x20) break;
lVar4 = lVar4 + 1;
if (param_3 - uVar5 == lVar4) {
return 0;
}
}
return 1;
}
return 0;
}
| |
25,051 | to_digit | bluesky950520[P]quickjs/quickjs.c | static inline int to_digit(int c)
{
if (c >= '0' && c <= '9')
return c - '0';
else if (c >= 'A' && c <= 'Z')
return c - 'A' + 10;
else if (c >= 'a' && c <= 'z')
return c - 'a' + 10;
else
return 36;
} | O2 | c | to_digit:
leal -0x30(%rdi), %eax
cmpl $0xa, %eax
jb 0x3ae5a
leal -0x41(%rdi), %eax
cmpl $0x19, %eax
ja 0x3ae4b
addl $-0x37, %edi
movl %edi, %eax
retq
leal -0x61(%rdi), %eax
addl $-0x57, %edi
cmpl $0x1a, %eax
pushq $0x24
popq %rax
cmovbl %edi, %eax
retq
| to_digit:
lea eax, [rdi-30h]
cmp eax, 0Ah
jb short locret_3AE5A
lea eax, [rdi-41h]
cmp eax, 19h
ja short loc_3AE4B
add edi, 0FFFFFFC9h
mov eax, edi
retn
loc_3AE4B:
lea eax, [rdi-61h]
add edi, 0FFFFFFA9h
cmp eax, 1Ah
push 24h ; '$'
pop rax
cmovb eax, edi
locret_3AE5A:
retn
| long long to_digit(int a1)
{
long long result; // rax
unsigned int v2; // eax
unsigned int v3; // edi
bool v4; // cf
result = (unsigned int)(a1 - 48);
if ( (unsigned int)result >= 0xA )
{
if ( (unsigned int)(a1 - 65) > 0x19 )
{
v2 = a1 - 97;
v3 = a1 - 87;
v4 = v2 < 0x1A;
result = 36LL;
if ( v4 )
return v3;
}
else
{
return (unsigned int)(a1 - 55);
}
}
return result;
}
| to_digit:
LEA EAX,[RDI + -0x30]
CMP EAX,0xa
JC 0x0013ae5a
LEA EAX,[RDI + -0x41]
CMP EAX,0x19
JA 0x0013ae4b
ADD EDI,-0x37
MOV EAX,EDI
RET
LAB_0013ae4b:
LEA EAX,[RDI + -0x61]
ADD EDI,-0x57
CMP EAX,0x1a
PUSH 0x24
POP RAX
CMOVC EAX,EDI
LAB_0013ae5a:
RET
|
uint to_digit(int param_1)
{
uint uVar1;
uVar1 = param_1 - 0x30U;
if (9 < param_1 - 0x30U) {
if (param_1 - 0x41U < 0x1a) {
return param_1 - 0x37;
}
uVar1 = 0x24;
if (param_1 - 0x61U < 0x1a) {
uVar1 = param_1 - 0x57;
}
}
return uVar1;
}
| |
25,052 | my_symlink | eloqsql/mysys/my_symlink.c | int my_symlink(const char *content, const char *linkname, myf MyFlags)
{
#ifndef HAVE_READLINK
return 0;
#else
int result;
DBUG_ENTER("my_symlink");
DBUG_PRINT("enter",("content: %s linkname: %s", content, linkname));
result= 0;
if (symlink(content, linkname))
{
result= -1;
my_errno=errno;
if (MyFlags & MY_WME)
my_error(EE_CANT_SYMLINK, MYF(0), linkname, content, errno);
}
else if ((MyFlags & MY_SYNC_DIR) && my_sync_dir_by_file(linkname, MyFlags))
result= -1;
DBUG_RETURN(result);
#endif /* HAVE_READLINK */
} | O0 | c | my_symlink:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x300d6
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x24070
cmpl $0x0, %eax
je 0x3014a
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
callq 0x24040
movl (%rax), %eax
movl %eax, -0x20(%rbp)
callq 0x26ab0
movl -0x20(%rbp), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0x30148
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x24040
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl (%rax), %r8d
movl $0x19, %edi
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x2e5f0
jmp 0x30175
movq -0x18(%rbp), %rax
andq $0x8000, %rax # imm = 0x8000
cmpq $0x0, %rax
je 0x30173
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x30840
cmpl $0x0, %eax
je 0x30173
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
jmp 0x30175
jmp 0x30177
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_symlink:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
jmp short $+2
loc_300D6:
mov [rbp+var_1C], 0
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
call _symlink
cmp eax, 0
jz short loc_3014A
mov [rbp+var_1C], 0FFFFFFFFh
call ___errno_location
mov eax, [rax]
mov [rbp+var_20], eax
call _my_thread_var
mov ecx, [rbp+var_20]
mov [rax], ecx
mov rax, [rbp+var_18]
and rax, 10h
cmp rax, 0
jz short loc_30148
mov rax, [rbp+var_10]
mov [rbp+var_30], rax
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
call ___errno_location
mov rdx, [rbp+var_30]
mov rcx, [rbp+var_28]
mov r8d, [rax]
mov edi, 19h
xor eax, eax
mov esi, eax
mov al, 0
call my_error
loc_30148:
jmp short loc_30175
loc_3014A:
mov rax, [rbp+var_18]
and rax, 8000h
cmp rax, 0
jz short loc_30173
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call my_sync_dir_by_file
cmp eax, 0
jz short loc_30173
mov [rbp+var_1C], 0FFFFFFFFh
loc_30173:
jmp short $+2
loc_30175:
jmp short $+2
loc_30177:
mov eax, [rbp+var_1C]
mov [rbp+var_34], eax
mov eax, [rbp+var_34]
add rsp, 40h
pop rbp
retn
| long long my_symlink(long long a1, long long a2, long long a3)
{
unsigned int *v3; // rax
int v5; // [rsp+20h] [rbp-20h]
unsigned int v6; // [rsp+24h] [rbp-1Ch]
v6 = 0;
if ( (unsigned int)symlink(a1, a2) )
{
v6 = -1;
v5 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var() = v5;
if ( (a3 & 0x10) != 0 )
{
v3 = (unsigned int *)__errno_location();
my_error(0x19u, 0LL, a2, a1, *v3);
}
}
else if ( (a3 & 0x8000) != 0 && (unsigned int)my_sync_dir_by_file(a2, a3) )
{
return (unsigned int)-1;
}
return v6;
}
| my_symlink:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
JMP 0x001300d6
LAB_001300d6:
MOV dword ptr [RBP + -0x1c],0x0
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x00124070
CMP EAX,0x0
JZ 0x0013014a
MOV dword ptr [RBP + -0x1c],0xffffffff
CALL 0x00124040
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x20],EAX
CALL 0x00126ab0
MOV ECX,dword ptr [RBP + -0x20]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x10
CMP RAX,0x0
JZ 0x00130148
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RAX
CALL 0x00124040
MOV RDX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8D,dword ptr [RAX]
MOV EDI,0x19
XOR EAX,EAX
MOV ESI,EAX
MOV AL,0x0
CALL 0x0012e5f0
LAB_00130148:
JMP 0x00130175
LAB_0013014a:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x8000
CMP RAX,0x0
JZ 0x00130173
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00130840
CMP EAX,0x0
JZ 0x00130173
MOV dword ptr [RBP + -0x1c],0xffffffff
LAB_00130173:
JMP 0x00130175
LAB_00130175:
JMP 0x00130177
LAB_00130177:
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x34]
ADD RSP,0x40
POP RBP
RET
|
int4 my_symlink(char *param_1,char *param_2,ulong param_3)
{
int iVar1;
int *piVar2;
int4 local_24;
local_24 = 0;
iVar1 = symlink(param_1,param_2);
if (iVar1 == 0) {
if (((param_3 & 0x8000) != 0) && (iVar1 = my_sync_dir_by_file(param_2,param_3), iVar1 != 0)) {
local_24 = 0xffffffff;
}
}
else {
local_24 = 0xffffffff;
piVar2 = __errno_location();
iVar1 = *piVar2;
piVar2 = (int *)_my_thread_var();
*piVar2 = iVar1;
if ((param_3 & 0x10) != 0) {
piVar2 = __errno_location();
my_error(0x19,0,param_2,param_1,*piVar2);
}
}
return local_24;
}
| |
25,053 | my_symlink | eloqsql/mysys/my_symlink.c | int my_symlink(const char *content, const char *linkname, myf MyFlags)
{
#ifndef HAVE_READLINK
return 0;
#else
int result;
DBUG_ENTER("my_symlink");
DBUG_PRINT("enter",("content: %s linkname: %s", content, linkname));
result= 0;
if (symlink(content, linkname))
{
result= -1;
my_errno=errno;
if (MyFlags & MY_WME)
my_error(EE_CANT_SYMLINK, MYF(0), linkname, content, errno);
}
else if ((MyFlags & MY_SYNC_DIR) && my_sync_dir_by_file(linkname, MyFlags))
result= -1;
DBUG_RETURN(result);
#endif /* HAVE_READLINK */
} | O3 | c | my_symlink:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
callq 0x24070
testl %eax, %eax
je 0x2bdae
callq 0x24050
movq %rax, %r13
movl (%rax), %r14d
callq 0x2686a
movl %r14d, (%rax)
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
testb $0x10, %r15b
je 0x2bdca
movl (%r13), %r8d
movl $0x19, %edi
xorl %esi, %esi
movq %rbx, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2ab8f
jmp 0x2bdca
xorl %r14d, %r14d
testw %r15w, %r15w
jns 0x2bdca
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2c1ff
xorl %r14d, %r14d
negl %eax
sbbl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_symlink:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rdx
mov rbx, rsi
mov r12, rdi
call _symlink
test eax, eax
jz short loc_2BDAE
call ___errno_location
mov r13, rax
mov r14d, [rax]
call _my_thread_var
mov [rax], r14d
mov r14d, 0FFFFFFFFh
test r15b, 10h
jz short loc_2BDCA
mov r8d, [r13+0]
mov edi, 19h
xor esi, esi
mov rdx, rbx
mov rcx, r12
xor eax, eax
call my_error
jmp short loc_2BDCA
loc_2BDAE:
xor r14d, r14d
test r15w, r15w
jns short loc_2BDCA
mov rdi, rbx
mov rsi, r15
call my_sync_dir_by_file
xor r14d, r14d
neg eax
sbb r14d, r14d
loc_2BDCA:
mov eax, r14d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_symlink(long long a1, long long a2, long long a3)
{
unsigned int *v4; // r13
unsigned int v5; // r14d
unsigned int v6; // r14d
if ( (unsigned int)symlink(a1) )
{
v4 = (unsigned int *)__errno_location(a1, a2);
v5 = *v4;
*(_DWORD *)my_thread_var() = v5;
v6 = -1;
if ( (a3 & 0x10) != 0 )
my_error(0x19u, 0, a2, a1, *v4);
}
else
{
v6 = 0;
if ( (a3 & 0x8000u) != 0LL )
return (unsigned int)-((unsigned int)my_sync_dir_by_file(a2, a3) != 0);
}
return v6;
}
| my_symlink:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV RBX,RSI
MOV R12,RDI
CALL 0x00124070
TEST EAX,EAX
JZ 0x0012bdae
CALL 0x00124050
MOV R13,RAX
MOV R14D,dword ptr [RAX]
CALL 0x0012686a
MOV dword ptr [RAX],R14D
MOV R14D,0xffffffff
TEST R15B,0x10
JZ 0x0012bdca
MOV R8D,dword ptr [R13]
MOV EDI,0x19
XOR ESI,ESI
MOV RDX,RBX
MOV RCX,R12
XOR EAX,EAX
CALL 0x0012ab8f
JMP 0x0012bdca
LAB_0012bdae:
XOR R14D,R14D
TEST R15W,R15W
JNS 0x0012bdca
MOV RDI,RBX
MOV RSI,R15
CALL 0x0012c1ff
XOR R14D,R14D
NEG EAX
SBB R14D,R14D
LAB_0012bdca:
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int my_symlink(char *param_1,char *param_2,ulong param_3)
{
int iVar1;
int *piVar2;
int *piVar3;
iVar1 = symlink(param_1,param_2);
if (iVar1 == 0) {
iVar1 = 0;
if ((short)param_3 < 0) {
iVar1 = my_sync_dir_by_file(param_2,param_3);
iVar1 = -(uint)(iVar1 != 0);
}
}
else {
piVar2 = __errno_location();
iVar1 = *piVar2;
piVar3 = (int *)_my_thread_var();
*piVar3 = iVar1;
iVar1 = -1;
if ((param_3 & 0x10) != 0) {
my_error(0x19,0,param_2,param_1,*piVar2);
}
}
return iVar1;
}
| |
25,054 | bitmap_subtract | eloqsql/mysys/my_bitmap.c | void bitmap_subtract(MY_BITMAP *map, const MY_BITMAP *map2)
{
my_bitmap_map *to= map->bitmap, *from= map2->bitmap, *end;
DBUG_ASSERT(map->bitmap);
DBUG_ASSERT(map2->bitmap);
DBUG_ASSERT(map->n_bits==map2->n_bits);
end= map->last_word_ptr;
while (to <= end)
*to++ &= ~(*from++);
} | O3 | c | bitmap_subtract:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
cmpq %rcx, %rax
ja 0xa007e
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rdx
movl (%rdx), %esi
notl %esi
andl %esi, (%rax)
addq $0x4, %rdx
addq $0x4, %rax
cmpq %rcx, %rax
jbe 0xa006a
popq %rbp
retq
| bitmap_subtract:
mov rax, [rdi]
mov rcx, [rdi+8]
cmp rax, rcx
ja short locret_A007E
push rbp
mov rbp, rsp
mov rdx, [rsi]
loc_A006A:
mov esi, [rdx]
not esi
and [rax], esi
add rdx, 4
add rax, 4
cmp rax, rcx
jbe short loc_A006A
pop rbp
locret_A007E:
retn
| _DWORD * bitmap_subtract(long long a1, _DWORD **a2)
{
_DWORD *result; // rax
unsigned long long v3; // rcx
_DWORD *v4; // rdx
result = *(_DWORD **)a1;
v3 = *(_QWORD *)(a1 + 8);
if ( *(_QWORD *)a1 <= v3 )
{
v4 = *a2;
do
*result++ &= ~*v4++;
while ( (unsigned long long)result <= v3 );
}
return result;
}
| bitmap_subtract:
MOV RAX,qword ptr [RDI]
MOV RCX,qword ptr [RDI + 0x8]
CMP RAX,RCX
JA 0x001a007e
PUSH RBP
MOV RBP,RSP
MOV RDX,qword ptr [RSI]
LAB_001a006a:
MOV ESI,dword ptr [RDX]
NOT ESI
AND dword ptr [RAX],ESI
ADD RDX,0x4
ADD RAX,0x4
CMP RAX,RCX
JBE 0x001a006a
POP RBP
LAB_001a007e:
RET
|
void bitmap_subtract(int8 *param_1,int8 *param_2)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
puVar2 = (uint *)*param_1;
puVar1 = (uint *)param_1[1];
if (puVar2 <= puVar1) {
puVar3 = (uint *)*param_2;
do {
*puVar2 = *puVar2 & ~*puVar3;
puVar3 = puVar3 + 1;
puVar2 = puVar2 + 1;
} while (puVar2 <= puVar1);
}
return;
}
| |
25,055 | minja::ExpressionNode::~ExpressionNode() | monkey531[P]llama/common/minja.hpp | ExpressionNode(const Location & location, std::shared_ptr<Expression> && e) : TemplateNode(location), expr(std::move(e)) {} | O1 | cpp | minja::ExpressionNode::~ExpressionNode():
pushq %rbx
movq %rdi, %rbx
leaq 0x8ff29(%rip), %rax # 0x13c2a8
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0xac394
callq 0x7ae1c
leaq 0x8fc2d(%rip), %rax # 0x13bfc8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xac3b1
popq %rbx
jmp 0x7ae1c
popq %rbx
retq
nop
| _ZN5minja14ExpressionNodeD2Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja14ExpressionNodeE; `vtable for'minja::ExpressionNode
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+28h]
test rdi, rdi
jz short loc_AC394
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_AC394:
lea rax, _ZTVN5minja12TemplateNodeE; `vtable for'minja::TemplateNode
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+10h]
test rdi, rdi
jz short loc_AC3B1
pop rbx
jmp _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_AC3B1:
pop rbx
retn
| void minja::ExpressionNode::~ExpressionNode(minja::ExpressionNode *this)
{
volatile signed __int32 *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::ExpressionNode + 2;
v2 = (volatile signed __int32 *)*((_QWORD *)this + 5);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
*(_QWORD *)this = &`vtable for'minja::TemplateNode + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 2);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
}
| ~ExpressionNode:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x23c2a8]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x28]
TEST RDI,RDI
JZ 0x001ac394
CALL 0x0017ae1c
LAB_001ac394:
LEA RAX,[0x23bfc8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x10]
TEST RDI,RDI
JZ 0x001ac3b1
POP RBX
JMP 0x0017ae1c
LAB_001ac3b1:
POP RBX
RET
|
/* minja::ExpressionNode::~ExpressionNode() */
void __thiscall minja::ExpressionNode::~ExpressionNode(ExpressionNode *this)
{
*(int ***)this = &PTR_do_render_0023c2b8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x28) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x28));
}
*(int ***)this = &PTR___cxa_pure_virtual_0023bfd8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x10) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x10));
return;
}
return;
}
| |
25,056 | minja::ExpressionNode::~ExpressionNode() | monkey531[P]llama/common/minja.hpp | ExpressionNode(const Location & location, std::shared_ptr<Expression> && e) : TemplateNode(location), expr(std::move(e)) {} | O2 | cpp | minja::ExpressionNode::~ExpressionNode():
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
callq 0x7eb6c
leaq 0x89ee8(%rip), %rax # 0x10b2b8
addq $0x10, %rax
movq %rax, (%r14)
andq $0x0, 0x28(%r14)
movups (%rbx), %xmm0
andq $0x0, 0x8(%rbx)
movups %xmm0, 0x20(%r14)
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| _ZN5minja14ExpressionNodeC2ERKNS_8LocationEOSt10shared_ptrINS_10ExpressionEE:
push r14
push rbx
push rax
mov rbx, rdx
mov r14, rdi
call _ZN5minja12TemplateNodeC2ERKNS_8LocationE; minja::TemplateNode::TemplateNode(minja::Location const&)
lea rax, _ZTVN5minja14ExpressionNodeE; `vtable for'minja::ExpressionNode
add rax, 10h
mov [r14], rax
and qword ptr [r14+28h], 0
movups xmm0, xmmword ptr [rbx]
and qword ptr [rbx+8], 0
movups xmmword ptr [r14+20h], xmm0
and qword ptr [rbx], 0
add rsp, 8
pop rbx
pop r14
retn
| long long * minja::ExpressionNode::ExpressionNode(long long a1, _QWORD *a2, __int128 *a3)
{
long long *result; // rax
__int128 v5; // xmm0
minja::TemplateNode::TemplateNode((_QWORD *)a1, a2);
result = &`vtable for'minja::ExpressionNode + 2;
*(_QWORD *)a1 = &`vtable for'minja::ExpressionNode + 2;
*(_QWORD *)(a1 + 40) = 0LL;
v5 = *a3;
*((_QWORD *)a3 + 1) = 0LL;
*(_OWORD *)(a1 + 32) = v5;
*(_QWORD *)a3 = 0LL;
return result;
}
| ExpressionNode:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RDI
CALL 0x0017eb6c
LEA RAX,[0x20b2b8]
ADD RAX,0x10
MOV qword ptr [R14],RAX
AND qword ptr [R14 + 0x28],0x0
MOVUPS XMM0,xmmword ptr [RBX]
AND qword ptr [RBX + 0x8],0x0
MOVUPS xmmword ptr [R14 + 0x20],XMM0
AND qword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* minja::ExpressionNode::ExpressionNode(minja::Location const&,
std::shared_ptr<minja::Expression>&&) */
void __thiscall
minja::ExpressionNode::ExpressionNode(ExpressionNode *this,Location *param_1,shared_ptr *param_2)
{
int8 uVar1;
TemplateNode::TemplateNode((TemplateNode *)this,param_1);
*(int ***)this = &PTR_do_render_0020b2c8;
*(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;
return;
}
| |
25,057 | minja::ExpressionNode::~ExpressionNode() | monkey531[P]llama/common/minja.hpp | ExpressionNode(const Location & location, std::shared_ptr<Expression> && e) : TemplateNode(location), expr(std::move(e)) {} | O3 | cpp | minja::ExpressionNode::~ExpressionNode():
pushq %rbx
movq %rdi, %rbx
leaq 0x8e6e3(%rip), %rax # 0x13a2a8
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0xabbda
callq 0x7b578
leaq 0x8e3e7(%rip), %rax # 0x139fc8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xabbf7
popq %rbx
jmp 0x7b578
popq %rbx
retq
nop
| _ZN5minja14ExpressionNodeD2Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja14ExpressionNodeE; `vtable for'minja::ExpressionNode
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+28h]
test rdi, rdi
jz short loc_ABBDA
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_ABBDA:
lea rax, _ZTVN5minja12TemplateNodeE; `vtable for'minja::TemplateNode
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+10h]
test rdi, rdi
jz short loc_ABBF7
pop rbx
jmp _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_ABBF7:
pop rbx
retn
| void minja::ExpressionNode::~ExpressionNode(minja::ExpressionNode *this)
{
volatile signed __int32 *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::ExpressionNode + 2;
v2 = (volatile signed __int32 *)*((_QWORD *)this + 5);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
*(_QWORD *)this = &`vtable for'minja::TemplateNode + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 2);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
}
| ~ExpressionNode:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x23a2a8]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x28]
TEST RDI,RDI
JZ 0x001abbda
CALL 0x0017b578
LAB_001abbda:
LEA RAX,[0x239fc8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x10]
TEST RDI,RDI
JZ 0x001abbf7
POP RBX
JMP 0x0017b578
LAB_001abbf7:
POP RBX
RET
|
/* minja::ExpressionNode::~ExpressionNode() */
void __thiscall minja::ExpressionNode::~ExpressionNode(ExpressionNode *this)
{
*(int ***)this = &PTR_do_render_0023a2b8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x28) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x28));
}
*(int ***)this = &PTR___cxa_pure_virtual_00239fd8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x10) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x10));
return;
}
return;
}
| |
25,058 | linenoiseEditHistoryNext(linenoiseState*, int) | monkey531[P]llama/examples/run/linenoise.cpp/linenoise.cpp | static void linenoiseEditHistoryNext(struct linenoiseState * l, int dir) {
if (history_len > 1) {
/* Update the current history entry before to
* overwrite it with the next one. */
free(history[history_len - 1 - l->history_index]);
history[history_len - 1 - l->history_index] = strdup(l->buf);
/* Show the new entry */
l->history_index += (dir == LINENOISE_HISTORY_PREV) ? 1 : -1;
if (l->history_index < 0) {
l->history_index = 0;
return;
} else if (l->history_index >= history_len) {
l->history_index = history_len-1;
return;
}
strncpy(l->buf,history[history_len - 1 - l->history_index],l->buflen);
l->buf[l->buflen-1] = '\0';
l->len = l->pos = strlen(l->buf);
refreshLine(l);
}
} | O1 | cpp | linenoiseEditHistoryNext(linenoiseState*, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x9f35e(%rip), %r14d # 0xebcf0
cmpl $0x2, %r14d
jl 0x4ca4e
movl %esi, %ebp
movq %rdi, %rbx
movq 0x9f350(%rip), %r15 # 0xebcf8
movl 0x60(%rdi), %eax
notl %eax
addl %r14d, %eax
cltq
movq (%r15,%rax,8), %rdi
callq 0x19900
movq 0x18(%rbx), %rdi
callq 0x19ea0
movl 0x60(%rbx), %ecx
movl %ecx, %edx
notl %edx
addl %r14d, %edx
movslq %edx, %rdx
movq %rax, (%r15,%rdx,8)
xorl %eax, %eax
cmpl $0x1, %ebp
sete %al
leal -0x1(,%rax,2), %eax
addl %ecx, %eax
movl %eax, 0x60(%rbx)
js 0x4ca3e
cmpl %r14d, %eax
jge 0x4ca47
notl %eax
addl %eax, %r14d
movslq %r14d, %rax
movq (%r15,%rax,8), %rsi
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rdx
callq 0x193d0
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
movb $0x0, -0x1(%rax,%rcx)
movq 0x18(%rbx), %rdi
callq 0x19360
movq %rax, 0x38(%rbx)
movq %rax, 0x48(%rbx)
movq %rbx, %rdi
movl $0x3, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4bffa
movl $0x0, 0x60(%rbx)
jmp 0x4ca4e
decl %r14d
movl %r14d, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| _ZL24linenoiseEditHistoryNextP14linenoiseStatei:
push rbp
push r15
push r14
push rbx
push rax
mov r14d, cs:_ZL11history_len; history_len
cmp r14d, 2
jl loc_4CA4E
mov ebp, esi
mov rbx, rdi
mov r15, cs:_ZL7history; history
mov eax, [rdi+60h]
not eax
add eax, r14d
cdqe
mov rdi, [r15+rax*8]
call _free
mov rdi, [rbx+18h]
call _strdup
mov ecx, [rbx+60h]
mov edx, ecx
not edx
add edx, r14d
movsxd rdx, edx
mov [r15+rdx*8], rax
xor eax, eax
cmp ebp, 1
setz al
lea eax, ds:0FFFFFFFFFFFFFFFFh[rax*2]
add eax, ecx
mov [rbx+60h], eax
js short loc_4CA3E
cmp eax, r14d
jge short loc_4CA47
not eax
add r14d, eax
movsxd rax, r14d
mov rsi, [r15+rax*8]
mov rdi, [rbx+18h]
mov rdx, [rbx+20h]
call _strncpy
mov rax, [rbx+18h]
mov rcx, [rbx+20h]
mov byte ptr [rax+rcx-1], 0
mov rdi, [rbx+18h]
call _strlen
mov [rbx+38h], rax
mov [rbx+48h], rax
mov rdi, rbx
mov esi, 3
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp _ZL20refreshLineWithFlagsP14linenoiseStatei; refreshLineWithFlags(linenoiseState *,int)
loc_4CA3E:
mov dword ptr [rbx+60h], 0
jmp short loc_4CA4E
loc_4CA47:
dec r14d
mov [rbx+60h], r14d
loc_4CA4E:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| void linenoiseEditHistoryNext(long long a1, int a2)
{
int v2; // r14d
long long v3; // r15
long long v4; // rax
int v5; // ecx
bool v6; // sf
int v7; // eax
long long v8; // rax
v2 = history_len;
if ( history_len >= 2 )
{
v3 = history;
free(*(_QWORD *)(history + 8LL * (history_len + ~*(_DWORD *)(a1 + 96))));
v4 = strdup(*(_QWORD *)(a1 + 24));
v5 = *(_DWORD *)(a1 + 96);
*(_QWORD *)(v3 + 8LL * (v2 + ~v5)) = v4;
LODWORD(v4) = 2 * (a2 == 1) - 1;
v6 = v5 + (int)v4 < 0;
v7 = v5 + v4;
*(_DWORD *)(a1 + 96) = v7;
if ( v6 )
{
*(_DWORD *)(a1 + 96) = 0;
}
else if ( v7 >= v2 )
{
*(_DWORD *)(a1 + 96) = v2 - 1;
}
else
{
strncpy(*(_QWORD *)(a1 + 24), *(_QWORD *)(v3 + 8LL * (~v7 + v2)), *(_QWORD *)(a1 + 32));
*(_BYTE *)(*(_QWORD *)(a1 + 24) + *(_QWORD *)(a1 + 32) - 1LL) = 0;
v8 = strlen(*(_QWORD *)(a1 + 24));
*(_QWORD *)(a1 + 56) = v8;
*(_QWORD *)(a1 + 72) = v8;
refreshLineWithFlags(a1, 3);
}
}
}
| linenoiseEditHistoryNext:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14D,dword ptr [0x001ebcf0]
CMP R14D,0x2
JL 0x0014ca4e
MOV EBP,ESI
MOV RBX,RDI
MOV R15,qword ptr [0x001ebcf8]
MOV EAX,dword ptr [RDI + 0x60]
NOT EAX
ADD EAX,R14D
CDQE
MOV RDI,qword ptr [R15 + RAX*0x8]
CALL 0x00119900
MOV RDI,qword ptr [RBX + 0x18]
CALL 0x00119ea0
MOV ECX,dword ptr [RBX + 0x60]
MOV EDX,ECX
NOT EDX
ADD EDX,R14D
MOVSXD RDX,EDX
MOV qword ptr [R15 + RDX*0x8],RAX
XOR EAX,EAX
CMP EBP,0x1
SETZ AL
LEA EAX,[-0x1 + RAX*0x2]
ADD EAX,ECX
MOV dword ptr [RBX + 0x60],EAX
JS 0x0014ca3e
CMP EAX,R14D
JGE 0x0014ca47
NOT EAX
ADD R14D,EAX
MOVSXD RAX,R14D
MOV RSI,qword ptr [R15 + RAX*0x8]
MOV RDI,qword ptr [RBX + 0x18]
MOV RDX,qword ptr [RBX + 0x20]
CALL 0x001193d0
MOV RAX,qword ptr [RBX + 0x18]
MOV RCX,qword ptr [RBX + 0x20]
MOV byte ptr [RAX + RCX*0x1 + -0x1],0x0
MOV RDI,qword ptr [RBX + 0x18]
CALL 0x00119360
MOV qword ptr [RBX + 0x38],RAX
MOV qword ptr [RBX + 0x48],RAX
MOV RDI,RBX
MOV ESI,0x3
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x0014bffa
LAB_0014ca3e:
MOV dword ptr [RBX + 0x60],0x0
JMP 0x0014ca4e
LAB_0014ca47:
DEC R14D
MOV dword ptr [RBX + 0x60],R14D
LAB_0014ca4e:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* linenoiseEditHistoryNext(linenoiseState*, int) */
void linenoiseEditHistoryNext(linenoiseState *param_1,int param_2)
{
int iVar1;
long lVar2;
uint uVar3;
char *pcVar4;
size_t sVar5;
lVar2 = history;
iVar1 = history_len;
if (1 < history_len) {
free(*(void **)(history + (long)(int)(~*(uint *)(param_1 + 0x60) + history_len) * 8));
pcVar4 = strdup(*(char **)(param_1 + 0x18));
uVar3 = *(uint *)(param_1 + 0x60);
*(char **)(lVar2 + (long)(int)(~uVar3 + iVar1) * 8) = pcVar4;
uVar3 = (uint)(param_2 == 1) * 2 + -1 + uVar3;
*(uint *)(param_1 + 0x60) = uVar3;
if ((int)uVar3 < 0) {
*(int4 *)(param_1 + 0x60) = 0;
}
else {
if ((int)uVar3 < iVar1) {
strncpy(*(char **)(param_1 + 0x18),*(char **)(lVar2 + (long)(int)(iVar1 + ~uVar3) * 8),
*(size_t *)(param_1 + 0x20));
*(int1 *)(*(long *)(param_1 + 0x18) + -1 + *(long *)(param_1 + 0x20)) = 0;
sVar5 = strlen(*(char **)(param_1 + 0x18));
*(size_t *)(param_1 + 0x38) = sVar5;
*(size_t *)(param_1 + 0x48) = sVar5;
refreshLineWithFlags(param_1,3);
return;
}
*(int *)(param_1 + 0x60) = iVar1 + -1;
}
}
return;
}
| |
25,059 | directory_file_name | eloqsql/mysys/my_lib.c | static char *directory_file_name (char * dst, const char *src)
{
/* Process as Unix format: just remove test the final slash. */
char *end;
DBUG_ASSERT(strlen(src) < (FN_REFLEN + 1));
if (src[0] == 0)
src= (char*) "."; /* Use empty as current */
end= strnmov(dst, src, FN_REFLEN + 1);
if (end[-1] != FN_LIBCHAR)
{
*end++= FN_LIBCHAR; /* Add last '/' */
*end='\0';
}
return end;
} | O0 | c | directory_file_name:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x8ad12
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x8ad29
leaq 0x579f3(%rip), %rax # 0xe2718
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x201, %edx # imm = 0x201
callq 0xd58d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x2f, %eax
je 0x8ad65
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x2f, (%rax)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
| directory_file_name:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
jmp short $+2
loc_8AD12:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 0
jnz short loc_8AD29
lea rax, aInvalidOrMissi+21h; "."
mov [rbp+var_10], rax
loc_8AD29:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov edx, 201h
call strnmov
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
movsx eax, byte ptr [rax-1]
cmp eax, 2Fh ; '/'
jz short loc_8AD65
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
mov byte ptr [rax], 2Fh ; '/'
mov rax, [rbp+var_18]
mov byte ptr [rax], 0
loc_8AD65:
mov rax, [rbp+var_18]
add rsp, 20h
pop rbp
retn
| _BYTE * directory_file_name(long long a1, char *a2)
{
_BYTE *v2; // rax
_BYTE *v4; // [rsp+8h] [rbp-18h]
char *v5; // [rsp+10h] [rbp-10h]
v5 = a2;
if ( !*a2 )
v5 = ".";
v4 = (_BYTE *)strnmov(a1, v5, 513LL);
if ( *(v4 - 1) != 47 )
{
v2 = v4++;
*v2 = 47;
*v4 = 0;
}
return v4;
}
| directory_file_name:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x0018ad12
LAB_0018ad12:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JNZ 0x0018ad29
LEA RAX,[0x1e2718]
MOV qword ptr [RBP + -0x10],RAX
LAB_0018ad29:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,0x201
CALL 0x001d58d0
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVSX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x2f
JZ 0x0018ad65
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
MOV byte ptr [RAX],0x2f
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],0x0
LAB_0018ad65:
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x20
POP RBP
RET
|
int1 * directory_file_name(int8 param_1,char *param_2)
{
int1 *puVar1;
int1 *local_20;
char *local_18;
local_18 = param_2;
if (*param_2 == '\0') {
local_18 = ".";
}
puVar1 = (int1 *)strnmov(param_1,local_18,0x201);
local_20 = puVar1;
if (puVar1[-1] != '/') {
local_20 = puVar1 + 1;
*puVar1 = 0x2f;
*local_20 = 0;
}
return local_20;
}
| |
25,060 | fill_uchar | eloqsql/strings/ctype.c | static int fill_uchar(uchar *a,uint size,const char *str, size_t len)
{
uint i= 0;
const char *s, *b, *e=str+len;
for (s=str ; s < e ; i++)
{
for ( ; (s < e) && strchr(" \t\r\n",s[0]); s++) ;
b=s;
for ( ; (s < e) && !strchr(" \t\r\n",s[0]); s++) ;
if (s == b || i > size)
break;
a[i]= (uchar) strtoul(b,NULL,16);
}
return 0;
} | O0 | c | fill_uchar:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x70996
jmp 0x708c2
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x41(%rbp)
jae 0x708ee
movq -0x30(%rbp), %rax
movsbl (%rax), %esi
leaq 0xf65c(%rip), %rdi # 0x7ff3b
callq 0x240f0
cmpq $0x0, %rax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x708f7
jmp 0x70907
jmp 0x708f9
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x708c2
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x42(%rbp)
jae 0x7093d
movq -0x30(%rbp), %rax
movsbl (%rax), %esi
leaq 0xf60f(%rip), %rdi # 0x7ff3b
callq 0x240f0
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0x70946
jmp 0x70956
jmp 0x70948
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x7090f
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x70968
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jbe 0x7096a
jmp 0x70996
movq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %edx
callq 0x24430
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x708b2
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nop
| fill_uchar:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_24], 0
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
loc_708B2:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_40]
jnb loc_70996
jmp short $+2
loc_708C2:
mov rcx, [rbp+var_30]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_41], al
jnb short loc_708EE
mov rax, [rbp+var_30]
movsx esi, byte ptr [rax]
lea rdi, asc_7FF3B; " \t\r\n"
call _strchr
cmp rax, 0
setnz al
mov [rbp+var_41], al
loc_708EE:
mov al, [rbp+var_41]
test al, 1
jnz short loc_708F7
jmp short loc_70907
loc_708F7:
jmp short $+2
loc_708F9:
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
jmp short loc_708C2
loc_70907:
mov rax, [rbp+var_30]
mov [rbp+var_38], rax
loc_7090F:
mov rcx, [rbp+var_30]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_42], al
jnb short loc_7093D
mov rax, [rbp+var_30]
movsx esi, byte ptr [rax]
lea rdi, asc_7FF3B; " \t\r\n"
call _strchr
cmp rax, 0
setnz al
xor al, 0FFh
mov [rbp+var_42], al
loc_7093D:
mov al, [rbp+var_42]
test al, 1
jnz short loc_70946
jmp short loc_70956
loc_70946:
jmp short $+2
loc_70948:
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
jmp short loc_7090F
loc_70956:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_38]
jz short loc_70968
mov eax, [rbp+var_24]
cmp eax, [rbp+var_C]
jbe short loc_7096A
loc_70968:
jmp short loc_70996
loc_7096A:
mov rdi, [rbp+var_38]
xor eax, eax
mov esi, eax
mov edx, 10h
call ___isoc23_strtoul
mov dl, al
mov rax, [rbp+var_8]
mov ecx, [rbp+var_24]
mov [rax+rcx], dl
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp loc_708B2
loc_70996:
xor eax, eax
add rsp, 50h
pop rbp
retn
| long long fill_uchar(long long a1, unsigned int a2, char *a3, long long a4)
{
char v5; // [rsp+Eh] [rbp-42h]
bool v6; // [rsp+Fh] [rbp-41h]
unsigned long long v7; // [rsp+10h] [rbp-40h]
char *v8; // [rsp+18h] [rbp-38h]
char *v9; // [rsp+20h] [rbp-30h]
unsigned int v10; // [rsp+2Ch] [rbp-24h]
v10 = 0;
v7 = (unsigned long long)&a3[a4];
v9 = a3;
while ( (unsigned long long)v9 < v7 )
{
while ( 1 )
{
v6 = 0;
if ( (unsigned long long)v9 < v7 )
v6 = strchr(" \t\r\n", (unsigned int)*v9) != 0;
if ( !v6 )
break;
++v9;
}
v8 = v9;
while ( 1 )
{
v5 = 0;
if ( (unsigned long long)v9 < v7 )
v5 = ~(strchr(" \t\r\n", (unsigned int)*v9) != 0);
if ( (v5 & 1) == 0 )
break;
++v9;
}
if ( v9 == v8 || v10 > a2 )
break;
*(_BYTE *)(a1 + v10++) = __isoc23_strtoul(v8, 0LL, 16LL);
}
return 0LL;
}
| fill_uchar:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV dword ptr [RBP + -0x24],0x0
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
LAB_001708b2:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x00170996
JMP 0x001708c2
LAB_001708c2:
MOV RCX,qword ptr [RBP + -0x30]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x41],AL
JNC 0x001708ee
MOV RAX,qword ptr [RBP + -0x30]
MOVSX ESI,byte ptr [RAX]
LEA RDI,[0x17ff3b]
CALL 0x001240f0
CMP RAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x41],AL
LAB_001708ee:
MOV AL,byte ptr [RBP + -0x41]
TEST AL,0x1
JNZ 0x001708f7
JMP 0x00170907
LAB_001708f7:
JMP 0x001708f9
LAB_001708f9:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001708c2
LAB_00170907:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x38],RAX
LAB_0017090f:
MOV RCX,qword ptr [RBP + -0x30]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x42],AL
JNC 0x0017093d
MOV RAX,qword ptr [RBP + -0x30]
MOVSX ESI,byte ptr [RAX]
LEA RDI,[0x17ff3b]
CALL 0x001240f0
CMP RAX,0x0
SETNZ AL
XOR AL,0xff
MOV byte ptr [RBP + -0x42],AL
LAB_0017093d:
MOV AL,byte ptr [RBP + -0x42]
TEST AL,0x1
JNZ 0x00170946
JMP 0x00170956
LAB_00170946:
JMP 0x00170948
LAB_00170948:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0017090f
LAB_00170956:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x38]
JZ 0x00170968
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0xc]
JBE 0x0017096a
LAB_00170968:
JMP 0x00170996
LAB_0017096a:
MOV RDI,qword ptr [RBP + -0x38]
XOR EAX,EAX
MOV ESI,EAX
MOV EDX,0x10
CALL 0x00124430
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0x24]
MOV byte ptr [RAX + RCX*0x1],DL
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
JMP 0x001708b2
LAB_00170996:
XOR EAX,EAX
ADD RSP,0x50
POP RBP
RET
|
int8 fill_uchar(long param_1,uint param_2,char *param_3,long param_4)
{
char *pcVar1;
int1 uVar2;
char *pcVar3;
char *pcVar4;
bool bVar5;
char *local_38;
uint local_2c;
local_2c = 0;
pcVar3 = param_3 + param_4;
local_38 = param_3;
while( true ) {
if (pcVar3 <= local_38) {
return 0;
}
while( true ) {
pcVar1 = local_38;
bVar5 = false;
if (local_38 < pcVar3) {
pcVar4 = strchr(" \t\r\n",(int)*local_38);
bVar5 = pcVar4 != (char *)0x0;
}
if (!bVar5) break;
local_38 = local_38 + 1;
}
while( true ) {
bVar5 = false;
if (local_38 < pcVar3) {
pcVar4 = strchr(" \t\r\n",(int)*local_38);
bVar5 = pcVar4 == (char *)0x0;
}
if (!bVar5) break;
local_38 = local_38 + 1;
}
if (local_38 == pcVar1) break;
if (param_2 < local_2c) {
return 0;
}
uVar2 = __isoc23_strtoul(pcVar1,0,0x10);
*(int1 *)(param_1 + (ulong)local_2c) = uVar2;
local_2c = local_2c + 1;
}
return 0;
}
| |
25,061 | 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 0x5ed43
leaq 0x2d512e(%rip), %rax # 0x333e60
movq (%rax), %rax
callq *0x48(%rax)
movq $0x0, 0x80(%rbx)
movq %r14, %rdi
callq 0x28430
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
jne 0x5ed64
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x28730
leaq 0x2d50f5(%rip), %rax # 0x333e60
movq (%rax), %rax
callq *0x68(%rax)
movq $0x0, 0x38(%rbx)
jmp 0x5ed54
| 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_5ED43
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+48h]
mov qword ptr [rbx+80h], 0
loc_5ED43:
mov rdi, r14
call _pthread_mutex_destroy
mov rdi, [rbx+38h]
test rdi, rdi
jnz short loc_5ED64
loc_5ED54:
add rbx, 8
mov rdi, rbx
pop rbx
pop r14
pop rbp
jmp _pthread_cond_destroy
loc_5ED64:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+68h]
mov qword ptr [rbx+38h], 0
jmp short loc_5ED54
| long long my_thread_destory_thr_mutex(long long a1)
{
if ( *(_QWORD *)(a1 + 128) )
{
PSI_server[9]();
*(_QWORD *)(a1 + 128) = 0LL;
}
pthread_mutex_destroy(a1 + 64);
if ( *(_QWORD *)(a1 + 56) )
{
PSI_server[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 0x0015ed43
LEA RAX,[0x433e60]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [RBX + 0x80],0x0
LAB_0015ed43:
MOV RDI,R14
CALL 0x00128430
MOV RDI,qword ptr [RBX + 0x38]
TEST RDI,RDI
JNZ 0x0015ed64
LAB_0015ed54:
ADD RBX,0x8
MOV RDI,RBX
POP RBX
POP R14
POP RBP
JMP 0x00128730
LAB_0015ed64:
LEA RAX,[0x433e60]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x68]
MOV qword ptr [RBX + 0x38],0x0
JMP 0x0015ed54
|
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;
}
| |
25,062 | test_vector_create | tsotchke[P]eshkol/tests/unit/test_vector.c | static void test_vector_create(void) {
printf("Testing vector creation...\n");
// Create an arena
Arena* arena = arena_create(1024);
assert(arena != NULL);
// Create vectors
VectorF* vf = vector_f_create(arena, 3);
assert(vf != NULL);
assert(vf->dim == 3);
assert(vf->data[0] == 0.0f && vf->data[1] == 0.0f && vf->data[2] == 0.0f);
VectorD* vd = vector_d_create(arena, 4);
assert(vd != NULL);
assert(vd->dim == 4);
assert(vd->data[0] == 0.0 && vd->data[1] == 0.0 && vd->data[2] == 0.0 && vd->data[3] == 0.0);
VectorI* vi = vector_i_create(arena, 2);
assert(vi != NULL);
assert(vi->dim == 2);
assert(vi->data[0] == 0 && vi->data[1] == 0);
// Destroy the arena
arena_destroy(arena);
printf("PASS: vector_create\n");
} | O0 | c | test_vector_create:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x8e8a(%rip), %rdi # 0xa1b9
movb $0x0, %al
callq 0x1080
movl $0x400, %edi # imm = 0x400
callq 0x42a0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x134d
jmp 0x136c
leaq 0x8e81(%rip), %rdi # 0xa1d5
leaq 0x8dd6(%rip), %rsi # 0xa131
movl $0x16, %edx
leaq 0x8e7c(%rip), %rcx # 0xa1e3
callq 0x1090
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x49a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1387
jmp 0x13a6
leaq 0x8e73(%rip), %rdi # 0xa201
leaq 0x8d9c(%rip), %rsi # 0xa131
movl $0x1a, %edx
leaq 0x8e42(%rip), %rcx # 0xa1e3
callq 0x1090
movq -0x10(%rbp), %rax
cmpq $0x3, 0x10(%rax)
jne 0x13b3
jmp 0x13d2
leaq 0x8e52(%rip), %rdi # 0xa20c
leaq 0x8d70(%rip), %rsi # 0xa131
movl $0x1b, %edx
leaq 0x8e16(%rip), %rcx # 0xa1e3
callq 0x1090
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x140c
jp 0x140c
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x140c
jp 0x140c
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x140c
jp 0x140c
jmp 0x142b
leaq 0x8e06(%rip), %rdi # 0xa219
leaq 0x8d17(%rip), %rsi # 0xa131
movl $0x1c, %edx
leaq 0x8dbd(%rip), %rcx # 0xa1e3
callq 0x1090
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x4c00
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1446
jmp 0x1465
leaq 0x8e0e(%rip), %rdi # 0xa25b
leaq 0x8cdd(%rip), %rsi # 0xa131
movl $0x1f, %edx
leaq 0x8d83(%rip), %rcx # 0xa1e3
callq 0x1090
movq -0x18(%rbp), %rax
cmpq $0x4, 0x20(%rax)
jne 0x1472
jmp 0x1491
leaq 0x8ded(%rip), %rdi # 0xa266
leaq 0x8cb1(%rip), %rsi # 0xa131
movl $0x20, %edx
leaq 0x8d57(%rip), %rcx # 0xa1e3
callq 0x1090
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x14e2
jp 0x14e2
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x14e2
jp 0x14e2
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x14e2
jp 0x14e2
movq -0x18(%rbp), %rax
movsd 0x18(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x14e2
jp 0x14e2
jmp 0x1501
leaq 0x8d8a(%rip), %rdi # 0xa273
leaq 0x8c41(%rip), %rsi # 0xa131
movl $0x21, %edx
leaq 0x8ce7(%rip), %rcx # 0xa1e3
callq 0x1090
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x4cc0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x151c
jmp 0x153b
leaq 0x8da5(%rip), %rdi # 0xa2c8
leaq 0x8c07(%rip), %rsi # 0xa131
movl $0x24, %edx
leaq 0x8cad(%rip), %rcx # 0xa1e3
callq 0x1090
movq -0x20(%rbp), %rax
cmpq $0x2, 0x10(%rax)
jne 0x1548
jmp 0x1567
leaq 0x8d84(%rip), %rdi # 0xa2d3
leaq 0x8bdb(%rip), %rsi # 0xa131
movl $0x25, %edx
leaq 0x8c81(%rip), %rcx # 0xa1e3
callq 0x1090
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x157c
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x157c
jmp 0x159b
leaq 0x8d5d(%rip), %rdi # 0xa2e0
leaq 0x8ba7(%rip), %rsi # 0xa131
movl $0x26, %edx
leaq 0x8c4d(%rip), %rcx # 0xa1e3
callq 0x1090
movq -0x8(%rbp), %rdi
callq 0x4880
leaq 0x8d5a(%rip), %rdi # 0xa305
movb $0x0, %al
callq 0x1080
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| test_vector_create:
push rbp
mov rbp, rsp
sub rsp, 20h
lea rdi, aTestingVectorC; "Testing vector creation...\n"
mov al, 0
call _printf
mov edi, 400h
call arena_create
mov [rbp+var_8], rax
cmp [rbp+var_8], 0
jz short loc_134D
jmp short loc_136C
loc_134D:
lea rdi, aArenaNull; "arena != NULL"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 16h
lea rcx, aVoidTestVector; "void test_vector_create(void)"
call ___assert_fail
loc_136C:
mov rdi, [rbp+var_8]
mov esi, 3
call vector_f_create
mov [rbp+var_10], rax
cmp [rbp+var_10], 0
jz short loc_1387
jmp short loc_13A6
loc_1387:
lea rdi, aVfNull; "vf != NULL"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 1Ah
lea rcx, aVoidTestVector; "void test_vector_create(void)"
call ___assert_fail
loc_13A6:
mov rax, [rbp+var_10]
cmp qword ptr [rax+10h], 3
jnz short loc_13B3
jmp short loc_13D2
loc_13B3:
lea rdi, aVfDim3; "vf->dim == 3"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 1Bh
lea rcx, aVoidTestVector; "void test_vector_create(void)"
call ___assert_fail
loc_13D2:
mov rax, [rbp+var_10]
movss xmm0, dword ptr [rax]
xorps xmm1, xmm1
ucomiss xmm0, xmm1
jnz short loc_140C
jp short loc_140C
mov rax, [rbp+var_10]
movss xmm0, dword ptr [rax+4]
xorps xmm1, xmm1
ucomiss xmm0, xmm1
jnz short loc_140C
jp short loc_140C
mov rax, [rbp+var_10]
movss xmm0, dword ptr [rax+8]
xorps xmm1, xmm1
ucomiss xmm0, xmm1
jnz short loc_140C
jp short loc_140C
jmp short loc_142B
loc_140C:
lea rdi, aVfData000fVfDa; "vf->data[0] == 0.0f && vf->data[1] == 0"...
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 1Ch
lea rcx, aVoidTestVector; "void test_vector_create(void)"
call ___assert_fail
loc_142B:
mov rdi, [rbp+var_8]
mov esi, 4
call vector_d_create
mov [rbp+var_18], rax
cmp [rbp+var_18], 0
jz short loc_1446
jmp short loc_1465
loc_1446:
lea rdi, aVdNull; "vd != NULL"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 1Fh
lea rcx, aVoidTestVector; "void test_vector_create(void)"
call ___assert_fail
loc_1465:
mov rax, [rbp+var_18]
cmp qword ptr [rax+20h], 4
jnz short loc_1472
jmp short loc_1491
loc_1472:
lea rdi, aVdDim4; "vd->dim == 4"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 20h ; ' '
lea rcx, aVoidTestVector; "void test_vector_create(void)"
call ___assert_fail
loc_1491:
mov rax, [rbp+var_18]
movsd xmm0, qword ptr [rax]
xorps xmm1, xmm1
ucomisd xmm0, xmm1
jnz short loc_14E2
jp short loc_14E2
mov rax, [rbp+var_18]
movsd xmm0, qword ptr [rax+8]
xorps xmm1, xmm1
ucomisd xmm0, xmm1
jnz short loc_14E2
jp short loc_14E2
mov rax, [rbp+var_18]
movsd xmm0, qword ptr [rax+10h]
xorps xmm1, xmm1
ucomisd xmm0, xmm1
jnz short loc_14E2
jp short loc_14E2
mov rax, [rbp+var_18]
movsd xmm0, qword ptr [rax+18h]
xorps xmm1, xmm1
ucomisd xmm0, xmm1
jnz short loc_14E2
jp short loc_14E2
jmp short loc_1501
loc_14E2:
lea rdi, aVdData000VdDat; "vd->data[0] == 0.0 && vd->data[1] == 0."...
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 21h ; '!'
lea rcx, aVoidTestVector; "void test_vector_create(void)"
call ___assert_fail
loc_1501:
mov rdi, [rbp+var_8]
mov esi, 2
call vector_i_create
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jz short loc_151C
jmp short loc_153B
loc_151C:
lea rdi, aViNull; "vi != NULL"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 24h ; '$'
lea rcx, aVoidTestVector; "void test_vector_create(void)"
call ___assert_fail
loc_153B:
mov rax, [rbp+var_20]
cmp qword ptr [rax+10h], 2
jnz short loc_1548
jmp short loc_1567
loc_1548:
lea rdi, aViDim2; "vi->dim == 2"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 25h ; '%'
lea rcx, aVoidTestVector; "void test_vector_create(void)"
call ___assert_fail
loc_1567:
mov rax, [rbp+var_20]
cmp dword ptr [rax], 0
jnz short loc_157C
mov rax, [rbp+var_20]
cmp dword ptr [rax+4], 0
jnz short loc_157C
jmp short loc_159B
loc_157C:
lea rdi, aViData00ViData; "vi->data[0] == 0 && vi->data[1] == 0"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 26h ; '&'
lea rcx, aVoidTestVector; "void test_vector_create(void)"
call ___assert_fail
loc_159B:
mov rdi, [rbp+var_8]
call arena_destroy
lea rdi, aPassVectorCrea; "PASS: vector_create\n"
mov al, 0
call _printf
add rsp, 20h
pop rbp
retn
| long long test_vector_create(long long a1, long long a2, long long a3)
{
long long v3; // rax
long long v4; // rax
long long v5; // rdx
long long v7; // [rsp+10h] [rbp-10h]
long long v8; // [rsp+18h] [rbp-8h]
printf("Testing vector creation...\n", a2, a3);
v8 = arena_create(1024LL);
if ( !v8 )
__assert_fail(
"arena != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_vector.c",
22LL,
"void test_vector_create(void)");
v7 = vector_f_create(v8, 3LL);
if ( !v7 )
__assert_fail(
"vf != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_vector.c",
26LL,
"void test_vector_create(void)");
if ( *(_QWORD *)(v7 + 16) != 3LL )
__assert_fail(
"vf->dim == 3",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_vector.c",
27LL,
"void test_vector_create(void)");
if ( *(float *)v7 != 0.0 || *(float *)(v7 + 4) != 0.0 || *(float *)(v7 + 8) != 0.0 )
__assert_fail(
"vf->data[0] == 0.0f && vf->data[1] == 0.0f && vf->data[2] == 0.0f",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_vector.c",
28LL,
"void test_vector_create(void)");
v3 = vector_d_create(v8, 4LL);
if ( !v3 )
__assert_fail(
"vd != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_vector.c",
31LL,
"void test_vector_create(void)");
if ( *(_QWORD *)(v3 + 32) != 4LL )
__assert_fail(
"vd->dim == 4",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_vector.c",
32LL,
"void test_vector_create(void)");
if ( *(double *)v3 != 0.0 || *(double *)(v3 + 8) != 0.0 || *(double *)(v3 + 16) != 0.0 || *(double *)(v3 + 24) != 0.0 )
__assert_fail(
"vd->data[0] == 0.0 && vd->data[1] == 0.0 && vd->data[2] == 0.0 && vd->data[3] == 0.0",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_vector.c",
33LL,
"void test_vector_create(void)");
v4 = vector_i_create(v8, 2LL);
if ( !v4 )
__assert_fail(
"vi != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_vector.c",
36LL,
"void test_vector_create(void)");
if ( *(_QWORD *)(v4 + 16) != 2LL )
__assert_fail(
"vi->dim == 2",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_vector.c",
37LL,
"void test_vector_create(void)");
if ( *(_DWORD *)v4 || *(_DWORD *)(v4 + 4) )
__assert_fail(
"vi->data[0] == 0 && vi->data[1] == 0",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_vector.c",
38LL,
"void test_vector_create(void)");
arena_destroy(v8);
return printf("PASS: vector_create\n", 2LL, v5);
}
| test_vector_create:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
LEA RDI,[0x10a1a7]
MOV AL,0x0
CALL 0x00101080
MOV EDI,0x400
CALL 0x001042a0
MOV qword ptr [RBP + -0x8],RAX
CMP qword ptr [RBP + -0x8],0x0
JZ 0x0010134d
JMP 0x0010136c
LAB_0010134d:
LEA RDI,[0x10a1c3]
LEA RSI,[0x10a131]
MOV EDX,0x16
LEA RCX,[0x10a1d1]
CALL 0x00101090
LAB_0010136c:
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,0x3
CALL 0x001049a0
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00101387
JMP 0x001013a6
LAB_00101387:
LEA RDI,[0x10a1ef]
LEA RSI,[0x10a131]
MOV EDX,0x1a
LEA RCX,[0x10a1d1]
CALL 0x00101090
LAB_001013a6:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x10],0x3
JNZ 0x001013b3
JMP 0x001013d2
LAB_001013b3:
LEA RDI,[0x10a1fa]
LEA RSI,[0x10a131]
MOV EDX,0x1b
LEA RCX,[0x10a1d1]
CALL 0x00101090
LAB_001013d2:
MOV RAX,qword ptr [RBP + -0x10]
MOVSS XMM0,dword ptr [RAX]
XORPS XMM1,XMM1
UCOMISS XMM0,XMM1
JNZ 0x0010140c
JP 0x0010140c
MOV RAX,qword ptr [RBP + -0x10]
MOVSS XMM0,dword ptr [RAX + 0x4]
XORPS XMM1,XMM1
UCOMISS XMM0,XMM1
JNZ 0x0010140c
JP 0x0010140c
MOV RAX,qword ptr [RBP + -0x10]
MOVSS XMM0,dword ptr [RAX + 0x8]
XORPS XMM1,XMM1
UCOMISS XMM0,XMM1
JNZ 0x0010140c
JP 0x0010140c
JMP 0x0010142b
LAB_0010140c:
LEA RDI,[0x10a207]
LEA RSI,[0x10a131]
MOV EDX,0x1c
LEA RCX,[0x10a1d1]
CALL 0x00101090
LAB_0010142b:
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,0x4
CALL 0x00104c00
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00101446
JMP 0x00101465
LAB_00101446:
LEA RDI,[0x10a249]
LEA RSI,[0x10a131]
MOV EDX,0x1f
LEA RCX,[0x10a1d1]
CALL 0x00101090
LAB_00101465:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x20],0x4
JNZ 0x00101472
JMP 0x00101491
LAB_00101472:
LEA RDI,[0x10a254]
LEA RSI,[0x10a131]
MOV EDX,0x20
LEA RCX,[0x10a1d1]
CALL 0x00101090
LAB_00101491:
MOV RAX,qword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [RAX]
XORPS XMM1,XMM1
UCOMISD XMM0,XMM1
JNZ 0x001014e2
JP 0x001014e2
MOV RAX,qword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [RAX + 0x8]
XORPS XMM1,XMM1
UCOMISD XMM0,XMM1
JNZ 0x001014e2
JP 0x001014e2
MOV RAX,qword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [RAX + 0x10]
XORPS XMM1,XMM1
UCOMISD XMM0,XMM1
JNZ 0x001014e2
JP 0x001014e2
MOV RAX,qword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [RAX + 0x18]
XORPS XMM1,XMM1
UCOMISD XMM0,XMM1
JNZ 0x001014e2
JP 0x001014e2
JMP 0x00101501
LAB_001014e2:
LEA RDI,[0x10a261]
LEA RSI,[0x10a131]
MOV EDX,0x21
LEA RCX,[0x10a1d1]
CALL 0x00101090
LAB_00101501:
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,0x2
CALL 0x00104cc0
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JZ 0x0010151c
JMP 0x0010153b
LAB_0010151c:
LEA RDI,[0x10a2b6]
LEA RSI,[0x10a131]
MOV EDX,0x24
LEA RCX,[0x10a1d1]
CALL 0x00101090
LAB_0010153b:
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX + 0x10],0x2
JNZ 0x00101548
JMP 0x00101567
LAB_00101548:
LEA RDI,[0x10a2c1]
LEA RSI,[0x10a131]
MOV EDX,0x25
LEA RCX,[0x10a1d1]
CALL 0x00101090
LAB_00101567:
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX],0x0
JNZ 0x0010157c
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX + 0x4],0x0
JNZ 0x0010157c
JMP 0x0010159b
LAB_0010157c:
LEA RDI,[0x10a2ce]
LEA RSI,[0x10a131]
MOV EDX,0x26
LEA RCX,[0x10a1d1]
CALL 0x00101090
LAB_0010159b:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00104880
LEA RDI,[0x10a2f3]
MOV AL,0x0
CALL 0x00101080
ADD RSP,0x20
POP RBP
RET
|
void test_vector_create(void)
{
long lVar1;
float *pfVar2;
double *pdVar3;
int *piVar4;
printf("Testing vector creation...\n");
lVar1 = arena_create(0x400);
if (lVar1 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("arena != NULL","/workspace/llm4binary/github2025/eshkol/tests/unit/test_vector.c"
,0x16,"void test_vector_create(void)");
}
pfVar2 = (float *)vector_f_create(lVar1,3);
if (pfVar2 == (float *)0x0) {
/* WARNING: Subroutine does not return */
__assert_fail("vf != NULL","/workspace/llm4binary/github2025/eshkol/tests/unit/test_vector.c",
0x1a,"void test_vector_create(void)");
}
if (*(long *)(pfVar2 + 4) != 3) {
/* WARNING: Subroutine does not return */
__assert_fail("vf->dim == 3","/workspace/llm4binary/github2025/eshkol/tests/unit/test_vector.c",
0x1b,"void test_vector_create(void)");
}
if ((((*pfVar2 == 0.0) && (!NAN(*pfVar2))) && (pfVar2[1] == 0.0)) && (!NAN(pfVar2[1]))) {
if ((pfVar2[2] == 0.0) && (!NAN(pfVar2[2]))) {
pdVar3 = (double *)vector_d_create(lVar1,4);
if (pdVar3 == (double *)0x0) {
/* WARNING: Subroutine does not return */
__assert_fail("vd != NULL",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_vector.c",0x1f,
"void test_vector_create(void)");
}
if (pdVar3[4] != 1.97626258336499e-323) {
/* WARNING: Subroutine does not return */
__assert_fail("vd->dim == 4",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_vector.c",0x20,
"void test_vector_create(void)");
}
if (((*pdVar3 == 0.0) && (!NAN(*pdVar3))) &&
((pdVar3[1] == 0.0 && (((!NAN(pdVar3[1]) && (pdVar3[2] == 0.0)) && (!NAN(pdVar3[2]))))))) {
if ((pdVar3[3] == 0.0) && (!NAN(pdVar3[3]))) {
piVar4 = (int *)vector_i_create(lVar1,2);
if (piVar4 == (int *)0x0) {
/* WARNING: Subroutine does not return */
__assert_fail("vi != NULL",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_vector.c",0x24,
"void test_vector_create(void)");
}
if (*(long *)(piVar4 + 4) == 2) {
if ((*piVar4 == 0) && (piVar4[1] == 0)) {
arena_destroy(lVar1);
printf("PASS: vector_create\n");
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("vi->data[0] == 0 && vi->data[1] == 0",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_vector.c",0x26,
"void test_vector_create(void)");
}
/* WARNING: Subroutine does not return */
__assert_fail("vi->dim == 2",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_vector.c",0x25,
"void test_vector_create(void)");
}
}
/* WARNING: Subroutine does not return */
__assert_fail("vd->data[0] == 0.0 && vd->data[1] == 0.0 && vd->data[2] == 0.0 && vd->data[3] == 0.0"
,"/workspace/llm4binary/github2025/eshkol/tests/unit/test_vector.c",0x21,
"void test_vector_create(void)");
}
}
/* WARNING: Subroutine does not return */
__assert_fail("vf->data[0] == 0.0f && vf->data[1] == 0.0f && vf->data[2] == 0.0f",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_vector.c",0x1c,
"void test_vector_create(void)");
}
| |
25,063 | nglog::LogMessage::Flush() | ng-log[P]ng-log/src/logging.cc | void LogMessage::Flush() {
if (data_->has_been_flushed_ || data_->severity_ < FLAGS_minloglevel) {
return;
}
data_->num_chars_to_log_ = data_->stream_.pcount();
data_->num_chars_to_syslog_ =
data_->num_chars_to_log_ - data_->num_prefix_chars_;
// Do we need to add a \n to the end of this message?
bool append_newline =
(data_->message_text_[data_->num_chars_to_log_ - 1] != '\n');
char original_final_char = '\0';
// If we do need to add a \n, we'll do it by violating the memory of the
// ostrstream buffer. This is quick, and we'll make sure to undo our
// modification before anything else is done with the ostrstream. It
// would be preferable not to do things this way, but it seems to be
// the best way to deal with this.
if (append_newline) {
original_final_char = data_->message_text_[data_->num_chars_to_log_];
data_->message_text_[data_->num_chars_to_log_++] = '\n';
}
data_->message_text_[data_->num_chars_to_log_] = '\0';
// Prevent any subtle race conditions by wrapping a mutex lock around
// the actual logging action per se.
{
std::lock_guard<std::mutex> l{log_mutex};
(this->*(data_->send_method_))();
++num_messages_[static_cast<int>(data_->severity_)];
}
LogDestination::WaitForSinks(data_);
if (append_newline) {
// Fix the ostrstream back how it was before we screwed with it.
// It's 99.44% certain that we don't need to worry about doing this.
data_->message_text_[data_->num_chars_to_log_ - 1] = original_final_char;
}
// If errno was already set before we enter the logging call, we'll
// set it back to that value when we return from the logging call.
// It happens often that we log an error message after a syscall
// failure, which can potentially set the errno to some other
// values. We would like to preserve the original errno.
if (data_->preserved_errno_ != 0) {
errno = data_->preserved_errno_;
}
// Note that this message is now safely logged. If we're asked to flush
// again, as a result of destruction, say, we'll do nothing on future calls.
data_->has_been_flushed_ = true;
} | O1 | cpp | nglog::LogMessage::Flush():
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x8(%rdi), %rax
cmpb $0x0, 0x76e0(%rax)
jne 0xcb80
movl 0x7698(%rax), %ecx
leaq 0x26076(%rip), %rdx # 0x32a80
cmpl (%rdx), %ecx
jl 0xcb80
movq %rdi, %rbx
movq 0x7568(%rax), %rcx
subq 0x7560(%rax), %rcx
movq %rcx, 0x76c0(%rax)
movq %rcx, %rdx
subq 0x76b8(%rax), %rdx
movq %rdx, 0x76c8(%rax)
movb 0x3(%rcx,%rax), %r14b
cmpb $0xa, %r14b
jne 0xca4a
xorl %ebp, %ebp
jmp 0xca5f
movb 0x4(%rax,%rcx), %bpl
leaq 0x1(%rcx), %rdx
movq %rdx, 0x76c0(%rax)
movb $0xa, 0x4(%rax,%rcx)
movq 0x8(%rbx), %rax
movq 0x76c0(%rax), %rcx
movb $0x0, 0x4(%rax,%rcx)
leaq 0x352a2(%rip), %rdi # 0x41d18
callq 0x77d0
testl %eax, %eax
jne 0xcb89
movq 0x8(%rbx), %rcx
movq 0x76a0(%rcx), %rax
movq 0x76a8(%rcx), %rdi
addq %rbx, %rdi
testb $0x1, %al
je 0xcaa4
movq (%rdi), %rcx
movq -0x1(%rcx,%rax), %rax
callq *%rax
movq 0x8(%rbx), %rax
movslq 0x7698(%rax), %rax
leaq 0x260d8(%rip), %rcx # 0x32b90
incq (%rcx,%rax,8)
leaq 0x35255(%rip), %rdi # 0x41d18
callq 0x73c0
movq 0x8(%rbx), %r15
leaq 0x26145(%rip), %rdi # 0x32c18
callq 0x139be
movq 0x26131(%rip), %rax # 0x32c10
testq %rax, %rax
je 0xcb0b
movq 0x8(%rax), %r12
subq (%rax), %r12
sarq $0x3, %r12
subq $0x1, %r12
jb 0xcb0b
movq 0x26114(%rip), %rax # 0x32c10
movq (%rax), %rax
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0xcaef
movq 0x76a0(%r15), %rax
cmpq 0x254d7(%rip), %rax # 0x31ff0
setne %cl
cmpq 0x25485(%rip), %rax # 0x31fa8
setne %al
testb %al, %cl
jne 0xcb46
cmpq $0x0, 0x76a8(%r15)
jne 0xcb46
movq 0x76b0(%r15), %rdi
testq %rdi, %rdi
je 0xcb46
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x260cb(%rip), %rdi # 0x32c18
callq 0x76d0
cmpb $0xa, %r14b
je 0xcb68
movq 0x8(%rbx), %rax
movq 0x76c0(%rax), %rcx
movb %bpl, 0x3(%rcx,%rax)
movq 0x8(%rbx), %rbx
movl (%rbx), %ebp
testl %ebp, %ebp
je 0xcb79
callq 0x7040
movl %ebp, (%rax)
movb $0x1, 0x76e0(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x7330
jmp 0xcba3
movq %rax, %rbx
leaq 0x3517c(%rip), %rdi # 0x41d18
callq 0x73c0
jmp 0xcbb2
movq %rax, %rbx
leaq 0x2606b(%rip), %rdi # 0x32c18
callq 0x76d0
movq %rbx, %rdi
callq 0x7930
| _ZN5nglog10LogMessage5FlushEv:
push rbp
push r15
push r14
push r12
push rbx
mov rax, [rdi+8]
cmp byte ptr [rax+76E0h], 0
jnz loc_CB80
mov ecx, [rax+7698h]
lea rdx, _ZN3fLI17FLAGS_minloglevelE; fLI::FLAGS_minloglevel
cmp ecx, [rdx]
jl loc_CB80
mov rbx, rdi
mov rcx, [rax+7568h]
sub rcx, [rax+7560h]
mov [rax+76C0h], rcx
mov rdx, rcx
sub rdx, [rax+76B8h]
mov [rax+76C8h], rdx
mov r14b, [rcx+rax+3]
cmp r14b, 0Ah
jnz short loc_CA4A
xor ebp, ebp
jmp short loc_CA5F
loc_CA4A:
mov bpl, [rax+rcx+4]
lea rdx, [rcx+1]
mov [rax+76C0h], rdx
mov byte ptr [rax+rcx+4], 0Ah
loc_CA5F:
mov rax, [rbx+8]
mov rcx, [rax+76C0h]
mov byte ptr [rax+rcx+4], 0
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _pthread_mutex_lock
test eax, eax
jnz loc_CB89
mov rcx, [rbx+8]
mov rax, [rcx+76A0h]
mov rdi, [rcx+76A8h]
add rdi, rbx
test al, 1
jz short loc_CAA4
mov rcx, [rdi]
mov rax, [rcx+rax-1]
loc_CAA4:
call rax
mov rax, [rbx+8]
movsxd rax, dword ptr [rax+7698h]
lea rcx, _ZN5nglog10LogMessage13num_messages_E; nglog::LogMessage::num_messages_
inc qword ptr [rcx+rax*8]
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _pthread_mutex_unlock
mov r15, [rbx+8]
lea rdi, _ZN5nglog14LogDestination11sink_mutex_E; this
call _ZNSt22__shared_mutex_pthread11lock_sharedEv; std::__shared_mutex_pthread::lock_shared(void)
mov rax, cs:_ZN5nglog14LogDestination6sinks_E; nglog::LogDestination::sinks_
test rax, rax
jz short loc_CB0B
mov r12, [rax+8]
sub r12, [rax]
sar r12, 3
loc_CAEF:
sub r12, 1
jb short loc_CB0B
mov rax, cs:_ZN5nglog14LogDestination6sinks_E; nglog::LogDestination::sinks_
mov rax, [rax]
mov rdi, [rax+r12*8]
mov rax, [rdi]
call qword ptr [rax+18h]
jmp short loc_CAEF
loc_CB0B:
mov rax, [r15+76A0h]
cmp rax, cs:_ZN5nglog10LogMessage10SendToSinkEv_ptr
setnz cl
cmp rax, cs:_ZN5nglog10LogMessage16SendToSinkAndLogEv_ptr
setnz al
test cl, al
jnz short loc_CB46
cmp qword ptr [r15+76A8h], 0
jnz short loc_CB46
mov rdi, [r15+76B0h]
test rdi, rdi
jz short loc_CB46
mov rax, [rdi]
call qword ptr [rax+18h]
loc_CB46:
lea rdi, _ZN5nglog14LogDestination11sink_mutex_E; nglog::LogDestination::sink_mutex_
call _pthread_rwlock_unlock
cmp r14b, 0Ah
jz short loc_CB68
mov rax, [rbx+8]
mov rcx, [rax+76C0h]
mov [rcx+rax+3], bpl
loc_CB68:
mov rbx, [rbx+8]
mov ebp, [rbx]
test ebp, ebp
jz short loc_CB79
call ___errno_location
mov [rax], ebp
loc_CB79:
mov byte ptr [rbx+76E0h], 1
loc_CB80:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_CB89:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
jmp short loc_CBA3
mov rbx, rax
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _pthread_mutex_unlock
jmp short loc_CBB2
loc_CBA3:
mov rbx, rax
lea rdi, _ZN5nglog14LogDestination11sink_mutex_E; nglog::LogDestination::sink_mutex_
call _pthread_rwlock_unlock
loc_CBB2:
mov rdi, rbx
call __Unwind_Resume
| long long nglog::LogMessage::Flush(nglog::LogMessage *this)
{
long long result; // rax
long long v3; // rcx
char v4; // r14
char v5; // bp
int v6; // eax
long long v7; // rcx
void ( *v8)(_QWORD); // rax
_QWORD *v9; // rdi
long long v10; // rax
_QWORD *v11; // r15
long long i; // r12
long long v14; // rdi
int *v15; // rbx
int v16; // ebp
result = *((_QWORD *)this + 1);
if ( !*(_BYTE *)(result + 30432) && *(_DWORD *)(result + 30360) >= fLI::FLAGS_minloglevel )
{
v3 = *(_QWORD *)(result + 30056) - *(_QWORD *)(result + 30048);
*(_QWORD *)(result + 30400) = v3;
*(_QWORD *)(result + 30408) = v3 - *(_QWORD *)(result + 30392);
v4 = *(_BYTE *)(v3 + result + 3);
if ( v4 == 10 )
{
v5 = 0;
}
else
{
v5 = *(_BYTE *)(result + v3 + 4);
*(_QWORD *)(result + 30400) = v3 + 1;
*(_BYTE *)(result + v3 + 4) = 10;
}
*(_BYTE *)(*((_QWORD *)this + 1) + *(_QWORD *)(*((_QWORD *)this + 1) + 30400LL) + 4LL) = 0;
v6 = pthread_mutex_lock(&nglog::log_mutex);
if ( v6 )
std::__throw_system_error(v6);
v7 = *((_QWORD *)this + 1);
v8 = *(void ( **)(_QWORD))(v7 + 30368);
v9 = (_QWORD *)((char *)this + *(_QWORD *)(v7 + 30376));
if ( ((unsigned __int8)v8 & 1) != 0 )
v8 = *(void ( **)(_QWORD))((char *)v8 + *v9 - 1);
v8(v9);
v10 = *(int *)(*((_QWORD *)this + 1) + 30360LL);
++nglog::LogMessage::num_messages_[v10];
pthread_mutex_unlock(&nglog::log_mutex);
v11 = (_QWORD *)*((_QWORD *)this + 1);
std::__shared_mutex_pthread::lock_shared((std::__shared_mutex_pthread *)&nglog::LogDestination::sink_mutex_);
if ( nglog::LogDestination::sinks_ )
{
for ( i = (long long)(*(_QWORD *)(nglog::LogDestination::sinks_ + 8) - *(_QWORD *)nglog::LogDestination::sinks_) >> 3;
i-- != 0;
(*(void ( **)(_QWORD))(**(_QWORD **)(*(_QWORD *)nglog::LogDestination::sinks_ + 8 * i) + 24LL))(*(_QWORD *)(*(_QWORD *)nglog::LogDestination::sinks_ + 8 * i)) )
{
;
}
}
if ( (v11[3796] == (_QWORD)nglog::LogMessage::SendToSinkAndLog || v11[3796] == (_QWORD)nglog::LogMessage::SendToSink)
&& !v11[3797] )
{
v14 = v11[3798];
if ( v14 )
(*(void ( **)(long long))(*(_QWORD *)v14 + 24LL))(v14);
}
result = pthread_rwlock_unlock(&nglog::LogDestination::sink_mutex_);
if ( v4 != 10 )
{
result = *((_QWORD *)this + 1);
*(_BYTE *)(*(_QWORD *)(result + 30400) + result + 3) = v5;
}
v15 = (int *)*((_QWORD *)this + 1);
v16 = *v15;
if ( *v15 )
{
result = __errno_location();
*(_DWORD *)result = v16;
}
*((_BYTE *)v15 + 30432) = 1;
}
return result;
}
| Flush:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RAX,qword ptr [RDI + 0x8]
CMP byte ptr [RAX + 0x76e0],0x0
JNZ 0x0010cb80
MOV ECX,dword ptr [RAX + 0x7698]
LEA RDX,[0x132a80]
CMP ECX,dword ptr [RDX]
JL 0x0010cb80
MOV RBX,RDI
MOV RCX,qword ptr [RAX + 0x7568]
SUB RCX,qword ptr [RAX + 0x7560]
MOV qword ptr [RAX + 0x76c0],RCX
MOV RDX,RCX
SUB RDX,qword ptr [RAX + 0x76b8]
MOV qword ptr [RAX + 0x76c8],RDX
MOV R14B,byte ptr [RCX + RAX*0x1 + 0x3]
CMP R14B,0xa
JNZ 0x0010ca4a
XOR EBP,EBP
JMP 0x0010ca5f
LAB_0010ca4a:
MOV BPL,byte ptr [RAX + RCX*0x1 + 0x4]
LEA RDX,[RCX + 0x1]
MOV qword ptr [RAX + 0x76c0],RDX
MOV byte ptr [RAX + RCX*0x1 + 0x4],0xa
LAB_0010ca5f:
MOV RAX,qword ptr [RBX + 0x8]
MOV RCX,qword ptr [RAX + 0x76c0]
MOV byte ptr [RAX + RCX*0x1 + 0x4],0x0
LEA RDI,[0x141d18]
CALL 0x001077d0
TEST EAX,EAX
JNZ 0x0010cb89
MOV RCX,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RCX + 0x76a0]
MOV RDI,qword ptr [RCX + 0x76a8]
ADD RDI,RBX
TEST AL,0x1
JZ 0x0010caa4
MOV RCX,qword ptr [RDI]
MOV RAX,qword ptr [RCX + RAX*0x1 + -0x1]
LAB_0010caa4:
CALL RAX
LAB_0010caa6:
MOV RAX,qword ptr [RBX + 0x8]
MOVSXD RAX,dword ptr [RAX + 0x7698]
LEA RCX,[0x132b90]
INC qword ptr [RCX + RAX*0x8]
LEA RDI,[0x141d18]
CALL 0x001073c0
MOV R15,qword ptr [RBX + 0x8]
LEA RDI,[0x132c18]
CALL 0x001139be
MOV RAX,qword ptr [0x00132c10]
TEST RAX,RAX
JZ 0x0010cb0b
MOV R12,qword ptr [RAX + 0x8]
SUB R12,qword ptr [RAX]
SAR R12,0x3
LAB_0010caef:
SUB R12,0x1
JC 0x0010cb0b
MOV RAX,qword ptr [0x00132c10]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + R12*0x8]
MOV RAX,qword ptr [RDI]
LAB_0010cb06:
CALL qword ptr [RAX + 0x18]
JMP 0x0010caef
LAB_0010cb0b:
MOV RAX,qword ptr [R15 + 0x76a0]
CMP RAX,qword ptr [0x00131ff0]
SETNZ CL
CMP RAX,qword ptr [0x00131fa8]
SETNZ AL
TEST CL,AL
JNZ 0x0010cb46
CMP qword ptr [R15 + 0x76a8],0x0
JNZ 0x0010cb46
MOV RDI,qword ptr [R15 + 0x76b0]
TEST RDI,RDI
JZ 0x0010cb46
MOV RAX,qword ptr [RDI]
LAB_0010cb43:
CALL qword ptr [RAX + 0x18]
LAB_0010cb46:
LEA RDI,[0x132c18]
CALL 0x001076d0
CMP R14B,0xa
JZ 0x0010cb68
MOV RAX,qword ptr [RBX + 0x8]
MOV RCX,qword ptr [RAX + 0x76c0]
MOV byte ptr [RCX + RAX*0x1 + 0x3],BPL
LAB_0010cb68:
MOV RBX,qword ptr [RBX + 0x8]
MOV EBP,dword ptr [RBX]
TEST EBP,EBP
JZ 0x0010cb79
CALL 0x00107040
MOV dword ptr [RAX],EBP
LAB_0010cb79:
MOV byte ptr [RBX + 0x76e0],0x1
LAB_0010cb80:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0010cb89:
MOV EDI,EAX
CALL 0x00107330
|
/* nglog::LogMessage::Flush() */
void __thiscall nglog::LogMessage::Flush(LogMessage *this)
{
char cVar1;
long lVar2;
int *piVar3;
int iVar4;
code *pcVar5;
int *piVar6;
long lVar7;
int1 uVar8;
bool bVar9;
lVar2 = *(long *)(this + 8);
if ((*(char *)(lVar2 + 0x76e0) == '\0') && (fLI::FLAGS_minloglevel <= *(int *)(lVar2 + 0x7698))) {
lVar7 = *(long *)(lVar2 + 0x7568) - *(long *)(lVar2 + 0x7560);
*(long *)(lVar2 + 0x76c0) = lVar7;
*(long *)(lVar2 + 0x76c8) = lVar7 - *(long *)(lVar2 + 0x76b8);
cVar1 = *(char *)(lVar7 + 3 + lVar2);
if (cVar1 == '\n') {
uVar8 = 0;
}
else {
uVar8 = *(int1 *)(lVar2 + 4 + lVar7);
*(long *)(lVar2 + 0x76c0) = lVar7 + 1;
*(int1 *)(lVar2 + 4 + lVar7) = 10;
}
*(int1 *)(*(long *)(this + 8) + 4 + *(long *)(*(long *)(this + 8) + 0x76c0)) = 0;
iVar4 = pthread_mutex_lock((pthread_mutex_t *)log_mutex);
if (iVar4 != 0) {
/* WARNING: Subroutine does not return */
std::__throw_system_error(iVar4);
}
pcVar5 = *(code **)(*(long *)(this + 8) + 0x76a0);
if (((ulong)pcVar5 & 1) != 0) {
pcVar5 = *(code **)(pcVar5 + *(long *)(this + *(long *)(*(long *)(this + 8) + 0x76a8)) + -1);
}
/* try { // try from 0010caa4 to 0010caa5 has its CatchHandler @ 0010cb92 */
(*pcVar5)();
*(long *)(num_messages_ + (long)*(int *)(*(long *)(this + 8) + 0x7698) * 8) =
*(long *)(num_messages_ + (long)*(int *)(*(long *)(this + 8) + 0x7698) * 8) + 1;
pthread_mutex_unlock((pthread_mutex_t *)log_mutex);
lVar2 = *(long *)(this + 8);
std::__shared_mutex_pthread::lock_shared((__shared_mutex_pthread *)LogDestination::sink_mutex_);
if (LogDestination::sinks_ != (long *)0x0) {
lVar7 = LogDestination::sinks_[1] - *LogDestination::sinks_ >> 3;
while (bVar9 = lVar7 != 0, lVar7 = lVar7 + -1, bVar9) {
/* try { // try from 0010cb06 to 0010cb08 has its CatchHandler @ 0010cba3 */
(**(code **)(**(long **)(*LogDestination::sinks_ + lVar7 * 8) + 0x18))();
}
}
if (((*(int **)(lVar2 + 0x76a0) == PTR_SendToSink_00131ff0 ||
*(int **)(lVar2 + 0x76a0) == PTR_SendToSinkAndLog_00131fa8) &&
(*(long *)(lVar2 + 0x76a8) == 0)) && (*(long **)(lVar2 + 0x76b0) != (long *)0x0)) {
/* try { // try from 0010cb43 to 0010cb45 has its CatchHandler @ 0010cb90 */
(**(code **)(**(long **)(lVar2 + 0x76b0) + 0x18))();
}
pthread_rwlock_unlock((pthread_rwlock_t *)LogDestination::sink_mutex_);
if (cVar1 != '\n') {
*(int1 *)(*(long *)(*(long *)(this + 8) + 0x76c0) + 3 + *(long *)(this + 8)) = uVar8;
}
piVar3 = *(int **)(this + 8);
iVar4 = *piVar3;
if (iVar4 != 0) {
piVar6 = __errno_location();
*piVar6 = iVar4;
}
*(int1 *)(piVar3 + 0x1db8) = 1;
}
return;
}
| |
25,064 | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::scan_comment() | monkey531[P]llama/common/json.hpp | bool scan_comment()
{
switch (get())
{
// single-line comments skip input until a newline or EOF is read
case '/':
{
while (true)
{
switch (get())
{
case '\n':
case '\r':
case char_traits<char_type>::eof():
case '\0':
return true;
default:
break;
}
}
}
// multi-line comments skip input until */ is read
case '*':
{
while (true)
{
switch (get())
{
case char_traits<char_type>::eof():
case '\0':
{
error_message = "invalid comment; missing closing '*/'";
return false;
}
case '*':
{
switch (get())
{
case '/':
return true;
default:
{
unget();
continue;
}
}
}
default:
continue;
}
}
}
// unexpected character after reading '/'
default:
{
error_message = "invalid comment; expecting '/' or '*' after '/'";
return false;
}
}
} | O1 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::scan_comment():
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x18e4e
cmpl $0x2f, %eax
je 0x451a9
cmpl $0x2a, %eax
jne 0x451c6
movq %rbx, %rdi
callq 0x18e4e
leal 0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x451cf
cmpl $0x2a, %eax
jne 0x4517d
movq %rbx, %rdi
callq 0x18e4e
cmpl $0x2f, %eax
je 0x451c2
movq %rbx, %rdi
callq 0x45a92
jmp 0x4517d
movl $0x4803, %ebp # imm = 0x4803
movq %rbx, %rdi
callq 0x18e4e
incl %eax
cmpl $0xf, %eax
jae 0x451ae
btl %eax, %ebp
jae 0x451ae
movb $0x1, %al
jmp 0x451dc
leaq 0x66ba6(%rip), %rax # 0xabd73
jmp 0x451d6
leaq 0x66b77(%rip), %rax # 0xabd4d
movq %rax, 0x70(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE12scan_commentEv:
push rbp
push rbx
push rax
mov rbx, rdi
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
cmp eax, 2Fh ; '/'
jz short loc_451A9
cmp eax, 2Ah ; '*'
jnz short loc_451C6
loc_4517D:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
lea ecx, [rax+1]
cmp ecx, 2
jb short loc_451CF
cmp eax, 2Ah ; '*'
jnz short loc_4517D
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
cmp eax, 2Fh ; '/'
jz short loc_451C2
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5ungetEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::unget(void)
jmp short loc_4517D
loc_451A9:
mov ebp, 4803h
loc_451AE:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
inc eax
cmp eax, 0Fh
jnb short loc_451AE
bt ebp, eax
jnb short loc_451AE
loc_451C2:
mov al, 1
jmp short loc_451DC
loc_451C6:
lea rax, aInvalidComment; "invalid comment; expecting '/' or '*' a"...
jmp short loc_451D6
loc_451CF:
lea rax, aInvalidComment_0; "invalid comment; missing closing '*/'"
loc_451D6:
mov [rbx+70h], rax
xor eax, eax
loc_451DC:
add rsp, 8
pop rbx
pop rbp
retn
| char nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::scan_comment(
__m128i *a1)
{
int v1; // eax
int v2; // eax
int v3; // ebp
unsigned int v4; // eax
const char *v6; // rax
v1 = nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1);
if ( v1 == 47 )
{
v3 = 18435;
do
{
do
v4 = nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1)
+ 1;
while ( v4 >= 0xF );
}
while ( !_bittest(&v3, v4) );
return 1;
}
else
{
if ( v1 == 42 )
{
while ( 1 )
{
v2 = nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1);
if ( (unsigned int)(v2 + 1) < 2 )
break;
if ( v2 == 42 )
{
if ( (unsigned int)nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1) == 47 )
return 1;
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::unget(a1);
}
}
v6 = "invalid comment; missing closing '*/'";
}
else
{
v6 = "invalid comment; expecting '/' or '*' after '/'";
}
a1[7].m128i_i64[0] = (long long)v6;
return 0;
}
}
| scan_comment:
PUSH RBP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x00118e4e
CMP EAX,0x2f
JZ 0x001451a9
CMP EAX,0x2a
JNZ 0x001451c6
LAB_0014517d:
MOV RDI,RBX
CALL 0x00118e4e
LEA ECX,[RAX + 0x1]
CMP ECX,0x2
JC 0x001451cf
CMP EAX,0x2a
JNZ 0x0014517d
MOV RDI,RBX
CALL 0x00118e4e
CMP EAX,0x2f
JZ 0x001451c2
MOV RDI,RBX
CALL 0x00145a92
JMP 0x0014517d
LAB_001451a9:
MOV EBP,0x4803
LAB_001451ae:
MOV RDI,RBX
CALL 0x00118e4e
INC EAX
CMP EAX,0xf
JNC 0x001451ae
BT EBP,EAX
JNC 0x001451ae
LAB_001451c2:
MOV AL,0x1
JMP 0x001451dc
LAB_001451c6:
LEA RAX,[0x1abd73]
JMP 0x001451d6
LAB_001451cf:
LEA RAX,[0x1abd4d]
LAB_001451d6:
MOV qword ptr [RBX + 0x70],RAX
XOR EAX,EAX
LAB_001451dc:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::scan_comment() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::scan_comment(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this)
{
int iVar1;
int8 uVar2;
char *pcVar3;
iVar1 = get(this);
if (iVar1 == 0x2f) {
do {
do {
iVar1 = get(this);
} while (0xe < iVar1 + 1U);
} while ((0x4803U >> (iVar1 + 1U & 0x1f) & 1) == 0);
LAB_001451c2:
uVar2 = 1;
}
else {
if (iVar1 == 0x2a) {
while (iVar1 = get(this), 1 < iVar1 + 1U) {
if (iVar1 == 0x2a) {
iVar1 = get(this);
if (iVar1 == 0x2f) goto LAB_001451c2;
unget(this);
}
}
pcVar3 = "invalid comment; missing closing \'*/\'";
}
else {
pcVar3 = "invalid comment; expecting \'/\' or \'*\' after \'/\'";
}
*(char **)(this + 0x70) = pcVar3;
uVar2 = 0;
}
return uVar2;
}
| |
25,065 | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::scan_comment() | monkey531[P]llama/common/json.hpp | bool scan_comment()
{
switch (get())
{
// single-line comments skip input until a newline or EOF is read
case '/':
{
while (true)
{
switch (get())
{
case '\n':
case '\r':
case char_traits<char_type>::eof():
case '\0':
return true;
default:
break;
}
}
}
// multi-line comments skip input until */ is read
case '*':
{
while (true)
{
switch (get())
{
case char_traits<char_type>::eof():
case '\0':
{
error_message = "invalid comment; missing closing '*/'";
return false;
}
case '*':
{
switch (get())
{
case '/':
return true;
default:
{
unget();
continue;
}
}
}
default:
continue;
}
}
}
// unexpected character after reading '/'
default:
{
error_message = "invalid comment; expecting '/' or '*' after '/'";
return false;
}
}
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::scan_comment():
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x18e36
cmpl $0x2f, %eax
je 0x444ef
cmpl $0x2a, %eax
jne 0x4450c
movq %rbx, %rdi
callq 0x18e36
leal 0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x44515
cmpl $0x2a, %eax
jne 0x444c3
movq %rbx, %rdi
callq 0x18e36
cmpl $0x2f, %eax
je 0x44508
movq %rbx, %rdi
callq 0x44d7e
jmp 0x444c3
movl $0x4803, %ebp # imm = 0x4803
movq %rbx, %rdi
callq 0x18e36
incl %eax
cmpl $0xf, %eax
jae 0x444f4
btl %eax, %ebp
jae 0x444f4
movb $0x1, %al
jmp 0x44522
leaq 0x65850(%rip), %rax # 0xa9d63
jmp 0x4451c
leaq 0x65821(%rip), %rax # 0xa9d3d
movq %rax, 0x70(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE12scan_commentEv:
push rbp
push rbx
push rax
mov rbx, rdi
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
cmp eax, 2Fh ; '/'
jz short loc_444EF
cmp eax, 2Ah ; '*'
jnz short loc_4450C
loc_444C3:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
lea ecx, [rax+1]
cmp ecx, 2
jb short loc_44515
cmp eax, 2Ah ; '*'
jnz short loc_444C3
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
cmp eax, 2Fh ; '/'
jz short loc_44508
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5ungetEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::unget(void)
jmp short loc_444C3
loc_444EF:
mov ebp, 4803h
loc_444F4:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
inc eax
cmp eax, 0Fh
jnb short loc_444F4
bt ebp, eax
jnb short loc_444F4
loc_44508:
mov al, 1
jmp short loc_44522
loc_4450C:
lea rax, aInvalidComment; "invalid comment; expecting '/' or '*' a"...
jmp short loc_4451C
loc_44515:
lea rax, aInvalidComment_0; "invalid comment; missing closing '*/'"
loc_4451C:
mov [rbx+70h], rax
xor eax, eax
loc_44522:
add rsp, 8
pop rbx
pop rbp
retn
| char nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::scan_comment(
__m128i *a1)
{
int v1; // eax
int v2; // eax
int v3; // ebp
unsigned int v4; // eax
const char *v6; // rax
v1 = nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1);
if ( v1 == 47 )
{
v3 = 18435;
do
{
do
v4 = nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1)
+ 1;
while ( v4 >= 0xF );
}
while ( !_bittest(&v3, v4) );
return 1;
}
else
{
if ( v1 == 42 )
{
while ( 1 )
{
v2 = nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1);
if ( (unsigned int)(v2 + 1) < 2 )
break;
if ( v2 == 42 )
{
if ( (unsigned int)nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1) == 47 )
return 1;
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::unget(a1);
}
}
v6 = "invalid comment; missing closing '*/'";
}
else
{
v6 = "invalid comment; expecting '/' or '*' after '/'";
}
a1[7].m128i_i64[0] = (long long)v6;
return 0;
}
}
| scan_comment:
PUSH RBP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x00118e36
CMP EAX,0x2f
JZ 0x001444ef
CMP EAX,0x2a
JNZ 0x0014450c
LAB_001444c3:
MOV RDI,RBX
CALL 0x00118e36
LEA ECX,[RAX + 0x1]
CMP ECX,0x2
JC 0x00144515
CMP EAX,0x2a
JNZ 0x001444c3
MOV RDI,RBX
CALL 0x00118e36
CMP EAX,0x2f
JZ 0x00144508
MOV RDI,RBX
CALL 0x00144d7e
JMP 0x001444c3
LAB_001444ef:
MOV EBP,0x4803
LAB_001444f4:
MOV RDI,RBX
CALL 0x00118e36
INC EAX
CMP EAX,0xf
JNC 0x001444f4
BT EBP,EAX
JNC 0x001444f4
LAB_00144508:
MOV AL,0x1
JMP 0x00144522
LAB_0014450c:
LEA RAX,[0x1a9d63]
JMP 0x0014451c
LAB_00144515:
LEA RAX,[0x1a9d3d]
LAB_0014451c:
MOV qword ptr [RBX + 0x70],RAX
XOR EAX,EAX
LAB_00144522:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::scan_comment() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::scan_comment(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this)
{
int iVar1;
int8 uVar2;
char *pcVar3;
iVar1 = get(this);
if (iVar1 == 0x2f) {
do {
do {
iVar1 = get(this);
} while (0xe < iVar1 + 1U);
} while ((0x4803U >> (iVar1 + 1U & 0x1f) & 1) == 0);
LAB_00144508:
uVar2 = 1;
}
else {
if (iVar1 == 0x2a) {
while (iVar1 = get(this), 1 < iVar1 + 1U) {
if (iVar1 == 0x2a) {
iVar1 = get(this);
if (iVar1 == 0x2f) goto LAB_00144508;
unget(this);
}
}
pcVar3 = "invalid comment; missing closing \'*/\'";
}
else {
pcVar3 = "invalid comment; expecting \'/\' or \'*\' after \'/\'";
}
*(char **)(this + 0x70) = pcVar3;
uVar2 = 0;
}
return uVar2;
}
| |
25,066 | compile_if_stmt_cont | fabiosvm[P]rak/src/compiler.c | static inline void compile_if_stmt_cont(RakCompiler *comp, uint16_t *off, RakError *err)
{
if (!match(comp, RAK_TOKEN_KIND_ELSE_KW))
{
emit_instr(comp, rak_pop_instr(), err);
if (!rak_is_ok(err)) return;
*off = (uint16_t) comp->chunk.instrs.len;
return;
}
next(comp, err);
if (match(comp, RAK_TOKEN_KIND_IF_KW))
{
emit_instr(comp, rak_pop_instr(), err);
if (!rak_is_ok(err)) return;
compile_if_stmt(comp, off, err);
return;
}
if (!match(comp, RAK_TOKEN_KIND_LBRACE))
{
expected_token_error(err, RAK_TOKEN_KIND_LBRACE, comp->lex.tok);
return;
}
compile_block(comp, err);
if (!rak_is_ok(err)) return;
*off = (uint16_t) comp->chunk.instrs.len;
} | O3 | c | compile_if_stmt_cont:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpl $0x26, 0x2810(%rdi)
jne 0x642e
leaq 0x27f8(%r14), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x679a
cmpb $0x1, (%rbx)
jne 0x644f
movl 0x2810(%r14), %r13d
cmpl $0x8, %r13d
je 0x645e
cmpl $0x28, %r13d
jne 0x649e
movq %r14, %rdi
movl $0xc, %esi
movq %rbx, %rdx
callq 0x392d
cmpb $0x1, (%rbx)
jne 0x644f
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x48c7
movq %r14, %rdi
movl $0xc, %esi
movq %rbx, %rdx
callq 0x392d
cmpb $0x1, (%rbx)
jne 0x644f
movzwl 0xffc(%r14), %eax
movw %ax, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
movq %rbx, %rsi
callq 0x679a
movb (%rbx), %al
cmpb $0x1, %al
jne 0x6534
incl 0x2828(%r14)
cmpl $0x9, 0x2810(%r14)
je 0x6516
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b13
movb (%rbx), %al
testb %al, %al
jne 0x647a
jmp 0x6534
movl 0x2814(%r14), %ebp
movl 0x2818(%r14), %r15d
movl 0x281c(%r14), %r12d
movq 0x2820(%r14), %r14
movl $0x8, %edi
callq 0x6764
testl %r13d, %r13d
je 0x64ef
movl %r15d, (%rsp)
leaq 0x3fd2(%rip), %rsi # 0xa4a6
movq %rbx, %rdi
movq %rax, %rdx
movl %r12d, %ecx
movq %r14, %r8
movl %ebp, %r9d
xorl %eax, %eax
callq 0x666c
jmp 0x644f
leaq 0x3f86(%rip), %rsi # 0xa47c
movq %rbx, %rdi
movq %rax, %rdx
movl %ebp, %ecx
movl %r15d, %r8d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x666c
movq %r12, %rdi
movq %rbx, %rsi
callq 0x679a
movb (%rbx), %al
cmpb $0x1, %al
jne 0x6534
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4afb
movb (%rbx), %al
testb $0x1, %al
jne 0x6443
jmp 0x644f
| compile_if_stmt_cont:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdx
mov r15, rsi
mov r14, rdi
cmp dword ptr [rdi+2810h], 26h ; '&'
jnz short loc_642E
lea r12, [r14+27F8h]
mov rdi, r12
mov rsi, rbx
call rak_lexer_next
cmp byte ptr [rbx], 1
jnz short loc_644F
mov r13d, [r14+2810h]
cmp r13d, 8
jz short loc_645E
cmp r13d, 28h ; '('
jnz loc_649E
mov rdi, r14
mov esi, 0Ch
mov rdx, rbx
call rak_chunk_append_instr
cmp byte ptr [rbx], 1
jnz short loc_644F
mov rdi, r14
mov rsi, r15
mov rdx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp compile_if_stmt
loc_642E:
mov rdi, r14
mov esi, 0Ch
mov rdx, rbx
call rak_chunk_append_instr
cmp byte ptr [rbx], 1
jnz short loc_644F
loc_6443:
movzx eax, word ptr [r14+0FFCh]
mov [r15], ax
loc_644F:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_645E:
mov rdi, r12
mov rsi, rbx
call rak_lexer_next
mov al, [rbx]
cmp al, 1
jnz loc_6534
inc dword ptr [r14+2828h]
loc_647A:
cmp dword ptr [r14+2810h], 9
jz loc_6516
mov rdi, r14
mov rsi, rbx
call compile_stmt
mov al, [rbx]
test al, al
jnz short loc_647A
jmp loc_6534
loc_649E:
mov ebp, [r14+2814h]
mov r15d, [r14+2818h]
mov r12d, [r14+281Ch]
mov r14, [r14+2820h]
mov edi, 8
call rak_token_kind_to_cstr
test r13d, r13d
jz short loc_64EF
mov [rsp+38h+var_38], r15d
lea rsi, aExpectedSButGo_0; "expected %s, but got '%.*s' at %d:%d"
mov rdi, rbx
mov rdx, rax
mov ecx, r12d
mov r8, r14
mov r9d, ebp
xor eax, eax
call rak_error_set
jmp loc_644F
loc_64EF:
lea rsi, aExpectedSButGo; "expected %s, but got end of file at %d:"...
mov rdi, rbx
mov rdx, rax
mov ecx, ebp
mov r8d, r15d
xor eax, eax
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp rak_error_set
loc_6516:
mov rdi, r12
mov rsi, rbx
call rak_lexer_next
mov al, [rbx]
cmp al, 1
jnz short loc_6534
mov rdi, r14
mov rsi, rbx
call end_scope
mov al, [rbx]
loc_6534:
test al, 1
jnz loc_6443
jmp loc_644F
| char compile_if_stmt_cont(long long a1, unsigned __int16 *a2, char *a3, int a4, int a5, int a6)
{
unsigned __int16 v7; // ax
int v8; // ecx
int v9; // r8d
int v10; // r9d
int v11; // r13d
int v12; // ebp
int v13; // r15d
int v14; // r12d
long long v15; // r14
int v16; // eax
int v17; // r9d
long long v18; // rdx
int v19; // ecx
int v20; // r8d
int v21; // r9d
if ( *(_DWORD *)(a1 + 10256) != 38 )
{
LOBYTE(v7) = rak_chunk_append_instr(a1, 12, a3, a4, a5, a6);
if ( *a3 != 1 )
return v7;
goto LABEL_8;
}
LOBYTE(v7) = rak_lexer_next(a1 + 10232, a3);
if ( *a3 != 1 )
return v7;
v11 = *(_DWORD *)(a1 + 10256);
if ( v11 != 8 )
{
if ( v11 == 40 )
{
LOBYTE(v7) = rak_chunk_append_instr(a1, 12, a3, v8, v9, v10);
if ( *a3 == 1 )
LOBYTE(v7) = compile_if_stmt(a1, a2, a3);
}
else
{
v12 = *(_DWORD *)(a1 + 10260);
v13 = *(_DWORD *)(a1 + 10264);
v14 = *(_DWORD *)(a1 + 10268);
v15 = *(_QWORD *)(a1 + 10272);
v16 = rak_token_kind_to_cstr(8LL);
if ( v11 )
LOBYTE(v7) = rak_error_set((_DWORD)a3, (unsigned int)"expected %s, but got '%.*s' at %d:%d", v16, v14, v15, v12);
else
LOBYTE(v7) = rak_error_set(
(_DWORD)a3,
(unsigned int)"expected %s, but got end of file at %d:%d",
v16,
v12,
v13,
v17);
}
return v7;
}
rak_lexer_next(a1 + 10232, a3);
LOBYTE(v7) = *a3;
if ( *a3 == 1 )
{
++*(_DWORD *)(a1 + 10280);
while ( *(_DWORD *)(a1 + 10256) != 9 )
{
compile_stmt(a1, a3);
LOBYTE(v7) = *a3;
if ( !*a3 )
goto LABEL_20;
}
rak_lexer_next(a1 + 10232, a3);
LOBYTE(v7) = *a3;
if ( *a3 == 1 )
{
end_scope(a1, a3, v18, v19, v20, v21);
LOBYTE(v7) = *a3;
}
}
LABEL_20:
if ( (v7 & 1) != 0 )
{
LABEL_8:
v7 = *(_WORD *)(a1 + 4092);
*a2 = v7;
}
return v7;
}
| compile_if_stmt_cont:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R15,RSI
MOV R14,RDI
CMP dword ptr [RDI + 0x2810],0x26
JNZ 0x0010642e
LEA R12,[R14 + 0x27f8]
MOV RDI,R12
MOV RSI,RBX
CALL 0x0010679a
CMP byte ptr [RBX],0x1
JNZ 0x0010644f
MOV R13D,dword ptr [R14 + 0x2810]
CMP R13D,0x8
JZ 0x0010645e
CMP R13D,0x28
JNZ 0x0010649e
MOV RDI,R14
MOV ESI,0xc
MOV RDX,RBX
CALL 0x0010392d
CMP byte ptr [RBX],0x1
JNZ 0x0010644f
MOV RDI,R14
MOV RSI,R15
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001048c7
LAB_0010642e:
MOV RDI,R14
MOV ESI,0xc
MOV RDX,RBX
CALL 0x0010392d
CMP byte ptr [RBX],0x1
JNZ 0x0010644f
LAB_00106443:
MOVZX EAX,word ptr [R14 + 0xffc]
MOV word ptr [R15],AX
LAB_0010644f:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0010645e:
MOV RDI,R12
MOV RSI,RBX
CALL 0x0010679a
MOV AL,byte ptr [RBX]
CMP AL,0x1
JNZ 0x00106534
INC dword ptr [R14 + 0x2828]
LAB_0010647a:
CMP dword ptr [R14 + 0x2810],0x9
JZ 0x00106516
MOV RDI,R14
MOV RSI,RBX
CALL 0x00103b13
MOV AL,byte ptr [RBX]
TEST AL,AL
JNZ 0x0010647a
JMP 0x00106534
LAB_0010649e:
MOV EBP,dword ptr [R14 + 0x2814]
MOV R15D,dword ptr [R14 + 0x2818]
MOV R12D,dword ptr [R14 + 0x281c]
MOV R14,qword ptr [R14 + 0x2820]
MOV EDI,0x8
CALL 0x00106764
TEST R13D,R13D
JZ 0x001064ef
MOV dword ptr [RSP],R15D
LEA RSI,[0x10a4a6]
MOV RDI,RBX
MOV RDX,RAX
MOV ECX,R12D
MOV R8,R14
MOV R9D,EBP
XOR EAX,EAX
CALL 0x0010666c
JMP 0x0010644f
LAB_001064ef:
LEA RSI,[0x10a47c]
MOV RDI,RBX
MOV RDX,RAX
MOV ECX,EBP
MOV R8D,R15D
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0010666c
LAB_00106516:
MOV RDI,R12
MOV RSI,RBX
CALL 0x0010679a
MOV AL,byte ptr [RBX]
CMP AL,0x1
JNZ 0x00106534
MOV RDI,R14
MOV RSI,RBX
CALL 0x00104afb
MOV AL,byte ptr [RBX]
LAB_00106534:
TEST AL,0x1
JNZ 0x00106443
JMP 0x0010644f
|
void compile_if_stmt_cont(long param_1,int2 *param_2,byte *param_3)
{
long lVar1;
int iVar2;
int4 uVar3;
int4 uVar4;
int4 uVar5;
int8 uVar6;
byte bVar7;
int8 in_RAX;
int8 uVar8;
int4 uVar9;
uVar9 = (int4)((ulong)in_RAX >> 0x20);
if (*(int *)(param_1 + 0x2810) == 0x26) {
lVar1 = param_1 + 0x27f8;
rak_lexer_next(lVar1,param_3);
if (*param_3 != 1) {
return;
}
iVar2 = *(int *)(param_1 + 0x2810);
if (iVar2 != 8) {
if (iVar2 != 0x28) {
uVar3 = *(int4 *)(param_1 + 0x2814);
uVar4 = *(int4 *)(param_1 + 0x2818);
uVar5 = *(int4 *)(param_1 + 0x281c);
uVar6 = *(int8 *)(param_1 + 0x2820);
uVar8 = rak_token_kind_to_cstr(8);
if (iVar2 != 0) {
rak_error_set(param_3,"expected %s, but got \'%.*s\' at %d:%d",uVar8,uVar5,uVar6,uVar3,
CONCAT44(uVar9,uVar4));
return;
}
rak_error_set(param_3,"expected %s, but got end of file at %d:%d",uVar8,uVar3,uVar4);
return;
}
rak_chunk_append_instr(param_1,0xc,param_3);
if (*param_3 != 1) {
return;
}
compile_if_stmt(param_1,param_2,param_3);
return;
}
rak_lexer_next(lVar1,param_3);
bVar7 = *param_3;
if (bVar7 == 1) {
*(int *)(param_1 + 0x2828) = *(int *)(param_1 + 0x2828) + 1;
do {
if (*(int *)(param_1 + 0x2810) == 9) {
rak_lexer_next(lVar1,param_3);
bVar7 = *param_3;
if (bVar7 == 1) {
end_scope(param_1,param_3);
bVar7 = *param_3;
}
goto LAB_00106534;
}
compile_stmt(param_1,param_3);
} while (*param_3 != 0);
bVar7 = 0;
}
LAB_00106534:
if ((bVar7 & 1) == 0) {
return;
}
}
else {
rak_chunk_append_instr(param_1,0xc,param_3);
if (*param_3 != 1) {
return;
}
}
*param_2 = *(int2 *)(param_1 + 0xffc);
return;
}
| |
25,067 | minja::Value::operator>(minja::Value const&) const | monkey531[P]llama/common/minja.hpp | bool operator>(const Value & other) const {
if (is_null())
throw std::runtime_error("Undefined value or reference");
if (is_number() && other.is_number()) return get<double>() > other.get<double>();
if (is_string() && other.is_string()) return get<std::string>() > other.get<std::string>();
throw std::runtime_error("Cannot compare values: " + dump() + " > " + other.dump());
} | O2 | cpp | minja::Value::operator>(minja::Value const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %r15
callq 0x64008
testb %al, %al
jne 0x714cd
movb 0x40(%r15), %al
leal -0x5(%rax), %ecx
cmpb $0x2, %cl
ja 0x71469
movb 0x40(%r14), %al
addb $-0x5, %al
cmpb $0x2, %al
ja 0x714fd
movq %r15, %rdi
callq 0x6393a
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x6393a
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
seta %bl
jmp 0x714bd
cmpb $0x3, %al
jne 0x714fd
cmpb $0x3, 0x40(%r14)
jne 0x714fd
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x64452
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x64452
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7178d
movl %eax, %ebx
movq %r15, %rdi
callq 0x24158
movq %r14, %rdi
callq 0x24158
movl %ebx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x23450
movq %rax, %rbx
leaq 0x42b4b(%rip), %rsi # 0xb402a
movq %rax, %rdi
callq 0x23310
movq 0x8cb02(%rip), %rsi # 0xfdff0
movq 0x8ca63(%rip), %rdx # 0xfdf58
movq %rbx, %rdi
callq 0x23ea0
pushq $0x10
popq %rdi
callq 0x23450
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
pushq $-0x1
popq %rdx
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x63a1e
leaq 0x436fe(%rip), %rsi # 0xb4c1f
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rdx
callq 0x59106
leaq 0x43701(%rip), %rdx # 0xb4c3b
leaq 0x28(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x38e94
leaq 0x48(%rsp), %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x63a1e
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x39ef7
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x23dd0
xorl %ebp, %ebp
movq 0x8ca65(%rip), %rsi # 0xfdff0
movq 0x8c9c6(%rip), %rdx # 0xfdf58
movq %rbx, %rdi
callq 0x23ea0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x24158
jmp 0x715af
movq %rax, %r14
movb $0x1, %bpl
leaq 0x48(%rsp), %rdi
callq 0x24158
jmp 0x715c1
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x24158
jmp 0x715d3
movq %rax, %r14
movb $0x1, %bpl
leaq 0x88(%rsp), %rdi
callq 0x24158
jmp 0x715e8
movq %rax, %r14
movb $0x1, %bpl
leaq 0x68(%rsp), %rdi
callq 0x24158
testb %bpl, %bpl
jne 0x7160d
jmp 0x71615
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x24158
jmp 0x71615
jmp 0x7160a
movq %rax, %r14
movq %rbx, %rdi
callq 0x23670
movq %r14, %rdi
callq 0x23f20
nop
| _ZNK5minja5ValuegtERKS0_:
push rbp
push r15
push r14
push rbx
sub rsp, 0A8h
mov r14, rsi
mov r15, rdi
call _ZNK5minja5Value7is_nullEv; minja::Value::is_null(void)
test al, al
jnz loc_714CD
mov al, [r15+40h]
lea ecx, [rax-5]
cmp cl, 2
ja short loc_71469
mov al, [r14+40h]
add al, 0FBh
cmp al, 2
ja loc_714FD
mov rdi, r15
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
movsd [rsp+0C8h+var_C8], xmm0
mov rdi, r14
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
movsd xmm1, [rsp+0C8h+var_C8]
ucomisd xmm1, xmm0
setnbe bl
jmp short loc_714BD
loc_71469:
cmp al, 3
jnz loc_714FD
cmp byte ptr [r14+40h], 3
jnz loc_714FD
lea rdi, [rsp+0C8h+var_C0]
mov rsi, r15
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
lea rdi, [rsp+0C8h+var_A0]
mov rsi, r14
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
lea r14, [rsp+0C8h+var_C0]
lea r15, [rsp+0C8h+var_A0]
mov rdi, r14
mov rsi, r15
call _ZStgtIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EESA_; std::operator><char>(std::string const&,std::string const&)
mov ebx, eax
mov rdi, r15; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_714BD:
mov eax, ebx
add rsp, 0A8h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_714CD:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aUndefinedValue; "Undefined value or reference"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_714FD:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+0C8h+var_60]
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r15
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aCannotCompareV; "Cannot compare values: "
lea rdi, [rsp+0C8h+var_40]
lea rdx, [rsp+0C8h+var_60]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
lea rdx, asc_B4C3B; " > "
lea rdi, [rsp+0C8h+var_A0]
lea rsi, [rsp+0C8h+var_40]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
lea rdi, [rsp+0C8h+var_80]
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r14
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rdi, [rsp+0C8h+var_C0]
lea rsi, [rsp+0C8h+var_A0]
lea rdx, [rsp+0C8h+var_80]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
mov bpl, 1
lea rsi, [rsp+0C8h+var_C0]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rdi, [rsp+0C8h+var_C0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_715AF
mov r14, rax
mov bpl, 1
loc_715AF:
lea rdi, [rsp+0C8h+var_80]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_715C1
mov r14, rax
mov bpl, 1
loc_715C1:
lea rdi, [rsp+0C8h+var_A0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_715D3
mov r14, rax
mov bpl, 1
loc_715D3:
lea rdi, [rsp+0C8h+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_715E8
mov r14, rax
mov bpl, 1
loc_715E8:
lea rdi, [rsp+0C8h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_7160D
jmp short loc_71615
mov r14, rax
lea rdi, [rsp+0C8h+var_C0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_71615
jmp short $+2
loc_7160A:
mov r14, rax
loc_7160D:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_71615:
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::operator>(minja::Value *a1, minja::Value *a2)
{
unsigned int v2; // ebx
char v3; // al
std::runtime_error *exception; // rbx
void *v6; // rbx
_BYTE v7[32]; // [rsp+8h] [rbp-C0h] BYREF
_QWORD v8[4]; // [rsp+28h] [rbp-A0h] BYREF
_QWORD v9[4]; // [rsp+48h] [rbp-80h] BYREF
_BYTE v10[32]; // [rsp+68h] [rbp-60h] BYREF
_BYTE v11[64]; // [rsp+88h] [rbp-40h] BYREF
if ( minja::Value::is_null(a1) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Undefined value or reference");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v3 = *((_BYTE *)a1 + 64);
if ( (unsigned __int8)(v3 - 5) > 2u )
{
if ( v3 == 3 && *((_BYTE *)a2 + 64) == 3 )
{
minja::Value::get<std::string>((long long)v7, a1);
minja::Value::get<std::string>((long long)v8, a2);
v2 = std::operator><char>(v7, v8);
std::string::~string(v8);
std::string::~string(v7);
return v2;
}
LABEL_10:
v6 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v10, (long long)a1, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v11, (long long)"Cannot compare values: ", (long long)v10);
std::operator+<char>((long long)v8, (long long)v11, (long long)" > ");
minja::Value::dump[abi:cxx11]((long long)v9, (long long)a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v7, v8, v9);
std::runtime_error::runtime_error(v6, v7);
__cxa_throw(
v6,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( (unsigned __int8)(*((_BYTE *)a2 + 64) - 5) > 2u )
goto LABEL_10;
minja::Value::get<double>(a1);
minja::Value::get<double>(a2);
LOBYTE(v2) = 0;
return v2;
}
| operator>:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xa8
MOV R14,RSI
MOV R15,RDI
CALL 0x00164008
TEST AL,AL
JNZ 0x001714cd
MOV AL,byte ptr [R15 + 0x40]
LEA ECX,[RAX + -0x5]
CMP CL,0x2
JA 0x00171469
MOV AL,byte ptr [R14 + 0x40]
ADD AL,0xfb
CMP AL,0x2
JA 0x001714fd
MOV RDI,R15
CALL 0x0016393a
MOVSD qword ptr [RSP],XMM0
MOV RDI,R14
CALL 0x0016393a
MOVSD XMM1,qword ptr [RSP]
UCOMISD XMM1,XMM0
SETA BL
JMP 0x001714bd
LAB_00171469:
CMP AL,0x3
JNZ 0x001714fd
CMP byte ptr [R14 + 0x40],0x3
JNZ 0x001714fd
LEA RDI,[RSP + 0x8]
MOV RSI,R15
CALL 0x00164452
LAB_00171489:
LEA RDI,[RSP + 0x28]
MOV RSI,R14
CALL 0x00164452
LAB_00171496:
LEA R14,[RSP + 0x8]
LEA R15,[RSP + 0x28]
MOV RDI,R14
MOV RSI,R15
CALL 0x0017178d
MOV EBX,EAX
MOV RDI,R15
CALL 0x00124158
MOV RDI,R14
CALL 0x00124158
LAB_001714bd:
MOV EAX,EBX
ADD RSP,0xa8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001714cd:
PUSH 0x10
POP RDI
CALL 0x00123450
MOV RBX,RAX
LAB_001714d8:
LEA RSI,[0x1b402a]
MOV RDI,RAX
CALL 0x00123310
LAB_001714e7:
MOV RSI,qword ptr [0x001fdff0]
MOV RDX,qword ptr [0x001fdf58]
MOV RDI,RBX
CALL 0x00123ea0
LAB_001714fd:
PUSH 0x10
POP RDI
CALL 0x00123450
MOV RBX,RAX
LAB_00171508:
LEA RDI,[RSP + 0x68]
PUSH -0x1
POP RDX
MOV RSI,R15
XOR ECX,ECX
CALL 0x00163a1e
LAB_0017151a:
LEA RSI,[0x1b4c1f]
LEA RDI,[RSP + 0x88]
LEA RDX,[RSP + 0x68]
CALL 0x00159106
LAB_00171533:
LEA RDX,[0x1b4c3b]
LEA RDI,[RSP + 0x28]
LEA RSI,[RSP + 0x88]
CALL 0x00138e94
LAB_0017154c:
LEA RDI,[RSP + 0x48]
PUSH -0x1
POP RDX
MOV RSI,R14
XOR ECX,ECX
CALL 0x00163a1e
LAB_0017155e:
LEA RDI,[RSP + 0x8]
LEA RSI,[RSP + 0x28]
LEA RDX,[RSP + 0x48]
CALL 0x00139ef7
MOV BPL,0x1
LAB_00171575:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00123dd0
XOR EBP,EBP
MOV RSI,qword ptr [0x001fdff0]
MOV RDX,qword ptr [0x001fdf58]
MOV RDI,RBX
CALL 0x00123ea0
|
/* minja::Value::TEMPNAMEPLACEHOLDERVALUE(minja::Value const&) const */
ulong __thiscall minja::Value::operator>(Value *this,Value *param_1)
{
char cVar1;
bool bVar2;
int7 extraout_var;
runtime_error *prVar3;
int8 unaff_RBX;
ulong uVar4;
double dVar5;
double dVar6;
string local_c0 [32];
string local_a0 [32];
int1 local_80 [32];
int1 local_60 [32];
char local_40 [32];
cVar1 = is_null(this);
if (cVar1 != '\0') {
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001714d8 to 001714e6 has its CatchHandler @ 0017160a */
std::runtime_error::runtime_error(prVar3,"Undefined value or reference");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_001fdff0,PTR__runtime_error_001fdf58);
}
if ((byte)((char)this[0x40] - 5U) < 3) {
if (2 < (byte)((char)param_1[0x40] - 5U)) {
LAB_001714fd:
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00171508 to 00171519 has its CatchHandler @ 00171608 */
dump_abi_cxx11_((int)local_60,SUB81(this,0));
/* try { // try from 0017151a to 00171532 has its CatchHandler @ 001715e2 */
std::operator+(local_40,(string *)"Cannot compare values: ");
/* try { // try from 00171533 to 0017154b has its CatchHandler @ 001715cd */
std::operator+(local_a0,local_40);
/* try { // try from 0017154c to 0017155d has its CatchHandler @ 001715bb */
dump_abi_cxx11_((int)local_80,SUB81(param_1,0));
/* try { // try from 0017155e to 00171571 has its CatchHandler @ 001715a9 */
std::operator+(local_c0,local_a0);
/* try { // try from 00171575 to 00171599 has its CatchHandler @ 0017159a */
std::runtime_error::runtime_error(prVar3,local_c0);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_001fdff0,PTR__runtime_error_001fdf58);
}
dVar5 = get<double>(this);
dVar6 = get<double>(param_1);
uVar4 = CONCAT71((int7)((ulong)unaff_RBX >> 8),dVar6 < dVar5);
}
else {
if ((this[0x40] != (Value)0x3) || (param_1[0x40] != (Value)0x3)) goto LAB_001714fd;
get<std::__cxx11::string>();
/* try { // try from 00171489 to 00171495 has its CatchHandler @ 001715f9 */
get<std::__cxx11::string>();
bVar2 = std::operator>(local_c0,local_a0);
uVar4 = CONCAT71(extraout_var,bVar2) & 0xffffffff;
std::__cxx11::string::~string(local_a0);
std::__cxx11::string::~string(local_c0);
}
return uVar4 & 0xffffffff;
}
| |
25,068 | func_uni_big5_onechar | eloqsql/strings/ctype-big5.c | static int func_uni_big5_onechar(int code){
if ((code>=0x00A2)&&(code<=0x00F7))
return(tab_uni_big50[code-0x00A2]);
if ((code>=0x02C7)&&(code<=0x0451))
return(tab_uni_big51[code-0x02C7]);
if ((code>=0x2013)&&(code<=0x22BF))
return(tab_uni_big52[code-0x2013]);
if ((code>=0x2460)&&(code<=0x2642))
return(tab_uni_big53[code-0x2460]);
if ((code>=0x3000)&&(code<=0x3129))
return(tab_uni_big54[code-0x3000]);
if ((code>=0x32A3)&&(code<=0x32A3))
return(tab_uni_big55[code-0x32A3]);
if ((code>=0x338E)&&(code<=0x33D5))
return(tab_uni_big56[code-0x338E]);
if ((code>=0x4E00)&&(code<=0x9483))
return(tab_uni_big57[code-0x4E00]);
if ((code>=0x9577)&&(code<=0x9FA4))
return(tab_uni_big58[code-0x9577]);
if ((code>=0xFA0C)&&(code<=0xFA0D))
return(tab_uni_big59[code-0xFA0C]);
if ((code>=0xFE30)&&(code<=0xFFFD))
return(tab_uni_big510[code-0xFE30]);
return(0);
} | O0 | c | func_uni_big5_onechar:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0xa2, -0x8(%rbp)
jl 0x98507
cmpl $0xf7, -0x8(%rbp)
jg 0x98507
movl -0x8(%rbp), %eax
subl $0xa2, %eax
movslq %eax, %rcx
leaq 0x591a5(%rip), %rax # 0xf16a0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x986e5
cmpl $0x2c7, -0x8(%rbp) # imm = 0x2C7
jl 0x98537
cmpl $0x451, -0x8(%rbp) # imm = 0x451
jg 0x98537
movl -0x8(%rbp), %eax
subl $0x2c7, %eax # imm = 0x2C7
movslq %eax, %rcx
leaq 0x59225(%rip), %rax # 0xf1750
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x986e5
cmpl $0x2013, -0x8(%rbp) # imm = 0x2013
jl 0x98567
cmpl $0x22bf, -0x8(%rbp) # imm = 0x22BF
jg 0x98567
movl -0x8(%rbp), %eax
subl $0x2013, %eax # imm = 0x2013
movslq %eax, %rcx
leaq 0x59515(%rip), %rax # 0xf1a70
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x986e5
cmpl $0x2460, -0x8(%rbp) # imm = 0x2460
jl 0x98597
cmpl $0x2642, -0x8(%rbp) # imm = 0x2642
jg 0x98597
movl -0x8(%rbp), %eax
subl $0x2460, %eax # imm = 0x2460
movslq %eax, %rcx
leaq 0x59a45(%rip), %rax # 0xf1fd0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x986e5
cmpl $0x3000, -0x8(%rbp) # imm = 0x3000
jl 0x985c7
cmpl $0x3129, -0x8(%rbp) # imm = 0x3129
jg 0x985c7
movl -0x8(%rbp), %eax
subl $0x3000, %eax # imm = 0x3000
movslq %eax, %rcx
leaq 0x59de5(%rip), %rax # 0xf23a0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x986e5
cmpl $0x32a3, -0x8(%rbp) # imm = 0x32A3
jl 0x985f7
cmpl $0x32a3, -0x8(%rbp) # imm = 0x32A3
jg 0x985f7
movl -0x8(%rbp), %eax
subl $0x32a3, %eax # imm = 0x32A3
movslq %eax, %rcx
leaq 0x5a009(%rip), %rax # 0xf25f4
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x986e5
cmpl $0x338e, -0x8(%rbp) # imm = 0x338E
jl 0x98627
cmpl $0x33d5, -0x8(%rbp) # imm = 0x33D5
jg 0x98627
movl -0x8(%rbp), %eax
subl $0x338e, %eax # imm = 0x338E
movslq %eax, %rcx
leaq 0x59fe5(%rip), %rax # 0xf2600
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x986e5
cmpl $0x4e00, -0x8(%rbp) # imm = 0x4E00
jl 0x98657
cmpl $0x9483, -0x8(%rbp) # imm = 0x9483
jg 0x98657
movl -0x8(%rbp), %eax
subl $0x4e00, %eax # imm = 0x4E00
movslq %eax, %rcx
leaq 0x5a045(%rip), %rax # 0xf2690
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x986e5
cmpl $0x9577, -0x8(%rbp) # imm = 0x9577
jl 0x98684
cmpl $0x9fa4, -0x8(%rbp) # imm = 0x9FA4
jg 0x98684
movl -0x8(%rbp), %eax
subl $0x9577, %eax # imm = 0x9577
movslq %eax, %rcx
leaq 0x62d25(%rip), %rax # 0xfb3a0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x986e5
cmpl $0xfa0c, -0x8(%rbp) # imm = 0xFA0C
jl 0x986b1
cmpl $0xfa0d, -0x8(%rbp) # imm = 0xFA0D
jg 0x986b1
movl -0x8(%rbp), %eax
subl $0xfa0c, %eax # imm = 0xFA0C
movslq %eax, %rcx
leaq 0x64154(%rip), %rax # 0xfc7fc
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x986e5
cmpl $0xfe30, -0x8(%rbp) # imm = 0xFE30
jl 0x986de
cmpl $0xfffd, -0x8(%rbp) # imm = 0xFFFD
jg 0x986de
movl -0x8(%rbp), %eax
subl $0xfe30, %eax # imm = 0xFE30
movslq %eax, %rcx
leaq 0x6412b(%rip), %rax # 0xfc800
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x986e5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
| func_uni_big5_onechar:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
cmp [rbp+var_8], 0A2h
jl short loc_98507
cmp [rbp+var_8], 0F7h
jg short loc_98507
mov eax, [rbp+var_8]
sub eax, 0A2h
movsxd rcx, eax
lea rax, tab_uni_big50
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_986E5
loc_98507:
cmp [rbp+var_8], 2C7h
jl short loc_98537
cmp [rbp+var_8], 451h
jg short loc_98537
mov eax, [rbp+var_8]
sub eax, 2C7h
movsxd rcx, eax
lea rax, tab_uni_big51
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_986E5
loc_98537:
cmp [rbp+var_8], 2013h
jl short loc_98567
cmp [rbp+var_8], 22BFh
jg short loc_98567
mov eax, [rbp+var_8]
sub eax, 2013h
movsxd rcx, eax
lea rax, tab_uni_big52
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_986E5
loc_98567:
cmp [rbp+var_8], 2460h
jl short loc_98597
cmp [rbp+var_8], 2642h
jg short loc_98597
mov eax, [rbp+var_8]
sub eax, 2460h
movsxd rcx, eax
lea rax, tab_uni_big53
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_986E5
loc_98597:
cmp [rbp+var_8], 3000h
jl short loc_985C7
cmp [rbp+var_8], 3129h
jg short loc_985C7
mov eax, [rbp+var_8]
sub eax, 3000h
movsxd rcx, eax
lea rax, tab_uni_big54
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_986E5
loc_985C7:
cmp [rbp+var_8], 32A3h
jl short loc_985F7
cmp [rbp+var_8], 32A3h
jg short loc_985F7
mov eax, [rbp+var_8]
sub eax, 32A3h
movsxd rcx, eax
lea rax, tab_uni_big55
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_986E5
loc_985F7:
cmp [rbp+var_8], 338Eh
jl short loc_98627
cmp [rbp+var_8], 33D5h
jg short loc_98627
mov eax, [rbp+var_8]
sub eax, 338Eh
movsxd rcx, eax
lea rax, tab_uni_big56
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_986E5
loc_98627:
cmp [rbp+var_8], 4E00h
jl short loc_98657
cmp [rbp+var_8], 9483h
jg short loc_98657
mov eax, [rbp+var_8]
sub eax, 4E00h
movsxd rcx, eax
lea rax, tab_uni_big57
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_986E5
loc_98657:
cmp [rbp+var_8], 9577h
jl short loc_98684
cmp [rbp+var_8], 9FA4h
jg short loc_98684
mov eax, [rbp+var_8]
sub eax, 9577h
movsxd rcx, eax
lea rax, tab_uni_big58
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_986E5
loc_98684:
cmp [rbp+var_8], 0FA0Ch
jl short loc_986B1
cmp [rbp+var_8], 0FA0Dh
jg short loc_986B1
mov eax, [rbp+var_8]
sub eax, 0FA0Ch
movsxd rcx, eax
lea rax, tab_uni_big59
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_986E5
loc_986B1:
cmp [rbp+var_8], 0FE30h
jl short loc_986DE
cmp [rbp+var_8], 0FFFDh
jg short loc_986DE
mov eax, [rbp+var_8]
sub eax, 0FE30h
movsxd rcx, eax
lea rax, tab_uni_big510
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_986E5
loc_986DE:
mov [rbp+var_4], 0
loc_986E5:
mov eax, [rbp+var_4]
pop rbp
retn
| long long func_uni_big5_onechar(int a1)
{
if ( a1 < 162 || a1 > 247 )
{
if ( a1 < 711 || a1 > 1105 )
{
if ( a1 < 8211 || a1 > 8895 )
{
if ( a1 < 9312 || a1 > 9794 )
{
if ( a1 < 12288 || a1 > 12585 )
{
if ( a1 == 12963 )
{
return tab_uni_big55;
}
else if ( a1 < 13198 || a1 > 13269 )
{
if ( a1 < 19968 || a1 > 38019 )
{
if ( a1 < 38263 || a1 > 40868 )
{
if ( a1 < 64012 || a1 > 64013 )
{
if ( a1 < 65072 || a1 > 65533 )
return 0;
else
return tab_uni_big510[a1 - 65072];
}
else
{
return tab_uni_big59[a1 - 64012];
}
}
else
{
return tab_uni_big58[a1 - 38263];
}
}
else
{
return tab_uni_big57[a1 - 19968];
}
}
else
{
return tab_uni_big56[a1 - 13198];
}
}
else
{
return tab_uni_big54[a1 - 12288];
}
}
else
{
return tab_uni_big53[a1 - 9312];
}
}
else
{
return tab_uni_big52[a1 - 8211];
}
}
else
{
return tab_uni_big51[a1 - 711];
}
}
else
{
return tab_uni_big50[a1 - 162];
}
}
| func_uni_big5_onechar:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
CMP dword ptr [RBP + -0x8],0xa2
JL 0x00198507
CMP dword ptr [RBP + -0x8],0xf7
JG 0x00198507
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xa2
MOVSXD RCX,EAX
LEA RAX,[0x1f16a0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001986e5
LAB_00198507:
CMP dword ptr [RBP + -0x8],0x2c7
JL 0x00198537
CMP dword ptr [RBP + -0x8],0x451
JG 0x00198537
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2c7
MOVSXD RCX,EAX
LEA RAX,[0x1f1750]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001986e5
LAB_00198537:
CMP dword ptr [RBP + -0x8],0x2013
JL 0x00198567
CMP dword ptr [RBP + -0x8],0x22bf
JG 0x00198567
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2013
MOVSXD RCX,EAX
LEA RAX,[0x1f1a70]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001986e5
LAB_00198567:
CMP dword ptr [RBP + -0x8],0x2460
JL 0x00198597
CMP dword ptr [RBP + -0x8],0x2642
JG 0x00198597
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2460
MOVSXD RCX,EAX
LEA RAX,[0x1f1fd0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001986e5
LAB_00198597:
CMP dword ptr [RBP + -0x8],0x3000
JL 0x001985c7
CMP dword ptr [RBP + -0x8],0x3129
JG 0x001985c7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x3000
MOVSXD RCX,EAX
LEA RAX,[0x1f23a0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001986e5
LAB_001985c7:
CMP dword ptr [RBP + -0x8],0x32a3
JL 0x001985f7
CMP dword ptr [RBP + -0x8],0x32a3
JG 0x001985f7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x32a3
MOVSXD RCX,EAX
LEA RAX,[0x1f25f4]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001986e5
LAB_001985f7:
CMP dword ptr [RBP + -0x8],0x338e
JL 0x00198627
CMP dword ptr [RBP + -0x8],0x33d5
JG 0x00198627
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x338e
MOVSXD RCX,EAX
LEA RAX,[0x1f2600]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001986e5
LAB_00198627:
CMP dword ptr [RBP + -0x8],0x4e00
JL 0x00198657
CMP dword ptr [RBP + -0x8],0x9483
JG 0x00198657
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x4e00
MOVSXD RCX,EAX
LEA RAX,[0x1f2690]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001986e5
LAB_00198657:
CMP dword ptr [RBP + -0x8],0x9577
JL 0x00198684
CMP dword ptr [RBP + -0x8],0x9fa4
JG 0x00198684
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x9577
MOVSXD RCX,EAX
LEA RAX,[0x1fb3a0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001986e5
LAB_00198684:
CMP dword ptr [RBP + -0x8],0xfa0c
JL 0x001986b1
CMP dword ptr [RBP + -0x8],0xfa0d
JG 0x001986b1
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xfa0c
MOVSXD RCX,EAX
LEA RAX,[0x1fc7fc]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001986e5
LAB_001986b1:
CMP dword ptr [RBP + -0x8],0xfe30
JL 0x001986de
CMP dword ptr [RBP + -0x8],0xfffd
JG 0x001986de
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xfe30
MOVSXD RCX,EAX
LEA RAX,[0x1fc800]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001986e5
LAB_001986de:
MOV dword ptr [RBP + -0x4],0x0
LAB_001986e5:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int2 func_uni_big5_onechar(int param_1)
{
int2 uVar1;
if ((param_1 < 0xa2) || (0xf7 < param_1)) {
if ((param_1 < 0x2c7) || (0x451 < param_1)) {
if ((param_1 < 0x2013) || (0x22bf < param_1)) {
if ((param_1 < 0x2460) || (0x2642 < param_1)) {
if ((param_1 < 0x3000) || (0x3129 < param_1)) {
if ((param_1 < 0x32a3) || (0x32a3 < param_1)) {
if ((param_1 < 0x338e) || (0x33d5 < param_1)) {
if ((param_1 < 0x4e00) || (0x9483 < param_1)) {
if ((param_1 < 0x9577) || (0x9fa4 < param_1)) {
if ((param_1 < 0xfa0c) || (0xfa0d < param_1)) {
if ((param_1 < 0xfe30) || (0xfffd < param_1)) {
uVar1 = 0;
}
else {
uVar1 = *(int2 *)(tab_uni_big510 + (long)(param_1 + -0xfe30) * 2);
}
}
else {
uVar1 = *(int2 *)((long)&tab_uni_big59 + (long)(param_1 + -0xfa0c) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big58 + (long)(param_1 + -0x9577) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big57 + (long)(param_1 + -0x4e00) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big56 + (long)(param_1 + -0x338e) * 2);
}
}
else {
uVar1 = (&tab_uni_big55)[param_1 + -0x32a3];
}
}
else {
uVar1 = *(int2 *)(tab_uni_big54 + (long)(param_1 + -0x3000) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big53 + (long)(param_1 + -0x2460) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big52 + (long)(param_1 + -0x2013) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big51 + (long)(param_1 + -0x2c7) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big50 + (long)(param_1 + -0xa2) * 2);
}
return uVar1;
}
| |
25,069 | ma_ck_delete | eloqsql/storage/maria/ma_delete.c | my_bool _ma_ck_delete(MARIA_HA *info, MARIA_KEY *key)
{
MARIA_SHARE *share= info->s;
int res;
my_bool buff_alloced;
LSN lsn= LSN_IMPOSSIBLE;
my_off_t new_root= share->state.key_root[key->keyinfo->key_nr];
uchar *key_buff, *save_key_data;
MARIA_KEY org_key;
DBUG_ENTER("_ma_ck_delete");
LINT_INIT_STRUCT(org_key);
alloc_on_stack(*info->stack_end_ptr, key_buff, buff_alloced,
key->keyinfo->max_store_length);
if (!key_buff)
DBUG_RETURN(1);
save_key_data= key->data;
if (share->now_transactional)
{
/* Save original value as the key may change */
memcpy(key_buff, key->data, key->data_length + key->ref_length);
org_key= *key;
key->data= key_buff;
}
if ((res= _ma_ck_real_delete(info, key, &new_root)))
{
/* We have to mark the table crashed before unpin_all_pages() */
maria_mark_crashed(info);
}
key->data= save_key_data;
if (!res && share->now_transactional)
res= _ma_write_undo_key_delete(info, &org_key, new_root, &lsn);
else
{
share->state.key_root[key->keyinfo->key_nr]= new_root;
_ma_fast_unlock_key_del(info);
}
_ma_unpin_all_pages_and_finalize_row(info, lsn);
stack_alloc_free(key_buff, buff_alloced);
DBUG_RETURN(res != 0);
} | O0 | c | ma_ck_delete:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq 0x118(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
movzbl 0xa5(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movzwl 0xb0(%rax), %eax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq (%rax), %rax
leaq -0x78(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
cmpq -0x78(%rbp), %rax
jbe 0x6b491
movq -0x80(%rbp), %rcx
subq -0x78(%rbp), %rcx
movl $0x10000, %eax # imm = 0x10000
cmpq %rcx, %rax
jb 0x6b467
movq -0x80(%rbp), %rcx
subq -0x78(%rbp), %rcx
movl $0x8000, %eax # imm = 0x8000
cmpq %rcx, %rax
jae 0x6b491
movl $0x1000, %eax # imm = 0x1000
cmpq -0x78(%rbp), %rax
ja 0x6b491
movb $0x0, -0x2d(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movzwl 0xb0(%rax), %eax
addl $0xf, %eax
andl $-0x10, %eax
movl %eax, %ecx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x48(%rbp)
jmp 0x6b4b6
movb $0x1, -0x2d(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movzwl 0xb0(%rax), %eax
movl %eax, %esi
xorl %edi, %edi
movl $0x10010, %edx # imm = 0x10010
callq 0xf99f0
movq %rax, -0x48(%rbp)
jmp 0x6b4b8
cmpq $0x0, -0x48(%rbp)
jne 0x6b4ca
jmp 0x6b4c1
movb $0x1, -0x9(%rbp)
jmp 0x6b5fe
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, 0x7e7(%rax)
je 0x6b532
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x20(%rbp), %rcx
addl 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x2a0b0
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x70(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x68(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x60(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x6b630
movsbl %al, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x6b56c
jmp 0x6b550
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl 0x170(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x170(%rax)
jmp 0x6b568
jmp 0x6b56a
jmp 0x6b56c
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpl $0x0, -0x2c(%rbp)
jne 0x6b5aa
movq -0x28(%rbp), %rax
movsbl 0x7e7(%rax), %eax
cmpl $0x0, %eax
je 0x6b5aa
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq -0x70(%rbp), %rsi
leaq -0x38(%rbp), %rcx
callq 0x6b960
movsbl %al, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6b5d5
movq -0x40(%rbp), %rdx
movq -0x28(%rbp), %rax
movq 0x118(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
movzbl 0xa5(%rcx), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rdi
callq 0x6bbf0
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x6bc20
movq -0x48(%rbp), %rdi
movsbl -0x2d(%rbp), %esi
callq 0x6bc50
cmpl $0x0, -0x2c(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
movb %al, -0x81(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x6b624
movb -0x81(%rbp), %al
movq %rbp, %rsp
popq %rbp
retq
callq 0x2a250
nopl (%rax)
| _ma_ck_delete:
push rbp
mov rbp, rsp
sub rsp, 90h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_28], rax
mov [rbp+var_38], 0
mov rax, [rbp+var_28]
mov rax, [rax+118h]
mov rcx, [rbp+var_20]
mov rcx, [rcx+8]
movzx ecx, byte ptr [rcx+0A5h]
mov rax, [rax+rcx*8]
mov [rbp+var_40], rax
mov rax, [rbp+var_20]
mov rax, [rax+8]
movzx eax, word ptr [rax+0B0h]
mov [rbp+var_78], rax
mov rax, [rbp+var_18]
mov rax, [rax+78h]
mov rax, [rax]
lea rcx, [rbp+var_78]
sub rax, rcx
mov [rbp+var_80], rax
mov rax, [rbp+var_80]
cmp rax, [rbp+var_78]
jbe short loc_6B491
mov rcx, [rbp+var_80]
sub rcx, [rbp+var_78]
mov eax, 10000h
cmp rax, rcx
jb short loc_6B467
mov rcx, [rbp+var_80]
sub rcx, [rbp+var_78]
mov eax, 8000h
cmp rax, rcx
jnb short loc_6B491
mov eax, 1000h
cmp rax, [rbp+var_78]
ja short loc_6B491
loc_6B467:
mov [rbp+var_2D], 0
mov rax, [rbp+var_20]
mov rax, [rax+8]
movzx eax, word ptr [rax+0B0h]
add eax, 0Fh
and eax, 0FFFFFFF0h
mov ecx, eax
mov rax, rsp
sub rax, rcx
mov rsp, rax
mov [rbp+var_48], rax
jmp short loc_6B4B6
loc_6B491:
mov [rbp+var_2D], 1
mov rax, [rbp+var_20]
mov rax, [rax+8]
movzx eax, word ptr [rax+0B0h]
mov esi, eax
xor edi, edi
mov edx, 10010h
call my_malloc
mov [rbp+var_48], rax
loc_6B4B6:
jmp short $+2
loc_6B4B8:
cmp [rbp+var_48], 0
jnz short loc_6B4CA
jmp short $+2
loc_6B4C1:
mov [rbp+var_9], 1
jmp loc_6B5FE
loc_6B4CA:
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_50], rax
mov rax, [rbp+var_28]
cmp byte ptr [rax+7E7h], 0
jz short loc_6B532
mov rdi, [rbp+var_48]
mov rax, [rbp+var_20]
mov rsi, [rax]
mov rax, [rbp+var_20]
mov eax, [rax+10h]
mov rcx, [rbp+var_20]
add eax, [rcx+14h]
mov eax, eax
mov edx, eax
call _memcpy
mov rax, [rbp+var_20]
mov rcx, [rax]
mov [rbp+var_70], rcx
mov rcx, [rax+8]
mov [rbp+var_68], rcx
mov rcx, [rax+10h]
mov [rbp+var_60], rcx
mov rax, [rax+18h]
mov [rbp+var_58], rax
mov rcx, [rbp+var_48]
mov rax, [rbp+var_20]
mov [rax], rcx
loc_6B532:
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
lea rdx, [rbp+var_40]
call _ma_ck_real_delete
movsx eax, al
mov [rbp+var_2C], eax
cmp eax, 0
jz short loc_6B56C
jmp short $+2
loc_6B550:
mov rax, [rbp+var_18]
mov rax, [rax]
mov ecx, [rax+170h]
or ecx, 2
mov [rax+170h], ecx
jmp short $+2
loc_6B568:
jmp short $+2
loc_6B56A:
jmp short $+2
loc_6B56C:
mov rcx, [rbp+var_50]
mov rax, [rbp+var_20]
mov [rax], rcx
cmp [rbp+var_2C], 0
jnz short loc_6B5AA
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax+7E7h]
cmp eax, 0
jz short loc_6B5AA
mov rdi, [rbp+var_18]
mov rdx, [rbp+var_40]
lea rsi, [rbp+var_70]
lea rcx, [rbp+var_38]
call _ma_write_undo_key_delete
movsx eax, al
mov [rbp+var_2C], eax
jmp short loc_6B5D5
loc_6B5AA:
mov rdx, [rbp+var_40]
mov rax, [rbp+var_28]
mov rax, [rax+118h]
mov rcx, [rbp+var_20]
mov rcx, [rcx+8]
movzx ecx, byte ptr [rcx+0A5h]
mov [rax+rcx*8], rdx
mov rdi, [rbp+var_18]
call _ma_fast_unlock_key_del_1
loc_6B5D5:
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_38]
call _ma_unpin_all_pages_and_finalize_row_2
mov rdi, [rbp+var_48]
movsx esi, [rbp+var_2D]
call stack_alloc_free_2
cmp [rbp+var_2C], 0
setnz al
and al, 1
movzx eax, al
mov [rbp+var_9], al
loc_6B5FE:
mov al, [rbp+var_9]
mov [rbp+var_81], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_6B624
mov al, [rbp+var_81]
mov rsp, rbp
pop rbp
retn
loc_6B624:
call ___stack_chk_fail
| bool ma_ck_delete(long long *a1, long long *a2)
{
char v2; // al
long long v4; // [rsp+0h] [rbp-90h] BYREF
unsigned long long v5; // [rsp+10h] [rbp-80h]
unsigned long long v6; // [rsp+18h] [rbp-78h] BYREF
_QWORD v7[4]; // [rsp+20h] [rbp-70h] BYREF
long long v8; // [rsp+40h] [rbp-50h]
char *v9; // [rsp+48h] [rbp-48h]
long long v10; // [rsp+50h] [rbp-40h] BYREF
long long v11; // [rsp+58h] [rbp-38h] BYREF
char v12; // [rsp+63h] [rbp-2Dh]
int v13; // [rsp+64h] [rbp-2Ch]
long long v14; // [rsp+68h] [rbp-28h]
long long *v15; // [rsp+70h] [rbp-20h]
long long *v16; // [rsp+78h] [rbp-18h]
unsigned long long v18; // [rsp+88h] [rbp-8h]
v18 = __readfsqword(0x28u);
v16 = a1;
v15 = a2;
v14 = *a1;
v11 = 0LL;
v10 = *(_QWORD *)(*(_QWORD *)(v14 + 280) + 8LL * *(unsigned __int8 *)(a2[1] + 165));
v6 = *(unsigned __int16 *)(a2[1] + 176);
v5 = *(_QWORD *)a1[15] - (_QWORD)&v6;
if ( v5 <= v6 || v5 - v6 <= 0x10000 && (v5 - v6 <= 0x8000 || v6 < 0x1000) )
{
v12 = 1;
v9 = (char *)my_malloc(0LL, *(unsigned __int16 *)(v15[1] + 176), 65552LL);
}
else
{
v12 = 0;
v9 = (char *)&v4 - ((*(unsigned __int16 *)(v15[1] + 176) + 15) & 0xFFFFFFF0);
}
if ( !v9 )
return 1;
v8 = *v15;
if ( *(_BYTE *)(v14 + 2023) )
{
memcpy(v9, *v15, (unsigned int)(*((_DWORD *)v15 + 5) + *((_DWORD *)v15 + 4)));
v7[0] = *v15;
v7[1] = v15[1];
v7[2] = v15[2];
v7[3] = v15[3];
*v15 = (long long)v9;
}
v2 = ma_ck_real_delete(v16, v15, &v10);
v13 = v2;
if ( v2 )
*(_DWORD *)(*v16 + 368) |= 2u;
*v15 = v8;
if ( v13 || !*(_BYTE *)(v14 + 2023) )
{
*(_QWORD *)(*(_QWORD *)(v14 + 280) + 8LL * *(unsigned __int8 *)(v15[1] + 165)) = v10;
ma_fast_unlock_key_del_1(v16);
}
else
{
v13 = (char)ma_write_undo_key_delete(v16, v7, v10, &v11);
}
ma_unpin_all_pages_and_finalize_row_2(v16, v11);
stack_alloc_free_2(v9, (unsigned int)v12);
return v13 != 0;
}
| _ma_ck_delete:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV qword ptr [RBP + -0x38],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x118]
MOV RCX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RCX + 0x8]
MOVZX ECX,byte ptr [RCX + 0xa5]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOVZX EAX,word ptr [RAX + 0xb0]
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x78]
MOV RAX,qword ptr [RAX]
LEA RCX,[RBP + -0x78]
SUB RAX,RCX
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x80]
CMP RAX,qword ptr [RBP + -0x78]
JBE 0x0016b491
MOV RCX,qword ptr [RBP + -0x80]
SUB RCX,qword ptr [RBP + -0x78]
MOV EAX,0x10000
CMP RAX,RCX
JC 0x0016b467
MOV RCX,qword ptr [RBP + -0x80]
SUB RCX,qword ptr [RBP + -0x78]
MOV EAX,0x8000
CMP RAX,RCX
JNC 0x0016b491
MOV EAX,0x1000
CMP RAX,qword ptr [RBP + -0x78]
JA 0x0016b491
LAB_0016b467:
MOV byte ptr [RBP + -0x2d],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOVZX EAX,word ptr [RAX + 0xb0]
ADD EAX,0xf
AND EAX,0xfffffff0
MOV ECX,EAX
MOV RAX,RSP
SUB RAX,RCX
MOV RSP,RAX
MOV qword ptr [RBP + -0x48],RAX
JMP 0x0016b4b6
LAB_0016b491:
MOV byte ptr [RBP + -0x2d],0x1
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOVZX EAX,word ptr [RAX + 0xb0]
MOV ESI,EAX
XOR EDI,EDI
MOV EDX,0x10010
CALL 0x001f99f0
MOV qword ptr [RBP + -0x48],RAX
LAB_0016b4b6:
JMP 0x0016b4b8
LAB_0016b4b8:
CMP qword ptr [RBP + -0x48],0x0
JNZ 0x0016b4ca
JMP 0x0016b4c1
LAB_0016b4c1:
MOV byte ptr [RBP + -0x9],0x1
JMP 0x0016b5fe
LAB_0016b4ca:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x28]
CMP byte ptr [RAX + 0x7e7],0x0
JZ 0x0016b532
MOV RDI,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x20]
ADD EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV EDX,EAX
CALL 0x0012a0b0
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBP + -0x70],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x68],RCX
MOV RCX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x60],RCX
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x58],RAX
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
LAB_0016b532:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
LEA RDX,[RBP + -0x40]
CALL 0x0016b630
MOVSX EAX,AL
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JZ 0x0016b56c
JMP 0x0016b550
LAB_0016b550:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x170]
OR ECX,0x2
MOV dword ptr [RAX + 0x170],ECX
JMP 0x0016b568
LAB_0016b568:
JMP 0x0016b56a
LAB_0016b56a:
JMP 0x0016b56c
LAB_0016b56c:
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
CMP dword ptr [RBP + -0x2c],0x0
JNZ 0x0016b5aa
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX + 0x7e7]
CMP EAX,0x0
JZ 0x0016b5aa
MOV RDI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x70]
LEA RCX,[RBP + -0x38]
CALL 0x0016b960
MOVSX EAX,AL
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x0016b5d5
LAB_0016b5aa:
MOV RDX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x118]
MOV RCX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RCX + 0x8]
MOVZX ECX,byte ptr [RCX + 0xa5]
MOV qword ptr [RAX + RCX*0x8],RDX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0016bbf0
LAB_0016b5d5:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x0016bc20
MOV RDI,qword ptr [RBP + -0x48]
MOVSX ESI,byte ptr [RBP + -0x2d]
CALL 0x0016bc50
CMP dword ptr [RBP + -0x2c],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x9],AL
LAB_0016b5fe:
MOV AL,byte ptr [RBP + -0x9]
MOV byte ptr [RBP + -0x81],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0016b624
MOV AL,byte ptr [RBP + -0x81]
MOV RSP,RBP
POP RBP
RET
LAB_0016b624:
CALL 0x0012a250
|
int8 _ma_ck_delete(long *param_1,int8 *param_2)
{
int iVar1;
void *__src;
int1 *puVar2;
int8 uVar3;
int8 *puVar4;
long *plVar5;
char cVar6;
int1 *puVar7;
int iVar8;
long in_FS_OFFSET;
int1 auStack_98 [15];
bool local_89;
ulong local_88;
ulong local_80;
int8 local_78;
int8 local_70;
int8 local_68;
int8 local_60;
int8 local_58;
int1 *local_50;
int8 local_48;
int8 local_40;
char local_35;
int local_34;
long local_30;
int8 *local_28;
long *local_20;
bool local_11;
long local_10;
puVar7 = auStack_98;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_30 = *param_1;
local_40 = 0;
local_48 = *(int8 *)(*(long *)(local_30 + 0x118) + (ulong)*(byte *)(param_2[1] + 0xa5) * 8);
local_80 = (ulong)*(ushort *)(param_2[1] + 0xb0);
local_88 = *(long *)param_1[0xf] - (long)&local_80;
local_28 = param_2;
local_20 = param_1;
if ((local_80 < local_88) &&
((0x10000 < local_88 - local_80 || ((0x8000 < local_88 - local_80 && (0xfff < local_80)))))) {
local_35 = '\0';
puVar7 = auStack_98 + -(ulong)(*(ushort *)(param_2[1] + 0xb0) + 0xf & 0xfffffff0);
local_50 = puVar7;
}
else {
local_35 = '\x01';
local_50 = (int1 *)my_malloc(0,*(int2 *)(param_2[1] + 0xb0),0x10010);
}
puVar2 = local_50;
if (local_50 == (int1 *)0x0) {
local_11 = true;
}
else {
local_58 = *local_28;
if (*(char *)(local_30 + 0x7e7) != '\0') {
__src = (void *)*local_28;
iVar8 = *(int *)(local_28 + 2);
iVar1 = *(int *)((long)local_28 + 0x14);
*(int8 *)(puVar7 + -8) = 0x16b504;
memcpy(puVar2,__src,(ulong)(uint)(iVar8 + iVar1));
local_78 = *local_28;
local_70 = local_28[1];
local_68 = local_28[2];
local_60 = local_28[3];
*local_28 = local_50;
}
plVar5 = local_20;
puVar4 = local_28;
*(int8 *)(puVar7 + -8) = 0x16b543;
cVar6 = _ma_ck_real_delete(plVar5,puVar4,&local_48);
plVar5 = local_20;
uVar3 = local_48;
local_34 = (int)cVar6;
if (local_34 != 0) {
*(uint *)(*local_20 + 0x170) = *(uint *)(*local_20 + 0x170) | 2;
}
*local_28 = local_58;
if ((local_34 == 0) && (*(char *)(local_30 + 0x7e7) != '\0')) {
*(int8 *)(puVar7 + -8) = 0x16b5a2;
cVar6 = _ma_write_undo_key_delete(plVar5,&local_78,uVar3,&local_40);
local_34 = (int)cVar6;
}
else {
*(int8 *)(*(long *)(local_30 + 0x118) + (ulong)*(byte *)(local_28[1] + 0xa5) * 8) =
local_48;
*(int8 *)(puVar7 + -8) = 0x16b5d5;
_ma_fast_unlock_key_del(plVar5);
}
plVar5 = local_20;
uVar3 = local_40;
*(int8 *)(puVar7 + -8) = 0x16b5e2;
_ma_unpin_all_pages_and_finalize_row(plVar5,uVar3);
puVar2 = local_50;
iVar8 = (int)local_35;
*(int8 *)(puVar7 + -8) = 0x16b5ef;
stack_alloc_free(puVar2,iVar8);
local_11 = local_34 != 0;
}
local_89 = local_11;
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),local_11);
}
/* WARNING: Subroutine does not return */
*(int8 *)(puVar7 + -8) = 0x16b629;
__stack_chk_fail();
}
| |
25,070 | LefDefParser::lefiPinAntennaModel::addAntennaMaxSideAreaCar(double, char const*) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiMacro.cpp | void
lefiPinAntennaModel::addAntennaMaxSideAreaCar(double val,
const char *layer)
{
int len;
if (numAntennaMaxSideAreaCar_ == antennaMaxSideAreaCarAllocated_) {
int i;
int max;
int lim = numAntennaMaxSideAreaCar_;
double *nd;
char **nl;
if (antennaMaxSideAreaCarAllocated_ == 0)
max = antennaMaxSideAreaCarAllocated_ = 2;
else
max = antennaMaxSideAreaCarAllocated_ *= 2;
nd = (double*) lefMalloc(sizeof(double) * max);
nl = (char**) lefMalloc(sizeof(double) * max);
for (i = 0; i < lim; i++) {
nl[i] = antennaMaxSideAreaCarLayer_[i];
nd[i] = antennaMaxSideAreaCar_[i];
}
lefFree((char*) (antennaMaxSideAreaCarLayer_));
lefFree((char*) (antennaMaxSideAreaCar_));
antennaMaxSideAreaCarLayer_ = nl;
antennaMaxSideAreaCar_ = nd;
}
antennaMaxSideAreaCar_[numAntennaMaxSideAreaCar_] = val;
if (layer) { // layer can be null, since it is optional
len = strlen(layer) + 1;
antennaMaxSideAreaCarLayer_[numAntennaMaxSideAreaCar_] =
(char*) lefMalloc(len);
strcpy(antennaMaxSideAreaCarLayer_[numAntennaMaxSideAreaCar_],
layer);
} else
antennaMaxSideAreaCarLayer_[numAntennaMaxSideAreaCar_] = NULL;
numAntennaMaxSideAreaCar_ += 1;
} | O3 | cpp | LefDefParser::lefiPinAntennaModel::addAntennaMaxSideAreaCar(double, char const*):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x40(%rdi), %r13d
cmpl 0x44(%rdi), %r13d
jne 0x28710
movsd %xmm0, 0x8(%rsp)
leal (,%r13,2), %eax
testl %r13d, %r13d
movl $0x2, %ecx
cmovnel %eax, %ecx
movl %ecx, 0x44(%rbx)
movslq %ecx, %r12
shlq $0x3, %r12
movq %r12, %rdi
callq 0x24985
movq %rax, %r15
movq %r12, %rdi
callq 0x24985
movq %rax, %r12
testl %r13d, %r13d
jle 0x286ea
xorl %eax, %eax
movq 0x50(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
movq %rcx, (%r12,%rax,8)
movq 0x48(%rbx), %rcx
movsd (%rcx,%rax,8), %xmm0
movsd %xmm0, (%r15,%rax,8)
incq %rax
cmpq %rax, %r13
jne 0x286c7
movq 0x50(%rbx), %rdi
callq 0x26040
movq 0x48(%rbx), %rdi
callq 0x26040
movq %r12, 0x50(%rbx)
movq %r15, 0x48(%rbx)
movl 0x40(%rbx), %r13d
movsd 0x8(%rsp), %xmm0
jmp 0x28714
movq 0x48(%rbx), %r15
movslq %r13d, %rax
movsd %xmm0, (%r15,%rax,8)
testq %r14, %r14
je 0x28756
movq %r14, %rdi
callq 0x20d0
incl %eax
movslq %eax, %rdi
callq 0x24985
movq 0x50(%rbx), %rcx
movslq 0x40(%rbx), %rdx
movq %rax, (%rcx,%rdx,8)
movq 0x50(%rbx), %rax
movq (%rax,%rdx,8), %rdi
movq %r14, %rsi
callq 0x21b0
movl 0x40(%rbx), %r13d
jmp 0x28762
movq 0x50(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incl %r13d
movl %r13d, 0x40(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
| _ZN12LefDefParser19lefiPinAntennaModel24addAntennaMaxSideAreaCarEdPKc:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov r14, rsi
mov rbx, rdi
mov r13d, [rdi+40h]
cmp r13d, [rdi+44h]
jnz loc_28710
movsd [rsp+38h+var_30], xmm0
lea eax, ds:0[r13*2]
test r13d, r13d
mov ecx, 2
cmovnz ecx, eax
mov [rbx+44h], ecx
movsxd r12, ecx
shl r12, 3
mov rdi, r12; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov r15, rax
mov rdi, r12; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov r12, rax
test r13d, r13d
jle short loc_286EA
xor eax, eax
loc_286C7:
mov rcx, [rbx+50h]
mov rcx, [rcx+rax*8]
mov [r12+rax*8], rcx
mov rcx, [rbx+48h]
movsd xmm0, qword ptr [rcx+rax*8]
movsd qword ptr [r15+rax*8], xmm0
inc rax
cmp r13, rax
jnz short loc_286C7
loc_286EA:
mov rdi, [rbx+50h]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov rdi, [rbx+48h]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov [rbx+50h], r12
mov [rbx+48h], r15
mov r13d, [rbx+40h]
movsd xmm0, [rsp+38h+var_30]
jmp short loc_28714
loc_28710:
mov r15, [rbx+48h]
loc_28714:
movsxd rax, r13d
movsd qword ptr [r15+rax*8], xmm0
test r14, r14
jz short loc_28756
mov rdi, r14
call _strlen
inc eax
movsxd rdi, eax; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov rcx, [rbx+50h]
movsxd rdx, dword ptr [rbx+40h]
mov [rcx+rdx*8], rax
mov rax, [rbx+50h]
mov rdi, [rax+rdx*8]
mov rsi, r14
call _strcpy
mov r13d, [rbx+40h]
jmp short loc_28762
loc_28756:
mov rcx, [rbx+50h]
mov qword ptr [rcx+rax*8], 0
loc_28762:
inc r13d
mov [rbx+40h], r13d
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| long long LefDefParser::lefiPinAntennaModel::addAntennaMaxSideAreaCar(
LefDefParser::lefiPinAntennaModel *this,
double a2,
char *a3)
{
long long v3; // r13
int v4; // ecx
LefDefParser *v5; // r12
long long v6; // r15
long long v7; // r12
long long i; // rax
long long result; // rax
int v10; // eax
long long v11; // rax
long long v12; // rdx
v3 = *((unsigned int *)this + 16);
if ( (_DWORD)v3 == *((_DWORD *)this + 17) )
{
v4 = 2;
if ( (_DWORD)v3 )
v4 = 2 * v3;
*((_DWORD *)this + 17) = v4;
v5 = (LefDefParser *)(8LL * v4);
v6 = LefDefParser::lefMalloc(v5);
v7 = LefDefParser::lefMalloc(v5);
if ( (int)v3 > 0 )
{
for ( i = 0LL; i != v3; ++i )
{
*(_QWORD *)(v7 + 8 * i) = *(_QWORD *)(*((_QWORD *)this + 10) + 8 * i);
*(_QWORD *)(v6 + 8 * i) = *(_QWORD *)(*((_QWORD *)this + 9) + 8 * i);
}
}
LefDefParser::lefFree(*((LefDefParser **)this + 10), a3);
LefDefParser::lefFree(*((LefDefParser **)this + 9), a3);
*((_QWORD *)this + 10) = v7;
*((_QWORD *)this + 9) = v6;
LODWORD(v3) = *((_DWORD *)this + 16);
}
else
{
v6 = *((_QWORD *)this + 9);
}
result = (int)v3;
*(double *)(v6 + 8LL * (int)v3) = a2;
if ( a3 )
{
v10 = strlen(a3);
v11 = LefDefParser::lefMalloc((LefDefParser *)(v10 + 1));
v12 = *((int *)this + 16);
*(_QWORD *)(*((_QWORD *)this + 10) + 8 * v12) = v11;
result = strcpy(*(_QWORD *)(*((_QWORD *)this + 10) + 8 * v12), a3);
LODWORD(v3) = *((_DWORD *)this + 16);
}
else
{
*(_QWORD *)(*((_QWORD *)this + 10) + 8LL * (int)v3) = 0LL;
}
*((_DWORD *)this + 16) = v3 + 1;
return result;
}
| addAntennaMaxSideAreaCar:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R14,RSI
MOV RBX,RDI
MOV R13D,dword ptr [RDI + 0x40]
CMP R13D,dword ptr [RDI + 0x44]
JNZ 0x00128710
MOVSD qword ptr [RSP + 0x8],XMM0
LEA EAX,[R13*0x2]
TEST R13D,R13D
MOV ECX,0x2
CMOVNZ ECX,EAX
MOV dword ptr [RBX + 0x44],ECX
MOVSXD R12,ECX
SHL R12,0x3
MOV RDI,R12
CALL 0x00124985
MOV R15,RAX
MOV RDI,R12
CALL 0x00124985
MOV R12,RAX
TEST R13D,R13D
JLE 0x001286ea
XOR EAX,EAX
LAB_001286c7:
MOV RCX,qword ptr [RBX + 0x50]
MOV RCX,qword ptr [RCX + RAX*0x8]
MOV qword ptr [R12 + RAX*0x8],RCX
MOV RCX,qword ptr [RBX + 0x48]
MOVSD XMM0,qword ptr [RCX + RAX*0x8]
MOVSD qword ptr [R15 + RAX*0x8],XMM0
INC RAX
CMP R13,RAX
JNZ 0x001286c7
LAB_001286ea:
MOV RDI,qword ptr [RBX + 0x50]
CALL 0x00126040
MOV RDI,qword ptr [RBX + 0x48]
CALL 0x00126040
MOV qword ptr [RBX + 0x50],R12
MOV qword ptr [RBX + 0x48],R15
MOV R13D,dword ptr [RBX + 0x40]
MOVSD XMM0,qword ptr [RSP + 0x8]
JMP 0x00128714
LAB_00128710:
MOV R15,qword ptr [RBX + 0x48]
LAB_00128714:
MOVSXD RAX,R13D
MOVSD qword ptr [R15 + RAX*0x8],XMM0
TEST R14,R14
JZ 0x00128756
MOV RDI,R14
CALL 0x001020d0
INC EAX
MOVSXD RDI,EAX
CALL 0x00124985
MOV RCX,qword ptr [RBX + 0x50]
MOVSXD RDX,dword ptr [RBX + 0x40]
MOV qword ptr [RCX + RDX*0x8],RAX
MOV RAX,qword ptr [RBX + 0x50]
MOV RDI,qword ptr [RAX + RDX*0x8]
MOV RSI,R14
CALL 0x001021b0
MOV R13D,dword ptr [RBX + 0x40]
JMP 0x00128762
LAB_00128756:
MOV RCX,qword ptr [RBX + 0x50]
MOV qword ptr [RCX + RAX*0x8],0x0
LAB_00128762:
INC R13D
MOV dword ptr [RBX + 0x40],R13D
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* LefDefParser::lefiPinAntennaModel::addAntennaMaxSideAreaCar(double, char const*) */
void __thiscall
LefDefParser::lefiPinAntennaModel::addAntennaMaxSideAreaCar
(lefiPinAntennaModel *this,double param_1,char *param_2)
{
long lVar1;
long lVar2;
ulong uVar3;
size_t sVar4;
int8 uVar5;
int iVar6;
char *pcVar7;
uint uVar8;
uVar8 = *(uint *)(this + 0x40);
pcVar7 = param_2;
if (uVar8 == *(uint *)(this + 0x44)) {
iVar6 = 2;
if (uVar8 != 0) {
iVar6 = uVar8 * 2;
}
*(int *)(this + 0x44) = iVar6;
lVar1 = lefMalloc((LefDefParser *)((long)iVar6 << 3),(ulong)param_2);
lVar2 = lefMalloc((LefDefParser *)((long)iVar6 << 3),(ulong)pcVar7);
if (0 < (int)uVar8) {
uVar3 = 0;
do {
*(int8 *)(lVar2 + uVar3 * 8) = *(int8 *)(*(long *)(this + 0x50) + uVar3 * 8);
*(int8 *)(lVar1 + uVar3 * 8) = *(int8 *)(*(long *)(this + 0x48) + uVar3 * 8);
uVar3 = uVar3 + 1;
} while (uVar8 != uVar3);
}
lefFree(*(void **)(this + 0x50));
lefFree(*(void **)(this + 0x48));
*(long *)(this + 0x50) = lVar2;
*(long *)(this + 0x48) = lVar1;
uVar8 = *(uint *)(this + 0x40);
}
else {
lVar1 = *(long *)(this + 0x48);
}
*(double *)(lVar1 + (long)(int)uVar8 * 8) = param_1;
if (param_2 == (char *)0x0) {
*(int8 *)(*(long *)(this + 0x50) + (long)(int)uVar8 * 8) = 0;
}
else {
sVar4 = strlen(param_2);
uVar5 = lefMalloc((LefDefParser *)(long)((int)sVar4 + 1),(ulong)pcVar7);
iVar6 = *(int *)(this + 0x40);
*(int8 *)(*(long *)(this + 0x50) + (long)iVar6 * 8) = uVar5;
strcpy(*(char **)(*(long *)(this + 0x50) + (long)iVar6 * 8),param_2);
uVar8 = *(uint *)(this + 0x40);
}
*(uint *)(this + 0x40) = uVar8 + 1;
return;
}
| |
25,071 | my_uca_previous_context_find | eloqsql/strings/ctype-uca.c | static const MY_CONTRACTION *
my_uca_previous_context_find(my_uca_scanner *scanner,
my_wc_t wc0, my_wc_t wc1)
{
const MY_CONTRACTIONS *list= &scanner->level->contractions;
MY_CONTRACTION *c, *last;
for (c= list->item, last= c + list->nitems; c < last; c++)
{
if (c->with_context && wc0 == c->ch[0] && wc1 == c->ch[1])
{
scanner->wbeg= c->weight + 1;
return c;
}
}
return NULL;
} | O0 | c | my_uca_previous_context_find:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
imulq $0x58, (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x61bce
movq -0x30(%rbp), %rax
movsbl 0x52(%rax), %eax
cmpl $0x0, %eax
je 0x61bbe
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x61bbe
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x61bbe
movq -0x30(%rbp), %rcx
addq $0x30, %rcx
addq $0x2, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x61bd6
jmp 0x61bc0
movq -0x30(%rbp), %rax
addq $0x58, %rax
movq %rax, -0x30(%rbp)
jmp 0x61b6f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
| my_uca_previous_context_find:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov rax, [rax+18h]
add rax, 18h
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov rcx, [rbp+var_28]
imul rcx, [rcx], 58h ; 'X'
add rax, rcx
mov [rbp+var_38], rax
loc_61B6F:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_38]
jnb short loc_61BCE
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax+52h]
cmp eax, 0
jz short loc_61BBE
mov rax, [rbp+var_18]
mov rcx, [rbp+var_30]
cmp rax, [rcx]
jnz short loc_61BBE
mov rax, [rbp+var_20]
mov rcx, [rbp+var_30]
cmp rax, [rcx+8]
jnz short loc_61BBE
mov rcx, [rbp+var_30]
add rcx, 30h ; '0'
add rcx, 2
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
jmp short loc_61BD6
loc_61BBE:
jmp short $+2
loc_61BC0:
mov rax, [rbp+var_30]
add rax, 58h ; 'X'
mov [rbp+var_30], rax
jmp short loc_61B6F
loc_61BCE:
mov [rbp+var_8], 0
loc_61BD6:
mov rax, [rbp+var_8]
pop rbp
retn
| unsigned long long my_uca_previous_context_find(_QWORD *a1, long long a2, long long a3)
{
unsigned long long v4; // [rsp+0h] [rbp-38h]
unsigned long long v5; // [rsp+8h] [rbp-30h]
v5 = *(_QWORD *)(a1[3] + 32LL);
v4 = 88LL * *(_QWORD *)(a1[3] + 24LL) + v5;
while ( v5 < v4 )
{
if ( *(_BYTE *)(v5 + 82) && a2 == *(_QWORD *)v5 && a3 == *(_QWORD *)(v5 + 8) )
{
*a1 = v5 + 50;
return v5;
}
v5 += 88LL;
}
return 0LL;
}
| my_uca_previous_context_find:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
ADD RAX,0x18
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x28]
IMUL RCX,qword ptr [RCX],0x58
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
LAB_00161b6f:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x38]
JNC 0x00161bce
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX + 0x52]
CMP EAX,0x0
JZ 0x00161bbe
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RCX]
JNZ 0x00161bbe
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RCX + 0x8]
JNZ 0x00161bbe
MOV RCX,qword ptr [RBP + -0x30]
ADD RCX,0x30
ADD RCX,0x2
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00161bd6
LAB_00161bbe:
JMP 0x00161bc0
LAB_00161bc0:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x58
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00161b6f
LAB_00161bce:
MOV qword ptr [RBP + -0x8],0x0
LAB_00161bd6:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
long * my_uca_previous_context_find(long *param_1,long param_2,long param_3)
{
long *plVar1;
long *local_38;
local_38 = *(long **)(param_1[3] + 0x20);
plVar1 = local_38 + *(long *)(param_1[3] + 0x18) * 0xb;
while( true ) {
if (plVar1 <= local_38) {
return (long *)0x0;
}
if (((*(char *)((long)local_38 + 0x52) != '\0') && (param_2 == *local_38)) &&
(param_3 == local_38[1])) break;
local_38 = local_38 + 0xb;
}
*param_1 = (long)local_38 + 0x32;
return local_38;
}
| |
25,072 | ChangeButtonState(Context&, Rectangle, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | csit-sgu[P]mit-game-2025_1/user.cpp | void ChangeButtonState(
Context &ctx,
Rectangle btnCollider,
size_t btn_id,
std::string path1,
std::string path2
) {
if (IsMouseOnButton(btnCollider)) {
for (auto &obj : ctx.current_scene) {
if (obj.id == btn_id) {
obj.render = Render(
ctx, path2, Vector2(btnCollider.width, btnCollider.height)
);
}
}
} else {
for (auto &obj : ctx.current_scene) {
if (obj.id == btn_id) {
obj.render = Render(
ctx, path1, Vector2(btnCollider.width, btnCollider.height)
);
}
}
}
} | O1 | cpp | ChangeButtonState(Context&, Rectangle, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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 $0xa8, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
movaps %xmm1, 0x80(%rsp)
movaps %xmm0, 0x90(%rsp)
movq %rdi, %r14
callq 0x7bd8f
movaps 0x90(%rsp), %xmm1
movaps 0x80(%rsp), %xmm2
callq 0x83648
movq 0x98(%r14), %r15
movq 0xa0(%r14), %rbp
testb %al, %al
je 0xce96
cmpq %rbp, %r15
je 0xcf66
addq $0x28, %r15
leaq 0x60(%rsp), %r13
cmpq %rbx, -0x20(%r15)
je 0xcdf8
leaq 0xe0(%r15), %rax
addq $0xb8, %r15
cmpq %rbp, %r15
movq %rax, %r15
jne 0xcdd7
jmp 0xcf66
leaq 0x70(%rsp), %rax
movq %rax, 0x60(%rsp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0xb256
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r13, %rdx
movaps 0x80(%rsp), %xmm0
callq 0xac86
movl 0x10(%rsp), %eax
movl %eax, -0x8(%r15)
movq 0x8(%rsp), %rax
movq %rax, -0x10(%r15)
movq %r15, %rdi
leaq 0x18(%rsp), %rsi
callq 0x9ac0
movq 0x38(%rsp), %rax
movq %rax, 0x20(%r15)
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0xce71
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x9550
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0xcddd
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x9550
jmp 0xcddd
cmpq %rbp, %r15
je 0xcf66
addq $0x28, %r15
leaq 0x40(%rsp), %r12
cmpq %rbx, -0x20(%r15)
je 0xcec9
leaq 0xe0(%r15), %rax
addq $0xb8, %r15
cmpq %rbp, %r15
movq %rax, %r15
jne 0xcea8
jmp 0xcf66
leaq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0xb256
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
movaps 0x80(%rsp), %xmm0
callq 0xac86
movl 0x10(%rsp), %eax
movl %eax, -0x8(%r15)
movq 0x8(%rsp), %rax
movq %rax, -0x10(%r15)
movq %r15, %rdi
leaq 0x18(%rsp), %rsi
callq 0x9ac0
movq 0x38(%rsp), %rax
movq %rax, 0x20(%r15)
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0xcf41
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x9550
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0xceae
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x9550
jmp 0xceae
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0xcfb0
movq 0x50(%rsp), %rsi
jmp 0xcfa8
movq %rax, %rbx
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0xcfb0
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x9550
movq %rbx, %rdi
callq 0x99c0
| _Z17ChangeButtonStateR7Context9RectanglemNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES7_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A8h
mov r12, rcx
mov r13, rdx
mov rbx, rsi
movaps [rsp+0D8h+var_58], xmm1
movaps [rsp+0D8h+var_48], xmm0
mov r14, rdi
call GetMousePosition
movaps xmm1, [rsp+0D8h+var_48]
movaps xmm2, [rsp+0D8h+var_58]
call CheckCollisionPointRec
mov r15, [r14+98h]
mov rbp, [r14+0A0h]
test al, al
jz loc_CE96
cmp r15, rbp
jz loc_CF66
add r15, 28h ; '('
lea r13, [rsp+0D8h+var_78]
loc_CDD7:
cmp [r15-20h], rbx
jz short loc_CDF8
loc_CDDD:
lea rax, [r15+0E0h]
add r15, 0B8h
cmp r15, rbp
mov r15, rax
jnz short loc_CDD7
jmp loc_CF66
loc_CDF8:
lea rax, [rsp+0D8h+var_68]
mov [rsp+0D8h+var_78], rax
mov rsi, [r12]
mov rdx, [r12+8]
add rdx, rsi
mov rdi, r13
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rdi, [rsp+0D8h+var_D0]
mov rsi, r14
mov rdx, r13
movaps xmm0, [rsp+0D8h+var_58]
call _ZN6RenderC2ER7ContextNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE7Vector2; Render::Render(Context &,std::string,Vector2)
mov eax, [rsp+0D8h+var_C8]
mov [r15-8], eax
mov rax, [rsp+0D8h+var_D0]
mov [r15-10h], rax
mov rdi, r15
lea rsi, [rsp+0D8h+var_C0]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rax, [rsp+0D8h+var_A0]
mov [r15+20h], rax
mov rdi, [rsp+0D8h+var_C0]; void *
lea rax, [rsp+0D8h+var_B0]
cmp rdi, rax
jz short loc_CE71
mov rsi, [rsp+0D8h+var_B0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_CE71:
mov rdi, [rsp+0D8h+var_78]; void *
lea rax, [rsp+0D8h+var_68]
cmp rdi, rax
jz loc_CDDD
mov rsi, [rsp+0D8h+var_68]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp loc_CDDD
loc_CE96:
cmp r15, rbp
jz loc_CF66
add r15, 28h ; '('
lea r12, [rsp+0D8h+var_98]
loc_CEA8:
cmp [r15-20h], rbx
jz short loc_CEC9
loc_CEAE:
lea rax, [r15+0E0h]
add r15, 0B8h
cmp r15, rbp
mov r15, rax
jnz short loc_CEA8
jmp loc_CF66
loc_CEC9:
lea rax, [rsp+0D8h+var_88]
mov [rsp+0D8h+var_98], rax
mov rsi, [r13+0]
mov rdx, [r13+8]
add rdx, rsi
mov rdi, r12
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rdi, [rsp+0D8h+var_D0]
mov rsi, r14
mov rdx, r12
movaps xmm0, [rsp+0D8h+var_58]
call _ZN6RenderC2ER7ContextNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE7Vector2; Render::Render(Context &,std::string,Vector2)
mov eax, [rsp+0D8h+var_C8]
mov [r15-8], eax
mov rax, [rsp+0D8h+var_D0]
mov [r15-10h], rax
mov rdi, r15
lea rsi, [rsp+0D8h+var_C0]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rax, [rsp+0D8h+var_A0]
mov [r15+20h], rax
mov rdi, [rsp+0D8h+var_C0]; void *
lea rax, [rsp+0D8h+var_B0]
cmp rdi, rax
jz short loc_CF41
mov rsi, [rsp+0D8h+var_B0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_CF41:
mov rdi, [rsp+0D8h+var_98]; void *
lea rax, [rsp+0D8h+var_88]
cmp rdi, rax
jz loc_CEAE
mov rsi, [rsp+0D8h+var_88]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp loc_CEAE
loc_CF66:
add rsp, 0A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_38]
lea rax, [rsp+arg_48]
cmp rdi, rax
jz short loc_CFB0
mov rsi, [rsp+arg_48]
jmp short loc_CFA8
mov rbx, rax
mov rdi, [rsp+arg_58]; void *
lea rax, [rsp+arg_68]
cmp rdi, rax
jz short loc_CFB0
mov rsi, [rsp+arg_68]
loc_CFA8:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_CFB0:
mov rdi, rbx
call __Unwind_Resume
| long long ChangeButtonState(long long a1, long long a2, long long a3, long long a4, __m128 a5, __m128 a6)
{
double MousePosition; // xmm0_8
long long result; // rax
long long v10; // r15
long long v11; // rbp
long long v12; // r15
bool v13; // zf
long long v14; // r15
long long v15; // [rsp+8h] [rbp-D0h] BYREF
int v16; // [rsp+10h] [rbp-C8h]
void *v17[2]; // [rsp+18h] [rbp-C0h] BYREF
_QWORD v18[2]; // [rsp+28h] [rbp-B0h] BYREF
long long v19; // [rsp+38h] [rbp-A0h]
void *v20[2]; // [rsp+40h] [rbp-98h] BYREF
_QWORD v21[2]; // [rsp+50h] [rbp-88h] BYREF
void *v22[2]; // [rsp+60h] [rbp-78h] BYREF
_QWORD v23[2]; // [rsp+70h] [rbp-68h] BYREF
__m128 v24; // [rsp+80h] [rbp-58h]
__m128 v25; // [rsp+90h] [rbp-48h]
v24 = a6;
v25 = a5;
MousePosition = GetMousePosition();
result = CheckCollisionPointRec(MousePosition, *(double *)v25.m128_u64, *(double *)a6.m128_u64);
v10 = *(_QWORD *)(a1 + 152);
v11 = *(_QWORD *)(a1 + 160);
if ( (_BYTE)result )
{
if ( v10 != v11 )
{
v12 = v10 + 40;
do
{
if ( *(_QWORD *)(v12 - 32) == a2 )
{
v22[0] = v23;
std::string::_M_construct<char *>(v22, *(_BYTE **)a4, *(_QWORD *)a4 + *(_QWORD *)(a4 + 8));
Render::Render((long long)&v15, a1, v22, v24);
*(_DWORD *)(v12 - 8) = v16;
*(_QWORD *)(v12 - 16) = v15;
std::string::operator=(v12, (long long)v17);
*(_QWORD *)(v12 + 32) = v19;
if ( v17[0] != v18 )
operator delete(v17[0], v18[0] + 1LL);
if ( v22[0] != v23 )
operator delete(v22[0], v23[0] + 1LL);
}
result = v12 + 224;
v13 = v12 + 184 == v11;
v12 += 224LL;
}
while ( !v13 );
}
}
else if ( v10 != v11 )
{
v14 = v10 + 40;
do
{
if ( *(_QWORD *)(v14 - 32) == a2 )
{
v20[0] = v21;
std::string::_M_construct<char *>(v20, *(_BYTE **)a3, *(_QWORD *)a3 + *(_QWORD *)(a3 + 8));
Render::Render((long long)&v15, a1, v20, v24);
*(_DWORD *)(v14 - 8) = v16;
*(_QWORD *)(v14 - 16) = v15;
std::string::operator=(v14, (long long)v17);
*(_QWORD *)(v14 + 32) = v19;
if ( v17[0] != v18 )
operator delete(v17[0], v18[0] + 1LL);
if ( v20[0] != v21 )
operator delete(v20[0], v21[0] + 1LL);
}
result = v14 + 224;
v13 = v14 + 184 == v11;
v14 += 224LL;
}
while ( !v13 );
}
return result;
}
| ChangeButtonState:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa8
MOV R12,RCX
MOV R13,RDX
MOV RBX,RSI
MOVAPS xmmword ptr [RSP + 0x80],XMM1
MOVAPS xmmword ptr [RSP + 0x90],XMM0
MOV R14,RDI
CALL 0x0017bd8f
MOVAPS XMM1,xmmword ptr [RSP + 0x90]
MOVAPS XMM2,xmmword ptr [RSP + 0x80]
CALL 0x00183648
MOV R15,qword ptr [R14 + 0x98]
MOV RBP,qword ptr [R14 + 0xa0]
TEST AL,AL
JZ 0x0010ce96
CMP R15,RBP
JZ 0x0010cf66
ADD R15,0x28
LEA R13,[RSP + 0x60]
LAB_0010cdd7:
CMP qword ptr [R15 + -0x20],RBX
JZ 0x0010cdf8
LAB_0010cddd:
LEA RAX,[R15 + 0xe0]
ADD R15,0xb8
CMP R15,RBP
MOV R15,RAX
JNZ 0x0010cdd7
JMP 0x0010cf66
LAB_0010cdf8:
LEA RAX,[RSP + 0x70]
MOV qword ptr [RSP + 0x60],RAX
MOV RSI,qword ptr [R12]
MOV RDX,qword ptr [R12 + 0x8]
ADD RDX,RSI
MOV RDI,R13
CALL 0x0010b256
LAB_0010ce16:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
MOV RDX,R13
MOVAPS XMM0,xmmword ptr [RSP + 0x80]
CALL 0x0010ac86
LAB_0010ce2e:
MOV EAX,dword ptr [RSP + 0x10]
MOV dword ptr [R15 + -0x8],EAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [R15 + -0x10],RAX
MOV RDI,R15
LEA RSI,[RSP + 0x18]
CALL 0x00109ac0
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [R15 + 0x20],RAX
MOV RDI,qword ptr [RSP + 0x18]
LEA RAX,[RSP + 0x28]
CMP RDI,RAX
JZ 0x0010ce71
MOV RSI,qword ptr [RSP + 0x28]
INC RSI
CALL 0x00109550
LAB_0010ce71:
MOV RDI,qword ptr [RSP + 0x60]
LEA RAX,[RSP + 0x70]
CMP RDI,RAX
JZ 0x0010cddd
MOV RSI,qword ptr [RSP + 0x70]
INC RSI
CALL 0x00109550
JMP 0x0010cddd
LAB_0010ce96:
CMP R15,RBP
JZ 0x0010cf66
ADD R15,0x28
LEA R12,[RSP + 0x40]
LAB_0010cea8:
CMP qword ptr [R15 + -0x20],RBX
JZ 0x0010cec9
LAB_0010ceae:
LEA RAX,[R15 + 0xe0]
ADD R15,0xb8
CMP R15,RBP
MOV R15,RAX
JNZ 0x0010cea8
JMP 0x0010cf66
LAB_0010cec9:
LEA RAX,[RSP + 0x50]
MOV qword ptr [RSP + 0x40],RAX
MOV RSI,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
ADD RDX,RSI
MOV RDI,R12
CALL 0x0010b256
LAB_0010cee6:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
MOV RDX,R12
MOVAPS XMM0,xmmword ptr [RSP + 0x80]
CALL 0x0010ac86
LAB_0010cefe:
MOV EAX,dword ptr [RSP + 0x10]
MOV dword ptr [R15 + -0x8],EAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [R15 + -0x10],RAX
MOV RDI,R15
LEA RSI,[RSP + 0x18]
CALL 0x00109ac0
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [R15 + 0x20],RAX
MOV RDI,qword ptr [RSP + 0x18]
LEA RAX,[RSP + 0x28]
CMP RDI,RAX
JZ 0x0010cf41
MOV RSI,qword ptr [RSP + 0x28]
INC RSI
CALL 0x00109550
LAB_0010cf41:
MOV RDI,qword ptr [RSP + 0x40]
LEA RAX,[RSP + 0x50]
CMP RDI,RAX
JZ 0x0010ceae
MOV RSI,qword ptr [RSP + 0x50]
INC RSI
CALL 0x00109550
JMP 0x0010ceae
LAB_0010cf66:
ADD RSP,0xa8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* ChangeButtonState(Context&, Rectangle, unsigned long, std::__cxx11::string, std::__cxx11::string)
*/
void ChangeButtonState(int4 param_1_00,Render *param_2,long param_1,long param_4,long *param_5
,long *param_6)
{
string *psVar1;
char cVar2;
string *psVar3;
string *psVar4;
int4 uVar5;
int8 local_d0;
int4 local_c8;
long *local_c0 [2];
long local_b0 [2];
int8 local_a0;
long *local_98 [2];
long local_88 [2];
long *local_78 [2];
long local_68 [2];
Render *local_58;
int4 local_48;
local_58._0_4_ = param_2._0_4_;
local_48 = param_1_00;
uVar5 = GetMousePosition();
cVar2 = CheckCollisionPointRec(uVar5,local_48,(int4)local_58._0_4_);
psVar4 = *(string **)(param_1 + 0x98);
psVar1 = *(string **)(param_1 + 0xa0);
if (cVar2 == '\0') {
if (psVar4 != psVar1) {
psVar4 = psVar4 + 0x28;
do {
if (*(long *)(psVar4 + -0x20) == param_4) {
local_98[0] = local_88;
std::__cxx11::string::_M_construct<char*>(local_98,*param_5,param_5[1] + *param_5);
/* try { // try from 0010cee6 to 0010cefd has its CatchHandler @ 0010cf78 */
Render::Render(local_58._0_4_,&local_d0,param_1,local_98);
*(int4 *)(psVar4 + -8) = local_c8;
*(int8 *)(psVar4 + -0x10) = local_d0;
std::__cxx11::string::operator=(psVar4,(string *)local_c0);
*(int8 *)(psVar4 + 0x20) = local_a0;
if (local_c0[0] != local_b0) {
operator_delete(local_c0[0],local_b0[0] + 1);
}
if (local_98[0] != local_88) {
operator_delete(local_98[0],local_88[0] + 1);
}
}
psVar3 = psVar4 + 0xb8;
psVar4 = psVar4 + 0xe0;
} while (psVar3 != psVar1);
}
}
else if (psVar4 != psVar1) {
psVar4 = psVar4 + 0x28;
do {
if (*(long *)(psVar4 + -0x20) == param_4) {
local_78[0] = local_68;
std::__cxx11::string::_M_construct<char*>(local_78,*param_6,param_6[1] + *param_6);
/* try { // try from 0010ce16 to 0010ce2d has its CatchHandler @ 0010cf91 */
Render::Render(local_58._0_4_,&local_d0,param_1,local_78);
*(int4 *)(psVar4 + -8) = local_c8;
*(int8 *)(psVar4 + -0x10) = local_d0;
std::__cxx11::string::operator=(psVar4,(string *)local_c0);
*(int8 *)(psVar4 + 0x20) = local_a0;
if (local_c0[0] != local_b0) {
operator_delete(local_c0[0],local_b0[0] + 1);
}
if (local_78[0] != local_68) {
operator_delete(local_78[0],local_68[0] + 1);
}
}
psVar3 = psVar4 + 0xb8;
psVar4 = psVar4 + 0xe0;
} while (psVar3 != psVar1);
}
return;
}
| |
25,073 | ChangeButtonState(Context&, Rectangle, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | csit-sgu[P]mit-game-2025_1/user.cpp | void ChangeButtonState(
Context &ctx,
Rectangle btnCollider,
size_t btn_id,
std::string path1,
std::string path2
) {
if (IsMouseOnButton(btnCollider)) {
for (auto &obj : ctx.current_scene) {
if (obj.id == btn_id) {
obj.render = Render(
ctx, path2, Vector2(btnCollider.width, btnCollider.height)
);
}
}
} else {
for (auto &obj : ctx.current_scene) {
if (obj.id == btn_id) {
obj.render = Render(
ctx, path1, Vector2(btnCollider.width, btnCollider.height)
);
}
}
}
} | O2 | cpp | ChangeButtonState(Context&, Rectangle, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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 $0x98, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, (%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movaps %xmm1, 0x10(%rsp)
callq 0xc9fa
movq 0x98(%r14), %r15
movq 0xa0(%r14), %r12
testb %al, %al
je 0xcaba
leaq 0x78(%rsp), %r13
leaq 0x20(%rsp), %rbp
cmpq %r12, %r15
je 0xcb15
cmpq %rbx, 0x8(%r15)
jne 0xcab1
movq %r13, %rdi
movq 0x8(%rsp), %rsi
callq 0xaaf4
movq %rbp, %rdi
movq %r14, %rsi
movq %r13, %rdx
movaps 0x10(%rsp), %xmm0
callq 0xa466
leaq 0x18(%r15), %rdi
movq %rbp, %rsi
callq 0xb078
leaq 0x30(%rsp), %rdi
callq 0xa5ac
movq %r13, %rdi
callq 0xa5ac
addq $0xe0, %r15
jmp 0xca64
leaq 0x58(%rsp), %r13
leaq 0x20(%rsp), %rbp
cmpq %r12, %r15
je 0xcb15
cmpq %rbx, 0x8(%r15)
jne 0xcb0c
movq %r13, %rdi
movq (%rsp), %rsi
callq 0xaaf4
movq %rbp, %rdi
movq %r14, %rsi
movq %r13, %rdx
movaps 0x10(%rsp), %xmm0
callq 0xa466
leaq 0x18(%r15), %rdi
movq %rbp, %rsi
callq 0xb078
leaq 0x30(%rsp), %rdi
callq 0xa5ac
movq %r13, %rdi
callq 0xa5ac
addq $0xe0, %r15
jmp 0xcac4
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
jmp 0xcb39
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0xa5ac
movq %rbx, %rdi
callq 0x99b0
| _Z17ChangeButtonStateR7Context9RectanglemNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES7_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov [rsp+0C8h+var_C0], rcx
mov [rsp+0C8h+var_C8], rdx
mov rbx, rsi
mov r14, rdi
movaps [rsp+0C8h+var_B8], xmm1
call _Z15IsMouseOnButton9Rectangle; IsMouseOnButton(Rectangle)
mov r15, [r14+98h]
mov r12, [r14+0A0h]
test al, al
jz short loc_CABA
lea r13, [rsp+0C8h+var_50]
lea rbp, [rsp+0C8h+var_A8]
loc_CA64:
cmp r15, r12
jz loc_CB15
cmp [r15+8], rbx
jnz short loc_CAB1
mov rdi, r13
mov rsi, [rsp+0C8h+var_C0]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
mov rdi, rbp
mov rsi, r14
mov rdx, r13
movaps xmm0, [rsp+0C8h+var_B8]
call _ZN6RenderC2ER7ContextNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE7Vector2; Render::Render(Context &,std::string,Vector2)
lea rdi, [r15+18h]
mov rsi, rbp
call _ZN6RenderaSEOS_; Render::operator=(Render&&)
lea rdi, [rsp+0C8h+var_98]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r13
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_CAB1:
add r15, 0E0h
jmp short loc_CA64
loc_CABA:
lea r13, [rsp+0C8h+var_70]
lea rbp, [rsp+0C8h+var_A8]
loc_CAC4:
cmp r15, r12
jz short loc_CB15
cmp [r15+8], rbx
jnz short loc_CB0C
mov rdi, r13
mov rsi, [rsp+0C8h+var_C8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
mov rdi, rbp
mov rsi, r14
mov rdx, r13
movaps xmm0, [rsp+0C8h+var_B8]
call _ZN6RenderC2ER7ContextNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE7Vector2; Render::Render(Context &,std::string,Vector2)
lea rdi, [r15+18h]
mov rsi, rbp
call _ZN6RenderaSEOS_; Render::operator=(Render&&)
lea rdi, [rsp+0C8h+var_98]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r13
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_CB0C:
add r15, 0E0h
jmp short loc_CAC4
loc_CB15:
add rsp, 98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_50]
jmp short loc_CB39
mov rbx, rax
lea rdi, [rsp+arg_70]
loc_CB39:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
| long long ChangeButtonState(long long a1, long long a2, _QWORD *a3, _QWORD *a4, double a5, __m128 a6)
{
long long result; // rax
long long v7; // r15
long long v8; // r12
_BYTE v11[16]; // [rsp+20h] [rbp-A8h] BYREF
_QWORD v12[4]; // [rsp+58h] [rbp-70h] BYREF
_QWORD v13[10]; // [rsp+78h] [rbp-50h] BYREF
result = IsMouseOnButton(a5, *(double *)a6.m128_u64);
v7 = *(_QWORD *)(a1 + 152);
v8 = *(_QWORD *)(a1 + 160);
if ( (_BYTE)result )
{
while ( v7 != v8 )
{
if ( *(_QWORD *)(v7 + 8) == a2 )
{
std::string::basic_string(v13, a4);
Render::Render((long long)v11, a1, v13, a6);
result = Render::operator=(v7 + 24, (long long)v11);
std::string::~string();
std::string::~string();
}
v7 += 224LL;
}
}
else
{
while ( v7 != v8 )
{
if ( *(_QWORD *)(v7 + 8) == a2 )
{
std::string::basic_string(v12, a3);
Render::Render((long long)v11, a1, v12, a6);
result = Render::operator=(v7 + 24, (long long)v11);
std::string::~string();
std::string::~string();
}
v7 += 224LL;
}
}
return result;
}
| ChangeButtonState:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RSP + 0x8],RCX
MOV qword ptr [RSP],RDX
MOV RBX,RSI
MOV R14,RDI
MOVAPS xmmword ptr [RSP + 0x10],XMM1
CALL 0x0010c9fa
MOV R15,qword ptr [R14 + 0x98]
MOV R12,qword ptr [R14 + 0xa0]
TEST AL,AL
JZ 0x0010caba
LEA R13,[RSP + 0x78]
LEA RBP,[RSP + 0x20]
LAB_0010ca64:
CMP R15,R12
JZ 0x0010cb15
CMP qword ptr [R15 + 0x8],RBX
JNZ 0x0010cab1
MOV RDI,R13
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x0010aaf4
LAB_0010ca80:
MOV RDI,RBP
MOV RSI,R14
MOV RDX,R13
MOVAPS XMM0,xmmword ptr [RSP + 0x10]
CALL 0x0010a466
LAB_0010ca93:
LEA RDI,[R15 + 0x18]
MOV RSI,RBP
CALL 0x0010b078
LEA RDI,[RSP + 0x30]
CALL 0x0010a5ac
MOV RDI,R13
CALL 0x0010a5ac
LAB_0010cab1:
ADD R15,0xe0
JMP 0x0010ca64
LAB_0010caba:
LEA R13,[RSP + 0x58]
LEA RBP,[RSP + 0x20]
LAB_0010cac4:
CMP R15,R12
JZ 0x0010cb15
CMP qword ptr [R15 + 0x8],RBX
JNZ 0x0010cb0c
MOV RDI,R13
MOV RSI,qword ptr [RSP]
CALL 0x0010aaf4
LAB_0010cadb:
MOV RDI,RBP
MOV RSI,R14
MOV RDX,R13
MOVAPS XMM0,xmmword ptr [RSP + 0x10]
CALL 0x0010a466
LAB_0010caee:
LEA RDI,[R15 + 0x18]
MOV RSI,RBP
CALL 0x0010b078
LEA RDI,[RSP + 0x30]
CALL 0x0010a5ac
MOV RDI,R13
CALL 0x0010a5ac
LAB_0010cb0c:
ADD R15,0xe0
JMP 0x0010cac4
LAB_0010cb15:
ADD RSP,0x98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* ChangeButtonState(Context&, Rectangle, unsigned long, std::__cxx11::string, std::__cxx11::string)
*/
void ChangeButtonState(int8 param_1_00,Render *param_2,long param_1,long param_4,
string *param_5,string *param_6)
{
long lVar1;
char cVar2;
long lVar3;
Render local_a8 [16];
string local_98 [40];
string local_70 [32];
string local_50 [32];
cVar2 = IsMouseOnButton();
lVar3 = *(long *)(param_1 + 0x98);
lVar1 = *(long *)(param_1 + 0xa0);
if (cVar2 == '\0') {
for (; lVar3 != lVar1; lVar3 = lVar3 + 0xe0) {
if (*(long *)(lVar3 + 8) == param_4) {
std::__cxx11::string::string(local_70,param_5);
/* try { // try from 0010cadb to 0010caed has its CatchHandler @ 0010cb27 */
Render::Render(param_2._0_4_,local_a8,param_1,local_70);
Render::operator=((Render *)(lVar3 + 0x18),local_a8);
std::__cxx11::string::~string(local_98);
std::__cxx11::string::~string(local_70);
}
}
}
else {
for (; lVar3 != lVar1; lVar3 = lVar3 + 0xe0) {
if (*(long *)(lVar3 + 8) == param_4) {
std::__cxx11::string::string(local_50,param_6);
/* try { // try from 0010ca80 to 0010ca92 has its CatchHandler @ 0010cb31 */
Render::Render(param_2._0_4_,local_a8,param_1,local_50);
Render::operator=((Render *)(lVar3 + 0x18),local_a8);
std::__cxx11::string::~string(local_98);
std::__cxx11::string::~string(local_50);
}
}
}
return;
}
| |
25,074 | wsrep_is_wsrep_xid | eloqsql/sql/wsrep_xid.cc | int wsrep_is_wsrep_xid(const void* xid_ptr)
{
const XID* xid= static_cast<const XID*>(xid_ptr);
return (xid->formatID == 1 &&
xid->bqual_length == 0 &&
xid->gtrid_length >= static_cast<long>(WSREP_XID_GTRID_LEN_V_1_2) &&
!memcmp(xid->data, WSREP_XID_PREFIX, WSREP_XID_PREFIX_LEN) &&
(((xid->data[WSREP_XID_VERSION_OFFSET] == WSREP_XID_VERSION_1 ||
xid->data[WSREP_XID_VERSION_OFFSET] == WSREP_XID_VERSION_2) &&
xid->gtrid_length == WSREP_XID_GTRID_LEN_V_1_2) ||
(xid->data[WSREP_XID_VERSION_OFFSET] == WSREP_XID_VERSION_3 &&
xid->gtrid_length == WSREP_XID_GTRID_LEN_V_3)));
} | O0 | cpp | wsrep_is_wsrep_xid:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x1, (%rcx)
movb %al, -0x11(%rbp)
jne 0xfc3a37
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x10(%rcx)
movb %al, -0x11(%rbp)
jne 0xfc3a37
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x20, 0x8(%rcx)
movb %al, -0x11(%rbp)
jl 0xfc3a37
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
leaq 0x4b0a96(%rip), %rsi # 0x1474460
movl $0x7, %edx
callq 0x776100
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
jne 0xfc3a37
movq -0x10(%rbp), %rax
movsbl 0x1f(%rax), %eax
cmpl $0x64, %eax
je 0xfc39fa
movq -0x10(%rbp), %rax
movsbl 0x1f(%rax), %eax
cmpl $0x65, %eax
jne 0xfc3a0a
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpq $0x20, 0x8(%rcx)
movb %al, -0x12(%rbp)
je 0xfc3a31
movq -0x10(%rbp), %rax
movsbl 0x1f(%rax), %ecx
xorl %eax, %eax
cmpl $0x66, %ecx
movb %al, -0x13(%rbp)
jne 0xfc3a2b
movq -0x10(%rbp), %rax
cmpq $0x30, 0x8(%rax)
sete %al
movb %al, -0x13(%rbp)
movb -0x13(%rbp), %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| wsrep_is_wsrep_xid:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rcx, [rbp+var_10]
xor eax, eax
cmp qword ptr [rcx], 1
mov [rbp+var_11], al
jnz loc_FC3A37
mov rcx, [rbp+var_10]
xor eax, eax
cmp qword ptr [rcx+10h], 0
mov [rbp+var_11], al
jnz loc_FC3A37
mov rcx, [rbp+var_10]
xor eax, eax
cmp qword ptr [rcx+8], 20h ; ' '
mov [rbp+var_11], al
jl short loc_FC3A37
mov rdi, [rbp+var_10]
add rdi, 18h
lea rsi, dword_1474460
mov edx, 7
call _memcmp
mov ecx, eax
xor eax, eax
cmp ecx, 0
mov [rbp+var_11], al
jnz short loc_FC3A37
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax+1Fh]
cmp eax, 64h ; 'd'
jz short loc_FC39FA
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax+1Fh]
cmp eax, 65h ; 'e'
jnz short loc_FC3A0A
loc_FC39FA:
mov rcx, [rbp+var_10]
mov al, 1
cmp qword ptr [rcx+8], 20h ; ' '
mov [rbp+var_12], al
jz short loc_FC3A31
loc_FC3A0A:
mov rax, [rbp+var_10]
movsx ecx, byte ptr [rax+1Fh]
xor eax, eax
cmp ecx, 66h ; 'f'
mov [rbp+var_13], al
jnz short loc_FC3A2B
mov rax, [rbp+var_10]
cmp qword ptr [rax+8], 30h ; '0'
setz al
mov [rbp+var_13], al
loc_FC3A2B:
mov al, [rbp+var_13]
mov [rbp+var_12], al
loc_FC3A31:
mov al, [rbp+var_12]
mov [rbp+var_11], al
loc_FC3A37:
mov al, [rbp+var_11]
and al, 1
movzx eax, al
add rsp, 20h
pop rbp
retn
| long long wsrep_is_wsrep_xid(long long a1)
{
bool v2; // [rsp+Dh] [rbp-13h]
char v3; // [rsp+Eh] [rbp-12h]
char v4; // [rsp+Fh] [rbp-11h]
v4 = 0;
if ( *(_QWORD *)a1 == 1LL )
{
v4 = 0;
if ( !*(_QWORD *)(a1 + 16) )
{
v4 = 0;
if ( *(long long *)(a1 + 8) >= 32 )
{
v4 = 0;
if ( !(unsigned int)memcmp(a1 + 24, &dword_1474460, 7LL) )
{
if ( *(_BYTE *)(a1 + 31) != 100 && *(_BYTE *)(a1 + 31) != 101 || (v3 = 1, *(_QWORD *)(a1 + 8) != 32LL) )
{
v2 = 0;
if ( *(_BYTE *)(a1 + 31) == 102 )
v2 = *(_QWORD *)(a1 + 8) == 48LL;
v3 = v2;
}
v4 = v3;
}
}
}
}
return v4 & 1;
}
| cmp_sec_link:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RAX + 0x60]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
MOV RCX,qword ptr [RCX + 0x20]
CMP RAX,qword ptr [RCX + 0x60]
JNC 0x00fc39a6
MOV EAX,0xffffffff
MOV dword ptr [RBP + -0x14],EAX
JMP 0x00fc39d4
LAB_00fc39a6:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x20]
MOV RDX,qword ptr [RAX + 0x60]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x20]
MOV RSI,qword ptr [RAX + 0x60]
XOR EAX,EAX
MOV ECX,0x1
CMP RDX,RSI
CMOVA EAX,ECX
MOV dword ptr [RBP + -0x14],EAX
LAB_00fc39d4:
MOV EAX,dword ptr [RBP + -0x14]
POP RBP
RET
|
uint cmp_sec_link(long *param_1,long *param_2)
{
uint local_1c;
if (*(ulong *)(*(long *)(*param_1 + 0x20) + 0x60) < *(ulong *)(*(long *)(*param_2 + 0x20) + 0x60))
{
local_1c = 0xffffffff;
}
else {
local_1c = (uint)(*(ulong *)(*(long *)(*param_2 + 0x20) + 0x60) <
*(ulong *)(*(long *)(*param_1 + 0x20) + 0x60));
}
return local_1c;
}
| |
25,075 | mi_kpos | eloqsql/storage/myisam/mi_search.c | my_off_t _mi_kpos(uint nod_flag, uchar *after_key)
{
after_key-=nod_flag;
switch (nod_flag) {
#if SIZEOF_OFF_T > 4
case 7:
return mi_uint7korr(after_key)*MI_MIN_KEY_BLOCK_LENGTH;
case 6:
return mi_uint6korr(after_key)*MI_MIN_KEY_BLOCK_LENGTH;
case 5:
return mi_uint5korr(after_key)*MI_MIN_KEY_BLOCK_LENGTH;
#else
case 7:
after_key++;
case 6:
after_key++;
case 5:
after_key++;
#endif
case 4:
return ((my_off_t) mi_uint4korr(after_key))*MI_MIN_KEY_BLOCK_LENGTH;
case 3:
return ((my_off_t) mi_uint3korr(after_key))*MI_MIN_KEY_BLOCK_LENGTH;
case 2:
return (my_off_t) (mi_uint2korr(after_key)*MI_MIN_KEY_BLOCK_LENGTH);
case 1:
return (uint) (*after_key)*MI_MIN_KEY_BLOCK_LENGTH;
case 0: /* At leaf page */
default: /* Impossible */
return(HA_OFFSET_ERROR);
}
} | O3 | c | mi_kpos:
pushq %rbp
movq %rsp, %rbp
leal -0x1(%rdi), %eax
cmpl $0x6, %eax
ja 0x845bf
movl %edi, %ecx
negq %rcx
leaq 0x5d596(%rip), %rdx # 0xe1ae4
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movzbl (%rsi,%rcx), %eax
shll $0xa, %eax
jmp 0x84613
movl (%rsi,%rcx), %eax
movzbl 0x4(%rsi,%rcx), %ecx
shlq $0x38, %rcx
shlq $0x18, %rax
jmp 0x84609
movzbl 0x2(%rsi,%rcx), %eax
movzbl 0x1(%rsi,%rcx), %edx
movzbl (%rsi,%rcx), %ecx
shlq $0x1a, %rcx
shll $0x12, %edx
shll $0xa, %eax
orl %edx, %eax
jmp 0x845ba
movzbl 0x3(%rsi,%rcx), %eax
movzbl 0x2(%rsi,%rcx), %edx
movzbl 0x1(%rsi,%rcx), %edi
movzbl (%rsi,%rcx), %ecx
shlq $0x22, %rcx
shlq $0x1a, %rdi
shll $0x12, %edx
shll $0xa, %eax
orl %edx, %eax
orq %rdi, %rax
orq %rcx, %rax
jmp 0x84613
movq $-0x1, %rax
jmp 0x84613
movzbl 0x1(%rsi,%rcx), %eax
movzbl (%rsi,%rcx), %ecx
shll $0x12, %ecx
shll $0xa, %eax
orl %ecx, %eax
jmp 0x84613
movl (%rsi,%rcx), %eax
movzwl 0x4(%rsi,%rcx), %ecx
shlq $0x30, %rcx
shlq $0x10, %rax
jmp 0x84609
movl (%rsi,%rcx), %eax
movzwl 0x4(%rsi,%rcx), %edx
movzbl 0x6(%rsi,%rcx), %ecx
shlq $0x38, %rcx
shlq $0x28, %rdx
shlq $0x8, %rax
orq %rdx, %rax
orq %rcx, %rax
bswapq %rax
shlq $0xa, %rax
popq %rbp
retq
| _mi_kpos:
push rbp
mov rbp, rsp
lea eax, [rdi-1]; switch 7 cases
cmp eax, 6
ja short def_84555; jumptable 0000000000084555 default case
mov ecx, edi
neg rcx
lea rdx, jpt_84555
movsxd rax, ds:(jpt_84555 - 0E1AE4h)[rdx+rax*4]
add rax, rdx
jmp rax; switch jump
loc_84557:
movzx eax, byte ptr [rsi+rcx]; jumptable 0000000000084555 case 1
shl eax, 0Ah
jmp loc_84613
loc_84563:
mov eax, [rsi+rcx]; jumptable 0000000000084555 case 5
movzx ecx, byte ptr [rsi+rcx+4]
shl rcx, 38h
shl rax, 18h
jmp loc_84609
loc_84578:
movzx eax, byte ptr [rsi+rcx+2]; jumptable 0000000000084555 case 3
movzx edx, byte ptr [rsi+rcx+1]
movzx ecx, byte ptr [rsi+rcx]
shl rcx, 1Ah
shl edx, 12h
shl eax, 0Ah
or eax, edx
jmp short loc_845BA
loc_84594:
movzx eax, byte ptr [rsi+rcx+3]; jumptable 0000000000084555 case 4
movzx edx, byte ptr [rsi+rcx+2]
movzx edi, byte ptr [rsi+rcx+1]
movzx ecx, byte ptr [rsi+rcx]
shl rcx, 22h
shl rdi, 1Ah
shl edx, 12h
shl eax, 0Ah
or eax, edx
or rax, rdi
loc_845BA:
or rax, rcx
jmp short loc_84613
def_84555:
mov rax, 0FFFFFFFFFFFFFFFFh; jumptable 0000000000084555 default case
jmp short loc_84613
loc_845C8:
movzx eax, byte ptr [rsi+rcx+1]; jumptable 0000000000084555 case 2
movzx ecx, byte ptr [rsi+rcx]
shl ecx, 12h
shl eax, 0Ah
or eax, ecx
jmp short loc_84613
loc_845DB:
mov eax, [rsi+rcx]; jumptable 0000000000084555 case 6
movzx ecx, word ptr [rsi+rcx+4]
shl rcx, 30h
shl rax, 10h
jmp short loc_84609
loc_845ED:
mov eax, [rsi+rcx]; jumptable 0000000000084555 case 7
movzx edx, word ptr [rsi+rcx+4]
movzx ecx, byte ptr [rsi+rcx+6]
shl rcx, 38h
shl rdx, 28h
shl rax, 8
or rax, rdx
loc_84609:
or rax, rcx
bswap rax
shl rax, 0Ah
loc_84613:
pop rbp
retn
| unsigned long long mi_kpos(unsigned int a1, long long a2)
{
unsigned long long result; // rax
unsigned long long v3; // rcx
unsigned long long v4; // rax
unsigned long long v5; // rcx
unsigned long long v6; // rax
switch ( a1 )
{
case 1u:
return *(unsigned __int8 *)(a2 - a1) << 10;
case 2u:
return (*(unsigned __int8 *)(a2 - a1) << 18) | (*(unsigned __int8 *)(a2 - a1 + 1) << 10);
case 3u:
v5 = (unsigned long long)*(unsigned __int8 *)(a2 - a1) << 26;
v6 = (*(unsigned __int8 *)(a2 - a1 + 1) << 18) | (*(unsigned __int8 *)(a2 - a1 + 2) << 10);
return v5 | v6;
case 4u:
v5 = (unsigned long long)*(unsigned __int8 *)(a2 - a1) << 34;
v6 = ((unsigned long long)*(unsigned __int8 *)(a2 - a1 + 1) << 26) | (*(unsigned __int8 *)(a2 - a1 + 2) << 18) | (*(unsigned __int8 *)(a2 - a1 + 3) << 10);
return v5 | v6;
case 5u:
v3 = (unsigned long long)*(unsigned __int8 *)(a2 - a1 + 4) << 56;
v4 = (unsigned long long)*(unsigned int *)(a2 - a1) << 24;
goto LABEL_11;
case 6u:
v3 = (unsigned long long)*(unsigned __int16 *)(a2 - a1 + 4) << 48;
v4 = (unsigned long long)*(unsigned int *)(a2 - a1) << 16;
goto LABEL_11;
case 7u:
v3 = (unsigned long long)*(unsigned __int8 *)(a2 - a1 + 6) << 56;
v4 = ((unsigned long long)*(unsigned __int16 *)(a2 - a1 + 4) << 40) | ((unsigned long long)*(unsigned int *)(a2 - a1) << 8);
LABEL_11:
result = _byteswap_uint64(v3 | v4) << 10;
break;
default:
result = -1LL;
break;
}
return result;
}
| _mi_kpos:
PUSH RBP
MOV RBP,RSP
LEA EAX,[RDI + -0x1]
CMP EAX,0x6
JA 0x001845bf
MOV ECX,EDI
NEG RCX
LEA RDX,[0x1e1ae4]
MOVSXD RAX,dword ptr [RDX + RAX*0x4]
ADD RAX,RDX
switchD:
JMP RAX
caseD_1:
MOVZX EAX,byte ptr [RSI + RCX*0x1]
SHL EAX,0xa
JMP 0x00184613
caseD_5:
MOV EAX,dword ptr [RSI + RCX*0x1]
MOVZX ECX,byte ptr [RSI + RCX*0x1 + 0x4]
SHL RCX,0x38
SHL RAX,0x18
JMP 0x00184609
caseD_3:
MOVZX EAX,byte ptr [RSI + RCX*0x1 + 0x2]
MOVZX EDX,byte ptr [RSI + RCX*0x1 + 0x1]
MOVZX ECX,byte ptr [RSI + RCX*0x1]
SHL RCX,0x1a
SHL EDX,0x12
SHL EAX,0xa
OR EAX,EDX
JMP 0x001845ba
caseD_4:
MOVZX EAX,byte ptr [RSI + RCX*0x1 + 0x3]
MOVZX EDX,byte ptr [RSI + RCX*0x1 + 0x2]
MOVZX EDI,byte ptr [RSI + RCX*0x1 + 0x1]
MOVZX ECX,byte ptr [RSI + RCX*0x1]
SHL RCX,0x22
SHL RDI,0x1a
SHL EDX,0x12
SHL EAX,0xa
OR EAX,EDX
OR RAX,RDI
LAB_001845ba:
OR RAX,RCX
JMP 0x00184613
LAB_001845bf:
MOV RAX,-0x1
JMP 0x00184613
caseD_2:
MOVZX EAX,byte ptr [RSI + RCX*0x1 + 0x1]
MOVZX ECX,byte ptr [RSI + RCX*0x1]
SHL ECX,0x12
SHL EAX,0xa
OR EAX,ECX
JMP 0x00184613
caseD_6:
MOV EAX,dword ptr [RSI + RCX*0x1]
MOVZX ECX,word ptr [RSI + RCX*0x1 + 0x4]
SHL RCX,0x30
SHL RAX,0x10
JMP 0x00184609
caseD_7:
MOV EAX,dword ptr [RSI + RCX*0x1]
MOVZX EDX,word ptr [RSI + RCX*0x1 + 0x4]
MOVZX ECX,byte ptr [RSI + RCX*0x1 + 0x6]
SHL RCX,0x38
SHL RDX,0x28
SHL RAX,0x8
OR RAX,RDX
LAB_00184609:
OR RAX,RCX
BSWAP RAX
SHL RAX,0xa
LAB_00184613:
POP RBP
RET
|
ulong _mi_kpos(uint param_1,long param_2)
{
ulong uVar1;
long lVar2;
ulong uVar3;
if (6 < param_1 - 1) {
return 0xffffffffffffffff;
}
lVar2 = -(ulong)param_1;
switch(param_1) {
case 1:
return (ulong)*(byte *)(param_2 + lVar2) << 10;
case 2:
return (ulong)((uint)*(byte *)(param_2 + 1 + lVar2) << 10 |
(uint)*(byte *)(param_2 + lVar2) << 0x12);
case 3:
uVar3 = (ulong)*(byte *)(param_2 + lVar2) << 0x1a;
uVar1 = (ulong)((uint)*(byte *)(param_2 + 2 + lVar2) << 10 |
(uint)*(byte *)(param_2 + 1 + lVar2) << 0x12);
goto LAB_001845ba;
case 4:
uVar3 = (ulong)*(byte *)(param_2 + lVar2) << 0x22;
uVar1 = (ulong)((uint)*(byte *)(param_2 + 3 + lVar2) << 10 |
(uint)*(byte *)(param_2 + 2 + lVar2) << 0x12) |
(ulong)*(byte *)(param_2 + 1 + lVar2) << 0x1a;
LAB_001845ba:
return uVar1 | uVar3;
case 5:
uVar3 = (ulong)*(byte *)(param_2 + 4 + lVar2) << 0x38;
uVar1 = (ulong)*(uint *)(param_2 + lVar2) << 0x18;
break;
case 6:
uVar3 = (ulong)*(ushort *)(param_2 + 4 + lVar2) << 0x30;
uVar1 = (ulong)*(uint *)(param_2 + lVar2) << 0x10;
break;
case 7:
uVar3 = (ulong)*(byte *)(param_2 + 6 + lVar2) << 0x38;
uVar1 = (ulong)*(uint *)(param_2 + lVar2) << 8 | (ulong)*(ushort *)(param_2 + 4 + lVar2) << 0x28
;
}
return (uVar3 >> 0x38 | ((uVar1 | uVar3) & 0xff000000000000) >> 0x28 |
(uVar1 & 0xff0000000000) >> 0x18 | (uVar1 & 0xff00000000) >> 8 | (uVar1 & 0xff000000) << 8
| (uVar1 & 0xff0000) << 0x18 | (uVar1 & 0xff00) << 0x28) << 10;
}
| |
25,076 | arena_alloc_aligned | tsotchke[P]eshkol/src/core/memory/arena.c | void* arena_alloc_aligned(Arena* arena, size_t size, size_t alignment) {
assert(arena != NULL);
// Add debug output for zero-sized allocations
if (size == 0) {
fprintf(stderr, "ERROR: Attempted to allocate 0 bytes in arena_alloc_aligned\n");
// Print stack trace if possible
void* buffer[100];
int nptrs = backtrace(buffer, 100);
backtrace_symbols_fd(buffer, nptrs, STDERR_FILENO);
// Continue with a minimum size of 1 instead of failing
size = 1;
}
assert(alignment > 0 && (alignment & (alignment - 1)) == 0); // Power of 2
// Try to allocate from current block
void* result = arena_alloc_from_block(arena, arena->current, size, alignment);
if (result) return result;
// Need a new block
size_t min_size = size + alignment - 1; // Ensure enough space for alignment
Block* block = arena_add_block(arena, min_size);
if (!block) return NULL;
// Allocate from the new block
result = arena_alloc_from_block(arena, block, size, alignment);
assert(result != NULL); // Should always succeed
return result;
} | O1 | c | arena_alloc_aligned:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x402d
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rsi, %rsi
je 0x401d
leaq -0x1(%rbx), %rax
movq %rbx, %rcx
xorq %rax, %rcx
cmpq %rax, %rcx
jbe 0x404c
movq (%r14), %rsi
movq %r14, %rdi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x408a
testq %rax, %rax
jne 0x4013
leaq (%rbx,%r15), %rax
decq %rax
je 0x406b
movq (%r14), %r12
movq 0x8(%r12), %r13
addq %r13, %r13
cmpq %rax, %r13
cmovbeq %rax, %r13
leaq 0x18(%r13), %rdi
callq 0x10d0
testq %rax, %rax
je 0x3fd5
xorl %ecx, %ecx
movq %rcx, (%rax)
movq %r13, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rax, (%r12)
movq %rax, (%r14)
jmp 0x3fd7
xorl %eax, %eax
testq %rax, %rax
je 0x4011
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x408a
testq %rax, %rax
jne 0x4013
leaq 0x4871(%rip), %rdi # 0x886a
leaq 0x4774(%rip), %rsi # 0x8774
leaq 0x47bf(%rip), %rcx # 0x87c6
movl $0xa5, %edx
callq 0x1090
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x1110
movl $0x1, %r15d
jmp 0x3f65
leaq 0x2ff4(%rip), %rdi # 0x7028
leaq 0x4739(%rip), %rsi # 0x8774
leaq 0x4784(%rip), %rcx # 0x87c6
movl $0x8b, %edx
callq 0x1090
leaq 0x47e3(%rip), %rdi # 0x8836
leaq 0x471a(%rip), %rsi # 0x8774
leaq 0x4765(%rip), %rcx # 0x87c6
movl $0x98, %edx
callq 0x1090
leaq 0x490f(%rip), %rdi # 0x8981
leaq 0x46fb(%rip), %rsi # 0x8774
leaq 0x48d9(%rip), %rcx # 0x8959
movl $0x6f, %edx
callq 0x1090
| arena_alloc_aligned:
push r15
push r14
push r13
push r12
push rbx
test rdi, rdi
jz loc_402D
mov rbx, rdx
mov r15, rsi
mov r14, rdi
test rsi, rsi
jz loc_401D
loc_3F65:
lea rax, [rbx-1]
mov rcx, rbx
xor rcx, rax
cmp rcx, rax
jbe loc_404C
mov rsi, [r14]
mov rdi, r14
mov rdx, r15
mov rcx, rbx
call arena_alloc_from_block
test rax, rax
jnz loc_4013
lea rax, [rbx+r15]
dec rax
jz loc_406B
mov r12, [r14]
mov r13, [r12+8]
add r13, r13
cmp r13, rax
cmovbe r13, rax
lea rdi, [r13+18h]
call _malloc
test rax, rax
jz short loc_3FD5
xor ecx, ecx
mov [rax], rcx
mov [rax+8], r13
mov [rax+10h], rcx
mov [r12], rax
mov [r14], rax
jmp short loc_3FD7
loc_3FD5:
xor eax, eax
loc_3FD7:
test rax, rax
jz short loc_4011
mov rdi, r14
mov rsi, rax
mov rdx, r15
mov rcx, rbx
call arena_alloc_from_block
test rax, rax
jnz short loc_4013
lea rdi, aResultNull; "result != NULL"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidArenaAlloc; "void *arena_alloc_aligned(Arena *, size"...
mov edx, 0A5h
call ___assert_fail
loc_4011:
xor eax, eax
loc_4013:
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_401D:
call arena_alloc_aligned_cold_1
mov r15d, 1
jmp loc_3F65
loc_402D:
lea rdi, aArenaNull; "arena != NULL"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidArenaAlloc; "void *arena_alloc_aligned(Arena *, size"...
mov edx, 8Bh
call ___assert_fail
loc_404C:
lea rdi, aAlignment0Alig; "alignment > 0 && (alignment & (alignmen"...
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidArenaAlloc; "void *arena_alloc_aligned(Arena *, size"...
mov edx, 98h
call ___assert_fail
loc_406B:
lea rdi, aMinSize0; "min_size > 0"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aBlockArenaAddB; "Block *arena_add_block(Arena *, size_t)"
mov edx, 6Fh ; 'o'
call ___assert_fail
| long long arena_alloc_aligned(_QWORD *a1, long long a2, unsigned long long a3)
{
long long v4; // r15
long long result; // rax
_QWORD *v6; // r12
unsigned long long v7; // r13
_QWORD *v8; // rax
if ( !a1 )
__assert_fail(
"arena != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/memory/arena.c",
139LL,
"void *arena_alloc_aligned(Arena *, size_t, size_t)");
v4 = a2;
if ( !a2 )
{
arena_alloc_aligned_cold_1();
v4 = 1LL;
}
if ( ((a3 - 1) ^ a3) <= a3 - 1 )
__assert_fail(
"alignment > 0 && (alignment & (alignment - 1)) == 0",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/memory/arena.c",
152LL,
"void *arena_alloc_aligned(Arena *, size_t, size_t)");
result = arena_alloc_from_block(a1, *a1, v4, a3);
if ( !result )
{
if ( a3 + v4 == 1 )
__assert_fail(
"min_size > 0",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/memory/arena.c",
111LL,
"Block *arena_add_block(Arena *, size_t)");
v6 = (_QWORD *)*a1;
v7 = 2LL * *(_QWORD *)(*a1 + 8LL);
if ( v7 <= a3 + v4 - 1 )
v7 = a3 + v4 - 1;
v8 = (_QWORD *)malloc(v7 + 24);
if ( v8 )
{
*v8 = 0LL;
v8[1] = v7;
v8[2] = 0LL;
*v6 = v8;
*a1 = v8;
}
else
{
v8 = 0LL;
}
if ( v8 )
{
result = arena_alloc_from_block(a1, v8, v4, a3);
if ( !result )
__assert_fail(
"result != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/memory/arena.c",
165LL,
"void *arena_alloc_aligned(Arena *, size_t, size_t)");
}
else
{
return 0LL;
}
}
return result;
}
| arena_alloc_aligned:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
TEST RDI,RDI
JZ 0x0010402d
MOV RBX,RDX
MOV R15,RSI
MOV R14,RDI
TEST RSI,RSI
JZ 0x0010401d
LAB_00103f65:
LEA RAX,[RBX + -0x1]
MOV RCX,RBX
XOR RCX,RAX
CMP RCX,RAX
JBE 0x0010404c
MOV RSI,qword ptr [R14]
MOV RDI,R14
MOV RDX,R15
MOV RCX,RBX
CALL 0x0010408a
TEST RAX,RAX
JNZ 0x00104013
LEA RAX,[RBX + R15*0x1]
DEC RAX
JZ 0x0010406b
MOV R12,qword ptr [R14]
MOV R13,qword ptr [R12 + 0x8]
ADD R13,R13
CMP R13,RAX
CMOVBE R13,RAX
LEA RDI,[R13 + 0x18]
CALL 0x001010d0
TEST RAX,RAX
JZ 0x00103fd5
XOR ECX,ECX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],R13
MOV qword ptr [RAX + 0x10],RCX
MOV qword ptr [R12],RAX
MOV qword ptr [R14],RAX
JMP 0x00103fd7
LAB_00103fd5:
XOR EAX,EAX
LAB_00103fd7:
TEST RAX,RAX
JZ 0x00104011
MOV RDI,R14
MOV RSI,RAX
MOV RDX,R15
MOV RCX,RBX
CALL 0x0010408a
TEST RAX,RAX
JNZ 0x00104013
LEA RDI,[0x10886a]
LEA RSI,[0x108774]
LEA RCX,[0x1087c6]
MOV EDX,0xa5
CALL 0x00101090
LAB_00104011:
XOR EAX,EAX
LAB_00104013:
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010401d:
CALL 0x00101110
MOV R15D,0x1
JMP 0x00103f65
LAB_0010402d:
LEA RDI,[0x107028]
LEA RSI,[0x108774]
LEA RCX,[0x1087c6]
MOV EDX,0x8b
CALL 0x00101090
LAB_0010404c:
LEA RDI,[0x108836]
LEA RSI,[0x108774]
LEA RCX,[0x1087c6]
MOV EDX,0x98
CALL 0x00101090
LAB_0010406b:
LEA RDI,[0x108981]
LEA RSI,[0x108774]
LEA RCX,[0x108959]
MOV EDX,0x6f
CALL 0x00101090
|
long arena_alloc_aligned(int8 *param_1,long param_2,ulong param_3)
{
int8 *puVar1;
long lVar2;
ulong uVar3;
int8 *puVar4;
ulong uVar5;
if (param_1 == (int8 *)0x0) {
/* WARNING: Subroutine does not return */
__assert_fail("arena != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/memory/arena.c"
,0x8b,"void *arena_alloc_aligned(Arena *, size_t, size_t)");
}
if (param_2 == 0) {
arena_alloc_aligned_cold_1();
param_2 = 1;
}
if (param_3 - 1 < (param_3 ^ param_3 - 1)) {
lVar2 = arena_alloc_from_block(param_1,*param_1,param_2);
if (lVar2 == 0) {
uVar3 = (param_3 + param_2) - 1;
if (uVar3 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("min_size > 0",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/memory/arena.c"
,0x6f,"Block *arena_add_block(Arena *, size_t)");
}
puVar1 = (int8 *)*param_1;
uVar5 = puVar1[1] * 2;
if (uVar5 <= uVar3) {
uVar5 = uVar3;
}
puVar4 = (int8 *)malloc(uVar5 + 0x18);
if (puVar4 == (int8 *)0x0) {
puVar4 = (int8 *)0x0;
}
else {
*puVar4 = 0;
puVar4[1] = uVar5;
puVar4[2] = 0;
*puVar1 = puVar4;
*param_1 = puVar4;
}
if (puVar4 == (int8 *)0x0) {
lVar2 = 0;
}
else {
lVar2 = arena_alloc_from_block(param_1,puVar4,param_2,param_3);
if (lVar2 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("result != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/memory/arena.c"
,0xa5,"void *arena_alloc_aligned(Arena *, size_t, size_t)");
}
}
}
return lVar2;
}
/* WARNING: Subroutine does not return */
__assert_fail("alignment > 0 && (alignment & (alignment - 1)) == 0",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/memory/arena.c",
0x98,"void *arena_alloc_aligned(Arena *, size_t, size_t)");
}
| |
25,077 | find_where_to_split_row | eloqsql/storage/maria/ma_bitmap.c | static uint find_where_to_split_row(MARIA_SHARE *share, MARIA_ROW *row,
uint extents, uint split_size)
{
uint *lengths, *lengths_end;
/*
Ensure we have the minimum required space on head page:
- Header + length of field lengths (row->min_length)
- Number of extents
- One extent
*/
uint row_length= (row->min_length +
size_to_store_key_length(extents) +
ROW_EXTENT_SIZE);
DBUG_ASSERT(row_length <= split_size);
/*
Store first in all_field_lengths the different parts that are written
to the row. This needs to be in same order as in
ma_block_rec.c::write_block_record()
*/
row->null_field_lengths[-3]= extents * ROW_EXTENT_SIZE;
row->null_field_lengths[-2]= share->base.fixed_not_null_fields_length;
row->null_field_lengths[-1]= row->field_lengths_length;
for (lengths= row->null_field_lengths - EXTRA_LENGTH_FIELDS,
lengths_end= (lengths + share->base.fields - share->base.blobs +
EXTRA_LENGTH_FIELDS); lengths < lengths_end; lengths++)
{
if (row_length + *lengths > split_size)
break;
row_length+= *lengths;
}
return row_length;
} | O0 | c | find_where_to_split_row:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movl -0x14(%rbp), %esi
movl $0x3, %ecx
movl $0x1, %edx
cmpl $0xff, %esi
cmovbl %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x7, %rax
movl %eax, -0x2c(%rbp)
jmp 0x5f9ef
imull $0x7, -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movl %ecx, -0xc(%rax)
movq -0x8(%rbp), %rax
movl 0x3d0(%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movl %ecx, -0x8(%rax)
movq -0x10(%rbp), %rax
movl 0xa8(%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movl %ecx, -0x4(%rax)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
addq $-0xc, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x3c8(%rcx), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movl 0x3f0(%rcx), %ecx
movl %ecx, %edx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
addq $0xc, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x5faa1
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
addl (%rcx), %eax
cmpl -0x18(%rbp), %eax
jbe 0x5fa87
jmp 0x5faa1
movq -0x20(%rbp), %rax
movl (%rax), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x5fa6d
movl -0x2c(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| find_where_to_split_row:
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_10]
mov rax, [rax+68h]
mov esi, [rbp+var_14]
mov ecx, 3
mov edx, 1
cmp esi, 0FFh
cmovb ecx, edx
movsxd rcx, ecx
add rax, rcx
add rax, 7
mov [rbp+var_2C], eax
jmp short $+2
loc_5F9EF:
imul ecx, [rbp+var_14], 7
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov [rax-0Ch], ecx
mov rax, [rbp+var_8]
mov ecx, [rax+3D0h]
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov [rax-8], ecx
mov rax, [rbp+var_10]
mov ecx, [rax+0A8h]
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov [rax-4], ecx
mov rax, [rbp+var_10]
mov rax, [rax+58h]
add rax, 0FFFFFFFFFFFFFFF4h
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_8]
mov ecx, [rcx+3C8h]
shl rcx, 2
add rax, rcx
mov rcx, [rbp+var_8]
mov ecx, [rcx+3F0h]
mov edx, ecx
xor ecx, ecx
sub rcx, rdx
shl rcx, 2
add rax, rcx
add rax, 0Ch
mov [rbp+var_28], rax
loc_5FA6D:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jnb short loc_5FAA1
mov eax, [rbp+var_2C]
mov rcx, [rbp+var_20]
add eax, [rcx]
cmp eax, [rbp+var_18]
jbe short loc_5FA87
jmp short loc_5FAA1
loc_5FA87:
mov rax, [rbp+var_20]
mov eax, [rax]
add eax, [rbp+var_2C]
mov [rbp+var_2C], eax
mov rax, [rbp+var_20]
add rax, 4
mov [rbp+var_20], rax
jmp short loc_5FA6D
loc_5FAA1:
mov eax, [rbp+var_2C]
pop rbp
retn
| long long find_where_to_split_row(unsigned int *a1, long long a2, unsigned int a3, unsigned int a4)
{
int v4; // ecx
unsigned int v6; // [rsp+0h] [rbp-2Ch]
_DWORD *i; // [rsp+Ch] [rbp-20h]
v4 = 3;
if ( a3 < 0xFF )
v4 = 1;
v6 = v4 + *(_QWORD *)(a2 + 104) + 7;
*(_DWORD *)(*(_QWORD *)(a2 + 88) - 12LL) = 7 * a3;
*(_DWORD *)(*(_QWORD *)(a2 + 88) - 8LL) = a1[244];
*(_DWORD *)(*(_QWORD *)(a2 + 88) - 4LL) = *(_DWORD *)(a2 + 168);
for ( i = (_DWORD *)(*(_QWORD *)(a2 + 88) - 12LL);
(unsigned long long)i < -4LL * a1[252] + 4 * (unsigned long long)a1[242] + *(_QWORD *)(a2 + 88) && *i + v6 <= a4;
++i )
{
v6 += *i;
}
return v6;
}
| find_where_to_split_row:
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 + -0x10]
MOV RAX,qword ptr [RAX + 0x68]
MOV ESI,dword ptr [RBP + -0x14]
MOV ECX,0x3
MOV EDX,0x1
CMP ESI,0xff
CMOVC ECX,EDX
MOVSXD RCX,ECX
ADD RAX,RCX
ADD RAX,0x7
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x0015f9ef
LAB_0015f9ef:
IMUL ECX,dword ptr [RBP + -0x14],0x7
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOV dword ptr [RAX + -0xc],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x3d0]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOV dword ptr [RAX + -0x8],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0xa8]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOV dword ptr [RAX + -0x4],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
ADD RAX,-0xc
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x3c8]
SHL RCX,0x2
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x3f0]
MOV EDX,ECX
XOR ECX,ECX
SUB RCX,RDX
SHL RCX,0x2
ADD RAX,RCX
ADD RAX,0xc
MOV qword ptr [RBP + -0x28],RAX
LAB_0015fa6d:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JNC 0x0015faa1
MOV EAX,dword ptr [RBP + -0x2c]
MOV RCX,qword ptr [RBP + -0x20]
ADD EAX,dword ptr [RCX]
CMP EAX,dword ptr [RBP + -0x18]
JBE 0x0015fa87
JMP 0x0015faa1
LAB_0015fa87:
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX]
ADD EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x4
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0015fa6d
LAB_0015faa1:
MOV EAX,dword ptr [RBP + -0x2c]
POP RBP
RET
|
int find_where_to_split_row(long param_1,long param_2,uint param_3,uint param_4)
{
int8 uVar1;
int *piVar2;
int iVar3;
int local_34;
int *local_28;
uVar1 = *(int8 *)(param_2 + 0x68);
iVar3 = 3;
if (param_3 < 0xff) {
iVar3 = 1;
}
*(uint *)(*(long *)(param_2 + 0x58) + -0xc) = param_3 * 7;
*(int4 *)(*(long *)(param_2 + 0x58) + -8) = *(int4 *)(param_1 + 0x3d0);
*(int4 *)(*(long *)(param_2 + 0x58) + -4) = *(int4 *)(param_2 + 0xa8);
local_28 = (int *)(*(long *)(param_2 + 0x58) + -0xc);
piVar2 = local_28 + (ulong)*(uint *)(param_1 + 0x3c8) + (3 - (ulong)*(uint *)(param_1 + 0x3f0));
for (local_34 = (int)uVar1 + iVar3 + 7;
(local_28 < piVar2 && ((uint)(local_34 + *local_28) <= param_4)); local_34 = iVar3 + local_34)
{
iVar3 = *local_28;
local_28 = local_28 + 1;
}
return local_34;
}
| |
25,078 | js_free_module_def | bluesky950520[P]quickjs/quickjs.c | static void js_free_module_def(JSContext *ctx, JSModuleDef *m)
{
int i;
JS_FreeAtom(ctx, m->module_name);
for(i = 0; i < m->req_module_entries_count; i++) {
JSReqModuleEntry *rme = &m->req_module_entries[i];
JS_FreeAtom(ctx, rme->module_name);
}
js_free(ctx, m->req_module_entries);
for(i = 0; i < m->export_entries_count; i++) {
JSExportEntry *me = &m->export_entries[i];
if (me->export_type == JS_EXPORT_TYPE_LOCAL)
free_var_ref(ctx->rt, me->u.local.var_ref);
JS_FreeAtom(ctx, me->export_name);
JS_FreeAtom(ctx, me->local_name);
}
js_free(ctx, m->export_entries);
js_free(ctx, m->star_export_entries);
for(i = 0; i < m->import_entries_count; i++) {
JSImportEntry *mi = &m->import_entries[i];
JS_FreeAtom(ctx, mi->import_name);
}
js_free(ctx, m->import_entries);
js_free(ctx, m->async_parent_modules);
JS_FreeValue(ctx, m->module_ns);
JS_FreeValue(ctx, m->func_obj);
JS_FreeValue(ctx, m->eval_exception);
JS_FreeValue(ctx, m->meta_obj);
JS_FreeValue(ctx, m->promise);
JS_FreeValue(ctx, m->resolving_funcs[0]);
JS_FreeValue(ctx, m->resolving_funcs[1]);
list_del(&m->link);
js_free(ctx, m);
} | O1 | c | js_free_module_def:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rsi), %esi
callq 0x1fbc4
cmpl $0x0, 0x20(%rbx)
jle 0x3aacf
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x18(%rbx), %rax
movl (%rax,%r15), %esi
movq %r14, %rdi
callq 0x1fbc4
incq %r12
movslq 0x20(%rbx), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x3aaaf
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x1bf85
cmpl $0x0, 0x30(%rbx)
jle 0x3ab2e
movl $0x18, %r15d
xorl %r12d, %r12d
movq 0x28(%rbx), %r13
cmpl $0x0, -0x8(%r13,%r15)
jne 0x3ab04
movq 0x18(%r14), %rdi
movq -0x10(%r13,%r15), %rsi
callq 0x257d8
movl (%r13,%r15), %esi
movq %r14, %rdi
callq 0x1fbc4
movl -0x4(%r13,%r15), %esi
movq %r14, %rdi
callq 0x1fbc4
incq %r12
movslq 0x30(%rbx), %rax
addq $0x20, %r15
cmpq %rax, %r12
jl 0x3aaea
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x1bf85
movq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0x1bf85
cmpl $0x0, 0x50(%rbx)
jle 0x3ab75
movl $0x4, %r15d
xorl %r12d, %r12d
movq 0x48(%rbx), %rax
movl (%rax,%r15), %esi
movq %r14, %rdi
callq 0x1fbc4
incq %r12
movslq 0x50(%rbx), %rax
addq $0xc, %r15
cmpq %rax, %r12
jl 0x3ab55
movq 0x48(%rbx), %rsi
movq %r14, %rdi
callq 0x1bf85
movq 0x98(%rbx), %rsi
movq %r14, %rdi
callq 0x1bf85
movq 0x58(%rbx), %rsi
movq 0x60(%rbx), %rdx
movq 0x18(%r14), %rdi
callq 0x1ccb2
movq 0x68(%rbx), %rsi
movq 0x70(%rbx), %rdx
movq 0x18(%r14), %rdi
callq 0x1ccb2
movq 0xf8(%rbx), %rsi
movq 0x100(%rbx), %rdx
movq 0x18(%r14), %rdi
callq 0x1ccb2
movq 0x108(%rbx), %rsi
movq 0x110(%rbx), %rdx
movq 0x18(%r14), %rdi
callq 0x1ccb2
movq 0xc0(%rbx), %rsi
movq 0xc8(%rbx), %rdx
movq 0x18(%r14), %rdi
callq 0x1ccb2
movq 0xd0(%rbx), %rsi
movq 0xd8(%rbx), %rdx
movq 0x18(%r14), %rdi
callq 0x1ccb2
movq 0xe0(%rbx), %rsi
movq 0xe8(%rbx), %rdx
movq 0x18(%r14), %rdi
callq 0x1ccb2
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1bf85
| js_free_module_def:
push r15
push r14
push r13
push r12
push rbx
mov rbx, rsi
mov r14, rdi
mov esi, [rsi+4]
call JS_FreeAtom
cmp dword ptr [rbx+20h], 0
jle short loc_3AACF
xor r15d, r15d
xor r12d, r12d
loc_3AAAF:
mov rax, [rbx+18h]
mov esi, [rax+r15]
mov rdi, r14
call JS_FreeAtom
inc r12
movsxd rax, dword ptr [rbx+20h]
add r15, 10h
cmp r12, rax
jl short loc_3AAAF
loc_3AACF:
mov rsi, [rbx+18h]
mov rdi, r14
call js_free
cmp dword ptr [rbx+30h], 0
jle short loc_3AB2E
mov r15d, 18h
xor r12d, r12d
loc_3AAEA:
mov r13, [rbx+28h]
cmp dword ptr [r13+r15-8], 0
jnz short loc_3AB04
mov rdi, [r14+18h]
mov rsi, [r13+r15-10h]
call free_var_ref
loc_3AB04:
mov esi, [r13+r15+0]
mov rdi, r14
call JS_FreeAtom
mov esi, [r13+r15-4]
mov rdi, r14
call JS_FreeAtom
inc r12
movsxd rax, dword ptr [rbx+30h]
add r15, 20h ; ' '
cmp r12, rax
jl short loc_3AAEA
loc_3AB2E:
mov rsi, [rbx+28h]
mov rdi, r14
call js_free
mov rsi, [rbx+38h]
mov rdi, r14
call js_free
cmp dword ptr [rbx+50h], 0
jle short loc_3AB75
mov r15d, 4
xor r12d, r12d
loc_3AB55:
mov rax, [rbx+48h]
mov esi, [rax+r15]
mov rdi, r14
call JS_FreeAtom
inc r12
movsxd rax, dword ptr [rbx+50h]
add r15, 0Ch
cmp r12, rax
jl short loc_3AB55
loc_3AB75:
mov rsi, [rbx+48h]
mov rdi, r14
call js_free
mov rsi, [rbx+98h]
mov rdi, r14
call js_free
mov rsi, [rbx+58h]
mov rdx, [rbx+60h]
mov rdi, [r14+18h]
call JS_FreeValueRT
mov rsi, [rbx+68h]
mov rdx, [rbx+70h]
mov rdi, [r14+18h]
call JS_FreeValueRT
mov rsi, [rbx+0F8h]
mov rdx, [rbx+100h]
mov rdi, [r14+18h]
call JS_FreeValueRT
mov rsi, [rbx+108h]
mov rdx, [rbx+110h]
mov rdi, [r14+18h]
call JS_FreeValueRT
mov rsi, [rbx+0C0h]
mov rdx, [rbx+0C8h]
mov rdi, [r14+18h]
call JS_FreeValueRT
mov rsi, [rbx+0D0h]
mov rdx, [rbx+0D8h]
mov rdi, [r14+18h]
call JS_FreeValueRT
mov rsi, [rbx+0E0h]
mov rdx, [rbx+0E8h]
mov rdi, [r14+18h]
call JS_FreeValueRT
mov rax, [rbx+8]
mov rcx, [rbx+10h]
mov [rax+8], rcx
mov [rcx], rax
xorps xmm0, xmm0
movups xmmword ptr [rbx+8], xmm0
mov rdi, r14
mov rsi, rbx
pop rbx
pop r12
pop r13
pop r14
pop r15
jmp js_free
| long long js_free_module_def(long long a1, long long a2)
{
long long v2; // r15
long long v3; // r12
long long v4; // r15
long long v5; // r12
long long v6; // r13
long long v7; // r15
long long v8; // r12
long long v9; // rax
_QWORD *v10; // rcx
JS_FreeAtom(a1, *(_DWORD *)(a2 + 4));
if ( *(int *)(a2 + 32) > 0 )
{
v2 = 0LL;
v3 = 0LL;
do
{
JS_FreeAtom(a1, *(_DWORD *)(*(_QWORD *)(a2 + 24) + v2));
++v3;
v2 += 16LL;
}
while ( v3 < *(int *)(a2 + 32) );
}
js_free(a1, *(_QWORD *)(a2 + 24));
if ( *(int *)(a2 + 48) > 0 )
{
v4 = 24LL;
v5 = 0LL;
do
{
v6 = *(_QWORD *)(a2 + 40);
if ( !*(_DWORD *)(v6 + v4 - 8) )
free_var_ref(*(_QWORD *)(a1 + 24), *(_QWORD *)(v6 + v4 - 16));
JS_FreeAtom(a1, *(_DWORD *)(v6 + v4));
JS_FreeAtom(a1, *(_DWORD *)(v6 + v4 - 4));
++v5;
v4 += 32LL;
}
while ( v5 < *(int *)(a2 + 48) );
}
js_free(a1, *(_QWORD *)(a2 + 40));
js_free(a1, *(_QWORD *)(a2 + 56));
if ( *(int *)(a2 + 80) > 0 )
{
v7 = 4LL;
v8 = 0LL;
do
{
JS_FreeAtom(a1, *(_DWORD *)(*(_QWORD *)(a2 + 72) + v7));
++v8;
v7 += 12LL;
}
while ( v8 < *(int *)(a2 + 80) );
}
js_free(a1, *(_QWORD *)(a2 + 72));
js_free(a1, *(_QWORD *)(a2 + 152));
JS_FreeValueRT(*(_QWORD *)(a1 + 24), *(_DWORD **)(a2 + 88), *(_QWORD *)(a2 + 96));
JS_FreeValueRT(*(_QWORD *)(a1 + 24), *(_DWORD **)(a2 + 104), *(_QWORD *)(a2 + 112));
JS_FreeValueRT(*(_QWORD *)(a1 + 24), *(_DWORD **)(a2 + 248), *(_QWORD *)(a2 + 256));
JS_FreeValueRT(*(_QWORD *)(a1 + 24), *(_DWORD **)(a2 + 264), *(_QWORD *)(a2 + 272));
JS_FreeValueRT(*(_QWORD *)(a1 + 24), *(_DWORD **)(a2 + 192), *(_QWORD *)(a2 + 200));
JS_FreeValueRT(*(_QWORD *)(a1 + 24), *(_DWORD **)(a2 + 208), *(_QWORD *)(a2 + 216));
JS_FreeValueRT(*(_QWORD *)(a1 + 24), *(_DWORD **)(a2 + 224), *(_QWORD *)(a2 + 232));
v9 = *(_QWORD *)(a2 + 8);
v10 = *(_QWORD **)(a2 + 16);
*(_QWORD *)(v9 + 8) = v10;
*v10 = v9;
*(_OWORD *)(a2 + 8) = 0LL;
return js_free(a1, a2);
}
| js_free_module_def:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
MOV ESI,dword ptr [RSI + 0x4]
CALL 0x0011fbc4
CMP dword ptr [RBX + 0x20],0x0
JLE 0x0013aacf
XOR R15D,R15D
XOR R12D,R12D
LAB_0013aaaf:
MOV RAX,qword ptr [RBX + 0x18]
MOV ESI,dword ptr [RAX + R15*0x1]
MOV RDI,R14
CALL 0x0011fbc4
INC R12
MOVSXD RAX,dword ptr [RBX + 0x20]
ADD R15,0x10
CMP R12,RAX
JL 0x0013aaaf
LAB_0013aacf:
MOV RSI,qword ptr [RBX + 0x18]
MOV RDI,R14
CALL 0x0011bf85
CMP dword ptr [RBX + 0x30],0x0
JLE 0x0013ab2e
MOV R15D,0x18
XOR R12D,R12D
LAB_0013aaea:
MOV R13,qword ptr [RBX + 0x28]
CMP dword ptr [R13 + R15*0x1 + -0x8],0x0
JNZ 0x0013ab04
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,qword ptr [R13 + R15*0x1 + -0x10]
CALL 0x001257d8
LAB_0013ab04:
MOV ESI,dword ptr [R13 + R15*0x1]
MOV RDI,R14
CALL 0x0011fbc4
MOV ESI,dword ptr [R13 + R15*0x1 + -0x4]
MOV RDI,R14
CALL 0x0011fbc4
INC R12
MOVSXD RAX,dword ptr [RBX + 0x30]
ADD R15,0x20
CMP R12,RAX
JL 0x0013aaea
LAB_0013ab2e:
MOV RSI,qword ptr [RBX + 0x28]
MOV RDI,R14
CALL 0x0011bf85
MOV RSI,qword ptr [RBX + 0x38]
MOV RDI,R14
CALL 0x0011bf85
CMP dword ptr [RBX + 0x50],0x0
JLE 0x0013ab75
MOV R15D,0x4
XOR R12D,R12D
LAB_0013ab55:
MOV RAX,qword ptr [RBX + 0x48]
MOV ESI,dword ptr [RAX + R15*0x1]
MOV RDI,R14
CALL 0x0011fbc4
INC R12
MOVSXD RAX,dword ptr [RBX + 0x50]
ADD R15,0xc
CMP R12,RAX
JL 0x0013ab55
LAB_0013ab75:
MOV RSI,qword ptr [RBX + 0x48]
MOV RDI,R14
CALL 0x0011bf85
MOV RSI,qword ptr [RBX + 0x98]
MOV RDI,R14
CALL 0x0011bf85
MOV RSI,qword ptr [RBX + 0x58]
MOV RDX,qword ptr [RBX + 0x60]
MOV RDI,qword ptr [R14 + 0x18]
CALL 0x0011ccb2
MOV RSI,qword ptr [RBX + 0x68]
MOV RDX,qword ptr [RBX + 0x70]
MOV RDI,qword ptr [R14 + 0x18]
CALL 0x0011ccb2
MOV RSI,qword ptr [RBX + 0xf8]
MOV RDX,qword ptr [RBX + 0x100]
MOV RDI,qword ptr [R14 + 0x18]
CALL 0x0011ccb2
MOV RSI,qword ptr [RBX + 0x108]
MOV RDX,qword ptr [RBX + 0x110]
MOV RDI,qword ptr [R14 + 0x18]
CALL 0x0011ccb2
MOV RSI,qword ptr [RBX + 0xc0]
MOV RDX,qword ptr [RBX + 0xc8]
MOV RDI,qword ptr [R14 + 0x18]
CALL 0x0011ccb2
MOV RSI,qword ptr [RBX + 0xd0]
MOV RDX,qword ptr [RBX + 0xd8]
MOV RDI,qword ptr [R14 + 0x18]
CALL 0x0011ccb2
MOV RSI,qword ptr [RBX + 0xe0]
MOV RDX,qword ptr [RBX + 0xe8]
MOV RDI,qword ptr [R14 + 0x18]
CALL 0x0011ccb2
MOV RAX,qword ptr [RBX + 0x8]
MOV RCX,qword ptr [RBX + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RCX],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x8],XMM0
MOV RDI,R14
MOV RSI,RBX
POP RBX
POP R12
POP R13
POP R14
POP R15
JMP 0x0011bf85
|
void js_free_module_def(long param_1,long param_2)
{
long lVar1;
long *plVar2;
long lVar3;
long lVar4;
JS_FreeAtom(param_1,*(int4 *)(param_2 + 4));
if (0 < *(int *)(param_2 + 0x20)) {
lVar4 = 0;
lVar3 = 0;
do {
JS_FreeAtom(param_1,*(int4 *)(*(long *)(param_2 + 0x18) + lVar4));
lVar3 = lVar3 + 1;
lVar4 = lVar4 + 0x10;
} while (lVar3 < *(int *)(param_2 + 0x20));
}
js_free(param_1,*(int8 *)(param_2 + 0x18));
if (0 < *(int *)(param_2 + 0x30)) {
lVar4 = 0x18;
lVar3 = 0;
do {
lVar1 = *(long *)(param_2 + 0x28);
if (*(int *)(lVar1 + -8 + lVar4) == 0) {
free_var_ref(*(int8 *)(param_1 + 0x18),*(int8 *)(lVar1 + -0x10 + lVar4));
}
JS_FreeAtom(param_1,*(int4 *)(lVar1 + lVar4));
JS_FreeAtom(param_1,*(int4 *)(lVar1 + -4 + lVar4));
lVar3 = lVar3 + 1;
lVar4 = lVar4 + 0x20;
} while (lVar3 < *(int *)(param_2 + 0x30));
}
js_free(param_1,*(int8 *)(param_2 + 0x28));
js_free(param_1,*(int8 *)(param_2 + 0x38));
if (0 < *(int *)(param_2 + 0x50)) {
lVar4 = 4;
lVar3 = 0;
do {
JS_FreeAtom(param_1,*(int4 *)(*(long *)(param_2 + 0x48) + lVar4));
lVar3 = lVar3 + 1;
lVar4 = lVar4 + 0xc;
} while (lVar3 < *(int *)(param_2 + 0x50));
}
js_free(param_1,*(int8 *)(param_2 + 0x48));
js_free(param_1,*(int8 *)(param_2 + 0x98));
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),*(int8 *)(param_2 + 0x58),
*(int8 *)(param_2 + 0x60));
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),*(int8 *)(param_2 + 0x68),
*(int8 *)(param_2 + 0x70));
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),*(int8 *)(param_2 + 0xf8),
*(int8 *)(param_2 + 0x100));
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),*(int8 *)(param_2 + 0x108),
*(int8 *)(param_2 + 0x110));
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),*(int8 *)(param_2 + 0xc0),
*(int8 *)(param_2 + 200));
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),*(int8 *)(param_2 + 0xd0),
*(int8 *)(param_2 + 0xd8));
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),*(int8 *)(param_2 + 0xe0),
*(int8 *)(param_2 + 0xe8));
lVar3 = *(long *)(param_2 + 8);
plVar2 = *(long **)(param_2 + 0x10);
*(long **)(lVar3 + 8) = plVar2;
*plVar2 = lVar3;
*(int8 *)(param_2 + 8) = 0;
*(int8 *)(param_2 + 0x10) = 0;
js_free(param_1,param_2);
return;
}
| |
25,079 | js_free_module_def | bluesky950520[P]quickjs/quickjs.c | static void js_free_module_def(JSContext *ctx, JSModuleDef *m)
{
int i;
JS_FreeAtom(ctx, m->module_name);
for(i = 0; i < m->req_module_entries_count; i++) {
JSReqModuleEntry *rme = &m->req_module_entries[i];
JS_FreeAtom(ctx, rme->module_name);
}
js_free(ctx, m->req_module_entries);
for(i = 0; i < m->export_entries_count; i++) {
JSExportEntry *me = &m->export_entries[i];
if (me->export_type == JS_EXPORT_TYPE_LOCAL)
free_var_ref(ctx->rt, me->u.local.var_ref);
JS_FreeAtom(ctx, me->export_name);
JS_FreeAtom(ctx, me->local_name);
}
js_free(ctx, m->export_entries);
js_free(ctx, m->star_export_entries);
for(i = 0; i < m->import_entries_count; i++) {
JSImportEntry *mi = &m->import_entries[i];
JS_FreeAtom(ctx, mi->import_name);
}
js_free(ctx, m->import_entries);
js_free(ctx, m->async_parent_modules);
JS_FreeValue(ctx, m->module_ns);
JS_FreeValue(ctx, m->func_obj);
JS_FreeValue(ctx, m->eval_exception);
JS_FreeValue(ctx, m->meta_obj);
JS_FreeValue(ctx, m->promise);
JS_FreeValue(ctx, m->resolving_funcs[0]);
JS_FreeValue(ctx, m->resolving_funcs[1]);
list_del(&m->link);
js_free(ctx, m);
} | O3 | c | js_free_module_def:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rsi), %esi
callq 0x202f5
cmpl $0x0, 0x20(%rbx)
jle 0x3c0be
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x18(%rbx), %rax
movl (%rax,%r15), %esi
movq %r14, %rdi
callq 0x202f5
incq %r12
movslq 0x20(%rbx), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x3c09e
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x1c845
cmpl $0x0, 0x30(%rbx)
jle 0x3c11d
movl $0x18, %r15d
xorl %r12d, %r12d
movq 0x28(%rbx), %r13
cmpl $0x0, -0x8(%r13,%r15)
jne 0x3c0f3
movq 0x18(%r14), %rdi
movq -0x10(%r13,%r15), %rsi
callq 0x25e23
movl (%r13,%r15), %esi
movq %r14, %rdi
callq 0x202f5
movl -0x4(%r13,%r15), %esi
movq %r14, %rdi
callq 0x202f5
incq %r12
movslq 0x30(%rbx), %rax
addq $0x20, %r15
cmpq %rax, %r12
jl 0x3c0d9
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x1c845
movq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0x1c845
cmpl $0x0, 0x50(%rbx)
jle 0x3c164
movl $0x4, %r15d
xorl %r12d, %r12d
movq 0x48(%rbx), %rax
movl (%rax,%r15), %esi
movq %r14, %rdi
callq 0x202f5
incq %r12
movslq 0x50(%rbx), %rax
addq $0xc, %r15
cmpq %rax, %r12
jl 0x3c144
movq 0x48(%rbx), %rsi
movq %r14, %rdi
callq 0x1c845
movq 0x98(%rbx), %rsi
movq %r14, %rdi
callq 0x1c845
movq 0x60(%rbx), %rdx
movq 0x18(%r14), %rdi
cmpl $-0x9, %edx
jb 0x3c1a5
movq 0x58(%rbx), %rsi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x3c1a5
callq 0x20d90
movq 0x18(%r14), %rdi
movq 0x70(%rbx), %rdx
cmpl $-0x9, %edx
jb 0x3c1c7
movq 0x68(%rbx), %rsi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x3c1c7
callq 0x20d90
movq 0x18(%r14), %rdi
movq 0x100(%rbx), %rdx
cmpl $-0x9, %edx
jb 0x3c1ef
movq 0xf8(%rbx), %rsi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x3c1ef
callq 0x20d90
movq 0x18(%r14), %rdi
movq 0x110(%rbx), %rdx
cmpl $-0x9, %edx
jb 0x3c217
movq 0x108(%rbx), %rsi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x3c217
callq 0x20d90
movq 0x18(%r14), %rdi
movq 0xc8(%rbx), %rdx
cmpl $-0x9, %edx
jb 0x3c23f
movq 0xc0(%rbx), %rsi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x3c23f
callq 0x20d90
movq 0x18(%r14), %rdi
movq 0xd8(%rbx), %rdx
cmpl $-0x9, %edx
jb 0x3c267
movq 0xd0(%rbx), %rsi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x3c267
callq 0x20d90
movq 0x18(%r14), %rdi
movq 0xe8(%rbx), %rdx
cmpl $-0x9, %edx
jb 0x3c28b
movq 0xe0(%rbx), %rsi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x3c28b
callq 0x20d90
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq 0x18(%r14), %r14
decq 0x28(%r14)
movq %rbx, %rdi
callq *0x20(%r14)
movq 0x10(%r14), %rcx
movq 0x30(%r14), %rdx
subq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x30(%r14)
movq 0x40(%r14), %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rcx
| js_free_module_def:
push r15
push r14
push r13
push r12
push rbx
mov rbx, rsi
mov r14, rdi
mov esi, [rsi+4]
call JS_FreeAtom
cmp dword ptr [rbx+20h], 0
jle short loc_3C0BE
xor r15d, r15d
xor r12d, r12d
loc_3C09E:
mov rax, [rbx+18h]
mov esi, [rax+r15]
mov rdi, r14
call JS_FreeAtom
inc r12
movsxd rax, dword ptr [rbx+20h]
add r15, 10h
cmp r12, rax
jl short loc_3C09E
loc_3C0BE:
mov rsi, [rbx+18h]
mov rdi, r14
call js_free
cmp dword ptr [rbx+30h], 0
jle short loc_3C11D
mov r15d, 18h
xor r12d, r12d
loc_3C0D9:
mov r13, [rbx+28h]
cmp dword ptr [r13+r15-8], 0
jnz short loc_3C0F3
mov rdi, [r14+18h]
mov rsi, [r13+r15-10h]
call free_var_ref
loc_3C0F3:
mov esi, [r13+r15+0]
mov rdi, r14
call JS_FreeAtom
mov esi, [r13+r15-4]
mov rdi, r14
call JS_FreeAtom
inc r12
movsxd rax, dword ptr [rbx+30h]
add r15, 20h ; ' '
cmp r12, rax
jl short loc_3C0D9
loc_3C11D:
mov rsi, [rbx+28h]
mov rdi, r14
call js_free
mov rsi, [rbx+38h]
mov rdi, r14
call js_free
cmp dword ptr [rbx+50h], 0
jle short loc_3C164
mov r15d, 4
xor r12d, r12d
loc_3C144:
mov rax, [rbx+48h]
mov esi, [rax+r15]
mov rdi, r14
call JS_FreeAtom
inc r12
movsxd rax, dword ptr [rbx+50h]
add r15, 0Ch
cmp r12, rax
jl short loc_3C144
loc_3C164:
mov rsi, [rbx+48h]
mov rdi, r14
call js_free
mov rsi, [rbx+98h]
mov rdi, r14
call js_free
mov rdx, [rbx+60h]
mov rdi, [r14+18h]
cmp edx, 0FFFFFFF7h
jb short loc_3C1A5
mov rsi, [rbx+58h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_3C1A5
call js_free_value_rt
mov rdi, [r14+18h]
loc_3C1A5:
mov rdx, [rbx+70h]
cmp edx, 0FFFFFFF7h
jb short loc_3C1C7
mov rsi, [rbx+68h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_3C1C7
call js_free_value_rt
mov rdi, [r14+18h]
loc_3C1C7:
mov rdx, [rbx+100h]
cmp edx, 0FFFFFFF7h
jb short loc_3C1EF
mov rsi, [rbx+0F8h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_3C1EF
call js_free_value_rt
mov rdi, [r14+18h]
loc_3C1EF:
mov rdx, [rbx+110h]
cmp edx, 0FFFFFFF7h
jb short loc_3C217
mov rsi, [rbx+108h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_3C217
call js_free_value_rt
mov rdi, [r14+18h]
loc_3C217:
mov rdx, [rbx+0C8h]
cmp edx, 0FFFFFFF7h
jb short loc_3C23F
mov rsi, [rbx+0C0h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_3C23F
call js_free_value_rt
mov rdi, [r14+18h]
loc_3C23F:
mov rdx, [rbx+0D8h]
cmp edx, 0FFFFFFF7h
jb short loc_3C267
mov rsi, [rbx+0D0h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_3C267
call js_free_value_rt
mov rdi, [r14+18h]
loc_3C267:
mov rdx, [rbx+0E8h]
cmp edx, 0FFFFFFF7h
jb short loc_3C28B
mov rsi, [rbx+0E0h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_3C28B
call js_free_value_rt
loc_3C28B:
mov rax, [rbx+8]
mov rcx, [rbx+10h]
mov [rax+8], rcx
mov [rcx], rax
xorps xmm0, xmm0
movups xmmword ptr [rbx+8], xmm0
mov r14, [r14+18h]
dec qword ptr [r14+28h]
mov rdi, rbx
call qword ptr [r14+20h]
mov rcx, [r14+10h]
mov rdx, [r14+30h]
sub rdx, rax
add rdx, 0FFFFFFFFFFFFFFF8h
mov [r14+30h], rdx
mov rdi, [r14+40h]
mov rsi, rbx
pop rbx
pop r12
pop r13
pop r14
pop r15
jmp rcx
| long long js_free_module_def(long long a1, long long a2)
{
long long v4; // r15
long long v5; // r12
long long v6; // rdx
long long v7; // rcx
long long v8; // r8
long long v9; // r9
long long v10; // r15
long long v11; // r12
long long v12; // r13
long long v13; // r15
long long v14; // r12
long long v15; // r8
long long v16; // r9
long long v17; // rdx
long long v18; // rdi
_QWORD *v19; // rsi
int v20; // eax
long long v21; // rcx
long long v22; // rdx
_QWORD *v23; // rsi
int v24; // eax
long long v25; // rcx
long long v26; // rdx
_QWORD *v27; // rsi
int v28; // eax
long long v29; // rcx
long long v30; // rdx
_QWORD *v31; // rsi
int v32; // eax
long long v33; // rcx
long long v34; // rdx
_QWORD *v35; // rsi
int v36; // eax
long long v37; // rcx
long long v38; // rdx
_QWORD *v39; // rsi
int v40; // eax
long long v41; // rcx
long long v42; // rdx
_QWORD *v43; // rsi
int v44; // eax
long long v45; // rcx
long long v46; // rax
_QWORD *v47; // rcx
long long v48; // r14
long long v49; // rax
long long ( *v50)(_QWORD, long long); // rcx
JS_FreeAtom(a1, *(_DWORD *)(a2 + 4));
if ( *(int *)(a2 + 32) > 0 )
{
v4 = 0LL;
v5 = 0LL;
do
{
JS_FreeAtom(a1, *(_DWORD *)(*(_QWORD *)(a2 + 24) + v4));
++v5;
v4 += 16LL;
}
while ( v5 < *(int *)(a2 + 32) );
}
js_free(a1, *(_QWORD *)(a2 + 24));
if ( *(int *)(a2 + 48) > 0 )
{
v10 = 24LL;
v11 = 0LL;
do
{
v12 = *(_QWORD *)(a2 + 40);
if ( !*(_DWORD *)(v12 + v10 - 8) )
free_var_ref(*(_QWORD *)(a1 + 24), *(_QWORD *)(v12 + v10 - 16), v6, v7, v8, v9);
JS_FreeAtom(a1, *(_DWORD *)(v12 + v10));
JS_FreeAtom(a1, *(_DWORD *)(v12 + v10 - 4));
++v11;
v10 += 32LL;
}
while ( v11 < *(int *)(a2 + 48) );
}
js_free(a1, *(_QWORD *)(a2 + 40));
js_free(a1, *(_QWORD *)(a2 + 56));
if ( *(int *)(a2 + 80) > 0 )
{
v13 = 4LL;
v14 = 0LL;
do
{
JS_FreeAtom(a1, *(_DWORD *)(*(_QWORD *)(a2 + 72) + v13));
++v14;
v13 += 12LL;
}
while ( v14 < *(int *)(a2 + 80) );
}
js_free(a1, *(_QWORD *)(a2 + 72));
js_free(a1, *(_QWORD *)(a2 + 152));
v17 = *(_QWORD *)(a2 + 96);
v18 = *(_QWORD *)(a1 + 24);
if ( (unsigned int)v17 >= 0xFFFFFFF7 )
{
v19 = *(_QWORD **)(a2 + 88);
v20 = *(_DWORD *)v19;
v21 = (unsigned int)(*(_DWORD *)v19 - 1);
*(_DWORD *)v19 = v21;
if ( v20 <= 1 )
{
js_free_value_rt(v18, v19, v17, v21, v15, v16);
v18 = *(_QWORD *)(a1 + 24);
}
}
v22 = *(_QWORD *)(a2 + 112);
if ( (unsigned int)v22 >= 0xFFFFFFF7 )
{
v23 = *(_QWORD **)(a2 + 104);
v24 = *(_DWORD *)v23;
v25 = (unsigned int)(*(_DWORD *)v23 - 1);
*(_DWORD *)v23 = v25;
if ( v24 <= 1 )
{
js_free_value_rt(v18, v23, v22, v25, v15, v16);
v18 = *(_QWORD *)(a1 + 24);
}
}
v26 = *(_QWORD *)(a2 + 256);
if ( (unsigned int)v26 >= 0xFFFFFFF7 )
{
v27 = *(_QWORD **)(a2 + 248);
v28 = *(_DWORD *)v27;
v29 = (unsigned int)(*(_DWORD *)v27 - 1);
*(_DWORD *)v27 = v29;
if ( v28 <= 1 )
{
js_free_value_rt(v18, v27, v26, v29, v15, v16);
v18 = *(_QWORD *)(a1 + 24);
}
}
v30 = *(_QWORD *)(a2 + 272);
if ( (unsigned int)v30 >= 0xFFFFFFF7 )
{
v31 = *(_QWORD **)(a2 + 264);
v32 = *(_DWORD *)v31;
v33 = (unsigned int)(*(_DWORD *)v31 - 1);
*(_DWORD *)v31 = v33;
if ( v32 <= 1 )
{
js_free_value_rt(v18, v31, v30, v33, v15, v16);
v18 = *(_QWORD *)(a1 + 24);
}
}
v34 = *(_QWORD *)(a2 + 200);
if ( (unsigned int)v34 >= 0xFFFFFFF7 )
{
v35 = *(_QWORD **)(a2 + 192);
v36 = *(_DWORD *)v35;
v37 = (unsigned int)(*(_DWORD *)v35 - 1);
*(_DWORD *)v35 = v37;
if ( v36 <= 1 )
{
js_free_value_rt(v18, v35, v34, v37, v15, v16);
v18 = *(_QWORD *)(a1 + 24);
}
}
v38 = *(_QWORD *)(a2 + 216);
if ( (unsigned int)v38 >= 0xFFFFFFF7 )
{
v39 = *(_QWORD **)(a2 + 208);
v40 = *(_DWORD *)v39;
v41 = (unsigned int)(*(_DWORD *)v39 - 1);
*(_DWORD *)v39 = v41;
if ( v40 <= 1 )
{
js_free_value_rt(v18, v39, v38, v41, v15, v16);
v18 = *(_QWORD *)(a1 + 24);
}
}
v42 = *(_QWORD *)(a2 + 232);
if ( (unsigned int)v42 >= 0xFFFFFFF7 )
{
v43 = *(_QWORD **)(a2 + 224);
v44 = *(_DWORD *)v43;
v45 = (unsigned int)(*(_DWORD *)v43 - 1);
*(_DWORD *)v43 = v45;
if ( v44 <= 1 )
js_free_value_rt(v18, v43, v42, v45, v15, v16);
}
v46 = *(_QWORD *)(a2 + 8);
v47 = *(_QWORD **)(a2 + 16);
*(_QWORD *)(v46 + 8) = v47;
*v47 = v46;
*(_OWORD *)(a2 + 8) = 0LL;
v48 = *(_QWORD *)(a1 + 24);
--*(_QWORD *)(v48 + 40);
v49 = (*(long long ( **)(long long))(v48 + 32))(a2);
v50 = *(long long ( **)(_QWORD, long long))(v48 + 16);
*(_QWORD *)(v48 + 48) = *(_QWORD *)(v48 + 48) - v49 - 8;
return v50(*(_QWORD *)(v48 + 64), a2);
}
| js_free_module_def:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
MOV ESI,dword ptr [RSI + 0x4]
CALL 0x001202f5
CMP dword ptr [RBX + 0x20],0x0
JLE 0x0013c0be
XOR R15D,R15D
XOR R12D,R12D
LAB_0013c09e:
MOV RAX,qword ptr [RBX + 0x18]
MOV ESI,dword ptr [RAX + R15*0x1]
MOV RDI,R14
CALL 0x001202f5
INC R12
MOVSXD RAX,dword ptr [RBX + 0x20]
ADD R15,0x10
CMP R12,RAX
JL 0x0013c09e
LAB_0013c0be:
MOV RSI,qword ptr [RBX + 0x18]
MOV RDI,R14
CALL 0x0011c845
CMP dword ptr [RBX + 0x30],0x0
JLE 0x0013c11d
MOV R15D,0x18
XOR R12D,R12D
LAB_0013c0d9:
MOV R13,qword ptr [RBX + 0x28]
CMP dword ptr [R13 + R15*0x1 + -0x8],0x0
JNZ 0x0013c0f3
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,qword ptr [R13 + R15*0x1 + -0x10]
CALL 0x00125e23
LAB_0013c0f3:
MOV ESI,dword ptr [R13 + R15*0x1]
MOV RDI,R14
CALL 0x001202f5
MOV ESI,dword ptr [R13 + R15*0x1 + -0x4]
MOV RDI,R14
CALL 0x001202f5
INC R12
MOVSXD RAX,dword ptr [RBX + 0x30]
ADD R15,0x20
CMP R12,RAX
JL 0x0013c0d9
LAB_0013c11d:
MOV RSI,qword ptr [RBX + 0x28]
MOV RDI,R14
CALL 0x0011c845
MOV RSI,qword ptr [RBX + 0x38]
MOV RDI,R14
CALL 0x0011c845
CMP dword ptr [RBX + 0x50],0x0
JLE 0x0013c164
MOV R15D,0x4
XOR R12D,R12D
LAB_0013c144:
MOV RAX,qword ptr [RBX + 0x48]
MOV ESI,dword ptr [RAX + R15*0x1]
MOV RDI,R14
CALL 0x001202f5
INC R12
MOVSXD RAX,dword ptr [RBX + 0x50]
ADD R15,0xc
CMP R12,RAX
JL 0x0013c144
LAB_0013c164:
MOV RSI,qword ptr [RBX + 0x48]
MOV RDI,R14
CALL 0x0011c845
MOV RSI,qword ptr [RBX + 0x98]
MOV RDI,R14
CALL 0x0011c845
MOV RDX,qword ptr [RBX + 0x60]
MOV RDI,qword ptr [R14 + 0x18]
CMP EDX,-0x9
JC 0x0013c1a5
MOV RSI,qword ptr [RBX + 0x58]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x0013c1a5
CALL 0x00120d90
MOV RDI,qword ptr [R14 + 0x18]
LAB_0013c1a5:
MOV RDX,qword ptr [RBX + 0x70]
CMP EDX,-0x9
JC 0x0013c1c7
MOV RSI,qword ptr [RBX + 0x68]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x0013c1c7
CALL 0x00120d90
MOV RDI,qword ptr [R14 + 0x18]
LAB_0013c1c7:
MOV RDX,qword ptr [RBX + 0x100]
CMP EDX,-0x9
JC 0x0013c1ef
MOV RSI,qword ptr [RBX + 0xf8]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x0013c1ef
CALL 0x00120d90
MOV RDI,qword ptr [R14 + 0x18]
LAB_0013c1ef:
MOV RDX,qword ptr [RBX + 0x110]
CMP EDX,-0x9
JC 0x0013c217
MOV RSI,qword ptr [RBX + 0x108]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x0013c217
CALL 0x00120d90
MOV RDI,qword ptr [R14 + 0x18]
LAB_0013c217:
MOV RDX,qword ptr [RBX + 0xc8]
CMP EDX,-0x9
JC 0x0013c23f
MOV RSI,qword ptr [RBX + 0xc0]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x0013c23f
CALL 0x00120d90
MOV RDI,qword ptr [R14 + 0x18]
LAB_0013c23f:
MOV RDX,qword ptr [RBX + 0xd8]
CMP EDX,-0x9
JC 0x0013c267
MOV RSI,qword ptr [RBX + 0xd0]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x0013c267
CALL 0x00120d90
MOV RDI,qword ptr [R14 + 0x18]
LAB_0013c267:
MOV RDX,qword ptr [RBX + 0xe8]
CMP EDX,-0x9
JC 0x0013c28b
MOV RSI,qword ptr [RBX + 0xe0]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x0013c28b
CALL 0x00120d90
LAB_0013c28b:
MOV RAX,qword ptr [RBX + 0x8]
MOV RCX,qword ptr [RBX + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RCX],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x8],XMM0
MOV R14,qword ptr [R14 + 0x18]
DEC qword ptr [R14 + 0x28]
MOV RDI,RBX
CALL qword ptr [R14 + 0x20]
MOV RCX,qword ptr [R14 + 0x10]
MOV RDX,qword ptr [R14 + 0x30]
SUB RDX,RAX
ADD RDX,-0x8
MOV qword ptr [R14 + 0x30],RDX
MOV RDI,qword ptr [R14 + 0x40]
MOV RSI,RBX
POP RBX
POP R12
POP R13
POP R14
POP R15
JMP RCX
|
void js_free_module_def(long param_1,long param_2)
{
int iVar1;
long lVar2;
long *plVar3;
int8 uVar4;
long lVar5;
long lVar6;
JS_FreeAtom(param_1,*(int4 *)(param_2 + 4));
if (0 < *(int *)(param_2 + 0x20)) {
lVar6 = 0;
lVar5 = 0;
do {
JS_FreeAtom(param_1,*(int4 *)(*(long *)(param_2 + 0x18) + lVar6));
lVar5 = lVar5 + 1;
lVar6 = lVar6 + 0x10;
} while (lVar5 < *(int *)(param_2 + 0x20));
}
js_free(param_1,*(int8 *)(param_2 + 0x18));
if (0 < *(int *)(param_2 + 0x30)) {
lVar6 = 0x18;
lVar5 = 0;
do {
lVar2 = *(long *)(param_2 + 0x28);
if (*(int *)(lVar2 + -8 + lVar6) == 0) {
free_var_ref(*(int8 *)(param_1 + 0x18),*(int8 *)(lVar2 + -0x10 + lVar6));
}
JS_FreeAtom(param_1,*(int4 *)(lVar2 + lVar6));
JS_FreeAtom(param_1,*(int4 *)(lVar2 + -4 + lVar6));
lVar5 = lVar5 + 1;
lVar6 = lVar6 + 0x20;
} while (lVar5 < *(int *)(param_2 + 0x30));
}
js_free(param_1,*(int8 *)(param_2 + 0x28));
js_free(param_1,*(int8 *)(param_2 + 0x38));
if (0 < *(int *)(param_2 + 0x50)) {
lVar6 = 4;
lVar5 = 0;
do {
JS_FreeAtom(param_1,*(int4 *)(*(long *)(param_2 + 0x48) + lVar6));
lVar5 = lVar5 + 1;
lVar6 = lVar6 + 0xc;
} while (lVar5 < *(int *)(param_2 + 0x50));
}
js_free(param_1,*(int8 *)(param_2 + 0x48));
js_free(param_1,*(int8 *)(param_2 + 0x98));
uVar4 = *(int8 *)(param_1 + 0x18);
if (0xfffffff6 < (uint)*(int8 *)(param_2 + 0x60)) {
iVar1 = **(int **)(param_2 + 0x58);
**(int **)(param_2 + 0x58) = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(uVar4);
uVar4 = *(int8 *)(param_1 + 0x18);
}
}
if (0xfffffff6 < (uint)*(int8 *)(param_2 + 0x70)) {
iVar1 = **(int **)(param_2 + 0x68);
**(int **)(param_2 + 0x68) = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(uVar4);
uVar4 = *(int8 *)(param_1 + 0x18);
}
}
if (0xfffffff6 < (uint)*(int8 *)(param_2 + 0x100)) {
iVar1 = **(int **)(param_2 + 0xf8);
**(int **)(param_2 + 0xf8) = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(uVar4);
uVar4 = *(int8 *)(param_1 + 0x18);
}
}
if (0xfffffff6 < (uint)*(int8 *)(param_2 + 0x110)) {
iVar1 = **(int **)(param_2 + 0x108);
**(int **)(param_2 + 0x108) = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(uVar4);
uVar4 = *(int8 *)(param_1 + 0x18);
}
}
if (0xfffffff6 < (uint)*(int8 *)(param_2 + 200)) {
iVar1 = **(int **)(param_2 + 0xc0);
**(int **)(param_2 + 0xc0) = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(uVar4);
uVar4 = *(int8 *)(param_1 + 0x18);
}
}
if (0xfffffff6 < (uint)*(int8 *)(param_2 + 0xd8)) {
iVar1 = **(int **)(param_2 + 0xd0);
**(int **)(param_2 + 0xd0) = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(uVar4);
uVar4 = *(int8 *)(param_1 + 0x18);
}
}
if (0xfffffff6 < (uint)*(int8 *)(param_2 + 0xe8)) {
iVar1 = **(int **)(param_2 + 0xe0);
**(int **)(param_2 + 0xe0) = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(uVar4);
}
}
lVar5 = *(long *)(param_2 + 8);
plVar3 = *(long **)(param_2 + 0x10);
*(long **)(lVar5 + 8) = plVar3;
*plVar3 = lVar5;
*(int8 *)(param_2 + 8) = 0;
*(int8 *)(param_2 + 0x10) = 0;
lVar5 = *(long *)(param_1 + 0x18);
*(long *)(lVar5 + 0x28) = *(long *)(lVar5 + 0x28) + -1;
lVar6 = (**(code **)(lVar5 + 0x20))(param_2);
lVar6 = (*(long *)(lVar5 + 0x30) - lVar6) + -8;
*(long *)(lVar5 + 0x30) = lVar6;
/* WARNING: Could not recover jumptable at 0x0013c2d3. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(lVar5 + 0x10))(*(int8 *)(lVar5 + 0x40),param_2,lVar6,*(code **)(lVar5 + 0x10));
return;
}
| |
25,080 | my_numchars_utf16 | eloqsql/strings/ctype-ucs2.c | static size_t
my_numchars_utf16(CHARSET_INFO *cs,
const char *b, const char *e)
{
size_t nchars= 0;
for ( ; ; nchars++)
{
size_t charlen= my_ismbchar(cs, b, e);
if (!charlen)
break;
b+= charlen;
}
return nchars;
} | O3 | c | my_numchars_utf16:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0xb8(%rdi), %rax
callq *0xc0(%rax)
xorl %r12d, %r12d
cmpl $0x2, %eax
jl 0xc2f1e
movl %eax, %eax
addq %rax, %r14
incq %r12
movq 0xb8(%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0xc0(%rax)
cmpl $0x1, %eax
jg 0xc2efb
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| my_numchars_utf16:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rax, [rdi+0B8h]
call qword ptr [rax+0C0h]
xor r12d, r12d
cmp eax, 2
jl short loc_C2F1E
loc_C2EFB:
mov eax, eax
add r14, rax
inc r12
mov rax, [r15+0B8h]
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call qword ptr [rax+0C0h]
cmp eax, 1
jg short loc_C2EFB
loc_C2F1E:
mov rax, r12
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long my_numchars_utf16(long long a1, long long a2, long long a3)
{
int v5; // eax
long long v6; // r12
v5 = (*(long long (**)(void))(*(_QWORD *)(a1 + 184) + 192LL))();
v6 = 0LL;
if ( v5 >= 2 )
{
do
{
a2 += (unsigned int)v5;
++v6;
v5 = (*(long long ( **)(long long, long long, long long))(*(_QWORD *)(a1 + 184) + 192LL))(a1, a2, a3);
}
while ( v5 > 1 );
}
return v6;
}
| my_numchars_utf16:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RAX,qword ptr [RDI + 0xb8]
CALL qword ptr [RAX + 0xc0]
XOR R12D,R12D
CMP EAX,0x2
JL 0x001c2f1e
LAB_001c2efb:
MOV EAX,EAX
ADD R14,RAX
INC R12
MOV RAX,qword ptr [R15 + 0xb8]
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL qword ptr [RAX + 0xc0]
CMP EAX,0x1
JG 0x001c2efb
LAB_001c2f1e:
MOV RAX,R12
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
long my_numchars_utf16(long param_1,long param_2,int8 param_3)
{
uint uVar1;
long lVar2;
uVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))();
lVar2 = 0;
while (1 < (int)uVar1) {
param_2 = param_2 + (ulong)uVar1;
lVar2 = lVar2 + 1;
uVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))(param_1,param_2,param_3);
}
return lVar2;
}
| |
25,081 | ft_boolean_find_relevance | eloqsql/storage/myisam/ft_boolean_search.c | float ft_boolean_find_relevance(FT_INFO *ftb, uchar *record, uint length)
{
FTB_EXPR *ftbe;
FT_SEG_ITERATOR ftsi, ftsi2;
my_off_t docid=ftb->info->lastpos;
MY_FTB_FIND_PARAM ftb_param;
MYSQL_FTPARSER_PARAM *param;
struct st_mysql_ftparser *parser= ftb->keynr == NO_SUCH_KEY ?
&ft_default_parser :
ftb->info->s->keyinfo[ftb->keynr].parser;
if (docid == HA_OFFSET_ERROR)
return -2.0;
if (!ftb->queue.elements)
return 0;
if (! (param= ftparser_call_initializer(ftb->info, ftb->keynr, 0)))
return 0;
if (ftb->state != INDEX_SEARCH && docid <= ftb->lastpos)
{
FTB_EXPR *x;
uint i;
for (i=0; i < ftb->queue.elements; i++)
{
ftb->list[i]->docid[1]=HA_OFFSET_ERROR;
for (x=ftb->list[i]->up; x; x=x->up)
x->docid[1]=HA_OFFSET_ERROR;
}
}
ftb->lastpos=docid;
if (ftb->keynr==NO_SUCH_KEY)
_mi_ft_segiterator_dummy_init(record, length, &ftsi);
else
_mi_ft_segiterator_init(ftb->info, ftb->keynr, record, &ftsi);
memcpy(&ftsi2, &ftsi, sizeof(ftsi));
ftb_param.ftb= ftb;
ftb_param.ftsi= &ftsi2;
param->mysql_parse= ftb_find_relevance_parse;
param->mysql_add_word= ftb_find_relevance_add_word;
param->mysql_ftparam= (void *)&ftb_param;
param->flags= 0;
param->cs= ftb->charset;
param->mode= MYSQL_FTPARSER_SIMPLE_MODE;
while (_mi_ft_segiterator(&ftsi))
{
if (!ftsi.pos)
continue;
param->doc= (char *)ftsi.pos;
param->length= ftsi.len;
if (unlikely(parser->parse(param)))
return 0;
}
ftbe=ftb->root;
if (ftbe->docid[1]==docid && ftbe->cur_weight>0 &&
ftbe->yesses>=ftbe->ythresh && !ftbe->nos)
{ /* row matched ! */
return ftbe->cur_weight;
}
else
{ /* match failed ! */
return 0.0;
}
} | O3 | c | ft_boolean_find_relevance:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq 0x170(%rdi), %r13
movl 0x340(%rbx), %esi
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rax, %rsi
je 0x2d50f
movq (%rdi), %rax
movq 0x218(%rax), %rax
imulq $0x70, %rsi, %rcx
movq 0x38(%rax,%rcx), %r12
jmp 0x2d516
leaq 0x356dea(%rip), %r12 # 0x384300
cmpq $-0x1, %r13
je 0x2d5b9
xorps %xmm0, %xmm0
cmpl $0x0, 0x80(%rbx)
je 0x2d682
movl %edx, -0x2c(%rbp)
xorl %edx, %edx
callq 0x7384d
testq %rax, %rax
je 0x2d67f
movq %rax, %r14
cmpl $0x2, 0x348(%rbx)
je 0x2d595
cmpq 0x338(%rbx), %r13
ja 0x2d595
cmpl $0x0, 0x80(%rbx)
je 0x2d595
xorl %eax, %eax
movq 0x20(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
orq $-0x1, 0x18(%rcx)
movq 0x20(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x2d587
orq $-0x1, 0x18(%rcx)
jmp 0x2d578
incq %rax
movl 0x80(%rbx), %ecx
cmpq %rcx, %rax
jb 0x2d563
movq %r13, 0x338(%rbx)
movl 0x340(%rbx), %esi
cmpl $-0x1, %esi
je 0x2d5c6
movq 0x8(%rbx), %rdi
leaq -0x50(%rbp), %rcx
movq %r15, %rdx
callq 0x739b4
jmp 0x2d5d5
movss 0xaaa4f(%rip), %xmm0 # 0xd8010
jmp 0x2d682
leaq -0x50(%rbp), %rdx
movq %r15, %rdi
movl -0x2c(%rbp), %esi
callq 0x739f7
leaq -0x50(%rbp), %rdi
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
leaq -0x80(%rbp), %rax
movaps %xmm1, 0x10(%rax)
movaps %xmm0, (%rax)
leaq -0x60(%rbp), %rcx
movq %rbx, (%rcx)
movq %rax, 0x8(%rcx)
leaq 0x4487c(%rip), %rax # 0x71e79
movq %rax, (%r14)
leaq 0x8a(%rip), %rax # 0x2d691
movq %rax, 0x8(%r14)
movq %rcx, 0x18(%r14)
andl $0x0, 0x34(%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x20(%r14)
andl $0x0, 0x38(%r14)
callq 0x73a12
testl %eax, %eax
je 0x2d65a
leaq -0x50(%rbp), %r15
movq -0x38(%rbp), %rax
testq %rax, %rax
je 0x2d64e
movq %rax, 0x28(%r14)
movl -0x4c(%rbp), %eax
movl %eax, 0x30(%r14)
movq %r14, %rdi
callq *0x8(%r12)
testl %eax, %eax
jne 0x2d67f
movq %r15, %rdi
callq 0x73a12
testl %eax, %eax
jne 0x2d62e
movq 0x18(%rbx), %rax
cmpq %r13, 0x18(%rax)
jne 0x2d67f
movss 0x2c(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x2d67f
movl 0x40(%rax), %ecx
cmpl 0x48(%rax), %ecx
jb 0x2d67f
cmpl $0x0, 0x44(%rax)
je 0x2d682
xorps %xmm0, %xmm0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ft_boolean_find_relevance:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r15, rsi
mov rbx, rdi
mov rdi, [rdi+8]
mov r13, [rdi+170h]
mov esi, [rbx+340h]
mov eax, 0FFFFFFFFh
cmp rsi, rax
jz short loc_2D50F
mov rax, [rdi]
mov rax, [rax+218h]
imul rcx, rsi, 70h ; 'p'
mov r12, [rax+rcx+38h]
jmp short loc_2D516
loc_2D50F:
lea r12, ft_default_parser
loc_2D516:
cmp r13, 0FFFFFFFFFFFFFFFFh
jz loc_2D5B9
xorps xmm0, xmm0
cmp dword ptr [rbx+80h], 0
jz loc_2D682
mov [rbp+var_2C], edx
xor edx, edx
call ftparser_call_initializer
test rax, rax
jz loc_2D67F
mov r14, rax
cmp dword ptr [rbx+348h], 2
jz short loc_2D595
cmp r13, [rbx+338h]
ja short loc_2D595
cmp dword ptr [rbx+80h], 0
jz short loc_2D595
xor eax, eax
loc_2D563:
mov rcx, [rbx+20h]
mov rcx, [rcx+rax*8]
or qword ptr [rcx+18h], 0FFFFFFFFFFFFFFFFh
mov rcx, [rbx+20h]
mov rcx, [rcx+rax*8]
loc_2D578:
mov rcx, [rcx]
test rcx, rcx
jz short loc_2D587
or qword ptr [rcx+18h], 0FFFFFFFFFFFFFFFFh
jmp short loc_2D578
loc_2D587:
inc rax
mov ecx, [rbx+80h]
cmp rax, rcx
jb short loc_2D563
loc_2D595:
mov [rbx+338h], r13
mov esi, [rbx+340h]
cmp esi, 0FFFFFFFFh
jz short loc_2D5C6
mov rdi, [rbx+8]
lea rcx, [rbp+var_50]
mov rdx, r15
call _mi_ft_segiterator_init
jmp short loc_2D5D5
loc_2D5B9:
movss xmm0, cs:dword_D8010
jmp loc_2D682
loc_2D5C6:
lea rdx, [rbp+var_50]
mov rdi, r15
mov esi, [rbp+var_2C]
call _mi_ft_segiterator_dummy_init
loc_2D5D5:
lea rdi, [rbp+var_50]
movups xmm0, xmmword ptr [rdi]
movups xmm1, xmmword ptr [rdi+10h]
lea rax, [rbp+var_80]
movaps xmmword ptr [rax+10h], xmm1
movaps xmmword ptr [rax], xmm0
lea rcx, [rbp+var_60]
mov [rcx], rbx
mov [rcx+8], rax
lea rax, ftb_find_relevance_parse
mov [r14], rax
lea rax, ftb_find_relevance_add_word
mov [r14+8], rax
mov [r14+18h], rcx
and dword ptr [r14+34h], 0
mov rax, [rbx+10h]
mov [r14+20h], rax
and dword ptr [r14+38h], 0
call _mi_ft_segiterator
test eax, eax
jz short loc_2D65A
lea r15, [rbp+var_50]
loc_2D62E:
mov rax, [rbp+var_38]
test rax, rax
jz short loc_2D64E
mov [r14+28h], rax
mov eax, [rbp+var_4C]
mov [r14+30h], eax
mov rdi, r14
call qword ptr [r12+8]
test eax, eax
jnz short loc_2D67F
loc_2D64E:
mov rdi, r15
call _mi_ft_segiterator
test eax, eax
jnz short loc_2D62E
loc_2D65A:
mov rax, [rbx+18h]
cmp [rax+18h], r13
jnz short loc_2D67F
movss xmm0, dword ptr [rax+2Ch]
xorps xmm1, xmm1
ucomiss xmm0, xmm1
jbe short loc_2D67F
mov ecx, [rax+40h]
cmp ecx, [rax+48h]
jb short loc_2D67F
cmp dword ptr [rax+44h], 0
jz short loc_2D682
loc_2D67F:
xorps xmm0, xmm0
loc_2D682:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| double ft_boolean_find_relevance(long long a1, long long a2, unsigned int a3)
{
_QWORD *v5; // rdi
unsigned long long v6; // r13
long long v7; // rsi
unsigned int ( **v8)(_QWORD); // r12
double result; // xmm0_8
long long v10; // rax
long long v11; // r14
unsigned long long v12; // rax
_QWORD *i; // rcx
long long v14; // rsi
long long v15; // rdx
long long v16; // r8
long long v17; // r9
long long v18; // rdx
long long v19; // rcx
long long v20; // r8
long long v21; // r9
long long v22; // rax
_OWORD v23[2]; // [rsp+0h] [rbp-80h] BYREF
_QWORD v24[2]; // [rsp+20h] [rbp-60h] BYREF
__int128 v25; // [rsp+30h] [rbp-50h] BYREF
__int128 v26; // [rsp+40h] [rbp-40h]
unsigned int v27; // [rsp+54h] [rbp-2Ch]
v5 = *(_QWORD **)(a1 + 8);
v6 = v5[46];
v7 = *(unsigned int *)(a1 + 832);
if ( v7 == 0xFFFFFFFFLL )
v8 = (unsigned int ( **)(_QWORD))&ft_default_parser;
else
v8 = *(unsigned int ( ***)(_QWORD))(*(_QWORD *)(*v5 + 536LL) + 112 * v7 + 56);
if ( v6 == -1LL )
{
*(_QWORD *)&result = 3221225472LL;
return result;
}
result = 0.0;
if ( !*(_DWORD *)(a1 + 128) )
return result;
v27 = a3;
v10 = ftparser_call_initializer(v5, v7, 0LL, 0.0);
if ( !v10 )
return 0.0;
v11 = v10;
if ( *(_DWORD *)(a1 + 840) != 2 && v6 <= *(_QWORD *)(a1 + 824) && *(_DWORD *)(a1 + 128) )
{
v12 = 0LL;
do
{
*(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 32) + 8 * v12) + 24LL) = -1LL;
for ( i = *(_QWORD **)(*(_QWORD *)(a1 + 32) + 8 * v12); ; i[3] = -1LL )
{
i = (_QWORD *)*i;
if ( !i )
break;
}
++v12;
}
while ( v12 < *(unsigned int *)(a1 + 128) );
}
*(_QWORD *)(a1 + 824) = v6;
v14 = *(unsigned int *)(a1 + 832);
if ( (_DWORD)v14 == -1 )
{
v14 = v27;
mi_ft_segiterator_dummy_init(a2, v27, &v25);
}
else
{
mi_ft_segiterator_init(*(_QWORD *)(a1 + 8), v14, a2, &v25);
}
v23[1] = v26;
v23[0] = v25;
v24[0] = a1;
v24[1] = v23;
*(_QWORD *)v11 = ftb_find_relevance_parse;
*(_QWORD *)(v11 + 8) = ftb_find_relevance_add_word;
*(_QWORD *)(v11 + 24) = v24;
*(_DWORD *)(v11 + 52) = 0;
*(_QWORD *)(v11 + 32) = *(_QWORD *)(a1 + 16);
*(_DWORD *)(v11 + 56) = 0;
if ( (unsigned int)mi_ft_segiterator(&v25, v14, v15, v24, v16, v17) )
{
do
{
if ( *((_QWORD *)&v26 + 1) )
{
*(_QWORD *)(v11 + 40) = *((_QWORD *)&v26 + 1);
*(_DWORD *)(v11 + 48) = DWORD1(v25);
if ( v8[1](v11) )
return 0.0;
}
}
while ( (unsigned int)mi_ft_segiterator(&v25, v14, v18, v19, v20, v21) );
}
v22 = *(_QWORD *)(a1 + 24);
if ( *(_QWORD *)(v22 + 24) != v6 )
return 0.0;
*(_QWORD *)&result = *(unsigned int *)(v22 + 44);
if ( *(float *)&result <= 0.0 || *(_DWORD *)(v22 + 64) < *(_DWORD *)(v22 + 72) || *(_DWORD *)(v22 + 68) )
return 0.0;
return result;
}
| ft_boolean_find_relevance:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R15,RSI
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x8]
MOV R13,qword ptr [RDI + 0x170]
MOV ESI,dword ptr [RBX + 0x340]
MOV EAX,0xffffffff
CMP RSI,RAX
JZ 0x0012d50f
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x218]
IMUL RCX,RSI,0x70
MOV R12,qword ptr [RAX + RCX*0x1 + 0x38]
JMP 0x0012d516
LAB_0012d50f:
LEA R12,[0x484300]
LAB_0012d516:
CMP R13,-0x1
JZ 0x0012d5b9
XORPS XMM0,XMM0
CMP dword ptr [RBX + 0x80],0x0
JZ 0x0012d682
MOV dword ptr [RBP + -0x2c],EDX
XOR EDX,EDX
CALL 0x0017384d
TEST RAX,RAX
JZ 0x0012d67f
MOV R14,RAX
CMP dword ptr [RBX + 0x348],0x2
JZ 0x0012d595
CMP R13,qword ptr [RBX + 0x338]
JA 0x0012d595
CMP dword ptr [RBX + 0x80],0x0
JZ 0x0012d595
XOR EAX,EAX
LAB_0012d563:
MOV RCX,qword ptr [RBX + 0x20]
MOV RCX,qword ptr [RCX + RAX*0x8]
OR qword ptr [RCX + 0x18],-0x1
MOV RCX,qword ptr [RBX + 0x20]
MOV RCX,qword ptr [RCX + RAX*0x8]
LAB_0012d578:
MOV RCX,qword ptr [RCX]
TEST RCX,RCX
JZ 0x0012d587
OR qword ptr [RCX + 0x18],-0x1
JMP 0x0012d578
LAB_0012d587:
INC RAX
MOV ECX,dword ptr [RBX + 0x80]
CMP RAX,RCX
JC 0x0012d563
LAB_0012d595:
MOV qword ptr [RBX + 0x338],R13
MOV ESI,dword ptr [RBX + 0x340]
CMP ESI,-0x1
JZ 0x0012d5c6
MOV RDI,qword ptr [RBX + 0x8]
LEA RCX,[RBP + -0x50]
MOV RDX,R15
CALL 0x001739b4
JMP 0x0012d5d5
LAB_0012d5b9:
MOVSS XMM0,dword ptr [0x001d8010]
JMP 0x0012d682
LAB_0012d5c6:
LEA RDX,[RBP + -0x50]
MOV RDI,R15
MOV ESI,dword ptr [RBP + -0x2c]
CALL 0x001739f7
LAB_0012d5d5:
LEA RDI,[RBP + -0x50]
MOVUPS XMM0,xmmword ptr [RDI]
MOVUPS XMM1,xmmword ptr [RDI + 0x10]
LEA RAX,[RBP + -0x80]
MOVAPS xmmword ptr [RAX + 0x10],XMM1
MOVAPS xmmword ptr [RAX],XMM0
LEA RCX,[RBP + -0x60]
MOV qword ptr [RCX],RBX
MOV qword ptr [RCX + 0x8],RAX
LEA RAX,[0x171e79]
MOV qword ptr [R14],RAX
LEA RAX,[0x12d691]
MOV qword ptr [R14 + 0x8],RAX
MOV qword ptr [R14 + 0x18],RCX
AND dword ptr [R14 + 0x34],0x0
MOV RAX,qword ptr [RBX + 0x10]
MOV qword ptr [R14 + 0x20],RAX
AND dword ptr [R14 + 0x38],0x0
CALL 0x00173a12
TEST EAX,EAX
JZ 0x0012d65a
LEA R15,[RBP + -0x50]
LAB_0012d62e:
MOV RAX,qword ptr [RBP + -0x38]
TEST RAX,RAX
JZ 0x0012d64e
MOV qword ptr [R14 + 0x28],RAX
MOV EAX,dword ptr [RBP + -0x4c]
MOV dword ptr [R14 + 0x30],EAX
MOV RDI,R14
CALL qword ptr [R12 + 0x8]
TEST EAX,EAX
JNZ 0x0012d67f
LAB_0012d64e:
MOV RDI,R15
CALL 0x00173a12
TEST EAX,EAX
JNZ 0x0012d62e
LAB_0012d65a:
MOV RAX,qword ptr [RBX + 0x18]
CMP qword ptr [RAX + 0x18],R13
JNZ 0x0012d67f
MOVSS XMM0,dword ptr [RAX + 0x2c]
XORPS XMM1,XMM1
UCOMISS XMM0,XMM1
JBE 0x0012d67f
MOV ECX,dword ptr [RAX + 0x40]
CMP ECX,dword ptr [RAX + 0x48]
JC 0x0012d67f
CMP dword ptr [RAX + 0x44],0x0
JZ 0x0012d682
LAB_0012d67f:
XORPS XMM0,XMM0
LAB_0012d682:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
float ft_boolean_find_relevance(long param_1,int8 param_2,int4 param_3)
{
ulong uVar1;
long lVar2;
int iVar3;
int8 *puVar4;
ulong uVar5;
long *plVar6;
int1 *puVar7;
float fVar8;
int4 local_88;
int4 uStack_84;
int4 uStack_80;
int4 uStack_7c;
int4 local_78;
int4 uStack_74;
int4 uStack_70;
int4 uStack_6c;
long local_68;
int4 *local_60;
int4 local_58;
int4 uStack_54;
int4 uStack_50;
int4 uStack_4c;
int4 local_48;
int4 uStack_44;
int4 uStack_40;
int4 uStack_3c;
int4 local_34;
plVar6 = *(long **)(param_1 + 8);
uVar1 = plVar6[0x2e];
uVar5 = (ulong)*(uint *)(param_1 + 0x340);
if (uVar5 == 0xffffffff) {
puVar7 = ft_default_parser;
}
else {
puVar7 = *(int1 **)(*(long *)(*plVar6 + 0x218) + 0x38 + uVar5 * 0x70);
}
fVar8 = DAT_001d8010;
if ((uVar1 != 0xffffffffffffffff) && (fVar8 = 0.0, *(int *)(param_1 + 0x80) != 0)) {
local_34 = param_3;
puVar4 = (int8 *)ftparser_call_initializer(0,plVar6,uVar5,0);
if (puVar4 != (int8 *)0x0) {
if (((*(int *)(param_1 + 0x348) != 2) && (uVar1 <= *(ulong *)(param_1 + 0x338))) &&
(*(int *)(param_1 + 0x80) != 0)) {
uVar5 = 0;
do {
*(int8 *)(*(long *)(*(long *)(param_1 + 0x20) + uVar5 * 8) + 0x18) =
0xffffffffffffffff;
plVar6 = *(long **)(*(long *)(param_1 + 0x20) + uVar5 * 8);
while (plVar6 = (long *)*plVar6, plVar6 != (long *)0x0) {
plVar6[3] = 0xffffffffffffffff;
}
uVar5 = uVar5 + 1;
} while (uVar5 < *(uint *)(param_1 + 0x80));
}
*(ulong *)(param_1 + 0x338) = uVar1;
if (*(int *)(param_1 + 0x340) == -1) {
_mi_ft_segiterator_dummy_init(param_2,local_34,&local_58);
}
else {
_mi_ft_segiterator_init
(*(int8 *)(param_1 + 8),*(int *)(param_1 + 0x340),param_2,&local_58);
}
local_60 = &local_88;
local_78 = local_48;
uStack_74 = uStack_44;
uStack_70 = uStack_40;
uStack_6c = uStack_3c;
local_88 = local_58;
uStack_84 = uStack_54;
uStack_80 = uStack_50;
uStack_7c = uStack_4c;
*puVar4 = ftb_find_relevance_parse;
puVar4[1] = ftb_find_relevance_add_word;
puVar4[3] = &local_68;
*(int4 *)((long)puVar4 + 0x34) = 0;
puVar4[4] = *(int8 *)(param_1 + 0x10);
*(int4 *)(puVar4 + 7) = 0;
local_68 = param_1;
iVar3 = _mi_ft_segiterator();
if (iVar3 != 0) {
do {
if (CONCAT44(uStack_3c,uStack_40) != 0) {
puVar4[5] = CONCAT44(uStack_3c,uStack_40);
*(int4 *)(puVar4 + 6) = uStack_54;
iVar3 = (**(code **)(puVar7 + 8))(puVar4);
if (iVar3 != 0) goto LAB_0012d67f;
}
iVar3 = _mi_ft_segiterator(&local_58);
} while (iVar3 != 0);
}
lVar2 = *(long *)(param_1 + 0x18);
if (((*(ulong *)(lVar2 + 0x18) == uVar1) && (0.0 < *(float *)(lVar2 + 0x2c))) &&
((*(uint *)(lVar2 + 0x48) <= *(uint *)(lVar2 + 0x40) && (*(int *)(lVar2 + 0x44) == 0)))) {
return *(float *)(lVar2 + 0x2c);
}
}
LAB_0012d67f:
fVar8 = 0.0;
}
return fVar8;
}
| |
25,082 | mj_jac | aimrt_mujoco_sim/_deps/mujoco-src/src/engine/engine_support.c | void mj_jac(const mjModel* m, const mjData* d,
mjtNum* jacp, mjtNum* jacr, const mjtNum point[3], int body) {
int da, nv = m->nv;
mjtNum offset[3], tmp[3], *cdof = d->cdof;
// clear jacobians
if (jacp) {
mju_zero(jacp, 3*nv);
}
if (jacr) {
mju_zero(jacr, 3*nv);
}
// compute point-com offset
mju_sub3(offset, point, d->subtree_com+3*m->body_rootid[body]);
// skip fixed bodies
while (body && !m->body_dofnum[body]) {
body = m->body_parentid[body];
}
// no movable body found: nothing to do
if (!body) {
return;
}
// get last dof that affects this (as well as the original) body
da = m->body_dofadr[body] + m->body_dofnum[body] - 1;
// backward pass over dof ancestor chain
while (da >= 0) {
// construct rotation jacobian
if (jacr) {
jacr[da] = cdof[6*da];
jacr[da+nv] = cdof[6*da+1];
jacr[da+2*nv] = cdof[6*da+2];
}
// construct translation jacobian (correct for rotation)
if (jacp) {
mju_cross(tmp, cdof+6*da, offset);
jacp[da] = cdof[6*da+3] + tmp[0];
jacp[da+nv] = cdof[6*da+4] + tmp[1];
jacp[da+2*nv] = cdof[6*da+5] + tmp[2];
}
// advance to parent dof
da = m->dof_parentid[da];
}
} | O3 | c | mj_jac:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r9d, %ebp
movq %r8, 0x10(%rsp)
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movl 0x4(%rdi), %eax
movq %rax, (%rsp)
movq %rsi, %r13
movq 0x27880(%rsi), %rax
movq %rax, 0x8(%rsp)
testq %rdx, %rdx
je 0x97d90
movq (%rsp), %rax
leal (%rax,%rax,2), %esi
movq %r14, %rdi
callq 0x2d1f0
testq %rbx, %rbx
je 0x97da4
movq (%rsp), %rax
leal (%rax,%rax,2), %esi
movq %rbx, %rdi
callq 0x2d1f0
movq 0x538(%r15), %rax
movslq %ebp, %r12
movslq (%rax,%r12,4), %rax
leaq (%rax,%rax,2), %rdx
shlq $0x3, %rdx
addq 0x27878(%r13), %rdx
leaq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2d100
testl %r12d, %r12d
movq (%rsp), %rsi
je 0x97ef6
movq 0x560(%r15), %rax
movslq %ebp, %rcx
movl (%rax,%rcx,4), %r12d
testl %r12d, %r12d
jne 0x97e03
movq 0x530(%r15), %rdx
movl (%rdx,%rcx,4), %ebp
testl %ebp, %ebp
jne 0x97de4
jmp 0x97ef6
movq 0x568(%r15), %rax
addl (%rax,%rcx,4), %r12d
decl %r12d
js 0x97ef6
leal (%rsi,%rsi), %edi
movq %r14, 0x18(%rsp)
movl %r12d, %r13d
testq %rbx, %rbx
je 0x97e61
leal (%r12,%r12), %eax
leal (%rax,%rax,2), %eax
movq 0x8(%rsp), %rdx
vmovsd (%rdx,%rax,8), %xmm0
vmovsd %xmm0, (%rbx,%r13,8)
vmovsd 0x8(%rdx,%rax,8), %xmm0
leal (%r12,%rsi), %ecx
movslq %ecx, %rcx
vmovsd %xmm0, (%rbx,%rcx,8)
vmovsd 0x10(%rdx,%rax,8), %xmm0
leal (%r12,%rdi), %eax
cltq
vmovsd %xmm0, (%rbx,%rax,8)
testq %r14, %r14
je 0x97ee2
leal (%r12,%r12), %eax
leal (%rax,%rax,2), %eax
movq 0x8(%rsp), %rcx
leaq (%rcx,%rax,8), %rbp
movq %rbx, %r14
movq %r15, %rbx
movq %rdi, %r15
leaq 0x20(%rsp), %rdi
movq %rbp, %rsi
leaq 0x40(%rsp), %rdx
callq 0x2d420
movq %r15, %rdi
movq %rbx, %r15
movq %r14, %rbx
movq 0x18(%rsp), %r14
movq (%rsp), %rsi
vmovsd 0x18(%rbp), %xmm0
vaddsd 0x20(%rsp), %xmm0, %xmm0
vmovsd %xmm0, (%r14,%r13,8)
vmovsd 0x20(%rbp), %xmm0
vaddsd 0x28(%rsp), %xmm0, %xmm0
leal (%r12,%rsi), %eax
cltq
vmovsd %xmm0, (%r14,%rax,8)
vmovsd 0x28(%rbp), %xmm0
vaddsd 0x30(%rsp), %xmm0, %xmm0
addl %edi, %r12d
movslq %r12d, %rax
vmovsd %xmm0, (%r14,%rax,8)
movq 0x6d0(%r15), %rax
movl (%rax,%r13,4), %r12d
testl %r12d, %r12d
jns 0x97e1f
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| mj_jac:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov ebp, r9d
mov [rsp+88h+var_78], r8
mov rbx, rcx
mov r14, rdx
mov r15, rdi
mov eax, [rdi+4]
mov [rsp+88h+var_88], rax
mov r13, rsi
mov rax, [rsi+27880h]
mov [rsp+88h+var_80], rax
test rdx, rdx
jz short loc_97D90
mov rax, [rsp+88h+var_88]
lea esi, [rax+rax*2]
mov rdi, r14
call _mju_zero
loc_97D90:
test rbx, rbx
jz short loc_97DA4
mov rax, [rsp+88h+var_88]
lea esi, [rax+rax*2]
mov rdi, rbx
call _mju_zero
loc_97DA4:
mov rax, [r15+538h]
movsxd r12, ebp
movsxd rax, dword ptr [rax+r12*4]
lea rdx, [rax+rax*2]
shl rdx, 3
add rdx, [r13+27878h]
lea rdi, [rsp+88h+var_48]
mov rsi, [rsp+88h+var_78]
call _mju_sub3
test r12d, r12d
mov rsi, [rsp+88h+var_88]
jz loc_97EF6
mov rax, [r15+560h]
loc_97DE4:
movsxd rcx, ebp
mov r12d, [rax+rcx*4]
test r12d, r12d
jnz short loc_97E03
mov rdx, [r15+530h]
mov ebp, [rdx+rcx*4]
test ebp, ebp
jnz short loc_97DE4
jmp loc_97EF6
loc_97E03:
mov rax, [r15+568h]
add r12d, [rax+rcx*4]
dec r12d
js loc_97EF6
lea edi, [rsi+rsi]
mov [rsp+88h+var_70], r14
loc_97E1F:
mov r13d, r12d
test rbx, rbx
jz short loc_97E61
lea eax, [r12+r12]
lea eax, [rax+rax*2]
mov rdx, [rsp+88h+var_80]
vmovsd xmm0, qword ptr [rdx+rax*8]
vmovsd qword ptr [rbx+r13*8], xmm0
vmovsd xmm0, qword ptr [rdx+rax*8+8]
lea ecx, [r12+rsi]
movsxd rcx, ecx
vmovsd qword ptr [rbx+rcx*8], xmm0
vmovsd xmm0, qword ptr [rdx+rax*8+10h]
lea eax, [r12+rdi]
cdqe
vmovsd qword ptr [rbx+rax*8], xmm0
loc_97E61:
test r14, r14
jz short loc_97EE2
lea eax, [r12+r12]
lea eax, [rax+rax*2]
mov rcx, [rsp+88h+var_80]
lea rbp, [rcx+rax*8]
mov r14, rbx
mov rbx, r15
mov r15, rdi
lea rdi, [rsp+88h+var_68]
mov rsi, rbp
lea rdx, [rsp+88h+var_48]
call _mju_cross
mov rdi, r15
mov r15, rbx
mov rbx, r14
mov r14, [rsp+88h+var_70]
mov rsi, [rsp+88h+var_88]
vmovsd xmm0, qword ptr [rbp+18h]
vaddsd xmm0, xmm0, [rsp+88h+var_68]
vmovsd qword ptr [r14+r13*8], xmm0
vmovsd xmm0, qword ptr [rbp+20h]
vaddsd xmm0, xmm0, [rsp+88h+var_60]
lea eax, [r12+rsi]
cdqe
vmovsd qword ptr [r14+rax*8], xmm0
vmovsd xmm0, qword ptr [rbp+28h]
vaddsd xmm0, xmm0, [rsp+88h+var_58]
add r12d, edi
movsxd rax, r12d
vmovsd qword ptr [r14+rax*8], xmm0
loc_97EE2:
mov rax, [r15+6D0h]
mov r12d, [rax+r13*4]
test r12d, r12d
jns loc_97E1F
loc_97EF6:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| void mj_jac(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
int a6,
double a7,
double a8,
double a9,
double a10,
double a11,
double a12,
double a13)
{
int v17; // esi
int v18; // r12d
int v19; // r12d
int v20; // edi
int v38; // [rsp+0h] [rbp-88h]
long long v39; // [rsp+8h] [rbp-80h]
long long v41; // [rsp+18h] [rbp-70h]
long long v42; // [rsp+20h] [rbp-68h] BYREF
_BYTE v43[72]; // [rsp+40h] [rbp-48h] BYREF
_RBX = a4;
_R14 = a3;
v38 = *(_DWORD *)(a1 + 4);
v39 = *(_QWORD *)(a2 + 161920);
if ( a3 )
a7 = mju_zero(a3, (unsigned int)(3 * v38), a7, a8, a9, a10, a11, a12, a13);
if ( _RBX )
mju_zero(_RBX, (unsigned int)(3 * v38), a7, a8, a9, a10, a11, a12, a13);
mju_sub3(v43, a5, *(_QWORD *)(a2 + 161912) + 24LL * *(int *)(*(_QWORD *)(a1 + 1336) + 4LL * a6));
v17 = v38;
if ( a6 )
{
while ( 1 )
{
v18 = *(_DWORD *)(*(_QWORD *)(a1 + 1376) + 4LL * a6);
if ( v18 )
break;
a6 = *(_DWORD *)(*(_QWORD *)(a1 + 1328) + 4LL * a6);
if ( !a6 )
return;
}
v19 = *(_DWORD *)(*(_QWORD *)(a1 + 1384) + 4LL * a6) + v18 - 1;
if ( v19 >= 0 )
{
v20 = 2 * v38;
v41 = _R14;
do
{
_R13 = (unsigned int)v19;
if ( _RBX )
{
_RAX = (unsigned int)(6 * v19);
_RDX = v39;
__asm
{
vmovsd xmm0, qword ptr [rdx+rax*8]
vmovsd qword ptr [rbx+r13*8], xmm0
vmovsd xmm0, qword ptr [rdx+rax*8+8]
}
_RCX = v19 + v17;
__asm
{
vmovsd qword ptr [rbx+rcx*8], xmm0
vmovsd xmm0, qword ptr [rdx+rax*8+10h]
}
_RAX = v19 + v20;
__asm { vmovsd qword ptr [rbx+rax*8], xmm0 }
}
if ( _R14 )
{
_RBP = v39 + 8LL * (unsigned int)(6 * v19);
mju_cross(&v42, _RBP, v43);
_R14 = v41;
v17 = v38;
__asm
{
vmovsd xmm0, qword ptr [rbp+18h]
vaddsd xmm0, xmm0, [rsp+88h+var_68]
vmovsd qword ptr [r14+r13*8], xmm0
vmovsd xmm0, qword ptr [rbp+20h]
vaddsd xmm0, xmm0, [rsp+88h+var_60]
}
_RAX = v19 + v38;
__asm
{
vmovsd qword ptr [r14+rax*8], xmm0
vmovsd xmm0, qword ptr [rbp+28h]
vaddsd xmm0, xmm0, [rsp+88h+var_58]
}
_RAX = v20 + v19;
__asm { vmovsd qword ptr [r14+rax*8], xmm0 }
}
v19 = *(_DWORD *)(*(_QWORD *)(a1 + 1744) + 4LL * (unsigned int)v19);
}
while ( v19 >= 0 );
}
}
}
| mj_jac:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV EBP,R9D
MOV qword ptr [RSP + 0x10],R8
MOV RBX,RCX
MOV R14,RDX
MOV R15,RDI
MOV EAX,dword ptr [RDI + 0x4]
MOV qword ptr [RSP],RAX
MOV R13,RSI
MOV RAX,qword ptr [RSI + 0x27880]
MOV qword ptr [RSP + 0x8],RAX
TEST RDX,RDX
JZ 0x00197d90
MOV RAX,qword ptr [RSP]
LEA ESI,[RAX + RAX*0x2]
MOV RDI,R14
CALL 0x0012d1f0
LAB_00197d90:
TEST RBX,RBX
JZ 0x00197da4
MOV RAX,qword ptr [RSP]
LEA ESI,[RAX + RAX*0x2]
MOV RDI,RBX
CALL 0x0012d1f0
LAB_00197da4:
MOV RAX,qword ptr [R15 + 0x538]
MOVSXD R12,EBP
MOVSXD RAX,dword ptr [RAX + R12*0x4]
LEA RDX,[RAX + RAX*0x2]
SHL RDX,0x3
ADD RDX,qword ptr [R13 + 0x27878]
LEA RDI,[RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x10]
CALL 0x0012d100
TEST R12D,R12D
MOV RSI,qword ptr [RSP]
JZ 0x00197ef6
MOV RAX,qword ptr [R15 + 0x560]
LAB_00197de4:
MOVSXD RCX,EBP
MOV R12D,dword ptr [RAX + RCX*0x4]
TEST R12D,R12D
JNZ 0x00197e03
MOV RDX,qword ptr [R15 + 0x530]
MOV EBP,dword ptr [RDX + RCX*0x4]
TEST EBP,EBP
JNZ 0x00197de4
JMP 0x00197ef6
LAB_00197e03:
MOV RAX,qword ptr [R15 + 0x568]
ADD R12D,dword ptr [RAX + RCX*0x4]
DEC R12D
JS 0x00197ef6
LEA EDI,[RSI + RSI*0x1]
MOV qword ptr [RSP + 0x18],R14
LAB_00197e1f:
MOV R13D,R12D
TEST RBX,RBX
JZ 0x00197e61
LEA EAX,[R12 + R12*0x1]
LEA EAX,[RAX + RAX*0x2]
MOV RDX,qword ptr [RSP + 0x8]
VMOVSD XMM0,qword ptr [RDX + RAX*0x8]
VMOVSD qword ptr [RBX + R13*0x8],XMM0
VMOVSD XMM0,qword ptr [RDX + RAX*0x8 + 0x8]
LEA ECX,[R12 + RSI*0x1]
MOVSXD RCX,ECX
VMOVSD qword ptr [RBX + RCX*0x8],XMM0
VMOVSD XMM0,qword ptr [RDX + RAX*0x8 + 0x10]
LEA EAX,[R12 + RDI*0x1]
CDQE
VMOVSD qword ptr [RBX + RAX*0x8],XMM0
LAB_00197e61:
TEST R14,R14
JZ 0x00197ee2
LEA EAX,[R12 + R12*0x1]
LEA EAX,[RAX + RAX*0x2]
MOV RCX,qword ptr [RSP + 0x8]
LEA RBP,[RCX + RAX*0x8]
MOV R14,RBX
MOV RBX,R15
MOV R15,RDI
LEA RDI,[RSP + 0x20]
MOV RSI,RBP
LEA RDX,[RSP + 0x40]
CALL 0x0012d420
MOV RDI,R15
MOV R15,RBX
MOV RBX,R14
MOV R14,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP]
VMOVSD XMM0,qword ptr [RBP + 0x18]
VADDSD XMM0,XMM0,qword ptr [RSP + 0x20]
VMOVSD qword ptr [R14 + R13*0x8],XMM0
VMOVSD XMM0,qword ptr [RBP + 0x20]
VADDSD XMM0,XMM0,qword ptr [RSP + 0x28]
LEA EAX,[R12 + RSI*0x1]
CDQE
VMOVSD qword ptr [R14 + RAX*0x8],XMM0
VMOVSD XMM0,qword ptr [RBP + 0x28]
VADDSD XMM0,XMM0,qword ptr [RSP + 0x30]
ADD R12D,EDI
MOVSXD RAX,R12D
VMOVSD qword ptr [R14 + RAX*0x8],XMM0
LAB_00197ee2:
MOV RAX,qword ptr [R15 + 0x6d0]
MOV R12D,dword ptr [RAX + R13*0x4]
TEST R12D,R12D
JNS 0x00197e1f
LAB_00197ef6:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void mj_jac(long param_1,long param_2,long param_3,long param_4,int8 param_5,int param_6)
{
int iVar1;
int iVar2;
long lVar3;
ulong uVar4;
long lVar5;
uint uVar6;
double local_68;
double local_60;
double local_58;
int1 local_48 [24];
ulong uVar7;
iVar1 = *(int *)(param_1 + 4);
lVar3 = *(long *)(param_2 + 0x27880);
if (param_3 != 0) {
mju_zero(param_3,iVar1 * 3);
}
if (param_4 != 0) {
mju_zero(param_4,iVar1 * 3);
}
mju_sub3(local_48,param_5,
(long)*(int *)(*(long *)(param_1 + 0x538) + (long)param_6 * 4) * 0x18 +
*(long *)(param_2 + 0x27878));
if (param_6 != 0) {
do {
lVar5 = (long)param_6;
iVar2 = *(int *)(*(long *)(param_1 + 0x560) + lVar5 * 4);
if (iVar2 != 0) {
uVar6 = (iVar2 + *(int *)(*(long *)(param_1 + 0x568) + lVar5 * 4)) - 1;
if ((int)uVar6 < 0) {
return;
}
do {
uVar7 = (ulong)uVar6;
if (param_4 != 0) {
uVar4 = (ulong)(uVar6 * 6);
*(int8 *)(param_4 + uVar7 * 8) = *(int8 *)(lVar3 + uVar4 * 8);
*(int8 *)(param_4 + (long)(int)(uVar6 + iVar1) * 8) =
*(int8 *)(lVar3 + 8 + uVar4 * 8);
*(int8 *)(param_4 + (long)(int)(uVar6 + iVar1 * 2) * 8) =
*(int8 *)(lVar3 + 0x10 + uVar4 * 8);
}
if (param_3 != 0) {
lVar5 = lVar3 + (ulong)(uVar6 * 6) * 8;
mju_cross(&local_68,lVar5,local_48);
*(double *)(param_3 + uVar7 * 8) = *(double *)(lVar5 + 0x18) + local_68;
*(double *)(param_3 + (long)(int)(uVar6 + iVar1) * 8) =
*(double *)(lVar5 + 0x20) + local_60;
*(double *)(param_3 + (long)(int)(uVar6 + iVar1 * 2) * 8) =
*(double *)(lVar5 + 0x28) + local_58;
}
uVar6 = *(uint *)(*(long *)(param_1 + 0x6d0) + uVar7 * 4);
} while (-1 < (int)uVar6);
return;
}
param_6 = *(int *)(*(long *)(param_1 + 0x530) + lVar5 * 4);
} while (param_6 != 0);
}
return;
}
| |
25,083 | Balloc | eloqsql/strings/dtoa.c | static Bigint *Balloc(int k, Stack_alloc *alloc)
{
Bigint *rv;
DBUG_ASSERT(k <= Kmax);
if (k <= Kmax && alloc->freelist[k])
{
rv= alloc->freelist[k];
alloc->freelist[k]= rv->p.next;
}
else
{
int x, len;
x= 1 << k;
len= MY_ALIGN(sizeof(Bigint) + x * sizeof(ULong), SIZEOF_CHARP);
if (alloc->free + len <= alloc->end)
{
rv= (Bigint*) alloc->free;
alloc->free+= len;
}
else
rv= (Bigint*) malloc(len);
rv->k= k;
rv->maxwds= x;
}
rv->sign= rv->wds= 0;
rv->p.x= (ULong*) (rv + 1);
return rv;
} | O0 | c | Balloc:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0xd4501
cmpl $0xf, -0x4(%rbp)
jg 0xd4541
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
cmpq $0x0, 0x18(%rax,%rcx,8)
je 0xd4541
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq %rdx, 0x18(%rax,%rcx,8)
jmp 0xd45c6
movl -0x4(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq $0x18, %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
ja 0xd45a5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
jmp 0xd45b2
movslq -0x20(%rbp), %rdi
callq 0x284c0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x18(%rbp), %rcx
addq $0x18, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| Balloc:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
jmp short $+2
loc_D4501:
cmp [rbp+var_4], 0Fh
jg short loc_D4541
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_4]
cmp qword ptr [rax+rcx*8+18h], 0
jz short loc_D4541
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_4]
mov rax, [rax+rcx*8+18h]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rdx, [rax]
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_4]
mov [rax+rcx*8+18h], rdx
jmp loc_D45C6
loc_D4541:
mov ecx, [rbp+var_4]
mov eax, 1
shl eax, cl
mov [rbp+var_1C], eax
movsxd rax, [rbp+var_1C]
shl rax, 2
add rax, 18h
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_20], eax
mov rax, [rbp+var_10]
mov rax, [rax+8]
movsxd rcx, [rbp+var_20]
add rax, rcx
mov rcx, [rbp+var_10]
cmp rax, [rcx+10h]
ja short loc_D45A5
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_18], rax
mov edx, [rbp+var_20]
mov rax, [rbp+var_10]
mov rcx, [rax+8]
movsxd rdx, edx
add rcx, rdx
mov [rax+8], rcx
jmp short loc_D45B2
loc_D45A5:
movsxd rdi, [rbp+var_20]
call _malloc
mov [rbp+var_18], rax
loc_D45B2:
mov ecx, [rbp+var_4]
mov rax, [rbp+var_18]
mov [rax+8], ecx
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_18]
mov [rax+0Ch], ecx
loc_D45C6:
mov rax, [rbp+var_18]
mov dword ptr [rax+14h], 0
mov rax, [rbp+var_18]
mov dword ptr [rax+10h], 0
mov rcx, [rbp+var_18]
add rcx, 18h
mov rax, [rbp+var_18]
mov [rax], rcx
mov rax, [rbp+var_18]
add rsp, 20h
pop rbp
retn
| long long Balloc(int a1, long long a2)
{
signed int v3; // [rsp+0h] [rbp-20h]
long long v4; // [rsp+8h] [rbp-18h]
if ( a1 <= 15 && *(_QWORD *)(a2 + 8LL * a1 + 24) )
{
v4 = *(_QWORD *)(a2 + 8LL * a1 + 24);
*(_QWORD *)(a2 + 8LL * a1 + 24) = *(_QWORD *)v4;
}
else
{
v3 = (4 * (1 << a1) + 31) & 0xFFFFFFF8;
if ( (unsigned long long)(v3 + *(_QWORD *)(a2 + 8)) > *(_QWORD *)(a2 + 16) )
{
v4 = malloc(v3);
}
else
{
v4 = *(_QWORD *)(a2 + 8);
*(_QWORD *)(a2 + 8) = v3 + v4;
}
*(_DWORD *)(v4 + 8) = a1;
*(_DWORD *)(v4 + 12) = 1 << a1;
}
*(_DWORD *)(v4 + 20) = 0;
*(_DWORD *)(v4 + 16) = 0;
*(_QWORD *)v4 = v4 + 24;
return v4;
}
| Balloc:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x001d4501
LAB_001d4501:
CMP dword ptr [RBP + -0x4],0xf
JG 0x001d4541
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x4]
CMP qword ptr [RAX + RCX*0x8 + 0x18],0x0
JZ 0x001d4541
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x4]
MOV RAX,qword ptr [RAX + RCX*0x8 + 0x18]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x4]
MOV qword ptr [RAX + RCX*0x8 + 0x18],RDX
JMP 0x001d45c6
LAB_001d4541:
MOV ECX,dword ptr [RBP + -0x4]
MOV EAX,0x1
SHL EAX,CL
MOV dword ptr [RBP + -0x1c],EAX
MOVSXD RAX,dword ptr [RBP + -0x1c]
SHL RAX,0x2
ADD RAX,0x18
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
MOV dword ptr [RBP + -0x20],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOVSXD RCX,dword ptr [RBP + -0x20]
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x10]
JA 0x001d45a5
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV EDX,dword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x8]
MOVSXD RDX,EDX
ADD RCX,RDX
MOV qword ptr [RAX + 0x8],RCX
JMP 0x001d45b2
LAB_001d45a5:
MOVSXD RDI,dword ptr [RBP + -0x20]
CALL 0x001284c0
MOV qword ptr [RBP + -0x18],RAX
LAB_001d45b2:
MOV ECX,dword ptr [RBP + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x8],ECX
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0xc],ECX
LAB_001d45c6:
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x14],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x10],0x0
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,0x18
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x20
POP RBP
RET
|
int8 * Balloc(int param_1,long param_2)
{
int iVar1;
uint uVar2;
int8 *local_20;
if ((param_1 < 0x10) && (*(long *)(param_2 + 0x18 + (long)param_1 * 8) != 0)) {
local_20 = *(int8 **)(param_2 + 0x18 + (long)param_1 * 8);
*(int8 *)(param_2 + 0x18 + (long)param_1 * 8) = *local_20;
}
else {
iVar1 = 1 << ((byte)param_1 & 0x1f);
uVar2 = iVar1 * 4 + 0x1fU & 0xfffffff8;
if (*(ulong *)(param_2 + 0x10) < (ulong)(*(long *)(param_2 + 8) + (long)(int)uVar2)) {
local_20 = (int8 *)malloc((long)(int)uVar2);
}
else {
local_20 = *(int8 **)(param_2 + 8);
*(long *)(param_2 + 8) = *(long *)(param_2 + 8) + (long)(int)uVar2;
}
*(int *)(local_20 + 1) = param_1;
*(int *)((long)local_20 + 0xc) = iVar1;
}
*(int4 *)((long)local_20 + 0x14) = 0;
*(int4 *)(local_20 + 2) = 0;
*local_20 = local_20 + 3;
return local_20;
}
| |
25,084 | JS_StringToBigInt | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_StringToBigInt(JSContext *ctx, JSValue val)
{
const char *str;
size_t len;
int flags;
str = JS_ToCStringLen(ctx, &len, val);
JS_FreeValue(ctx, val);
if (!str)
return JS_EXCEPTION;
flags = ATOD_WANT_BIG_INT |
ATOD_TRIM_SPACES | ATOD_ACCEPT_EMPTY |
ATOD_ACCEPT_HEX_PREFIX | ATOD_ACCEPT_BIN_OCT |
ATOD_DECIMAL_AFTER_SIGN | ATOD_NO_TRAILING_CHARS;
val = js_atof(ctx, str, len, NULL, 10, flags);
JS_FreeCString(ctx, str);
return val;
} | O1 | c | JS_StringToBigInt:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
leaq 0x8(%rsp), %rsi
xorl %ebx, %ebx
movq %r13, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0x20bf7
movq %rax, %r14
movq 0x18(%r15), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1d8c6
testq %r14, %r14
je 0x3e5f4
movq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
movl $0xa, %r8d
movl $0x733, %r9d # imm = 0x733
callq 0x3e60e
movq %rax, %rbx
movq %rdx, %r12
movq 0x18(%r15), %rdi
movl -0x18(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, -0x18(%r14)
cmpl $0x1, %eax
jg 0x3e5fa
addq $-0x18, %r14
movq %r14, %rsi
movq $-0x7, %rdx
callq 0x21266
jmp 0x3e5fa
movl $0x6, %r12d
movq %rbx, %rax
movq %r12, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| JS_StringToBigInt:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov r12, rdx
mov r13, rsi
mov r15, rdi
lea rsi, [rsp+38h+var_30]
xor ebx, ebx
mov rdx, r13
mov rcx, r12
xor r8d, r8d
call JS_ToCStringLen2
mov r14, rax
mov rdi, [r15+18h]
mov rsi, r13
mov rdx, r12
call JS_FreeValueRT
test r14, r14
jz short loc_3E5F4
mov rdx, [rsp+38h+var_30]
mov rdi, r15
mov rsi, r14
xor ecx, ecx
mov r8d, 0Ah
mov r9d, 733h
call js_atof
mov rbx, rax
mov r12, rdx
mov rdi, [r15+18h]
mov eax, [r14-18h]
lea ecx, [rax-1]
mov [r14-18h], ecx
cmp eax, 1
jg short loc_3E5FA
add r14, 0FFFFFFFFFFFFFFE8h
mov rsi, r14
mov rdx, 0FFFFFFFFFFFFFFF9h
call js_free_value_rt
jmp short loc_3E5FA
loc_3E5F4:
mov r12d, 6
loc_3E5FA:
mov rax, rbx
mov rdx, r12
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| long long JS_StringToBigInt(long long a1, _DWORD *a2, long long a3)
{
long long v4; // rbx
long long v5; // r14
long long v6; // rdi
int v7; // eax
long long v9[6]; // [rsp+8h] [rbp-30h] BYREF
v4 = 0LL;
v5 = JS_ToCStringLen2(a1, v9, (long long)a2, a3, 0);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), a2, a3);
if ( v5 )
{
v4 = js_atof(a1, v5, v9[0], 0LL, 10LL, 1843LL);
v6 = *(_QWORD *)(a1 + 24);
v7 = *(_DWORD *)(v5 - 24);
*(_DWORD *)(v5 - 24) = v7 - 1;
if ( v7 <= 1 )
js_free_value_rt(v6, (_QWORD *)(v5 - 24), -7);
}
return v4;
}
| JS_StringToBigInt:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R12,RDX
MOV R13,RSI
MOV R15,RDI
LEA RSI,[RSP + 0x8]
XOR EBX,EBX
MOV RDX,R13
MOV RCX,R12
XOR R8D,R8D
CALL 0x00120bf7
MOV R14,RAX
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,R13
MOV RDX,R12
CALL 0x0011d8c6
TEST R14,R14
JZ 0x0013e5f4
MOV RDX,qword ptr [RSP + 0x8]
MOV RDI,R15
MOV RSI,R14
XOR ECX,ECX
MOV R8D,0xa
MOV R9D,0x733
CALL 0x0013e60e
MOV RBX,RAX
MOV R12,RDX
MOV RDI,qword ptr [R15 + 0x18]
MOV EAX,dword ptr [R14 + -0x18]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R14 + -0x18],ECX
CMP EAX,0x1
JG 0x0013e5fa
ADD R14,-0x18
MOV RSI,R14
MOV RDX,-0x7
CALL 0x00121266
JMP 0x0013e5fa
LAB_0013e5f4:
MOV R12D,0x6
LAB_0013e5fa:
MOV RAX,RBX
MOV RDX,R12
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
int1 [16] JS_StringToBigInt(long param_1,int8 param_2,int8 param_3)
{
int iVar1;
int8 uVar2;
long lVar3;
int1 auVar4 [16];
int8 local_30;
lVar3 = JS_ToCStringLen2(param_1,&local_30,param_2,param_3,0);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),param_2,param_3);
if (lVar3 == 0) {
auVar4 = ZEXT816(6) << 0x40;
}
else {
auVar4 = js_atof(param_1,lVar3,local_30,0,10,0x733);
uVar2 = *(int8 *)(param_1 + 0x18);
iVar1 = *(int *)(lVar3 + -0x18);
*(int *)(lVar3 + -0x18) = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(uVar2,lVar3 + -0x18,0xfffffffffffffff9);
}
}
return auVar4;
}
| |
25,085 | JS_StringToBigInt | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_StringToBigInt(JSContext *ctx, JSValue val)
{
const char *str;
size_t len;
int flags;
str = JS_ToCStringLen(ctx, &len, val);
JS_FreeValue(ctx, val);
if (!str)
return JS_EXCEPTION;
flags = ATOD_WANT_BIG_INT |
ATOD_TRIM_SPACES | ATOD_ACCEPT_EMPTY |
ATOD_ACCEPT_HEX_PREFIX | ATOD_ACCEPT_BIN_OCT |
ATOD_DECIMAL_AFTER_SIGN | ATOD_NO_TRAILING_CHARS;
val = js_atof(ctx, str, len, NULL, 10, flags);
JS_FreeCString(ctx, str);
return val;
} | O2 | c | JS_StringToBigInt:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsp, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x36bee
movq %rax, %r14
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1801e
testq %r14, %r14
je 0x36bd5
movq (%rsp), %rdx
pushq $0xa
popq %r8
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
movl $0x733, %r9d # imm = 0x733
callq 0x36bf6
movq %rax, %r12
movq %rdx, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b057
jmp 0x36bdc
pushq $0x6
popq %r15
xorl %r12d, %r12d
movq %r12, %rax
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| JS_StringToBigInt:
push r15
push r14
push r12
push rbx
push rax
mov r15, rdx
mov r12, rsi
mov rbx, rdi
mov rsi, rsp
mov rdx, r12
mov rcx, r15
call JS_ToCStringLen_0
mov r14, rax
mov rdi, rbx
mov rsi, r12
mov rdx, r15
call JS_FreeValue
test r14, r14
jz short loc_36BD5
mov rdx, [rsp+28h+var_28]
push 0Ah
pop r8
mov rdi, rbx
mov rsi, r14
xor ecx, ecx
mov r9d, 733h
call js_atof
mov r12, rax
mov r15, rdx
mov rdi, rbx
mov rsi, r14
call JS_FreeCString
jmp short loc_36BDC
loc_36BD5:
push 6
pop r15
xor r12d, r12d
loc_36BDC:
mov rax, r12
mov rdx, r15
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long JS_StringToBigInt(long long a1, long long a2, long long a3)
{
long long v3; // rax
long long v5; // r14
long long v6; // r12
_QWORD v8[5]; // [rsp+0h] [rbp-28h] BYREF
v8[0] = v3;
v5 = JS_ToCStringLen_0(a1, v8, a2, a3);
JS_FreeValue(a1, a2, a3);
if ( !v5 )
return 0LL;
v6 = js_atof(a1, v5, v8[0], 0LL, 10LL, 1843LL);
JS_FreeCString(a1, v5);
return v6;
}
| JS_StringToBigInt:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV R12,RSI
MOV RBX,RDI
MOV RSI,RSP
MOV RDX,R12
MOV RCX,R15
CALL 0x00136bee
MOV R14,RAX
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R15
CALL 0x0011801e
TEST R14,R14
JZ 0x00136bd5
MOV RDX,qword ptr [RSP]
PUSH 0xa
POP R8
MOV RDI,RBX
MOV RSI,R14
XOR ECX,ECX
MOV R9D,0x733
CALL 0x00136bf6
MOV R12,RAX
MOV R15,RDX
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011b057
JMP 0x00136bdc
LAB_00136bd5:
PUSH 0x6
POP R15
XOR R12D,R12D
LAB_00136bdc:
MOV RAX,R12
MOV RDX,R15
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int1 [16] JS_StringToBigInt(int8 param_1,int8 param_2,int8 param_3)
{
int8 in_RAX;
long lVar1;
int1 auVar2 [16];
int8 local_28;
local_28 = in_RAX;
lVar1 = JS_ToCStringLen(param_1,&local_28,param_2,param_3);
JS_FreeValue(param_1,param_2,param_3);
if (lVar1 == 0) {
auVar2 = ZEXT816(6) << 0x40;
}
else {
auVar2 = js_atof(param_1,lVar1,local_28,0,10,0x733);
JS_FreeCString(param_1,lVar1);
}
return auVar2;
}
| |
25,086 | ulight::highlight(ulight::Non_Owning_Buffer<ulight_token>&, std::basic_string_view<char8_t, std::char_traits<char8_t>>, ulight::Lang, std::pmr::memory_resource*, ulight::Highlight_Options const&) | ulight/include/ulight/impl/highlight.hpp | inline Status highlight(
Non_Owning_Buffer<Token>& out,
std::u8string_view source,
Lang language,
std::pmr::memory_resource* memory,
const Highlight_Options& options = {}
)
{
constexpr auto to_result = [](bool success) -> Status {
if (success) {
return Status::ok;
}
return Status::bad_code;
};
switch (language) {
case Lang::cpp: //
return to_result(highlight_cpp(out, source, memory, options));
case Lang::mmml: //
return to_result(highlight_mmml(out, source, memory, options));
case Lang::lua: //
return to_result(highlight_lua(out, source, memory, options));
case Lang::html: //
return to_result(highlight_html(out, source, memory, options));
case Lang::css: //
return to_result(highlight_css(out, source, memory, options));
case Lang::c: //
return to_result(highlight_c(out, source, memory, options));
default: //
return Status::bad_lang;
}
} | O0 | cpp | ulight::highlight(ulight::Non_Owning_Buffer<ulight_token>&, std::basic_string_view<char8_t, std::char_traits<char8_t>>, ulight::Lang, std::pmr::memory_resource*, ulight::Highlight_Options const&):
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movb %cl, %al
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movb %al, -0x21(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movb $0x0, -0x39(%rbp)
movb -0x21(%rbp), %al
decb %al
movzbl %al, %ecx
movq %rcx, -0xa8(%rbp)
subb $0x5, %al
ja 0x71a8
movq -0xa8(%rbp), %rax
leaq 0x16063(%rip), %rcx # 0x1d070
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0xaa20
movzbl %al, %esi
andl $0x1, %esi
leaq -0x39(%rbp), %rdi
callq 0x7b20
movb %al, -0x1(%rbp)
jmp 0x71ac
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x15030
movzbl %al, %esi
andl $0x1, %esi
leaq -0x39(%rbp), %rdi
callq 0x7b20
movb %al, -0x1(%rbp)
jmp 0x71ac
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0x13f50
movzbl %al, %esi
andl $0x1, %esi
leaq -0x39(%rbp), %rdi
callq 0x7b20
movb %al, -0x1(%rbp)
jmp 0x71ac
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
callq 0x107c0
movzbl %al, %esi
andl $0x1, %esi
leaq -0x39(%rbp), %rdi
callq 0x7b20
movb %al, -0x1(%rbp)
jmp 0x71ac
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
callq 0xe2a0
movzbl %al, %esi
andl $0x1, %esi
leaq -0x39(%rbp), %rdi
callq 0x7b20
movb %al, -0x1(%rbp)
jmp 0x71ac
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
callq 0xa0f0
movzbl %al, %esi
andl $0x1, %esi
leaq -0x39(%rbp), %rdi
callq 0x7b20
movb %al, -0x1(%rbp)
jmp 0x71ac
movb $0x2, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZN6ulight9highlightERNS_17Non_Owning_BufferI12ulight_tokenEESt17basic_string_viewIDuSt11char_traitsIDuEENS_4LangEPNSt3pmr15memory_resourceERKNS_17Highlight_OptionsE:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov al, cl
mov [rbp+var_18], rsi
mov [rbp+var_10], rdx
mov [rbp+var_20], rdi
mov [rbp+var_21], al
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov [rbp+var_39], 0
mov al, [rbp+var_21]
dec al; switch 6 cases
movzx ecx, al
mov [rbp+var_A8], rcx
sub al, 5
ja def_7014; jumptable 0000000000007014 default case
mov rax, [rbp+var_A8]
lea rcx, jpt_7014
movsxd rax, ds:(jpt_7014 - 1D070h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_7016:
mov rdi, [rbp+var_20]; jumptable 0000000000007014 case 2
mov rax, [rbp+var_18]
mov [rbp+var_50], rax
mov rax, [rbp+var_10]
mov [rbp+var_48], rax
mov rcx, [rbp+var_30]
mov r8, [rbp+var_38]
mov rsi, [rbp+var_50]
mov rdx, [rbp+var_48]
call _ZN6ulight13highlight_cppERNS_17Non_Owning_BufferI12ulight_tokenEESt17basic_string_viewIDuSt11char_traitsIDuEEPNSt3pmr15memory_resourceERKNS_17Highlight_OptionsE; ulight::highlight_cpp(ulight::Non_Owning_Buffer<ulight_token> &,std::u8string_view,std::pmr::memory_resource *,ulight::Highlight_Options const&)
movzx esi, al
and esi, 1
lea rdi, [rbp+var_39]
call _ZZN6ulight9highlightERNS_17Non_Owning_BufferI12ulight_tokenEESt17basic_string_viewIDuSt11char_traitsIDuEENS_4LangEPNSt3pmr15memory_resourceERKNS_17Highlight_OptionsEENKUlbE_clEb; ulight::highlight(ulight::Non_Owning_Buffer<ulight_token> &,std::u8string_view,ulight::Lang,std::pmr::memory_resource *,ulight::Highlight_Options const&)::{lambda(bool)#1}::operator()(bool)
mov [rbp+var_1], al
jmp loc_71AC
loc_7056:
mov rdi, [rbp+var_20]; jumptable 0000000000007014 case 1
mov rax, [rbp+var_18]
mov [rbp+var_60], rax
mov rax, [rbp+var_10]
mov [rbp+var_58], rax
mov rcx, [rbp+var_30]
mov r8, [rbp+var_38]
mov rsi, [rbp+var_60]
mov rdx, [rbp+var_58]
call _ZN6ulight14highlight_mmmlERNS_17Non_Owning_BufferI12ulight_tokenEESt17basic_string_viewIDuSt11char_traitsIDuEEPNSt3pmr15memory_resourceERKNS_17Highlight_OptionsE; ulight::highlight_mmml(ulight::Non_Owning_Buffer<ulight_token> &,std::u8string_view,std::pmr::memory_resource *,ulight::Highlight_Options const&)
movzx esi, al
and esi, 1
lea rdi, [rbp+var_39]
call _ZZN6ulight9highlightERNS_17Non_Owning_BufferI12ulight_tokenEESt17basic_string_viewIDuSt11char_traitsIDuEENS_4LangEPNSt3pmr15memory_resourceERKNS_17Highlight_OptionsEENKUlbE_clEb; ulight::highlight(ulight::Non_Owning_Buffer<ulight_token> &,std::u8string_view,ulight::Lang,std::pmr::memory_resource *,ulight::Highlight_Options const&)::{lambda(bool)#1}::operator()(bool)
mov [rbp+var_1], al
jmp loc_71AC
loc_7096:
mov rdi, [rbp+var_20]; jumptable 0000000000007014 case 3
mov rax, [rbp+var_18]
mov [rbp+var_70], rax
mov rax, [rbp+var_10]
mov [rbp+var_68], rax
mov rcx, [rbp+var_30]
mov r8, [rbp+var_38]
mov rsi, [rbp+var_70]
mov rdx, [rbp+var_68]
call _ZN6ulight13highlight_luaERNS_17Non_Owning_BufferI12ulight_tokenEESt17basic_string_viewIDuSt11char_traitsIDuEEPNSt3pmr15memory_resourceERKNS_17Highlight_OptionsE; ulight::highlight_lua(ulight::Non_Owning_Buffer<ulight_token> &,std::u8string_view,std::pmr::memory_resource *,ulight::Highlight_Options const&)
movzx esi, al
and esi, 1
lea rdi, [rbp+var_39]
call _ZZN6ulight9highlightERNS_17Non_Owning_BufferI12ulight_tokenEESt17basic_string_viewIDuSt11char_traitsIDuEENS_4LangEPNSt3pmr15memory_resourceERKNS_17Highlight_OptionsEENKUlbE_clEb; ulight::highlight(ulight::Non_Owning_Buffer<ulight_token> &,std::u8string_view,ulight::Lang,std::pmr::memory_resource *,ulight::Highlight_Options const&)::{lambda(bool)#1}::operator()(bool)
mov [rbp+var_1], al
jmp loc_71AC
loc_70D6:
mov rdi, [rbp+var_20]; jumptable 0000000000007014 case 4
mov rax, [rbp+var_18]
mov [rbp+var_80], rax
mov rax, [rbp+var_10]
mov [rbp+var_78], rax
mov rcx, [rbp+var_30]
mov r8, [rbp+var_38]
mov rsi, [rbp+var_80]
mov rdx, [rbp+var_78]
call _ZN6ulight14highlight_htmlERNS_17Non_Owning_BufferI12ulight_tokenEESt17basic_string_viewIDuSt11char_traitsIDuEEPNSt3pmr15memory_resourceERKNS_17Highlight_OptionsE; ulight::highlight_html(ulight::Non_Owning_Buffer<ulight_token> &,std::u8string_view,std::pmr::memory_resource *,ulight::Highlight_Options const&)
movzx esi, al
and esi, 1
lea rdi, [rbp+var_39]
call _ZZN6ulight9highlightERNS_17Non_Owning_BufferI12ulight_tokenEESt17basic_string_viewIDuSt11char_traitsIDuEENS_4LangEPNSt3pmr15memory_resourceERKNS_17Highlight_OptionsEENKUlbE_clEb; ulight::highlight(ulight::Non_Owning_Buffer<ulight_token> &,std::u8string_view,ulight::Lang,std::pmr::memory_resource *,ulight::Highlight_Options const&)::{lambda(bool)#1}::operator()(bool)
mov [rbp+var_1], al
jmp loc_71AC
loc_7116:
mov rdi, [rbp+var_20]; jumptable 0000000000007014 case 5
mov rax, [rbp+var_18]
mov [rbp+var_90], rax
mov rax, [rbp+var_10]
mov [rbp+var_88], rax
mov rcx, [rbp+var_30]
mov r8, [rbp+var_38]
mov rsi, [rbp+var_90]
mov rdx, [rbp+var_88]
call _ZN6ulight13highlight_cssERNS_17Non_Owning_BufferI12ulight_tokenEESt17basic_string_viewIDuSt11char_traitsIDuEEPNSt3pmr15memory_resourceERKNS_17Highlight_OptionsE; ulight::highlight_css(ulight::Non_Owning_Buffer<ulight_token> &,std::u8string_view,std::pmr::memory_resource *,ulight::Highlight_Options const&)
movzx esi, al
and esi, 1
lea rdi, [rbp+var_39]
call _ZZN6ulight9highlightERNS_17Non_Owning_BufferI12ulight_tokenEESt17basic_string_viewIDuSt11char_traitsIDuEENS_4LangEPNSt3pmr15memory_resourceERKNS_17Highlight_OptionsEENKUlbE_clEb; ulight::highlight(ulight::Non_Owning_Buffer<ulight_token> &,std::u8string_view,ulight::Lang,std::pmr::memory_resource *,ulight::Highlight_Options const&)::{lambda(bool)#1}::operator()(bool)
mov [rbp+var_1], al
jmp short loc_71AC
loc_715F:
mov rdi, [rbp+var_20]; jumptable 0000000000007014 case 6
mov rax, [rbp+var_18]
mov [rbp+var_A0], rax
mov rax, [rbp+var_10]
mov [rbp+var_98], rax
mov rcx, [rbp+var_30]
mov r8, [rbp+var_38]
mov rsi, [rbp+var_A0]
mov rdx, [rbp+var_98]
call _ZN6ulight11highlight_cERNS_17Non_Owning_BufferI12ulight_tokenEESt17basic_string_viewIDuSt11char_traitsIDuEEPNSt3pmr15memory_resourceERKNS_17Highlight_OptionsE; ulight::highlight_c(ulight::Non_Owning_Buffer<ulight_token> &,std::u8string_view,std::pmr::memory_resource *,ulight::Highlight_Options const&)
movzx esi, al
and esi, 1
lea rdi, [rbp+var_39]
call _ZZN6ulight9highlightERNS_17Non_Owning_BufferI12ulight_tokenEESt17basic_string_viewIDuSt11char_traitsIDuEENS_4LangEPNSt3pmr15memory_resourceERKNS_17Highlight_OptionsEENKUlbE_clEb; ulight::highlight(ulight::Non_Owning_Buffer<ulight_token> &,std::u8string_view,ulight::Lang,std::pmr::memory_resource *,ulight::Highlight_Options const&)::{lambda(bool)#1}::operator()(bool)
mov [rbp+var_1], al
jmp short loc_71AC
def_7014:
mov [rbp+var_1], 2; jumptable 0000000000007014 default case
loc_71AC:
mov al, [rbp+var_1]
add rsp, 0B0h
pop rbp
retn
| char ulight::highlight(long long a1, long long a2, long long a3, char a4, long long a5, long long a6)
{
char v6; // al
char v7; // al
char v8; // al
char v9; // al
char v10; // al
char v11; // al
char v13; // [rsp+77h] [rbp-39h] BYREF
long long v14; // [rsp+78h] [rbp-38h]
long long v15; // [rsp+80h] [rbp-30h]
char v16; // [rsp+8Fh] [rbp-21h]
long long v17; // [rsp+90h] [rbp-20h]
long long v18; // [rsp+98h] [rbp-18h]
long long v19; // [rsp+A0h] [rbp-10h]
char v20; // [rsp+AFh] [rbp-1h]
v18 = a2;
v19 = a3;
v17 = a1;
v16 = a4;
v15 = a5;
v14 = a6;
v13 = 0;
switch ( a4 )
{
case 1:
v7 = ulight::highlight_mmml(v17, v18, v19, v15, v14);
v20 = ulight::highlight(ulight::Non_Owning_Buffer<ulight_token> &,std::u8string_view,ulight::Lang,std::pmr::memory_resource *,ulight::Highlight_Options const&)::{lambda(bool)#1}::operator()(
&v13,
v7 & 1);
break;
case 2:
v6 = ulight::highlight_cpp(v17, v18, v19, v15, v14);
v20 = ulight::highlight(ulight::Non_Owning_Buffer<ulight_token> &,std::u8string_view,ulight::Lang,std::pmr::memory_resource *,ulight::Highlight_Options const&)::{lambda(bool)#1}::operator()(
&v13,
v6 & 1);
break;
case 3:
v8 = ulight::highlight_lua(v17, v18, v19, v15, v14);
v20 = ulight::highlight(ulight::Non_Owning_Buffer<ulight_token> &,std::u8string_view,ulight::Lang,std::pmr::memory_resource *,ulight::Highlight_Options const&)::{lambda(bool)#1}::operator()(
&v13,
v8 & 1);
break;
case 4:
v9 = ulight::highlight_html(v17, v18, v19, v15, v14);
v20 = ulight::highlight(ulight::Non_Owning_Buffer<ulight_token> &,std::u8string_view,ulight::Lang,std::pmr::memory_resource *,ulight::Highlight_Options const&)::{lambda(bool)#1}::operator()(
&v13,
v9 & 1);
break;
case 5:
v10 = ulight::highlight_css(v17, v18, v19, v15, v14);
v20 = ulight::highlight(ulight::Non_Owning_Buffer<ulight_token> &,std::u8string_view,ulight::Lang,std::pmr::memory_resource *,ulight::Highlight_Options const&)::{lambda(bool)#1}::operator()(
&v13,
v10 & 1);
break;
case 6:
v11 = ulight::highlight_c(v17, v18, v19, v15, v14);
v20 = ulight::highlight(ulight::Non_Owning_Buffer<ulight_token> &,std::u8string_view,ulight::Lang,std::pmr::memory_resource *,ulight::Highlight_Options const&)::{lambda(bool)#1}::operator()(
&v13,
v11 & 1);
break;
default:
v20 = 2;
break;
}
return v20;
}
| highlight:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV AL,CL
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x10],RDX
MOV qword ptr [RBP + -0x20],RDI
MOV byte ptr [RBP + -0x21],AL
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV byte ptr [RBP + -0x39],0x0
MOV AL,byte ptr [RBP + -0x21]
DEC AL
MOVZX ECX,AL
MOV qword ptr [RBP + -0xa8],RCX
SUB AL,0x5
JA 0x001071a8
MOV RAX,qword ptr [RBP + -0xa8]
LEA RCX,[0x11d070]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_2:
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x48],RAX
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x48]
CALL 0x0010aa20
MOVZX ESI,AL
AND ESI,0x1
LEA RDI,[RBP + -0x39]
CALL 0x00107b20
MOV byte ptr [RBP + -0x1],AL
JMP 0x001071ac
caseD_1:
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x58],RAX
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x60]
MOV RDX,qword ptr [RBP + -0x58]
CALL 0x00115030
MOVZX ESI,AL
AND ESI,0x1
LEA RDI,[RBP + -0x39]
CALL 0x00107b20
MOV byte ptr [RBP + -0x1],AL
JMP 0x001071ac
caseD_3:
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x68],RAX
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x70]
MOV RDX,qword ptr [RBP + -0x68]
CALL 0x00113f50
MOVZX ESI,AL
AND ESI,0x1
LEA RDI,[RBP + -0x39]
CALL 0x00107b20
MOV byte ptr [RBP + -0x1],AL
JMP 0x001071ac
caseD_4:
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x78],RAX
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x80]
MOV RDX,qword ptr [RBP + -0x78]
CALL 0x001107c0
MOVZX ESI,AL
AND ESI,0x1
LEA RDI,[RBP + -0x39]
CALL 0x00107b20
MOV byte ptr [RBP + -0x1],AL
JMP 0x001071ac
caseD_5:
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x90],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x88],RAX
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x90]
MOV RDX,qword ptr [RBP + -0x88]
CALL 0x0010e2a0
MOVZX ESI,AL
AND ESI,0x1
LEA RDI,[RBP + -0x39]
CALL 0x00107b20
MOV byte ptr [RBP + -0x1],AL
JMP 0x001071ac
caseD_6:
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0xa0],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x98],RAX
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0xa0]
MOV RDX,qword ptr [RBP + -0x98]
CALL 0x0010a0f0
MOVZX ESI,AL
AND ESI,0x1
LEA RDI,[RBP + -0x39]
CALL 0x00107b20
MOV byte ptr [RBP + -0x1],AL
JMP 0x001071ac
default:
MOV byte ptr [RBP + -0x1],0x2
LAB_001071ac:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0xb0
POP RBP
RET
|
/* ulight::highlight(ulight::Non_Owning_Buffer<ulight_token>&, std::basic_string_view<char8_t,
std::char_traits<char8_t> >, ulight::Lang, std::pmr::memory_resource*, ulight::Highlight_Options
const&) */
int8 __thiscall
ulight::highlight(ulight *this,int8 param_1,int8 param_3,int1 param_4,
int8 param_5,int8 param_6)
{
int1 extraout_AL;
int1 extraout_AL_00;
int1 extraout_AL_01;
int1 extraout_AL_02;
int1 extraout_AL_03;
byte bVar1;
int1 extraout_AL_04;
int8 in_RAX;
int7 uVar2;
int7 extraout_var;
int7 extraout_var_00;
int7 extraout_var_01;
int7 extraout_var_02;
int7 extraout_var_03;
int7 extraout_var_04;
_lambda_bool__1_ local_41;
int8 local_40;
int8 local_38;
int1 local_29;
ulight *local_28;
int8 local_20;
int8 local_18;
int1 local_9;
uVar2 = (int7)((ulong)in_RAX >> 8);
local_41 = (_lambda_bool__1_)0x0;
local_40 = param_6;
local_38 = param_5;
local_29 = param_4;
local_28 = this;
local_20 = param_1;
local_18 = param_3;
switch(param_4) {
case 1:
bVar1 = highlight_mmml(this,param_1,param_3,param_5,param_6);
highlight(ulight::Non_Owning_Buffer<ulight_token>&,std::basic_string_view<char8_t,std::char_traits<char8_t>>,ulight::Lang,std::pmr::memory_resource*,ulight::Highlight_Options_const&)
::{lambda(bool)#1}::operator()(&local_41,(bool)(bVar1 & 1));
uVar2 = extraout_var_00;
local_9 = extraout_AL_00;
break;
case 2:
bVar1 = highlight_cpp(this,param_1,param_3,param_5,param_6);
highlight(ulight::Non_Owning_Buffer<ulight_token>&,std::basic_string_view<char8_t,std::char_traits<char8_t>>,ulight::Lang,std::pmr::memory_resource*,ulight::Highlight_Options_const&)
::{lambda(bool)#1}::operator()(&local_41,(bool)(bVar1 & 1));
uVar2 = extraout_var;
local_9 = extraout_AL;
break;
case 3:
bVar1 = highlight_lua(this,param_1,param_3,param_5,param_6);
highlight(ulight::Non_Owning_Buffer<ulight_token>&,std::basic_string_view<char8_t,std::char_traits<char8_t>>,ulight::Lang,std::pmr::memory_resource*,ulight::Highlight_Options_const&)
::{lambda(bool)#1}::operator()(&local_41,(bool)(bVar1 & 1));
uVar2 = extraout_var_01;
local_9 = extraout_AL_01;
break;
case 4:
bVar1 = highlight_html(this,param_1,param_3,param_5,param_6);
highlight(ulight::Non_Owning_Buffer<ulight_token>&,std::basic_string_view<char8_t,std::char_traits<char8_t>>,ulight::Lang,std::pmr::memory_resource*,ulight::Highlight_Options_const&)
::{lambda(bool)#1}::operator()(&local_41,(bool)(bVar1 & 1));
uVar2 = extraout_var_02;
local_9 = extraout_AL_02;
break;
case 5:
bVar1 = highlight_css(this,param_1,param_3,param_5,param_6);
highlight(ulight::Non_Owning_Buffer<ulight_token>&,std::basic_string_view<char8_t,std::char_traits<char8_t>>,ulight::Lang,std::pmr::memory_resource*,ulight::Highlight_Options_const&)
::{lambda(bool)#1}::operator()(&local_41,(bool)(bVar1 & 1));
uVar2 = extraout_var_03;
local_9 = extraout_AL_03;
break;
case 6:
bVar1 = highlight_c(this,param_1,param_3,param_5,param_6);
highlight(ulight::Non_Owning_Buffer<ulight_token>&,std::basic_string_view<char8_t,std::char_traits<char8_t>>,ulight::Lang,std::pmr::memory_resource*,ulight::Highlight_Options_const&)
::{lambda(bool)#1}::operator()(&local_41,(bool)(bVar1 & 1));
uVar2 = extraout_var_04;
local_9 = extraout_AL_04;
break;
default:
local_9 = 2;
}
return CONCAT71(uVar2,local_9);
}
| |
25,087 | parse_connection_string | eloqsql/libmariadb/libmariadb/mariadb_lib.c | static int parse_connection_string(MYSQL *mysql, const char *unused __attribute__((unused)),
const char *conn_str, ssize_t len)
{
char *conn_save,
*end, *pos,
*key= NULL, *val= NULL;
my_bool in_curly_brace= 0;
if (len == -1)
len= strlen(conn_str);
/* don't modify original dsn */
conn_save= (char *)malloc(len + 1);
memcpy(conn_save, conn_str, len);
conn_save[len]= 0;
/* start and end */
pos= conn_save;
end= conn_save + len;
while (pos <= end)
{
/* ignore white space, unless it is between curly braces */
if (isspace(*pos) && !in_curly_brace)
{
pos++;
continue;
}
switch (*pos) {
case '{':
if (!key)
goto error;
if (!in_curly_brace)
{
in_curly_brace= 1;
if (pos < end)
{
pos++;
val= pos;
continue;
}
}
break;
case '}':
if (in_curly_brace)
{
if (!key)
goto error;
if (pos < end && *(pos + 1) == '}')
{
memmove(pos, pos + 1, end - pos - 1);
end--;
pos += 2;
continue;
}
if (in_curly_brace)
in_curly_brace= 0;
else
goto error;
*pos++= 0;
continue;
}
break;
case '=':
if (in_curly_brace)
{
pos++;
continue;
}
if (!key)
goto error;
*pos++= 0;
if (pos < end)
val= pos;
continue;
break;
case ';':
if (in_curly_brace)
{
pos++;
continue;
}
if (!key)
goto error;
*pos++= 0;
if (key && strcasecmp(key, "connection") != 0)
_mariadb_set_conf_option(mysql, key, val);
key= val= NULL;
continue;
break;
}
if (!key && *pos)
key= pos;
pos++;
}
if (key && strcasecmp(key, "connection") != 0)
_mariadb_set_conf_option(mysql, key, val);
free(conn_save);
return 0;
error:
my_set_error(mysql, CR_CONNSTR_PARSE_ERROR, SQLSTATE_UNKNOWN, 0, pos - conn_save);
free(conn_save);
return 1;
} | O0 | c | parse_connection_string:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movb $0x0, -0x51(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x17ea0
movq -0x20(%rbp), %rdi
callq 0x131a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
callq 0x135b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x13360
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
ja 0x18124
callq 0x13470
movq (%rax), %rax
movq -0x40(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax # imm = 0x2000
cmpl $0x0, %eax
je 0x17f24
cmpb $0x0, -0x51(%rbp)
jne 0x17f24
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x17ee2
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x58(%rbp)
subl $0x3b, %eax
je 0x18081
jmp 0x17f39
movl -0x58(%rbp), %eax
subl $0x3d, %eax
je 0x18035
jmp 0x17f47
movl -0x58(%rbp), %eax
subl $0x7b, %eax
je 0x17f5e
jmp 0x17f51
movl -0x58(%rbp), %eax
subl $0x7d, %eax
je 0x17f9e
jmp 0x180f8
cmpq $0x0, -0x48(%rbp)
jne 0x17f6a
jmp 0x18163
cmpb $0x0, -0x51(%rbp)
jne 0x17f99
movb $0x1, -0x51(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x17f97
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x17ee2
jmp 0x17f99
jmp 0x180f8
cmpb $0x0, -0x51(%rbp)
je 0x18030
cmpq $0x0, -0x48(%rbp)
jne 0x17fb4
jmp 0x18163
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x18008
movq -0x40(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x7d, %eax
jne 0x18008
movq -0x40(%rbp), %rdi
movq -0x40(%rbp), %rsi
addq $0x1, %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rax
subq %rax, %rdx
subq $0x1, %rdx
callq 0x136f0
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x40(%rbp)
jmp 0x17ee2
cmpb $0x0, -0x51(%rbp)
je 0x18014
movb $0x0, -0x51(%rbp)
jmp 0x18019
jmp 0x18163
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x40(%rbp)
movb $0x0, (%rax)
jmp 0x17ee2
jmp 0x180f8
cmpb $0x0, -0x51(%rbp)
je 0x1804c
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x17ee2
cmpq $0x0, -0x48(%rbp)
jne 0x18058
jmp 0x18163
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x40(%rbp)
movb $0x0, (%rax)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x1807c
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x17ee2
cmpb $0x0, -0x51(%rbp)
je 0x18098
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x17ee2
cmpq $0x0, -0x48(%rbp)
jne 0x180a4
jmp 0x18163
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x40(%rbp)
movb $0x0, (%rax)
cmpq $0x0, -0x48(%rbp)
je 0x180e3
movq -0x48(%rbp), %rdi
leaq 0x34b68(%rip), %rsi # 0x4cc30
callq 0x13480
cmpl $0x0, %eax
je 0x180e3
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x181b0
movq $0x0, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
jmp 0x17ee2
cmpq $0x0, -0x48(%rbp)
jne 0x18113
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x18113
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x17ee2
cmpq $0x0, -0x48(%rbp)
je 0x18151
movq -0x48(%rbp), %rdi
leaq 0x34afa(%rip), %rsi # 0x4cc30
callq 0x13480
cmpl $0x0, %eax
je 0x18151
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x181b0
movq -0x30(%rbp), %rdi
callq 0x13520
movl $0x0, -0x4(%rbp)
jmp 0x1819c
movq -0x10(%rbp), %rdi
leaq 0x48d72(%rip), %rax # 0x60ee0
movq (%rax), %rdx
movq -0x40(%rbp), %r8
movq -0x30(%rbp), %rax
subq %rax, %r8
movl $0x1393, %esi # imm = 0x1393
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x16c80
movq -0x30(%rbp), %rdi
callq 0x13520
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| parse_connection_string:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_48], 0
mov [rbp+var_50], 0
mov [rbp+var_51], 0
cmp [rbp+var_28], 0FFFFFFFFFFFFFFFFh
jnz short loc_17EA0
mov rdi, [rbp+var_20]
call _strlen
mov [rbp+var_28], rax
loc_17EA0:
mov rdi, [rbp+var_28]
add rdi, 1
call _malloc
mov [rbp+var_30], rax
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
call _memcpy
mov rax, [rbp+var_30]
mov rcx, [rbp+var_28]
mov byte ptr [rax+rcx], 0
mov rax, [rbp+var_30]
mov [rbp+var_40], rax
mov rax, [rbp+var_30]
add rax, [rbp+var_28]
mov [rbp+var_38], rax
loc_17EE2:
mov rax, [rbp+var_40]
cmp rax, [rbp+var_38]
ja loc_18124
call ___ctype_b_loc
mov rax, [rax]
mov rcx, [rbp+var_40]
movsx ecx, byte ptr [rcx]
movsxd rcx, ecx
movzx eax, word ptr [rax+rcx*2]
and eax, 2000h
cmp eax, 0
jz short loc_17F24
cmp [rbp+var_51], 0
jnz short loc_17F24
mov rax, [rbp+var_40]
add rax, 1
mov [rbp+var_40], rax
jmp short loc_17EE2
loc_17F24:
mov rax, [rbp+var_40]
movsx eax, byte ptr [rax]
mov [rbp+var_58], eax
sub eax, 3Bh ; ';'
jz loc_18081
jmp short $+2
loc_17F39:
mov eax, [rbp+var_58]
sub eax, 3Dh ; '='
jz loc_18035
jmp short $+2
loc_17F47:
mov eax, [rbp+var_58]
sub eax, 7Bh ; '{'
jz short loc_17F5E
jmp short $+2
loc_17F51:
mov eax, [rbp+var_58]
sub eax, 7Dh ; '}'
jz short loc_17F9E
jmp loc_180F8
loc_17F5E:
cmp [rbp+var_48], 0
jnz short loc_17F6A
jmp loc_18163
loc_17F6A:
cmp [rbp+var_51], 0
jnz short loc_17F99
mov [rbp+var_51], 1
mov rax, [rbp+var_40]
cmp rax, [rbp+var_38]
jnb short loc_17F97
mov rax, [rbp+var_40]
add rax, 1
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov [rbp+var_50], rax
jmp loc_17EE2
loc_17F97:
jmp short $+2
loc_17F99:
jmp loc_180F8
loc_17F9E:
cmp [rbp+var_51], 0
jz loc_18030
cmp [rbp+var_48], 0
jnz short loc_17FB4
jmp loc_18163
loc_17FB4:
mov rax, [rbp+var_40]
cmp rax, [rbp+var_38]
jnb short loc_18008
mov rax, [rbp+var_40]
movsx eax, byte ptr [rax+1]
cmp eax, 7Dh ; '}'
jnz short loc_18008
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_40]
add rsi, 1
mov rdx, [rbp+var_38]
mov rax, [rbp+var_40]
sub rdx, rax
sub rdx, 1
call _memmove
mov rax, [rbp+var_38]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_38], rax
mov rax, [rbp+var_40]
add rax, 2
mov [rbp+var_40], rax
jmp loc_17EE2
loc_18008:
cmp [rbp+var_51], 0
jz short loc_18014
mov [rbp+var_51], 0
jmp short loc_18019
loc_18014:
jmp loc_18163
loc_18019:
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 1
mov [rbp+var_40], rcx
mov byte ptr [rax], 0
jmp loc_17EE2
loc_18030:
jmp loc_180F8
loc_18035:
cmp [rbp+var_51], 0
jz short loc_1804C
mov rax, [rbp+var_40]
add rax, 1
mov [rbp+var_40], rax
jmp loc_17EE2
loc_1804C:
cmp [rbp+var_48], 0
jnz short loc_18058
jmp loc_18163
loc_18058:
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 1
mov [rbp+var_40], rcx
mov byte ptr [rax], 0
mov rax, [rbp+var_40]
cmp rax, [rbp+var_38]
jnb short loc_1807C
mov rax, [rbp+var_40]
mov [rbp+var_50], rax
loc_1807C:
jmp loc_17EE2
loc_18081:
cmp [rbp+var_51], 0
jz short loc_18098
mov rax, [rbp+var_40]
add rax, 1
mov [rbp+var_40], rax
jmp loc_17EE2
loc_18098:
cmp [rbp+var_48], 0
jnz short loc_180A4
jmp loc_18163
loc_180A4:
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 1
mov [rbp+var_40], rcx
mov byte ptr [rax], 0
cmp [rbp+var_48], 0
jz short loc_180E3
mov rdi, [rbp+var_48]
lea rsi, aConnection; "connection"
call _strcasecmp
cmp eax, 0
jz short loc_180E3
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_48]
mov rdx, [rbp+var_50]
call _mariadb_set_conf_option
loc_180E3:
mov [rbp+var_50], 0
mov [rbp+var_48], 0
jmp loc_17EE2
loc_180F8:
cmp [rbp+var_48], 0
jnz short loc_18113
mov rax, [rbp+var_40]
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_18113
mov rax, [rbp+var_40]
mov [rbp+var_48], rax
loc_18113:
mov rax, [rbp+var_40]
add rax, 1
mov [rbp+var_40], rax
jmp loc_17EE2
loc_18124:
cmp [rbp+var_48], 0
jz short loc_18151
mov rdi, [rbp+var_48]
lea rsi, aConnection; "connection"
call _strcasecmp
cmp eax, 0
jz short loc_18151
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_48]
mov rdx, [rbp+var_50]
call _mariadb_set_conf_option
loc_18151:
mov rdi, [rbp+var_30]
call _free
mov [rbp+var_4], 0
jmp short loc_1819C
loc_18163:
mov rdi, [rbp+var_10]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov r8, [rbp+var_40]
mov rax, [rbp+var_30]
sub r8, rax
mov esi, 1393h
xor eax, eax
mov ecx, eax
mov al, 0
call my_set_error
mov rdi, [rbp+var_30]
call _free
mov [rbp+var_4], 1
loc_1819C:
mov eax, [rbp+var_4]
add rsp, 60h
pop rbp
retn
| long long parse_connection_string(long long a1, long long a2, long long a3, long long a4)
{
char *v4; // rax
char *v5; // rax
char *v6; // rax
int v8; // [rsp+8h] [rbp-58h]
char v9; // [rsp+Fh] [rbp-51h]
char *v10; // [rsp+10h] [rbp-50h]
char *v11; // [rsp+18h] [rbp-48h]
char *v12; // [rsp+20h] [rbp-40h]
unsigned long long v13; // [rsp+28h] [rbp-38h]
long long v14; // [rsp+30h] [rbp-30h]
long long v15; // [rsp+38h] [rbp-28h]
v15 = a4;
v11 = 0LL;
v10 = 0LL;
v9 = 0;
if ( a4 == -1 )
v15 = strlen(a3);
v14 = malloc(v15 + 1);
memcpy(v14, a3, v15);
*(_BYTE *)(v14 + v15) = 0;
v12 = (char *)v14;
v13 = v15 + v14;
while ( (unsigned long long)v12 <= v13 )
{
if ( (*(_WORD *)(*(_QWORD *)__ctype_b_loc() + 2LL * *v12) & 0x2000) == 0 || v9 )
{
v8 = *v12;
switch ( v8 )
{
case ';':
if ( v9 )
{
++v12;
}
else
{
if ( !v11 )
{
LABEL_45:
my_set_error(a1, 0x1393u, (long long)SQLSTATE_UNKNOWN, 0LL, &v12[-v14]);
free(v14);
return 1;
}
v6 = v12++;
*v6 = 0;
if ( (unsigned int)strcasecmp(v11, "connection") )
mariadb_set_conf_option(a1, v11, v10);
v10 = 0LL;
v11 = 0LL;
}
break;
case '=':
if ( v9 )
{
++v12;
}
else
{
if ( !v11 )
goto LABEL_45;
v5 = v12++;
*v5 = 0;
if ( (unsigned long long)v12 < v13 )
v10 = v12;
}
break;
case '{':
if ( !v11 )
goto LABEL_45;
if ( v9 || (v9 = 1, (unsigned long long)v12 >= v13) )
{
LABEL_37:
if ( !v11 )
{
if ( *v12 )
v11 = v12;
}
++v12;
}
else
{
v10 = ++v12;
}
break;
default:
if ( v8 != 125 || !v9 )
goto LABEL_37;
if ( !v11 )
goto LABEL_45;
if ( (unsigned long long)v12 < v13 && v12[1] == 125 )
{
memmove(v12, v12 + 1, v13 - (_QWORD)v12 - 1);
--v13;
v12 += 2;
}
else
{
v9 = 0;
v4 = v12++;
*v4 = 0;
}
break;
}
}
else
{
++v12;
}
}
if ( v11 && (unsigned int)strcasecmp(v11, "connection") )
mariadb_set_conf_option(a1, v11, v10);
free(v14);
return 0;
}
| parse_connection_string:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x48],0x0
MOV qword ptr [RBP + -0x50],0x0
MOV byte ptr [RBP + -0x51],0x0
CMP qword ptr [RBP + -0x28],-0x1
JNZ 0x00117ea0
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001131a0
MOV qword ptr [RBP + -0x28],RAX
LAB_00117ea0:
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x1
CALL 0x001135b0
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x00113360
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x38],RAX
LAB_00117ee2:
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x38]
JA 0x00118124
CALL 0x00113470
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x40]
MOVSX ECX,byte ptr [RCX]
MOVSXD RCX,ECX
MOVZX EAX,word ptr [RAX + RCX*0x2]
AND EAX,0x2000
CMP EAX,0x0
JZ 0x00117f24
CMP byte ptr [RBP + -0x51],0x0
JNZ 0x00117f24
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00117ee2
LAB_00117f24:
MOV RAX,qword ptr [RBP + -0x40]
MOVSX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x58],EAX
SUB EAX,0x3b
JZ 0x00118081
JMP 0x00117f39
LAB_00117f39:
MOV EAX,dword ptr [RBP + -0x58]
SUB EAX,0x3d
JZ 0x00118035
JMP 0x00117f47
LAB_00117f47:
MOV EAX,dword ptr [RBP + -0x58]
SUB EAX,0x7b
JZ 0x00117f5e
JMP 0x00117f51
LAB_00117f51:
MOV EAX,dword ptr [RBP + -0x58]
SUB EAX,0x7d
JZ 0x00117f9e
JMP 0x001180f8
LAB_00117f5e:
CMP qword ptr [RBP + -0x48],0x0
JNZ 0x00117f6a
JMP 0x00118163
LAB_00117f6a:
CMP byte ptr [RBP + -0x51],0x0
JNZ 0x00117f99
MOV byte ptr [RBP + -0x51],0x1
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x38]
JNC 0x00117f97
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00117ee2
LAB_00117f97:
JMP 0x00117f99
LAB_00117f99:
JMP 0x001180f8
LAB_00117f9e:
CMP byte ptr [RBP + -0x51],0x0
JZ 0x00118030
CMP qword ptr [RBP + -0x48],0x0
JNZ 0x00117fb4
JMP 0x00118163
LAB_00117fb4:
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x38]
JNC 0x00118008
MOV RAX,qword ptr [RBP + -0x40]
MOVSX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x7d
JNZ 0x00118008
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x40]
ADD RSI,0x1
MOV RDX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x40]
SUB RDX,RAX
SUB RDX,0x1
CALL 0x001136f0
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x2
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00117ee2
LAB_00118008:
CMP byte ptr [RBP + -0x51],0x0
JZ 0x00118014
MOV byte ptr [RBP + -0x51],0x0
JMP 0x00118019
LAB_00118014:
JMP 0x00118163
LAB_00118019:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x40],RCX
MOV byte ptr [RAX],0x0
JMP 0x00117ee2
LAB_00118030:
JMP 0x001180f8
LAB_00118035:
CMP byte ptr [RBP + -0x51],0x0
JZ 0x0011804c
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00117ee2
LAB_0011804c:
CMP qword ptr [RBP + -0x48],0x0
JNZ 0x00118058
JMP 0x00118163
LAB_00118058:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x40],RCX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x38]
JNC 0x0011807c
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x50],RAX
LAB_0011807c:
JMP 0x00117ee2
LAB_00118081:
CMP byte ptr [RBP + -0x51],0x0
JZ 0x00118098
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00117ee2
LAB_00118098:
CMP qword ptr [RBP + -0x48],0x0
JNZ 0x001180a4
JMP 0x00118163
LAB_001180a4:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x40],RCX
MOV byte ptr [RAX],0x0
CMP qword ptr [RBP + -0x48],0x0
JZ 0x001180e3
MOV RDI,qword ptr [RBP + -0x48]
LEA RSI,[0x14cc30]
CALL 0x00113480
CMP EAX,0x0
JZ 0x001180e3
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x50]
CALL 0x001181b0
LAB_001180e3:
MOV qword ptr [RBP + -0x50],0x0
MOV qword ptr [RBP + -0x48],0x0
JMP 0x00117ee2
LAB_001180f8:
CMP qword ptr [RBP + -0x48],0x0
JNZ 0x00118113
MOV RAX,qword ptr [RBP + -0x40]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x00118113
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x48],RAX
LAB_00118113:
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00117ee2
LAB_00118124:
CMP qword ptr [RBP + -0x48],0x0
JZ 0x00118151
MOV RDI,qword ptr [RBP + -0x48]
LEA RSI,[0x14cc30]
CALL 0x00113480
CMP EAX,0x0
JZ 0x00118151
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x50]
CALL 0x001181b0
LAB_00118151:
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00113520
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0011819c
LAB_00118163:
MOV RDI,qword ptr [RBP + -0x10]
LEA RAX,[0x160ee0]
MOV RDX,qword ptr [RAX]
MOV R8,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x30]
SUB R8,RAX
MOV ESI,0x1393
XOR EAX,EAX
MOV ECX,EAX
MOV AL,0x0
CALL 0x00116c80
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00113520
MOV dword ptr [RBP + -0x4],0x1
LAB_0011819c:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x60
POP RBP
RET
|
int4
parse_connection_string(int8 param_1,int8 param_2,char *param_3,size_t param_4)
{
char cVar1;
bool bVar2;
int iVar3;
char *__dest;
ushort **ppuVar4;
char *pcVar5;
char *local_58;
char *local_50;
char *local_48;
char *local_40;
size_t local_30;
local_50 = (char *)0x0;
local_58 = (char *)0x0;
bVar2 = false;
local_30 = param_4;
if (param_4 == 0xffffffffffffffff) {
local_30 = strlen(param_3);
}
__dest = (char *)malloc(local_30 + 1);
memcpy(__dest,param_3,local_30);
__dest[local_30] = '\0';
local_40 = __dest + local_30;
local_48 = __dest;
LAB_00117ee2:
while( true ) {
while( true ) {
if (local_40 < local_48) {
if ((local_50 != (char *)0x0) && (iVar3 = strcasecmp(local_50,"connection"), iVar3 != 0)) {
_mariadb_set_conf_option(param_1,local_50,local_58);
}
free(__dest);
return 0;
}
ppuVar4 = __ctype_b_loc();
if ((((*ppuVar4)[(int)*local_48] & 0x2000) == 0) || (bVar2)) break;
local_48 = local_48 + 1;
}
cVar1 = *local_48;
if (cVar1 != ';') break;
if (bVar2) {
local_48 = local_48 + 1;
}
else {
if (local_50 == (char *)0x0) goto LAB_00118163;
*local_48 = '\0';
if ((local_50 != (char *)0x0) && (iVar3 = strcasecmp(local_50,"connection"), iVar3 != 0)) {
_mariadb_set_conf_option(param_1,local_50,local_58);
}
local_58 = (char *)0x0;
local_50 = (char *)0x0;
local_48 = local_48 + 1;
}
}
if (cVar1 == '=') {
if (bVar2) {
local_48 = local_48 + 1;
goto LAB_00117ee2;
}
if (local_50 != (char *)0x0) {
pcVar5 = local_48 + 1;
*local_48 = '\0';
local_48 = pcVar5;
if (pcVar5 < local_40) {
local_58 = pcVar5;
}
goto LAB_00117ee2;
}
LAB_00118163:
my_set_error(param_1,0x1393,SQLSTATE_UNKNOWN,0,(long)local_48 - (long)__dest);
free(__dest);
return 1;
}
if (cVar1 == '{') {
if (local_50 == (char *)0x0) goto LAB_00118163;
if ((!bVar2) && (bVar2 = true, local_48 < local_40)) {
local_58 = local_48 + 1;
local_48 = local_48 + 1;
goto LAB_00117ee2;
}
}
else if ((cVar1 == '}') && (bVar2)) {
if (local_50 == (char *)0x0) goto LAB_00118163;
if ((local_48 < local_40) && (local_48[1] == '}')) {
memmove(local_48,local_48 + 1,(size_t)(local_40 + (-1 - (long)local_48)));
local_40 = local_40 + -1;
local_48 = local_48 + 2;
goto LAB_00117ee2;
}
if (bVar2) {
bVar2 = false;
*local_48 = '\0';
local_48 = local_48 + 1;
goto LAB_00117ee2;
}
goto LAB_00118163;
}
if ((local_50 == (char *)0x0) && (*local_48 != '\0')) {
local_50 = local_48;
}
local_48 = local_48 + 1;
goto LAB_00117ee2;
}
| |
25,088 | testing::internal::FormatCxxExceptionMessage[abi:cxx11](char const*, char const*) | giladroyz[P]FindPeaks/build_O3/_deps/googletest-src/googletest/src/gtest.cc | static std::string FormatCxxExceptionMessage(const char* description,
const char* location) {
Message message;
if (description != nullptr) {
message << "C++ exception with description \"" << description << "\"";
} else {
message << "Unknown C++ exception";
}
message << " thrown in " << location << ".";
return message.GetString();
} | O3 | cpp | testing::internal::FormatCxxExceptionMessage[abi:cxx11](char const*, char const*):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1c968
movq (%rbx), %rbx
leaq 0x10(%rbx), %r15
testq %r13, %r13
je 0x308ee
leaq 0x13f28(%rip), %rsi # 0x447e5
movl $0x20, %edx
movq %r15, %rdi
callq 0x85b0
movq %r13, %rdi
callq 0x8200
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x85b0
movl $0x1, %edx
leaq 0x12e9f(%rip), %rsi # 0x4378b
jmp 0x308fa
movl $0x15, %edx
leaq 0x13f0c(%rip), %rsi # 0x44806
movq %r15, %rdi
callq 0x85b0
leaq 0x13f13(%rip), %rsi # 0x4481c
movl $0xb, %edx
movq %r15, %rdi
callq 0x85b0
testq %r12, %r12
je 0x30928
movq %r12, %rdi
callq 0x8200
movq %rax, %rdx
jmp 0x30934
movl $0x6, %edx
leaq 0xfd25(%rip), %r12 # 0x40659
movq %r15, %rdi
movq %r12, %rsi
callq 0x85b0
leaq 0x12dcb(%rip), %rsi # 0x43711
movl $0x1, %edx
movq %r15, %rdi
callq 0x85b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1cbbf
testq %rbx, %rbx
je 0x30979
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *0x8(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3099a
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8990
| _ZN7testing8internalL25FormatCxxExceptionMessageB5cxx11EPKcS2_:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov r12, rdx
mov r13, rsi
mov r14, rdi
lea rbx, [rsp+38h+var_30]
mov rdi, rbx; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
mov rbx, [rbx]
lea r15, [rbx+10h]
test r13, r13
jz short loc_308EE
lea rsi, aCExceptionWith; "C++ exception with description \""
mov edx, 20h ; ' '
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, r13
call _strlen
mov rdi, r15
mov rsi, r13
mov rdx, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov edx, 1
lea rsi, aMessage+0Fh; "\""
jmp short loc_308FA
loc_308EE:
mov edx, 15h
lea rsi, aUnknownCExcept; "Unknown C++ exception"
loc_308FA:
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aThrownIn; " thrown in "
mov edx, 0Bh
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
test r12, r12
jz short loc_30928
mov rdi, r12
call _strlen
mov rdx, rax
jmp short loc_30934
loc_30928:
mov edx, 6
lea r12, aNull; "(null)"
loc_30934:
mov rdi, r15
mov rsi, r12
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, asc_43710+1; "."
mov edx, 1
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, r14
mov rsi, rbx
call _ZN7testing8internal20StringStreamToStringEPNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE; testing::internal::StringStreamToString(std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>> *)
test rbx, rbx
jz short loc_30979
mov rax, [rbx]
mov rdi, rbx
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
jmp qword ptr [rax+8]
loc_30979:
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+arg_0]
test rdi, rdi
jz short loc_3099A
mov rax, [rdi]
call qword ptr [rax+8]
loc_3099A:
mov rdi, rbx
call __Unwind_Resume
| long long testing::internal::FormatCxxExceptionMessage[abi:cxx11](long long a1, long long a2, const char *a3)
{
long long v4; // rbx
long long v5; // rax
long long v6; // rdx
char *v7; // rsi
long long v8; // rdx
long long result; // rax
long long v10[6]; // [rsp+8h] [rbp-30h] BYREF
testing::Message::Message((testing::Message *)v10);
v4 = v10[0];
if ( a2 )
{
std::__ostream_insert<char,std::char_traits<char>>(v10[0] + 16, "C++ exception with description \"", 32LL);
v5 = strlen(a2);
std::__ostream_insert<char,std::char_traits<char>>(v4 + 16, a2, v5);
v6 = 1LL;
v7 = "\"";
}
else
{
v6 = 21LL;
v7 = "Unknown C++ exception";
}
std::__ostream_insert<char,std::char_traits<char>>(v4 + 16, v7, v6);
std::__ostream_insert<char,std::char_traits<char>>(v4 + 16, " thrown in ", 11LL);
if ( a3 )
{
v8 = strlen(a3);
}
else
{
v8 = 6LL;
a3 = "(null)";
}
std::__ostream_insert<char,std::char_traits<char>>(v4 + 16, a3, v8);
std::__ostream_insert<char,std::char_traits<char>>(v4 + 16, ".", 1LL);
result = testing::internal::StringStreamToString(a1, v4);
if ( v4 )
return (*(long long ( **)(long long))(*(_QWORD *)v4 + 8LL))(v4);
return result;
}
| FormatCxxExceptionMessage[abi:cxx11]:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R12,RDX
MOV R13,RSI
MOV R14,RDI
LEA RBX,[RSP + 0x8]
MOV RDI,RBX
CALL 0x0011c968
MOV RBX,qword ptr [RBX]
LEA R15,[RBX + 0x10]
TEST R13,R13
JZ 0x001308ee
LAB_001308b6:
LEA RSI,[0x1447e5]
MOV EDX,0x20
MOV RDI,R15
CALL 0x001085b0
MOV RDI,R13
CALL 0x00108200
MOV RDI,R15
MOV RSI,R13
MOV RDX,RAX
CALL 0x001085b0
MOV EDX,0x1
LEA RSI,[0x14378b]
JMP 0x001308fa
LAB_001308ee:
MOV EDX,0x15
LEA RSI,[0x144806]
LAB_001308fa:
MOV RDI,R15
CALL 0x001085b0
LEA RSI,[0x14481c]
MOV EDX,0xb
MOV RDI,R15
CALL 0x001085b0
TEST R12,R12
JZ 0x00130928
MOV RDI,R12
CALL 0x00108200
MOV RDX,RAX
JMP 0x00130934
LAB_00130928:
MOV EDX,0x6
LEA R12,[0x140659]
LAB_00130934:
MOV RDI,R15
MOV RSI,R12
CALL 0x001085b0
LEA RSI,[0x143711]
MOV EDX,0x1
MOV RDI,R15
CALL 0x001085b0
MOV RDI,R14
MOV RSI,RBX
CALL 0x0011cbbf
LAB_0013095e:
TEST RBX,RBX
JZ 0x00130979
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
JMP qword ptr [RAX + 0x8]
LAB_00130979:
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* testing::internal::FormatCxxExceptionMessage[abi:cxx11](char const*, char const*) */
void __thiscall
testing::internal::FormatCxxExceptionMessage_abi_cxx11_(internal *this,char *param_1,char *param_2)
{
ostream *poVar1;
size_t sVar2;
long lVar3;
char *pcVar4;
long *local_30;
Message::Message((Message *)&local_30);
poVar1 = (ostream *)(local_30 + 2);
if (param_1 == (char *)0x0) {
lVar3 = 0x15;
pcVar4 = "Unknown C++ exception";
}
else {
/* try { // try from 001308b6 to 0013095d has its CatchHandler @ 00130987 */
std::__ostream_insert<char,std::char_traits<char>>
(poVar1,"C++ exception with description \"",0x20);
sVar2 = strlen(param_1);
std::__ostream_insert<char,std::char_traits<char>>(poVar1,param_1,sVar2);
lVar3 = 1;
pcVar4 = "\"";
}
std::__ostream_insert<char,std::char_traits<char>>(poVar1,pcVar4,lVar3);
std::__ostream_insert<char,std::char_traits<char>>(poVar1," thrown in ",0xb);
if (param_2 == (char *)0x0) {
sVar2 = 6;
param_2 = "(null)";
}
else {
sVar2 = strlen(param_2);
}
std::__ostream_insert<char,std::char_traits<char>>(poVar1,param_2,sVar2);
std::__ostream_insert<char,std::char_traits<char>>(poVar1,".",1);
StringStreamToString((stringstream *)this);
if (local_30 != (long *)0x0) {
/* WARNING: Could not recover jumptable at 0x00130976. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(*local_30 + 8))(local_30);
return;
}
return;
}
| |
25,089 | aimrt::executor::ExecutorRef::SupportTimerSchedule() const | aimrt_mujoco_sim/_deps/aimrt-src/src/interface/aimrt_module_cpp_interface/../aimrt_module_cpp_interface/executor/executor.h | bool SupportTimerSchedule() const {
AIMRT_ASSERT(base_ptr_, "Reference is null.");
return base_ptr_->is_support_timer_schedule(base_ptr_->impl);
} | O3 | c | aimrt::executor::ExecutorRef::SupportTimerSchedule() const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0xc1ca7
movq 0x40(%rax), %rdi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmpq *0x20(%rax)
movl $0x28, %edi
callq 0x80f20
movq %rax, %rbx
leaq 0x12edec(%rip), %rsi # 0x1f0aa7
movq %rsp, %rdi
leaq 0x20(%rsp), %r8
movl $0x12, %edx
xorl %ecx, %ecx
callq 0x9b9c8
leaq 0x1d5252(%rip), %rax # 0x296f28
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x18, %rax
movq %rax, 0x8(%rbx)
leaq 0x10(%rsp), %r15
movq -0x10(%r15), %rcx
cmpq %r15, %rcx
jne 0xc1cfb
movups (%r15), %xmm0
movups %xmm0, (%rax)
jmp 0xc1d08
movq %rcx, 0x8(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rbx)
movq %r15, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
leaq 0x1d5116(%rip), %rsi # 0x296e40
leaq -0x271cf(%rip), %rdx # 0x9ab62
movq %rbx, %rdi
callq 0x83970
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xc1d5f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x82190
jmp 0xc1d5f
movq %rax, %r14
movq %rbx, %rdi
callq 0x816f0
movq %r14, %rdi
callq 0x83b70
nop
| _ZNK5aimrt8executor11ExecutorRef20SupportTimerScheduleEv:
push r15
push r14
push rbx
sub rsp, 30h
mov rax, [rdi]
test rax, rax
jz short loc_C1CA7
mov rdi, [rax+40h]
add rsp, 30h
pop rbx
pop r14
pop r15
jmp qword ptr [rax+20h]
loc_C1CA7:
mov edi, 28h ; '('; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aReferenceIsNul; "Reference is null."
mov rdi, rsp; int
lea r8, [rsp+48h+var_28]; int
mov edx, 12h; int
xor ecx, ecx; int
call _ZN3fmt3v107vformatB5cxx11ENS0_17basic_string_viewIcEENS0_17basic_format_argsINS0_20basic_format_contextINS0_8appenderEcEEEE; fmt::v10::vformat(fmt::v10::basic_string_view<char>,fmt::v10::basic_format_args<fmt::v10::basic_format_context<fmt::v10::appender,char>>)
lea rax, off_296F28
mov [rbx], rax
mov rax, rbx
add rax, 18h
mov [rbx+8], rax
lea r15, [rsp+48h+var_38]
mov rcx, [r15-10h]
cmp rcx, r15
jnz short loc_C1CFB
movups xmm0, xmmword ptr [r15]
movups xmmword ptr [rax], xmm0
jmp short loc_C1D08
loc_C1CFB:
mov [rbx+8], rcx
mov rax, [rsp+48h+var_38]
mov [rbx+18h], rax
loc_C1D08:
mov rax, [rsp+48h+var_40]
mov [rbx+10h], rax
mov [rsp+48h+var_48], r15
mov [rsp+48h+var_40], 0
mov byte ptr [rsp+48h+var_38], 0
lea rsi, _ZTIN5aimrt6common4util14AimRTExceptionE; lptinfo
lea rdx, _ZN5aimrt6common4util14AimRTExceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, [rsp+48h+var_48]; void *
cmp rdi, r15
jz short loc_C1D5F
mov rsi, [rsp+48h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_C1D5F
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
loc_C1D5F:
mov rdi, r14
call __Unwind_Resume
| long long aimrt::executor::ExecutorRef::SupportTimerSchedule(aimrt::executor::ExecutorRef *this)
{
char *exception; // rbx
void *v3; // [rsp+0h] [rbp-48h] BYREF
long long v4; // [rsp+8h] [rbp-40h]
__int128 v5; // [rsp+10h] [rbp-38h] BYREF
int v6[10]; // [rsp+20h] [rbp-28h] BYREF
if ( !*(_QWORD *)this )
{
exception = (char *)__cxa_allocate_exception(0x28uLL);
fmt::v10::vformat[abi:cxx11](&v3, "Reference is null.", 18LL, 0LL, (long long)v6);
*(_QWORD *)exception = off_296F28;
*((_QWORD *)exception + 1) = exception + 24;
if ( v3 == &v5 )
{
*(_OWORD *)(exception + 24) = v5;
}
else
{
*((_QWORD *)exception + 1) = v3;
*((_QWORD *)exception + 3) = v5;
}
*((_QWORD *)exception + 2) = v4;
v3 = &v5;
v4 = 0LL;
LOBYTE(v5) = 0;
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'aimrt::common::util::AimRTException,
(void (*)(void *))aimrt::common::util::AimRTException::~AimRTException);
}
return (*(long long ( **)(_QWORD))(*(_QWORD *)this + 32LL))(*(_QWORD *)(*(_QWORD *)this + 64LL));
}
| SupportTimerSchedule:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x001c1ca7
MOV RDI,qword ptr [RAX + 0x40]
ADD RSP,0x30
POP RBX
POP R14
POP R15
JMP qword ptr [RAX + 0x20]
LAB_001c1ca7:
MOV EDI,0x28
CALL 0x00180f20
MOV RBX,RAX
LAB_001c1cb4:
LEA RSI,[0x2f0aa7]
MOV RDI,RSP
LEA R8,[RSP + 0x20]
MOV EDX,0x12
XOR ECX,ECX
CALL 0x0019b9c8
LEA RAX,[0x396f28]
MOV qword ptr [RBX],RAX
MOV RAX,RBX
ADD RAX,0x18
MOV qword ptr [RBX + 0x8],RAX
LEA R15,[RSP + 0x10]
MOV RCX,qword ptr [R15 + -0x10]
CMP RCX,R15
JNZ 0x001c1cfb
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RAX],XMM0
JMP 0x001c1d08
LAB_001c1cfb:
MOV qword ptr [RBX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RBX + 0x18],RAX
LAB_001c1d08:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RBX + 0x10],RAX
MOV qword ptr [RSP],R15
MOV qword ptr [RSP + 0x8],0x0
MOV byte ptr [RSP + 0x10],0x0
LAB_001c1d23:
LEA RSI,[0x396e40]
LEA RDX,[0x19ab62]
MOV RDI,RBX
CALL 0x00183970
|
/* aimrt::executor::ExecutorRef::SupportTimerSchedule() const */
void __thiscall aimrt::executor::ExecutorRef::SupportTimerSchedule(ExecutorRef *this)
{
long lVar1;
int8 *puVar2;
uint *local_48;
int8 local_40;
uint local_38;
int4 uStack_34;
int4 uStack_30;
int4 uStack_2c;
int1 local_28 [16];
lVar1 = *(long *)this;
if (lVar1 != 0) {
/* WARNING: Could not recover jumptable at 0x001c1ca4. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(lVar1 + 0x20))(*(int8 *)(lVar1 + 0x40));
return;
}
puVar2 = (int8 *)__cxa_allocate_exception(0x28);
/* try { // try from 001c1cb4 to 001c1cce has its CatchHandler @ 001c1d54 */
fmt::v10::vformat_abi_cxx11_(&local_48,"Reference is null.",0x12,0,local_28);
*puVar2 = &PTR__AimRTException_00396f28;
puVar2[1] = puVar2 + 3;
if (local_48 == &local_38) {
*(uint *)(puVar2 + 3) = local_38;
*(int4 *)((long)puVar2 + 0x1c) = uStack_34;
*(int4 *)(puVar2 + 4) = uStack_30;
*(int4 *)((long)puVar2 + 0x24) = uStack_2c;
}
else {
puVar2[1] = local_48;
puVar2[3] = CONCAT44(uStack_34,local_38);
}
puVar2[2] = local_40;
local_40 = 0;
local_38 = local_38 & 0xffffff00;
local_48 = &local_38;
/* try { // try from 001c1d23 to 001c1d38 has its CatchHandler @ 001c1d39 */
/* WARNING: Subroutine does not return */
__cxa_throw(puVar2,&common::util::AimRTException::typeinfo,
common::util::AimRTException::~AimRTException);
}
| |
25,090 | LefDefParser::defwEndScanchain() | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defwWriter.cpp | int
defwEndScanchain()
{
defwFunc = DEFW_SCANCHAIN_END; // Current function of writer
if (!defwFile)
return DEFW_UNINITIALIZED;
if (defwState != DEFW_SCANCHAIN_START && defwState != DEFW_SCAN_ORDERED &&
defwState != DEFW_SCAN_FLOATING && defwState != DEFW_SCANCHAIN)
return DEFW_BAD_ORDER;
if (defwState != DEFW_SCANCHAIN_START) // from previous statement
fprintf(defwFile, " ;\n");
if (defwCounter > 0)
return DEFW_BAD_DATA;
else if (defwCounter < 0)
return DEFW_TOO_MANY_STMS;
fprintf(defwFile, "END SCANCHAINS\n\n");
defwLines++;
defwState = DEFW_SCANCHAIN_END;
return DEFW_OK;
} | O0 | cpp | LefDefParser::defwEndScanchain():
pushq %rax
leaq 0xdd50(%rip), %rax # 0x2b168
movl $0x47, (%rax)
leaq 0xdd33(%rip), %rax # 0x2b158
cmpq $0x0, (%rax)
jne 0x1d438
movl $0x1, 0x4(%rsp)
jmp 0x1d509
leaq 0xdd25(%rip), %rax # 0x2b164
cmpl $0x43, (%rax)
je 0x1d475
leaq 0xdd19(%rip), %rax # 0x2b164
cmpl $0x46, (%rax)
je 0x1d475
leaq 0xdd0d(%rip), %rax # 0x2b164
cmpl $0x45, (%rax)
je 0x1d475
leaq 0xdd01(%rip), %rax # 0x2b164
cmpl $0x44, (%rax)
je 0x1d475
movl $0x2, 0x4(%rsp)
jmp 0x1d509
leaq 0xdce8(%rip), %rax # 0x2b164
cmpl $0x43, (%rax)
je 0x1d499
leaq 0xdcd0(%rip), %rax # 0x2b158
movq (%rax), %rdi
leaq 0x69c0(%rip), %rsi # 0x23e52
movb $0x0, %al
callq 0x10f0
leaq 0xdcd8(%rip), %rax # 0x2b178
cmpl $0x0, (%rax)
jle 0x1d4af
movl $0x3, 0x4(%rsp)
jmp 0x1d509
leaq 0xdcc2(%rip), %rax # 0x2b178
cmpl $0x0, (%rax)
jge 0x1d4c5
movl $0x7, 0x4(%rsp)
jmp 0x1d509
jmp 0x1d4c7
leaq 0xdc8a(%rip), %rax # 0x2b158
movq (%rax), %rdi
leaq 0x7a1a(%rip), %rsi # 0x24ef2
movb $0x0, %al
callq 0x10f0
leaq 0xdc7a(%rip), %rax # 0x2b160
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0xdc6e(%rip), %rax # 0x2b160
movl %ecx, (%rax)
leaq 0xdc69(%rip), %rax # 0x2b164
movl $0x47, (%rax)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
popq %rcx
retq
nop
| _ZN12LefDefParser16defwEndScanchainEv:
push rax
lea rax, _ZN12LefDefParser8defwFuncE; LefDefParser::defwFunc
mov dword ptr [rax], 47h ; 'G'
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
cmp qword ptr [rax], 0
jnz short loc_1D438
mov [rsp+8+var_4], 1
jmp loc_1D509
loc_1D438:
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
cmp dword ptr [rax], 43h ; 'C'
jz short loc_1D475
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
cmp dword ptr [rax], 46h ; 'F'
jz short loc_1D475
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
cmp dword ptr [rax], 45h ; 'E'
jz short loc_1D475
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
cmp dword ptr [rax], 44h ; 'D'
jz short loc_1D475
mov [rsp+8+var_4], 2
jmp loc_1D509
loc_1D475:
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
cmp dword ptr [rax], 43h ; 'C'
jz short loc_1D499
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
mov rdi, [rax]
lea rsi, aDividercharS+10h; " ;\n"
mov al, 0
call _fprintf
loc_1D499:
lea rax, _ZN12LefDefParser11defwCounterE; LefDefParser::defwCounter
cmp dword ptr [rax], 0
jle short loc_1D4AF
mov [rsp+8+var_4], 3
jmp short loc_1D509
loc_1D4AF:
lea rax, _ZN12LefDefParser11defwCounterE; LefDefParser::defwCounter
cmp dword ptr [rax], 0
jge short loc_1D4C5
mov [rsp+8+var_4], 7
jmp short loc_1D509
loc_1D4C5:
jmp short $+2
loc_1D4C7:
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
mov rdi, [rax]
lea rsi, aEndScanchains; "END SCANCHAINS\n\n"
mov al, 0
call _fprintf
lea rax, _ZN12LefDefParser9defwLinesE; LefDefParser::defwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9defwLinesE; LefDefParser::defwLines
mov [rax], ecx
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
mov dword ptr [rax], 47h ; 'G'
mov [rsp+8+var_4], 0
loc_1D509:
mov eax, [rsp+8+var_4]
pop rcx
retn
| long long LefDefParser::defwEndScanchain(LefDefParser *this)
{
LefDefParser::defwFunc = 71;
if ( LefDefParser::defwFile )
{
if ( LefDefParser::defwState == 67
|| LefDefParser::defwState == 70
|| LefDefParser::defwState == 69
|| LefDefParser::defwState == 68 )
{
if ( LefDefParser::defwState != 67 )
fprintf(LefDefParser::defwFile, " ;\n");
if ( LefDefParser::defwCounter <= 0 )
{
if ( LefDefParser::defwCounter >= 0 )
{
fprintf(LefDefParser::defwFile, "END SCANCHAINS\n\n");
++LefDefParser::defwLines;
LefDefParser::defwState = 71;
return 0;
}
else
{
return 7;
}
}
else
{
return 3;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
| defwEndScanchain:
PUSH RAX
LEA RAX,[0x12b168]
MOV dword ptr [RAX],0x47
LEA RAX,[0x12b158]
CMP qword ptr [RAX],0x0
JNZ 0x0011d438
MOV dword ptr [RSP + 0x4],0x1
JMP 0x0011d509
LAB_0011d438:
LEA RAX,[0x12b164]
CMP dword ptr [RAX],0x43
JZ 0x0011d475
LEA RAX,[0x12b164]
CMP dword ptr [RAX],0x46
JZ 0x0011d475
LEA RAX,[0x12b164]
CMP dword ptr [RAX],0x45
JZ 0x0011d475
LEA RAX,[0x12b164]
CMP dword ptr [RAX],0x44
JZ 0x0011d475
MOV dword ptr [RSP + 0x4],0x2
JMP 0x0011d509
LAB_0011d475:
LEA RAX,[0x12b164]
CMP dword ptr [RAX],0x43
JZ 0x0011d499
LEA RAX,[0x12b158]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x123e52]
MOV AL,0x0
CALL 0x001010f0
LAB_0011d499:
LEA RAX,[0x12b178]
CMP dword ptr [RAX],0x0
JLE 0x0011d4af
MOV dword ptr [RSP + 0x4],0x3
JMP 0x0011d509
LAB_0011d4af:
LEA RAX,[0x12b178]
CMP dword ptr [RAX],0x0
JGE 0x0011d4c5
MOV dword ptr [RSP + 0x4],0x7
JMP 0x0011d509
LAB_0011d4c5:
JMP 0x0011d4c7
LAB_0011d4c7:
LEA RAX,[0x12b158]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x124ef2]
MOV AL,0x0
CALL 0x001010f0
LEA RAX,[0x12b160]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x12b160]
MOV dword ptr [RAX],ECX
LEA RAX,[0x12b164]
MOV dword ptr [RAX],0x47
MOV dword ptr [RSP + 0x4],0x0
LAB_0011d509:
MOV EAX,dword ptr [RSP + 0x4]
POP RCX
RET
|
/* LefDefParser::defwEndScanchain() */
int4 LefDefParser::defwEndScanchain(void)
{
int4 local_4;
defwFunc = 0x47;
if (defwFile == (FILE *)0x0) {
local_4 = 1;
}
else if ((((defwState == 0x43) || (defwState == 0x46)) || (defwState == 0x45)) ||
(defwState == 0x44)) {
if (defwState != 0x43) {
fprintf(defwFile," ;\n");
}
if (defwCounter < 1) {
if (defwCounter < 0) {
local_4 = 7;
}
else {
fprintf(defwFile,"END SCANCHAINS\n\n");
defwLines = defwLines + 1;
defwState = 0x47;
local_4 = 0;
}
}
else {
local_4 = 3;
}
}
else {
local_4 = 2;
}
return local_4;
}
| |
25,091 | my_b_safe_write | eloqsql/mysys/mf_iocache.c | int my_b_safe_write(IO_CACHE *info, const uchar *Buffer, size_t Count)
{
/*
Sasha: We are not writing this with the ? operator to avoid hitting
a possible compiler bug. At least gcc 2.95 cannot deal with
several layers of ternary operators that evaluated comma(,) operator
expressions inside - I do have a test case if somebody wants it
*/
if (info->type == SEQ_READ_APPEND)
return my_b_append(info, Buffer, Count);
return my_b_write(info, Buffer, Count);
} | O3 | c | my_b_safe_write:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0x3, 0xb0(%rdi)
jne 0x9625a
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x96002
movq 0x40(%r14), %rdi
leaq (%rdi,%rbx), %rax
cmpq 0x48(%r14), %rax
jbe 0x96277
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x957fb
testq %rbx, %rbx
je 0x96288
movq %rbx, %rdx
callq 0x29080
addq %rbx, 0x40(%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
| my_b_safe_write:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdx
mov r14, rdi
cmp dword ptr [rdi+0B0h], 3
jnz short loc_9625A
mov rdi, r14
mov rdx, rbx
pop rbx
pop r14
pop rbp
jmp my_b_append
loc_9625A:
mov rdi, [r14+40h]
lea rax, [rdi+rbx]
cmp rax, [r14+48h]
jbe short loc_96277
mov rdi, r14
mov rdx, rbx
pop rbx
pop r14
pop rbp
jmp _my_b_write
loc_96277:
test rbx, rbx
jz short loc_96288
mov rdx, rbx
call _memcpy
add [r14+40h], rbx
loc_96288:
xor eax, eax
pop rbx
pop r14
pop rbp
retn
| long long my_b_safe_write(long long a1, const char *a2, unsigned long long a3)
{
long long v6; // rdi
if ( *(_DWORD *)(a1 + 176) == 3 )
return my_b_append(a1, (long long)a2, a3);
v6 = *(_QWORD *)(a1 + 64);
if ( v6 + a3 > *(_QWORD *)(a1 + 72) )
return my_b_write(a1, a2, a3);
if ( a3 )
{
memcpy(v6, a2, a3);
*(_QWORD *)(a1 + 64) += a3;
}
return 0LL;
}
| my_b_safe_write:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV R14,RDI
CMP dword ptr [RDI + 0xb0],0x3
JNZ 0x0019625a
MOV RDI,R14
MOV RDX,RBX
POP RBX
POP R14
POP RBP
JMP 0x00196002
LAB_0019625a:
MOV RDI,qword ptr [R14 + 0x40]
LEA RAX,[RDI + RBX*0x1]
CMP RAX,qword ptr [R14 + 0x48]
JBE 0x00196277
MOV RDI,R14
MOV RDX,RBX
POP RBX
POP R14
POP RBP
JMP 0x001957fb
LAB_00196277:
TEST RBX,RBX
JZ 0x00196288
MOV RDX,RBX
CALL 0x00129080
ADD qword ptr [R14 + 0x40],RBX
LAB_00196288:
XOR EAX,EAX
POP RBX
POP R14
POP RBP
RET
|
int8 my_b_safe_write(long param_1,void *param_2,size_t param_3)
{
int8 uVar1;
if (*(int *)(param_1 + 0xb0) == 3) {
uVar1 = my_b_append(param_1,param_2,param_3);
return uVar1;
}
if (*(ulong *)(param_1 + 0x48) < (long)*(void **)(param_1 + 0x40) + param_3) {
uVar1 = _my_b_write(param_1,param_2,param_3);
return uVar1;
}
if (param_3 != 0) {
memcpy(*(void **)(param_1 + 0x40),param_2,param_3);
*(long *)(param_1 + 0x40) = *(long *)(param_1 + 0x40) + param_3;
}
return 0;
}
| |
25,092 | ma_field_extension_deep_dup | eloqsql/libmariadb/libmariadb/mariadb_lib.c | MA_FIELD_EXTENSION *ma_field_extension_deep_dup(MA_MEM_ROOT *memroot,
const MA_FIELD_EXTENSION *from)
{
MA_FIELD_EXTENSION *ext= new_ma_field_extension(memroot);
uint i;
if (!ext)
return NULL;
for (i= 0; i < MARIADB_FIELD_ATTR_LAST; i++)
{
if (from->metadata[i].str)
ext->metadata[i]= ma_const_string_copy_root(memroot,
from->metadata[i].str,
from->metadata[i].length);
}
return ext;
} | O3 | c | ma_field_extension_deep_dup:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movl $0x20, %esi
callq 0x20a6f
movq %rax, %rbx
testq %rax, %rax
je 0x1a752
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq (%r15), %rsi
testq %rsi, %rsi
je 0x1a752
movq 0x8(%r15), %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x20c63
testq %rax, %rax
cmoveq %rax, %r15
movq %rax, (%rbx)
movq %r15, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| ma_field_extension_deep_dup:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r15, rsi
mov r14, rdi
mov esi, 20h ; ' '
call ma_alloc_root
mov rbx, rax
test rax, rax
jz short loc_1A752
xorps xmm0, xmm0
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx], xmm0
mov rsi, [r15]
test rsi, rsi
jz short loc_1A752
mov r15, [r15+8]
mov rdi, r14
mov rdx, r15
call ma_memdup_root
test rax, rax
cmovz r15, rax
mov [rbx], rax
mov [rbx+8], r15
loc_1A752:
mov rax, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long * ma_field_extension_deep_dup(long long a1, long long *a2)
{
long long *v3; // rax
long long *v4; // rbx
long long v5; // rsi
long long v6; // r15
long long v7; // rax
v3 = (long long *)ma_alloc_root(a1, 32LL);
v4 = v3;
if ( v3 )
{
*((_OWORD *)v3 + 1) = 0LL;
*(_OWORD *)v3 = 0LL;
v5 = *a2;
if ( *a2 )
{
v6 = a2[1];
v7 = ma_memdup_root(a1, v5, v6);
if ( !v7 )
v6 = 0LL;
*v4 = v7;
v4[1] = v6;
}
}
return v4;
}
| ma_field_extension_deep_dup:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R15,RSI
MOV R14,RDI
MOV ESI,0x20
CALL 0x00120a6f
MOV RBX,RAX
TEST RAX,RAX
JZ 0x0011a752
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX],XMM0
MOV RSI,qword ptr [R15]
TEST RSI,RSI
JZ 0x0011a752
MOV R15,qword ptr [R15 + 0x8]
MOV RDI,R14
MOV RDX,R15
CALL 0x00120c63
TEST RAX,RAX
CMOVZ R15,RAX
MOV qword ptr [RBX],RAX
MOV qword ptr [RBX + 0x8],R15
LAB_0011a752:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
long * ma_field_extension_deep_dup(int8 param_1,long *param_2)
{
long *plVar1;
long lVar2;
long lVar3;
plVar1 = (long *)ma_alloc_root(param_1,0x20);
if (plVar1 != (long *)0x0) {
plVar1[2] = 0;
plVar1[3] = 0;
*plVar1 = 0;
plVar1[1] = 0;
if (*param_2 != 0) {
lVar3 = param_2[1];
lVar2 = ma_memdup_root(param_1,*param_2,lVar3);
if (lVar2 == 0) {
lVar3 = 0;
}
*plVar1 = lVar2;
plVar1[1] = lVar3;
}
}
return plVar1;
}
| |
25,093 | coro::net::udp::peer::peer(std::shared_ptr<coro::io_scheduler>, coro::net::udp::peer::info const&) | AlayaLite/build_O3/_deps/libcoro-src/src/net/udp/peer.cpp | peer::peer(std::shared_ptr<io_scheduler> scheduler, const info& bind_info)
: m_io_scheduler(std::move(scheduler)),
m_socket(net::make_accept_socket(
net::socket::options{bind_info.address.domain(), net::socket::type_t::udp, net::socket::blocking_t::no},
bind_info.address,
bind_info.port)),
m_bound(true)
{
} | O3 | cpp | coro::net::udp::peer::peer(std::shared_ptr<coro::io_scheduler>, coro::net::udp::peer::info const&):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movups (%rsi), %xmm0
movq %rax, 0x8(%rsi)
movups %xmm0, (%rdi)
movq %rax, (%rsi)
addq $0x10, %rdi
movl (%rdx), %eax
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x4(%rsi)
movzwl 0x14(%rdx), %ecx
movl $0x80, %r8d
callq 0xcb9d5
movb $0x1, 0x14(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xcc4c0
callq 0x33e7c
movq %r14, %rdi
callq 0x17740
| _ZN4coro3net3udp4peerC2ESt10shared_ptrINS_12io_schedulerEERKNS2_4infoE:
push r14; Alternative name is 'coro::net::udp::peer::peer(std::shared_ptr<coro::io_scheduler>, coro::net::udp::peer::info const&)'
push rbx
sub rsp, 18h
mov rbx, rdi
xor eax, eax
mov [rdi+8], rax
movups xmm0, xmmword ptr [rsi]
mov [rsi+8], rax
movups xmmword ptr [rdi], xmm0
mov [rsi], rax
add rdi, 10h
mov eax, [rdx]
lea rsi, [rsp+28h+var_1C]
mov [rsi], eax
mov rax, 100000000h
mov [rsi+4], rax
movzx ecx, word ptr [rdx+14h]
mov r8d, 80h
call _ZN4coro3net18make_accept_socketERKNS0_6socket7optionsERKNS0_10ip_addressEti; coro::net::make_accept_socket(coro::net::socket::options const&,coro::net::ip_address const&,ushort,int)
mov byte ptr [rbx+14h], 1
add rsp, 18h
pop rbx
pop r14
retn
mov r14, rax
mov rdi, [rbx+8]
test rdi, rdi
jz short loc_CC4C0
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_CC4C0:
mov rdi, r14
call __Unwind_Resume
| unsigned int * coro::net::udp::peer::peer(long long a1, __int128 *a2, long long a3)
{
__int128 v3; // xmm0
unsigned int *result; // rax
unsigned int v5; // [rsp+Ch] [rbp-1Ch] BYREF
long long v6; // [rsp+10h] [rbp-18h]
*(_QWORD *)(a1 + 8) = 0LL;
v3 = *a2;
*((_QWORD *)a2 + 1) = 0LL;
*(_OWORD *)a1 = v3;
*(_QWORD *)a2 = 0LL;
v5 = *(_DWORD *)a3;
v6 = 0x100000000LL;
result = coro::net::make_accept_socket((unsigned int *)(a1 + 16), &v5, a3, *(_WORD *)(a3 + 20), 0x80u);
*(_BYTE *)(a1 + 20) = 1;
return result;
}
| peer:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
XOR EAX,EAX
MOV qword ptr [RDI + 0x8],RAX
MOVUPS XMM0,xmmword ptr [RSI]
MOV qword ptr [RSI + 0x8],RAX
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RSI],RAX
ADD RDI,0x10
MOV EAX,dword ptr [RDX]
LEA RSI,[RSP + 0xc]
MOV dword ptr [RSI],EAX
MOV RAX,0x100000000
MOV qword ptr [RSI + 0x4],RAX
MOVZX ECX,word ptr [RDX + 0x14]
LAB_001cc498:
MOV R8D,0x80
CALL 0x001cb9d5
LAB_001cc4a3:
MOV byte ptr [RBX + 0x14],0x1
ADD RSP,0x18
POP RBX
POP R14
RET
|
/* coro::net::udp::peer::peer(std::shared_ptr<coro::io_scheduler>, coro::net::udp::peer::info
const&) */
void __thiscall coro::net::udp::peer::peer(peer *this,int8 *param_2,ip_address *param_3)
{
int8 uVar1;
int4 local_1c;
int8 local_18;
*(int8 *)(this + 8) = 0;
uVar1 = param_2[1];
param_2[1] = 0;
*(int8 *)this = *param_2;
*(int8 *)(this + 8) = uVar1;
*param_2 = 0;
local_1c = *(int4 *)param_3;
local_18 = 0x100000000;
/* try { // try from 001cc498 to 001cc4a2 has its CatchHandler @ 001cc4af */
make_accept_socket((net *)(this + 0x10),(options *)&local_1c,param_3,*(ushort *)(param_3 + 0x14),
0x80);
this[0x14] = (peer)0x1;
return;
}
| |
25,094 | LefDefParser::lefiViaLayer::addPoly(int, LefDefParser::lefiGeometries*) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiVia.cpp | void
lefiViaLayer::addPoly(int colorMask,
lefiGeometries *geom)
{
if (numPolys_ == polysAllocated_) {
int i;
lefiGeomPolygon **poly;
int *polyMask;
polysAllocated_ = (polysAllocated_ == 0) ?
2 : polysAllocated_ * 2;
poly = (lefiGeomPolygon**) lefMalloc(sizeof(lefiGeomPolygon*) *
polysAllocated_);
polyMask = (int*) lefMalloc(sizeof(int) * polysAllocated_);
for (i = 0; i < numPolys_; i++) {
poly[i] = polygons_[i];
polyMask[i] = polyColorMask_[i];
}
if (polygons_) {
lefFree((char*) (polygons_));
lefFree((char*) (polyColorMask_));
}
polygons_ = poly;
polyColorMask_ = polyMask;
}
polygons_[numPolys_] = geom->getPolygon(0);
polyColorMask_[numPolys_] = colorMask;
numPolys_ += 1;
} | O0 | cpp | LefDefParser::lefiViaLayer::addPoly(int, LefDefParser::lefiGeometries*):
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movl 0x40(%rcx), %eax
cmpl 0x44(%rcx), %eax
jne 0x1426f
movq 0x10(%rsp), %rax
cmpl $0x0, 0x44(%rax)
jne 0x1418e
movl $0x2, %eax
movl %eax, 0xc(%rsp)
jmp 0x1419c
movq 0x10(%rsp), %rax
movl 0x44(%rax), %eax
shll %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, 0x44(%rax)
movslq 0x44(%rax), %rdi
shlq $0x3, %rdi
callq 0x4f550
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rsp)
movslq 0x44(%rax), %rdi
shlq $0x2, %rdi
callq 0x4f550
movq %rax, 0x18(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0x40(%rcx), %eax
jge 0x14230
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rcx
movslq 0x2c(%rsp), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x20(%rsp), %rcx
movslq 0x2c(%rsp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x10(%rax), %rax
movslq 0x2c(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x18(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x141dc
movq 0x10(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x14258
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x52810
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x52810
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x48(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x10f90
movq %rax, %rsi
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rcx
movslq 0x40(%rax), %rdx
movq %rsi, (%rcx,%rdx,8)
movl 0x3c(%rsp), %esi
movq 0x10(%rax), %rcx
movslq 0x40(%rax), %rdx
movl %esi, (%rcx,%rdx,4)
movl 0x40(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x40(%rax)
addq $0x48, %rsp
retq
nopl (%rax)
| _ZN12LefDefParser12lefiViaLayer7addPolyEiPNS_14lefiGeometriesE:
sub rsp, 48h
mov [rsp+48h+var_8], rdi
mov [rsp+48h+var_C], esi
mov [rsp+48h+var_18], rdx
mov rcx, [rsp+48h+var_8]
mov [rsp+48h+var_38], rcx
mov eax, [rcx+40h]
cmp eax, [rcx+44h]
jnz loc_1426F
mov rax, [rsp+48h+var_38]
cmp dword ptr [rax+44h], 0
jnz short loc_1418E
mov eax, 2
mov [rsp+48h+var_3C], eax
jmp short loc_1419C
loc_1418E:
mov rax, [rsp+48h+var_38]
mov eax, [rax+44h]
shl eax, 1
mov [rsp+48h+var_3C], eax
loc_1419C:
mov rax, [rsp+48h+var_38]
mov ecx, [rsp+48h+var_3C]
mov [rax+44h], ecx
movsxd rdi, dword ptr [rax+44h]
shl rdi, 3; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov rcx, rax
mov rax, [rsp+48h+var_38]
mov [rsp+48h+var_28], rcx
movsxd rdi, dword ptr [rax+44h]
shl rdi, 2; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov [rsp+48h+var_30], rax
mov [rsp+48h+var_1C], 0
loc_141DC:
mov rcx, [rsp+48h+var_38]
mov eax, [rsp+48h+var_1C]
cmp eax, [rcx+40h]
jge short loc_14230
mov rax, [rsp+48h+var_38]
mov rcx, [rax+48h]
movsxd rdx, [rsp+48h+var_1C]
mov rsi, [rcx+rdx*8]; void *
mov rcx, [rsp+48h+var_28]
movsxd rdx, [rsp+48h+var_1C]
mov [rcx+rdx*8], rsi
mov rax, [rax+10h]
movsxd rcx, [rsp+48h+var_1C]
mov edx, [rax+rcx*4]
mov rax, [rsp+48h+var_30]
movsxd rcx, [rsp+48h+var_1C]
mov [rax+rcx*4], edx
mov eax, [rsp+48h+var_1C]
add eax, 1
mov [rsp+48h+var_1C], eax
jmp short loc_141DC
loc_14230:
mov rax, [rsp+48h+var_38]
cmp qword ptr [rax+48h], 0
jz short loc_14258
mov rax, [rsp+48h+var_38]
mov rdi, [rax+48h]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov rax, [rsp+48h+var_38]
mov rdi, [rax+10h]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
loc_14258:
mov rax, [rsp+48h+var_38]
mov rcx, [rsp+48h+var_28]
mov [rax+48h], rcx
mov rcx, [rsp+48h+var_30]
mov [rax+10h], rcx
loc_1426F:
mov rdi, [rsp+48h+var_18]; this
xor esi, esi; int
call _ZNK12LefDefParser14lefiGeometries10getPolygonEi; LefDefParser::lefiGeometries::getPolygon(int)
mov rsi, rax
mov rax, [rsp+48h+var_38]
mov rcx, [rax+48h]
movsxd rdx, dword ptr [rax+40h]
mov [rcx+rdx*8], rsi
mov esi, [rsp+48h+var_C]
mov rcx, [rax+10h]
movsxd rdx, dword ptr [rax+40h]
mov [rcx+rdx*4], esi
mov ecx, [rax+40h]
add ecx, 1
mov [rax+40h], ecx
add rsp, 48h
retn
| LefDefParser::lefiViaLayer * LefDefParser::lefiViaLayer::addPoly(
LefDefParser::lefiViaLayer *this,
void *a2,
LefDefParser::lefiGeometries *a3)
{
long long Polygon; // rsi
LefDefParser::lefiViaLayer *result; // rax
int v5; // [rsp+Ch] [rbp-3Ch]
long long v6; // [rsp+18h] [rbp-30h]
long long v7; // [rsp+20h] [rbp-28h]
int i; // [rsp+2Ch] [rbp-1Ch]
int v10; // [rsp+3Ch] [rbp-Ch]
v10 = (int)a2;
if ( *((_DWORD *)this + 16) == *((_DWORD *)this + 17) )
{
if ( *((_DWORD *)this + 17) )
v5 = 2 * *((_DWORD *)this + 17);
else
v5 = 2;
*((_DWORD *)this + 17) = v5;
v7 = LefDefParser::lefMalloc((LefDefParser *)(8LL * *((int *)this + 17)), (unsigned long long)a2);
v6 = LefDefParser::lefMalloc((LefDefParser *)(4LL * *((int *)this + 17)), (unsigned long long)a2);
for ( i = 0; i < *((_DWORD *)this + 16); ++i )
{
a2 = *(void **)(*((_QWORD *)this + 9) + 8LL * i);
*(_QWORD *)(v7 + 8LL * i) = a2;
*(_DWORD *)(v6 + 4LL * i) = *(_DWORD *)(*((_QWORD *)this + 2) + 4LL * i);
}
if ( *((_QWORD *)this + 9) )
{
LefDefParser::lefFree(*((LefDefParser **)this + 9), a2);
LefDefParser::lefFree(*((LefDefParser **)this + 2), a2);
}
*((_QWORD *)this + 9) = v7;
*((_QWORD *)this + 2) = v6;
}
Polygon = LefDefParser::lefiGeometries::getPolygon(a3, 0);
result = this;
*(_QWORD *)(*((_QWORD *)this + 9) + 8LL * *((int *)this + 16)) = Polygon;
*(_DWORD *)(*((_QWORD *)this + 2) + 4LL * (int)(*((_DWORD *)this + 16))++) = v10;
return result;
}
| addPoly:
SUB RSP,0x48
MOV qword ptr [RSP + 0x40],RDI
MOV dword ptr [RSP + 0x3c],ESI
MOV qword ptr [RSP + 0x30],RDX
MOV RCX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x10],RCX
MOV EAX,dword ptr [RCX + 0x40]
CMP EAX,dword ptr [RCX + 0x44]
JNZ 0x0011426f
MOV RAX,qword ptr [RSP + 0x10]
CMP dword ptr [RAX + 0x44],0x0
JNZ 0x0011418e
MOV EAX,0x2
MOV dword ptr [RSP + 0xc],EAX
JMP 0x0011419c
LAB_0011418e:
MOV RAX,qword ptr [RSP + 0x10]
MOV EAX,dword ptr [RAX + 0x44]
SHL EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
LAB_0011419c:
MOV RAX,qword ptr [RSP + 0x10]
MOV ECX,dword ptr [RSP + 0xc]
MOV dword ptr [RAX + 0x44],ECX
MOVSXD RDI,dword ptr [RAX + 0x44]
SHL RDI,0x3
CALL 0x0014f550
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x20],RCX
MOVSXD RDI,dword ptr [RAX + 0x44]
SHL RDI,0x2
CALL 0x0014f550
MOV qword ptr [RSP + 0x18],RAX
MOV dword ptr [RSP + 0x2c],0x0
LAB_001141dc:
MOV RCX,qword ptr [RSP + 0x10]
MOV EAX,dword ptr [RSP + 0x2c]
CMP EAX,dword ptr [RCX + 0x40]
JGE 0x00114230
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RAX + 0x48]
MOVSXD RDX,dword ptr [RSP + 0x2c]
MOV RSI,qword ptr [RCX + RDX*0x8]
MOV RCX,qword ptr [RSP + 0x20]
MOVSXD RDX,dword ptr [RSP + 0x2c]
MOV qword ptr [RCX + RDX*0x8],RSI
MOV RAX,qword ptr [RAX + 0x10]
MOVSXD RCX,dword ptr [RSP + 0x2c]
MOV EDX,dword ptr [RAX + RCX*0x4]
MOV RAX,qword ptr [RSP + 0x18]
MOVSXD RCX,dword ptr [RSP + 0x2c]
MOV dword ptr [RAX + RCX*0x4],EDX
MOV EAX,dword ptr [RSP + 0x2c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x2c],EAX
JMP 0x001141dc
LAB_00114230:
MOV RAX,qword ptr [RSP + 0x10]
CMP qword ptr [RAX + 0x48],0x0
JZ 0x00114258
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RAX + 0x48]
CALL 0x00152810
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RAX + 0x10]
CALL 0x00152810
LAB_00114258:
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + 0x48],RCX
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x10],RCX
LAB_0011426f:
MOV RDI,qword ptr [RSP + 0x30]
XOR ESI,ESI
CALL 0x00110f90
MOV RSI,RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RAX + 0x48]
MOVSXD RDX,dword ptr [RAX + 0x40]
MOV qword ptr [RCX + RDX*0x8],RSI
MOV ESI,dword ptr [RSP + 0x3c]
MOV RCX,qword ptr [RAX + 0x10]
MOVSXD RDX,dword ptr [RAX + 0x40]
MOV dword ptr [RCX + RDX*0x4],ESI
MOV ECX,dword ptr [RAX + 0x40]
ADD ECX,0x1
MOV dword ptr [RAX + 0x40],ECX
ADD RSP,0x48
RET
|
/* LefDefParser::lefiViaLayer::addPoly(int, LefDefParser::lefiGeometries*) */
void __thiscall
LefDefParser::lefiViaLayer::addPoly(lefiViaLayer *this,int param_1,lefiGeometries *param_2)
{
long lVar1;
long lVar2;
int8 uVar3;
int local_3c;
int local_1c;
if (*(int *)(this + 0x40) == *(int *)(this + 0x44)) {
if (*(int *)(this + 0x44) == 0) {
local_3c = 2;
}
else {
local_3c = *(int *)(this + 0x44) << 1;
}
*(int *)(this + 0x44) = local_3c;
lVar1 = lefMalloc((long)*(int *)(this + 0x44) << 3);
lVar2 = lefMalloc((long)*(int *)(this + 0x44) << 2);
for (local_1c = 0; local_1c < *(int *)(this + 0x40); local_1c = local_1c + 1) {
*(int8 *)(lVar1 + (long)local_1c * 8) =
*(int8 *)(*(long *)(this + 0x48) + (long)local_1c * 8);
*(int4 *)(lVar2 + (long)local_1c * 4) =
*(int4 *)(*(long *)(this + 0x10) + (long)local_1c * 4);
}
if (*(long *)(this + 0x48) != 0) {
lefFree(*(void **)(this + 0x48));
lefFree(*(void **)(this + 0x10));
}
*(long *)(this + 0x48) = lVar1;
*(long *)(this + 0x10) = lVar2;
}
uVar3 = lefiGeometries::getPolygon(param_2,0);
*(int8 *)(*(long *)(this + 0x48) + (long)*(int *)(this + 0x40) * 8) = uVar3;
*(int *)(*(long *)(this + 0x10) + (long)*(int *)(this + 0x40) * 4) = param_1;
*(int *)(this + 0x40) = *(int *)(this + 0x40) + 1;
return;
}
| |
25,095 | LefDefParser::lefiViaLayer::addPoly(int, LefDefParser::lefiGeometries*) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiVia.cpp | void
lefiViaLayer::addPoly(int colorMask,
lefiGeometries *geom)
{
if (numPolys_ == polysAllocated_) {
int i;
lefiGeomPolygon **poly;
int *polyMask;
polysAllocated_ = (polysAllocated_ == 0) ?
2 : polysAllocated_ * 2;
poly = (lefiGeomPolygon**) lefMalloc(sizeof(lefiGeomPolygon*) *
polysAllocated_);
polyMask = (int*) lefMalloc(sizeof(int) * polysAllocated_);
for (i = 0; i < numPolys_; i++) {
poly[i] = polygons_[i];
polyMask[i] = polyColorMask_[i];
}
if (polygons_) {
lefFree((char*) (polygons_));
lefFree((char*) (polyColorMask_));
}
polygons_ = poly;
polyColorMask_ = polyMask;
}
polygons_[numPolys_] = geom->getPolygon(0);
polyColorMask_[numPolys_] = colorMask;
numPolys_ += 1;
} | O3 | cpp | LefDefParser::lefiViaLayer::addPoly(int, LefDefParser::lefiGeometries*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movl 0x40(%rdi), %eax
cmpl 0x44(%rdi), %eax
jne 0xe1eb
leal (%rax,%rax), %ecx
testl %eax, %eax
movl $0x2, %eax
cmovnel %ecx, %eax
movl %eax, 0x44(%rbx)
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x30c15
movq %rax, %r15
movslq 0x44(%rbx), %rdi
shlq $0x2, %rdi
callq 0x30c15
movq %rax, %r12
cmpl $0x0, 0x40(%rbx)
jle 0xe1cc
xorl %eax, %eax
movq 0x48(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
movq %rcx, (%r15,%rax,8)
movq 0x10(%rbx), %rcx
movl (%rcx,%rax,4), %ecx
movl %ecx, (%r12,%rax,4)
incq %rax
movslq 0x40(%rbx), %rcx
cmpq %rcx, %rax
jl 0xe1a9
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0xe1e3
callq 0x322d0
movq 0x10(%rbx), %rdi
callq 0x322d0
movq %r15, 0x48(%rbx)
movq %r12, 0x10(%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0xc4ee
movq 0x48(%rbx), %rcx
movslq 0x40(%rbx), %rdx
movq %rax, (%rcx,%rdx,8)
movq 0x10(%rbx), %rax
movl %ebp, (%rax,%rdx,4)
incl 0x40(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| _ZN12LefDefParser12lefiViaLayer7addPolyEiPNS_14lefiGeometriesE:
push rbp
push r15
push r14
push r12
push rbx
mov r14, rdx
mov ebp, esi
mov rbx, rdi
mov eax, [rdi+40h]
cmp eax, [rdi+44h]
jnz short loc_E1EB
lea ecx, [rax+rax]
test eax, eax
mov eax, 2
cmovnz eax, ecx
mov [rbx+44h], eax
movsxd rdi, eax
shl rdi, 3; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov r15, rax
movsxd rdi, dword ptr [rbx+44h]
shl rdi, 2; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov r12, rax
cmp dword ptr [rbx+40h], 0
jle short loc_E1CC
xor eax, eax
loc_E1A9:
mov rcx, [rbx+48h]
mov rcx, [rcx+rax*8]
mov [r15+rax*8], rcx
mov rcx, [rbx+10h]
mov ecx, [rcx+rax*4]
mov [r12+rax*4], ecx
inc rax
movsxd rcx, dword ptr [rbx+40h]
cmp rax, rcx
jl short loc_E1A9
loc_E1CC:
mov rdi, [rbx+48h]; this
test rdi, rdi
jz short loc_E1E3
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov rdi, [rbx+10h]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
loc_E1E3:
mov [rbx+48h], r15
mov [rbx+10h], r12
loc_E1EB:
mov rdi, r14; this
xor esi, esi; int
call _ZNK12LefDefParser14lefiGeometries10getPolygonEi; LefDefParser::lefiGeometries::getPolygon(int)
mov rcx, [rbx+48h]
movsxd rdx, dword ptr [rbx+40h]
mov [rcx+rdx*8], rax
mov rax, [rbx+10h]
mov [rax+rdx*4], ebp
inc dword ptr [rbx+40h]
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long LefDefParser::lefiViaLayer::addPoly(
LefDefParser::lefiViaLayer *this,
void *a2,
LefDefParser::lefiGeometries *a3)
{
int v5; // eax
int v6; // ecx
bool v7; // zf
int v8; // eax
long long v9; // r15
long long v10; // r12
long long v11; // rax
LefDefParser *v12; // rdi
long long Polygon; // rax
long long v14; // rdx
long long result; // rax
v5 = *((_DWORD *)this + 16);
if ( v5 == *((_DWORD *)this + 17) )
{
v6 = 2 * v5;
v7 = v5 == 0;
v8 = 2;
if ( !v7 )
v8 = v6;
*((_DWORD *)this + 17) = v8;
v9 = LefDefParser::lefMalloc((LefDefParser *)(8LL * v8), (unsigned long long)a2);
v10 = LefDefParser::lefMalloc((LefDefParser *)(4LL * *((int *)this + 17)), (unsigned long long)a2);
if ( *((int *)this + 16) > 0 )
{
v11 = 0LL;
do
{
*(_QWORD *)(v9 + 8 * v11) = *(_QWORD *)(*((_QWORD *)this + 9) + 8 * v11);
*(_DWORD *)(v10 + 4 * v11) = *(_DWORD *)(*((_QWORD *)this + 2) + 4 * v11);
++v11;
}
while ( v11 < *((int *)this + 16) );
}
v12 = (LefDefParser *)*((_QWORD *)this + 9);
if ( v12 )
{
LefDefParser::lefFree(v12, a2);
LefDefParser::lefFree(*((LefDefParser **)this + 2), a2);
}
*((_QWORD *)this + 9) = v9;
*((_QWORD *)this + 2) = v10;
}
Polygon = LefDefParser::lefiGeometries::getPolygon(a3, 0);
v14 = *((int *)this + 16);
*(_QWORD *)(*((_QWORD *)this + 9) + 8 * v14) = Polygon;
result = *((_QWORD *)this + 2);
*(_DWORD *)(result + 4 * v14) = (_DWORD)a2;
++*((_DWORD *)this + 16);
return result;
}
| addPoly:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14,RDX
MOV EBP,ESI
MOV RBX,RDI
MOV EAX,dword ptr [RDI + 0x40]
CMP EAX,dword ptr [RDI + 0x44]
JNZ 0x0010e1eb
LEA ECX,[RAX + RAX*0x1]
TEST EAX,EAX
MOV EAX,0x2
CMOVNZ EAX,ECX
MOV dword ptr [RBX + 0x44],EAX
MOVSXD RDI,EAX
SHL RDI,0x3
CALL 0x00130c15
MOV R15,RAX
MOVSXD RDI,dword ptr [RBX + 0x44]
SHL RDI,0x2
CALL 0x00130c15
MOV R12,RAX
CMP dword ptr [RBX + 0x40],0x0
JLE 0x0010e1cc
XOR EAX,EAX
LAB_0010e1a9:
MOV RCX,qword ptr [RBX + 0x48]
MOV RCX,qword ptr [RCX + RAX*0x8]
MOV qword ptr [R15 + RAX*0x8],RCX
MOV RCX,qword ptr [RBX + 0x10]
MOV ECX,dword ptr [RCX + RAX*0x4]
MOV dword ptr [R12 + RAX*0x4],ECX
INC RAX
MOVSXD RCX,dword ptr [RBX + 0x40]
CMP RAX,RCX
JL 0x0010e1a9
LAB_0010e1cc:
MOV RDI,qword ptr [RBX + 0x48]
TEST RDI,RDI
JZ 0x0010e1e3
CALL 0x001322d0
MOV RDI,qword ptr [RBX + 0x10]
CALL 0x001322d0
LAB_0010e1e3:
MOV qword ptr [RBX + 0x48],R15
MOV qword ptr [RBX + 0x10],R12
LAB_0010e1eb:
MOV RDI,R14
XOR ESI,ESI
CALL 0x0010c4ee
MOV RCX,qword ptr [RBX + 0x48]
MOVSXD RDX,dword ptr [RBX + 0x40]
MOV qword ptr [RCX + RDX*0x8],RAX
MOV RAX,qword ptr [RBX + 0x10]
MOV dword ptr [RAX + RDX*0x4],EBP
INC dword ptr [RBX + 0x40]
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* LefDefParser::lefiViaLayer::addPoly(int, LefDefParser::lefiGeometries*) */
void __thiscall
LefDefParser::lefiViaLayer::addPoly(lefiViaLayer *this,int param_1,lefiGeometries *param_2)
{
int iVar1;
int iVar2;
long lVar3;
long lVar4;
long lVar5;
int8 uVar6;
int4 in_register_00000034;
ulong uVar7;
uVar7 = CONCAT44(in_register_00000034,param_1);
iVar1 = *(int *)(this + 0x40);
if (iVar1 == *(int *)(this + 0x44)) {
iVar2 = 2;
if (iVar1 != 0) {
iVar2 = iVar1 * 2;
}
*(int *)(this + 0x44) = iVar2;
lVar3 = lefMalloc((LefDefParser *)((long)iVar2 << 3),uVar7);
lVar4 = lefMalloc((LefDefParser *)((long)*(int *)(this + 0x44) << 2),uVar7);
if (0 < *(int *)(this + 0x40)) {
lVar5 = 0;
do {
*(int8 *)(lVar3 + lVar5 * 8) = *(int8 *)(*(long *)(this + 0x48) + lVar5 * 8);
*(int4 *)(lVar4 + lVar5 * 4) = *(int4 *)(*(long *)(this + 0x10) + lVar5 * 4);
lVar5 = lVar5 + 1;
} while (lVar5 < *(int *)(this + 0x40));
}
if (*(void **)(this + 0x48) != (void *)0x0) {
lefFree(*(void **)(this + 0x48));
lefFree(*(void **)(this + 0x10));
}
*(long *)(this + 0x48) = lVar3;
*(long *)(this + 0x10) = lVar4;
}
uVar6 = lefiGeometries::getPolygon(param_2,0);
iVar1 = *(int *)(this + 0x40);
*(int8 *)(*(long *)(this + 0x48) + (long)iVar1 * 8) = uVar6;
*(int *)(*(long *)(this + 0x10) + (long)iVar1 * 4) = param_1;
*(int *)(this + 0x40) = *(int *)(this + 0x40) + 1;
return;
}
| |
25,096 | cs_leave | eloqsql/strings/ctype.c | static int cs_leave(MY_XML_PARSER *st,const char *attr, size_t len)
{
struct my_cs_file_info *i= (struct my_cs_file_info *)st->user_data;
const struct my_cs_file_section_st *s= cs_file_sec(attr,len);
int state= s ? s->state : 0;
int rc;
switch(state){
case _CS_COLLATION:
if (i->tailoring_length)
i->cs.tailoring= i->tailoring;
rc= i->loader->add_collation ? i->loader->add_collation(&i->cs) : MY_XML_OK;
break;
/* Rules: Logical Reset Positions */
case _CS_RESET_FIRST_NON_IGNORABLE:
rc= tailoring_append(st, "[first non-ignorable]", 0, NULL);
break;
case _CS_RESET_LAST_NON_IGNORABLE:
rc= tailoring_append(st, "[last non-ignorable]", 0, NULL);
break;
case _CS_RESET_FIRST_PRIMARY_IGNORABLE:
rc= tailoring_append(st, "[first primary ignorable]", 0, NULL);
break;
case _CS_RESET_LAST_PRIMARY_IGNORABLE:
rc= tailoring_append(st, "[last primary ignorable]", 0, NULL);
break;
case _CS_RESET_FIRST_SECONDARY_IGNORABLE:
rc= tailoring_append(st, "[first secondary ignorable]", 0, NULL);
break;
case _CS_RESET_LAST_SECONDARY_IGNORABLE:
rc= tailoring_append(st, "[last secondary ignorable]", 0, NULL);
break;
case _CS_RESET_FIRST_TERTIARY_IGNORABLE:
rc= tailoring_append(st, "[first tertiary ignorable]", 0, NULL);
break;
case _CS_RESET_LAST_TERTIARY_IGNORABLE:
rc= tailoring_append(st, "[last tertiary ignorable]", 0, NULL);
break;
case _CS_RESET_FIRST_TRAILING:
rc= tailoring_append(st, "[first trailing]", 0, NULL);
break;
case _CS_RESET_LAST_TRAILING:
rc= tailoring_append(st, "[last trailing]", 0, NULL);
break;
case _CS_RESET_FIRST_VARIABLE:
rc= tailoring_append(st, "[first variable]", 0, NULL);
break;
case _CS_RESET_LAST_VARIABLE:
rc= tailoring_append(st, "[last variable]", 0, NULL);
break;
default:
rc=MY_XML_OK;
}
return rc;
} | O3 | c | cs_leave:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq 0x140(%rdi), %rbx
leaq 0x2a4bc0(%rip), %r13 # 0x331470
leaq 0x9b7a(%rip), %r12 # 0x96431
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x28180
testl %eax, %eax
jne 0x8c8d0
cmpb $0x0, (%r12,%r14)
je 0x8c8ee
movq 0x18(%r13), %r12
addq $0x10, %r13
testq %r12, %r12
jne 0x8c8b7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl (%r13), %ecx
leal -0x191(%rcx), %eax
cmpl $0xb, %eax
ja 0x8c919
leaq 0x288a58(%rip), %rcx # 0x31535c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xc6c5(%rip), %rsi # 0x98fd9
jmp 0x8c9c4
cmpl $0x9, %ecx
jne 0x8c8dd
cmpq $0x0, 0x690(%rbx)
je 0x8c936
movq 0x688(%rbx), %rax
movq %rax, 0x718(%rbx)
movq 0x7a8(%rbx), %rax
movq 0xa8(%rax), %rax
testq %rax, %rax
je 0x8c8dd
addq $0x6e0, %rbx # imm = 0x6E0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
leaq 0xc65a(%rip), %rsi # 0x98fc4
jmp 0x8c9c4
leaq 0xc6d0(%rip), %rsi # 0x99043
jmp 0x8c9c4
leaq 0xc72e(%rip), %rsi # 0x990aa
jmp 0x8c9c4
leaq 0xc687(%rip), %rsi # 0x9900c
jmp 0x8c9c4
leaq 0xc69a(%rip), %rsi # 0x99028
jmp 0x8c9c4
leaq 0xc6f2(%rip), %rsi # 0x99089
jmp 0x8c9c4
leaq 0xc653(%rip), %rsi # 0x98ff3
jmp 0x8c9c4
leaq 0xc6b5(%rip), %rsi # 0x9905e
jmp 0x8c9c4
leaq 0xc6c6(%rip), %rsi # 0x99078
jmp 0x8c9c4
leaq 0xc5f3(%rip), %rsi # 0x98fae
jmp 0x8c9c4
leaq 0xc6d5(%rip), %rsi # 0x99099
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8d214
| cs_leave:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdx
mov r15, rsi
mov rbx, [rdi+140h]
lea r13, sec
lea r12, aIndexXml+6; "xml"
loc_8C8B7:
mov rdi, r15
mov rsi, r12
mov rdx, r14
call _strncmp
test eax, eax
jnz short loc_8C8D0
cmp byte ptr [r12+r14], 0
jz short loc_8C8EE
loc_8C8D0:
mov r12, [r13+18h]
add r13, 10h
test r12, r12
jnz short loc_8C8B7
loc_8C8DD:
xor eax, eax
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8C8EE:
mov ecx, [r13+0]
lea eax, [rcx-191h]; switch 12 cases
cmp eax, 0Bh
ja short def_8C90B; jumptable 000000000008C90B default case
lea rcx, jpt_8C90B
movsxd rax, ds:(jpt_8C90B - 31535Ch)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_8C90D:
lea rsi, aFirstPrimaryIg; jumptable 000000000008C90B case 401
jmp loc_8C9C4
def_8C90B:
cmp ecx, 9; jumptable 000000000008C90B default case
jnz short loc_8C8DD
cmp qword ptr [rbx+690h], 0
jz short loc_8C936
mov rax, [rbx+688h]
mov [rbx+718h], rax
loc_8C936:
mov rax, [rbx+7A8h]
mov rax, [rax+0A8h]
test rax, rax
jz short loc_8C8DD
add rbx, 6E0h
mov rdi, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp rax
loc_8C963:
lea rsi, aLastNonIgnorab; jumptable 000000000008C90B case 412
jmp short loc_8C9C4
loc_8C96C:
lea rsi, aFirstTertiaryI; jumptable 000000000008C90B case 405
jmp short loc_8C9C4
loc_8C975:
lea rsi, aLastVariable; jumptable 000000000008C90B case 410
jmp short loc_8C9C4
loc_8C97E:
lea rsi, aFirstSecondary; jumptable 000000000008C90B case 403
jmp short loc_8C9C4
loc_8C987:
lea rsi, aLastSecondaryI; jumptable 000000000008C90B case 404
jmp short loc_8C9C4
loc_8C990:
lea rsi, aLastTrailing; jumptable 000000000008C90B case 408
jmp short loc_8C9C4
loc_8C999:
lea rsi, aLastPrimaryIgn; jumptable 000000000008C90B case 402
jmp short loc_8C9C4
loc_8C9A2:
lea rsi, aLastTertiaryIg; jumptable 000000000008C90B case 406
jmp short loc_8C9C4
loc_8C9AB:
lea rsi, aFirstTrailing; jumptable 000000000008C90B case 407
jmp short loc_8C9C4
loc_8C9B4:
lea rsi, aFirstNonIgnora; jumptable 000000000008C90B case 411
jmp short loc_8C9C4
loc_8C9BD:
lea rsi, aFirstVariable; jumptable 000000000008C90B case 409
loc_8C9C4:
mov rdi, rbx
xor edx, edx
xor ecx, ecx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp tailoring_append
| long long cs_leave(long long a1, long long a2, long long a3)
{
_QWORD *v4; // rbx
char *v5; // r13
char *v6; // r12
long long result; // rax
long long ( *v8)(_QWORD *); // rax
v4 = *(_QWORD **)(a1 + 320);
v5 = (char *)&sec;
v6 = "xml";
while ( (unsigned int)strncmp(a2, v6, a3) || v6[a3] )
{
v6 = (char *)*((_QWORD *)v5 + 3);
v5 += 16;
if ( !v6 )
return 0LL;
}
switch ( *(_DWORD *)v5 )
{
case 0x191:
result = tailoring_append(v4, "[first primary ignorable]", 0LL, 0LL);
break;
case 0x192:
result = tailoring_append(v4, "[last primary ignorable]", 0LL, 0LL);
break;
case 0x193:
result = tailoring_append(v4, "[first secondary ignorable]", 0LL, 0LL);
break;
case 0x194:
result = tailoring_append(v4, "[last secondary ignorable]", 0LL, 0LL);
break;
case 0x195:
result = tailoring_append(v4, "[first tertiary ignorable]", 0LL, 0LL);
break;
case 0x196:
result = tailoring_append(v4, "[last tertiary ignorable]", 0LL, 0LL);
break;
case 0x197:
result = tailoring_append(v4, "[first trailing]", 0LL, 0LL);
break;
case 0x198:
result = tailoring_append(v4, "[last trailing]", 0LL, 0LL);
break;
case 0x199:
result = tailoring_append(v4, "[first variable]", 0LL, 0LL);
break;
case 0x19A:
result = tailoring_append(v4, "[last variable]", 0LL, 0LL);
break;
case 0x19B:
result = tailoring_append(v4, "[first non-ignorable]", 0LL, 0LL);
break;
case 0x19C:
result = tailoring_append(v4, "[last non-ignorable]", 0LL, 0LL);
break;
default:
if ( *(_DWORD *)v5 != 9 )
return 0LL;
if ( v4[210] )
v4[227] = v4[209];
v8 = *(long long ( **)(_QWORD *))(v4[245] + 168LL);
if ( !v8 )
return 0LL;
result = v8(v4 + 220);
break;
}
return result;
}
| cs_leave:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV R15,RSI
MOV RBX,qword ptr [RDI + 0x140]
LEA R13,[0x431470]
LEA R12,[0x196431]
LAB_0018c8b7:
MOV RDI,R15
MOV RSI,R12
MOV RDX,R14
CALL 0x00128180
TEST EAX,EAX
JNZ 0x0018c8d0
CMP byte ptr [R12 + R14*0x1],0x0
JZ 0x0018c8ee
LAB_0018c8d0:
MOV R12,qword ptr [R13 + 0x18]
ADD R13,0x10
TEST R12,R12
JNZ 0x0018c8b7
LAB_0018c8dd:
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0018c8ee:
MOV ECX,dword ptr [R13]
LEA EAX,[RCX + -0x191]
CMP EAX,0xb
JA 0x0018c919
LEA RCX,[0x41535c]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_191:
LEA RSI,[0x198fd9]
JMP 0x0018c9c4
LAB_0018c919:
CMP ECX,0x9
JNZ 0x0018c8dd
CMP qword ptr [RBX + 0x690],0x0
JZ 0x0018c936
MOV RAX,qword ptr [RBX + 0x688]
MOV qword ptr [RBX + 0x718],RAX
LAB_0018c936:
MOV RAX,qword ptr [RBX + 0x7a8]
MOV RAX,qword ptr [RAX + 0xa8]
TEST RAX,RAX
JZ 0x0018c8dd
ADD RBX,0x6e0
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP RAX
caseD_19c:
LEA RSI,[0x198fc4]
JMP 0x0018c9c4
caseD_195:
LEA RSI,[0x199043]
JMP 0x0018c9c4
caseD_19a:
LEA RSI,[0x1990aa]
JMP 0x0018c9c4
caseD_193:
LEA RSI,[0x19900c]
JMP 0x0018c9c4
caseD_194:
LEA RSI,[0x199028]
JMP 0x0018c9c4
caseD_198:
LEA RSI,[0x199089]
JMP 0x0018c9c4
caseD_192:
LEA RSI,[0x198ff3]
JMP 0x0018c9c4
caseD_196:
LEA RSI,[0x19905e]
JMP 0x0018c9c4
caseD_197:
LEA RSI,[0x199078]
JMP 0x0018c9c4
caseD_19b:
LEA RSI,[0x198fae]
JMP 0x0018c9c4
caseD_199:
LEA RSI,[0x199099]
LAB_0018c9c4:
MOV RDI,RBX
XOR EDX,EDX
XOR ECX,ECX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0018d214
|
int8 cs_leave(long param_1,char *param_2,size_t param_3)
{
long lVar1;
code *UNRECOVERED_JUMPTABLE;
int iVar2;
int8 uVar3;
char *pcVar4;
int *piVar5;
lVar1 = *(long *)(param_1 + 0x140);
piVar5 = &sec;
pcVar4 = "xml";
while ((iVar2 = strncmp(param_2,pcVar4,param_3), iVar2 != 0 || (pcVar4[param_3] != '\0'))) {
pcVar4 = *(char **)(piVar5 + 6);
piVar5 = piVar5 + 4;
if (pcVar4 == (char *)0x0) {
return 0;
}
}
switch(*piVar5) {
case 0x191:
pcVar4 = "[first primary ignorable]";
break;
case 0x192:
pcVar4 = "[last primary ignorable]";
break;
case 0x193:
pcVar4 = "[first secondary ignorable]";
break;
case 0x194:
pcVar4 = "[last secondary ignorable]";
break;
case 0x195:
pcVar4 = "[first tertiary ignorable]";
break;
case 0x196:
pcVar4 = "[last tertiary ignorable]";
break;
case 0x197:
pcVar4 = "[first trailing]";
break;
case 0x198:
pcVar4 = "[last trailing]";
break;
case 0x199:
pcVar4 = "[first variable]";
break;
case 0x19a:
pcVar4 = "[last variable]";
break;
case 0x19b:
pcVar4 = "[first non-ignorable]";
break;
case 0x19c:
pcVar4 = "[last non-ignorable]";
break;
default:
if (*piVar5 != 9) {
return 0;
}
if (*(long *)(lVar1 + 0x690) != 0) {
*(int8 *)(lVar1 + 0x718) = *(int8 *)(lVar1 + 0x688);
}
UNRECOVERED_JUMPTABLE = *(code **)(*(long *)(lVar1 + 0x7a8) + 0xa8);
if (UNRECOVERED_JUMPTABLE == (code *)0x0) {
return 0;
}
/* WARNING: Could not recover jumptable at 0x0018c961. Too many branches */
/* WARNING: Treating indirect jump as call */
uVar3 = (*UNRECOVERED_JUMPTABLE)(lVar1 + 0x6e0);
return uVar3;
}
uVar3 = tailoring_append(lVar1,pcVar4,0,0);
return uVar3;
}
| |
25,097 | init_one_value | eloqsql/mysys/my_getopt.c | static void init_one_value(const struct my_option *option, void *variable,
longlong value)
{
DBUG_ENTER("init_one_value");
switch ((option->var_type & GET_TYPE_MASK)) {
case GET_BOOL:
*((my_bool*) variable)= (my_bool) value;
break;
case GET_INT:
*((int*) variable)= (int) getopt_ll_limit_value((int) value, option, NULL);
break;
case GET_ENUM:
*((ulong*) variable)= (ulong) value;
break;
case GET_UINT:
*((uint*) variable)= (uint) getopt_ull_limit_value((uint) value, option, NULL);
break;
case GET_LONG:
*((long*) variable)= (long) getopt_ll_limit_value((long) value, option, NULL);
break;
case GET_ULONG:
*((ulong*) variable)= (ulong) getopt_ull_limit_value((ulong) value, option, NULL);
break;
case GET_LL:
*((longlong*) variable)= (longlong) getopt_ll_limit_value((longlong) value, option, NULL);
break;
case GET_ULL:
*((ulonglong*) variable)= (ulonglong) getopt_ull_limit_value((ulonglong) value, option, NULL);
break;
case GET_SET:
case GET_FLAGSET:
*((ulonglong*) variable)= (ulonglong) value;
break;
case GET_BIT:
{
ulonglong bit= (option->block_size >= 0 ?
option->block_size :
-option->block_size);
if (option->block_size < 0)
value= !value;
if (value)
(*(ulonglong*)variable)|= bit;
else
(*(ulonglong*)variable)&= ~bit;
break;
}
case GET_DOUBLE:
*((double*) variable)= getopt_ulonglong2double(value);
break;
case GET_STR:
/*
Do not clear variable value if it has no default value.
The default value may already be set.
NOTE: To avoid compiler warnings, we first cast longlong to intptr,
so that the value has the same size as a pointer.
*/
if ((char*) (intptr) value)
*((char**) variable)= (char*) (intptr) value;
break;
case GET_STR_ALLOC:
/*
Do not clear variable value if it has no default value.
The default value may already be set.
NOTE: To avoid compiler warnings, we first cast longlong to intptr,
so that the value has the same size as a pointer.
*/
if ((char*) (intptr) value)
{
char **pstr= (char **) variable;
my_free(*pstr);
*pstr= my_strdup(key_memory_defaults, (char*) (intptr) value, MYF(MY_WME));
}
break;
default: /* dummy default to avoid compiler warnings */
break;
}
DBUG_VOID_RETURN;
} | O3 | c | init_one_value:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x30(%rdi), %rax
andl $0x3f, %eax
addq $-0x2, %rax
cmpq $0xe, %rax
ja 0x269d7
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x3dea4(%rip), %rcx # 0x647d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, (%rbx)
jmp 0x269d7
movq %r14, %rdi
xorl %edx, %edx
callq 0x26ec3
jmp 0x269d4
movq %r14, %rdi
xorl %edx, %edx
callq 0x26fe4
jmp 0x269d4
movq 0x60(%rsi), %rcx
movq %rcx, %rax
negq %rax
cmovsq %rcx, %rax
xorl %edx, %edx
testq %r14, %r14
sete %dl
testq %rcx, %rcx
cmovnsq %r14, %rdx
testq %rdx, %rdx
je 0x269ce
orq (%rbx), %rax
jmp 0x269d4
movb %r14b, (%rbx)
jmp 0x269d7
movl %r14d, %edi
xorl %edx, %edx
callq 0x26fe4
jmp 0x269bf
testq %r14, %r14
je 0x269d7
movq (%rbx), %rdi
callq 0x284b6
leaq 0x343ec4(%rip), %rax # 0x36a868
movl (%rax), %edi
movl $0x10, %edx
movq %r14, %rsi
callq 0x2854c
jmp 0x269d4
movslq %r14d, %rdi
xorl %edx, %edx
callq 0x26ec3
movl %eax, (%rbx)
jmp 0x269d7
testq %r14, %r14
jne 0x26935
jmp 0x269d7
notq %rax
andq (%rbx), %rax
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
| init_one_value:
push rbp
mov rbp, rsp
push r14
push rbx
mov rax, [rdi+30h]
and eax, 3Fh
add rax, 0FFFFFFFFFFFFFFFEh; switch 15 cases
cmp rax, 0Eh
ja def_26933; jumptable 0000000000026933 default case, case 11
mov r14, rdx
mov rbx, rsi
mov rsi, rdi
lea rcx, jpt_26933
movsxd rax, ds:(jpt_26933 - 647D0h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_26935:
mov [rbx], r14; jumptable 0000000000026933 cases 12-15
jmp def_26933; jumptable 0000000000026933 default case, case 11
loc_2693D:
mov rdi, r14; jumptable 0000000000026933 cases 5,7
xor edx, edx
call getopt_ll_limit_value
jmp loc_269D4
loc_2694C:
mov rdi, r14; jumptable 0000000000026933 cases 6,8
xor edx, edx
call getopt_ull_limit_value
jmp short loc_269D4
loc_26958:
mov rcx, [rsi+60h]; jumptable 0000000000026933 case 16
mov rax, rcx
neg rax
cmovs rax, rcx
xor edx, edx
test r14, r14
setz dl
test rcx, rcx
cmovns rdx, r14
test rdx, rdx
jz short loc_269CE
or rax, [rbx]
jmp short loc_269D4
loc_2697F:
mov [rbx], r14b; jumptable 0000000000026933 case 2
jmp short def_26933; jumptable 0000000000026933 default case, case 11
loc_26984:
mov edi, r14d; jumptable 0000000000026933 case 4
xor edx, edx
call getopt_ull_limit_value
jmp short loc_269BF
loc_26990:
test r14, r14; jumptable 0000000000026933 case 10
jz short def_26933; jumptable 0000000000026933 default case, case 11
mov rdi, [rbx]
call my_free
lea rax, key_memory_defaults
mov edi, [rax]
mov edx, 10h
mov rsi, r14
call my_strdup
jmp short loc_269D4
loc_269B5:
movsxd rdi, r14d; jumptable 0000000000026933 case 3
xor edx, edx
call getopt_ll_limit_value
loc_269BF:
mov [rbx], eax
jmp short def_26933; jumptable 0000000000026933 default case, case 11
loc_269C3:
test r14, r14; jumptable 0000000000026933 case 9
jnz loc_26935; jumptable 0000000000026933 cases 12-15
jmp short def_26933; jumptable 0000000000026933 default case, case 11
loc_269CE:
not rax
and rax, [rbx]
loc_269D4:
mov [rbx], rax
def_26933:
pop rbx; jumptable 0000000000026933 default case, case 11
pop r14
pop rbp
retn
| long long init_one_value(long long a1, long long *a2, _BOOL8 a3)
{
long long result; // rax
long long v5; // rax
_BOOL8 v6; // rdx
result = (*(_QWORD *)(a1 + 48) & 0x3FLL) - 2;
switch ( *(_QWORD *)(a1 + 48) & 0x3FLL )
{
case 2LL:
*(_BYTE *)a2 = a3;
return result;
case 3LL:
result = getopt_ll_limit_value(a3, a1, 0LL);
goto LABEL_16;
case 4LL:
result = getopt_ull_limit_value(a3, a1, 0LL);
LABEL_16:
*(_DWORD *)a2 = result;
return result;
case 5LL:
case 7LL:
result = getopt_ll_limit_value(a3, a1, 0LL);
goto LABEL_20;
case 6LL:
case 8LL:
result = getopt_ull_limit_value(a3, a1, 0LL);
goto LABEL_20;
case 9LL:
if ( !a3 )
return result;
goto LABEL_2;
case 0xALL:
if ( !a3 )
return result;
my_free(*a2);
result = my_strdup(key_memory_defaults, a3, 16LL);
goto LABEL_20;
case 0xCLL:
case 0xDLL:
case 0xELL:
case 0xFLL:
LABEL_2:
*a2 = a3;
return result;
case 0x10LL:
v5 = -*(_QWORD *)(a1 + 96);
if ( *(long long *)(a1 + 96) > 0 )
v5 = *(_QWORD *)(a1 + 96);
v6 = !a3;
if ( *(long long *)(a1 + 96) >= 0 )
v6 = a3;
if ( v6 )
result = *a2 | v5;
else
result = *a2 & ~v5;
LABEL_20:
*a2 = result;
break;
default:
return result;
}
return result;
}
| init_one_value:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RAX,qword ptr [RDI + 0x30]
AND EAX,0x3f
ADD RAX,-0x2
CMP RAX,0xe
JA 0x001269d7
MOV R14,RDX
MOV RBX,RSI
MOV RSI,RDI
LEA RCX,[0x1647d0]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_c:
MOV qword ptr [RBX],R14
JMP 0x001269d7
caseD_5:
MOV RDI,R14
XOR EDX,EDX
CALL 0x00126ec3
JMP 0x001269d4
caseD_6:
MOV RDI,R14
XOR EDX,EDX
CALL 0x00126fe4
JMP 0x001269d4
caseD_10:
MOV RCX,qword ptr [RSI + 0x60]
MOV RAX,RCX
NEG RAX
CMOVS RAX,RCX
XOR EDX,EDX
TEST R14,R14
SETZ DL
TEST RCX,RCX
CMOVNS RDX,R14
TEST RDX,RDX
JZ 0x001269ce
OR RAX,qword ptr [RBX]
JMP 0x001269d4
caseD_2:
MOV byte ptr [RBX],R14B
JMP 0x001269d7
caseD_4:
MOV EDI,R14D
XOR EDX,EDX
CALL 0x00126fe4
JMP 0x001269bf
caseD_a:
TEST R14,R14
JZ 0x001269d7
MOV RDI,qword ptr [RBX]
CALL 0x001284b6
LEA RAX,[0x46a868]
MOV EDI,dword ptr [RAX]
MOV EDX,0x10
MOV RSI,R14
CALL 0x0012854c
JMP 0x001269d4
caseD_3:
MOVSXD RDI,R14D
XOR EDX,EDX
CALL 0x00126ec3
LAB_001269bf:
MOV dword ptr [RBX],EAX
JMP 0x001269d7
caseD_9:
TEST R14,R14
JNZ 0x00126935
JMP 0x001269d7
LAB_001269ce:
NOT RAX
AND RAX,qword ptr [RBX]
LAB_001269d4:
MOV qword ptr [RBX],RAX
caseD_b:
POP RBX
POP R14
POP RBP
RET
|
void init_one_value(long param_1,ulong *param_2,ulong param_3)
{
ulong uVar1;
int4 uVar2;
ulong uVar3;
ulong uVar4;
switch((uint)*(int8 *)(param_1 + 0x30) & 0x3f) {
case 2:
*(char *)param_2 = (char)param_3;
return;
case 3:
uVar2 = getopt_ll_limit_value((long)(int)param_3,param_1,0);
goto LAB_001269bf;
case 4:
uVar2 = getopt_ull_limit_value(param_3 & 0xffffffff,param_1,0);
LAB_001269bf:
*(int4 *)param_2 = uVar2;
return;
case 5:
case 7:
uVar3 = getopt_ll_limit_value(param_3,param_1,0);
break;
case 6:
case 8:
uVar3 = getopt_ull_limit_value(param_3,param_1,0);
break;
case 9:
if (param_3 == 0) {
return;
}
case 0xc:
case 0xd:
case 0xe:
case 0xf:
*param_2 = param_3;
return;
case 10:
if (param_3 == 0) {
return;
}
my_free(*param_2);
uVar3 = my_strdup(key_memory_defaults,param_3,0x10);
break;
default:
goto switchD_00126933_caseD_b;
case 0x10:
uVar1 = *(ulong *)(param_1 + 0x60);
uVar3 = -uVar1;
if (0 < (long)uVar1) {
uVar3 = uVar1;
}
uVar4 = (ulong)(param_3 == 0);
if (-1 < (long)uVar1) {
uVar4 = param_3;
}
if (uVar4 == 0) {
uVar3 = ~uVar3 & *param_2;
}
else {
uVar3 = uVar3 | *param_2;
}
}
*param_2 = uVar3;
switchD_00126933_caseD_b:
return;
}
| |
25,098 | LefDefParser::lefiPin::antennaModel(int) const | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiMacro.cpp | lefiPinAntennaModel *
lefiPin::antennaModel(int index) const
{
int j = index;
lefiPinAntennaModel *amo;
if (index == 0) { // reset all the return flags to 0, beginning of the loop
int i;
for (i = 0; i < 4; i++)
antennaModel_[i]->setAntennaReturnFlag(0);
}
while (j < 4) {
amo = antennaModel_[j];
if (!(amo->antennaOxide()) &&
(amo->hasReturn() == 0))
j++;
else
break;
if (j == 4) { // something very wrong, normally this can't happen
lefiError(0, 1351, "ERROR (LEFPARS-1351): There is an unexpected lef parser bug which cause it unable to retrieve ANTENNAMODEL data with the given index.");
return 0;
}
}
// If it arrived here, it is saved, mark the antennaModel has returned
antennaModel_[j]->setAntennaReturnFlag(1);
return antennaModel_[j];
} | O3 | cpp | LefDefParser::lefiPin::antennaModel(int) const:
pushq %rbx
testl %esi, %esi
jne 0x2a2ac
movq 0x178(%rdi), %rax
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdx
movl $0x0, 0x8(%rdx)
incq %rcx
cmpq $0x4, %rcx
jne 0x2a298
movq 0x178(%rdi), %rax
movslq %esi, %rcx
cmpl $0x5, %esi
movl $0x4, %edx
cmovgel %esi, %edx
cmpq %rcx, %rdx
je 0x2a2f6
movq (%rax,%rcx,8), %rsi
cmpq $0x0, (%rsi)
jne 0x2a2f8
cmpl $0x0, 0x8(%rsi)
jne 0x2a2f8
incq %rcx
cmpq $0x4, %rcx
jne 0x2a2c1
leaq 0x27dc3(%rip), %rdx # 0x520a9
xorl %ebx, %ebx
xorl %edi, %edi
movl $0x547, %esi # imm = 0x547
callq 0x27ae8
jmp 0x2a306
movl %edx, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rbx
movl $0x1, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
nop
| _ZNK12LefDefParser7lefiPin12antennaModelEi:
push rbx
test esi, esi
jnz short loc_2A2AC
mov rax, [rdi+178h]
xor ecx, ecx
loc_2A298:
mov rdx, [rax+rcx*8]
mov dword ptr [rdx+8], 0
inc rcx
cmp rcx, 4
jnz short loc_2A298
loc_2A2AC:
mov rax, [rdi+178h]
movsxd rcx, esi
cmp esi, 5
mov edx, 4
cmovge edx, esi
loc_2A2C1:
cmp rdx, rcx
jz short loc_2A2F6
mov rsi, [rax+rcx*8]
cmp qword ptr [rsi], 0
jnz short loc_2A2F8
cmp dword ptr [rsi+8], 0
jnz short loc_2A2F8
inc rcx; char *
cmp rcx, 4
jnz short loc_2A2C1
lea rdx, aErrorLefpars13_23; "ERROR (LEFPARS-1351): There is an unexp"...
xor ebx, ebx
xor edi, edi; this
mov esi, 547h; int
call _ZN12LefDefParser9lefiErrorEiiPKc; LefDefParser::lefiError(int,int,char const*)
jmp short loc_2A306
loc_2A2F6:
mov ecx, edx
loc_2A2F8:
movsxd rcx, ecx
mov rbx, [rax+rcx*8]
mov dword ptr [rbx+8], 1
loc_2A306:
mov rax, rbx
pop rbx
retn
| long long LefDefParser::lefiPin::antennaModel(LefDefParser::lefiPin *this, int a2)
{
long long v2; // rax
long long i; // rcx
long long v4; // rax
long long v5; // rcx
long long v6; // rdx
long long v7; // rsi
long long v8; // rbx
if ( !a2 )
{
v2 = *((_QWORD *)this + 47);
for ( i = 0LL; i != 4; ++i )
*(_DWORD *)(*(_QWORD *)(v2 + 8 * i) + 8LL) = 0;
}
v4 = *((_QWORD *)this + 47);
v5 = a2;
v6 = 4LL;
if ( a2 >= 5 )
v6 = (unsigned int)a2;
while ( v6 != v5 )
{
v7 = *(_QWORD *)(v4 + 8 * v5);
if ( *(_QWORD *)v7 || *(_DWORD *)(v7 + 8) )
goto LABEL_12;
if ( ++v5 == 4 )
{
v8 = 0LL;
LefDefParser::lefiError(
0LL,
1351,
(long long)"ERROR (LEFPARS-1351): There is an unexpected lef parser bug which cause it unable to retrieve ANTENNAMO"
"DEL data with the given index.",
&byte_4);
return v8;
}
}
LODWORD(v5) = v6;
LABEL_12:
v8 = *(_QWORD *)(v4 + 8LL * (int)v5);
*(_DWORD *)(v8 + 8) = 1;
return v8;
}
| antennaModel:
PUSH RBX
TEST ESI,ESI
JNZ 0x0012a2ac
MOV RAX,qword ptr [RDI + 0x178]
XOR ECX,ECX
LAB_0012a298:
MOV RDX,qword ptr [RAX + RCX*0x8]
MOV dword ptr [RDX + 0x8],0x0
INC RCX
CMP RCX,0x4
JNZ 0x0012a298
LAB_0012a2ac:
MOV RAX,qword ptr [RDI + 0x178]
MOVSXD RCX,ESI
CMP ESI,0x5
MOV EDX,0x4
CMOVGE EDX,ESI
LAB_0012a2c1:
CMP RDX,RCX
JZ 0x0012a2f6
MOV RSI,qword ptr [RAX + RCX*0x8]
CMP qword ptr [RSI],0x0
JNZ 0x0012a2f8
CMP dword ptr [RSI + 0x8],0x0
JNZ 0x0012a2f8
INC RCX
CMP RCX,0x4
JNZ 0x0012a2c1
LEA RDX,[0x1520a9]
XOR EBX,EBX
XOR EDI,EDI
MOV ESI,0x547
CALL 0x00127ae8
JMP 0x0012a306
LAB_0012a2f6:
MOV ECX,EDX
LAB_0012a2f8:
MOVSXD RCX,ECX
MOV RBX,qword ptr [RAX + RCX*0x8]
MOV dword ptr [RBX + 0x8],0x1
LAB_0012a306:
MOV RAX,RBX
POP RBX
RET
|
/* LefDefParser::lefiPin::antennaModel(int) const */
long __thiscall LefDefParser::lefiPin::antennaModel(lefiPin *this,int param_1)
{
long lVar1;
long *plVar2;
long lVar3;
ulong uVar4;
ulong uVar5;
ulong uVar6;
if (param_1 == 0) {
lVar1 = *(long *)(this + 0x178);
lVar3 = 0;
do {
*(int4 *)(*(long *)(lVar1 + lVar3 * 8) + 8) = 0;
lVar3 = lVar3 + 1;
} while (lVar3 != 4);
}
uVar4 = (ulong)param_1;
uVar6 = 4;
if (4 < param_1) {
uVar6 = (ulong)(uint)param_1;
}
while (((uVar5 = uVar6, uVar6 != uVar4 &&
(plVar2 = *(long **)(*(long *)(this + 0x178) + uVar4 * 8), uVar5 = uVar4, *plVar2 == 0))
&& ((int)plVar2[1] == 0))) {
uVar4 = uVar4 + 1;
if (uVar4 == 4) {
lefiError(0,0x547,
"ERROR (LEFPARS-1351): There is an unexpected lef parser bug which cause it unable to retrieve ANTENNAMODEL data with the given index."
);
return 0;
}
}
lVar1 = *(long *)(*(long *)(this + 0x178) + (long)(int)uVar5 * 8);
*(int4 *)(lVar1 + 8) = 1;
return lVar1;
}
| |
25,099 | allocate_full_pages | eloqsql/storage/maria/ma_bitmap.c | static ulong allocate_full_pages(MARIA_FILE_BITMAP *bitmap,
ulong pages_needed,
MARIA_BITMAP_BLOCK *block, my_bool full_page)
{
uchar *data, *data_end, *page_end;
uchar *best_data= 0;
uint min_size;
uint best_area_size, UNINIT_VAR(best_prefix_area_size);
uint page, size;
ulonglong UNINIT_VAR(best_prefix_bits);
DBUG_ENTER("allocate_full_pages");
DBUG_PRINT("enter", ("pages_needed: %lu", pages_needed));
min_size= pages_needed;
if (!full_page && min_size > BLOB_SEGMENT_MIN_SIZE)
min_size= BLOB_SEGMENT_MIN_SIZE;
best_area_size= ~(uint) 0;
data= bitmap->map + (bitmap->full_head_size/6)*6;
data_end= bitmap->map + bitmap->used_size;
page_end= bitmap->map + bitmap->total_size;
for (; data < page_end; data+= 6)
{
ulonglong bits= uint6korr(data); /* 6 bytes = 6*8/3= 16 patterns */
uchar *data_start;
ulonglong prefix_bits= 0;
uint area_size, prefix_area_size, suffix_area_size;
/* Find area with at least 16 free pages */
if (bits)
continue;
data_start= data;
/* Find size of area */
for (data+=6 ; data < data_end ; data+= 6)
{
if ((bits= uint6korr(data)))
break;
}
/*
Check if we are end of bitmap. In this case we know that
the rest of the bitmap is usable
*/
if (data >= data_end)
data= page_end;
area_size= (uint) (data - data_start) / 6 * 16;
if (area_size >= best_area_size)
continue;
prefix_area_size= suffix_area_size= 0;
if (!bits)
{
/*
End of page; All the rest of the bits on page are part of area
This is needed because bitmap->used_size only covers the set bits
in the bitmap.
*/
area_size+= (uint) (page_end - data) / 6 * 16;
if (area_size >= best_area_size)
break;
data= page_end;
}
else
{
/* Add bits at end of page */
for (; !(bits & 7); bits >>= 3)
suffix_area_size++;
area_size+= suffix_area_size;
}
if (data_start != bitmap->map)
{
/* Add bits before page */
bits= prefix_bits= uint6korr(data_start - 6);
DBUG_ASSERT(bits != 0);
/* 111 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 */
if (!(bits & 07000000000000000LL))
{
data_start-= 6;
do
{
prefix_area_size++;
bits<<= 3;
} while (!(bits & 07000000000000000LL));
area_size+= prefix_area_size;
/* Calculate offset to page from data_start */
prefix_area_size= 16 - prefix_area_size;
}
}
if (area_size >= min_size && area_size <= best_area_size)
{
best_data= data_start;
best_area_size= area_size;
best_prefix_bits= prefix_bits;
best_prefix_area_size= prefix_area_size;
/* Prefer to put data in biggest possible area */
if (area_size <= pages_needed)
min_size= area_size;
else
min_size= pages_needed;
}
}
if (!best_data)
DBUG_RETURN(0); /* No room on page */
/*
Now allocate MY_MIN(pages_needed, area_size), starting from
best_start + best_prefix_area_size
*/
if (best_area_size > pages_needed)
best_area_size= pages_needed;
/* For each 6 bytes we have 6*8/3= 16 patterns */
page= ((uint) (best_data - bitmap->map) * 8) / 3 + best_prefix_area_size;
block->page= bitmap->page + 1 + page;
block->page_count= best_area_size;
block->empty_space= 0;
block->sub_blocks= 0;
block->org_bitmap_value= 0;
block->used= 0;
DBUG_ASSERT(page + best_area_size < bitmap->pages_covered);
DBUG_PRINT("info", ("page: %lu page_count: %u",
(ulong) block->page, block->page_count));
if (best_prefix_area_size)
{
ulonglong tmp;
/* Convert offset back to bits */
best_prefix_area_size= 16 - best_prefix_area_size;
if (best_area_size < best_prefix_area_size)
{
tmp= (1LL << best_area_size*3) - 1;
best_area_size= best_prefix_area_size; /* for easy end test */
}
else
tmp= (1LL << best_prefix_area_size*3) - 1;
tmp<<= (16 - best_prefix_area_size) * 3;
DBUG_ASSERT((best_prefix_bits & tmp) == 0);
best_prefix_bits|= tmp;
int6store(best_data, best_prefix_bits);
if (!(best_area_size-= best_prefix_area_size))
goto end;
best_data+= 6;
}
best_area_size*= 3; /* Bits to set */
size= best_area_size/8; /* Bytes to set */
bfill(best_data, size, 255);
best_data+= size;
if ((best_area_size-= size * 8))
{
/* fill last uchar */
*best_data|= (uchar) ((1 << best_area_size) -1);
best_data++;
}
if (data_end < best_data)
{
bitmap->used_size= (uint) (best_data - bitmap->map);
DBUG_ASSERT(bitmap->used_size <= bitmap->total_size);
}
end:
bitmap->changed= 1;
DBUG_EXECUTE("bitmap", _ma_print_bitmap_changes(bitmap););
DBUG_RETURN(block->page_count);
} | O3 | c | allocate_full_pages:
movl 0x28(%rdi), %eax
movl $0xaaaaaaab, %r8d # imm = 0xAAAAAAAB
imulq %r8, %rax
shrq $0x22, %rax
addl %eax, %eax
leal (%rax,%rax,2), %r9d
movl 0x128(%rdi), %eax
cmpl %eax, %r9d
jae 0x422ef
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, -0x38(%rbp)
movq 0x8(%rdi), %r8
movq %rdi, -0x30(%rbp)
movl 0x24(%rdi), %ebx
addq %r8, %rbx
addq %r8, %rax
movl %r9d, %r12d
addq %r8, %r12
testb %cl, %cl
movl $0x80, %ecx
cmovnel %esi, %ecx
cmpq $0x81, %rsi
cmovbl %esi, %ecx
movl $0xffffffff, %r10d # imm = 0xFFFFFFFF
movq $0x0, -0x48(%rbp)
movabsq $0x1c0000000000, %r11 # imm = 0x1C0000000000
movq %rdx, -0x40(%rbp)
movl (%r12), %edi
movzwl 0x4(%r12), %r9d
orq %rdi, %r9
je 0x421d4
movq %r12, %r13
addq $0x6, %r13
movq %r13, %r12
cmpq %rax, %r13
jb 0x421b1
jmp 0x422f2
leaq 0x6(%r12), %r9
xorl %r13d, %r13d
leaq (%r9,%r13), %rdi
cmpq %rbx, %rdi
jae 0x42240
movl (%r9,%r13), %r15d
movzwl 0x4(%r9,%r13), %edi
shlq $0x20, %rdi
addq $0x6, %r13
orq %r15, %rdi
je 0x421dc
movl %r13d, %r14d
movl $0xaaaaaaab, %edx # imm = 0xAAAAAAAB
imulq %rdx, %r14
shrq $0x20, %r14
shll $0x2, %r14d
andl $-0x10, %r14d
addq %r12, %r13
cmpl %r10d, %r14d
jae 0x421c3
xorl %r9d, %r9d
testb $0x7, %r15b
jne 0x4223b
xorl %r9d, %r9d
movq %rdi, %r15
incl %r9d
shrq $0x3, %r15
testb $0x38, %dil
movq %r15, %rdi
je 0x4222b
addl %r14d, %r9d
jmp 0x42263
movl %eax, %r9d
subl %r12d, %r9d
movl $0xaaaaaaab, %edx # imm = 0xAAAAAAAB
imulq %rdx, %r9
shrq $0x20, %r9
shll $0x2, %r9d
andl $-0x10, %r9d
movq %rax, %r13
cmpl %r10d, %r9d
jae 0x422ab
xorl %edi, %edi
cmpq %r8, %r12
je 0x422b3
movl -0x6(%r12), %r15d
movzwl -0x2(%r12), %r14d
movq %r14, %rdx
shlq $0x20, %rdx
orq %r15, %rdx
cmpq $0x1fff, %r14 # imm = 0x1FFF
ja 0x422b8
addq $-0x6, %r12
xorl %edi, %edi
movq %rdx, %r15
leaq (,%r15,8), %r14
decl %edi
testq %r11, %r15
movq %r14, %r15
je 0x42291
subl %edi, %r9d
addl $0x10, %edi
jmp 0x422b8
movq %rax, %r13
jmp 0x421c3
movq %r8, %r12
xorl %edx, %edx
cmpl %ecx, %r9d
setb %r14b
cmpl %r10d, %r9d
seta %r15b
orb %r14b, %r15b
jne 0x421c3
movl %r9d, %ecx
cmpq %rsi, %rcx
movl %r9d, %ecx
cmoval %esi, %ecx
movl %r9d, %r10d
movq %rdi, -0x40(%rbp)
movq %r12, -0x48(%rbp)
movq %rdx, -0x50(%rbp)
jmp 0x421c3
xorl %eax, %eax
retq
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x423eb
movl %r10d, %eax
cmpq %rsi, %rax
cmovbel %r10d, %esi
movl %edi, %eax
subl %r8d, %eax
shll $0x3, %eax
movl $0xaaaaaaab, %ecx # imm = 0xAAAAAAAB
imulq %rax, %rcx
shrq $0x21, %rcx
movq -0x40(%rbp), %r10
addl %r10d, %ecx
movq -0x30(%rbp), %r8
movq 0x10(%r8), %rax
addq %rcx, %rax
incq %rax
movq -0x38(%rbp), %r9
movq %rax, (%r9)
movl %esi, 0x8(%r9)
movq $0x0, 0xc(%r9)
movw $0x0, 0x14(%r9)
testl %r10d, %r10d
je 0x42393
movl $0x10, %eax
subl %r10d, %eax
cmpl %eax, %esi
movl %eax, %ecx
cmovbl %esi, %ecx
leal (%rcx,%rcx,2), %ecx
movq $-0x1, %rdx
shlq %cl, %rdx
notq %rdx
leal (%r10,%r10,2), %ecx
shlq %cl, %rdx
orq -0x50(%rbp), %rdx
movl %edx, (%rdi)
shrq $0x20, %rdx
xorl %ecx, %ecx
movw %dx, 0x4(%rdi)
subl %eax, %esi
cmovbl %ecx, %esi
jbe 0x423e0
addq $0x6, %rdi
leal (%rsi,%rsi,2), %r12d
movl %r12d, %r13d
shrl $0x3, %r13d
movl $0xff, %esi
movq %r13, %rdx
movq %rdi, %r14
callq 0x292c0
movq %r14, %rdx
addq %r13, %rdx
andl $0x7, %r12d
je 0x423cb
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movl %r12d, %ecx
shll %cl, %eax
notb %al
orb %al, (%rdx)
incq %rdx
movq -0x38(%rbp), %r9
movq -0x30(%rbp), %r8
cmpq %rdx, %rbx
jae 0x423e0
subl 0x8(%r8), %edx
movl %edx, 0x24(%r8)
movb $0x1, 0x20(%r8)
movl 0x8(%r9), %eax
jmp 0x423ed
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| allocate_full_pages:
mov eax, [rdi+28h]
mov r8d, 0AAAAAAABh
imul rax, r8
shr rax, 22h
add eax, eax
lea r9d, [rax+rax*2]
mov eax, [rdi+128h]
cmp r9d, eax
jnb loc_422EF
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rbp-38h], rdx
mov r8, [rdi+8]
mov [rbp-30h], rdi
mov ebx, [rdi+24h]
add rbx, r8
add rax, r8
mov r12d, r9d
add r12, r8
test cl, cl
mov ecx, 80h
cmovnz ecx, esi
cmp rsi, 81h
cmovb ecx, esi
mov r10d, 0FFFFFFFFh
mov qword ptr [rbp-48h], 0
mov r11, 1C0000000000h
mov [rbp-40h], rdx
loc_421B1:
mov edi, [r12]
movzx r9d, word ptr [r12+4]
or r9, rdi
jz short loc_421D4
mov r13, r12
loc_421C3:
add r13, 6
mov r12, r13
cmp r13, rax
jb short loc_421B1
jmp loc_422F2
loc_421D4:
lea r9, [r12+6]
xor r13d, r13d
loc_421DC:
lea rdi, [r9+r13]
cmp rdi, rbx
jnb short loc_42240
mov r15d, [r9+r13]
movzx edi, word ptr [r9+r13+4]
shl rdi, 20h
add r13, 6
or rdi, r15
jz short loc_421DC
mov r14d, r13d
mov edx, 0AAAAAAABh
imul r14, rdx
shr r14, 20h
shl r14d, 2
and r14d, 0FFFFFFF0h
add r13, r12
cmp r14d, r10d
jnb short loc_421C3
xor r9d, r9d
test r15b, 7
jnz short loc_4223B
xor r9d, r9d
mov r15, rdi
loc_4222B:
inc r9d
shr r15, 3
test dil, 38h
mov rdi, r15
jz short loc_4222B
loc_4223B:
add r9d, r14d
jmp short loc_42263
loc_42240:
mov r9d, eax
sub r9d, r12d
mov edx, 0AAAAAAABh
imul r9, rdx
shr r9, 20h
shl r9d, 2
and r9d, 0FFFFFFF0h
mov r13, rax
cmp r9d, r10d
jnb short loc_422AB
loc_42263:
xor edi, edi
cmp r12, r8
jz short loc_422B3
mov r15d, [r12-6]
movzx r14d, word ptr [r12-2]
mov rdx, r14
shl rdx, 20h
or rdx, r15
cmp r14, 1FFFh
ja short loc_422B8
add r12, 0FFFFFFFFFFFFFFFAh
xor edi, edi
mov r15, rdx
loc_42291:
lea r14, ds:0[r15*8]
dec edi
test r15, r11
mov r15, r14
jz short loc_42291
sub r9d, edi
add edi, 10h
jmp short loc_422B8
loc_422AB:
mov r13, rax
jmp loc_421C3
loc_422B3:
mov r12, r8
xor edx, edx
loc_422B8:
cmp r9d, ecx
setb r14b
cmp r9d, r10d
setnbe r15b
or r15b, r14b
jnz loc_421C3
mov ecx, r9d
cmp rcx, rsi
mov ecx, r9d
cmova ecx, esi
mov r10d, r9d
mov [rbp-40h], rdi
mov [rbp-48h], r12
mov [rbp-50h], rdx
jmp loc_421C3
loc_422EF:
xor eax, eax
retn
loc_422F2:
mov rdi, [rbp-48h]
test rdi, rdi
jz loc_423EB
mov eax, r10d
cmp rax, rsi
cmovbe esi, r10d
mov eax, edi
sub eax, r8d
shl eax, 3
mov ecx, 0AAAAAAABh
imul rcx, rax
shr rcx, 21h
mov r10, [rbp-40h]
add ecx, r10d
mov r8, [rbp-30h]
mov rax, [r8+10h]
add rax, rcx
inc rax
mov r9, [rbp-38h]
mov [r9], rax
mov [r9+8], esi
mov qword ptr [r9+0Ch], 0
mov word ptr [r9+14h], 0
test r10d, r10d
jz short loc_42393
mov eax, 10h
sub eax, r10d
cmp esi, eax
mov ecx, eax
cmovb ecx, esi
lea ecx, [rcx+rcx*2]
mov rdx, 0FFFFFFFFFFFFFFFFh
shl rdx, cl
not rdx
lea ecx, [r10+r10*2]
shl rdx, cl
or rdx, [rbp-50h]
mov [rdi], edx
shr rdx, 20h
xor ecx, ecx
mov [rdi+4], dx
sub esi, eax
cmovb esi, ecx
jbe short loc_423E0
add rdi, 6
loc_42393:
lea r12d, [rsi+rsi*2]
mov r13d, r12d
shr r13d, 3
mov esi, 0FFh
mov rdx, r13
mov r14, rdi
call _memset
mov rdx, r14
add rdx, r13
and r12d, 7
jz short loc_423CB
mov eax, 0FFFFFFFFh
mov ecx, r12d
shl eax, cl
not al
or [rdx], al
inc rdx
loc_423CB:
mov r9, [rbp-38h]
mov r8, [rbp-30h]
cmp rbx, rdx
jnb short loc_423E0
sub edx, [r8+8]
mov [r8+24h], edx
loc_423E0:
mov byte ptr [r8+20h], 1
mov eax, [r9+8]
jmp short loc_423ED
loc_423EB:
xor eax, eax
loc_423ED:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long allocate_full_pages(long long a1, unsigned long long a2, long long a3, char a4)
{
unsigned int v4; // r9d
long long v5; // rax
unsigned int *v6; // r8
unsigned long long v7; // rbx
unsigned long long v8; // rax
unsigned int *v9; // r12
bool v10; // zf
unsigned int v11; // ecx
unsigned int v12; // r10d
char *v13; // r13
char *v14; // r9
long long v15; // r13
long long v16; // r15
unsigned long long v17; // rdi
unsigned long long v18; // rdi
unsigned int v19; // r14d
int v20; // r9d
unsigned long long v21; // r15
unsigned int v22; // r9d
int v23; // edi
unsigned long long v24; // rdx
int v25; // edi
unsigned long long v26; // r15
unsigned int *v28; // rdi
long long v29; // rcx
long long v30; // r8
long long v31; // r9
unsigned int v32; // eax
char v33; // cl
long long v34; // rdx
bool v35; // cf
bool v36; // cc
long long v37; // r13
char *v38; // rdx
unsigned long long v39; // [rsp-58h] [rbp-58h]
unsigned int *v40; // [rsp-50h] [rbp-50h]
int v41; // [rsp-48h] [rbp-48h]
v4 = 6 * (*(_DWORD *)(a1 + 40) / 6u);
v5 = *(unsigned int *)(a1 + 296);
if ( v4 >= (unsigned int)v5 )
return 0LL;
v6 = *(unsigned int **)(a1 + 8);
v7 = (unsigned long long)v6 + *(unsigned int *)(a1 + 36);
v8 = (unsigned long long)v6 + v5;
v9 = (unsigned int *)((char *)v6 + v4);
v10 = a4 == 0;
v11 = 128;
if ( !v10 )
v11 = a2;
if ( a2 < 0x81 )
v11 = a2;
v12 = -1;
v40 = 0LL;
v41 = a3;
do
{
if ( *v9 | (unsigned long long)*((unsigned __int16 *)v9 + 2) )
{
v13 = (char *)v9;
}
else
{
v14 = (char *)v9 + 6;
v15 = 0LL;
while ( (unsigned long long)&v14[v15] < v7 )
{
v16 = *(unsigned int *)&v14[v15];
v17 = (unsigned long long)*(unsigned __int16 *)&v14[v15 + 4] << 32;
v15 += 6LL;
v18 = v16 | v17;
if ( v18 )
{
v19 = (4 * ((2863311531u * (unsigned long long)(unsigned int)v15) >> 32)) & 0xFFFFFFF0;
v13 = (char *)v9 + v15;
if ( v19 >= v12 )
goto LABEL_9;
v20 = 0;
if ( (v16 & 7) == 0 )
{
v20 = 0;
v21 = v18;
do
{
++v20;
v21 >>= 3;
v10 = (v18 & 0x38) == 0;
LOBYTE(v18) = v21;
}
while ( v10 );
}
v22 = v19 + v20;
goto LABEL_20;
}
}
v22 = (4 * ((2863311531u * (unsigned long long)(unsigned int)(v8 - (_DWORD)v9)) >> 32)) & 0xFFFFFFF0;
v13 = (char *)v8;
if ( v22 >= v12 )
{
v13 = (char *)v8;
goto LABEL_9;
}
LABEL_20:
v23 = 0;
if ( v9 == v6 )
{
v9 = v6;
v24 = 0LL;
}
else
{
v24 = *(unsigned int *)((char *)v9 - 6) | ((unsigned long long)*((unsigned __int16 *)v9 - 1) << 32);
if ( *((unsigned __int16 *)v9 - 1) <= 0x1FFFuLL )
{
v9 = (unsigned int *)((char *)v9 - 6);
v25 = 0;
v26 = v24;
do
{
--v25;
v10 = (v26 & 0x1C0000000000LL) == 0;
v26 *= 8LL;
}
while ( v10 );
v22 -= v25;
v23 = v25 + 16;
}
}
if ( v22 >= v11 && v22 <= v12 )
{
v11 = v22;
if ( v22 > a2 )
v11 = a2;
v12 = v22;
v41 = v23;
v40 = v9;
v39 = v24;
}
}
LABEL_9:
v9 = (unsigned int *)(v13 + 6);
}
while ( (unsigned long long)(v13 + 6) < v8 );
v28 = v40;
if ( v40 )
{
if ( v12 <= a2 )
LODWORD(a2) = v12;
v29 = v41 + 8 * ((int)v40 - (int)v6) / 3u;
v30 = a1;
v31 = a3;
*(_QWORD *)a3 = v29 + *(_QWORD *)(a1 + 16) + 1;
*(_DWORD *)(a3 + 8) = a2;
*(_QWORD *)(a3 + 12) = 0LL;
*(_WORD *)(a3 + 20) = 0;
if ( v41 )
{
v32 = 16 - v41;
v33 = 16 - v41;
if ( (unsigned int)a2 < 16 - v41 )
v33 = a2;
v34 = v39 | (~(-1LL << (3 * v33)) << (3 * (unsigned __int8)v41));
*v40 = v34;
*((_WORD *)v40 + 2) = WORD2(v34);
v35 = (unsigned int)a2 < v32;
LODWORD(a2) = a2 - v32;
v36 = v35 || (_DWORD)a2 == 0;
if ( v35 )
LODWORD(a2) = 0;
if ( v36 )
goto LABEL_46;
v28 = (unsigned int *)((char *)v40 + 6);
}
v37 = (unsigned int)(3 * a2) >> 3;
memset(v28, 255LL, v37);
v38 = (char *)v28 + v37;
if ( ((3 * (_BYTE)a2) & 7) != 0 )
*v38++ |= ~(unsigned __int8)(-1 << ((3 * a2) & 7));
v31 = a3;
v30 = a1;
if ( v7 < (unsigned long long)v38 )
*(_DWORD *)(a1 + 36) = (_DWORD)v38 - *(_DWORD *)(a1 + 8);
LABEL_46:
*(_BYTE *)(v30 + 32) = 1;
return *(unsigned int *)(v31 + 8);
}
return 0LL;
}
| allocate_full_pages:
MOV EAX,dword ptr [RDI + 0x28]
MOV R8D,0xaaaaaaab
IMUL RAX,R8
SHR RAX,0x22
ADD EAX,EAX
LEA R9D,[RAX + RAX*0x2]
MOV EAX,dword ptr [RDI + 0x128]
CMP R9D,EAX
JNC 0x001422ef
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x38],RDX
MOV R8,qword ptr [RDI + 0x8]
MOV qword ptr [RBP + -0x30],RDI
MOV EBX,dword ptr [RDI + 0x24]
ADD RBX,R8
ADD RAX,R8
MOV R12D,R9D
ADD R12,R8
TEST CL,CL
MOV ECX,0x80
CMOVNZ ECX,ESI
CMP RSI,0x81
CMOVC ECX,ESI
MOV R10D,0xffffffff
MOV qword ptr [RBP + -0x48],0x0
MOV R11,0x1c0000000000
MOV qword ptr [RBP + -0x40],RDX
LAB_001421b1:
MOV EDI,dword ptr [R12]
MOVZX R9D,word ptr [R12 + 0x4]
OR R9,RDI
JZ 0x001421d4
MOV R13,R12
LAB_001421c3:
ADD R13,0x6
MOV R12,R13
CMP R13,RAX
JC 0x001421b1
JMP 0x001422f2
LAB_001421d4:
LEA R9,[R12 + 0x6]
XOR R13D,R13D
LAB_001421dc:
LEA RDI,[R9 + R13*0x1]
CMP RDI,RBX
JNC 0x00142240
MOV R15D,dword ptr [R9 + R13*0x1]
MOVZX EDI,word ptr [R9 + R13*0x1 + 0x4]
SHL RDI,0x20
ADD R13,0x6
OR RDI,R15
JZ 0x001421dc
MOV R14D,R13D
MOV EDX,0xaaaaaaab
IMUL R14,RDX
SHR R14,0x20
SHL R14D,0x2
AND R14D,0xfffffff0
ADD R13,R12
CMP R14D,R10D
JNC 0x001421c3
XOR R9D,R9D
TEST R15B,0x7
JNZ 0x0014223b
XOR R9D,R9D
MOV R15,RDI
LAB_0014222b:
INC R9D
SHR R15,0x3
TEST DIL,0x38
MOV RDI,R15
JZ 0x0014222b
LAB_0014223b:
ADD R9D,R14D
JMP 0x00142263
LAB_00142240:
MOV R9D,EAX
SUB R9D,R12D
MOV EDX,0xaaaaaaab
IMUL R9,RDX
SHR R9,0x20
SHL R9D,0x2
AND R9D,0xfffffff0
MOV R13,RAX
CMP R9D,R10D
JNC 0x001422ab
LAB_00142263:
XOR EDI,EDI
CMP R12,R8
JZ 0x001422b3
MOV R15D,dword ptr [R12 + -0x6]
MOVZX R14D,word ptr [R12 + -0x2]
MOV RDX,R14
SHL RDX,0x20
OR RDX,R15
CMP R14,0x1fff
JA 0x001422b8
ADD R12,-0x6
XOR EDI,EDI
MOV R15,RDX
LAB_00142291:
LEA R14,[R15*0x8]
DEC EDI
TEST R15,R11
MOV R15,R14
JZ 0x00142291
SUB R9D,EDI
ADD EDI,0x10
JMP 0x001422b8
LAB_001422ab:
MOV R13,RAX
JMP 0x001421c3
LAB_001422b3:
MOV R12,R8
XOR EDX,EDX
LAB_001422b8:
CMP R9D,ECX
SETC R14B
CMP R9D,R10D
SETA R15B
OR R15B,R14B
JNZ 0x001421c3
MOV ECX,R9D
CMP RCX,RSI
MOV ECX,R9D
CMOVA ECX,ESI
MOV R10D,R9D
MOV qword ptr [RBP + -0x40],RDI
MOV qword ptr [RBP + -0x48],R12
MOV qword ptr [RBP + -0x50],RDX
JMP 0x001421c3
LAB_001422ef:
XOR EAX,EAX
RET
LAB_001422f2:
MOV RDI,qword ptr [RBP + -0x48]
TEST RDI,RDI
JZ 0x001423eb
MOV EAX,R10D
CMP RAX,RSI
CMOVBE ESI,R10D
MOV EAX,EDI
SUB EAX,R8D
SHL EAX,0x3
MOV ECX,0xaaaaaaab
IMUL RCX,RAX
SHR RCX,0x21
MOV R10,qword ptr [RBP + -0x40]
ADD ECX,R10D
MOV R8,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [R8 + 0x10]
ADD RAX,RCX
INC RAX
MOV R9,qword ptr [RBP + -0x38]
MOV qword ptr [R9],RAX
MOV dword ptr [R9 + 0x8],ESI
MOV qword ptr [R9 + 0xc],0x0
MOV word ptr [R9 + 0x14],0x0
TEST R10D,R10D
JZ 0x00142393
MOV EAX,0x10
SUB EAX,R10D
CMP ESI,EAX
MOV ECX,EAX
CMOVC ECX,ESI
LEA ECX,[RCX + RCX*0x2]
MOV RDX,-0x1
SHL RDX,CL
NOT RDX
LEA ECX,[R10 + R10*0x2]
SHL RDX,CL
OR RDX,qword ptr [RBP + -0x50]
MOV dword ptr [RDI],EDX
SHR RDX,0x20
XOR ECX,ECX
MOV word ptr [RDI + 0x4],DX
SUB ESI,EAX
CMOVC ESI,ECX
JBE 0x001423e0
ADD RDI,0x6
LAB_00142393:
LEA R12D,[RSI + RSI*0x2]
MOV R13D,R12D
SHR R13D,0x3
MOV ESI,0xff
MOV RDX,R13
MOV R14,RDI
CALL 0x001292c0
MOV RDX,R14
ADD RDX,R13
AND R12D,0x7
JZ 0x001423cb
MOV EAX,0xffffffff
MOV ECX,R12D
SHL EAX,CL
NOT AL
OR byte ptr [RDX],AL
INC RDX
LAB_001423cb:
MOV R9,qword ptr [RBP + -0x38]
MOV R8,qword ptr [RBP + -0x30]
CMP RBX,RDX
JNC 0x001423e0
SUB EDX,dword ptr [R8 + 0x8]
MOV dword ptr [R8 + 0x24],EDX
LAB_001423e0:
MOV byte ptr [R8 + 0x20],0x1
MOV EAX,dword ptr [R9 + 0x8]
JMP 0x001423ed
LAB_001423eb:
XOR EAX,EAX
LAB_001423ed:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int4 allocate_full_pages(long param_1,ulong param_2,long *param_3,char param_4)
{
int *piVar1;
ulong uVar2;
long lVar3;
uint uVar4;
int *piVar5;
ulong uVar6;
byte *pbVar7;
byte *pbVar8;
int iVar9;
ulong uVar10;
long *plVar11;
int iVar12;
ulong uVar13;
uint uVar14;
int *piVar15;
int *piVar16;
ulong uVar17;
uint uVar18;
bool bVar19;
ulong local_58;
int *local_50;
long *local_48;
uVar14 = (*(uint *)(param_1 + 0x28) / 6) * 6;
if (*(uint *)(param_1 + 0x128) <= uVar14) {
return 0;
}
piVar1 = *(int **)(param_1 + 8);
pbVar8 = (byte *)((ulong)*(uint *)(param_1 + 0x24) + (long)piVar1);
piVar5 = (int *)((ulong)*(uint *)(param_1 + 0x128) + (long)piVar1);
piVar15 = (int *)((ulong)uVar14 + (long)piVar1);
uVar6 = 0x80;
if (param_4 != '\0') {
uVar6 = param_2 & 0xffffffff;
}
if (param_2 < 0x81) {
uVar6 = param_2 & 0xffffffff;
}
uVar13 = 0xffffffff;
local_50 = (int *)0x0;
local_48 = param_3;
do {
piVar16 = piVar15;
if ((short)piVar15[1] == 0 && *piVar15 == 0) {
uVar17 = 0;
do {
uVar14 = (uint)uVar13;
if (pbVar8 <= (byte *)((long)piVar15 + uVar17 + 6)) {
uVar18 = ((uint)((ulong)(uint)((int)piVar5 - (int)piVar15) * 0xaaaaaaab >> 0x20) &
0x3ffffffc) << 2;
piVar16 = piVar5;
if (uVar18 < uVar14) goto LAB_00142263;
goto LAB_001421c3;
}
uVar4 = *(uint *)((long)piVar15 + uVar17 + 6);
lVar3 = uVar17 + 10;
uVar17 = uVar17 + 6;
uVar10 = (ulong)CONCAT24(*(int2 *)((long)piVar15 + lVar3),uVar4);
} while (uVar10 == 0);
uVar18 = ((uint)((uVar17 & 0xffffffff) * 0xaaaaaaab >> 0x20) & 0x3ffffffc) * 4;
piVar16 = (int *)(uVar17 + (long)piVar15);
if (uVar18 < uVar14) {
iVar12 = 0;
if ((uVar4 & 7) == 0) {
iVar12 = 0;
do {
iVar12 = iVar12 + 1;
uVar17 = uVar10 & 0x38;
uVar10 = uVar10 >> 3;
} while (uVar17 == 0);
}
uVar18 = iVar12 + uVar18;
LAB_00142263:
plVar11 = (long *)0x0;
if (piVar15 == piVar1) {
uVar17 = 0;
piVar15 = piVar1;
}
else {
uVar17 = (ulong)*(uint6 *)((long)piVar15 + -6);
if (*(ushort *)((long)piVar15 + -2) < 0x2000) {
uVar10 = uVar17;
iVar12 = 0;
do {
iVar9 = iVar12;
iVar12 = iVar9 + -1;
uVar2 = uVar10 & 0x1c0000000000;
uVar10 = uVar10 * 8;
} while (uVar2 == 0);
uVar18 = uVar18 - iVar12;
plVar11 = (long *)(ulong)(iVar9 + 0xf);
piVar15 = (int *)((long)piVar15 + -6);
}
}
if (uVar18 <= uVar14 && (uint)uVar6 <= uVar18) {
uVar6 = (ulong)uVar18;
if (param_2 < uVar18) {
uVar6 = param_2 & 0xffffffff;
}
uVar13 = (ulong)uVar18;
local_58 = uVar17;
local_50 = piVar15;
local_48 = plVar11;
}
}
}
LAB_001421c3:
piVar15 = (int *)((long)piVar16 + 6);
} while (piVar15 < piVar5);
if (local_50 == (int *)0x0) {
return 0;
}
uVar14 = (uint)param_2;
if (uVar13 <= param_2) {
uVar14 = (uint)uVar13;
}
iVar12 = (int)local_48;
*param_3 = *(long *)(param_1 + 0x10) +
(ulong)((uint)(((int)local_50 - (int)piVar1) * 8) / 3 + iVar12) + 1;
*(uint *)(param_3 + 1) = uVar14;
*(int8 *)((long)param_3 + 0xc) = 0;
*(int2 *)((long)param_3 + 0x14) = 0;
if (iVar12 != 0) {
uVar4 = 0x10 - iVar12;
uVar18 = uVar4;
if (uVar14 < uVar4) {
uVar18 = uVar14;
}
uVar6 = ~(-1L << ((char)uVar18 * '\x03' & 0x3fU)) << ((char)local_48 * '\x03' & 0x3fU) |
local_58;
*local_50 = (int)uVar6;
*(short *)(local_50 + 1) = (short)(uVar6 >> 0x20);
bVar19 = uVar14 < uVar4;
uVar4 = uVar14 - uVar4;
uVar14 = uVar4;
if (bVar19) {
uVar14 = 0;
}
if (bVar19 || uVar4 == 0) goto LAB_001423e0;
local_50 = (int *)((long)local_50 + 6);
}
uVar6 = (ulong)(uVar14 * 3 >> 3);
memset(local_50,0xff,uVar6);
pbVar7 = (byte *)((long)local_50 + uVar6);
uVar14 = uVar14 * 3 & 7;
if (uVar14 != 0) {
*pbVar7 = *pbVar7 | ~(byte)(-1 << (sbyte)uVar14);
pbVar7 = pbVar7 + 1;
}
if (pbVar8 < pbVar7) {
*(int *)(param_1 + 0x24) = (int)pbVar7 - *(int *)(param_1 + 8);
}
LAB_001423e0:
*(int1 *)(param_1 + 0x20) = 1;
return (int)param_3[1];
}
|
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.