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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
45,600 | rlOrtho | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rlgl.h | void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar)
{
// NOTE: If left-right and top-botton values are equal it could create a division by zero,
// response to it is platform/compiler dependant
Matrix matOrtho = { 0 };
float rl = (float)(right - left);
float tb = (float)(top - bottom);
float fn = (float)(zfar - znear);
matOrtho.m0 = 2.0f/rl;
matOrtho.m1 = 0.0f;
matOrtho.m2 = 0.0f;
matOrtho.m3 = 0.0f;
matOrtho.m4 = 0.0f;
matOrtho.m5 = 2.0f/tb;
matOrtho.m6 = 0.0f;
matOrtho.m7 = 0.0f;
matOrtho.m8 = 0.0f;
matOrtho.m9 = 0.0f;
matOrtho.m10 = -2.0f/fn;
matOrtho.m11 = 0.0f;
matOrtho.m12 = -((float)left + (float)right)/rl;
matOrtho.m13 = -((float)top + (float)bottom)/tb;
matOrtho.m14 = -((float)zfar + (float)znear)/fn;
matOrtho.m15 = 1.0f;
*RLGL.State.currentMatrix = rlMatrixMultiply(*RLGL.State.currentMatrix, matOrtho);
} | O3 | c | rlOrtho:
pushq %r14
pushq %rbx
subq $0x148, %rsp # imm = 0x148
cvtsd2ss %xmm1, %xmm6
subsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm1
cvtsd2ss %xmm3, %xmm7
subsd %xmm2, %xmm3
cvtsd2ss %xmm3, %xmm3
cvtsd2ss %xmm5, %xmm8
subsd %xmm4, %xmm5
cvtsd2ss %xmm5, %xmm5
movss 0x7c4d4(%rip), %xmm9 # 0xdd2d4
movaps %xmm9, %xmm10
divss %xmm1, %xmm10
movss %xmm10, 0x80(%rsp)
xorl %eax, %eax
movl %eax, 0x90(%rsp)
divss %xmm3, %xmm9
movss %xmm9, 0x94(%rsp)
xorps %xmm9, %xmm9
cvtsd2ss %xmm4, %xmm4
addss %xmm8, %xmm4
movaps 0x6e310(%rip), %xmm8 # 0xcf150
xorps %xmm8, %xmm4
movaps 0x7c524(%rip), %xmm10 # 0xdd370
unpcklps %xmm4, %xmm10 # xmm10 = xmm10[0],xmm4[0],xmm10[1],xmm4[1]
unpcklps %xmm5, %xmm5 # xmm5 = xmm5[0,0,1,1]
divps %xmm5, %xmm10
movlhps %xmm10, %xmm9 # xmm9 = xmm9[0],xmm10[0]
movups %xmm9, 0xa0(%rsp)
movq $0x0, 0x84(%rsp)
movl %eax, 0x98(%rsp)
cvtsd2ss %xmm0, %xmm0
addss %xmm0, %xmm6
xorps %xmm8, %xmm6
divss %xmm1, %xmm6
xorps %xmm0, %xmm0
cvtsd2ss %xmm2, %xmm0
movss %xmm6, 0x8c(%rsp)
addss %xmm7, %xmm0
xorps %xmm8, %xmm0
divss %xmm3, %xmm0
movss %xmm0, 0x9c(%rsp)
movaps 0x7c49d(%rip), %xmm0 # 0xdd350
movups %xmm0, 0xb0(%rsp)
movq 0xda29e(%rip), %r14 # 0x13b160
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movaps %xmm3, 0xf0(%rsp)
movaps %xmm2, 0xe0(%rsp)
movaps %xmm1, 0xd0(%rsp)
movaps %xmm0, 0xc0(%rsp)
movups 0x80(%rsp), %xmm0
movups 0x90(%rsp), %xmm1
movups 0xa0(%rsp), %xmm2
movups 0xb0(%rsp), %xmm3
movups %xmm3, 0x70(%rsp)
movups %xmm2, 0x60(%rsp)
movups %xmm1, 0x50(%rsp)
movups %xmm0, 0x40(%rsp)
movaps 0xc0(%rsp), %xmm0
movaps 0xd0(%rsp), %xmm1
movaps 0xe0(%rsp), %xmm2
movaps 0xf0(%rsp), %xmm3
movups %xmm3, 0x30(%rsp)
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x108(%rsp), %rbx
movq %rbx, %rdi
callq 0x60539
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups 0x30(%rbx), %xmm3
movups %xmm3, 0x30(%r14)
movups %xmm2, 0x20(%r14)
movups %xmm1, 0x10(%r14)
movups %xmm0, (%r14)
addq $0x148, %rsp # imm = 0x148
popq %rbx
popq %r14
retq
| rlOrtho:
push r14
push rbx
sub rsp, 148h
cvtsd2ss xmm6, xmm1
subsd xmm1, xmm0
cvtsd2ss xmm1, xmm1
cvtsd2ss xmm7, xmm3
subsd xmm3, xmm2
cvtsd2ss xmm3, xmm3
cvtsd2ss xmm8, xmm5
subsd xmm5, xmm4
cvtsd2ss xmm5, xmm5
movss xmm9, cs:dword_DD2D4
movaps xmm10, xmm9
divss xmm10, xmm1
movss dword ptr [rsp+158h+var_D8], xmm10
xor eax, eax
mov dword ptr [rsp+158h+var_C8], eax
divss xmm9, xmm3
movss dword ptr [rsp+158h+var_C8+4], xmm9
xorps xmm9, xmm9
cvtsd2ss xmm4, xmm4
addss xmm4, xmm8
movaps xmm8, cs:xmmword_CF150
xorps xmm4, xmm8
movaps xmm10, cs:xmmword_DD370
unpcklps xmm10, xmm4
unpcklps xmm5, xmm5
divps xmm10, xmm5
movlhps xmm9, xmm10
movups [rsp+158h+var_B8], xmm9
mov qword ptr [rsp+158h+var_D8+4], 0
mov dword ptr [rsp+158h+var_C8+8], eax
cvtsd2ss xmm0, xmm0
addss xmm6, xmm0
xorps xmm6, xmm8
divss xmm6, xmm1
xorps xmm0, xmm0
cvtsd2ss xmm0, xmm2
movss dword ptr [rsp+158h+var_D8+0Ch], xmm6
addss xmm0, xmm7
xorps xmm0, xmm8
divss xmm0, xmm3
movss dword ptr [rsp+158h+var_C8+0Ch], xmm0
movaps xmm0, cs:xmmword_DD350
movups [rsp+158h+var_A8], xmm0
mov r14, cs:qword_13B160
movups xmm0, xmmword ptr [r14]
movups xmm1, xmmword ptr [r14+10h]
movups xmm2, xmmword ptr [r14+20h]
movups xmm3, xmmword ptr [r14+30h]
movaps [rsp+158h+var_68], xmm3
movaps [rsp+158h+var_78], xmm2
movaps [rsp+158h+var_88], xmm1
movaps [rsp+158h+var_98], xmm0
movups xmm0, [rsp+158h+var_D8]
movups xmm1, [rsp+158h+var_C8]
movups xmm2, [rsp+158h+var_B8]
movups xmm3, [rsp+158h+var_A8]
movups [rsp+158h+var_E8], xmm3
movups [rsp+158h+var_F8], xmm2
movups [rsp+158h+var_108], xmm1
movups [rsp+158h+var_118], xmm0
movaps xmm0, [rsp+158h+var_98]
movaps xmm1, [rsp+158h+var_88]
movaps xmm2, [rsp+158h+var_78]
movaps xmm3, [rsp+158h+var_68]
movups [rsp+158h+var_128], xmm3
movups [rsp+158h+var_138], xmm2
movups [rsp+158h+var_148], xmm1
movups [rsp+158h+var_158], xmm0
lea rbx, [rsp+158h+var_50]
mov rdi, rbx
call rlMatrixMultiply
movups xmm0, xmmword ptr [rbx]
movups xmm1, xmmword ptr [rbx+10h]
movups xmm2, xmmword ptr [rbx+20h]
movups xmm3, xmmword ptr [rbx+30h]
movups xmmword ptr [r14+30h], xmm3
movups xmmword ptr [r14+20h], xmm2
movups xmmword ptr [r14+10h], xmm1
movups xmmword ptr [r14], xmm0
add rsp, 148h
pop rbx
pop r14
retn
| void rlOrtho(
double a1,
double a2,
double a3,
double a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
long long a9,
long long a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
float v14; // xmm1_4
float v15; // xmm8_4
float v16; // xmm0_4
__m128 v17; // xmm6
long long v18; // r14
__m128 v19; // xmm0
__m128 v20; // xmm1
__m128 v21; // xmm2
__m128 v22[5]; // [rsp+108h] [rbp-50h] BYREF
a7.m128_f32[0] = a2;
v14 = a2 - a1;
a8.m128_f32[0] = a4;
v15 = *(double *)a6.m128_u64;
*(double *)a6.m128_u64 = *(double *)a6.m128_u64 - *(double *)a5.m128_u64;
a6.m128_f32[0] = *(double *)a6.m128_u64;
a5.m128_f32[0] = *(double *)a5.m128_u64;
a5.m128_f32[0] = a5.m128_f32[0] + v15;
v16 = a1;
a7.m128_f32[0] = a7.m128_f32[0] + v16;
v17 = _mm_xor_ps(a7, (__m128)xmmword_CF150);
v17.m128_f32[0] = v17.m128_f32[0] / v14;
v18 = qword_13B160;
rlMatrixMultiply(
v22,
a10,
a11,
a12,
a13,
a14,
*(__m128 *)qword_13B160,
*(__m128 *)(qword_13B160 + 16),
*(__m128 *)(qword_13B160 + 32),
*(__m128 *)(qword_13B160 + 48),
_mm_xor_ps(a5, (__m128)xmmword_CF150),
_mm_unpacklo_ps(a6, a6),
v17,
a8);
v19 = v22[0];
v20 = v22[1];
v21 = v22[2];
*(__m128 *)(v18 + 48) = v22[3];
*(__m128 *)(v18 + 32) = v21;
*(__m128 *)(v18 + 16) = v20;
*(__m128 *)v18 = v19;
}
| rlOrtho:
PUSH R14
PUSH RBX
SUB RSP,0x148
CVTSD2SS XMM6,XMM1
SUBSD XMM1,XMM0
CVTSD2SS XMM1,XMM1
CVTSD2SS XMM7,XMM3
SUBSD XMM3,XMM2
CVTSD2SS XMM3,XMM3
CVTSD2SS XMM8,XMM5
SUBSD XMM5,XMM4
CVTSD2SS XMM5,XMM5
MOVSS XMM9,dword ptr [0x001dd2d4]
MOVAPS XMM10,XMM9
DIVSS XMM10,XMM1
MOVSS dword ptr [RSP + 0x80],XMM10
XOR EAX,EAX
MOV dword ptr [RSP + 0x90],EAX
DIVSS XMM9,XMM3
MOVSS dword ptr [RSP + 0x94],XMM9
XORPS XMM9,XMM9
CVTSD2SS XMM4,XMM4
ADDSS XMM4,XMM8
MOVAPS XMM8,xmmword ptr [0x001cf150]
XORPS XMM4,XMM8
MOVAPS XMM10,xmmword ptr [0x001dd370]
UNPCKLPS XMM10,XMM4
UNPCKLPS XMM5,XMM5
DIVPS XMM10,XMM5
MOVLHPS XMM9,XMM10
MOVUPS xmmword ptr [RSP + 0xa0],XMM9
MOV qword ptr [RSP + 0x84],0x0
MOV dword ptr [RSP + 0x98],EAX
CVTSD2SS XMM0,XMM0
ADDSS XMM6,XMM0
XORPS XMM6,XMM8
DIVSS XMM6,XMM1
XORPS XMM0,XMM0
CVTSD2SS XMM0,XMM2
MOVSS dword ptr [RSP + 0x8c],XMM6
ADDSS XMM0,XMM7
XORPS XMM0,XMM8
DIVSS XMM0,XMM3
MOVSS dword ptr [RSP + 0x9c],XMM0
MOVAPS XMM0,xmmword ptr [0x001dd350]
MOVUPS xmmword ptr [RSP + 0xb0],XMM0
MOV R14,qword ptr [0x0023b160]
MOVUPS XMM0,xmmword ptr [R14]
MOVUPS XMM1,xmmword ptr [R14 + 0x10]
MOVUPS XMM2,xmmword ptr [R14 + 0x20]
MOVUPS XMM3,xmmword ptr [R14 + 0x30]
MOVAPS xmmword ptr [RSP + 0xf0],XMM3
MOVAPS xmmword ptr [RSP + 0xe0],XMM2
MOVAPS xmmword ptr [RSP + 0xd0],XMM1
MOVAPS xmmword ptr [RSP + 0xc0],XMM0
MOVUPS XMM0,xmmword ptr [RSP + 0x80]
MOVUPS XMM1,xmmword ptr [RSP + 0x90]
MOVUPS XMM2,xmmword ptr [RSP + 0xa0]
MOVUPS XMM3,xmmword ptr [RSP + 0xb0]
MOVUPS xmmword ptr [RSP + 0x70],XMM3
MOVUPS xmmword ptr [RSP + 0x60],XMM2
MOVUPS xmmword ptr [RSP + 0x50],XMM1
MOVUPS xmmword ptr [RSP + 0x40],XMM0
MOVAPS XMM0,xmmword ptr [RSP + 0xc0]
MOVAPS XMM1,xmmword ptr [RSP + 0xd0]
MOVAPS XMM2,xmmword ptr [RSP + 0xe0]
MOVAPS XMM3,xmmword ptr [RSP + 0xf0]
MOVUPS xmmword ptr [RSP + 0x30],XMM3
MOVUPS xmmword ptr [RSP + 0x20],XMM2
MOVUPS xmmword ptr [RSP + 0x10],XMM1
MOVUPS xmmword ptr [RSP],XMM0
LEA RBX,[RSP + 0x108]
MOV RDI,RBX
CALL 0x00160539
MOVUPS XMM0,xmmword ptr [RBX]
MOVUPS XMM1,xmmword ptr [RBX + 0x10]
MOVUPS XMM2,xmmword ptr [RBX + 0x20]
MOVUPS XMM3,xmmword ptr [RBX + 0x30]
MOVUPS xmmword ptr [R14 + 0x30],XMM3
MOVUPS xmmword ptr [R14 + 0x20],XMM2
MOVUPS xmmword ptr [R14 + 0x10],XMM1
MOVUPS xmmword ptr [R14],XMM0
ADD RSP,0x148
POP RBX
POP R14
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void rlOrtho(void)
{
int1 auVar1 [16];
int8 *puVar2;
double in_XMM4_Qa;
float fVar3;
double in_XMM5_Qa;
int4 uVar4;
int1 auVar5 [16];
int8 local_50;
int8 uStack_48;
int8 local_40;
int8 uStack_38;
int8 local_30;
int8 uStack_28;
int8 local_20;
int8 uStack_18;
int1 auVar6 [16];
puVar2 = DAT_0023b160;
uVar4 = (int4)((ulong)(in_XMM5_Qa - in_XMM4_Qa) >> 0x20);
fVar3 = (float)(in_XMM5_Qa - in_XMM4_Qa);
auVar6._0_8_ = SUB168(_DAT_001dd370,0);
auVar6._8_4_ = SUB164(_DAT_001dd370,4);
auVar6._12_4_ = (uint)((ulong)in_XMM4_Qa >> 0x20) ^ _UNK_001cf154;
auVar5._8_8_ = auVar6._8_8_;
auVar5._0_4_ = SUB164(_DAT_001dd370,0);
auVar5._4_4_ = (uint)((float)in_XMM4_Qa + (float)in_XMM5_Qa) ^ _DAT_001cf150;
auVar1._4_4_ = fVar3;
auVar1._0_4_ = fVar3;
auVar1._8_4_ = uVar4;
auVar1._12_4_ = uVar4;
divps(auVar5,auVar1);
rlMatrixMultiply(&local_50);
puVar2[6] = local_20;
puVar2[7] = uStack_18;
puVar2[4] = local_30;
puVar2[5] = uStack_28;
puVar2[2] = local_40;
puVar2[3] = uStack_38;
*puVar2 = local_50;
puVar2[1] = uStack_48;
return;
}
| |
45,601 | my_valid_mbcharlen_utf8mb3 | eloqsql/strings/ctype-utf8.c | static inline
int my_valid_mbcharlen_utf8mb3(const uchar *s, const uchar *e)
{
uchar c;
DBUG_ASSERT(s < e);
c= s[0];
if (c < 0x80)
return 1;
if (c < 0xc2)
return MY_CS_ILSEQ;
if (c < 0xe0)
{
if (s+2 > e) /* We need 2 characters */
return MY_CS_TOOSMALL2;
if (!(IS_CONTINUATION_BYTE(s[1])))
return MY_CS_ILSEQ;
return 2;
}
DBUG_ASSERT(c < 0xf0);
if (s+3 > e) /* We need 3 characters */
return MY_CS_TOOSMALL3;
if (!IS_UTF8MB3_STEP2(c, s[1], s[2]))
return MY_CS_ILSEQ;
return 3;
} | O0 | c | my_valid_mbcharlen_utf8mb3:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
jmp 0x66d9e
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0x80, %eax
jge 0x66dbe
movl $0x1, -0x4(%rbp)
jmp 0x66e87
movzbl -0x19(%rbp), %eax
cmpl $0xc2, %eax
jge 0x66dd5
movl $0x0, -0x4(%rbp)
jmp 0x66e87
movzbl -0x19(%rbp), %eax
cmpl $0xe0, %eax
jge 0x66e1e
movq -0x10(%rbp), %rax
addq $0x2, %rax
cmpq -0x18(%rbp), %rax
jbe 0x66dfa
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x66e87
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jl 0x66e15
movl $0x0, -0x4(%rbp)
jmp 0x66e87
movl $0x2, -0x4(%rbp)
jmp 0x66e87
jmp 0x66e20
jmp 0x66e22
movq -0x10(%rbp), %rax
addq $0x3, %rax
cmpq -0x18(%rbp), %rax
jbe 0x66e39
movl $0xffffff99, -0x4(%rbp) # imm = 0xFFFFFF99
jmp 0x66e87
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x66e77
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x66e77
movzbl -0x19(%rbp), %eax
cmpl $0xe1, %eax
jge 0x66e80
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xa0, %eax
jge 0x66e80
movl $0x0, -0x4(%rbp)
jmp 0x66e87
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
| my_valid_mbcharlen_utf8mb3:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
jmp short $+2
loc_66D9E:
mov rax, [rbp+var_10]
mov al, [rax]
mov [rbp+var_19], al
movzx eax, [rbp+var_19]
cmp eax, 80h
jge short loc_66DBE
mov [rbp+var_4], 1
jmp loc_66E87
loc_66DBE:
movzx eax, [rbp+var_19]
cmp eax, 0C2h
jge short loc_66DD5
mov [rbp+var_4], 0
jmp loc_66E87
loc_66DD5:
movzx eax, [rbp+var_19]
cmp eax, 0E0h
jge short loc_66E1E
mov rax, [rbp+var_10]
add rax, 2
cmp rax, [rbp+var_18]
jbe short loc_66DFA
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_66E87
loc_66DFA:
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jl short loc_66E15
mov [rbp+var_4], 0
jmp short loc_66E87
loc_66E15:
mov [rbp+var_4], 2
jmp short loc_66E87
loc_66E1E:
jmp short $+2
loc_66E20:
jmp short $+2
loc_66E22:
mov rax, [rbp+var_10]
add rax, 3
cmp rax, [rbp+var_18]
jbe short loc_66E39
mov [rbp+var_4], 0FFFFFF99h
jmp short loc_66E87
loc_66E39:
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_66E77
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_66E77
movzx eax, [rbp+var_19]
cmp eax, 0E1h
jge short loc_66E80
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+1]
cmp eax, 0A0h
jge short loc_66E80
loc_66E77:
mov [rbp+var_4], 0
jmp short loc_66E87
loc_66E80:
mov [rbp+var_4], 3
loc_66E87:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_valid_mbcharlen_utf8mb3(unsigned __int8 *a1, unsigned long long a2)
{
unsigned __int8 v3; // [rsp+1h] [rbp-19h]
v3 = *a1;
if ( *a1 >= 0x80u )
{
if ( v3 >= 0xC2u )
{
if ( v3 >= 0xE0u )
{
if ( (unsigned long long)(a1 + 3) <= a2 )
{
if ( (a1[1] ^ 0x80) < 64 && (a1[2] ^ 0x80) < 64 && (v3 >= 0xE1u || a1[1] >= 0xA0u) )
return 3;
else
return 0;
}
else
{
return (unsigned int)-103;
}
}
else if ( (unsigned long long)(a1 + 2) <= a2 )
{
if ( (a1[1] ^ 0x80) < 64 )
return 2;
else
return 0;
}
else
{
return (unsigned int)-102;
}
}
else
{
return 0;
}
}
else
{
return 1;
}
}
| my_valid_mbcharlen_utf8mb3:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
JMP 0x00166d9e
LAB_00166d9e:
MOV RAX,qword ptr [RBP + -0x10]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x19],AL
MOVZX EAX,byte ptr [RBP + -0x19]
CMP EAX,0x80
JGE 0x00166dbe
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00166e87
LAB_00166dbe:
MOVZX EAX,byte ptr [RBP + -0x19]
CMP EAX,0xc2
JGE 0x00166dd5
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00166e87
LAB_00166dd5:
MOVZX EAX,byte ptr [RBP + -0x19]
CMP EAX,0xe0
JGE 0x00166e1e
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x18]
JBE 0x00166dfa
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x00166e87
LAB_00166dfa:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JL 0x00166e15
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00166e87
LAB_00166e15:
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00166e87
LAB_00166e1e:
JMP 0x00166e20
LAB_00166e20:
JMP 0x00166e22
LAB_00166e22:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x3
CMP RAX,qword ptr [RBP + -0x18]
JBE 0x00166e39
MOV dword ptr [RBP + -0x4],0xffffff99
JMP 0x00166e87
LAB_00166e39:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x00166e77
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x00166e77
MOVZX EAX,byte ptr [RBP + -0x19]
CMP EAX,0xe1
JGE 0x00166e80
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xa0
JGE 0x00166e80
LAB_00166e77:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00166e87
LAB_00166e80:
MOV dword ptr [RBP + -0x4],0x3
LAB_00166e87:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_valid_mbcharlen_utf8mb3(byte *param_1,byte *param_2)
{
byte bVar1;
int4 local_c;
bVar1 = *param_1;
if (bVar1 < 0x80) {
local_c = 1;
}
else if (bVar1 < 0xc2) {
local_c = 0;
}
else if (bVar1 < 0xe0) {
if (param_2 < param_1 + 2) {
local_c = 0xffffff9a;
}
else if ((param_1[1] ^ 0x80) < 0x40) {
local_c = 2;
}
else {
local_c = 0;
}
}
else if (param_2 < param_1 + 3) {
local_c = 0xffffff99;
}
else if ((((param_1[1] ^ 0x80) < 0x40) && ((param_1[2] ^ 0x80) < 0x40)) &&
((0xe0 < bVar1 || (0x9f < param_1[1])))) {
local_c = 3;
}
else {
local_c = 0;
}
return local_c;
}
| |
45,602 | Item_cond_and::get_mm_tree(RANGE_OPT_PARAM*, Item**) | eloqsql/sql/opt_range.cc | SEL_TREE *Item_cond_and::get_mm_tree(RANGE_OPT_PARAM *param, Item **cond_ptr)
{
DBUG_ENTER("Item_cond_and::get_mm_tree");
SEL_TREE *tree= NULL;
List_iterator<Item> li(*argument_list());
Item *item;
while ((item= li++))
{
SEL_TREE *new_tree= li.ref()[0]->get_mm_tree(param,li.ref());
if (param->statement_should_be_aborted())
DBUG_RETURN(NULL);
tree= tree_and(param, tree, new_tree);
if (tree && tree->type == SEL_TREE::IMPOSSIBLE)
{
/*
Do not remove 'item' from 'cond'. We return a SEL_TREE::IMPOSSIBLE
and that is sufficient for the caller to see that the whole
condition is never true.
*/
break;
}
}
DBUG_RETURN(tree);
} | O0 | cpp | Item_cond_and::get_mm_tree(RANGE_OPT_PARAM*, Item**):
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq $0x0, -0x28(%rbp)
callq 0x8cb070
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x87ec00
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x87ec30
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x8b953a
leaq -0x48(%rbp), %rdi
callq 0x8cb090
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8cb090
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rdx
movq (%rdi), %rax
callq *0x248(%rax)
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8cb0b0
testb $0x1, %al
jne 0x8b9502
jmp 0x8b950e
jmp 0x8b9504
movq $0x0, -0x8(%rbp)
jmp 0x8b9544
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x8ad580
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x8b9535
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x8b9535
jmp 0x8b953a
jmp 0x8b94a1
jmp 0x8b953c
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nop
| _ZN13Item_cond_and11get_mm_treeEP15RANGE_OPT_PARAMPP4Item:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rdi, [rbp+var_10]; this
mov [rbp+var_28], 0
call _ZN9Item_cond13argument_listEv; Item_cond::argument_list(void)
mov rsi, rax
lea rdi, [rbp+var_48]
call _ZN13List_iteratorI4ItemEC2ER4ListIS0_E; List_iterator<Item>::List_iterator(List<Item> &)
loc_8B94A1:
lea rdi, [rbp+var_48]
xor esi, esi
call _ZN13List_iteratorI4ItemEppEi; List_iterator<Item>::operator++(int)
mov [rbp+var_50], rax
cmp rax, 0
jz loc_8B953A
lea rdi, [rbp+var_48]
call _ZN13List_iteratorI4ItemE3refEv; List_iterator<Item>::ref(void)
mov rax, [rax]
mov [rbp+var_68], rax
mov rax, [rbp+var_18]
mov [rbp+var_60], rax
lea rdi, [rbp+var_48]
call _ZN13List_iteratorI4ItemE3refEv; List_iterator<Item>::ref(void)
mov rdi, [rbp+var_68]
mov rsi, [rbp+var_60]
mov rdx, rax
mov rax, [rdi]
call qword ptr [rax+248h]
mov [rbp+var_58], rax
mov rdi, [rbp+var_18]; this
call _ZNK15RANGE_OPT_PARAM27statement_should_be_abortedEv; RANGE_OPT_PARAM::statement_should_be_aborted(void)
test al, 1
jnz short loc_8B9502
jmp short loc_8B950E
loc_8B9502:
jmp short $+2
loc_8B9504:
mov [rbp+var_8], 0
jmp short loc_8B9544
loc_8B950E:
mov rdi, [rbp+var_18]; RANGE_OPT_PARAM *
mov rsi, [rbp+var_28]; SEL_TREE *
mov rdx, [rbp+var_58]; SEL_TREE *
call _ZL8tree_andP15RANGE_OPT_PARAMP8SEL_TREES2_; tree_and(RANGE_OPT_PARAM *,SEL_TREE *,SEL_TREE *)
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jz short loc_8B9535
mov rax, [rbp+var_28]
cmp dword ptr [rax], 0
jnz short loc_8B9535
jmp short loc_8B953A
loc_8B9535:
jmp loc_8B94A1
loc_8B953A:
jmp short $+2
loc_8B953C:
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
loc_8B9544:
mov rax, [rbp+var_8]
add rsp, 70h
pop rbp
retn
| SEL_TREE * Item_cond_and::get_mm_tree(Item_cond_and *this, RANGE_OPT_PARAM *a2, Item **a3)
{
base_list *v3; // rax
long long v4; // rax
long long v6; // [rsp+8h] [rbp-68h]
RANGE_OPT_PARAM *v7; // [rsp+10h] [rbp-60h]
SEL_TREE *v8; // [rsp+18h] [rbp-58h]
_BYTE v9[32]; // [rsp+28h] [rbp-48h] BYREF
SEL_TREE *v10; // [rsp+48h] [rbp-28h]
Item **v11; // [rsp+50h] [rbp-20h]
RANGE_OPT_PARAM *v12; // [rsp+58h] [rbp-18h]
Item_cond *v13; // [rsp+60h] [rbp-10h]
v13 = this;
v12 = a2;
v11 = a3;
v10 = 0LL;
v3 = (base_list *)Item_cond::argument_list(this);
List_iterator<Item>::List_iterator((base_list_iterator *)v9, v3);
while ( List_iterator<Item>::operator++((base_list_iterator *)v9) )
{
v6 = *(_QWORD *)List_iterator<Item>::ref(v9, 0LL);
v7 = v12;
v4 = List_iterator<Item>::ref(v9, 0LL);
v8 = (SEL_TREE *)(*(long long ( **)(long long, RANGE_OPT_PARAM *, long long))(*(_QWORD *)v6 + 584LL))(
v6,
v7,
v4);
if ( (RANGE_OPT_PARAM::statement_should_be_aborted(v12) & 1) != 0 )
return 0LL;
v10 = tree_and(v12, v10, v8);
if ( v10 )
{
if ( !*(_DWORD *)v10 )
break;
}
}
return v10;
}
| __cxx_global_var_init.2:
PUSH RBP
MOV RBP,RSP
LEA RDI,[0x1e7deb8]
MOV ESI,0x4
CALL 0x008fd530
POP RBP
RET
|
void __cxx_global_var_init_2(void)
{
date_conv_mode_t::date_conv_mode_t((date_conv_mode_t *)&TIME_TIME_ONLY,4);
return;
}
| |
45,603 | real_open_cached_file | eloqsql/mysys/mf_cache.c | my_bool real_open_cached_file(IO_CACHE *cache)
{
char name_buff[FN_REFLEN];
int error=1;
DBUG_ENTER("real_open_cached_file");
if ((cache->file= create_temp_file(name_buff, cache->dir,
cache->prefix[0] ? cache->prefix : 0,
O_BINARY, MYF(MY_WME | MY_TEMPORARY))) >= 0)
{
error=0;
}
DBUG_RETURN(error);
} | O0 | c | real_open_cached_file:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x218(%rbp)
movl $0x1, -0x21c(%rbp)
leaq -0x210(%rbp), %rax
movq %rax, -0x230(%rbp)
movq -0x218(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x228(%rbp)
movq -0x218(%rbp), %rax
movsbl 0xd0(%rax), %eax
cmpl $0x0, %eax
je 0xc91c5
movq -0x218(%rbp), %rax
addq $0xd0, %rax
movq %rax, -0x238(%rbp)
jmp 0xc91d0
xorl %eax, %eax
movq %rax, -0x238(%rbp)
jmp 0xc91d0
movq -0x228(%rbp), %rsi
movq -0x230(%rbp), %rdi
movq -0x238(%rbp), %rdx
xorl %ecx, %ecx
movl $0x50, %r8d
callq 0xbad90
movq -0x218(%rbp), %rcx
movl %eax, 0xd4(%rcx)
cmpl $0x0, %eax
jl 0xc920e
movl $0x0, -0x21c(%rbp)
jmp 0xc9210
movl -0x21c(%rbp), %eax
movb %al, -0x239(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xc923d
movb -0x239(%rbp), %al
addq $0x240, %rsp # imm = 0x240
popq %rbp
retq
callq 0x60310
nopw %cs:(%rax,%rax)
| real_open_cached_file:
push rbp
mov rbp, rsp
sub rsp, 240h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_218], rdi
mov [rbp+var_21C], 1
lea rax, [rbp+var_210]
mov [rbp+var_230], rax
mov rax, [rbp+var_218]
mov rax, [rax+0C8h]
mov [rbp+var_228], rax
mov rax, [rbp+var_218]
movsx eax, byte ptr [rax+0D0h]
cmp eax, 0
jz short loc_C91C5
mov rax, [rbp+var_218]
add rax, 0D0h
mov [rbp+var_238], rax
jmp short loc_C91D0
loc_C91C5:
xor eax, eax
mov [rbp+var_238], rax
jmp short $+2
loc_C91D0:
mov rsi, [rbp+var_228]
mov rdi, [rbp+var_230]
mov rdx, [rbp+var_238]
xor ecx, ecx
mov r8d, 50h ; 'P'
call create_temp_file
mov rcx, [rbp+var_218]
mov [rcx+0D4h], eax
cmp eax, 0
jl short loc_C920E
mov [rbp+var_21C], 0
loc_C920E:
jmp short $+2
loc_C9210:
mov eax, [rbp+var_21C]
mov [rbp+var_239], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_C923D
mov al, [rbp+var_239]
add rsp, 240h
pop rbp
retn
loc_C923D:
call ___stack_chk_fail
| char real_open_cached_file(long long a1)
{
int temp_file; // eax
const char *v3; // [rsp+18h] [rbp-228h]
char v4; // [rsp+24h] [rbp-21Ch]
_BYTE v5[520]; // [rsp+30h] [rbp-210h] BYREF
unsigned long long v6; // [rsp+238h] [rbp-8h]
v6 = __readfsqword(0x28u);
v4 = 1;
v3 = *(const char **)(a1 + 200);
if ( *(_BYTE *)(a1 + 208) )
temp_file = create_temp_file(v5, v3, a1 + 208, 0, 80LL);
else
temp_file = create_temp_file(v5, v3, 0LL, 0, 80LL);
*(_DWORD *)(a1 + 212) = temp_file;
if ( temp_file >= 0 )
return 0;
return v4;
}
| real_open_cached_file:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x240
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x218],RDI
MOV dword ptr [RBP + -0x21c],0x1
LEA RAX,[RBP + -0x210]
MOV qword ptr [RBP + -0x230],RAX
MOV RAX,qword ptr [RBP + -0x218]
MOV RAX,qword ptr [RAX + 0xc8]
MOV qword ptr [RBP + -0x228],RAX
MOV RAX,qword ptr [RBP + -0x218]
MOVSX EAX,byte ptr [RAX + 0xd0]
CMP EAX,0x0
JZ 0x001c91c5
MOV RAX,qword ptr [RBP + -0x218]
ADD RAX,0xd0
MOV qword ptr [RBP + -0x238],RAX
JMP 0x001c91d0
LAB_001c91c5:
XOR EAX,EAX
MOV qword ptr [RBP + -0x238],RAX
JMP 0x001c91d0
LAB_001c91d0:
MOV RSI,qword ptr [RBP + -0x228]
MOV RDI,qword ptr [RBP + -0x230]
MOV RDX,qword ptr [RBP + -0x238]
XOR ECX,ECX
MOV R8D,0x50
CALL 0x001bad90
MOV RCX,qword ptr [RBP + -0x218]
MOV dword ptr [RCX + 0xd4],EAX
CMP EAX,0x0
JL 0x001c920e
MOV dword ptr [RBP + -0x21c],0x0
LAB_001c920e:
JMP 0x001c9210
LAB_001c9210:
MOV EAX,dword ptr [RBP + -0x21c]
MOV byte ptr [RBP + -0x239],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001c923d
MOV AL,byte ptr [RBP + -0x239]
ADD RSP,0x240
POP RBP
RET
LAB_001c923d:
CALL 0x00160310
|
int8 real_open_cached_file(long param_1)
{
int iVar1;
long in_FS_OFFSET;
long local_240;
int1 local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (*(char *)(param_1 + 0xd0) == '\0') {
local_240 = 0;
}
else {
local_240 = param_1 + 0xd0;
}
iVar1 = create_temp_file(local_218,*(int8 *)(param_1 + 200),local_240,0,0x50);
*(int *)(param_1 + 0xd4) = iVar1;
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),iVar1 < 0);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
45,604 | read_block_primary | eloqsql/mysys/mf_keycache.c | static void read_block_primary(SIMPLE_KEY_CACHE_CB *keycache,
BLOCK_LINK *block, uint read_length,
uint min_length)
{
size_t got_length;
/* On entry cache_lock is locked */
KEYCACHE_THREAD_TRACE("read_block_primary");
/*
This code is executed only by threads that submitted primary
requests. Until block->status contains BLOCK_READ, all other
request for the block become secondary requests. For a primary
request the block must be properly initialized.
*/
DBUG_ASSERT(((block->status & ~BLOCK_FOR_UPDATE) == BLOCK_IN_USE) ||
fail_block(block));
DBUG_ASSERT((block->length == 0) || fail_block(block));
DBUG_ASSERT((block->offset == keycache->key_cache_block_size) ||
fail_block(block));
DBUG_ASSERT((block->requests > 0) || fail_block(block));
KEYCACHE_DBUG_PRINT("read_block_primary",
("page to be read by primary request"));
keycache->global_cache_read++;
/* Page is not in buffer yet, is to be read from disk */
keycache_pthread_mutex_unlock(&keycache->cache_lock);
/*
Here other threads may step in and register as secondary readers.
They will register in block->wqueue[COND_FOR_REQUESTED].
*/
got_length= my_pread(block->hash_link->file, block->buffer,
read_length, block->hash_link->diskpos, MYF(0));
keycache_pthread_mutex_lock(&keycache->cache_lock);
/*
The block can now have been marked for free (in case of
FLUSH_RELEASE). Otherwise the state must be unchanged.
*/
DBUG_ASSERT(((block->status & ~(BLOCK_REASSIGNED |
BLOCK_FOR_UPDATE)) == BLOCK_IN_USE) ||
fail_block(block));
DBUG_ASSERT((block->length == 0) || fail_block(block));
DBUG_ASSERT((block->offset == keycache->key_cache_block_size) ||
fail_block(block));
DBUG_ASSERT((block->requests > 0) || fail_block(block));
if (got_length < min_length)
block->status|= BLOCK_ERROR;
else
{
block->status|= BLOCK_READ;
block->length= (uint)got_length;
/*
Do not set block->offset here. If this block is marked
BLOCK_CHANGED later, we want to flush only the modified part. So
only a writer may set block->offset down from
keycache->key_cache_block_size.
*/
}
KEYCACHE_DBUG_PRINT("read_block_primary",
("primary request: new page in cache"));
/* Signal that all pending requests for this page now can be processed */
release_whole_queue(&block->wqueue[COND_FOR_REQUESTED]);
DBUG_ASSERT(keycache->can_be_used);
} | O3 | c | read_block_primary:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r14d
movl %edx, %r13d
movq %rdi, %r12
incq 0x158(%rdi)
movq %rsi, %rbx
leaq 0xc0(%rdi), %r15
movq 0x100(%rdi), %rdi
testq %rdi, %rdi
jne 0x97b89
movq %r15, %rdi
callq 0x291e0
movq 0x20(%rbx), %rax
movq 0x40(%rbx), %rsi
movl 0x18(%rax), %edi
movl %r13d, %edx
movq 0x20(%rax), %rcx
xorl %r8d, %r8d
callq 0xa01b0
movq %rax, %r13
cmpq $0x0, 0x100(%r12)
jne 0x97b9e
movq %r15, %rdi
callq 0x29220
movl %r14d, %ecx
movl 0x50(%rbx), %eax
cmpq %rcx, %r13
jae 0x97b65
orl $0x1, %eax
movl %eax, 0x50(%rbx)
jmp 0x97b6f
orl $0x2, %eax
movl %eax, 0x50(%rbx)
movl %r13d, 0x4c(%rbx)
addq $0x28, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x98509
leaq 0x2ee480(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x97b1a
leaq 0x444bf(%rip), %rsi # 0xdc064
movq %r15, %rdi
movl $0xa63, %edx # imm = 0xA63
callq 0x2eb8f
jmp 0x97b52
| read_block_primary:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14d, ecx
mov r13d, edx
mov r12, rdi
inc qword ptr [rdi+158h]
mov rbx, rsi
lea r15, [rdi+0C0h]
mov rdi, [rdi+100h]
test rdi, rdi
jnz short loc_97B89
loc_97B1A:
mov rdi, r15
call _pthread_mutex_unlock
mov rax, [rbx+20h]
mov rsi, [rbx+40h]
mov edi, [rax+18h]
mov edx, r13d
mov rcx, [rax+20h]
xor r8d, r8d
call my_pread
mov r13, rax
cmp qword ptr [r12+100h], 0
jnz short loc_97B9E
mov rdi, r15
call _pthread_mutex_lock
loc_97B52:
mov ecx, r14d
mov eax, [rbx+50h]
cmp r13, rcx
jnb short loc_97B65
or eax, 1
mov [rbx+50h], eax
jmp short loc_97B6F
loc_97B65:
or eax, 2
mov [rbx+50h], eax
mov [rbx+4Ch], r13d
loc_97B6F:
add rbx, 28h ; '('
mov rdi, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp release_whole_queue
loc_97B89:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_97B1A
loc_97B9E:
lea rsi, aWorkspaceLlm4b_39; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r15
mov edx, 0A63h
call psi_mutex_lock
jmp short loc_97B52
| long long read_block_primary(long long a1, long long a2, unsigned int a3, unsigned int a4)
{
long long v7; // r15
long long v8; // rdi
unsigned long long v9; // r13
int v10; // eax
++*(_QWORD *)(a1 + 344);
v7 = a1 + 192;
v8 = *(_QWORD *)(a1 + 256);
if ( v8 )
((void ( *)(long long))PSI_server[44])(v8);
pthread_mutex_unlock(v7);
v9 = my_pread(
*(unsigned int *)(*(_QWORD *)(a2 + 32) + 24LL),
*(_QWORD *)(a2 + 64),
a3,
*(_QWORD *)(*(_QWORD *)(a2 + 32) + 32LL),
0LL);
if ( *(_QWORD *)(a1 + 256) )
psi_mutex_lock(v7, (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c", 0xA63u);
else
pthread_mutex_lock(v7);
v10 = *(_DWORD *)(a2 + 80);
if ( v9 >= a4 )
{
*(_DWORD *)(a2 + 80) = v10 | 2;
*(_DWORD *)(a2 + 76) = v9;
}
else
{
*(_DWORD *)(a2 + 80) = v10 | 1;
}
return release_whole_queue(a2 + 40);
}
| read_block_primary:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14D,ECX
MOV R13D,EDX
MOV R12,RDI
INC qword ptr [RDI + 0x158]
MOV RBX,RSI
LEA R15,[RDI + 0xc0]
MOV RDI,qword ptr [RDI + 0x100]
TEST RDI,RDI
JNZ 0x00197b89
LAB_00197b1a:
MOV RDI,R15
CALL 0x001291e0
MOV RAX,qword ptr [RBX + 0x20]
MOV RSI,qword ptr [RBX + 0x40]
MOV EDI,dword ptr [RAX + 0x18]
MOV EDX,R13D
MOV RCX,qword ptr [RAX + 0x20]
XOR R8D,R8D
CALL 0x001a01b0
MOV R13,RAX
CMP qword ptr [R12 + 0x100],0x0
JNZ 0x00197b9e
MOV RDI,R15
CALL 0x00129220
LAB_00197b52:
MOV ECX,R14D
MOV EAX,dword ptr [RBX + 0x50]
CMP R13,RCX
JNC 0x00197b65
OR EAX,0x1
MOV dword ptr [RBX + 0x50],EAX
JMP 0x00197b6f
LAB_00197b65:
OR EAX,0x2
MOV dword ptr [RBX + 0x50],EAX
MOV dword ptr [RBX + 0x4c],R13D
LAB_00197b6f:
ADD RBX,0x28
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00198509
LAB_00197b89:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00197b1a
LAB_00197b9e:
LEA RSI,[0x1dc064]
MOV RDI,R15
MOV EDX,0xa63
CALL 0x0012eb8f
JMP 0x00197b52
|
void read_block_primary(long param_1,long param_2,int4 param_3,ulong param_4)
{
pthread_mutex_t *__mutex;
ulong uVar1;
*(long *)(param_1 + 0x158) = *(long *)(param_1 + 0x158) + 1;
__mutex = (pthread_mutex_t *)(param_1 + 0xc0);
if (*(long *)(param_1 + 0x100) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
uVar1 = my_pread(*(int4 *)(*(long *)(param_2 + 0x20) + 0x18),*(int8 *)(param_2 + 0x40)
,param_3,*(int8 *)(*(long *)(param_2 + 0x20) + 0x20),0);
if (*(long *)(param_1 + 0x100) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",0xa63);
}
if (uVar1 < (param_4 & 0xffffffff)) {
*(uint *)(param_2 + 0x50) = *(uint *)(param_2 + 0x50) | 1;
}
else {
*(uint *)(param_2 + 0x50) = *(uint *)(param_2 + 0x50) | 2;
*(int *)(param_2 + 0x4c) = (int)uVar1;
}
release_whole_queue(param_2 + 0x28);
return;
}
| |
45,605 | string_format[abi:cxx11](char const*, ...) | monkey531[P]llama/common/common.cpp | std::string string_format(const char * fmt, ...) {
va_list ap;
va_list ap2;
va_start(ap, fmt);
va_copy(ap2, ap);
int size = vsnprintf(NULL, 0, fmt, ap);
GGML_ASSERT(size >= 0 && size < INT_MAX); // NOLINT
std::vector<char> buf(size + 1);
int size2 = vsnprintf(buf.data(), size + 1, fmt, ap2);
GGML_ASSERT(size2 == size);
va_end(ap2);
va_end(ap);
return std::string(buf.data(), size);
} | O0 | cpp | string_format[abi:cxx11](char const*, ...):
subq $0x178, %rsp # imm = 0x178
movq %rdi, 0x30(%rsp)
movq %rdi, %r10
movq %r10, 0x38(%rsp)
testb %al, %al
je 0xede05
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq %r9, 0x68(%rsp)
movq %r8, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rdi, 0x170(%rsp)
movq %rsi, 0x168(%rsp)
leaq 0x150(%rsp), %rax
leaq 0x40(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x180(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq 0x130(%rsp), %rax
leaq 0x150(%rsp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq 0x168(%rsp), %rdx
leaq 0x150(%rsp), %rcx
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x5b560
movl %eax, 0x12c(%rsp)
cmpl $0x0, 0x12c(%rsp)
jl 0xedeab
cmpl $0x7fffffff, 0x12c(%rsp) # imm = 0x7FFFFFFF
jl 0xedecc
leaq 0x123eb3(%rip), %rdi # 0x211d65
movl $0x1b2, %esi # imm = 0x1B2
leaq 0x120c50(%rip), %rdx # 0x20eb0e
leaq 0x123eec(%rip), %rcx # 0x211db1
movb $0x0, %al
callq 0x5aee0
movl 0x12c(%rsp), %eax
incl %eax
cltq
movq %rax, 0x20(%rsp)
leaq 0x10f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x5b0d0
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x110(%rsp), %rdi
callq 0xf92c0
jmp 0xedf07
leaq 0x10f(%rsp), %rdi
callq 0x5b540
leaq 0x110(%rsp), %rdi
callq 0xd0a30
movq %rax, %rdi
movl 0x12c(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
movq 0x168(%rsp), %rdx
leaq 0x130(%rsp), %rcx
callq 0x5b560
movl %eax, 0xf8(%rsp)
movl 0xf8(%rsp), %eax
cmpl 0x12c(%rsp), %eax
je 0xedfbf
leaq 0x123e01(%rip), %rdi # 0x211d65
leaq 0x120ba3(%rip), %rdx # 0x20eb0e
leaq 0x123e5b(%rip), %rcx # 0x211dcd
xorl %eax, %eax
movl $0x1b5, %esi # imm = 0x1B5
callq 0x5aee0
jmp 0xedf80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
leaq 0x10f(%rsp), %rdi
callq 0x5b540
jmp 0xee060
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
jmp 0xee053
leaq 0x110(%rsp), %rdi
callq 0xd0a30
movq %rax, 0x8(%rsp)
movslq 0x12c(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xf7(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x5b0d0
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x5b410
jmp 0xee00b
leaq 0xf7(%rsp), %rdi
callq 0x5b540
leaq 0x110(%rsp), %rdi
callq 0xa7a10
movq 0x38(%rsp), %rax
addq $0x178, %rsp # imm = 0x178
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
leaq 0xf7(%rsp), %rdi
callq 0x5b540
leaq 0x110(%rsp), %rdi
callq 0xa7a10
movq 0x100(%rsp), %rdi
callq 0x5abc0
nopl (%rax)
| _Z13string_formatB5cxx11PKcz:
sub rsp, 178h
mov [rsp+178h+var_148], rdi
mov r10, rdi
mov [rsp+178h+var_140], r10
test al, al
jz short loc_EDE05
movaps [rsp+178h+var_108], xmm0
movaps [rsp+178h+var_F8], xmm1
movaps [rsp+178h+var_E8], xmm2
movaps [rsp+178h+var_D8], xmm3
movaps [rsp+178h+var_C8], xmm4
movaps [rsp+178h+var_B8], xmm5
movaps [rsp+178h+var_A8], xmm6
movaps [rsp+178h+var_98], xmm7
loc_EDE05:
mov [rsp+178h+var_110], r9
mov [rsp+178h+var_118], r8
mov [rsp+178h+var_120], rcx
mov [rsp+178h+var_128], rdx
mov [rsp+178h+var_8], rdi
mov [rsp+178h+var_10], rsi
lea rax, [rsp+178h+var_28]
lea rcx, [rsp+178h+var_138]
mov [rax+10h], rcx
lea rcx, [rsp+178h+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 10h
lea rax, [rsp+178h+var_48]
lea rcx, [rsp+178h+var_28]
mov rdx, [rcx+10h]
mov [rax+10h], rdx
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rax], xmm0
mov rdx, [rsp+178h+var_10]
lea rcx, [rsp+178h+var_28]
xor eax, eax
mov esi, eax
mov rdi, rsi
call vsnprintf
mov [rsp+178h+var_4C], eax
cmp [rsp+178h+var_4C], 0
jl short loc_EDEAB
cmp [rsp+178h+var_4C], 7FFFFFFFh
jl short loc_EDECC
loc_EDEAB:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov esi, 1B2h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aSize0SizeIntMa; "size >= 0 && size < INT_MAX"
mov al, 0
call _ggml_abort
loc_EDECC:
mov eax, [rsp+178h+var_4C]
inc eax
cdqe
mov [rsp+178h+var_158], rax
lea rdi, [rsp+178h+var_69]
mov [rsp+178h+var_150], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rsi, [rsp+178h+var_158]
mov rdx, [rsp+178h+var_150]
lea rdi, [rsp+178h+var_68]
call _ZNSt6vectorIcSaIcEEC2EmRKS0_; std::vector<char>::vector(ulong,std::allocator<char> const&)
jmp short $+2
loc_EDF07:
lea rdi, [rsp+178h+var_69]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
lea rdi, [rsp+178h+var_68]
call _ZNSt6vectorIcSaIcEE4dataEv; std::vector<char>::data(void)
mov rdi, rax
mov eax, [rsp+178h+var_4C]
add eax, 1
movsxd rsi, eax
mov rdx, [rsp+178h+var_10]
lea rcx, [rsp+178h+var_48]
call vsnprintf
mov [rsp+178h+var_80], eax
mov eax, [rsp+178h+var_80]
cmp eax, [rsp+178h+var_4C]
jz short loc_EDFBF
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aSize2Size; "size2 == size"
xor eax, eax
mov esi, 1B5h
call _ggml_abort
jmp short $+2
loc_EDF80:
mov rcx, rax
mov eax, edx
mov [rsp+178h+var_78], rcx
mov [rsp+178h+var_7C], eax
lea rdi, [rsp+178h+var_69]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_EE060
mov rcx, rax
mov eax, edx
mov [rsp+178h+var_78], rcx
mov [rsp+178h+var_7C], eax
jmp loc_EE053
loc_EDFBF:
lea rdi, [rsp+178h+var_68]
call _ZNSt6vectorIcSaIcEE4dataEv; std::vector<char>::data(void)
mov [rsp+178h+var_170], rax
movsxd rax, [rsp+178h+var_4C]
mov [rsp+178h+var_168], rax
lea rdi, [rsp+178h+var_81]
mov [rsp+178h+var_160], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdi, [rsp+178h+var_148]
mov rsi, [rsp+178h+var_170]
mov rdx, [rsp+178h+var_168]
mov rcx, [rsp+178h+var_160]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1EPKcmRKS3_; std::string::basic_string(char const*,ulong,std::allocator<char> const&)
jmp short $+2
loc_EE00B:
lea rdi, [rsp+178h+var_81]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
lea rdi, [rsp+178h+var_68]
call _ZNSt6vectorIcSaIcEED2Ev; std::vector<char>::~vector()
mov rax, [rsp+178h+var_140]
add rsp, 178h
retn
mov rcx, rax
mov eax, edx
mov [rsp+178h+var_78], rcx
mov [rsp+178h+var_7C], eax
lea rdi, [rsp+178h+var_81]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
loc_EE053:
lea rdi, [rsp+178h+var_68]
call _ZNSt6vectorIcSaIcEED2Ev; std::vector<char>::~vector()
loc_EE060:
mov rdi, [rsp+178h+var_78]
call __Unwind_Resume
| long long string_format[abi:cxx11](
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
int v15; // ecx
int v16; // r8d
int v17; // r9d
long long v18; // rax
int v19; // edx
long long v21; // [rsp+8h] [rbp-170h]
long long v22; // [rsp+10h] [rbp-168h]
unsigned int v23; // [rsp+20h] [rbp-158h]
_BYTE v24[16]; // [rsp+40h] [rbp-138h] BYREF
long long v25; // [rsp+50h] [rbp-128h]
long long v26; // [rsp+58h] [rbp-120h]
long long v27; // [rsp+60h] [rbp-118h]
long long v28; // [rsp+68h] [rbp-110h]
__m128 v29; // [rsp+70h] [rbp-108h]
__m128 v30; // [rsp+80h] [rbp-F8h]
__m128 v31; // [rsp+90h] [rbp-E8h]
__m128 v32; // [rsp+A0h] [rbp-D8h]
__m128 v33; // [rsp+B0h] [rbp-C8h]
__m128 v34; // [rsp+C0h] [rbp-B8h]
__m128 v35; // [rsp+D0h] [rbp-A8h]
__m128 v36; // [rsp+E0h] [rbp-98h]
char v37; // [rsp+F7h] [rbp-81h] BYREF
int v38; // [rsp+F8h] [rbp-80h]
int v39; // [rsp+FCh] [rbp-7Ch]
long long v40; // [rsp+100h] [rbp-78h]
char v41; // [rsp+10Fh] [rbp-69h] BYREF
long long v42[3]; // [rsp+110h] [rbp-68h] BYREF
unsigned int v43; // [rsp+12Ch] [rbp-4Ch]
__int128 v44; // [rsp+130h] [rbp-48h] BYREF
_BYTE *v45; // [rsp+140h] [rbp-38h]
__int128 v46; // [rsp+150h] [rbp-28h] BYREF
_BYTE *v47; // [rsp+160h] [rbp-18h]
long long v48; // [rsp+168h] [rbp-10h]
long long v49; // [rsp+170h] [rbp-8h]
v29 = a7;
v30 = a8;
v31 = a9;
v32 = a10;
v33 = a11;
v34 = a12;
v35 = a13;
v36 = a14;
v28 = a6;
v27 = a5;
v26 = a4;
v25 = a3;
v49 = a1;
v48 = a2;
v47 = v24;
*((_QWORD *)&v46 + 1) = &a15;
*(_QWORD *)&v46 = 0x3000000010LL;
v45 = v24;
v44 = v46;
v43 = vsnprintf(0LL, 0LL, a2, &v46);
if ( v43 > 0x7FFFFFFE )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",
434LL,
"GGML_ASSERT(%s) failed",
"size >= 0 && size < INT_MAX");
v23 = v43 + 1;
std::allocator<char>::allocator();
std::vector<char>::vector((unsigned int)v42, v23, (unsigned int)&v41, v15, v16, v17);
std::allocator<char>::~allocator(&v41);
v18 = std::vector<char>::data(v42);
v38 = vsnprintf(v18, (int)(v43 + 1), v48, &v44);
if ( v38 != v43 )
{
v40 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",
437LL,
"GGML_ASSERT(%s) failed",
"size2 == size");
v39 = v19;
std::allocator<char>::~allocator(&v41);
_Unwind_Resume(v40);
}
v21 = std::vector<char>::data(v42);
v22 = (int)v43;
std::allocator<char>::allocator();
std::string::basic_string(a1, v21, v22, &v37);
std::allocator<char>::~allocator(&v37);
std::vector<char>::~vector(v42);
return a1;
}
| string_format[abi:cxx11]:
SUB RSP,0x178
MOV qword ptr [RSP + 0x30],RDI
MOV R10,RDI
MOV qword ptr [RSP + 0x38],R10
TEST AL,AL
JZ 0x001ede05
MOVAPS xmmword ptr [RSP + 0x70],XMM0
MOVAPS xmmword ptr [RSP + 0x80],XMM1
MOVAPS xmmword ptr [RSP + 0x90],XMM2
MOVAPS xmmword ptr [RSP + 0xa0],XMM3
MOVAPS xmmword ptr [RSP + 0xb0],XMM4
MOVAPS xmmword ptr [RSP + 0xc0],XMM5
MOVAPS xmmword ptr [RSP + 0xd0],XMM6
MOVAPS xmmword ptr [RSP + 0xe0],XMM7
LAB_001ede05:
MOV qword ptr [RSP + 0x68],R9
MOV qword ptr [RSP + 0x60],R8
MOV qword ptr [RSP + 0x58],RCX
MOV qword ptr [RSP + 0x50],RDX
MOV qword ptr [RSP + 0x170],RDI
MOV qword ptr [RSP + 0x168],RSI
LEA RAX,[RSP + 0x150]
LEA RCX,[RSP + 0x40]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RSP + 0x180]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x10
LEA RAX,[RSP + 0x130]
LEA RCX,[RSP + 0x150]
MOV RDX,qword ptr [RCX + 0x10]
MOV qword ptr [RAX + 0x10],RDX
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RAX],XMM0
MOV RDX,qword ptr [RSP + 0x168]
LEA RCX,[RSP + 0x150]
XOR EAX,EAX
MOV ESI,EAX
MOV RDI,RSI
CALL 0x0015b560
MOV dword ptr [RSP + 0x12c],EAX
CMP dword ptr [RSP + 0x12c],0x0
JL 0x001edeab
CMP dword ptr [RSP + 0x12c],0x7fffffff
JL 0x001edecc
LAB_001edeab:
LEA RDI,[0x311d65]
MOV ESI,0x1b2
LEA RDX,[0x30eb0e]
LEA RCX,[0x311db1]
MOV AL,0x0
CALL 0x0015aee0
LAB_001edecc:
MOV EAX,dword ptr [RSP + 0x12c]
INC EAX
CDQE
MOV qword ptr [RSP + 0x20],RAX
LEA RDI,[RSP + 0x10f]
MOV qword ptr [RSP + 0x28],RDI
CALL 0x0015b0d0
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
LAB_001edef8:
LEA RDI,[RSP + 0x110]
CALL 0x001f92c0
JMP 0x001edf07
LAB_001edf07:
LEA RDI,[RSP + 0x10f]
CALL 0x0015b540
LEA RDI,[RSP + 0x110]
CALL 0x001d0a30
MOV RDI,RAX
MOV EAX,dword ptr [RSP + 0x12c]
ADD EAX,0x1
MOVSXD RSI,EAX
MOV RDX,qword ptr [RSP + 0x168]
LEA RCX,[RSP + 0x130]
CALL 0x0015b560
MOV dword ptr [RSP + 0xf8],EAX
MOV EAX,dword ptr [RSP + 0xf8]
CMP EAX,dword ptr [RSP + 0x12c]
JZ 0x001edfbf
LAB_001edf5d:
LEA RDI,[0x311d65]
LEA RDX,[0x30eb0e]
LEA RCX,[0x311dcd]
XOR EAX,EAX
MOV ESI,0x1b5
CALL 0x0015aee0
JMP 0x001edf80
LAB_001edf80:
MOV RCX,RAX
MOV EAX,EDX
MOV qword ptr [RSP + 0x100],RCX
MOV dword ptr [RSP + 0xfc],EAX
LEA RDI,[RSP + 0x10f]
CALL 0x0015b540
JMP 0x001ee060
LAB_001edfbf:
LEA RDI,[RSP + 0x110]
CALL 0x001d0a30
MOV qword ptr [RSP + 0x8],RAX
MOVSXD RAX,dword ptr [RSP + 0x12c]
MOV qword ptr [RSP + 0x10],RAX
LEA RDI,[RSP + 0xf7]
MOV qword ptr [RSP + 0x18],RDI
CALL 0x0015b0d0
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x18]
LAB_001ee004:
CALL 0x0015b410
LAB_001ee009:
JMP 0x001ee00b
LAB_001ee00b:
LEA RDI,[RSP + 0xf7]
CALL 0x0015b540
LEA RDI,[RSP + 0x110]
CALL 0x001a7a10
MOV RAX,qword ptr [RSP + 0x38]
ADD RSP,0x178
RET
LAB_001ee060:
MOV RDI,qword ptr [RSP + 0x100]
CALL 0x0015abc0
|
/* string_format[abi:cxx11](char const*, ...) */
char * string_format_abi_cxx11_(char *param_1,...)
{
char in_AL;
int iVar1;
char *pcVar2;
ulong uVar3;
int8 in_RCX;
int8 in_RDX;
char *in_RSI;
int8 in_R8;
int8 in_R9;
int4 in_XMM0_Da;
int8 in_XMM1_Qa;
int8 in_XMM2_Qa;
int8 in_XMM3_Qa;
int8 in_XMM4_Qa;
int8 in_XMM5_Qa;
int8 in_XMM6_Qa;
int8 in_XMM7_Qa;
int1 auVar4 [12];
int1 local_138 [16];
int8 local_128;
int8 local_120;
int8 local_118;
int8 local_110;
int4 local_108;
int8 local_f8;
int8 local_e8;
int8 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
allocator local_81;
int local_80;
int4 local_7c;
int8 local_78;
allocator local_69;
vector<char,std::allocator<char>> local_68 [28];
int local_4c;
int8 local_48;
int1 *puStack_40;
int1 *local_38;
int4 local_28;
int4 uStack_24;
int1 *puStack_20;
int1 *local_18;
char *local_10;
char *local_8;
if (in_AL != '\0') {
local_108 = in_XMM0_Da;
local_f8 = in_XMM1_Qa;
local_e8 = in_XMM2_Qa;
local_d8 = in_XMM3_Qa;
local_c8 = in_XMM4_Qa;
local_b8 = in_XMM5_Qa;
local_a8 = in_XMM6_Qa;
local_98 = in_XMM7_Qa;
}
local_38 = local_138;
puStack_40 = &stack0x00000008;
uStack_24 = 0x30;
local_28 = 0x10;
local_48 = 0x3000000010;
local_128 = in_RDX;
local_120 = in_RCX;
local_118 = in_R8;
local_110 = in_R9;
puStack_20 = puStack_40;
local_18 = local_38;
local_10 = in_RSI;
local_8 = param_1;
local_4c = vsnprintf((char *)0x0,0,in_RSI,&local_28);
if ((local_4c < 0) || (0x7ffffffe < local_4c)) {
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",0x1b2,
"GGML_ASSERT(%s) failed","size >= 0 && size < INT_MAX");
}
iVar1 = local_4c + 1;
std::allocator<char>::allocator();
/* try { // try from 001edef8 to 001edf04 has its CatchHandler @ 001edf80 */
std::vector<char,std::allocator<char>>::vector(local_68,(long)iVar1,&local_69);
std::allocator<char>::~allocator((allocator<char> *)&local_69);
pcVar2 = (char *)std::vector<char,std::allocator<char>>::data(local_68);
local_80 = vsnprintf(pcVar2,(long)(local_4c + 1),local_10,&local_48);
if (local_80 != local_4c) {
/* try { // try from 001edf5d to 001edf7d has its CatchHandler @ 001edfa6 */
auVar4 = ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp"
,0x1b5,"GGML_ASSERT(%s) failed","size2 == size");
local_7c = auVar4._8_4_;
local_78 = auVar4._0_8_;
/* catch() { ... } // from try @ 001edef8 with catch @ 001edf80 */
std::allocator<char>::~allocator((allocator<char> *)&local_69);
/* WARNING: Subroutine does not return */
_Unwind_Resume(local_78);
}
pcVar2 = (char *)std::vector<char,std::allocator<char>>::data(local_68);
uVar3 = (ulong)local_4c;
std::allocator<char>::allocator();
/* try { // try from 001ee004 to 001ee008 has its CatchHandler @ 001ee032 */
std::__cxx11::string::string((string *)param_1,pcVar2,uVar3,&local_81);
std::allocator<char>::~allocator((allocator<char> *)&local_81);
std::vector<char,std::allocator<char>>::~vector(local_68);
return param_1;
}
| |
45,606 | string_format[abi:cxx11](char const*, ...) | monkey531[P]llama/common/common.cpp | std::string string_format(const char * fmt, ...) {
va_list ap;
va_list ap2;
va_start(ap, fmt);
va_copy(ap2, ap);
int size = vsnprintf(NULL, 0, fmt, ap);
GGML_ASSERT(size >= 0 && size < INT_MAX); // NOLINT
std::vector<char> buf(size + 1);
int size2 = vsnprintf(buf.data(), size + 1, fmt, ap2);
GGML_ASSERT(size2 == size);
va_end(ap2);
va_end(ap);
return std::string(buf.data(), size);
} | O2 | cpp | string_format[abi:cxx11](char const*, ...):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x60(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x53a72
movaps %xmm0, 0x90(%rsp)
movaps %xmm1, 0xa0(%rsp)
movaps %xmm2, 0xb0(%rsp)
movaps %xmm3, 0xc0(%rsp)
movaps %xmm4, 0xd0(%rsp)
movaps %xmm5, 0xe0(%rsp)
movaps %xmm6, 0xf0(%rsp)
movaps %xmm7, 0x100(%rsp)
movabsq $0x3000000010, %rax # imm = 0x3000000010
leaq 0x40(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x140(%rsp), %rax
movq %rax, 0x8(%rcx)
movq %rsi, 0x10(%rcx)
movq %rsi, 0x20(%rsp)
movq (%rcx), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rcx), %rax
movq %rax, 0x18(%rsp)
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x241f0
cmpl $0x7fffffff, %eax # imm = 0x7FFFFFFF
jae 0x53b2a
movl %eax, %r15d
leal 0x1(%r15), %r12d
leaq 0x28(%rsp), %r13
leaq 0xf(%rsp), %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x58922
movq (%r13), %rdi
leaq 0x10(%rsp), %rcx
movq %r12, %rsi
movq %r14, %rdx
callq 0x241f0
cmpl %r15d, %eax
jne 0x53b4b
movq 0x28(%rsp), %rsi
movl %r15d, %edx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x280e6
leaq 0x28(%rsp), %rdi
callq 0x3f0a4
movq %rbx, %rax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x5f860(%rip), %rdi # 0xb3391
leaq 0x5ca3e(%rip), %rdx # 0xb0576
leaq 0x5f89e(%rip), %rcx # 0xb33dd
movl $0x1b2, %esi # imm = 0x1B2
xorl %eax, %eax
callq 0x23ed0
leaq 0x5f83f(%rip), %rdi # 0xb3391
leaq 0x5ca1d(%rip), %rdx # 0xb0576
leaq 0x5f899(%rip), %rcx # 0xb33f9
movl $0x1b5, %esi # imm = 0x1B5
xorl %eax, %eax
callq 0x23ed0
jmp 0x53b6e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3f0a4
movq %rbx, %rdi
callq 0x23fb0
| _Z13string_formatB5cxx11PKcz:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 110h
mov r14, rsi
mov rbx, rdi
lea rsi, [rsp+138h+var_D8]
mov [rsi+10h], rdx
mov [rsi+18h], rcx
mov [rsi+20h], r8
mov [rsi+28h], r9
test al, al
jz short loc_53A72
movaps [rsp+138h+var_A8], xmm0
movaps [rsp+138h+var_98], xmm1
movaps [rsp+138h+var_88], xmm2
movaps [rsp+138h+var_78], xmm3
movaps [rsp+138h+var_68], xmm4
movaps [rsp+138h+var_58], xmm5
movaps [rsp+138h+var_48], xmm6
movaps [rsp+138h+var_38], xmm7
loc_53A72:
mov rax, 3000000010h
lea rcx, [rsp+138h+var_F8]
mov [rcx], rax
lea rax, [rsp+138h+arg_0]
mov [rcx+8], rax
mov [rcx+10h], rsi
mov [rsp+138h+var_118], rsi
mov rax, [rcx]
mov [rsp+138h+var_128], rax
mov rax, [rcx+8]
mov [rsp+138h+var_120], rax
xor edi, edi
xor esi, esi
mov rdx, r14
call vsnprintf
cmp eax, 7FFFFFFFh
jnb short loc_53B2A
mov r15d, eax
lea r12d, [r15+1]
lea r13, [rsp+138h+var_110]
lea rdx, [rsp+138h+var_129]
mov rdi, r13
mov rsi, r12
call _ZNSt6vectorIcSaIcEEC2EmRKS0_; std::vector<char>::vector(ulong,std::allocator<char> const&)
mov rdi, [r13+0]
lea rcx, [rsp+138h+var_128]
mov rsi, r12
mov rdx, r14
call vsnprintf
cmp eax, r15d
jnz short loc_53B4B
mov rsi, [rsp+138h+var_110]
mov edx, r15d
lea rax, [rbx+10h]
mov [rbx], rax
add rdx, rsi
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rdi, [rsp+138h+var_110]
call _ZNSt12_Vector_baseIcSaIcEED2Ev; std::_Vector_base<char>::~_Vector_base()
mov rax, rbx
add rsp, 110h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_53B2A:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aSize0SizeIntMa; "size >= 0 && size < INT_MAX"
mov esi, 1B2h
xor eax, eax
call _ggml_abort
loc_53B4B:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aSize2Size; "size2 == size"
mov esi, 1B5h
xor eax, eax
call _ggml_abort
jmp short $+2
loc_53B6E:
mov rbx, rax
lea rdi, [rsp+138h+var_110]
call _ZNSt12_Vector_baseIcSaIcEED2Ev; std::_Vector_base<char>::~_Vector_base()
mov rdi, rbx
call __Unwind_Resume
| _QWORD * string_format[abi:cxx11](
_QWORD *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
unsigned int v15; // eax
unsigned int v16; // r15d
long long v17; // r12
_BYTE *v18; // rsi
long long v20; // rax
char v21; // [rsp+Fh] [rbp-129h] BYREF
_QWORD v22[3]; // [rsp+10h] [rbp-128h] BYREF
_QWORD v23[3]; // [rsp+28h] [rbp-110h] BYREF
_QWORD v24[4]; // [rsp+40h] [rbp-F8h] BYREF
_BYTE v25[16]; // [rsp+60h] [rbp-D8h] BYREF
long long v26; // [rsp+70h] [rbp-C8h]
long long v27; // [rsp+78h] [rbp-C0h]
long long v28; // [rsp+80h] [rbp-B8h]
long long v29; // [rsp+88h] [rbp-B0h]
__m128 v30; // [rsp+90h] [rbp-A8h]
__m128 v31; // [rsp+A0h] [rbp-98h]
__m128 v32; // [rsp+B0h] [rbp-88h]
__m128 v33; // [rsp+C0h] [rbp-78h]
__m128 v34; // [rsp+D0h] [rbp-68h]
__m128 v35; // [rsp+E0h] [rbp-58h]
__m128 v36; // [rsp+F0h] [rbp-48h]
__m128 v37; // [rsp+100h] [rbp-38h]
v30 = a7;
v31 = a8;
v32 = a9;
v33 = a10;
v34 = a11;
v35 = a12;
v36 = a13;
v37 = a14;
v26 = a3;
v27 = a4;
v28 = a5;
v29 = a6;
v24[0] = 0x3000000010LL;
v24[1] = &a15;
v24[2] = v25;
v22[2] = v25;
v22[0] = 0x3000000010LL;
v22[1] = &a15;
v15 = vsnprintf(0LL, 0LL, a2, v24);
if ( v15 >= 0x7FFFFFFF )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",
434LL,
"GGML_ASSERT(%s) failed",
"size >= 0 && size < INT_MAX");
LABEL_5:
v20 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",
437LL,
"GGML_ASSERT(%s) failed",
"size2 == size");
std::_Vector_base<char>::~_Vector_base((long long)v23);
_Unwind_Resume(v20);
}
v16 = v15;
v17 = v15 + 1;
std::vector<char>::vector(v23, v17, &v21);
if ( (unsigned int)vsnprintf(v23[0], v17, a2, v22) != v16 )
goto LABEL_5;
v18 = (_BYTE *)v23[0];
*a1 = a1 + 2;
std::string::_M_construct<char const*>((long long)a1, v18, (long long)&v18[v16]);
std::_Vector_base<char>::~_Vector_base((long long)v23);
return a1;
}
| string_format[abi:cxx11]:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x110
MOV R14,RSI
MOV RBX,RDI
LEA RSI,[RSP + 0x60]
MOV qword ptr [RSI + 0x10],RDX
MOV qword ptr [RSI + 0x18],RCX
MOV qword ptr [RSI + 0x20],R8
MOV qword ptr [RSI + 0x28],R9
TEST AL,AL
JZ 0x00153a72
MOVAPS xmmword ptr [RSP + 0x90],XMM0
MOVAPS xmmword ptr [RSP + 0xa0],XMM1
MOVAPS xmmword ptr [RSP + 0xb0],XMM2
MOVAPS xmmword ptr [RSP + 0xc0],XMM3
MOVAPS xmmword ptr [RSP + 0xd0],XMM4
MOVAPS xmmword ptr [RSP + 0xe0],XMM5
MOVAPS xmmword ptr [RSP + 0xf0],XMM6
MOVAPS xmmword ptr [RSP + 0x100],XMM7
LAB_00153a72:
MOV RAX,0x3000000010
LEA RCX,[RSP + 0x40]
MOV qword ptr [RCX],RAX
LEA RAX,[RSP + 0x140]
MOV qword ptr [RCX + 0x8],RAX
MOV qword ptr [RCX + 0x10],RSI
MOV qword ptr [RSP + 0x20],RSI
MOV RAX,qword ptr [RCX]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RCX + 0x8]
MOV qword ptr [RSP + 0x18],RAX
XOR EDI,EDI
XOR ESI,ESI
MOV RDX,R14
CALL 0x001241f0
CMP EAX,0x7fffffff
JNC 0x00153b2a
MOV R15D,EAX
LEA R12D,[R15 + 0x1]
LEA R13,[RSP + 0x28]
LEA RDX,[RSP + 0xf]
MOV RDI,R13
MOV RSI,R12
CALL 0x00158922
MOV RDI,qword ptr [R13]
LEA RCX,[RSP + 0x10]
MOV RSI,R12
MOV RDX,R14
CALL 0x001241f0
CMP EAX,R15D
JNZ 0x00153b4b
MOV RSI,qword ptr [RSP + 0x28]
MOV EDX,R15D
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
ADD RDX,RSI
LAB_00153b04:
MOV RDI,RBX
CALL 0x001280e6
LAB_00153b0c:
LEA RDI,[RSP + 0x28]
CALL 0x0013f0a4
MOV RAX,RBX
ADD RSP,0x110
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_00153b2a:
LEA RDI,[0x1b3391]
LEA RDX,[0x1b0576]
LEA RCX,[0x1b33dd]
MOV ESI,0x1b2
XOR EAX,EAX
CALL 0x00123ed0
LAB_00153b4b:
LEA RDI,[0x1b3391]
LEA RDX,[0x1b0576]
LEA RCX,[0x1b33f9]
MOV ESI,0x1b5
XOR EAX,EAX
CALL 0x00123ed0
|
/* string_format[abi:cxx11](char const*, ...) */
char * string_format_abi_cxx11_(char *param_1,...)
{
char in_AL;
uint uVar1;
uint uVar2;
int8 in_RCX;
int8 in_RDX;
char *in_RSI;
int8 in_R8;
int8 in_R9;
int8 in_XMM0_Qa;
int8 in_XMM1_Qa;
int8 in_XMM2_Qa;
int8 in_XMM3_Qa;
int8 in_XMM4_Qa;
int8 in_XMM5_Qa;
int8 in_XMM6_Qa;
int8 in_XMM7_Qa;
allocator local_129;
int8 local_128;
int1 *local_120;
int1 *local_118;
char *local_110 [3];
int8 local_f8;
int1 *local_f0;
int1 *local_e8;
int1 local_d8 [16];
int8 local_c8;
int8 local_c0;
int8 local_b8;
int8 local_b0;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int8 local_38;
local_118 = local_d8;
if (in_AL != '\0') {
local_a8 = in_XMM0_Qa;
local_98 = in_XMM1_Qa;
local_88 = in_XMM2_Qa;
local_78 = in_XMM3_Qa;
local_68 = in_XMM4_Qa;
local_58 = in_XMM5_Qa;
local_48 = in_XMM6_Qa;
local_38 = in_XMM7_Qa;
}
local_f8 = 0x3000000010;
local_120 = &stack0x00000008;
local_128 = 0x3000000010;
local_f0 = local_120;
local_e8 = local_118;
local_c8 = in_RDX;
local_c0 = in_RCX;
local_b8 = in_R8;
local_b0 = in_R9;
uVar1 = vsnprintf((char *)0x0,0,in_RSI,&local_f8);
if (uVar1 < 0x7fffffff) {
std::vector<char,std::allocator<char>>::vector
((vector<char,std::allocator<char>> *)local_110,(ulong)(uVar1 + 1),&local_129);
uVar2 = vsnprintf(local_110[0],(ulong)(uVar1 + 1),in_RSI,&local_128);
if (uVar2 == uVar1) {
*(char **)param_1 = param_1 + 0x10;
/* try { // try from 00153b04 to 00153b0b has its CatchHandler @ 00153b6c */
std::__cxx11::string::_M_construct<char_const*>(param_1,local_110[0],local_110[0] + uVar1);
std::_Vector_base<char,std::allocator<char>>::~_Vector_base
((_Vector_base<char,std::allocator<char>> *)local_110);
return param_1;
}
/* try { // try from 00153b4b to 00153b6b has its CatchHandler @ 00153b6e */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",0x1b5,
"GGML_ASSERT(%s) failed","size2 == size");
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",0x1b2,
"GGML_ASSERT(%s) failed","size >= 0 && size < INT_MAX");
}
| |
45,607 | stbi_zlib_decode_malloc_guesssize | 7CodeWizard[P]stablediffusion/thirdparty/stb_image.h | STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
{
stbi__zbuf a;
char *p = (char *) stbi__malloc(initial_size);
if (p == NULL) return NULL;
a.zbuffer = (stbi_uc *) buffer;
a.zbuffer_end = (stbi_uc *) buffer + len;
if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {
if (outlen) *outlen = (int) (a.zout - a.zout_start);
return a.zout_start;
} else {
STBI_FREE(a.zout_start);
return NULL;
}
} | O0 | c | stbi_zlib_decode_malloc_guesssize:
subq $0x1028, %rsp # imm = 0x1028
movq %rdi, 0x1018(%rsp)
movl %esi, 0x1014(%rsp)
movl %edx, 0x1010(%rsp)
movq %rcx, 0x1008(%rsp)
movslq 0x1010(%rsp), %rdi
callq 0xf360
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0xf2be
movq $0x0, 0x1020(%rsp)
jmp 0xf34f
movq 0x1018(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x1018(%rsp), %rax
movslq 0x1014(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq (%rsp), %rsi
movl 0x1010(%rsp), %edx
leaq 0x8(%rsp), %rdi
movl $0x1, %r8d
movl %r8d, %ecx
callq 0xf370
cmpl $0x0, %eax
je 0xf339
cmpq $0x0, 0x1008(%rsp)
je 0xf32a
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq 0x1008(%rsp), %rax
movl %ecx, (%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x1020(%rsp)
jmp 0xf34f
movq 0x28(%rsp), %rdi
callq 0xb900
movq $0x0, 0x1020(%rsp)
movq 0x1020(%rsp), %rax
addq $0x1028, %rsp # imm = 0x1028
retq
nop
| stbi_zlib_decode_malloc_guesssize:
sub rsp, 1028h
mov [rsp+1028h+var_10], rdi
mov [rsp+1028h+var_14], esi
mov [rsp+1028h+var_18], edx
mov [rsp+1028h+var_20], rcx
movsxd rdi, [rsp+1028h+var_18]; unsigned __int64
call _ZL12stbi__mallocm; stbi__malloc(ulong)
mov [rsp+1028h+var_1028], rax
cmp [rsp+1028h+var_1028], 0
jnz short loc_F2BE
mov [rsp+1028h+var_8], 0
jmp loc_F34F
loc_F2BE:
mov rax, [rsp+1028h+var_10]
mov [rsp+1028h+var_1020], rax
mov rax, [rsp+1028h+var_10]
movsxd rcx, [rsp+1028h+var_14]
add rax, rcx
mov [rsp+1028h+var_1018], rax
mov rsi, [rsp+1028h+var_1028]
mov edx, [rsp+1028h+var_18]
lea rdi, [rsp+1028h+var_1020]
mov r8d, 1
mov ecx, r8d
call _ZL13stbi__do_zlibP10stbi__zbufPciii; stbi__do_zlib(stbi__zbuf *,char *,int,int,int)
cmp eax, 0
jz short loc_F339
cmp [rsp+1028h+var_20], 0
jz short loc_F32A
mov rax, [rsp+1028h+var_1008]
mov rcx, [rsp+1028h+var_1000]
sub rax, rcx
mov ecx, eax
mov rax, [rsp+1028h+var_20]
mov [rax], ecx
loc_F32A:
mov rax, [rsp+1028h+var_1000]
mov [rsp+1028h+var_8], rax
jmp short loc_F34F
loc_F339:
mov rdi, [rsp+1028h+var_1000]
call _free
mov [rsp+1028h+var_8], 0
loc_F34F:
mov rax, [rsp+1028h+var_8]
add rsp, 1028h
retn
| long long stbi_zlib_decode_malloc_guesssize(long long a1, int a2, int a3, _DWORD *a4)
{
long long v5; // [rsp+0h] [rbp-1028h]
_QWORD v6[3]; // [rsp+8h] [rbp-1020h] BYREF
long long v7; // [rsp+20h] [rbp-1008h]
long long v8; // [rsp+28h] [rbp-1000h]
_DWORD *v9; // [rsp+1008h] [rbp-20h]
unsigned int v10; // [rsp+1010h] [rbp-18h]
int v11; // [rsp+1014h] [rbp-14h]
long long v12; // [rsp+1018h] [rbp-10h]
v12 = a1;
v11 = a2;
v10 = a3;
v9 = a4;
v5 = stbi__malloc(a3);
if ( !v5 )
return 0LL;
v6[0] = v12;
v6[1] = v11 + v12;
if ( (unsigned int)stbi__do_zlib(v6, v5, v10, 1LL) )
{
if ( v9 )
*v9 = v7 - v8;
return v8;
}
else
{
free(v8);
return 0LL;
}
}
| stbi_zlib_decode_malloc_guesssize:
SUB RSP,0x1028
MOV qword ptr [RSP + 0x1018],RDI
MOV dword ptr [RSP + 0x1014],ESI
MOV dword ptr [RSP + 0x1010],EDX
MOV qword ptr [RSP + 0x1008],RCX
MOVSXD RDI,dword ptr [RSP + 0x1010]
CALL 0x0010f360
MOV qword ptr [RSP],RAX
CMP qword ptr [RSP],0x0
JNZ 0x0010f2be
MOV qword ptr [RSP + 0x1020],0x0
JMP 0x0010f34f
LAB_0010f2be:
MOV RAX,qword ptr [RSP + 0x1018]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x1018]
MOVSXD RCX,dword ptr [RSP + 0x1014]
ADD RAX,RCX
MOV qword ptr [RSP + 0x10],RAX
MOV RSI,qword ptr [RSP]
MOV EDX,dword ptr [RSP + 0x1010]
LEA RDI,[RSP + 0x8]
MOV R8D,0x1
MOV ECX,R8D
CALL 0x0010f370
CMP EAX,0x0
JZ 0x0010f339
CMP qword ptr [RSP + 0x1008],0x0
JZ 0x0010f32a
MOV RAX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x28]
SUB RAX,RCX
MOV ECX,EAX
MOV RAX,qword ptr [RSP + 0x1008]
MOV dword ptr [RAX],ECX
LAB_0010f32a:
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x1020],RAX
JMP 0x0010f34f
LAB_0010f339:
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0010b900
MOV qword ptr [RSP + 0x1020],0x0
LAB_0010f34f:
MOV RAX,qword ptr [RSP + 0x1020]
ADD RSP,0x1028
RET
|
void * stbi_zlib_decode_malloc_guesssize(long param_1,int param_2,int param_3,int *param_4)
{
int iVar1;
char *pcVar2;
long local_1020;
long local_1018;
int local_1008;
void *local_1000;
int *local_20;
int local_18;
int local_14;
long local_10;
void *local_8;
local_20 = param_4;
local_18 = param_3;
local_14 = param_2;
local_10 = param_1;
pcVar2 = (char *)stbi__malloc((long)param_3);
if (pcVar2 == (char *)0x0) {
local_8 = (void *)0x0;
}
else {
local_1020 = local_10;
local_1018 = local_10 + local_14;
iVar1 = stbi__do_zlib((stbi__zbuf *)&local_1020,pcVar2,local_18,1,1);
if (iVar1 == 0) {
free(local_1000);
local_8 = (void *)0x0;
}
else {
if (local_20 != (int *)0x0) {
*local_20 = local_1008 - (int)local_1000;
}
local_8 = local_1000;
}
}
return local_8;
}
| |
45,608 | stbi_zlib_decode_malloc_guesssize | 7CodeWizard[P]stablediffusion/thirdparty/stb_image.h | STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
{
stbi__zbuf a;
char *p = (char *) stbi__malloc(initial_size);
if (p == NULL) return NULL;
a.zbuffer = (stbi_uc *) buffer;
a.zbuffer_end = (stbi_uc *) buffer + len;
if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {
if (outlen) *outlen = (int) (a.zout - a.zout_start);
return a.zout_start;
} else {
STBI_FREE(a.zout_start);
return NULL;
}
} | O1 | c | stbi_zlib_decode_malloc_guesssize:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp # imm = 0x1008
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movslq %edx, %rdi
callq 0xa7c0
testq %rax, %rax
je 0x1af9e
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
movslq %r15d, %rcx
addq %r14, %rcx
movq %rcx, 0x8(%rdi)
movq %rax, %rsi
movl %ebp, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x1afae
testl %eax, %eax
je 0x1af94
testq %rbx, %rbx
je 0x1af8d
movl 0x20(%rsp), %eax
subl 0x28(%rsp), %eax
movl %eax, (%rbx)
movq 0x28(%rsp), %rax
jmp 0x1afa0
movq 0x28(%rsp), %rdi
callq 0xa700
xorl %eax, %eax
addq $0x1008, %rsp # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| stbi_zlib_decode_malloc_guesssize:
push rbp
push r15
push r14
push rbx
sub rsp, 1008h
mov rbx, rcx
mov ebp, edx
mov r15d, esi
mov r14, rdi
movsxd rdi, edx
call _malloc
test rax, rax
jz short loc_1AF9E
lea rdi, [rsp+1028h+var_1020]
mov [rdi], r14
movsxd rcx, r15d
add rcx, r14
mov [rdi+8], rcx
mov rsi, rax
mov edx, ebp
mov ecx, 1
mov r8d, 1
call _ZL13stbi__do_zlibP10stbi__zbufPciii; stbi__do_zlib(stbi__zbuf *,char *,int,int,int)
test eax, eax
jz short loc_1AF94
test rbx, rbx
jz short loc_1AF8D
mov eax, [rsp+1028h+var_1008]
sub eax, dword ptr [rsp+1028h+var_1000]
mov [rbx], eax
loc_1AF8D:
mov rax, [rsp+1028h+var_1000]
jmp short loc_1AFA0
loc_1AF94:
mov rdi, [rsp+1028h+var_1000]
call _free
loc_1AF9E:
xor eax, eax
loc_1AFA0:
add rsp, 1008h
pop rbx
pop r14
pop r15
pop rbp
retn
| long long stbi_zlib_decode_malloc_guesssize(long long a1, int a2, unsigned int a3, _DWORD *a4)
{
long long v6; // rax
_QWORD v8[3]; // [rsp+8h] [rbp-1020h] BYREF
int v9; // [rsp+20h] [rbp-1008h]
long long v10; // [rsp+28h] [rbp-1000h]
v6 = malloc((int)a3);
if ( !v6 )
return 0LL;
v8[0] = a1;
v8[1] = a1 + a2;
if ( !(unsigned int)stbi__do_zlib(v8, v6, a3, 1LL, 1LL) )
{
free(v10);
return 0LL;
}
if ( a4 )
*a4 = v9 - v10;
return v10;
}
| |||
45,609 | stbi_zlib_decode_malloc_guesssize | 7CodeWizard[P]stablediffusion/thirdparty/stb_image.h | STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
{
stbi__zbuf a;
char *p = (char *) stbi__malloc(initial_size);
if (p == NULL) return NULL;
a.zbuffer = (stbi_uc *) buffer;
a.zbuffer_end = (stbi_uc *) buffer + len;
if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {
if (outlen) *outlen = (int) (a.zout - a.zout_start);
return a.zout_start;
} else {
STBI_FREE(a.zout_start);
return NULL;
}
} | O3 | c | stbi_zlib_decode_malloc_guesssize:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp # imm = 0x1008
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movslq %edx, %rdi
callq 0xa7b0
testq %rax, %rax
je 0x1aa40
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
movslq %r15d, %rcx
addq %r14, %rcx
movq %rcx, 0x8(%rdi)
movq %rax, %rsi
movl %ebp, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x1aa57
testl %eax, %eax
je 0x1aa36
testq %rbx, %rbx
je 0x1aa50
movl 0x20(%rsp), %ecx
movq 0x28(%rsp), %rax
subl %eax, %ecx
movl %ecx, (%rbx)
jmp 0x1aa42
movq 0x28(%rsp), %rdi
callq 0xa6f0
xorl %eax, %eax
addq $0x1008, %rsp # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%rsp), %rax
jmp 0x1aa42
| stbi_zlib_decode_malloc_guesssize:
push rbp
push r15
push r14
push rbx
sub rsp, 1008h
mov rbx, rcx
mov ebp, edx
mov r15d, esi
mov r14, rdi
movsxd rdi, edx
call _malloc
test rax, rax
jz short loc_1AA40
lea rdi, [rsp+1028h+var_1020]
mov [rdi], r14
movsxd rcx, r15d
add rcx, r14
mov [rdi+8], rcx
mov rsi, rax
mov edx, ebp
mov ecx, 1
mov r8d, 1
call _ZL13stbi__do_zlibP10stbi__zbufPciii; stbi__do_zlib(stbi__zbuf *,char *,int,int,int)
test eax, eax
jz short loc_1AA36
test rbx, rbx
jz short loc_1AA50
mov ecx, [rsp+1028h+var_1008]
mov rax, [rsp+1028h+var_1000]
sub ecx, eax
mov [rbx], ecx
jmp short loc_1AA42
loc_1AA36:
mov rdi, [rsp+1028h+var_1000]
call _free
loc_1AA40:
xor eax, eax
loc_1AA42:
add rsp, 1008h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_1AA50:
mov rax, [rsp+1028h+var_1000]
jmp short loc_1AA42
| long long stbi_zlib_decode_malloc_guesssize(long long a1, int a2, unsigned int a3, _DWORD *a4)
{
long long v6; // rax
long long result; // rax
_QWORD v8[3]; // [rsp+8h] [rbp-1020h] BYREF
int v9; // [rsp+20h] [rbp-1008h]
long long v10; // [rsp+28h] [rbp-1000h]
v6 = malloc((int)a3);
if ( !v6 )
return 0LL;
v8[0] = a1;
v8[1] = a1 + a2;
if ( !(unsigned int)stbi__do_zlib(v8, v6, a3, 1LL, 1LL) )
{
free(v10);
return 0LL;
}
result = v10;
if ( a4 )
*a4 = v9 - v10;
return result;
}
| |||
45,610 | do_save_master_pos() | eloqsql/client/mysqltest.cc | int do_save_master_pos()
{
MYSQL_RES *res;
MYSQL_ROW row;
MYSQL *mysql = cur_con->mysql;
const char *query;
DBUG_ENTER("do_save_master_pos");
if (mysql_query(mysql, query= "show master status"))
die("failed in 'show master status': %d %s",
mysql_errno(mysql), mysql_error(mysql));
if (!(res = mysql_store_result(mysql)))
die("mysql_store_result() returned NULL for '%s'", query);
if (!(row = mysql_fetch_row(res)))
die("empty result in show master status");
strnmov(master_pos.file, row[0], sizeof(master_pos.file)-1);
master_pos.pos = strtoul(row[1], (char**) 0, 10);
mysql_free_result(res);
DBUG_RETURN(0);
} | O0 | cpp | do_save_master_pos():
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x44fd09(%rip), %rax # 0x4b95a8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xe2f35(%rip), %rax # 0x14c7e6
movq %rax, -0x20(%rbp)
leaq 0xe2f2a(%rip), %rsi # 0x14c7e6
callq 0x61670
cmpl $0x0, %eax
je 0x698ef
movq -0x18(%rbp), %rdi
callq 0x86630
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x86660
movl -0x24(%rbp), %esi
movq %rax, %rdx
leaq 0xe2ec8(%rip), %rdi # 0x14c7b0
movb $0x0, %al
callq 0x62b40
movq -0x18(%rbp), %rdi
callq 0x614b0
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
jne 0x69914
movq -0x20(%rbp), %rsi
leaq 0xe2d77(%rip), %rdi # 0x14c684
movb $0x0, %al
callq 0x62b40
movq -0x8(%rbp), %rdi
callq 0x612a0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x69935
leaq 0xe2ea8(%rip), %rdi # 0x14c7d6
movb $0x0, %al
callq 0x62b40
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x44f7ad(%rip), %rdi # 0x4b90f0
movl $0x1ff, %edx # imm = 0x1FF
callq 0x148b90
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x600d0
movq %rax, 0x44f986(%rip) # 0x4b92f0
movq -0x8(%rbp), %rdi
callq 0x61520
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _Z18do_save_master_posv:
push rbp
mov rbp, rsp
sub rsp, 30h
mov rax, cs:cur_con
mov rax, [rax]
mov [rbp+var_18], rax
mov rdi, [rbp+var_18]
lea rax, aEmptyResultInS_0+10h; "show master status"
mov [rbp+var_20], rax
lea rsi, aEmptyResultInS_0+10h; "show master status"
call _Z16wrap_mysql_queryP8st_mysqlPKc; wrap_mysql_query(st_mysql *,char const*)
cmp eax, 0
jz short loc_698EF
mov rdi, [rbp+var_18]
call mysql_errno
mov [rbp+var_24], eax
mov rdi, [rbp+var_18]
call mysql_error
mov esi, [rbp+var_24]
mov rdx, rax
lea rdi, aFailedInShowMa; "failed in 'show master status': %d %s"
mov al, 0
call _ZL3diePKcz; die(char const*,...)
loc_698EF:
mov rdi, [rbp+var_18]
call _Z23wrap_mysql_store_resultP8st_mysql; wrap_mysql_store_result(st_mysql *)
mov [rbp+var_8], rax
cmp rax, 0
jnz short loc_69914
mov rsi, [rbp+var_20]
lea rdi, aMysqlStoreResu_2; "mysql_store_result() returned NULL for "...
mov al, 0
call _ZL3diePKcz; die(char const*,...)
loc_69914:
mov rdi, [rbp+var_8]
call _Z20wrap_mysql_fetch_rowP12st_mysql_res; wrap_mysql_fetch_row(st_mysql_res *)
mov [rbp+var_10], rax
cmp rax, 0
jnz short loc_69935
lea rdi, aEmptyResultInS_0; "empty result in show master status"
mov al, 0
call _ZL3diePKcz; die(char const*,...)
loc_69935:
mov rax, [rbp+var_10]
mov rsi, [rax]
lea rdi, master_pos
mov edx, 1FFh
call strnmov
mov rax, [rbp+var_10]
mov rdi, [rax+8]
xor eax, eax
mov esi, eax
mov edx, 0Ah
call ___isoc23_strtoul
mov cs:qword_4B92F0, rax
mov rdi, [rbp+var_8]
call _Z22wrap_mysql_free_resultP12st_mysql_res; wrap_mysql_free_result(st_mysql_res *)
xor eax, eax
add rsp, 30h
pop rbp
retn
| long long do_save_master_pos(void)
{
const char *v0; // rax
int v2; // [rsp+Ch] [rbp-24h]
long long v3; // [rsp+18h] [rbp-18h]
_QWORD *row; // [rsp+20h] [rbp-10h]
long long v5; // [rsp+28h] [rbp-8h]
v3 = *(_QWORD *)cur_con;
if ( (unsigned int)wrap_mysql_query(*(_QWORD *)cur_con, (long long)"show master status") )
{
v2 = mysql_errno(v3);
v0 = (const char *)mysql_error(v3);
die("failed in 'show master status': %d %s", v2, v0);
}
v5 = wrap_mysql_store_result(v3);
if ( !v5 )
die("mysql_store_result() returned NULL for '%s'", "show master status");
row = (_QWORD *)wrap_mysql_fetch_row(v5);
if ( !row )
die("empty result in show master status");
strnmov(&master_pos, *row, 511LL);
qword_4B92F0 = __isoc23_strtoul(row[1], 0LL, 10LL);
wrap_mysql_free_result(v5);
return 0LL;
}
| do_save_master_pos:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV RAX,qword ptr [0x005b95a8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x18]
LEA RAX,[0x24c7e6]
MOV qword ptr [RBP + -0x20],RAX
LEA RSI,[0x24c7e6]
CALL 0x00161670
CMP EAX,0x0
JZ 0x001698ef
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00186630
MOV dword ptr [RBP + -0x24],EAX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00186660
MOV ESI,dword ptr [RBP + -0x24]
MOV RDX,RAX
LEA RDI,[0x24c7b0]
MOV AL,0x0
CALL 0x00162b40
LAB_001698ef:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001614b0
MOV qword ptr [RBP + -0x8],RAX
CMP RAX,0x0
JNZ 0x00169914
MOV RSI,qword ptr [RBP + -0x20]
LEA RDI,[0x24c684]
MOV AL,0x0
CALL 0x00162b40
LAB_00169914:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001612a0
MOV qword ptr [RBP + -0x10],RAX
CMP RAX,0x0
JNZ 0x00169935
LEA RDI,[0x24c7d6]
MOV AL,0x0
CALL 0x00162b40
LAB_00169935:
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX]
LEA RDI,[0x5b90f0]
MOV EDX,0x1ff
CALL 0x00248b90
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x8]
XOR EAX,EAX
MOV ESI,EAX
MOV EDX,0xa
CALL 0x001600d0
MOV qword ptr [0x005b92f0],RAX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00161520
XOR EAX,EAX
ADD RSP,0x30
POP RBP
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* do_save_master_pos() */
int8 do_save_master_pos(void)
{
st_mysql *psVar1;
int iVar2;
uint uVar3;
int8 uVar4;
st_mysql_res *psVar5;
int8 *puVar6;
psVar1 = (st_mysql *)*cur_con;
iVar2 = wrap_mysql_query(psVar1,"show master status");
if (iVar2 != 0) {
uVar3 = mysql_errno(psVar1);
uVar4 = mysql_error(psVar1);
die("failed in \'show master status\': %d %s",(ulong)uVar3,uVar4);
}
psVar5 = (st_mysql_res *)wrap_mysql_store_result(psVar1);
if (psVar5 == (st_mysql_res *)0x0) {
die("mysql_store_result() returned NULL for \'%s\'","show master status");
}
puVar6 = (int8 *)wrap_mysql_fetch_row(psVar5);
if (puVar6 == (int8 *)0x0) {
die("empty result in show master status");
}
strnmov(&master_pos,*puVar6,0x1ff);
DAT_005b92f0 = __isoc23_strtoul(puVar6[1],0,10);
wrap_mysql_free_result(psVar5);
return 0;
}
| |
45,611 | stbi_zlib_decode_malloc_guesssize | monkey531[P]llama/examples/llava/../../common/stb_image.h | STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
{
stbi__zbuf a;
char *p = (char *) stbi__malloc(initial_size);
if (p == NULL) return NULL;
a.zbuffer = (stbi_uc *) buffer;
a.zbuffer_end = (stbi_uc *) buffer + len;
if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {
if (outlen) *outlen = (int) (a.zout - a.zout_start);
return a.zout_start;
} else {
STBI_FREE(a.zout_start);
return NULL;
}
} | O1 | c | stbi_zlib_decode_malloc_guesssize:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp # imm = 0x1008
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movslq %edx, %rdi
callq 0x1e000
testq %rax, %rax
je 0x29cc6
movq %rsp, %rdi
movq %r14, (%rdi)
movslq %r15d, %rcx
addq %r14, %rcx
movq %rcx, 0x8(%rdi)
movq %rax, %rsi
movl %ebp, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x29cd6
testl %eax, %eax
je 0x29cbc
testq %rbx, %rbx
je 0x29cb5
movl 0x20(%rsp), %eax
subl 0x28(%rsp), %eax
movl %eax, (%rbx)
movq 0x28(%rsp), %rax
jmp 0x29cc8
movq 0x28(%rsp), %rdi
callq 0x1de70
xorl %eax, %eax
addq $0x1008, %rsp # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| stbi_zlib_decode_malloc_guesssize:
push rbp
push r15
push r14
push rbx
sub rsp, 1008h
mov rbx, rcx
mov ebp, edx
mov r15d, esi
mov r14, rdi
movsxd rdi, edx
call _malloc
test rax, rax
jz short loc_29CC6
mov rdi, rsp
mov [rdi], r14
movsxd rcx, r15d
add rcx, r14
mov [rdi+8], rcx
mov rsi, rax
mov edx, ebp
mov ecx, 1
mov r8d, 1
call _ZL13stbi__do_zlibP10stbi__zbufPciii; stbi__do_zlib(stbi__zbuf *,char *,int,int,int)
test eax, eax
jz short loc_29CBC
test rbx, rbx
jz short loc_29CB5
mov eax, [rsp+1028h+var_1008]
sub eax, dword ptr [rsp+1028h+var_1000]
mov [rbx], eax
loc_29CB5:
mov rax, [rsp+1028h+var_1000]
jmp short loc_29CC8
loc_29CBC:
mov rdi, [rsp+1028h+var_1000]
call _free
loc_29CC6:
xor eax, eax
loc_29CC8:
add rsp, 1008h
pop rbx
pop r14
pop r15
pop rbp
retn
| long long stbi_zlib_decode_malloc_guesssize(long long a1, int a2, unsigned int a3, _DWORD *a4)
{
long long v6; // rax
_QWORD v8[4]; // [rsp+0h] [rbp-1028h] BYREF
int v9; // [rsp+20h] [rbp-1008h]
long long v10; // [rsp+28h] [rbp-1000h]
v6 = malloc((int)a3);
if ( !v6 )
return 0LL;
v8[0] = a1;
v8[1] = a1 + a2;
if ( !(unsigned int)((long long ( *)(_QWORD *, long long, _QWORD, long long, long long))stbi__do_zlib)(
v8,
v6,
a3,
1LL,
1LL) )
{
free(v10);
return 0LL;
}
if ( a4 )
*a4 = v9 - v10;
return v10;
}
| stbi_zlib_decode_malloc_guesssize:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x1008
MOV RBX,RCX
MOV EBP,EDX
MOV R15D,ESI
MOV R14,RDI
MOVSXD RDI,EDX
CALL 0x0011e000
TEST RAX,RAX
JZ 0x00129cc6
MOV RDI,RSP
MOV qword ptr [RDI],R14
MOVSXD RCX,R15D
ADD RCX,R14
MOV qword ptr [RDI + 0x8],RCX
MOV RSI,RAX
MOV EDX,EBP
MOV ECX,0x1
MOV R8D,0x1
CALL 0x00129cd6
TEST EAX,EAX
JZ 0x00129cbc
TEST RBX,RBX
JZ 0x00129cb5
MOV EAX,dword ptr [RSP + 0x20]
SUB EAX,dword ptr [RSP + 0x28]
MOV dword ptr [RBX],EAX
LAB_00129cb5:
MOV RAX,qword ptr [RSP + 0x28]
JMP 0x00129cc8
LAB_00129cbc:
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0011de70
LAB_00129cc6:
XOR EAX,EAX
LAB_00129cc8:
ADD RSP,0x1008
POP RBX
POP R14
POP R15
POP RBP
RET
|
int8 stbi_zlib_decode_malloc_guesssize(long param_1,int param_2,int param_3,int *param_4)
{
int iVar1;
char *pcVar2;
long local_1028;
long local_1020;
int local_1008;
int local_1000;
int4 uStack_ffc;
pcVar2 = (char *)malloc((long)param_3);
if (pcVar2 != (char *)0x0) {
local_1020 = param_2 + param_1;
local_1028 = param_1;
iVar1 = stbi__do_zlib((stbi__zbuf *)&local_1028,pcVar2,param_3,1,1);
if (iVar1 != 0) {
if (param_4 != (int *)0x0) {
*param_4 = local_1008 - local_1000;
}
return CONCAT44(uStack_ffc,local_1000);
}
free((void *)CONCAT44(uStack_ffc,local_1000));
}
return 0;
}
| |
45,612 | stbi_zlib_decode_malloc_guesssize | monkey531[P]llama/examples/llava/../../common/stb_image.h | STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
{
stbi__zbuf a;
char *p = (char *) stbi__malloc(initial_size);
if (p == NULL) return NULL;
a.zbuffer = (stbi_uc *) buffer;
a.zbuffer_end = (stbi_uc *) buffer + len;
if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {
if (outlen) *outlen = (int) (a.zout - a.zout_start);
return a.zout_start;
} else {
STBI_FREE(a.zout_start);
return NULL;
}
} | O3 | c | stbi_zlib_decode_malloc_guesssize:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp # imm = 0x1008
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movslq %edx, %rdi
callq 0x1e010
testq %rax, %rax
je 0x29b80
movq %rsp, %rdi
movq %r14, (%rdi)
movslq %r15d, %rcx
addq %r14, %rcx
movq %rcx, 0x8(%rdi)
movq %rax, %rsi
movl %ebp, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x29b97
testl %eax, %eax
je 0x29b76
testq %rbx, %rbx
je 0x29b90
movl 0x20(%rsp), %ecx
movq 0x28(%rsp), %rax
subl %eax, %ecx
movl %ecx, (%rbx)
jmp 0x29b82
movq 0x28(%rsp), %rdi
callq 0x1de80
xorl %eax, %eax
addq $0x1008, %rsp # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%rsp), %rax
jmp 0x29b82
| stbi_zlib_decode_malloc_guesssize:
push rbp
push r15
push r14
push rbx
sub rsp, 1008h
mov rbx, rcx
mov ebp, edx
mov r15d, esi
mov r14, rdi
movsxd rdi, edx
call _malloc
test rax, rax
jz short loc_29B80
mov rdi, rsp
mov [rdi], r14
movsxd rcx, r15d
add rcx, r14
mov [rdi+8], rcx
mov rsi, rax
mov edx, ebp
mov ecx, 1
mov r8d, 1
call _ZL13stbi__do_zlibP10stbi__zbufPciii; stbi__do_zlib(stbi__zbuf *,char *,int,int,int)
test eax, eax
jz short loc_29B76
test rbx, rbx
jz short loc_29B90
mov ecx, [rsp+1028h+var_1008]
mov rax, [rsp+1028h+var_1000]
sub ecx, eax
mov [rbx], ecx
jmp short loc_29B82
loc_29B76:
mov rdi, [rsp+1028h+var_1000]
call _free
loc_29B80:
xor eax, eax
loc_29B82:
add rsp, 1008h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_29B90:
mov rax, [rsp+1028h+var_1000]
jmp short loc_29B82
| long long stbi_zlib_decode_malloc_guesssize(long long a1, int a2, unsigned int a3, _DWORD *a4)
{
long long v6; // rax
long long result; // rax
_QWORD v8[4]; // [rsp+0h] [rbp-1028h] BYREF
int v9; // [rsp+20h] [rbp-1008h]
long long v10; // [rsp+28h] [rbp-1000h]
v6 = malloc((int)a3);
if ( !v6 )
return 0LL;
v8[0] = a1;
v8[1] = a1 + a2;
if ( !(unsigned int)((long long ( *)(_QWORD *, long long, _QWORD, long long, long long))stbi__do_zlib)(
v8,
v6,
a3,
1LL,
1LL) )
{
free(v10);
return 0LL;
}
result = v10;
if ( a4 )
*a4 = v9 - v10;
return result;
}
| stbi_zlib_decode_malloc_guesssize:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x1008
MOV RBX,RCX
MOV EBP,EDX
MOV R15D,ESI
MOV R14,RDI
MOVSXD RDI,EDX
CALL 0x0011e010
TEST RAX,RAX
JZ 0x00129b80
MOV RDI,RSP
MOV qword ptr [RDI],R14
MOVSXD RCX,R15D
ADD RCX,R14
MOV qword ptr [RDI + 0x8],RCX
MOV RSI,RAX
MOV EDX,EBP
MOV ECX,0x1
MOV R8D,0x1
CALL 0x00129b97
TEST EAX,EAX
JZ 0x00129b76
TEST RBX,RBX
JZ 0x00129b90
MOV ECX,dword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x28]
SUB ECX,EAX
MOV dword ptr [RBX],ECX
JMP 0x00129b82
LAB_00129b76:
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0011de80
LAB_00129b80:
XOR EAX,EAX
LAB_00129b82:
ADD RSP,0x1008
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00129b90:
MOV RAX,qword ptr [RSP + 0x28]
JMP 0x00129b82
|
void * stbi_zlib_decode_malloc_guesssize(long param_1,int param_2,int param_3,int *param_4)
{
int iVar1;
char *pcVar2;
long local_1028;
long local_1020;
int local_1008;
void *local_1000;
pcVar2 = (char *)malloc((long)param_3);
if (pcVar2 != (char *)0x0) {
local_1020 = param_2 + param_1;
local_1028 = param_1;
iVar1 = stbi__do_zlib((stbi__zbuf *)&local_1028,pcVar2,param_3,1,1);
if (iVar1 != 0) {
if (param_4 == (int *)0x0) {
return local_1000;
}
*param_4 = local_1008 - (int)local_1000;
return local_1000;
}
free(local_1000);
}
return (void *)0x0;
}
| |
45,613 | crypto_sign_ed25519_ref10_ge_sub | eloqsql/plugin/auth_ed25519/ref10/ge_sub.c | void ge_sub(ge_p1p1 *r,const ge_p3 *p,const ge_cached *q)
{
fe t0;
#include "ge_sub.h"
} | O3 | c | crypto_sign_ed25519_ref10_ge_sub:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsi), %r12
movq %r12, %rsi
movq %r15, %rdx
callq 0x2100
leaq 0x28(%rbx), %r14
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2050
leaq 0x50(%rbx), %rdi
movq %rdi, -0x30(%rbp)
leaq 0x28(%r13), %rdx
movq %rbx, %rsi
callq 0x2140
movq %r14, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x2140
leaq 0x78(%rbx), %r12
leaq 0x78(%r13), %rsi
leaq 0x78(%r15), %rdx
movq %r12, %rdi
callq 0x2140
addq $0x50, %r15
addq $0x50, %r13
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x2140
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x2100
movq %rbx, %rdi
movq -0x30(%rbp), %rbx
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2050
movq %r14, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2100
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2050
movq %r12, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2100
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| crypto_sign_ed25519_ref10_ge_sub:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r13, rdx
mov r15, rsi
mov rbx, rdi
lea r12, [rsi+28h]
mov rsi, r12
mov rdx, r15
call _crypto_sign_ed25519_ref10_fe_add
lea r14, [rbx+28h]
mov rdi, r14
mov rsi, r12
mov rdx, r15
call _crypto_sign_ed25519_ref10_fe_sub
lea rdi, [rbx+50h]
mov [rbp+var_30], rdi
lea rdx, [r13+28h]
mov rsi, rbx
call _crypto_sign_ed25519_ref10_fe_mul
mov rdi, r14
mov rsi, r14
mov rdx, r13
call _crypto_sign_ed25519_ref10_fe_mul
lea r12, [rbx+78h]
lea rsi, [r13+78h]
lea rdx, [r15+78h]
mov rdi, r12
call _crypto_sign_ed25519_ref10_fe_mul
add r15, 50h ; 'P'
add r13, 50h ; 'P'
mov rdi, rbx
mov rsi, r15
mov rdx, r13
call _crypto_sign_ed25519_ref10_fe_mul
lea r15, [rbp+var_60]
mov rdi, r15
mov rsi, rbx
mov rdx, rbx
call _crypto_sign_ed25519_ref10_fe_add
mov rdi, rbx
mov rbx, [rbp+var_30]
mov rsi, rbx
mov rdx, r14
call _crypto_sign_ed25519_ref10_fe_sub
mov rdi, r14
mov rsi, rbx
mov rdx, r14
call _crypto_sign_ed25519_ref10_fe_add
mov rdi, rbx
mov rsi, r15
mov rdx, r12
call _crypto_sign_ed25519_ref10_fe_sub
mov rdi, r12
mov rsi, r15
mov rdx, r12
call _crypto_sign_ed25519_ref10_fe_add
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| void crypto_sign_ed25519_ref10_ge_sub(long long a1, long long a2, long long a3)
{
__m128i *v5; // rbx
__m128i v6[3]; // [rsp+0h] [rbp-60h] BYREF
__m128i *v7; // [rsp+30h] [rbp-30h]
crypto_sign_ed25519_ref10_fe_add((__m128i *)a1, (const __m128i *)(a2 + 40), (const __m128i *)a2);
crypto_sign_ed25519_ref10_fe_sub((__m128i *)(a1 + 40), (const __m128i *)(a2 + 40), (const __m128i *)a2);
v7 = (__m128i *)(a1 + 80);
crypto_sign_ed25519_ref10_fe_mul(a1 + 80, a1, a3 + 40);
crypto_sign_ed25519_ref10_fe_mul(a1 + 40, a1 + 40, a3);
crypto_sign_ed25519_ref10_fe_mul(a1 + 120, a3 + 120, a2 + 120);
crypto_sign_ed25519_ref10_fe_mul(a1, a2 + 80, a3 + 80);
crypto_sign_ed25519_ref10_fe_add(v6, (const __m128i *)a1, (const __m128i *)a1);
v5 = v7;
crypto_sign_ed25519_ref10_fe_sub((__m128i *)a1, v7, (const __m128i *)(a1 + 40));
crypto_sign_ed25519_ref10_fe_add((__m128i *)(a1 + 40), v5, (const __m128i *)(a1 + 40));
crypto_sign_ed25519_ref10_fe_sub(v5, v6, (const __m128i *)(a1 + 120));
crypto_sign_ed25519_ref10_fe_add((__m128i *)(a1 + 120), v6, (const __m128i *)(a1 + 120));
}
| crypto_sign_ed25519_ref10_ge_sub:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R13,RDX
MOV R15,RSI
MOV RBX,RDI
LEA R12,[RSI + 0x28]
MOV RSI,R12
MOV RDX,R15
CALL 0x00102100
LEA R14,[RBX + 0x28]
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
CALL 0x00102050
LEA RDI,[RBX + 0x50]
MOV qword ptr [RBP + -0x30],RDI
LEA RDX,[R13 + 0x28]
MOV RSI,RBX
CALL 0x00102140
MOV RDI,R14
MOV RSI,R14
MOV RDX,R13
CALL 0x00102140
LEA R12,[RBX + 0x78]
LEA RSI,[R13 + 0x78]
LEA RDX,[R15 + 0x78]
MOV RDI,R12
CALL 0x00102140
ADD R15,0x50
ADD R13,0x50
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R13
CALL 0x00102140
LEA R15,[RBP + -0x60]
MOV RDI,R15
MOV RSI,RBX
MOV RDX,RBX
CALL 0x00102100
MOV RDI,RBX
MOV RBX,qword ptr [RBP + -0x30]
MOV RSI,RBX
MOV RDX,R14
CALL 0x00102050
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R14
CALL 0x00102100
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R12
CALL 0x00102050
MOV RDI,R12
MOV RSI,R15
MOV RDX,R12
CALL 0x00102100
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void crypto_sign_ed25519_ref10_ge_sub(long param_1,long param_2,long param_3)
{
long lVar1;
long lVar2;
long lVar3;
int1 local_68 [48];
long local_38;
crypto_sign_ed25519_ref10_fe_add(param_1,param_2 + 0x28,param_2);
lVar1 = param_1 + 0x28;
crypto_sign_ed25519_ref10_fe_sub(lVar1,param_2 + 0x28,param_2);
local_38 = param_1 + 0x50;
crypto_sign_ed25519_ref10_fe_mul(local_38,param_1,param_3 + 0x28);
crypto_sign_ed25519_ref10_fe_mul(lVar1,lVar1,param_3);
lVar2 = param_1 + 0x78;
crypto_sign_ed25519_ref10_fe_mul(lVar2,param_3 + 0x78,param_2 + 0x78);
crypto_sign_ed25519_ref10_fe_mul(param_1,param_2 + 0x50,param_3 + 0x50);
crypto_sign_ed25519_ref10_fe_add(local_68,param_1,param_1);
lVar3 = local_38;
crypto_sign_ed25519_ref10_fe_sub(param_1,local_38,lVar1);
crypto_sign_ed25519_ref10_fe_add(lVar1,lVar3,lVar1);
crypto_sign_ed25519_ref10_fe_sub(lVar3,local_68,lVar2);
crypto_sign_ed25519_ref10_fe_add(lVar2,local_68,lVar2);
return;
}
| |
45,614 | translog_walk_filenames | eloqsql/storage/maria/ma_loghandler.c | my_bool translog_walk_filenames(const char *directory,
my_bool (*callback)(const char *,
const char *))
{
MY_DIR *dirp;
uint i;
my_bool rc= FALSE;
/* Finds and removes transaction log files */
if (!(dirp = my_dir(directory, MYF(MY_DONT_SORT))))
return FALSE;
for (i= 0; i < dirp->number_of_files; i++)
{
char *file= dirp->dir_entry[i].name;
if (strncmp(file, "aria_log.", 10) == 0 &&
file[10] >= '0' && file[10] <= '9' &&
file[11] >= '0' && file[11] <= '9' &&
file[12] >= '0' && file[12] <= '9' &&
file[13] >= '0' && file[13] <= '9' &&
file[14] >= '0' && file[14] <= '9' &&
file[15] >= '0' && file[15] <= '9' &&
file[16] >= '0' && file[16] <= '9' &&
file[17] >= '0' && file[17] <= '9' &&
file[18] == '\0' && (*callback)(directory, file))
{
rc= TRUE;
break;
}
}
my_dirend(dirp);
return rc;
} | O3 | c | translog_walk_filenames:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
xorl %esi, %esi
callq 0x9f8d5
testq %rax, %rax
je 0x3285d
movq %rax, %rbx
movl 0x8(%rax), %r12d
testl %r12d, %r12d
je 0x32852
movq %r15, -0x30(%rbp)
movq %r14, -0x38(%rbp)
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r14), %r13
movl $0xa, %edx
movq %r13, %rdi
leaq 0xa6bd4(%rip), %rsi # 0xd93a1
callq 0x291b0
testl %eax, %eax
jne 0x3283f
movb 0xa(%r13), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x3283f
movb 0xb(%r13), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x3283f
movb 0xc(%r13), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x3283f
movb 0xd(%r13), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x3283f
movb 0xe(%r13), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x3283f
movb 0xf(%r13), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x3283f
movb 0x10(%r13), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x3283f
movb 0x11(%r13), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x3283f
cmpb $0x0, 0x12(%r13)
jne 0x3283f
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq *-0x38(%rbp)
testb %al, %al
jne 0x3286f
movl 0x8(%rbx), %r12d
incq %r15
movl %r12d, %eax
addq $0x10, %r14
cmpq %rax, %r15
jb 0x327b7
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0x9f8a4
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %r12b
jmp 0x32855
| translog_walk_filenames:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14, rsi
mov r15, rdi
xor r12d, r12d
xor esi, esi
call my_dir
test rax, rax
jz loc_3285D
mov rbx, rax
mov r12d, [rax+8]
test r12d, r12d
jz loc_32852
mov [rbp+var_30], r15
mov [rbp+var_38], r14
xor r14d, r14d
xor r15d, r15d
loc_327B7:
mov rax, [rbx]
mov r13, [rax+r14]
mov edx, 0Ah
mov rdi, r13
lea rsi, aAriaLog; "aria_log."
call _strncmp
test eax, eax
jnz short loc_3283F
mov al, [r13+0Ah]
add al, 0D0h
cmp al, 9
ja short loc_3283F
mov al, [r13+0Bh]
add al, 0D0h
cmp al, 9
ja short loc_3283F
mov al, [r13+0Ch]
add al, 0D0h
cmp al, 9
ja short loc_3283F
mov al, [r13+0Dh]
add al, 0D0h
cmp al, 9
ja short loc_3283F
mov al, [r13+0Eh]
add al, 0D0h
cmp al, 9
ja short loc_3283F
mov al, [r13+0Fh]
add al, 0D0h
cmp al, 9
ja short loc_3283F
mov al, [r13+10h]
add al, 0D0h
cmp al, 9
ja short loc_3283F
mov al, [r13+11h]
add al, 0D0h
cmp al, 9
ja short loc_3283F
cmp byte ptr [r13+12h], 0
jnz short loc_3283F
mov rdi, [rbp+var_30]
mov rsi, r13
call [rbp+var_38]
test al, al
jnz short loc_3286F
mov r12d, [rbx+8]
loc_3283F:
inc r15
mov eax, r12d
add r14, 10h
cmp r15, rax
jb loc_327B7
loc_32852:
xor r12d, r12d
loc_32855:
mov rdi, rbx
call my_dirend
loc_3285D:
mov eax, r12d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3286F:
mov r12b, 1
jmp short loc_32855
| long long translog_walk_filenames(long long a1, unsigned __int8 ( *a2)(long long, _BYTE *))
{
unsigned int v2; // r12d
long long v3; // rax
long long v4; // rbx
long long v5; // r14
unsigned long long v6; // r15
_BYTE *v7; // r13
v2 = 0;
v3 = my_dir(a1, 0LL);
if ( !v3 )
return v2;
v4 = v3;
v2 = *(_DWORD *)(v3 + 8);
if ( !v2 )
{
LABEL_17:
v2 = 0;
goto LABEL_18;
}
v5 = 0LL;
v6 = 0LL;
while ( 1 )
{
v7 = *(_BYTE **)(*(_QWORD *)v4 + v5);
if ( (unsigned int)strncmp(v7, "aria_log.", 10LL)
|| (unsigned __int8)(v7[10] - 48) > 9u
|| (unsigned __int8)(v7[11] - 48) > 9u
|| (unsigned __int8)(v7[12] - 48) > 9u
|| (unsigned __int8)(v7[13] - 48) > 9u
|| (unsigned __int8)(v7[14] - 48) > 9u
|| (unsigned __int8)(v7[15] - 48) > 9u
|| (unsigned __int8)(v7[16] - 48) > 9u
|| (unsigned __int8)(v7[17] - 48) > 9u
|| v7[18] )
{
goto LABEL_16;
}
if ( a2(a1, v7) )
break;
v2 = *(_DWORD *)(v4 + 8);
LABEL_16:
++v6;
v5 += 16LL;
if ( v6 >= v2 )
goto LABEL_17;
}
LOBYTE(v2) = 1;
LABEL_18:
my_dirend(v4);
return v2;
}
| translog_walk_filenames:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R14,RSI
MOV R15,RDI
XOR R12D,R12D
XOR ESI,ESI
CALL 0x0019f8d5
TEST RAX,RAX
JZ 0x0013285d
MOV RBX,RAX
MOV R12D,dword ptr [RAX + 0x8]
TEST R12D,R12D
JZ 0x00132852
MOV qword ptr [RBP + -0x30],R15
MOV qword ptr [RBP + -0x38],R14
XOR R14D,R14D
XOR R15D,R15D
LAB_001327b7:
MOV RAX,qword ptr [RBX]
MOV R13,qword ptr [RAX + R14*0x1]
MOV EDX,0xa
MOV RDI,R13
LEA RSI,[0x1d93a1]
CALL 0x001291b0
TEST EAX,EAX
JNZ 0x0013283f
MOV AL,byte ptr [R13 + 0xa]
ADD AL,0xd0
CMP AL,0x9
JA 0x0013283f
MOV AL,byte ptr [R13 + 0xb]
ADD AL,0xd0
CMP AL,0x9
JA 0x0013283f
MOV AL,byte ptr [R13 + 0xc]
ADD AL,0xd0
CMP AL,0x9
JA 0x0013283f
MOV AL,byte ptr [R13 + 0xd]
ADD AL,0xd0
CMP AL,0x9
JA 0x0013283f
MOV AL,byte ptr [R13 + 0xe]
ADD AL,0xd0
CMP AL,0x9
JA 0x0013283f
MOV AL,byte ptr [R13 + 0xf]
ADD AL,0xd0
CMP AL,0x9
JA 0x0013283f
MOV AL,byte ptr [R13 + 0x10]
ADD AL,0xd0
CMP AL,0x9
JA 0x0013283f
MOV AL,byte ptr [R13 + 0x11]
ADD AL,0xd0
CMP AL,0x9
JA 0x0013283f
CMP byte ptr [R13 + 0x12],0x0
JNZ 0x0013283f
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,R13
CALL qword ptr [RBP + -0x38]
TEST AL,AL
JNZ 0x0013286f
MOV R12D,dword ptr [RBX + 0x8]
LAB_0013283f:
INC R15
MOV EAX,R12D
ADD R14,0x10
CMP R15,RAX
JC 0x001327b7
LAB_00132852:
XOR R12D,R12D
LAB_00132855:
MOV RDI,RBX
CALL 0x0019f8a4
LAB_0013285d:
MOV EAX,R12D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013286f:
MOV R12B,0x1
JMP 0x00132855
|
int8 translog_walk_filenames(int8 param_1,code *param_2)
{
char *__s1;
char cVar1;
int iVar2;
long *plVar3;
ulong uVar4;
int8 uVar5;
long lVar6;
ulong uVar7;
uVar5 = 0;
plVar3 = (long *)my_dir(param_1,0);
if (plVar3 != (long *)0x0) {
uVar4 = (ulong)*(uint *)(plVar3 + 1);
if (*(uint *)(plVar3 + 1) != 0) {
lVar6 = 0;
uVar7 = 0;
do {
__s1 = *(char **)(*plVar3 + lVar6);
iVar2 = strncmp(__s1,"aria_log.",10);
if ((((((iVar2 == 0) && ((byte)(__s1[10] - 0x30U) < 10)) && ((byte)(__s1[0xb] - 0x30U) < 10)
) && (((byte)(__s1[0xc] - 0x30U) < 10 && ((byte)(__s1[0xd] - 0x30U) < 10)))) &&
(((byte)(__s1[0xe] - 0x30U) < 10 &&
(((byte)(__s1[0xf] - 0x30U) < 10 && ((byte)(__s1[0x10] - 0x30U) < 10)))))) &&
(((byte)(__s1[0x11] - 0x30U) < 10 && (__s1[0x12] == '\0')))) {
cVar1 = (*param_2)(param_1,__s1);
if (cVar1 != '\0') {
uVar5 = CONCAT71((int7)(uVar4 >> 8),1);
goto LAB_00132855;
}
uVar4 = (ulong)*(uint *)(plVar3 + 1);
}
uVar7 = uVar7 + 1;
lVar6 = lVar6 + 0x10;
} while (uVar7 < uVar4);
}
uVar5 = 0;
LAB_00132855:
my_dirend(plVar3);
}
return uVar5;
}
| |
45,615 | ma_bitmap_get_page_bits | eloqsql/storage/maria/ma_bitmap.c | static uint bitmap_get_page_bits(MARIA_HA *info, MARIA_FILE_BITMAP *bitmap,
pgcache_page_no_t page)
{
pgcache_page_no_t bitmap_page;
uint offset_page, offset, tmp;
uchar *data;
DBUG_ENTER("_ma_bitmap_get_page_bits");
bitmap_page= page - page % bitmap->pages_covered;
if (bitmap_page != bitmap->page &&
_ma_change_bitmap_page(info, bitmap, bitmap_page))
DBUG_RETURN(~ (uint) 0);
/* Find page number from start of bitmap */
offset_page= (uint) (page - bitmap->page - 1);
/*
Mark place used by reading/writing 2 bytes at a time to handle
bitmaps in overlapping bytes
*/
offset_page*= 3;
offset= offset_page & 7;
data= bitmap->map + offset_page / 8;
tmp= uint2korr(data);
DBUG_RETURN((tmp >> offset) & 7);
} | O3 | c | ma_bitmap_get_page_bits:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0x88(%rsi), %rbx
cmpq $0x0, 0xc8(%rsi)
jne 0x4f89f
movq %rbx, %rdi
callq 0x291d0
movq %r15, %rax
xorl %edx, %edx
divq 0x138(%r14)
movq %rdx, %rax
movq %r15, %rdx
subq %rax, %rdx
cmpq 0x10(%r14), %rdx
je 0x4f85e
movq %r12, %rdi
movq %r14, %rsi
callq 0x4f491
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
testb %al, %al
jne 0x4f87f
movq 0x10(%r14), %rdx
notl %edx
addl %edx, %r15d
leal (%r15,%r15,2), %ecx
movq 0x8(%r14), %rax
movl %ecx, %edx
shrl $0x3, %edx
movzwl (%rax,%rdx), %r12d
andb $0x7, %cl
shrl %cl, %r12d
andl $0x7, %r12d
movq 0xc8(%r14), %rdi
testq %rdi, %rdi
jne 0x4f8b8
movq %rbx, %rdi
callq 0x291a0
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8ad0c(%rip), %rsi # 0xda5b2
movq %rbx, %rdi
movl $0x97b, %edx # imm = 0x97B
callq 0x2ee6f
jmp 0x4f82a
leaq 0x337791(%rip), %rax # 0x387050
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x4f88b
| _ma_bitmap_get_page_bits:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r15, rdx
mov r14, rsi
mov r12, rdi
lea rbx, [rsi+88h]
cmp qword ptr [rsi+0C8h], 0
jnz short loc_4F89F
mov rdi, rbx
call _pthread_mutex_lock
loc_4F82A:
mov rax, r15
xor edx, edx
div qword ptr [r14+138h]
mov rax, rdx
mov rdx, r15
sub rdx, rax
cmp rdx, [r14+10h]
jz short loc_4F85E
mov rdi, r12
mov rsi, r14
call _ma_change_bitmap_page
mov r12d, 0FFFFFFFFh
test al, al
jnz short loc_4F87F
mov rdx, [r14+10h]
loc_4F85E:
not edx
add r15d, edx
lea ecx, [r15+r15*2]
mov rax, [r14+8]
mov edx, ecx
shr edx, 3
movzx r12d, word ptr [rax+rdx]
and cl, 7
shr r12d, cl
and r12d, 7
loc_4F87F:
mov rdi, [r14+0C8h]
test rdi, rdi
jnz short loc_4F8B8
loc_4F88B:
mov rdi, rbx
call _pthread_mutex_unlock
mov eax, r12d
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_4F89F:
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rbx
mov edx, 97Bh
call psi_mutex_lock
jmp loc_4F82A
loc_4F8B8:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_4F88B
| long long ma_bitmap_get_page_bits(long long *a1, _QWORD *a2, unsigned long long a3)
{
long long v4; // rbx
unsigned long long v5; // rdx
unsigned int v6; // r12d
v4 = (long long)(a2 + 17);
if ( a2[25] )
psi_mutex_lock(v4, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c", 0x97Bu);
else
pthread_mutex_lock(a2 + 17);
v5 = a3 - a3 % a2[39];
if ( v5 != a2[2] )
{
v6 = -1;
if ( (unsigned __int8)ma_change_bitmap_page(a1, (long long)a2, v5) )
goto LABEL_7;
v5 = a2[2];
}
v6 = (*(unsigned __int16 *)(a2[1] + ((unsigned int)(3 * (~(_DWORD)v5 + a3)) >> 3)) >> ((3 * (~(_BYTE)v5 + a3)) & 7)) & 7;
LABEL_7:
if ( a2[25] )
PSI_server[44]();
pthread_mutex_unlock(v4);
return v6;
}
| _ma_bitmap_get_page_bits:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R15,RDX
MOV R14,RSI
MOV R12,RDI
LEA RBX,[RSI + 0x88]
CMP qword ptr [RSI + 0xc8],0x0
JNZ 0x0014f89f
MOV RDI,RBX
CALL 0x001291d0
LAB_0014f82a:
MOV RAX,R15
XOR EDX,EDX
DIV qword ptr [R14 + 0x138]
MOV RAX,RDX
MOV RDX,R15
SUB RDX,RAX
CMP RDX,qword ptr [R14 + 0x10]
JZ 0x0014f85e
MOV RDI,R12
MOV RSI,R14
CALL 0x0014f491
MOV R12D,0xffffffff
TEST AL,AL
JNZ 0x0014f87f
MOV RDX,qword ptr [R14 + 0x10]
LAB_0014f85e:
NOT EDX
ADD R15D,EDX
LEA ECX,[R15 + R15*0x2]
MOV RAX,qword ptr [R14 + 0x8]
MOV EDX,ECX
SHR EDX,0x3
MOVZX R12D,word ptr [RAX + RDX*0x1]
AND CL,0x7
SHR R12D,CL
AND R12D,0x7
LAB_0014f87f:
MOV RDI,qword ptr [R14 + 0xc8]
TEST RDI,RDI
JNZ 0x0014f8b8
LAB_0014f88b:
MOV RDI,RBX
CALL 0x001291a0
MOV EAX,R12D
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0014f89f:
LEA RSI,[0x1da5b2]
MOV RDI,RBX
MOV EDX,0x97b
CALL 0x0012ee6f
JMP 0x0014f82a
LAB_0014f8b8:
LEA RAX,[0x487050]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0014f88b
|
uint _ma_bitmap_get_page_bits(int8 param_1,long param_2,ulong param_3)
{
pthread_mutex_t *__mutex;
char cVar1;
long lVar2;
uint uVar3;
__mutex = (pthread_mutex_t *)(param_2 + 0x88);
if (*(long *)(param_2 + 200) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",
0x97b);
}
lVar2 = param_3 - param_3 % *(ulong *)(param_2 + 0x138);
if (lVar2 != *(long *)(param_2 + 0x10)) {
cVar1 = _ma_change_bitmap_page(param_1,param_2);
uVar3 = 0xffffffff;
if (cVar1 != '\0') goto LAB_0014f87f;
lVar2 = *(long *)(param_2 + 0x10);
}
uVar3 = ((int)param_3 + ~(uint)lVar2) * 3;
uVar3 = *(ushort *)(*(long *)(param_2 + 8) + (ulong)(uVar3 >> 3)) >> ((byte)uVar3 & 7) & 7;
LAB_0014f87f:
if (*(long *)(param_2 + 200) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
return uVar3;
}
| |
45,616 | my_strnncoll_win1250ch | eloqsql/strings/ctype-win1250ch.c | static int my_strnncoll_win1250ch(CHARSET_INFO *cs __attribute__((unused)),
const uchar *s1, size_t len1,
const uchar *s2, size_t len2,
my_bool s2_is_prefix)
{
int v1, v2;
const uchar *p1, * p2;
int pass1 = 0, pass2 = 0;
int diff;
if (s2_is_prefix && len1 > len2)
len1=len2;
p1 = s1; p2 = s2;
do
{
NEXT_CMP_VALUE(s1, p1, pass1, v1, (int)len1);
NEXT_CMP_VALUE(s2, p2, pass2, v2, (int)len2);
if ((diff = v1 - v2))
return diff;
} while (v1);
return 0;
} | O0 | c | my_strnncoll_win1250ch:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %r9b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movb %al, -0x31(%rbp)
movl $0x0, -0x54(%rbp)
movl $0x0, -0x58(%rbp)
movsbl -0x31(%rbp), %eax
cmpl $0x0, %eax
je 0x7bc4b
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x7bc4b
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x7bc5d
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq -0x20(%rbp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jl 0x7bca4
cmpl $0x0, -0x54(%rbp)
jne 0x7bc96
movq -0x20(%rbp), %rax
cmpl $0x0, %eax
jle 0x7bc96
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x7bca2
movl $0x0, -0x38(%rbp)
jmp 0x7be18
jmp 0x7bca4
cmpl $0x0, -0x54(%rbp)
jne 0x7bcc6
movq -0x48(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x14db46(%rip), %rax # 0x1c9800
movzbl (%rax,%rcx), %eax
movl %eax, -0x8c(%rbp)
jmp 0x7bce0
movq -0x48(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x31e8ea(%rip), %rax # 0x39a5c0
movzbl (%rax,%rcx), %eax
movl %eax, -0x8c(%rbp)
movl -0x8c(%rbp), %eax
movl %eax, -0x38(%rbp)
cmpl $0xff, -0x38(%rbp)
jne 0x7be0c
movl $0x0, -0x60(%rbp)
cmpl $0x50, -0x60(%rbp)
jge 0x7be0a
movslq -0x60(%rbp), %rcx
leaq 0x1667fe(%rip), %rax # 0x1e2510
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x8d(%rbp)
je 0x7bd74
movq -0x70(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rax, %rcx
movq -0x20(%rbp), %rax
movslq %eax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x8d(%rbp)
jge 0x7bd74
movq -0x68(%rbp), %rax
movzbl (%rax), %eax
movq -0x70(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x8d(%rbp)
movb -0x8d(%rbp), %al
testb $0x1, %al
jne 0x7bd80
jmp 0x7bd9a
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0x7bd28
movq -0x68(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x7bdfa
cmpl $0x0, -0x54(%rbp)
jne 0x7bdc7
movslq -0x60(%rbp), %rcx
leaq 0x16675c(%rip), %rax # 0x1e2510
shlq $0x4, %rcx
addq %rcx, %rax
movzbl 0x8(%rax), %eax
movl %eax, -0x94(%rbp)
jmp 0x7bde3
movslq -0x60(%rbp), %rcx
leaq 0x16673e(%rip), %rax # 0x1e2510
shlq $0x4, %rcx
addq %rcx, %rax
movzbl 0x9(%rax), %eax
movl %eax, -0x94(%rbp)
movl -0x94(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x70(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x7be0a
jmp 0x7bdfc
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x7bcfd
jmp 0x7be0c
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x7be1a
movq -0x50(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq -0x30(%rbp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jl 0x7be61
cmpl $0x0, -0x58(%rbp)
jne 0x7be53
movq -0x30(%rbp), %rax
cmpl $0x0, %eax
jle 0x7be53
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x7be5f
movl $0x0, -0x3c(%rbp)
jmp 0x7bfe7
jmp 0x7be61
cmpl $0x0, -0x58(%rbp)
jne 0x7be83
movq -0x50(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x14d989(%rip), %rax # 0x1c9800
movzbl (%rax,%rcx), %eax
movl %eax, -0x98(%rbp)
jmp 0x7be9d
movq -0x50(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x31e72d(%rip), %rax # 0x39a5c0
movzbl (%rax,%rcx), %eax
movl %eax, -0x98(%rbp)
movl -0x98(%rbp), %eax
movl %eax, -0x3c(%rbp)
cmpl $0xff, -0x3c(%rbp)
jne 0x7bfdb
movl $0x0, -0x74(%rbp)
cmpl $0x50, -0x74(%rbp)
jge 0x7bfd9
movslq -0x74(%rbp), %rcx
leaq 0x166641(%rip), %rax # 0x1e2510
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x99(%rbp)
je 0x7bf3a
movq -0x88(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rax, %rcx
movq -0x30(%rbp), %rax
movslq %eax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x99(%rbp)
jge 0x7bf3a
movq -0x80(%rbp), %rax
movzbl (%rax), %eax
movq -0x88(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x99(%rbp)
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x7bf46
jmp 0x7bf66
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
movq -0x88(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
jmp 0x7bee8
movq -0x80(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x7bfc9
cmpl $0x0, -0x58(%rbp)
jne 0x7bf93
movslq -0x74(%rbp), %rcx
leaq 0x166590(%rip), %rax # 0x1e2510
shlq $0x4, %rcx
addq %rcx, %rax
movzbl 0x8(%rax), %eax
movl %eax, -0xa0(%rbp)
jmp 0x7bfaf
movslq -0x74(%rbp), %rcx
leaq 0x166572(%rip), %rax # 0x1e2510
shlq $0x4, %rcx
addq %rcx, %rax
movzbl 0x9(%rax), %eax
movl %eax, -0xa0(%rbp)
movl -0xa0(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x88(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x7bfd9
jmp 0x7bfcb
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x7beba
jmp 0x7bfdb
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
movl -0x38(%rbp), %eax
subl -0x3c(%rbp), %eax
movl %eax, -0x5c(%rbp)
cmpl $0x0, %eax
je 0x7bffd
movl -0x5c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7c010
jmp 0x7bfff
cmpl $0x0, -0x38(%rbp)
jne 0x7bc5b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| my_strnncoll_win1250ch:
push rbp
mov rbp, rsp
sub rsp, 20h
mov al, r9b
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_31], al
mov [rbp+var_54], 0
mov [rbp+var_58], 0
movsx eax, [rbp+var_31]
cmp eax, 0
jz short loc_7BC4B
mov rax, [rbp+var_20]
cmp rax, [rbp+var_30]
jbe short loc_7BC4B
mov rax, [rbp+var_30]
mov [rbp+var_20], rax
loc_7BC4B:
mov rax, [rbp+var_18]
mov [rbp+var_48], rax
mov rax, [rbp+var_28]
mov [rbp+var_50], rax
loc_7BC5B:
jmp short $+2
loc_7BC5D:
mov rax, [rbp+var_48]
mov rcx, [rbp+var_18]
sub rax, rcx
mov rcx, [rbp+var_20]
movsxd rcx, ecx
cmp rax, rcx
jl short loc_7BCA4
cmp [rbp+var_54], 0
jnz short loc_7BC96
mov rax, [rbp+var_20]
cmp eax, 0
jle short loc_7BC96
mov rax, [rbp+var_18]
mov [rbp+var_48], rax
mov eax, [rbp+var_54]
add eax, 1
mov [rbp+var_54], eax
jmp short loc_7BCA2
loc_7BC96:
mov [rbp+var_38], 0
jmp loc_7BE18
loc_7BCA2:
jmp short $+2
loc_7BCA4:
cmp [rbp+var_54], 0
jnz short loc_7BCC6
mov rax, [rbp+var_48]
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, _sort_order_win1250ch1
movzx eax, byte ptr [rax+rcx]
mov [rbp+var_8C], eax
jmp short loc_7BCE0
loc_7BCC6:
mov rax, [rbp+var_48]
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, _sort_order_win1250ch2
movzx eax, byte ptr [rax+rcx]
mov [rbp+var_8C], eax
loc_7BCE0:
mov eax, [rbp+var_8C]
mov [rbp+var_38], eax
cmp [rbp+var_38], 0FFh
jnz loc_7BE0C
mov [rbp+var_60], 0
loc_7BCFD:
cmp [rbp+var_60], 50h ; 'P'
jge loc_7BE0A
movsxd rcx, [rbp+var_60]
lea rax, doubles_0
shl rcx, 4
add rax, rcx
mov rax, [rax]
mov [rbp+var_68], rax
mov rax, [rbp+var_48]
mov [rbp+var_70], rax
loc_7BD28:
mov rax, [rbp+var_68]
movzx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, 0
mov [rbp+var_8D], al
jz short loc_7BD74
mov rcx, [rbp+var_70]
mov rax, [rbp+var_18]
sub rcx, rax
mov rax, [rbp+var_20]
movsxd rdx, eax
xor eax, eax
cmp rcx, rdx
mov [rbp+var_8D], al
jge short loc_7BD74
mov rax, [rbp+var_68]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_70]
movzx ecx, byte ptr [rcx]
cmp eax, ecx
setz al
mov [rbp+var_8D], al
loc_7BD74:
mov al, [rbp+var_8D]
test al, 1
jnz short loc_7BD80
jmp short loc_7BD9A
loc_7BD80:
mov rax, [rbp+var_68]
add rax, 1
mov [rbp+var_68], rax
mov rax, [rbp+var_70]
add rax, 1
mov [rbp+var_70], rax
jmp short loc_7BD28
loc_7BD9A:
mov rax, [rbp+var_68]
cmp byte ptr [rax], 0
jnz short loc_7BDFA
cmp [rbp+var_54], 0
jnz short loc_7BDC7
movsxd rcx, [rbp+var_60]
lea rax, doubles_0
shl rcx, 4
add rax, rcx
movzx eax, byte ptr [rax+8]
mov [rbp+var_94], eax
jmp short loc_7BDE3
loc_7BDC7:
movsxd rcx, [rbp+var_60]
lea rax, doubles_0
shl rcx, 4
add rax, rcx
movzx eax, byte ptr [rax+9]
mov [rbp+var_94], eax
loc_7BDE3:
mov eax, [rbp+var_94]
mov [rbp+var_38], eax
mov rax, [rbp+var_70]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_48], rax
jmp short loc_7BE0A
loc_7BDFA:
jmp short $+2
loc_7BDFC:
mov eax, [rbp+var_60]
add eax, 1
mov [rbp+var_60], eax
jmp loc_7BCFD
loc_7BE0A:
jmp short $+2
loc_7BE0C:
mov rax, [rbp+var_48]
add rax, 1
mov [rbp+var_48], rax
loc_7BE18:
jmp short $+2
loc_7BE1A:
mov rax, [rbp+var_50]
mov rcx, [rbp+var_28]
sub rax, rcx
mov rcx, [rbp+var_30]
movsxd rcx, ecx
cmp rax, rcx
jl short loc_7BE61
cmp [rbp+var_58], 0
jnz short loc_7BE53
mov rax, [rbp+var_30]
cmp eax, 0
jle short loc_7BE53
mov rax, [rbp+var_28]
mov [rbp+var_50], rax
mov eax, [rbp+var_58]
add eax, 1
mov [rbp+var_58], eax
jmp short loc_7BE5F
loc_7BE53:
mov [rbp+var_3C], 0
jmp loc_7BFE7
loc_7BE5F:
jmp short $+2
loc_7BE61:
cmp [rbp+var_58], 0
jnz short loc_7BE83
mov rax, [rbp+var_50]
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, _sort_order_win1250ch1
movzx eax, byte ptr [rax+rcx]
mov [rbp+var_98], eax
jmp short loc_7BE9D
loc_7BE83:
mov rax, [rbp+var_50]
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, _sort_order_win1250ch2
movzx eax, byte ptr [rax+rcx]
mov [rbp+var_98], eax
loc_7BE9D:
mov eax, [rbp+var_98]
mov [rbp+var_3C], eax
cmp [rbp+var_3C], 0FFh
jnz loc_7BFDB
mov [rbp+var_74], 0
loc_7BEBA:
cmp [rbp+var_74], 50h ; 'P'
jge loc_7BFD9
movsxd rcx, [rbp+var_74]
lea rax, doubles_0
shl rcx, 4
add rax, rcx
mov rax, [rax]
mov [rbp+var_80], rax
mov rax, [rbp+var_50]
mov [rbp+var_88], rax
loc_7BEE8:
mov rax, [rbp+var_80]
movzx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, 0
mov [rbp+var_99], al
jz short loc_7BF3A
mov rcx, [rbp+var_88]
mov rax, [rbp+var_28]
sub rcx, rax
mov rax, [rbp+var_30]
movsxd rdx, eax
xor eax, eax
cmp rcx, rdx
mov [rbp+var_99], al
jge short loc_7BF3A
mov rax, [rbp+var_80]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_88]
movzx ecx, byte ptr [rcx]
cmp eax, ecx
setz al
mov [rbp+var_99], al
loc_7BF3A:
mov al, [rbp+var_99]
test al, 1
jnz short loc_7BF46
jmp short loc_7BF66
loc_7BF46:
mov rax, [rbp+var_80]
add rax, 1
mov [rbp+var_80], rax
mov rax, [rbp+var_88]
add rax, 1
mov [rbp+var_88], rax
jmp short loc_7BEE8
loc_7BF66:
mov rax, [rbp+var_80]
cmp byte ptr [rax], 0
jnz short loc_7BFC9
cmp [rbp+var_58], 0
jnz short loc_7BF93
movsxd rcx, [rbp+var_74]
lea rax, doubles_0
shl rcx, 4
add rax, rcx
movzx eax, byte ptr [rax+8]
mov [rbp+var_A0], eax
jmp short loc_7BFAF
loc_7BF93:
movsxd rcx, [rbp+var_74]
lea rax, doubles_0
shl rcx, 4
add rax, rcx
movzx eax, byte ptr [rax+9]
mov [rbp+var_A0], eax
loc_7BFAF:
mov eax, [rbp+var_A0]
mov [rbp+var_3C], eax
mov rax, [rbp+var_88]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_50], rax
jmp short loc_7BFD9
loc_7BFC9:
jmp short $+2
loc_7BFCB:
mov eax, [rbp+var_74]
add eax, 1
mov [rbp+var_74], eax
jmp loc_7BEBA
loc_7BFD9:
jmp short $+2
loc_7BFDB:
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_50], rax
loc_7BFE7:
mov eax, [rbp+var_38]
sub eax, [rbp+var_3C]
mov [rbp+var_5C], eax
cmp eax, 0
jz short loc_7BFFD
mov eax, [rbp+var_5C]
mov [rbp+var_4], eax
jmp short loc_7C010
loc_7BFFD:
jmp short $+2
loc_7BFFF:
cmp [rbp+var_38], 0
jnz loc_7BC5B
mov [rbp+var_4], 0
loc_7C010:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long my_strnncoll_win1250ch(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned __int8 *a4,
unsigned long long a5,
char a6)
{
int v7; // [rsp+0h] [rbp-A0h]
bool v8; // [rsp+7h] [rbp-99h]
int v9; // [rsp+8h] [rbp-98h]
int v10; // [rsp+Ch] [rbp-94h]
bool v11; // [rsp+13h] [rbp-8Dh]
int v12; // [rsp+14h] [rbp-8Ch]
unsigned __int8 *m; // [rsp+18h] [rbp-88h]
_BYTE *v14; // [rsp+20h] [rbp-80h]
int k; // [rsp+2Ch] [rbp-74h]
unsigned __int8 *j; // [rsp+30h] [rbp-70h]
_BYTE *v17; // [rsp+38h] [rbp-68h]
int i; // [rsp+40h] [rbp-60h]
int v19; // [rsp+48h] [rbp-58h]
int v20; // [rsp+4Ch] [rbp-54h]
unsigned __int8 *v21; // [rsp+50h] [rbp-50h]
unsigned __int8 *v22; // [rsp+58h] [rbp-48h]
int v23; // [rsp+64h] [rbp-3Ch]
int v24; // [rsp+68h] [rbp-38h]
int v25; // [rsp+80h] [rbp-20h]
v25 = a3;
v20 = 0;
v19 = 0;
if ( a6 && a3 > a5 )
v25 = a5;
v22 = a2;
v21 = a4;
do
{
if ( v22 - a2 >= v25 )
{
if ( v20 || v25 <= 0 )
{
v24 = 0;
goto LABEL_29;
}
v22 = a2;
v20 = 1;
}
if ( v20 )
v12 = sort_order_win1250ch2[*v22];
else
v12 = sort_order_win1250ch1[*v22];
v24 = v12;
if ( v12 == 255 )
{
for ( i = 0; i < 80; ++i )
{
v17 = *(&doubles_0 + 2 * i);
for ( j = v22; ; ++j )
{
v11 = 0;
if ( *v17 )
{
v11 = 0;
if ( j - a2 < v25 )
v11 = (unsigned __int8)*v17 == *j;
}
if ( !v11 )
break;
++v17;
}
if ( !*v17 )
{
if ( v20 )
v10 = *((unsigned __int8 *)&doubles_0 + 16 * i + 9);
else
v10 = *((unsigned __int8 *)&doubles_0 + 16 * i + 8);
v24 = v10;
v22 = j - 1;
break;
}
}
}
++v22;
LABEL_29:
if ( v21 - a4 >= (int)a5 )
{
if ( v19 || (int)a5 <= 0 )
{
v23 = 0;
goto LABEL_53;
}
v21 = a4;
v19 = 1;
}
if ( v19 )
v9 = sort_order_win1250ch2[*v21];
else
v9 = sort_order_win1250ch1[*v21];
v23 = v9;
if ( v9 == 255 )
{
for ( k = 0; k < 80; ++k )
{
v14 = *(&doubles_0 + 2 * k);
for ( m = v21; ; ++m )
{
v8 = 0;
if ( *v14 )
{
v8 = 0;
if ( m - a4 < (int)a5 )
v8 = (unsigned __int8)*v14 == *m;
}
if ( !v8 )
break;
++v14;
}
if ( !*v14 )
{
if ( v19 )
v7 = *((unsigned __int8 *)&doubles_0 + 16 * k + 9);
else
v7 = *((unsigned __int8 *)&doubles_0 + 16 * k + 8);
v23 = v7;
v21 = m - 1;
break;
}
}
}
++v21;
LABEL_53:
if ( v24 != v23 )
return (unsigned int)(v24 - v23);
}
while ( v24 );
return 0;
}
| my_strnncoll_win1250ch:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV AL,R9B
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV byte ptr [RBP + -0x31],AL
MOV dword ptr [RBP + -0x54],0x0
MOV dword ptr [RBP + -0x58],0x0
MOVSX EAX,byte ptr [RBP + -0x31]
CMP EAX,0x0
JZ 0x0017bc4b
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x30]
JBE 0x0017bc4b
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x20],RAX
LAB_0017bc4b:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x50],RAX
LAB_0017bc5b:
JMP 0x0017bc5d
LAB_0017bc5d:
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,RCX
MOV RCX,qword ptr [RBP + -0x20]
MOVSXD RCX,ECX
CMP RAX,RCX
JL 0x0017bca4
CMP dword ptr [RBP + -0x54],0x0
JNZ 0x0017bc96
MOV RAX,qword ptr [RBP + -0x20]
CMP EAX,0x0
JLE 0x0017bc96
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x48],RAX
MOV EAX,dword ptr [RBP + -0x54]
ADD EAX,0x1
MOV dword ptr [RBP + -0x54],EAX
JMP 0x0017bca2
LAB_0017bc96:
MOV dword ptr [RBP + -0x38],0x0
JMP 0x0017be18
LAB_0017bca2:
JMP 0x0017bca4
LAB_0017bca4:
CMP dword ptr [RBP + -0x54],0x0
JNZ 0x0017bcc6
MOV RAX,qword ptr [RBP + -0x48]
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x2c9800]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RBP + -0x8c],EAX
JMP 0x0017bce0
LAB_0017bcc6:
MOV RAX,qword ptr [RBP + -0x48]
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x49a5c0]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RBP + -0x8c],EAX
LAB_0017bce0:
MOV EAX,dword ptr [RBP + -0x8c]
MOV dword ptr [RBP + -0x38],EAX
CMP dword ptr [RBP + -0x38],0xff
JNZ 0x0017be0c
MOV dword ptr [RBP + -0x60],0x0
LAB_0017bcfd:
CMP dword ptr [RBP + -0x60],0x50
JGE 0x0017be0a
MOVSXD RCX,dword ptr [RBP + -0x60]
LEA RAX,[0x2e2510]
SHL RCX,0x4
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x70],RAX
LAB_0017bd28:
MOV RAX,qword ptr [RBP + -0x68]
MOVZX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x8d],AL
JZ 0x0017bd74
MOV RCX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x18]
SUB RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RDX,EAX
XOR EAX,EAX
CMP RCX,RDX
MOV byte ptr [RBP + -0x8d],AL
JGE 0x0017bd74
MOV RAX,qword ptr [RBP + -0x68]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x70]
MOVZX ECX,byte ptr [RCX]
CMP EAX,ECX
SETZ AL
MOV byte ptr [RBP + -0x8d],AL
LAB_0017bd74:
MOV AL,byte ptr [RBP + -0x8d]
TEST AL,0x1
JNZ 0x0017bd80
JMP 0x0017bd9a
LAB_0017bd80:
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,0x1
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x70]
ADD RAX,0x1
MOV qword ptr [RBP + -0x70],RAX
JMP 0x0017bd28
LAB_0017bd9a:
MOV RAX,qword ptr [RBP + -0x68]
CMP byte ptr [RAX],0x0
JNZ 0x0017bdfa
CMP dword ptr [RBP + -0x54],0x0
JNZ 0x0017bdc7
MOVSXD RCX,dword ptr [RBP + -0x60]
LEA RAX,[0x2e2510]
SHL RCX,0x4
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x94],EAX
JMP 0x0017bde3
LAB_0017bdc7:
MOVSXD RCX,dword ptr [RBP + -0x60]
LEA RAX,[0x2e2510]
SHL RCX,0x4
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX + 0x9]
MOV dword ptr [RBP + -0x94],EAX
LAB_0017bde3:
MOV EAX,dword ptr [RBP + -0x94]
MOV dword ptr [RBP + -0x38],EAX
MOV RAX,qword ptr [RBP + -0x70]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x48],RAX
JMP 0x0017be0a
LAB_0017bdfa:
JMP 0x0017bdfc
LAB_0017bdfc:
MOV EAX,dword ptr [RBP + -0x60]
ADD EAX,0x1
MOV dword ptr [RBP + -0x60],EAX
JMP 0x0017bcfd
LAB_0017be0a:
JMP 0x0017be0c
LAB_0017be0c:
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,0x1
MOV qword ptr [RBP + -0x48],RAX
LAB_0017be18:
JMP 0x0017be1a
LAB_0017be1a:
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV RCX,qword ptr [RBP + -0x30]
MOVSXD RCX,ECX
CMP RAX,RCX
JL 0x0017be61
CMP dword ptr [RBP + -0x58],0x0
JNZ 0x0017be53
MOV RAX,qword ptr [RBP + -0x30]
CMP EAX,0x0
JLE 0x0017be53
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x50],RAX
MOV EAX,dword ptr [RBP + -0x58]
ADD EAX,0x1
MOV dword ptr [RBP + -0x58],EAX
JMP 0x0017be5f
LAB_0017be53:
MOV dword ptr [RBP + -0x3c],0x0
JMP 0x0017bfe7
LAB_0017be5f:
JMP 0x0017be61
LAB_0017be61:
CMP dword ptr [RBP + -0x58],0x0
JNZ 0x0017be83
MOV RAX,qword ptr [RBP + -0x50]
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x2c9800]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RBP + -0x98],EAX
JMP 0x0017be9d
LAB_0017be83:
MOV RAX,qword ptr [RBP + -0x50]
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x49a5c0]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RBP + -0x98],EAX
LAB_0017be9d:
MOV EAX,dword ptr [RBP + -0x98]
MOV dword ptr [RBP + -0x3c],EAX
CMP dword ptr [RBP + -0x3c],0xff
JNZ 0x0017bfdb
MOV dword ptr [RBP + -0x74],0x0
LAB_0017beba:
CMP dword ptr [RBP + -0x74],0x50
JGE 0x0017bfd9
MOVSXD RCX,dword ptr [RBP + -0x74]
LEA RAX,[0x2e2510]
SHL RCX,0x4
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x88],RAX
LAB_0017bee8:
MOV RAX,qword ptr [RBP + -0x80]
MOVZX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x99],AL
JZ 0x0017bf3a
MOV RCX,qword ptr [RBP + -0x88]
MOV RAX,qword ptr [RBP + -0x28]
SUB RCX,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVSXD RDX,EAX
XOR EAX,EAX
CMP RCX,RDX
MOV byte ptr [RBP + -0x99],AL
JGE 0x0017bf3a
MOV RAX,qword ptr [RBP + -0x80]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x88]
MOVZX ECX,byte ptr [RCX]
CMP EAX,ECX
SETZ AL
MOV byte ptr [RBP + -0x99],AL
LAB_0017bf3a:
MOV AL,byte ptr [RBP + -0x99]
TEST AL,0x1
JNZ 0x0017bf46
JMP 0x0017bf66
LAB_0017bf46:
MOV RAX,qword ptr [RBP + -0x80]
ADD RAX,0x1
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x88]
ADD RAX,0x1
MOV qword ptr [RBP + -0x88],RAX
JMP 0x0017bee8
LAB_0017bf66:
MOV RAX,qword ptr [RBP + -0x80]
CMP byte ptr [RAX],0x0
JNZ 0x0017bfc9
CMP dword ptr [RBP + -0x58],0x0
JNZ 0x0017bf93
MOVSXD RCX,dword ptr [RBP + -0x74]
LEA RAX,[0x2e2510]
SHL RCX,0x4
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX + 0x8]
MOV dword ptr [RBP + -0xa0],EAX
JMP 0x0017bfaf
LAB_0017bf93:
MOVSXD RCX,dword ptr [RBP + -0x74]
LEA RAX,[0x2e2510]
SHL RCX,0x4
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX + 0x9]
MOV dword ptr [RBP + -0xa0],EAX
LAB_0017bfaf:
MOV EAX,dword ptr [RBP + -0xa0]
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x88]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x50],RAX
JMP 0x0017bfd9
LAB_0017bfc9:
JMP 0x0017bfcb
LAB_0017bfcb:
MOV EAX,dword ptr [RBP + -0x74]
ADD EAX,0x1
MOV dword ptr [RBP + -0x74],EAX
JMP 0x0017beba
LAB_0017bfd9:
JMP 0x0017bfdb
LAB_0017bfdb:
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
LAB_0017bfe7:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x5c],EAX
CMP EAX,0x0
JZ 0x0017bffd
MOV EAX,dword ptr [RBP + -0x5c]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0017c010
LAB_0017bffd:
JMP 0x0017bfff
LAB_0017bfff:
CMP dword ptr [RBP + -0x38],0x0
JNZ 0x0017bc5b
MOV dword ptr [RBP + -0x4],0x0
LAB_0017c010:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int my_strnncoll_win1250ch
(int8 param_1,byte *param_2,ulong param_3,byte *param_4,ulong param_5,
char param_6)
{
byte bVar1;
bool bVar2;
bool bVar3;
int iVar4;
bool bVar5;
uint local_a8;
uint local_a0;
uint local_9c;
uint local_94;
byte *local_90;
byte *local_88;
int local_7c;
byte *local_78;
byte *local_70;
int local_68;
byte *local_58;
byte *local_50;
uint local_44;
uint local_40;
ulong local_28;
bVar2 = false;
bVar3 = false;
local_58 = param_4;
local_50 = param_2;
local_28 = param_3;
if ((param_6 != '\0') && (param_5 < param_3)) {
local_28 = param_5;
}
do {
iVar4 = (int)local_28;
if ((long)local_50 - (long)param_2 < (long)iVar4) {
LAB_0017bca4:
if (bVar2) {
bVar1 = _sort_order_win1250ch2[*local_50];
}
else {
bVar1 = _sort_order_win1250ch1[*local_50];
}
local_94 = (uint)bVar1;
local_40 = local_94;
if (local_94 == 0xff) {
for (local_68 = 0; local_68 < 0x50; local_68 = local_68 + 1) {
local_70 = *(byte **)(doubles + (long)local_68 * 0x10);
local_78 = local_50;
while( true ) {
bVar5 = false;
if ((*local_70 != 0) && (bVar5 = false, (long)local_78 - (long)param_2 < (long)iVar4)) {
bVar5 = *local_70 == *local_78;
}
if (!bVar5) break;
local_70 = local_70 + 1;
local_78 = local_78 + 1;
}
if (*local_70 == 0) {
if (bVar2) {
bVar1 = doubles[(long)local_68 * 0x10 + 9];
}
else {
bVar1 = doubles[(long)local_68 * 0x10 + 8];
}
local_9c = (uint)bVar1;
local_40 = local_9c;
local_50 = local_78 + -1;
break;
}
}
}
local_50 = local_50 + 1;
}
else {
if ((!bVar2) && (0 < iVar4)) {
bVar2 = true;
local_50 = param_2;
goto LAB_0017bca4;
}
local_40 = 0;
}
iVar4 = (int)param_5;
if ((long)local_58 - (long)param_4 < (long)iVar4) {
LAB_0017be61:
if (bVar3) {
bVar1 = _sort_order_win1250ch2[*local_58];
}
else {
bVar1 = _sort_order_win1250ch1[*local_58];
}
local_a0 = (uint)bVar1;
local_44 = local_a0;
if (local_a0 == 0xff) {
for (local_7c = 0; local_7c < 0x50; local_7c = local_7c + 1) {
local_88 = *(byte **)(doubles + (long)local_7c * 0x10);
local_90 = local_58;
while( true ) {
bVar5 = false;
if ((*local_88 != 0) && (bVar5 = false, (long)local_90 - (long)param_4 < (long)iVar4)) {
bVar5 = *local_88 == *local_90;
}
if (!bVar5) break;
local_88 = local_88 + 1;
local_90 = local_90 + 1;
}
if (*local_88 == 0) {
if (bVar3) {
bVar1 = doubles[(long)local_7c * 0x10 + 9];
}
else {
bVar1 = doubles[(long)local_7c * 0x10 + 8];
}
local_a8 = (uint)bVar1;
local_44 = local_a8;
local_58 = local_90 + -1;
break;
}
}
}
local_58 = local_58 + 1;
}
else {
if ((!bVar3) && (0 < iVar4)) {
bVar3 = true;
local_58 = param_4;
goto LAB_0017be61;
}
local_44 = 0;
}
if (local_40 - local_44 != 0) {
return local_40 - local_44;
}
if (local_40 == 0) {
return 0;
}
} while( true );
}
| |
45,617 | testing::internal::RE::Init(char const*) | giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest-port.cc | void RE::Init(const char* regex) {
pattern_ = regex;
// NetBSD (and Android, which takes its regex implemntation from NetBSD) does
// not include the GNU regex extensions (such as Perl style character classes
// like \w) in REG_EXTENDED. REG_EXTENDED is only specified to include the
// [[:alpha:]] style character classes. Enable REG_GNU wherever it is defined
// so users can use those extensions.
#if defined(REG_GNU)
constexpr int reg_flags = REG_EXTENDED | REG_GNU;
#else
constexpr int reg_flags = REG_EXTENDED;
#endif
// Reserves enough bytes to hold the regular expression used for a
// full match.
const size_t full_regex_len = strlen(regex) + 10;
char* const full_pattern = new char[full_regex_len];
snprintf(full_pattern, full_regex_len, "^(%s)$", regex);
is_valid_ = regcomp(&full_regex_, full_pattern, reg_flags) == 0;
// We want to call regcomp(&partial_regex_, ...) even if the
// previous expression returns false. Otherwise partial_regex_ may
// not be properly initialized can may cause trouble when it's
// freed.
//
// Some implementation of POSIX regex (e.g. on at least some
// versions of Cygwin) doesn't accept the empty string as a valid
// regex. We change it to an equivalent form "()" to be safe.
if (is_valid_) {
const char* const partial_regex = (*regex == '\0') ? "()" : regex;
is_valid_ = regcomp(&partial_regex_, partial_regex, reg_flags) == 0;
}
EXPECT_TRUE(is_valid_)
<< "Regular expression \"" << regex
<< "\" is not a valid POSIX Extended regular expression.";
delete[] full_pattern;
} | O1 | cpp | testing::internal::RE::Init(char const*):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq %rsi, %rdi
callq 0x8200
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0x88a0
movq %r12, %rdi
callq 0x8200
leaq 0xa(%rax), %r15
movq %r15, %rdi
callq 0x8040
movq %rax, %r14
leaq 0x2be47(%rip), %rdx # 0x42369
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0x88e0
leaq 0x28(%rbx), %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x85c0
testl %eax, %eax
sete 0x20(%rbx)
jne 0x1656f
cmpb $0x0, (%r12)
leaq 0x2cbc5(%rip), %rsi # 0x4311c
cmovneq %r12, %rsi
leaq 0x68(%rbx), %rdi
movl $0x1, %edx
callq 0x85c0
testl %eax, %eax
sete 0x20(%rbx)
movb 0x20(%rbx), %al
leaq 0x18(%rsp), %rbx
movb %al, -0x8(%rbx)
movq $0x0, (%rbx)
testb %al, %al
jne 0x1666d
leaq 0x8(%rsp), %rdi
callq 0x1cd64
movq 0x8(%rsp), %r15
leaq 0x10(%r15), %r13
leaq 0x2bdcd(%rip), %rsi # 0x42370
movl $0x14, %edx
movq %r13, %rdi
callq 0x85b0
testq %r12, %r12
je 0x165c2
movq %r12, %rdi
callq 0x8200
movq %rax, %rdx
jmp 0x165ce
movl $0x6, %edx
leaq 0x2a01b(%rip), %r12 # 0x405e9
movq %r13, %rdi
movq %r12, %rsi
callq 0x85b0
leaq 0x2bda5(%rip), %rsi # 0x42385
movl $0x33, %edx
movq %r13, %rdi
callq 0x85b0
leaq 0x2be3e(%rip), %rdx # 0x42432
leaq 0x29d77(%rip), %rcx # 0x40372
leaq 0x29d76(%rip), %r8 # 0x40378
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x166fd
movq 0x20(%rsp), %r8
leaq 0x2bd9c(%rip), %rdx # 0x423b9
movq %rsp, %rdi
movl $0x1, %esi
movl $0x2e9, %ecx # imm = 0x2E9
callq 0x18f74
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x16886
movq %rsp, %rdi
callq 0x18fe0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1665f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84e0
testq %r15, %r15
je 0x1666d
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x1667f
movq %rbx, %rdi
callq 0xde4a
movq %r14, %rdi
callq 0x86f0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x18fe0
jmp 0x166a5
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x166cc
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84e0
jmp 0x166cc
jmp 0x166c9
movq %rax, %r14
jmp 0x166e3
movq %rax, %r14
testq %r15, %r15
je 0x166da
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x166f5
movq %rbx, %rdi
callq 0xde4a
movq %r14, %rdi
callq 0x8990
| _ZN7testing8internal2RE4InitEPKc:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 40h
mov r12, rsi
mov rbx, rdi
mov r14, [rdi+8]
mov rdi, rsi
call _strlen
mov rdi, rbx
xor esi, esi
mov rdx, r14
mov rcx, r12
mov r8, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
mov rdi, r12
call _strlen
lea r15, [rax+0Ah]
mov rdi, r15; unsigned __int64
call __Znam; operator new[](ulong)
mov r14, rax
lea rdx, aS; "^(%s)$"
mov rdi, rax
mov rsi, r15
mov rcx, r12
xor eax, eax
call _snprintf
lea rdi, [rbx+28h]
mov rsi, r14
mov edx, 1
call _regcomp
test eax, eax
setz byte ptr [rbx+20h]
jnz short loc_1656F
cmp byte ptr [r12], 0
lea rsi, aTeardowntestsu+11h; "()"
cmovnz rsi, r12
lea rdi, [rbx+68h]
mov edx, 1
call _regcomp
test eax, eax
setz byte ptr [rbx+20h]
loc_1656F:
mov al, [rbx+20h]
lea rbx, [rsp+68h+var_50]
mov [rbx-8], al
mov qword ptr [rbx], 0
test al, al
jnz loc_1666D
lea rdi, [rsp+68h+var_60]; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
mov r15, [rsp+68h+var_60]
lea r13, [r15+10h]
lea rsi, aRegularExpress; "Regular expression \""
mov edx, 14h
mov rdi, r13
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_165C2
mov rdi, r12
call _strlen
mov rdx, rax
jmp short loc_165CE
loc_165C2:
mov edx, 6
lea r12, aNull; "(null)"
loc_165CE:
mov rdi, r13
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, aIsNotAValidPos; "\" is not a valid POSIX Extended regula"...
mov edx, 33h ; '3'
mov rdi, r13
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rdx, aIsValid; "is_valid_"
lea rcx, aFalse; "false"
lea r8, aTrue; "true"
lea rdi, [rsp+68h+var_48]
lea rsi, [rsp+68h+var_58]
call _ZN7testing8internal30GetBoolAssertionFailureMessageB5cxx11ERKNS_15AssertionResultEPKcS5_S5_; testing::internal::GetBoolAssertionFailureMessage(testing::AssertionResult const&,char const*,char const*,char const*)
mov r8, [rsp+68h+var_48]
lea rdx, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
mov rdi, rsp
mov esi, 1
mov ecx, 2E9h
call _ZN7testing8internal12AssertHelperC2ENS_14TestPartResult4TypeEPKciS5_; testing::internal::AssertHelper::AssertHelper(testing::TestPartResult::Type,char const*,int,char const*)
mov rdi, rsp
lea rsi, [rsp+68h+var_60]
call _ZNK7testing8internal12AssertHelperaSERKNS_7MessageE; testing::internal::AssertHelper::operator=(testing::Message const&)
mov rdi, rsp; this
call _ZN7testing8internal12AssertHelperD2Ev; testing::internal::AssertHelper::~AssertHelper()
lea rax, [rsp+68h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_1665F
mov rsi, [rsp+68h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1665F:
test r15, r15
jz short loc_1666D
mov rax, [r15]
mov rdi, r15
call qword ptr [rax+8]
loc_1666D:
mov rsi, [rsp+68h+var_50]
test rsi, rsi
jz short loc_1667F
mov rdi, rbx
call _ZNKSt14default_deleteINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEPS5_; std::default_delete<std::string>::operator()(std::string*)
loc_1667F:
mov rdi, r14; void *
call __ZdaPv; operator delete[](void *)
add rsp, 40h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov r14, rax
mov rdi, rsp; this
call _ZN7testing8internal12AssertHelperD2Ev; testing::internal::AssertHelper::~AssertHelper()
jmp short loc_166A5
mov r14, rax
loc_166A5:
lea rax, [rsp+arg_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_166CC
mov rsi, [rsp+arg_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_166CC
jmp short loc_166C9
mov r14, rax
jmp short loc_166E3
loc_166C9:
mov r14, rax
loc_166CC:
test r15, r15
jz short loc_166DA
mov rax, [r15]
mov rdi, r15
call qword ptr [rax+8]
loc_166DA:
mov [rsp+arg_0], 0
loc_166E3:
mov rsi, [rsp+arg_10]
test rsi, rsi
jz short loc_166F5
mov rdi, rbx
call _ZNKSt14default_deleteINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEPS5_; std::default_delete<std::string>::operator()(std::string*)
loc_166F5:
mov rdi, r14
call __Unwind_Resume
| void testing::internal::RE::Init(testing::internal::RE *this, const char *a2)
{
const char *v2; // r12
long long v3; // r14
long long v4; // rax
unsigned long long v5; // r15
void *v6; // r14
int v7; // eax
char *v8; // rsi
long long v9; // r15
long long v10; // r13
long long v11; // rdx
int v12; // edx
int v13; // ecx
int v14; // r8d
int v15; // r9d
int v16; // [rsp+0h] [rbp-68h] BYREF
long long v17; // [rsp+8h] [rbp-60h] BYREF
int v18; // [rsp+10h] [rbp-58h] BYREF
long long v19; // [rsp+18h] [rbp-50h] BYREF
void *v20[2]; // [rsp+20h] [rbp-48h] BYREF
long long v21; // [rsp+30h] [rbp-38h] BYREF
v2 = a2;
v3 = *((_QWORD *)this + 1);
v4 = strlen(a2);
std::string::_M_replace(this, 0LL, v3, a2, v4);
v5 = strlen(a2) + 10;
v6 = (void *)operator new[](v5);
snprintf(v6, v5, "^(%s)$", a2);
v7 = regcomp((char *)this + 40, v6, 1LL);
*((_BYTE *)this + 32) = v7 == 0;
if ( !v7 )
{
v8 = "()";
if ( *v2 )
v8 = (char *)v2;
*((_BYTE *)this + 32) = (unsigned int)regcomp((char *)this + 104, v8, 1LL) == 0;
}
LOBYTE(v18) = *((_BYTE *)this + 32);
v19 = 0LL;
if ( !(_BYTE)v18 )
{
testing::Message::Message((testing::Message *)&v17);
v9 = v17;
v10 = v17 + 16;
std::__ostream_insert<char,std::char_traits<char>>(v17 + 16, "Regular expression \"", 20LL);
if ( v2 )
{
v11 = strlen(v2);
}
else
{
v11 = 6LL;
v2 = "(null)";
}
std::__ostream_insert<char,std::char_traits<char>>(v10, v2, v11);
std::__ostream_insert<char,std::char_traits<char>>(
v10,
"\" is not a valid POSIX Extended regular expression.",
51LL);
testing::internal::GetBoolAssertionFailureMessage[abi:cxx11](v20, &v18, "is_valid_", "false", "true");
testing::internal::AssertHelper::AssertHelper(
&v16,
1LL,
"/workspace/llm4binary/github/2025_star3/giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest-port.cc",
745LL,
v20[0]);
testing::internal::AssertHelper::operator=(
(unsigned int)&v16,
(unsigned int)&v17,
v12,
v13,
v14,
v15,
v16,
v17,
v18,
v19,
v20[0],
(long long)v20[1]);
testing::internal::AssertHelper::~AssertHelper((testing::internal::AssertHelper *)&v16);
if ( v20[0] != &v21 )
operator delete(v20[0], v21 + 1);
if ( v9 )
(*(void ( **)(long long))(*(_QWORD *)v9 + 8LL))(v9);
}
if ( v19 )
std::default_delete<std::string>::operator()((long long)&v19, v19);
operator delete[](v6);
}
| Init:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV R12,RSI
MOV RBX,RDI
MOV R14,qword ptr [RDI + 0x8]
MOV RDI,RSI
CALL 0x00108200
MOV RDI,RBX
XOR ESI,ESI
MOV RDX,R14
MOV RCX,R12
MOV R8,RAX
CALL 0x001088a0
MOV RDI,R12
CALL 0x00108200
LEA R15,[RAX + 0xa]
MOV RDI,R15
CALL 0x00108040
MOV R14,RAX
LEA RDX,[0x142369]
MOV RDI,RAX
MOV RSI,R15
MOV RCX,R12
XOR EAX,EAX
CALL 0x001088e0
LEA RDI,[RBX + 0x28]
MOV RSI,R14
MOV EDX,0x1
CALL 0x001085c0
TEST EAX,EAX
SETZ byte ptr [RBX + 0x20]
JNZ 0x0011656f
CMP byte ptr [R12],0x0
LEA RSI,[0x14311c]
CMOVNZ RSI,R12
LEA RDI,[RBX + 0x68]
MOV EDX,0x1
CALL 0x001085c0
TEST EAX,EAX
SETZ byte ptr [RBX + 0x20]
LAB_0011656f:
MOV AL,byte ptr [RBX + 0x20]
LEA RBX,[RSP + 0x18]
MOV byte ptr [RBX + -0x8],AL
MOV qword ptr [RBX],0x0
TEST AL,AL
JNZ 0x0011666d
LAB_00116589:
LEA RDI,[RSP + 0x8]
CALL 0x0011cd64
MOV R15,qword ptr [RSP + 0x8]
LEA R13,[R15 + 0x10]
LAB_0011659c:
LEA RSI,[0x142370]
MOV EDX,0x14
MOV RDI,R13
CALL 0x001085b0
TEST R12,R12
JZ 0x001165c2
MOV RDI,R12
CALL 0x00108200
MOV RDX,RAX
JMP 0x001165ce
LAB_001165c2:
MOV EDX,0x6
LEA R12,[0x1405e9]
LAB_001165ce:
MOV RDI,R13
MOV RSI,R12
CALL 0x001085b0
LEA RSI,[0x142385]
MOV EDX,0x33
MOV RDI,R13
CALL 0x001085b0
LAB_001165ed:
LEA RDX,[0x142432]
LEA RCX,[0x140372]
LEA R8,[0x140378]
LEA RDI,[RSP + 0x20]
LEA RSI,[RSP + 0x10]
CALL 0x001166fd
MOV R8,qword ptr [RSP + 0x20]
LAB_00116616:
LEA RDX,[0x1423b9]
MOV RDI,RSP
MOV ESI,0x1
MOV ECX,0x2e9
CALL 0x00118f74
LAB_0011662f:
MOV RDI,RSP
LEA RSI,[RSP + 0x8]
CALL 0x00116886
LAB_0011663c:
MOV RDI,RSP
CALL 0x00118fe0
LEA RAX,[RSP + 0x30]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0011665f
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x001084e0
LAB_0011665f:
TEST R15,R15
JZ 0x0011666d
MOV RAX,qword ptr [R15]
MOV RDI,R15
CALL qword ptr [RAX + 0x8]
LAB_0011666d:
MOV RSI,qword ptr [RSP + 0x18]
TEST RSI,RSI
JZ 0x0011667f
MOV RDI,RBX
CALL 0x0010de4a
LAB_0011667f:
MOV RDI,R14
CALL 0x001086f0
ADD RSP,0x40
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* testing::internal::RE::Init(char const*) */
void __thiscall testing::internal::RE::Init(RE *this,char *param_1)
{
ostream *poVar1;
int iVar2;
size_t sVar3;
char *pcVar4;
char *__pattern;
AssertHelper aAStack_68 [8];
long *local_60;
RE local_58 [8];
string *local_50;
long *local_48 [2];
long local_38 [2];
pcVar4 = *(char **)(this + 8);
strlen(param_1);
std::__cxx11::string::_M_replace((ulong)this,0,pcVar4,(ulong)param_1);
sVar3 = strlen(param_1);
pcVar4 = (char *)operator_new__(sVar3 + 10);
snprintf(pcVar4,sVar3 + 10,"^(%s)$",param_1);
iVar2 = regcomp((regex_t *)(this + 0x28),pcVar4,1);
this[0x20] = (RE)(iVar2 == 0);
if (iVar2 == 0) {
__pattern = "()";
if (*param_1 != '\0') {
__pattern = param_1;
}
iVar2 = regcomp((regex_t *)(this + 0x68),__pattern,1);
this[0x20] = (RE)(iVar2 == 0);
}
local_58[0] = this[0x20];
local_50 = (string *)0x0;
if (local_58[0] == (RE)0x0) {
/* try { // try from 00116589 to 00116592 has its CatchHandler @ 001166c4 */
Message::Message((Message *)&local_60);
poVar1 = (ostream *)(local_60 + 2);
/* try { // try from 0011659c to 001165ec has its CatchHandler @ 001166c9 */
std::__ostream_insert<char,std::char_traits<char>>(poVar1,"Regular expression \"",0x14);
if (param_1 == (char *)0x0) {
sVar3 = 6;
param_1 = "(null)";
}
else {
sVar3 = strlen(param_1);
}
std::__ostream_insert<char,std::char_traits<char>>(poVar1,param_1,sVar3);
std::__ostream_insert<char,std::char_traits<char>>
(poVar1,"\" is not a valid POSIX Extended regular expression.",0x33);
/* try { // try from 001165ed to 00116610 has its CatchHandler @ 001166c2 */
GetBoolAssertionFailureMessage_abi_cxx11_
((internal *)local_48,(AssertionResult *)local_58,"is_valid_","false","true");
/* try { // try from 00116616 to 0011662e has its CatchHandler @ 001166a2 */
AssertHelper::AssertHelper
(aAStack_68,1,
"/workspace/llm4binary/github/2025_star3/giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest-port.cc"
,0x2e9,local_48[0]);
/* try { // try from 0011662f to 0011663b has its CatchHandler @ 00116695 */
AssertHelper::operator=(aAStack_68,(Message *)&local_60);
AssertHelper::~AssertHelper(aAStack_68);
if (local_48[0] != local_38) {
operator_delete(local_48[0],local_38[0] + 1);
}
if (local_60 != (long *)0x0) {
(**(code **)(*local_60 + 8))(local_60);
}
}
if (local_50 != (string *)0x0) {
std::default_delete<std::__cxx11::string>::operator()
((default_delete<std::__cxx11::string> *)&local_50,local_50);
}
operator_delete__(pcVar4);
return;
}
| |
45,618 | ggml_out_prod | ngxson[P]ggml-easy/ggml/src/ggml.c | struct ggml_tensor * ggml_out_prod(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b) {
GGML_ASSERT(ggml_can_out_prod(a, b));
GGML_ASSERT(!ggml_is_transposed(a));
// a is broadcastable to b for ne[2] and ne[3] -> use b->ne[2] and b->ne[3]
const int64_t ne[4] = { a->ne[0], b->ne[0], b->ne[2], b->ne[3] };
struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, 4, ne);
result->op = GGML_OP_OUT_PROD;
result->src[0] = a;
result->src[1] = b;
return result;
} | O2 | c | ggml_out_prod:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x18(%rsi), %rax
cmpq 0x18(%rdx), %rax
jne 0x2154a
movq %rdx, %rbx
movq %rsi, %r14
movq 0x20(%rdx), %r8
movq %r8, %rax
cqto
idivq 0x20(%rsi)
testq %rdx, %rdx
jne 0x2154a
movq 0x28(%rbx), %rsi
movq %rsi, %rax
cqto
idivq 0x28(%r14)
testq %rdx, %rdx
jne 0x2154a
movq 0x30(%r14), %rax
cmpq 0x38(%r14), %rax
ja 0x21566
movq 0x10(%r14), %rax
movq %rsp, %rcx
movq %rax, (%rcx)
movq 0x10(%rbx), %rax
movq %rax, 0x8(%rcx)
movq %r8, 0x10(%rcx)
movq %rsi, 0x18(%rcx)
pushq $0x4
popq %rdx
xorl %esi, %esi
callq 0x1c230
movl $0x1d, 0x50(%rax)
movq %r14, 0x98(%rax)
movq %rbx, 0xa0(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x2a032(%rip), %rdi # 0x4b583
leaq 0x2a076(%rip), %rdx # 0x4b5ce
leaq 0x2a34e(%rip), %rcx # 0x4b8ad
movl $0xb04, %esi # imm = 0xB04
jmp 0x21580
leaq 0x2a016(%rip), %rdi # 0x4b583
leaq 0x2a05a(%rip), %rdx # 0x4b5ce
leaq 0x2a247(%rip), %rcx # 0x4b7c2
movl $0xb05, %esi # imm = 0xB05
xorl %eax, %eax
callq 0x1e770
| ggml_out_prod:
push r14
push rbx
sub rsp, 28h
mov rax, [rsi+18h]
cmp rax, [rdx+18h]
jnz short loc_2154A
mov rbx, rdx
mov r14, rsi
mov r8, [rdx+20h]
mov rax, r8
cqo
idiv qword ptr [rsi+20h]
test rdx, rdx
jnz short loc_2154A
mov rsi, [rbx+28h]
mov rax, rsi
cqo
idiv qword ptr [r14+28h]
test rdx, rdx
jnz short loc_2154A
mov rax, [r14+30h]
cmp rax, [r14+38h]
ja short loc_21566
mov rax, [r14+10h]
mov rcx, rsp
mov [rcx], rax
mov rax, [rbx+10h]
mov [rcx+8], rax
mov [rcx+10h], r8
mov [rcx+18h], rsi
push 4
pop rdx
xor esi, esi
call _ggml_new_tensor
mov dword ptr [rax+50h], 1Dh
mov [rax+98h], r14
mov [rax+0A0h], rbx
add rsp, 28h
pop rbx
pop r14
retn
loc_2154A:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlCanOutProd; "ggml_can_out_prod(a, b)"
mov esi, 0B04h
jmp short loc_21580
loc_21566:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlIsTranspos_0; "!ggml_is_transposed(a)"
mov esi, 0B05h
loc_21580:
xor eax, eax
call _ggml_abort
| long long ggml_out_prod(
long long a1,
_QWORD *a2,
_QWORD *a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
long long a12,
long long a13,
long long a14)
{
long long v16; // rsi
long long result; // rax
const char *v18; // rcx
int v19; // esi
_QWORD v20[7]; // [rsp+0h] [rbp-38h] BYREF
if ( a2[3] != a3[3] || (a13 = a3[4], a13 % a2[4]) || (v16 = a3[5], v16 % a2[5]) )
{
v18 = "ggml_can_out_prod(a, b)";
v19 = 2820;
goto LABEL_8;
}
if ( a2[6] > a2[7] )
{
v18 = "!ggml_is_transposed(a)";
v19 = 2821;
LABEL_8:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",
v19,
(long long)"GGML_ASSERT(%s) failed",
(long long)v18,
a13,
a14,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
v20[0]);
}
v20[0] = a2[2];
v20[1] = a3[2];
v20[2] = a13;
v20[3] = v16;
result = ggml_new_tensor(a1, 0LL, 4LL, (long long)v20);
*(_DWORD *)(result + 80) = 29;
*(_QWORD *)(result + 152) = a2;
*(_QWORD *)(result + 160) = a3;
return result;
}
| ggml_out_prod:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr [RSI + 0x18]
CMP RAX,qword ptr [RDX + 0x18]
JNZ 0x0012154a
MOV RBX,RDX
MOV R14,RSI
MOV R8,qword ptr [RDX + 0x20]
MOV RAX,R8
CQO
IDIV qword ptr [RSI + 0x20]
TEST RDX,RDX
JNZ 0x0012154a
MOV RSI,qword ptr [RBX + 0x28]
MOV RAX,RSI
CQO
IDIV qword ptr [R14 + 0x28]
TEST RDX,RDX
JNZ 0x0012154a
MOV RAX,qword ptr [R14 + 0x30]
CMP RAX,qword ptr [R14 + 0x38]
JA 0x00121566
MOV RAX,qword ptr [R14 + 0x10]
MOV RCX,RSP
MOV qword ptr [RCX],RAX
MOV RAX,qword ptr [RBX + 0x10]
MOV qword ptr [RCX + 0x8],RAX
MOV qword ptr [RCX + 0x10],R8
MOV qword ptr [RCX + 0x18],RSI
PUSH 0x4
POP RDX
XOR ESI,ESI
CALL 0x0011c230
MOV dword ptr [RAX + 0x50],0x1d
MOV qword ptr [RAX + 0x98],R14
MOV qword ptr [RAX + 0xa0],RBX
ADD RSP,0x28
POP RBX
POP R14
RET
LAB_0012154a:
LEA RDI,[0x14b583]
LEA RDX,[0x14b5ce]
LEA RCX,[0x14b8ad]
MOV ESI,0xb04
JMP 0x00121580
LAB_00121566:
LEA RDI,[0x14b583]
LEA RDX,[0x14b5ce]
LEA RCX,[0x14b7c2]
MOV ESI,0xb05
LAB_00121580:
XOR EAX,EAX
CALL 0x0011e770
|
void ggml_out_prod(int8 param_1,long param_2,long param_3)
{
long lVar1;
char *pcVar2;
int8 uVar3;
if (((*(long *)(param_2 + 0x18) == *(long *)(param_3 + 0x18)) &&
(*(long *)(param_3 + 0x20) % *(long *)(param_2 + 0x20) == 0)) &&
(*(long *)(param_3 + 0x28) % *(long *)(param_2 + 0x28) == 0)) {
if (*(ulong *)(param_2 + 0x30) <= *(ulong *)(param_2 + 0x38)) {
lVar1 = ggml_new_tensor(param_1,0,4);
*(int4 *)(lVar1 + 0x50) = 0x1d;
*(long *)(lVar1 + 0x98) = param_2;
*(long *)(lVar1 + 0xa0) = param_3;
return;
}
pcVar2 = "!ggml_is_transposed(a)";
uVar3 = 0xb05;
}
else {
pcVar2 = "ggml_can_out_prod(a, b)";
uVar3 = 0xb04;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",uVar3,
"GGML_ASSERT(%s) failed",pcVar2);
}
| |
45,619 | bf_get_uint64 | bluesky950520[P]quickjs/libbf.c | int bf_get_uint64(uint64_t *pres, const bf_t *a)
{
uint64_t v;
int ret;
if (a->expn == BF_EXP_NAN) {
goto overflow;
} else if (a->expn <= 0) {
v = 0;
ret = 0;
} else if (a->sign) {
v = 0;
ret = BF_ST_INVALID_OP;
} else if (a->expn <= 64) {
#if LIMB_BITS == 32
if (a->expn <= 32)
v = a->tab[a->len - 1] >> (LIMB_BITS - a->expn);
else
v = (((uint64_t)a->tab[a->len - 1] << 32) |
get_limbz(a, a->len - 2)) >> (64 - a->expn);
#else
v = a->tab[a->len - 1] >> (LIMB_BITS - a->expn);
#endif
ret = 0;
} else {
overflow:
v = UINT64_MAX;
ret = BF_ST_INVALID_OP;
}
*pres = v;
return ret;
} | O1 | c | bf_get_uint64:
movq 0x10(%rsi), %rcx
movl $0x1, %eax
movq $-0x1, %rdx
movabsq $0x7fffffffffffffff, %r8 # imm = 0x7FFFFFFFFFFFFFFF
cmpq %r8, %rcx
je 0x87e1c
testq %rcx, %rcx
jle 0x87dfe
cmpl $0x0, 0x8(%rsi)
je 0x87e02
xorl %edx, %edx
jmp 0x87e1c
xorl %edx, %edx
jmp 0x87e1a
cmpq $0x40, %rcx
jg 0x87e1c
movq 0x18(%rsi), %rax
movq 0x20(%rsi), %rdx
movq -0x8(%rdx,%rax,8), %rdx
negb %cl
shrq %cl, %rdx
xorl %eax, %eax
movq %rdx, (%rdi)
retq
| bf_get_uint64:
mov rcx, [rsi+10h]
mov eax, 1
mov rdx, 0FFFFFFFFFFFFFFFFh
mov r8, 7FFFFFFFFFFFFFFFh
cmp rcx, r8
jz short loc_87E1C
test rcx, rcx
jle short loc_87DFE
cmp dword ptr [rsi+8], 0
jz short loc_87E02
xor edx, edx
jmp short loc_87E1C
loc_87DFE:
xor edx, edx
jmp short loc_87E1A
loc_87E02:
cmp rcx, 40h ; '@'
jg short loc_87E1C
mov rax, [rsi+18h]
mov rdx, [rsi+20h]
mov rdx, [rdx+rax*8-8]
neg cl
shr rdx, cl
loc_87E1A:
xor eax, eax
loc_87E1C:
mov [rdi], rdx
retn
| long long bf_get_uint64(long long *a1, long long a2)
{
long long v2; // rcx
long long result; // rax
long long v4; // rdx
v2 = *(_QWORD *)(a2 + 16);
result = 1LL;
v4 = -1LL;
if ( v2 != 0x7FFFFFFFFFFFFFFFLL )
{
if ( v2 <= 0 )
{
v4 = 0LL;
}
else
{
if ( *(_DWORD *)(a2 + 8) )
{
v4 = 0LL;
goto LABEL_9;
}
if ( v2 > 64 )
goto LABEL_9;
v4 = *(_QWORD *)(*(_QWORD *)(a2 + 32) + 8LL * *(_QWORD *)(a2 + 24) - 8) >> -(char)v2;
}
result = 0LL;
}
LABEL_9:
*a1 = v4;
return result;
}
| bf_get_uint64:
MOV RCX,qword ptr [RSI + 0x10]
MOV EAX,0x1
MOV RDX,-0x1
MOV R8,0x7fffffffffffffff
CMP RCX,R8
JZ 0x00187e1c
TEST RCX,RCX
JLE 0x00187dfe
CMP dword ptr [RSI + 0x8],0x0
JZ 0x00187e02
XOR EDX,EDX
JMP 0x00187e1c
LAB_00187dfe:
XOR EDX,EDX
JMP 0x00187e1a
LAB_00187e02:
CMP RCX,0x40
JG 0x00187e1c
MOV RAX,qword ptr [RSI + 0x18]
MOV RDX,qword ptr [RSI + 0x20]
MOV RDX,qword ptr [RDX + RAX*0x8 + -0x8]
NEG CL
SHR RDX,CL
LAB_00187e1a:
XOR EAX,EAX
LAB_00187e1c:
MOV qword ptr [RDI],RDX
RET
|
int8 bf_get_uint64(ulong *param_1,long param_2)
{
long lVar1;
int8 uVar2;
ulong uVar3;
lVar1 = *(long *)(param_2 + 0x10);
uVar2 = 1;
uVar3 = 0xffffffffffffffff;
if (lVar1 == 0x7fffffffffffffff) goto LAB_00187e1c;
if (lVar1 < 1) {
uVar3 = 0;
}
else {
if (*(int *)(param_2 + 8) != 0) {
uVar3 = 0;
goto LAB_00187e1c;
}
if (0x40 < lVar1) goto LAB_00187e1c;
uVar3 = *(ulong *)(*(long *)(param_2 + 0x20) + -8 + *(long *)(param_2 + 0x18) * 8) >>
(-(char)lVar1 & 0x3fU);
}
uVar2 = 0;
LAB_00187e1c:
*param_1 = uVar3;
return uVar2;
}
| |
45,620 | thai2sortable | eloqsql/strings/ctype-tis620.c | static size_t thai2sortable(uchar *tstr, size_t len)
{
uchar *p;
size_t tlen;
uchar l2bias;
tlen= len;
l2bias= 256 - 8;
for (p= tstr; tlen > 0; p++, tlen--)
{
uchar c= *p;
if (isthai(c))
{
const int *t_ctype0= t_ctype[c];
if (isconsnt(c))
l2bias -= 8;
if (isldvowel(c) && tlen != 1 && isconsnt(p[1]))
{
/* simply swap between leading-vowel and consonant */
*p= p[1];
p[1]= c;
tlen--;
p++;
continue;
}
/* if found level 2 char (L2_GARAN,L2_TONE*,L2_TYKHU) move to last */
if (t_ctype0[1] >= L2_GARAN)
{
/*
l2bias use to control position weight of l2char
example (*=l2char) XX*X must come before X*XX
*/
memmove((char*) p, (char*) (p+1), tlen-1);
tstr[len-1]= l2bias + t_ctype0[1]- L2_GARAN +1;
p--;
continue;
}
}
else
{
l2bias-= 8;
*p= to_lower_tis620[c];
}
}
return len;
} | O3 | c | thai2sortable:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, -0x38(%rbp)
movq %rsi, -0x30(%rbp)
testq %rsi, %rsi
je 0xb7850
movb $-0x8, %r13b
leaq 0x1added(%rip), %r12 # 0x265580
leaq 0x2f7696(%rip), %r8 # 0x3aee30
movq -0x38(%rbp), %r15
movq -0x30(%rbp), %rbx
movb (%r15), %al
movzbl %al, %ecx
testb %cl, %cl
js 0xb77c4
addb $-0x8, %r13b
movb (%rcx,%r8), %al
movb %al, (%r15)
incq %r15
decq %rbx
jne 0xb77a2
jmp 0xb7850
leaq (%rcx,%rcx,4), %rcx
movl 0x10(%r12,%rcx,4), %edx
leal -0x8(%r13), %esi
testb $0x10, %dl
movzbl %r13b, %edi
movzbl %sil, %r13d
cmovel %edi, %r13d
cmpq $0x1, %rbx
je 0xb77fd
andl $0x20, %edx
je 0xb77fd
movzbl 0x1(%r15), %edx
leaq -0xcf(%rdx), %rsi
cmpq $-0x2e, %rsi
jae 0xb783e
leaq (%r12,%rcx,4), %rax
movl 0x4(%rax), %r14d
cmpl $0x9, %r14d
jl 0xb77b7
leaq 0x1(%r15), %rsi
leaq -0x1(%rbx), %rdx
movq %r15, %rdi
callq 0x29120
leaq 0x2f760e(%rip), %r8 # 0x3aee30
addb %r13b, %r14b
addb $-0x8, %r14b
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movb %r14b, -0x1(%rcx,%rax)
decq %r15
jmp 0xb77b7
movb %dl, (%r15)
movb %al, 0x1(%r15)
incq %r15
decq %rbx
jmp 0xb77b7
movq -0x30(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| thai2sortable:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rbp+var_38], rdi
mov [rbp+var_30], rsi
test rsi, rsi
jz loc_B7850
mov r13b, 0F8h
lea r12, t_ctype
lea r8, to_lower_tis620
mov r15, [rbp+var_38]
mov rbx, [rbp+var_30]
loc_B77A2:
mov al, [r15]
movzx ecx, al
test cl, cl
js short loc_B77C4
add r13b, 0F8h
mov al, [rcx+r8]
mov [r15], al
loc_B77B7:
inc r15
dec rbx
jnz short loc_B77A2
jmp loc_B7850
loc_B77C4:
lea rcx, [rcx+rcx*4]
mov edx, [r12+rcx*4+10h]
lea esi, [r13-8]
test dl, 10h
movzx edi, r13b
movzx r13d, sil
cmovz r13d, edi
cmp rbx, 1
jz short loc_B77FD
and edx, 20h
jz short loc_B77FD
movzx edx, byte ptr [r15+1]
lea rsi, [rdx-0CFh]
cmp rsi, 0FFFFFFFFFFFFFFD2h
jnb short loc_B783E
loc_B77FD:
lea rax, [r12+rcx*4]
mov r14d, [rax+4]
cmp r14d, 9
jl short loc_B77B7
lea rsi, [r15+1]
lea rdx, [rbx-1]
mov rdi, r15
call _memmove
lea r8, to_lower_tis620
add r14b, r13b
add r14b, 0F8h
mov rax, [rbp+var_30]
mov rcx, [rbp+var_38]
mov [rcx+rax-1], r14b
dec r15
jmp loc_B77B7
loc_B783E:
mov [r15], dl
mov [r15+1], al
inc r15
dec rbx
jmp loc_B77B7
loc_B7850:
mov rax, [rbp+var_30]
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long thai2sortable(unsigned __int8 *a1, long long a2)
{
char v2; // r13
unsigned __int8 *v3; // r15
long long v4; // rbx
unsigned __int8 v5; // al
long long v6; // rcx
long long v7; // rcx
int v8; // edx
char v9; // di
long long v10; // rdx
int v11; // r14d
if ( a2 )
{
v2 = -8;
v3 = a1;
v4 = a2;
do
{
v5 = *v3;
v6 = *v3;
if ( (v6 & 0x80u) != 0LL )
{
v7 = 5 * v6;
v8 = t_ctype[v7 + 4];
v9 = v2;
v2 -= 8;
if ( (v8 & 0x10) == 0 )
v2 = v9;
if ( v4 != 1 && (v8 & 0x20) != 0 && (v10 = v3[1], (unsigned long long)(v10 - 207) >= 0xFFFFFFFFFFFFFFD2LL) )
{
*v3 = v10;
*++v3 = v5;
--v4;
}
else
{
v11 = t_ctype[v7 + 1];
if ( v11 >= 9 )
{
memmove(v3, v3 + 1, v4 - 1);
a1[a2 - 1] = v2 + v11 - 8;
--v3;
}
}
}
else
{
v2 -= 8;
*v3 = to_lower_tis620[v6];
}
++v3;
--v4;
}
while ( v4 );
}
return a2;
}
| thai2sortable:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x30],RSI
TEST RSI,RSI
JZ 0x001b7850
MOV R13B,0xf8
LEA R12,[0x365580]
LEA R8,[0x4aee30]
MOV R15,qword ptr [RBP + -0x38]
MOV RBX,qword ptr [RBP + -0x30]
LAB_001b77a2:
MOV AL,byte ptr [R15]
MOVZX ECX,AL
TEST CL,CL
JS 0x001b77c4
ADD R13B,0xf8
MOV AL,byte ptr [RCX + R8*0x1]
MOV byte ptr [R15],AL
LAB_001b77b7:
INC R15
DEC RBX
JNZ 0x001b77a2
JMP 0x001b7850
LAB_001b77c4:
LEA RCX,[RCX + RCX*0x4]
MOV EDX,dword ptr [R12 + RCX*0x4 + 0x10]
LEA ESI,[R13 + -0x8]
TEST DL,0x10
MOVZX EDI,R13B
MOVZX R13D,SIL
CMOVZ R13D,EDI
CMP RBX,0x1
JZ 0x001b77fd
AND EDX,0x20
JZ 0x001b77fd
MOVZX EDX,byte ptr [R15 + 0x1]
LEA RSI,[RDX + -0xcf]
CMP RSI,-0x2e
JNC 0x001b783e
LAB_001b77fd:
LEA RAX,[R12 + RCX*0x4]
MOV R14D,dword ptr [RAX + 0x4]
CMP R14D,0x9
JL 0x001b77b7
LEA RSI,[R15 + 0x1]
LEA RDX,[RBX + -0x1]
MOV RDI,R15
CALL 0x00129120
LEA R8,[0x4aee30]
ADD R14B,R13B
ADD R14B,0xf8
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x38]
MOV byte ptr [RCX + RAX*0x1 + -0x1],R14B
DEC R15
JMP 0x001b77b7
LAB_001b783e:
MOV byte ptr [R15],DL
MOV byte ptr [R15 + 0x1],AL
INC R15
DEC RBX
JMP 0x001b77b7
LAB_001b7850:
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long thai2sortable(byte *param_1,long param_2)
{
byte bVar1;
int iVar2;
char cVar3;
ulong uVar4;
long lVar5;
char cVar6;
byte *__dest;
if (param_2 != 0) {
cVar6 = -8;
lVar5 = param_2;
__dest = param_1;
do {
bVar1 = *__dest;
uVar4 = (ulong)bVar1;
if ((char)bVar1 < '\0') {
cVar3 = cVar6 + -8;
if ((*(uint *)(t_ctype + uVar4 * 0x14 + 0x10) & 0x10) == 0) {
cVar3 = cVar6;
}
cVar6 = cVar3;
if (((lVar5 == 1) || ((*(uint *)(t_ctype + uVar4 * 0x14 + 0x10) & 0x20) == 0)) ||
((ulong)__dest[1] - 0xcf < 0xffffffffffffffd2)) {
iVar2 = *(int *)(t_ctype + uVar4 * 0x14 + 4);
if (8 < iVar2) {
memmove(__dest,__dest + 1,lVar5 - 1);
param_1[param_2 + -1] = ((char)iVar2 + cVar3) - 8;
__dest = __dest + -1;
}
}
else {
*__dest = __dest[1];
__dest[1] = bVar1;
__dest = __dest + 1;
lVar5 = lVar5 + -1;
}
}
else {
*__dest = to_lower_tis620[uVar4];
cVar6 = cVar6 + -8;
}
__dest = __dest + 1;
lVar5 = lVar5 + -1;
} while (lVar5 != 0);
}
return param_2;
}
| |
45,621 | my_b_seq_read | eloqsql/mysys/mf_iocache.c | static int _my_b_seq_read(IO_CACHE *info, uchar *Buffer, size_t Count)
{
size_t length, diff_length, save_count, max_length;
my_off_t pos_in_file;
save_count=Count;
lock_append_buffer(info);
/* pos_in_file always point on where info->buffer was read */
if ((pos_in_file=info->pos_in_file +
(size_t) (info->read_end - info->buffer)) >= info->end_of_file)
goto read_append_buffer;
/*
With read-append cache we must always do a seek before we read,
because the write could have moved the file pointer astray
*/
if (mysql_file_seek(info->file, pos_in_file, MY_SEEK_SET, MYF(0)) == MY_FILEPOS_ERROR)
{
info->error= -1;
unlock_append_buffer(info);
return (1);
}
info->seek_not_done=0;
diff_length= (size_t) (pos_in_file & (IO_SIZE-1));
/* now the second stage begins - read from file descriptor */
if (Count >= (size_t) (IO_SIZE+(IO_SIZE-diff_length)))
{
/* Fill first intern buffer */
size_t read_length;
length= IO_ROUND_DN(Count) - diff_length;
if ((read_length= mysql_file_read(info->file,Buffer, length,
info->myflags)) == (size_t) -1)
{
info->error= -1;
unlock_append_buffer(info);
return 1;
}
Count-=read_length;
Buffer+=read_length;
pos_in_file+=read_length;
if (read_length != length)
{
/*
We only got part of data; Read the rest of the data from the
write buffer
*/
goto read_append_buffer;
}
diff_length=0;
}
max_length= info->read_length-diff_length;
if (max_length > (info->end_of_file - pos_in_file))
max_length= (size_t) (info->end_of_file - pos_in_file);
if (!max_length)
{
if (Count)
goto read_append_buffer;
length=0; /* Didn't read any more chars */
}
else
{
length= mysql_file_read(info->file,info->buffer, max_length, info->myflags);
if (length == (size_t) -1)
{
info->error= -1;
unlock_append_buffer(info);
return 1;
}
if (length < Count)
{
memcpy(Buffer, info->buffer, length);
Count -= length;
Buffer += length;
/*
added the line below to make
DBUG_ASSERT(pos_in_file==info->end_of_file) pass.
otherwise this does not appear to be needed
*/
pos_in_file += length;
goto read_append_buffer;
}
}
unlock_append_buffer(info);
info->read_pos=info->buffer+Count;
info->read_end=info->buffer+length;
info->pos_in_file=pos_in_file;
memcpy(Buffer,info->buffer,(size_t) Count);
return 0;
read_append_buffer:
/*
Read data from the current write buffer.
Count should never be == 0 here (The code will work even if count is 0)
*/
{
/* First copy the data to Count */
size_t len_in_buff = (size_t) (info->write_pos - info->append_read_pos);
size_t copy_len;
size_t transfer_len;
DBUG_ASSERT(info->append_read_pos <= info->write_pos);
copy_len=MY_MIN(Count, len_in_buff);
memcpy(Buffer, info->append_read_pos, copy_len);
info->append_read_pos += copy_len;
Count -= copy_len;
if (Count)
info->error= (int) (save_count - Count);
/* Fill read buffer with data from write buffer */
memcpy(info->buffer, info->append_read_pos,
(size_t) (transfer_len=len_in_buff - copy_len));
info->read_pos= info->buffer;
info->read_end= info->buffer+transfer_len;
info->append_read_pos=info->write_pos;
info->pos_in_file=pos_in_file+copy_len;
info->end_of_file+=len_in_buff;
}
unlock_append_buffer(info);
return Count ? 1 : 0;
} | O3 | c | my_b_seq_read:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r12
movq %rsi, -0x40(%rbp)
movq %rdi, %r14
leaq 0x50(%rdi), %r15
cmpq $0x0, 0x90(%rdi)
jne 0x96903
movq %r15, %rdi
callq 0x29220
movq 0x18(%r14), %r13
subq 0x20(%r14), %r13
addq (%r14), %r13
cmpq 0x8(%r14), %r13
jae 0x9667f
movl 0xd4(%r14), %ebx
leaq 0x2ef9f5(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0xa8(%rbp), %rdi
movl %ebx, %esi
movl $0x8, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x96931
movl %ebx, %edi
movq %r13, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xa0ba0
cmpq $-0x1, %rax
je 0x96866
movl $0x0, 0xe0(%r14)
movl %r13d, %eax
andl $0xfff, %eax # imm = 0xFFF
movl $0x2000, %ecx # imm = 0x2000
subq %rax, %rcx
cmpq %r12, %rcx
jbe 0x96726
movq %r12, %rdx
jmp 0x967ac
movq %r13, -0x38(%rbp)
movq %r15, -0x30(%rbp)
movq %r12, %r13
movq 0x38(%r14), %rsi
movq 0x40(%r14), %r15
subq %rsi, %r15
cmpq %r15, %r13
movq %r15, %rbx
cmovbq %r13, %rbx
movq -0x40(%rbp), %rdi
movq %rbx, %rdx
callq 0x29080
movq 0x38(%r14), %rsi
addq %rbx, %rsi
movq %rsi, 0x38(%r14)
cmpq %r15, %r13
jbe 0x966c9
subl %r13d, %r12d
leal (%rbx,%r12), %eax
movl %eax, 0xe4(%r14)
movq 0x20(%r14), %rdi
movq %r15, %r12
subq %rbx, %r12
movq %r12, %rdx
callq 0x29080
movq 0x20(%r14), %rax
movq 0x40(%r14), %rcx
movq %rax, 0x10(%r14)
addq %rax, %r12
movq %r12, 0x18(%r14)
movq %rcx, 0x38(%r14)
movq -0x38(%rbp), %rax
addq %rbx, %rax
movq %rax, (%r14)
addq %r15, 0x8(%r14)
movq 0x90(%r14), %rdi
testq %rdi, %rdi
jne 0x9691c
xorl %ebx, %ebx
cmpq %r15, %r13
seta %bl
movq -0x30(%rbp), %rdi
callq 0x291e0
jmp 0x9688e
movq %r13, -0x38(%rbp)
movl %r12d, %r13d
andl $0xfffff000, %r13d # imm = 0xFFFFF000
subq %rax, %r13
movl 0xd4(%r14), %ebx
movq 0xf8(%r14), %rax
movq %rax, -0x30(%rbp)
leaq 0x2ef8c0(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0xa8(%rbp), %rdi
movl %ebx, %esi
movl $0x6, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x96962
movl %ebx, %edi
movq -0x40(%rbp), %rsi
movq %r13, %rdx
movq -0x30(%rbp), %rcx
callq 0xa09a0
movq %rax, %rbx
cmpq $-0x1, %rbx
je 0x96866
movq %r12, %rdx
subq %rbx, %rdx
addq %rbx, -0x40(%rbp)
addq %rbx, -0x38(%rbp)
cmpq %r13, %rbx
jne 0x968ab
xorl %eax, %eax
movq -0x38(%rbp), %r13
movq 0x8(%r14), %rbx
movq 0xf0(%r14), %rcx
subq %rax, %rcx
subq %r13, %rbx
cmpq %rbx, %rcx
cmovbq %rcx, %rbx
testq %rbx, %rbx
je 0x968a2
movq %rdx, -0x48(%rbp)
movq %r13, -0x38(%rbp)
movl 0xd4(%r14), %r13d
movq 0x20(%r14), %rax
movq %rax, -0x50(%rbp)
movq 0xf8(%r14), %rax
movq %rax, -0x30(%rbp)
leaq 0x2ef81a(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0xa8(%rbp), %rdi
movl %r13d, %esi
movl $0x6, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x969d7
movl %r13d, %edi
movq -0x50(%rbp), %rsi
movq %rbx, %rdx
movq -0x30(%rbp), %rcx
callq 0xa09a0
cmpq $-0x1, %rax
movq -0x48(%rbp), %rdx
je 0x96866
movq %rdx, %r13
subq %rax, %r13
jbe 0x968b7
movq %r15, -0x30(%rbp)
movq 0x20(%r14), %rsi
movq -0x40(%rbp), %rbx
movq %rbx, %rdi
movq %rax, %rdx
movq %rax, %r15
callq 0x29080
addq %r15, %rbx
movq %rbx, -0x40(%rbp)
addq %r15, -0x38(%rbp)
jmp 0x9668a
movl $0xffffffff, 0xe4(%r14) # imm = 0xFFFFFFFF
movq 0x90(%r14), %rdi
testq %rdi, %rdi
jne 0x9694d
movq %r15, %rdi
callq 0x291e0
movl $0x1, %ebx
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %rdx, %rdx
je 0x968bd
movq %r13, -0x38(%rbp)
movq %r15, -0x30(%rbp)
movq %rdx, %r13
jmp 0x9668a
movq -0x38(%rbp), %r13
jmp 0x968bf
xorl %eax, %eax
movq %rax, %r12
movq %rdx, %rbx
movq 0x90(%r14), %rdi
testq %rdi, %rdi
jne 0x96a4b
movq %r15, %rdi
callq 0x291e0
movq 0x20(%r14), %rsi
movq %rbx, %rdx
leaq (%rsi,%rbx), %rax
movq %rax, 0x10(%r14)
addq %rsi, %r12
movq %r12, 0x18(%r14)
movq %r13, (%r14)
movq -0x40(%rbp), %rdi
callq 0x29080
xorl %ebx, %ebx
jmp 0x9688e
leaq 0x45a25(%rip), %rsi # 0xdc32f
movq %r15, %rdi
movl $0x54c, %edx # imm = 0x54C
callq 0x2eb8f
jmp 0x965fc
leaq 0x2ef6ed(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x96710
leaq -0x60(%rbp), %rcx
movq %rax, %rdi
movl %ebx, %esi
movq %r13, %rdx
movq %rcx, %rbx
callq 0x2ea93
movq (%rbx), %rax
jmp 0x96649
leaq 0x2ef6bc(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x96881
movq %rax, %rcx
leaq 0x2ef6a4(%rip), %rax # 0x386010
movq (%rax), %rax
leaq 0x459b9(%rip), %rdx # 0xdc32f
movq %rcx, -0x48(%rbp)
movq %rcx, %rdi
movq %r13, %rsi
movl $0x569, %ecx # imm = 0x569
callq *0x210(%rax)
movl %ebx, %edi
movq -0x40(%rbp), %rsi
movq %r13, %rdx
movq -0x30(%rbp), %rcx
callq 0xa09a0
movq %rax, %rbx
xorl %esi, %esi
testq %rax, %rax
movl $0x0, %eax
cmoveq %r13, %rax
cmpq $-0x1, %rbx
cmovneq %rbx, %rsi
testb $0x6, -0x30(%rbp)
cmovneq %rax, %rsi
leaq 0x2ef64b(%rip), %rax # 0x386010
movq (%rax), %rax
movq -0x48(%rbp), %rdi
callq *0x218(%rax)
jmp 0x96785
movq %rax, %rcx
leaq 0x2ef62f(%rip), %rax # 0x386010
movq (%rax), %rax
leaq 0x45944(%rip), %rdx # 0xdc32f
movq %rcx, -0x58(%rbp)
movq %rcx, %rdi
movq %rbx, %rsi
movl $0x589, %ecx # imm = 0x589
callq *0x210(%rax)
movl %r13d, %edi
movq -0x50(%rbp), %rsi
movq %rbx, %rdx
movq -0x30(%rbp), %rcx
callq 0xa09a0
movq %rax, %r13
xorl %esi, %esi
testq %rax, %rax
cmovneq %rsi, %rbx
cmpq $-0x1, %rax
cmovneq %rax, %rsi
testb $0x6, -0x30(%rbp)
cmovneq %rbx, %rsi
leaq 0x2ef5da(%rip), %rax # 0x386010
movq (%rax), %rax
movq -0x58(%rbp), %rdi
callq *0x218(%rax)
movq %r13, %rax
jmp 0x9682a
leaq 0x2ef5be(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x968d5
| _my_b_seq_read:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov r12, rdx
mov [rbp+var_40], rsi
mov r14, rdi
lea r15, [rdi+50h]
cmp qword ptr [rdi+90h], 0
jnz loc_96903
mov rdi, r15
call _pthread_mutex_lock
loc_965FC:
mov r13, [r14+18h]
sub r13, [r14+20h]
add r13, [r14]
cmp r13, [r14+8]
jnb short loc_9667F
mov ebx, [r14+0D4h]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_A8]
mov esi, ebx
mov edx, 8
call qword ptr [rax+158h]
test rax, rax
jnz loc_96931
mov edi, ebx
mov rsi, r13
xor edx, edx
xor ecx, ecx
call my_seek
loc_96649:
cmp rax, 0FFFFFFFFFFFFFFFFh
jz loc_96866
mov dword ptr [r14+0E0h], 0
mov eax, r13d
and eax, 0FFFh
mov ecx, 2000h
sub rcx, rax
cmp rcx, r12
jbe loc_96726
mov rdx, r12
jmp loc_967AC
loc_9667F:
mov [rbp+var_38], r13
mov [rbp+var_30], r15
mov r13, r12
loc_9668A:
mov rsi, [r14+38h]
mov r15, [r14+40h]
sub r15, rsi
cmp r13, r15
mov rbx, r15
cmovb rbx, r13
mov rdi, [rbp+var_40]
mov rdx, rbx
call _memcpy
mov rsi, [r14+38h]
add rsi, rbx
mov [r14+38h], rsi
cmp r13, r15
jbe short loc_966C9
sub r12d, r13d
lea eax, [rbx+r12]
mov [r14+0E4h], eax
loc_966C9:
mov rdi, [r14+20h]
mov r12, r15
sub r12, rbx
mov rdx, r12
call _memcpy
mov rax, [r14+20h]
mov rcx, [r14+40h]
mov [r14+10h], rax
add r12, rax
mov [r14+18h], r12
mov [r14+38h], rcx
mov rax, [rbp+var_38]
add rax, rbx
mov [r14], rax
add [r14+8], r15
mov rdi, [r14+90h]
test rdi, rdi
jnz loc_9691C
loc_96710:
xor ebx, ebx
cmp r13, r15
setnbe bl
mov rdi, [rbp+var_30]
call _pthread_mutex_unlock
jmp loc_9688E
loc_96726:
mov [rbp+var_38], r13
mov r13d, r12d
and r13d, 0FFFFF000h
sub r13, rax
mov ebx, [r14+0D4h]
mov rax, [r14+0F8h]
mov [rbp+var_30], rax
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_A8]
mov esi, ebx
mov edx, 6
call qword ptr [rax+158h]
test rax, rax
jnz loc_96962
mov edi, ebx
mov rsi, [rbp+var_40]
mov rdx, r13
mov rcx, [rbp+var_30]
call my_read
mov rbx, rax
loc_96785:
cmp rbx, 0FFFFFFFFFFFFFFFFh
jz loc_96866
mov rdx, r12
sub rdx, rbx
add [rbp+var_40], rbx
add [rbp+var_38], rbx
cmp rbx, r13
jnz loc_968AB
xor eax, eax
mov r13, [rbp+var_38]
loc_967AC:
mov rbx, [r14+8]
mov rcx, [r14+0F0h]
sub rcx, rax
sub rbx, r13
cmp rcx, rbx
cmovb rbx, rcx
test rbx, rbx
jz loc_968A2
mov [rbp+var_48], rdx
mov [rbp+var_38], r13
mov r13d, [r14+0D4h]
mov rax, [r14+20h]
mov [rbp+var_50], rax
mov rax, [r14+0F8h]
mov [rbp+var_30], rax
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_A8]
mov esi, r13d
mov edx, 6
call qword ptr [rax+158h]
test rax, rax
jnz loc_969D7
mov edi, r13d
mov rsi, [rbp+var_50]
mov rdx, rbx
mov rcx, [rbp+var_30]
call my_read
loc_9682A:
cmp rax, 0FFFFFFFFFFFFFFFFh
mov rdx, [rbp+var_48]
jz short loc_96866
mov r13, rdx
sub r13, rax
jbe short loc_968B7
mov [rbp+var_30], r15
mov rsi, [r14+20h]
mov rbx, [rbp+var_40]
mov rdi, rbx
mov rdx, rax
mov r15, rax
call _memcpy
add rbx, r15
mov [rbp+var_40], rbx
add [rbp+var_38], r15
jmp loc_9668A
loc_96866:
mov dword ptr [r14+0E4h], 0FFFFFFFFh
mov rdi, [r14+90h]
test rdi, rdi
jnz loc_9694D
loc_96881:
mov rdi, r15
call _pthread_mutex_unlock
mov ebx, 1
loc_9688E:
mov eax, ebx
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_968A2:
test rdx, rdx
jz short loc_968BD
mov [rbp+var_38], r13
loc_968AB:
mov [rbp+var_30], r15
mov r13, rdx
jmp loc_9668A
loc_968B7:
mov r13, [rbp+var_38]
jmp short loc_968BF
loc_968BD:
xor eax, eax
loc_968BF:
mov r12, rax
mov rbx, rdx
mov rdi, [r14+90h]
test rdi, rdi
jnz loc_96A4B
loc_968D5:
mov rdi, r15
call _pthread_mutex_unlock
mov rsi, [r14+20h]
mov rdx, rbx
lea rax, [rsi+rbx]
mov [r14+10h], rax
add r12, rsi
mov [r14+18h], r12
mov [r14], r13
mov rdi, [rbp+var_40]
call _memcpy
xor ebx, ebx
jmp short loc_9688E
loc_96903:
lea rsi, aWorkspaceLlm4b_21; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r15
mov edx, 54Ch
call psi_mutex_lock
jmp loc_965FC
loc_9691C:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_96710
loc_96931:
lea rcx, [rbp+var_60]
mov rdi, rax
mov esi, ebx
mov rdx, r13
mov rbx, rcx
call _my_b_seq_read_cold_1
mov rax, [rbx]
jmp loc_96649
loc_9694D:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_96881
loc_96962:
mov rcx, rax
lea rax, PSI_server
mov rax, [rax]
lea rdx, aWorkspaceLlm4b_21; "/workspace/llm4binary/github2025/eloqsq"...
mov [rbp+var_48], rcx
mov rdi, rcx
mov rsi, r13
mov ecx, 569h
call qword ptr [rax+210h]
mov edi, ebx
mov rsi, [rbp+var_40]
mov rdx, r13
mov rcx, [rbp+var_30]
call my_read
mov rbx, rax
xor esi, esi
test rax, rax
mov eax, 0
cmovz rax, r13
cmp rbx, 0FFFFFFFFFFFFFFFFh
cmovnz rsi, rbx
test byte ptr [rbp+var_30], 6
cmovnz rsi, rax
lea rax, PSI_server
mov rax, [rax]
mov rdi, [rbp+var_48]
call qword ptr [rax+218h]
jmp loc_96785
loc_969D7:
mov rcx, rax
lea rax, PSI_server
mov rax, [rax]
lea rdx, aWorkspaceLlm4b_21; "/workspace/llm4binary/github2025/eloqsq"...
mov [rbp+var_58], rcx
mov rdi, rcx
mov rsi, rbx
mov ecx, 589h
call qword ptr [rax+210h]
mov edi, r13d
mov rsi, [rbp+var_50]
mov rdx, rbx
mov rcx, [rbp+var_30]
call my_read
mov r13, rax
xor esi, esi
test rax, rax
cmovnz rbx, rsi
cmp rax, 0FFFFFFFFFFFFFFFFh
cmovnz rsi, rax
test byte ptr [rbp+var_30], 6
cmovnz rsi, rbx
lea rax, PSI_server
mov rax, [rax]
mov rdi, [rbp+var_58]
call qword ptr [rax+218h]
mov rax, r13
jmp loc_9682A
loc_96A4B:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_968D5
| _BOOL8 my_b_seq_read(long long a1, unsigned long long a2, unsigned long long a3)
{
long long v4; // r15
unsigned long long v5; // r13
unsigned int v6; // ebx
long long v7; // rax
unsigned long long v8; // rsi
long long v9; // rax
unsigned long long v10; // rdx
unsigned long long v11; // rax
unsigned long long v12; // r13
long long v13; // rsi
unsigned long long v14; // r15
unsigned long long v15; // rbx
unsigned long long v16; // rsi
long long v17; // rax
long long v18; // rcx
BOOL v19; // ebx
unsigned long long v20; // r13
unsigned int v21; // ebx
long long v22; // rax
long long v23; // rbx
unsigned long long v24; // rbx
unsigned int v25; // r13d
long long v26; // rax
unsigned long long v27; // rax
unsigned long long v28; // rbx
unsigned long long v29; // r15
long long v30; // rdi
unsigned long long v32; // r12
unsigned long long v33; // rbx
long long v34; // rsi
unsigned long long v35; // rax
long long v36; // rax
unsigned long long v37; // r13
_BYTE v38[72]; // [rsp+8h] [rbp-A8h] BYREF
long long v39; // [rsp+50h] [rbp-60h] BYREF
long long v40; // [rsp+58h] [rbp-58h]
unsigned long long v41; // [rsp+60h] [rbp-50h]
unsigned long long v42; // [rsp+68h] [rbp-48h]
unsigned long long v43; // [rsp+70h] [rbp-40h]
unsigned long long v44; // [rsp+78h] [rbp-38h]
long long v45; // [rsp+80h] [rbp-30h]
v43 = a2;
v4 = a1 + 80;
if ( *(_QWORD *)(a1 + 144) )
psi_mutex_lock(a1 + 80, (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c", 0x54Cu);
else
pthread_mutex_lock(a1 + 80);
v5 = *(_QWORD *)a1 + *(_QWORD *)(a1 + 24) - *(_QWORD *)(a1 + 32);
if ( v5 >= *(_QWORD *)(a1 + 8) )
{
v44 = *(_QWORD *)a1 + *(_QWORD *)(a1 + 24) - *(_QWORD *)(a1 + 32);
v45 = a1 + 80;
v12 = a3;
LABEL_10:
v13 = *(_QWORD *)(a1 + 56);
v14 = *(_QWORD *)(a1 + 64) - v13;
v15 = v14;
if ( v12 < v14 )
v15 = v12;
memcpy(v43, v13, v15);
v16 = v15 + *(_QWORD *)(a1 + 56);
*(_QWORD *)(a1 + 56) = v16;
if ( v12 > v14 )
*(_DWORD *)(a1 + 228) = v15 + a3 - v12;
memcpy(*(_QWORD *)(a1 + 32), v16, v14 - v15);
v17 = *(_QWORD *)(a1 + 32);
v18 = *(_QWORD *)(a1 + 64);
*(_QWORD *)(a1 + 16) = v17;
*(_QWORD *)(a1 + 24) = v17 + v14 - v15;
*(_QWORD *)(a1 + 56) = v18;
*(_QWORD *)a1 = v15 + v44;
*(_QWORD *)(a1 + 8) += v14;
if ( *(_QWORD *)(a1 + 144) )
PSI_server[44]();
v19 = v12 > v14;
pthread_mutex_unlock(v45);
return v19;
}
v6 = *(_DWORD *)(a1 + 212);
v7 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v38, v6, 8LL);
if ( v7 )
{
v8 = v6;
my_b_seq_read_cold_1(v7, v6, v5, &v39);
v9 = v39;
}
else
{
v8 = v5;
v9 = my_seek(v6, v5, 0LL, 0LL);
}
if ( v9 == -1 )
goto LABEL_30;
*(_DWORD *)(a1 + 224) = 0;
v11 = v5 & 0xFFF;
if ( 0x2000 - v11 <= a3 )
{
v44 = v5;
v20 = ((unsigned int)a3 & 0xFFFFF000) - v11;
v21 = *(_DWORD *)(a1 + 212);
v45 = *(_QWORD *)(a1 + 248);
v22 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v38, v21, 6LL);
if ( v22 )
{
v42 = v22;
((void ( *)(long long, unsigned long long, const char *, long long))PSI_server[66])(
v22,
v20,
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
1385LL);
v23 = my_read(v21, v43, v20, v45);
v8 = 0LL;
v35 = 0LL;
if ( !v23 )
v35 = v20;
if ( v23 != -1 )
v8 = v23;
if ( (v45 & 6) != 0 )
v8 = v35;
((void ( *)(unsigned long long, unsigned long long))PSI_server[67])(v42, v8);
}
else
{
v8 = v43;
v23 = my_read(v21, v43, v20, v45);
}
if ( v23 == -1 )
goto LABEL_30;
v10 = a3 - v23;
v43 += v23;
v44 += v23;
if ( v23 != v20 )
{
LABEL_36:
v45 = a1 + 80;
v12 = v10;
goto LABEL_10;
}
v11 = 0LL;
v5 = v44;
}
else
{
v10 = a3;
}
v24 = *(_QWORD *)(a1 + 8) - v5;
if ( *(_QWORD *)(a1 + 240) - v11 < v24 )
v24 = *(_QWORD *)(a1 + 240) - v11;
if ( !v24 )
{
if ( !v10 )
{
v27 = 0LL;
LABEL_39:
v32 = v27;
v33 = v10;
if ( *(_QWORD *)(a1 + 144) )
PSI_server[44]();
pthread_mutex_unlock(v4);
v34 = *(_QWORD *)(a1 + 32);
*(_QWORD *)(a1 + 16) = v34 + v33;
*(_QWORD *)(a1 + 24) = v34 + v32;
*(_QWORD *)a1 = v5;
memcpy(v43, v34, v33);
return 0;
}
v44 = v5;
goto LABEL_36;
}
v42 = v10;
v44 = v5;
v25 = *(_DWORD *)(a1 + 212);
v41 = *(_QWORD *)(a1 + 32);
v45 = *(_QWORD *)(a1 + 248);
v26 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v38, v25, 6LL);
if ( v26 )
{
v40 = v26;
((void ( *)(long long, unsigned long long, const char *, long long))PSI_server[66])(
v26,
v24,
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
1417LL);
v36 = my_read(v25, v41, v24, v45);
v37 = v36;
v8 = 0LL;
if ( v36 )
v24 = 0LL;
if ( v36 != -1 )
v8 = v36;
if ( (v45 & 6) != 0 )
v8 = v24;
((void ( *)(long long))PSI_server[67])(v40);
v27 = v37;
}
else
{
v8 = v41;
v27 = my_read(v25, v41, v24, v45);
}
v10 = v42;
if ( v27 != -1LL )
{
v12 = v42 - v27;
if ( v42 > v27 )
{
v45 = a1 + 80;
v28 = v43;
v29 = v27;
memcpy(v43, *(_QWORD *)(a1 + 32), v27);
v43 = v29 + v28;
v44 += v29;
goto LABEL_10;
}
v5 = v44;
goto LABEL_39;
}
LABEL_30:
*(_DWORD *)(a1 + 228) = -1;
v30 = *(_QWORD *)(a1 + 144);
if ( v30 )
((void ( *)(long long, unsigned long long, unsigned long long))PSI_server[44])(v30, v8, v10);
pthread_mutex_unlock(v4);
return 1;
}
| _my_b_seq_read:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV R12,RDX
MOV qword ptr [RBP + -0x40],RSI
MOV R14,RDI
LEA R15,[RDI + 0x50]
CMP qword ptr [RDI + 0x90],0x0
JNZ 0x00196903
MOV RDI,R15
CALL 0x00129220
LAB_001965fc:
MOV R13,qword ptr [R14 + 0x18]
SUB R13,qword ptr [R14 + 0x20]
ADD R13,qword ptr [R14]
CMP R13,qword ptr [R14 + 0x8]
JNC 0x0019667f
MOV EBX,dword ptr [R14 + 0xd4]
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0xa8]
MOV ESI,EBX
MOV EDX,0x8
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00196931
MOV EDI,EBX
MOV RSI,R13
XOR EDX,EDX
XOR ECX,ECX
CALL 0x001a0ba0
LAB_00196649:
CMP RAX,-0x1
JZ 0x00196866
MOV dword ptr [R14 + 0xe0],0x0
MOV EAX,R13D
AND EAX,0xfff
MOV ECX,0x2000
SUB RCX,RAX
CMP RCX,R12
JBE 0x00196726
MOV RDX,R12
JMP 0x001967ac
LAB_0019667f:
MOV qword ptr [RBP + -0x38],R13
MOV qword ptr [RBP + -0x30],R15
MOV R13,R12
LAB_0019668a:
MOV RSI,qword ptr [R14 + 0x38]
MOV R15,qword ptr [R14 + 0x40]
SUB R15,RSI
CMP R13,R15
MOV RBX,R15
CMOVC RBX,R13
MOV RDI,qword ptr [RBP + -0x40]
MOV RDX,RBX
CALL 0x00129080
MOV RSI,qword ptr [R14 + 0x38]
ADD RSI,RBX
MOV qword ptr [R14 + 0x38],RSI
CMP R13,R15
JBE 0x001966c9
SUB R12D,R13D
LEA EAX,[RBX + R12*0x1]
MOV dword ptr [R14 + 0xe4],EAX
LAB_001966c9:
MOV RDI,qword ptr [R14 + 0x20]
MOV R12,R15
SUB R12,RBX
MOV RDX,R12
CALL 0x00129080
MOV RAX,qword ptr [R14 + 0x20]
MOV RCX,qword ptr [R14 + 0x40]
MOV qword ptr [R14 + 0x10],RAX
ADD R12,RAX
MOV qword ptr [R14 + 0x18],R12
MOV qword ptr [R14 + 0x38],RCX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RBX
MOV qword ptr [R14],RAX
ADD qword ptr [R14 + 0x8],R15
MOV RDI,qword ptr [R14 + 0x90]
TEST RDI,RDI
JNZ 0x0019691c
LAB_00196710:
XOR EBX,EBX
CMP R13,R15
SETA BL
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x001291e0
JMP 0x0019688e
LAB_00196726:
MOV qword ptr [RBP + -0x38],R13
MOV R13D,R12D
AND R13D,0xfffff000
SUB R13,RAX
MOV EBX,dword ptr [R14 + 0xd4]
MOV RAX,qword ptr [R14 + 0xf8]
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0xa8]
MOV ESI,EBX
MOV EDX,0x6
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00196962
MOV EDI,EBX
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,R13
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x001a09a0
MOV RBX,RAX
LAB_00196785:
CMP RBX,-0x1
JZ 0x00196866
MOV RDX,R12
SUB RDX,RBX
ADD qword ptr [RBP + -0x40],RBX
ADD qword ptr [RBP + -0x38],RBX
CMP RBX,R13
JNZ 0x001968ab
XOR EAX,EAX
MOV R13,qword ptr [RBP + -0x38]
LAB_001967ac:
MOV RBX,qword ptr [R14 + 0x8]
MOV RCX,qword ptr [R14 + 0xf0]
SUB RCX,RAX
SUB RBX,R13
CMP RCX,RBX
CMOVC RBX,RCX
TEST RBX,RBX
JZ 0x001968a2
MOV qword ptr [RBP + -0x48],RDX
MOV qword ptr [RBP + -0x38],R13
MOV R13D,dword ptr [R14 + 0xd4]
MOV RAX,qword ptr [R14 + 0x20]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [R14 + 0xf8]
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0xa8]
MOV ESI,R13D
MOV EDX,0x6
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x001969d7
MOV EDI,R13D
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,RBX
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x001a09a0
LAB_0019682a:
CMP RAX,-0x1
MOV RDX,qword ptr [RBP + -0x48]
JZ 0x00196866
MOV R13,RDX
SUB R13,RAX
JBE 0x001968b7
MOV qword ptr [RBP + -0x30],R15
MOV RSI,qword ptr [R14 + 0x20]
MOV RBX,qword ptr [RBP + -0x40]
MOV RDI,RBX
MOV RDX,RAX
MOV R15,RAX
CALL 0x00129080
ADD RBX,R15
MOV qword ptr [RBP + -0x40],RBX
ADD qword ptr [RBP + -0x38],R15
JMP 0x0019668a
LAB_00196866:
MOV dword ptr [R14 + 0xe4],0xffffffff
MOV RDI,qword ptr [R14 + 0x90]
TEST RDI,RDI
JNZ 0x0019694d
LAB_00196881:
MOV RDI,R15
CALL 0x001291e0
MOV EBX,0x1
LAB_0019688e:
MOV EAX,EBX
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001968a2:
TEST RDX,RDX
JZ 0x001968bd
MOV qword ptr [RBP + -0x38],R13
LAB_001968ab:
MOV qword ptr [RBP + -0x30],R15
MOV R13,RDX
JMP 0x0019668a
LAB_001968b7:
MOV R13,qword ptr [RBP + -0x38]
JMP 0x001968bf
LAB_001968bd:
XOR EAX,EAX
LAB_001968bf:
MOV R12,RAX
MOV RBX,RDX
MOV RDI,qword ptr [R14 + 0x90]
TEST RDI,RDI
JNZ 0x00196a4b
LAB_001968d5:
MOV RDI,R15
CALL 0x001291e0
MOV RSI,qword ptr [R14 + 0x20]
MOV RDX,RBX
LEA RAX,[RSI + RBX*0x1]
MOV qword ptr [R14 + 0x10],RAX
ADD R12,RSI
MOV qword ptr [R14 + 0x18],R12
MOV qword ptr [R14],R13
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x00129080
XOR EBX,EBX
JMP 0x0019688e
LAB_00196903:
LEA RSI,[0x1dc32f]
MOV RDI,R15
MOV EDX,0x54c
CALL 0x0012eb8f
JMP 0x001965fc
LAB_0019691c:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00196710
LAB_00196931:
LEA RCX,[RBP + -0x60]
MOV RDI,RAX
MOV ESI,EBX
MOV RDX,R13
MOV RBX,RCX
CALL 0x0012ea93
MOV RAX,qword ptr [RBX]
JMP 0x00196649
LAB_0019694d:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00196881
LAB_00196962:
MOV RCX,RAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDX,[0x1dc32f]
MOV qword ptr [RBP + -0x48],RCX
MOV RDI,RCX
MOV RSI,R13
MOV ECX,0x569
CALL qword ptr [RAX + 0x210]
MOV EDI,EBX
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,R13
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x001a09a0
MOV RBX,RAX
XOR ESI,ESI
TEST RAX,RAX
MOV EAX,0x0
CMOVZ RAX,R13
CMP RBX,-0x1
CMOVNZ RSI,RBX
TEST byte ptr [RBP + -0x30],0x6
CMOVNZ RSI,RAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x48]
CALL qword ptr [RAX + 0x218]
JMP 0x00196785
LAB_001969d7:
MOV RCX,RAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDX,[0x1dc32f]
MOV qword ptr [RBP + -0x58],RCX
MOV RDI,RCX
MOV RSI,RBX
MOV ECX,0x589
CALL qword ptr [RAX + 0x210]
MOV EDI,R13D
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,RBX
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x001a09a0
MOV R13,RAX
XOR ESI,ESI
TEST RAX,RAX
CMOVNZ RBX,RSI
CMP RAX,-0x1
CMOVNZ RSI,RAX
TEST byte ptr [RBP + -0x30],0x6
CMOVNZ RSI,RBX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x58]
CALL qword ptr [RAX + 0x218]
MOV RAX,R13
JMP 0x0019682a
LAB_00196a4b:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x001968d5
|
bool _my_b_seq_read(ulong *param_1,void *param_2,ulong param_3)
{
int4 uVar1;
void *pvVar2;
pthread_mutex_t *__mutex;
long lVar3;
long lVar4;
ulong __n;
long lVar5;
ulong uVar6;
long lVar7;
uint uVar8;
ulong uVar9;
ulong uVar10;
int1 local_b0 [72];
long local_68;
long local_60;
ulong local_58;
ulong local_50;
void *local_48;
ulong local_40;
pthread_mutex_t *local_38;
__mutex = (pthread_mutex_t *)(param_1 + 10);
local_48 = param_2;
if (param_1[0x12] == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x54c);
}
uVar9 = (param_1[3] - param_1[4]) + *param_1;
uVar8 = (uint)param_3;
if (uVar9 < param_1[1]) {
uVar1 = *(int4 *)((long)param_1 + 0xd4);
lVar3 = (**(code **)(PSI_server + 0x158))(local_b0,uVar1,8);
if (lVar3 == 0) {
local_68 = my_seek(uVar1,uVar9,0,0);
}
else {
_my_b_seq_read_cold_1(lVar3,uVar1,uVar9);
}
if (local_68 == -1) {
LAB_00196866:
*(int4 *)((long)param_1 + 0xe4) = 0xffffffff;
if (param_1[0x12] != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
return true;
}
*(int4 *)(param_1 + 0x1c) = 0;
uVar10 = (ulong)((uint)uVar9 & 0xfff);
if (0x2000 - uVar10 <= param_3) {
lVar3 = (uVar8 & 0xfffff000) - uVar10;
uVar1 = *(int4 *)((long)param_1 + 0xd4);
local_38 = (pthread_mutex_t *)param_1[0x1f];
local_40 = uVar9;
uVar9 = (**(code **)(PSI_server + 0x158))(local_b0,uVar1,6);
if (uVar9 == 0) {
lVar4 = my_read(uVar1,local_48,lVar3,local_38);
}
else {
local_50 = uVar9;
(**(code **)(PSI_server + 0x210))
(uVar9,lVar3,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x569);
lVar4 = my_read(uVar1,local_48,lVar3,local_38);
lVar5 = 0;
if (lVar4 == 0) {
lVar5 = lVar3;
}
lVar7 = 0;
if (lVar4 != -1) {
lVar7 = lVar4;
}
if (((ulong)local_38 & 6) != 0) {
lVar7 = lVar5;
}
(**(code **)(PSI_server + 0x218))(local_50,lVar7);
}
if (lVar4 == -1) goto LAB_00196866;
param_3 = param_3 - lVar4;
local_48 = (void *)((long)local_48 + lVar4);
uVar9 = local_40 + lVar4;
if (lVar4 != lVar3) goto LAB_0019668a;
uVar10 = 0;
local_40 = uVar9;
}
uVar6 = param_1[1] - uVar9;
if (param_1[0x1e] - uVar10 < param_1[1] - uVar9) {
uVar6 = param_1[0x1e] - uVar10;
}
if (uVar6 == 0) {
if (param_3 == 0) {
__n = 0;
uVar10 = param_3;
LAB_001968bf:
if (param_1[0x12] != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
pvVar2 = (void *)param_1[4];
param_1[2] = (long)pvVar2 + uVar10;
param_1[3] = __n + (long)pvVar2;
*param_1 = uVar9;
memcpy(local_48,pvVar2,uVar10);
return false;
}
}
else {
uVar1 = *(int4 *)((long)param_1 + 0xd4);
local_58 = param_1[4];
local_38 = (pthread_mutex_t *)param_1[0x1f];
local_50 = param_3;
local_40 = uVar9;
lVar3 = (**(code **)(PSI_server + 0x158))(local_b0,uVar1,6);
if (lVar3 == 0) {
__n = my_read(uVar1,local_58,uVar6,local_38);
}
else {
local_60 = lVar3;
(**(code **)(PSI_server + 0x210))
(lVar3,uVar6,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x589);
__n = my_read(uVar1,local_58,uVar6,local_38);
if (__n != 0) {
uVar6 = 0;
}
uVar9 = 0;
if (__n != 0xffffffffffffffff) {
uVar9 = __n;
}
if (((ulong)local_38 & 6) != 0) {
uVar9 = uVar6;
}
(**(code **)(PSI_server + 0x218))(local_60,uVar9);
}
pvVar2 = local_48;
if (__n == 0xffffffffffffffff) goto LAB_00196866;
param_3 = local_50 - __n;
uVar10 = local_50;
uVar9 = local_40;
if (local_50 < __n || param_3 == 0) goto LAB_001968bf;
local_38 = __mutex;
memcpy(local_48,(void *)param_1[4],__n);
local_48 = (void *)((long)pvVar2 + __n);
uVar9 = local_40 + __n;
__mutex = local_38;
}
}
LAB_0019668a:
local_38 = __mutex;
local_40 = uVar9;
uVar10 = param_1[8] - (long)param_1[7];
uVar9 = uVar10;
if (param_3 < uVar10) {
uVar9 = param_3;
}
memcpy(local_48,(void *)param_1[7],uVar9);
uVar6 = param_1[7];
param_1[7] = uVar6 + uVar9;
if (uVar10 < param_3) {
*(uint *)((long)param_1 + 0xe4) = (int)uVar9 + (uVar8 - (int)param_3);
}
memcpy((void *)param_1[4],(void *)(uVar6 + uVar9),uVar10 - uVar9);
param_1[2] = param_1[4];
param_1[3] = (uVar10 - uVar9) + param_1[4];
param_1[7] = param_1[8];
*param_1 = local_40 + uVar9;
param_1[1] = param_1[1] + uVar10;
if (param_1[0x12] != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(local_38);
return uVar10 < param_3;
}
| |
45,622 | glfwWaitEventsTimeout | untodesu[P]riteg/build_O2/_deps/glfw-src/src/window.c | GLFWAPI void glfwWaitEventsTimeout(double timeout)
{
_GLFW_REQUIRE_INIT();
assert(timeout == timeout);
assert(timeout >= 0.0);
assert(timeout <= DBL_MAX);
if (timeout != timeout || timeout < 0.0 || timeout > DBL_MAX)
{
_glfwInputError(GLFW_INVALID_VALUE, "Invalid time %f", timeout);
return;
}
_glfwPlatformWaitEventsTimeout(timeout);
} | O2 | c | glfwWaitEventsTimeout:
pushq %rax
leaq 0x81012(%rip), %rax # 0x9b648
cmpl $0x0, (%rax)
je 0x1a677
ucomisd %xmm0, %xmm0
jp 0x1a68c
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1a6ab
movsd 0x5756d(%rip), %xmm1 # 0x71bc0
ucomisd %xmm0, %xmm1
jb 0x1a6ca
ucomisd 0x5755f(%rip), %xmm0 # 0x71bc0
jbe 0x1a686
leaq 0x57d1d(%rip), %rsi # 0x72387
movl $0x10004, %edi # imm = 0x10004
movb $0x1, %al
popq %rcx
jmp 0x1547b
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
popq %rcx
jmp 0x1547b
popq %rax
jmp 0x20562
leaq 0x59694(%rip), %rdi # 0x73d27
leaq 0x58bb8(%rip), %rsi # 0x73252
leaq 0x59699(%rip), %rcx # 0x73d3a
movl $0x43a, %edx # imm = 0x43A
callq 0xb510
leaq 0x596ab(%rip), %rdi # 0x73d5d
leaq 0x58b99(%rip), %rsi # 0x73252
leaq 0x5967a(%rip), %rcx # 0x73d3a
movl $0x43b, %edx # imm = 0x43B
callq 0xb510
leaq 0x5969b(%rip), %rdi # 0x73d6c
leaq 0x58b7a(%rip), %rsi # 0x73252
leaq 0x5965b(%rip), %rcx # 0x73d3a
movl $0x43c, %edx # imm = 0x43C
callq 0xb510
| glfwWaitEventsTimeout:
push rax
lea rax, _glfw
cmp dword ptr [rax], 0
jz short loc_1A677
ucomisd xmm0, xmm0
jp short loc_1A68C
xorpd xmm1, xmm1
ucomisd xmm0, xmm1
jb short loc_1A6AB
movsd xmm1, cs:qword_71BC0
ucomisd xmm1, xmm0
jb short loc_1A6CA
ucomisd xmm0, cs:qword_71BC0
jbe short loc_1A686
lea rsi, aInvalidTimeF; "Invalid time %f"
mov edi, 10004h
mov al, 1
pop rcx
jmp _glfwInputError
loc_1A677:
mov edi, 10001h
xor esi, esi
xor eax, eax
pop rcx
jmp _glfwInputError
loc_1A686:
pop rax
jmp _glfwPlatformWaitEventsTimeout
loc_1A68C:
lea rdi, aTimeoutTimeout; "timeout == timeout"
lea rsi, aWorkspaceLlm4b_15; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGlfwwaitev; "void glfwWaitEventsTimeout(double)"
mov edx, 43Ah
call ___assert_fail
loc_1A6AB:
lea rdi, aTimeout00; "timeout >= 0.0"
lea rsi, aWorkspaceLlm4b_15; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGlfwwaitev; "void glfwWaitEventsTimeout(double)"
mov edx, 43Bh
call ___assert_fail
loc_1A6CA:
lea rdi, aTimeoutDblMax; "timeout <= DBL_MAX"
lea rsi, aWorkspaceLlm4b_15; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGlfwwaitev; "void glfwWaitEventsTimeout(double)"
mov edx, 43Ch
call ___assert_fail
| long long ( * glfwWaitEventsTimeout(double a1))(_QWORD, _QWORD)
{
if ( !glfw[0] )
return glfwInputError(0x10001u, 0LL);
if ( a1 < 0.0 )
__assert_fail(
"timeout >= 0.0",
"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/build_O2/_deps/glfw-src/src/window.c",
1083LL,
"void glfwWaitEventsTimeout(double)");
if ( a1 > 1.797693134862316e308 )
__assert_fail(
"timeout <= DBL_MAX",
"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/build_O2/_deps/glfw-src/src/window.c",
1084LL,
"void glfwWaitEventsTimeout(double)");
return (long long ( *)(_QWORD, _QWORD))glfwPlatformWaitEventsTimeout();
}
| glfwWaitEventsTimeout:
PUSH RAX
LEA RAX,[0x19b648]
CMP dword ptr [RAX],0x0
JZ 0x0011a677
UCOMISD XMM0,XMM0
JP 0x0011a68c
XORPD XMM1,XMM1
UCOMISD XMM0,XMM1
JC 0x0011a6ab
MOVSD XMM1,qword ptr [0x00171bc0]
UCOMISD XMM1,XMM0
JC 0x0011a6ca
UCOMISD XMM0,qword ptr [0x00171bc0]
JBE 0x0011a686
LEA RSI,[0x172387]
MOV EDI,0x10004
MOV AL,0x1
POP RCX
JMP 0x0011547b
LAB_0011a677:
MOV EDI,0x10001
XOR ESI,ESI
XOR EAX,EAX
POP RCX
JMP 0x0011547b
LAB_0011a686:
POP RAX
JMP 0x00120562
LAB_0011a68c:
LEA RDI,[0x173d27]
LEA RSI,[0x173252]
LEA RCX,[0x173d3a]
MOV EDX,0x43a
CALL 0x0010b510
LAB_0011a6ab:
LEA RDI,[0x173d5d]
LEA RSI,[0x173252]
LEA RCX,[0x173d3a]
MOV EDX,0x43b
CALL 0x0010b510
LAB_0011a6ca:
LEA RDI,[0x173d6c]
LEA RSI,[0x173252]
LEA RCX,[0x173d3a]
MOV EDX,0x43c
CALL 0x0010b510
|
void glfwWaitEventsTimeout(double param_1,int8 param_2,int8 param_3,int8 param_4)
{
int8 in_RAX;
if (_glfw == 0) {
_glfwInputError(0x10001,0,param_4,in_RAX);
return;
}
if (NAN(param_1)) {
/* WARNING: Subroutine does not return */
__assert_fail("timeout == timeout",
"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/build_O2/_deps/glfw-src/src/window.c"
,0x43a,"void glfwWaitEventsTimeout(double)");
}
if (param_1 < 0.0) {
/* WARNING: Subroutine does not return */
__assert_fail("timeout >= 0.0",
"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/build_O2/_deps/glfw-src/src/window.c"
,0x43b,"void glfwWaitEventsTimeout(double)");
}
if (param_1 <= DAT_00171bc0) {
if (DAT_00171bc0 < param_1) {
_glfwInputError(0x10004,"Invalid time %f",param_4,in_RAX);
return;
}
_glfwPlatformWaitEventsTimeout();
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("timeout <= DBL_MAX",
"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/build_O2/_deps/glfw-src/src/window.c"
,0x43c,"void glfwWaitEventsTimeout(double)");
}
| |
45,623 | void fmt::v10::detail::parse_format_string<false, char, void fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char>&, fmt::v10::basic_string_view<char>, fmt::v10::detail::vformat_args<char>::type, fmt::v10::detail::locale_ref)::format_handler>(fmt::v10::basic_string_view<char>, void fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char>&, fmt::v10::basic_string_view<char>, fmt::v10::detail::vformat_args<char>::type, fmt::v10::detail::locale_ref)::format_handler&&)::writer::operator()(char const*, char const*) | aimrt_mujoco_sim/_deps/fmt-src/include/fmt/core.h | FMT_CONSTEXPR void operator()(const Char* from, const Char* to) {
if (from == to) return;
for (;;) {
const Char* p = nullptr;
if (!find<IS_CONSTEXPR>(from, to, Char('}'), p))
return handler_.on_text(from, to);
++p;
if (p == to || *p != '}')
return handler_.on_error("unmatched '}' in format string");
handler_.on_text(from, p);
from = p + 1;
}
} | O0 | c | void fmt::v10::detail::parse_format_string<false, char, void fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char>&, fmt::v10::basic_string_view<char>, fmt::v10::detail::vformat_args<char>::type, fmt::v10::detail::locale_ref)::format_handler>(fmt::v10::basic_string_view<char>, void fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char>&, fmt::v10::basic_string_view<char>, fmt::v10::detail::vformat_args<char>::type, fmt::v10::detail::locale_ref)::format_handler&&)::writer::operator()(char const*, char const*):
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0xbbb0d
jmp 0xbbbb0
jmp 0xbbb0f
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x7d, %edx
leaq 0x8(%rsp), %rcx
callq 0xbba70
testb $0x1, %al
jne 0xbbb4d
movq (%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xbad40
jmp 0xbbbb0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0xbbb74
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x7d, %eax
je 0xbbb87
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0xf23c6(%rip), %rsi # 0x1adf48
callq 0xbba50
movq (%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xbad40
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xbbb0f
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| _ZZN3fmt3v106detail19parse_format_stringILb0EcZNS1_10vformat_toIcEEvRNS1_6bufferIT_EENS0_17basic_string_viewIS5_EENS1_12vformat_argsIS5_E4typeENS1_10locale_refEE14format_handlerEEvNS8_IT0_EEOT1_EN6writerclEPKcSL_:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
mov [rsp+28h+var_18], rdx
mov rax, [rsp+28h+var_8]
mov [rsp+28h+var_28], rax
mov rax, [rsp+28h+var_10]
cmp rax, [rsp+28h+var_18]
jnz short loc_BBB0D
jmp loc_BBBB0
loc_BBB0D:
jmp short $+2
loc_BBB0F:
mov [rsp+28h+var_20], 0
mov rdi, [rsp+28h+var_10]
mov rsi, [rsp+28h+var_18]
mov edx, 7Dh ; '}'
lea rcx, [rsp+28h+var_20]
call _ZN3fmt3v106detail4findILb0EcPKcEEbT1_S5_T0_RS5_; fmt::v10::detail::find<false,char,char const*>(char const*,char const*,char,char const*&)
test al, 1
jnz short loc_BBB4D
mov rax, [rsp+28h+var_28]
mov rdi, [rax]
mov rsi, [rsp+28h+var_10]
mov rdx, [rsp+28h+var_18]
call _ZZN3fmt3v106detail10vformat_toIcEEvRNS1_6bufferIT_EENS0_17basic_string_viewIS4_EENS1_12vformat_argsIS4_E4typeENS1_10locale_refEEN14format_handler7on_textEPKcSF_; fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char> &,fmt::v10::basic_string_view<char>,fmt::v10::detail::vformat_args<char>::type,fmt::v10::detail::locale_ref)::format_handler::on_text(char const*,char const*)
jmp short loc_BBBB0
loc_BBB4D:
mov rax, [rsp+28h+var_20]
add rax, 1
mov [rsp+28h+var_20], rax
mov rax, [rsp+28h+var_20]
cmp rax, [rsp+28h+var_18]
jz short loc_BBB74
mov rax, [rsp+28h+var_20]
movsx eax, byte ptr [rax]
cmp eax, 7Dh ; '}'
jz short loc_BBB87
loc_BBB74:
mov rax, [rsp+28h+var_28]
mov rdi, [rax]; this
lea rsi, aUnmatchedInFor; "unmatched '}' in format string"
call _ZN3fmt3v106detail13error_handler8on_errorEPKc; fmt::v10::detail::error_handler::on_error(char const*)
loc_BBB87:
mov rax, [rsp+28h+var_28]
mov rdi, [rax]
mov rsi, [rsp+28h+var_10]
mov rdx, [rsp+28h+var_20]
call _ZZN3fmt3v106detail10vformat_toIcEEvRNS1_6bufferIT_EENS0_17basic_string_viewIS4_EENS1_12vformat_argsIS4_E4typeENS1_10locale_refEEN14format_handler7on_textEPKcSF_; fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char> &,fmt::v10::basic_string_view<char>,fmt::v10::detail::vformat_args<char>::type,fmt::v10::detail::locale_ref)::format_handler::on_text(char const*,char const*)
mov rax, [rsp+28h+var_20]
add rax, 1
mov [rsp+28h+var_10], rax
jmp loc_BBB0F
loc_BBBB0:
add rsp, 28h
retn
| long long fmt::v10::detail::parse_format_string<false,char,void fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char> &,fmt::v10::basic_string_view<char>,fmt::v10::detail::vformat_args<char>::type,fmt::v10::detail::locale_ref)::format_handler>(fmt::v10::basic_string_view<char>,void fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char> &,fmt::v10::basic_string_view<char>,fmt::v10::detail::vformat_args<char>::type,fmt::v10::detail::locale_ref)::format_handler &&)::writer::operator()(
fmt::v10::detail::error_handler **a1,
long long a2,
long long a3)
{
long long result; // rax
_BYTE *v4; // [rsp+8h] [rbp-20h] BYREF
_BYTE *v5; // [rsp+10h] [rbp-18h]
_BYTE *v6; // [rsp+18h] [rbp-10h]
fmt::v10::detail::error_handler **v7; // [rsp+20h] [rbp-8h]
v7 = a1;
v6 = (_BYTE *)a2;
v5 = (_BYTE *)a3;
result = a2;
if ( a2 != a3 )
{
while ( 1 )
{
v4 = 0LL;
if ( !fmt::v10::detail::find<false,char,char const*>((long long)v6, (long long)v5, 125, &v4) )
break;
if ( ++v4 == v5 || *v4 != 125 )
fmt::v10::detail::error_handler::on_error(*a1, (fmt::v10::detail *)"unmatched '}' in format string");
fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char> &,fmt::v10::basic_string_view<char>,fmt::v10::detail::vformat_args<char>::type,fmt::v10::detail::locale_ref)::format_handler::on_text(
(long long)*a1,
(long long)v6,
(long long)v4);
v6 = v4 + 1;
}
return fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char> &,fmt::v10::basic_string_view<char>,fmt::v10::detail::vformat_args<char>::type,fmt::v10::detail::locale_ref)::format_handler::on_text(
(long long)*a1,
(long long)v6,
(long long)v5);
}
return result;
}
| operator():
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [RSP + 0x18]
CMP RAX,qword ptr [RSP + 0x10]
JNZ 0x001bbb0d
JMP 0x001bbbb0
LAB_001bbb0d:
JMP 0x001bbb0f
LAB_001bbb0f:
MOV qword ptr [RSP + 0x8],0x0
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x10]
MOV EDX,0x7d
LEA RCX,[RSP + 0x8]
CALL 0x001bba70
TEST AL,0x1
JNZ 0x001bbb4d
MOV RAX,qword ptr [RSP]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x10]
CALL 0x001bad40
JMP 0x001bbbb0
LAB_001bbb4d:
MOV RAX,qword ptr [RSP + 0x8]
ADD RAX,0x1
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x8]
CMP RAX,qword ptr [RSP + 0x10]
JZ 0x001bbb74
MOV RAX,qword ptr [RSP + 0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x7d
JZ 0x001bbb87
LAB_001bbb74:
MOV RAX,qword ptr [RSP]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x2adf48]
CALL 0x001bba50
LAB_001bbb87:
MOV RAX,qword ptr [RSP]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x8]
CALL 0x001bad40
MOV RAX,qword ptr [RSP + 0x8]
ADD RAX,0x1
MOV qword ptr [RSP + 0x18],RAX
JMP 0x001bbb0f
LAB_001bbbb0:
ADD RSP,0x28
RET
|
/* fmt::v10::detail::parse_format_string<false, char,
fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char>&,
fmt::v10::basic_string_view<char>, fmt::v10::detail::vformat_args<char>::type,
fmt::v10::detail::locale_ref)::format_handler>(fmt::v10::basic_string_view<char>,
fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char>&,
fmt::v10::basic_string_view<char>, fmt::v10::detail::vformat_args<char>::type,
fmt::v10::detail::locale_ref)::format_handler&&)::writer::TEMPNAMEPLACEHOLDERVALUE(char const*,
char const*) */
void __thiscall
fmt::v10::detail::
parse_format_string<false,char,fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char>&,fmt::v10::basic_string_view<char>,fmt::v10::detail::vformat_args<char>::type,fmt::v10::detail::locale_ref)::format_handler>(fmt::v10::basic_string_view<char>,fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char>&,fmt::v10::basic_string_view<char>,fmt::v10::detail::vformat_args<char>::type,fmt::v10::detail::locale_ref)::format_handler&&)
::writer::operator()(writer *this,char *param_1,char *param_2)
{
bool bVar1;
char *local_20;
char *local_18;
char *local_10;
writer *local_8;
local_18 = param_2;
local_10 = param_1;
local_8 = this;
if (param_1 != param_2) {
while( true ) {
local_20 = (char *)0x0;
bVar1 = find<false,char,char_const*>(local_10,local_18,'}',&local_20);
if (!bVar1) break;
local_20 = local_20 + 1;
if ((local_20 == local_18) || (*local_20 != '}')) {
error_handler::on_error(*(error_handler **)this,"unmatched \'}\' in format string");
}
vformat_to<char>(fmt::v10::detail::buffer<char>&,fmt::v10::basic_string_view<char>,fmt::v10::detail::vformat_args<char>::type,fmt::v10::detail::locale_ref)
::format_handler::on_text(*(format_handler **)this,local_10,local_20);
local_10 = local_20 + 1;
}
vformat_to<char>(fmt::v10::detail::buffer<char>&,fmt::v10::basic_string_view<char>,fmt::v10::detail::vformat_args<char>::type,fmt::v10::detail::locale_ref)
::format_handler::on_text(*(format_handler **)this,local_10,local_18);
}
return;
}
| |
45,624 | void fmt::v10::detail::parse_format_string<false, char, void fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char>&, fmt::v10::basic_string_view<char>, fmt::v10::detail::vformat_args<char>::type, fmt::v10::detail::locale_ref)::format_handler>(fmt::v10::basic_string_view<char>, void fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char>&, fmt::v10::basic_string_view<char>, fmt::v10::detail::vformat_args<char>::type, fmt::v10::detail::locale_ref)::format_handler&&)::writer::operator()(char const*, char const*) | aimrt_mujoco_sim/_deps/fmt-src/include/fmt/core.h | FMT_CONSTEXPR void operator()(const Char* from, const Char* to) {
if (from == to) return;
for (;;) {
const Char* p = nullptr;
if (!find<IS_CONSTEXPR>(from, to, Char('}'), p))
return handler_.on_text(from, to);
++p;
if (p == to || *p != '}')
return handler_.on_error("unmatched '}' in format string");
handler_.on_text(from, p);
from = p + 1;
}
} | O3 | c | void fmt::v10::detail::parse_format_string<false, char, void fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char>&, fmt::v10::basic_string_view<char>, fmt::v10::detail::vformat_args<char>::type, fmt::v10::detail::locale_ref)::format_handler>(fmt::v10::basic_string_view<char>, void fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char>&, fmt::v10::basic_string_view<char>, fmt::v10::detail::vformat_args<char>::type, fmt::v10::detail::locale_ref)::format_handler&&)::writer::operator()(char const*, char const*):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpq %rdx, %rsi
je 0x2f1a7
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %r13
subq %rsi, %r13
movq %rsi, %rdi
movl $0x7d, %esi
movq %r13, %rdx
callq 0x1f3d0
testq %rax, %rax
je 0x2f18e
movq %rax, %r12
leaq 0x1(%r12), %rsi
cmpq %r15, %rsi
je 0x2f1b1
cmpb $0x7d, (%rsi)
jne 0x2f1b1
movq (%rbx), %r13
subq %r14, %rsi
movq 0x18(%r13), %rdx
addq %r14, %rsi
movq %r14, %rdi
callq 0x2e43b
movq %rax, 0x18(%r13)
movq %r12, %r14
addq $0x2, %r14
movq %r15, %r13
subq %r14, %r13
movq %r14, %rdi
movl $0x7d, %esi
movq %r13, %rdx
callq 0x1f3d0
movq %rax, %r12
testq %rax, %rax
jne 0x2f141
movq (%rbx), %rbx
movq 0x18(%rbx), %rdx
addq %r14, %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x2e43b
movq %rax, 0x18(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x54812(%rip), %rdi # 0x839ca
callq 0x254fc
nop
| _ZZN3fmt3v106detail19parse_format_stringILb0EcZNS1_10vformat_toIcEEvRNS1_6bufferIT_EENS0_17basic_string_viewIS5_EENS1_12vformat_argsIS5_E4typeENS1_10locale_refEE14format_handlerEEvNS8_IT0_EEOT1_EN6writerclEPKcSL_:
push r15
push r14
push r13
push r12
push rbx
cmp rsi, rdx
jz loc_2F1A7
mov r15, rdx
mov r14, rsi
mov rbx, rdi
mov r13, rdx
sub r13, rsi
mov rdi, rsi
mov esi, 7Dh ; '}'
mov rdx, r13
call _memchr
test rax, rax
jz short loc_2F18E
mov r12, rax
loc_2F141:
lea rsi, [r12+1]; char *
cmp rsi, r15
jz short loc_2F1B1
cmp byte ptr [rsi], 7Dh ; '}'
jnz short loc_2F1B1
mov r13, [rbx]
sub rsi, r14
mov rdx, [r13+18h]
add rsi, r14
mov rdi, r14
call _ZN3fmt3v106detail17copy_str_noinlineIcPKcNS0_8appenderEEET1_T0_S7_S6_; fmt::v10::detail::copy_str_noinline<char,char const*,fmt::v10::appender>(char const*,char const*,fmt::v10::appender)
mov [r13+18h], rax
mov r14, r12
add r14, 2
mov r13, r15
sub r13, r14
mov rdi, r14
mov esi, 7Dh ; '}'
mov rdx, r13
call _memchr
mov r12, rax
test rax, rax
jnz short loc_2F141
loc_2F18E:
mov rbx, [rbx]
mov rdx, [rbx+18h]
add r13, r14
mov rdi, r14
mov rsi, r13
call _ZN3fmt3v106detail17copy_str_noinlineIcPKcNS0_8appenderEEET1_T0_S7_S6_; fmt::v10::detail::copy_str_noinline<char,char const*,fmt::v10::appender>(char const*,char const*,fmt::v10::appender)
mov [rbx+18h], rax
loc_2F1A7:
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_2F1B1:
lea rdi, aUnmatchedInFor; "unmatched '}' in format string"
call _ZN3fmt3v106detail18throw_format_errorEPKc; fmt::v10::detail::throw_format_error(char const*)
| void fmt::v10::detail::parse_format_string<false,char,void fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char> &,fmt::v10::basic_string_view<char>,fmt::v10::detail::vformat_args<char>::type,fmt::v10::detail::locale_ref)::format_handler>(fmt::v10::basic_string_view<char>,void fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char> &,fmt::v10::basic_string_view<char>,fmt::v10::detail::vformat_args<char>::type,fmt::v10::detail::locale_ref)::format_handler &&)::writer::operator()(
long long *a1,
long long a2,
long long a3)
{
long long v4; // r14
long long v5; // r13
long long v6; // rax
long long v7; // r12
const char *v8; // rsi
long long v9; // r13
long long v10; // rbx
if ( a2 != a3 )
{
v4 = a2;
v5 = a3 - a2;
v6 = memchr(a2, 125LL, a3 - a2);
if ( v6 )
{
v7 = v6;
do
{
v8 = (const char *)(v7 + 1);
if ( v7 + 1 == a3 || *v8 != 125 )
fmt::v10::detail::throw_format_error((fmt::v10::detail *)"unmatched '}' in format string", v8);
v9 = *a1;
*(_QWORD *)(v9 + 24) = fmt::v10::detail::copy_str_noinline<char,char const*,fmt::v10::appender>(
v4,
(long long)v8,
*(_QWORD *)(*a1 + 24));
v4 = v7 + 2;
v5 = a3 - (v7 + 2);
v7 = memchr(v7 + 2, 125LL, v5);
}
while ( v7 );
}
v10 = *a1;
*(_QWORD *)(v10 + 24) = fmt::v10::detail::copy_str_noinline<char,char const*,fmt::v10::appender>(
v4,
v4 + v5,
*(_QWORD *)(v10 + 24));
}
}
| operator():
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
CMP RSI,RDX
JZ 0x0012f1a7
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
MOV R13,RDX
SUB R13,RSI
MOV RDI,RSI
MOV ESI,0x7d
MOV RDX,R13
CALL 0x0011f3d0
TEST RAX,RAX
JZ 0x0012f18e
MOV R12,RAX
LAB_0012f141:
LEA RSI,[R12 + 0x1]
CMP RSI,R15
JZ 0x0012f1b1
CMP byte ptr [RSI],0x7d
JNZ 0x0012f1b1
MOV R13,qword ptr [RBX]
SUB RSI,R14
MOV RDX,qword ptr [R13 + 0x18]
ADD RSI,R14
MOV RDI,R14
CALL 0x0012e43b
MOV qword ptr [R13 + 0x18],RAX
MOV R14,R12
ADD R14,0x2
MOV R13,R15
SUB R13,R14
MOV RDI,R14
MOV ESI,0x7d
MOV RDX,R13
CALL 0x0011f3d0
MOV R12,RAX
TEST RAX,RAX
JNZ 0x0012f141
LAB_0012f18e:
MOV RBX,qword ptr [RBX]
MOV RDX,qword ptr [RBX + 0x18]
ADD R13,R14
MOV RDI,R14
MOV RSI,R13
CALL 0x0012e43b
MOV qword ptr [RBX + 0x18],RAX
LAB_0012f1a7:
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_0012f1b1:
LEA RDI,[0x1839ca]
CALL 0x001254fc
|
/* fmt::v10::detail::parse_format_string<false, char,
fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char>&,
fmt::v10::basic_string_view<char>, fmt::v10::detail::vformat_args<char>::type,
fmt::v10::detail::locale_ref)::format_handler>(fmt::v10::basic_string_view<char>,
fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char>&,
fmt::v10::basic_string_view<char>, fmt::v10::detail::vformat_args<char>::type,
fmt::v10::detail::locale_ref)::format_handler&&)::writer::TEMPNAMEPLACEHOLDERVALUE(char const*,
char const*) */
void __thiscall
fmt::v10::detail::
parse_format_string<false,char,fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char>&,fmt::v10::basic_string_view<char>,fmt::v10::detail::vformat_args<char>::type,fmt::v10::detail::locale_ref)::format_handler>(fmt::v10::basic_string_view<char>,fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char>&,fmt::v10::basic_string_view<char>,fmt::v10::detail::vformat_args<char>::type,fmt::v10::detail::locale_ref)::format_handler&&)
::writer::operator()(writer *this,char *param_1,char *param_2)
{
char *pcVar1;
long lVar2;
void *pvVar3;
int8 uVar4;
size_t __n;
if (param_1 != param_2) {
__n = (long)param_2 - (long)param_1;
pvVar3 = memchr(param_1,0x7d,__n);
while (pvVar3 != (void *)0x0) {
pcVar1 = (char *)((long)pvVar3 + 1);
if ((pcVar1 == param_2) || (*pcVar1 != '}')) {
/* WARNING: Subroutine does not return */
throw_format_error("unmatched \'}\' in format string");
}
lVar2 = *(long *)this;
uVar4 = copy_str_noinline<char,char_const*,fmt::v10::appender>
(param_1,pcVar1,*(int8 *)(lVar2 + 0x18));
*(int8 *)(lVar2 + 0x18) = uVar4;
param_1 = (char *)((long)pvVar3 + 2);
__n = (long)param_2 - (long)param_1;
pvVar3 = memchr(param_1,0x7d,__n);
}
lVar2 = *(long *)this;
uVar4 = copy_str_noinline<char,char_const*,fmt::v10::appender>
(param_1,param_1 + __n,*(int8 *)(lVar2 + 0x18));
*(int8 *)(lVar2 + 0x18) = uVar4;
}
return;
}
| |
45,625 | LefDefParser::defiGroup::propNumber(int) const | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiGroup.cpp | double defiGroup::propNumber(int index) const {
char msg[160];
if (index < 0 || index >= numProps_) {
sprintf (msg, "ERROR (LEFPARS-6050): The index number %d given for the GROUP PROPERTY is invalid.\nValid index is from 0 to %d", index, numProps_);
defiError(0, 6050, msg, defData);
return 0;
}
return propDValues_[index];
} | O0 | cpp | LefDefParser::defiGroup::propNumber(int) const:
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movl %esi, 0xb4(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0xb4(%rsp)
jl 0x4d57e
movq 0x8(%rsp), %rcx
movl 0xb4(%rsp), %eax
cmpl 0x5c(%rcx), %eax
jl 0x4d5cb
movq 0x8(%rsp), %rax
leaq 0x10(%rsp), %rdi
movl 0xb4(%rsp), %edx
movl 0x5c(%rax), %ecx
leaq 0x28949(%rip), %rsi # 0x75ee2
movb $0x0, %al
callq 0x7060
movq 0x8(%rsp), %rax
leaq 0x10(%rsp), %rdx
movq 0x88(%rax), %rcx
xorl %edi, %edi
movl $0x17a2, %esi # imm = 0x17A2
callq 0x2a600
xorps %xmm0, %xmm0
movsd %xmm0, 0xc0(%rsp)
jmp 0x4d5ea
movq 0x8(%rsp), %rax
movq 0x78(%rax), %rax
movslq 0xb4(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0xc0(%rsp)
movsd 0xc0(%rsp), %xmm0
addq $0xc8, %rsp
retq
nopl (%rax,%rax)
| _ZNK12LefDefParser9defiGroup10propNumberEi:
sub rsp, 0C8h
mov [rsp+0C8h+var_10], rdi
mov [rsp+0C8h+var_14], esi
mov rax, [rsp+0C8h+var_10]
mov [rsp+0C8h+var_C0], rax
cmp [rsp+0C8h+var_14], 0
jl short loc_4D57E
mov rcx, [rsp+0C8h+var_C0]
mov eax, [rsp+0C8h+var_14]
cmp eax, [rcx+5Ch]
jl short loc_4D5CB
loc_4D57E:
mov rax, [rsp+0C8h+var_C0]
lea rdi, [rsp+0C8h+var_B8]
mov edx, [rsp+0C8h+var_14]
mov ecx, [rax+5Ch]
lea rsi, aErrorLefpars60_0; "ERROR (LEFPARS-6050): The index number "...
mov al, 0
call _sprintf
mov rax, [rsp+0C8h+var_C0]
lea rdx, [rsp+0C8h+var_B8]; int
mov rcx, [rax+88h]; char *
xor edi, edi; this
mov esi, 17A2h; int
call _ZN12LefDefParser9defiErrorEiiPKcPNS_8defrDataE; LefDefParser::defiError(int,int,char const*,LefDefParser::defrData *)
xorps xmm0, xmm0
movsd [rsp+0C8h+var_8], xmm0
jmp short loc_4D5EA
loc_4D5CB:
mov rax, [rsp+0C8h+var_C0]
mov rax, [rax+78h]
movsxd rcx, [rsp+0C8h+var_14]
movsd xmm0, qword ptr [rax+rcx*8]
movsd [rsp+0C8h+var_8], xmm0
loc_4D5EA:
movsd xmm0, [rsp+0C8h+var_8]
add rsp, 0C8h
retn
| double LefDefParser::defiGroup::propNumber(LefDefParser::defrData **this, int a2)
{
LefDefParser::defrData *v2; // r8
char v4[164]; // [rsp+10h] [rbp-B8h] BYREF
int v5; // [rsp+B4h] [rbp-14h]
LefDefParser::defiGroup *v6; // [rsp+B8h] [rbp-10h]
v6 = (LefDefParser::defiGroup *)this;
v5 = a2;
if ( a2 >= 0 && v5 < *((_DWORD *)this + 23) )
return *((double *)this[15] + v5);
sprintf(
v4,
"ERROR (LEFPARS-6050): The index number %d given for the GROUP PROPERTY is invalid.\nValid index is from 0 to %d",
v5,
*((_DWORD *)this + 23));
LefDefParser::defiError(0LL, 6050, v4, this[17], v2);
return 0.0;
}
| propNumber:
SUB RSP,0xc8
MOV qword ptr [RSP + 0xb8],RDI
MOV dword ptr [RSP + 0xb4],ESI
MOV RAX,qword ptr [RSP + 0xb8]
MOV qword ptr [RSP + 0x8],RAX
CMP dword ptr [RSP + 0xb4],0x0
JL 0x0014d57e
MOV RCX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RSP + 0xb4]
CMP EAX,dword ptr [RCX + 0x5c]
JL 0x0014d5cb
LAB_0014d57e:
MOV RAX,qword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x10]
MOV EDX,dword ptr [RSP + 0xb4]
MOV ECX,dword ptr [RAX + 0x5c]
LEA RSI,[0x175ee2]
MOV AL,0x0
CALL 0x00107060
MOV RAX,qword ptr [RSP + 0x8]
LEA RDX,[RSP + 0x10]
MOV RCX,qword ptr [RAX + 0x88]
XOR EDI,EDI
MOV ESI,0x17a2
CALL 0x0012a600
XORPS XMM0,XMM0
MOVSD qword ptr [RSP + 0xc0],XMM0
JMP 0x0014d5ea
LAB_0014d5cb:
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOVSXD RCX,dword ptr [RSP + 0xb4]
MOVSD XMM0,qword ptr [RAX + RCX*0x8]
MOVSD qword ptr [RSP + 0xc0],XMM0
LAB_0014d5ea:
MOVSD XMM0,qword ptr [RSP + 0xc0]
ADD RSP,0xc8
RET
|
/* LefDefParser::defiGroup::propNumber(int) const */
int8 __thiscall LefDefParser::defiGroup::propNumber(defiGroup *this,int param_1)
{
char local_b8 [164];
int local_14;
defiGroup *local_10;
int8 local_8;
if ((param_1 < 0) || (*(int *)(this + 0x5c) <= param_1)) {
local_14 = param_1;
local_10 = this;
sprintf(local_b8,
"ERROR (LEFPARS-6050): The index number %d given for the GROUP PROPERTY is invalid.\nValid index is from 0 to %d"
,(ulong)(uint)param_1,(ulong)*(uint *)(this + 0x5c));
defiError(0,0x17a2,local_b8,*(defrData **)(this + 0x88));
local_8 = 0;
}
else {
local_8 = *(int8 *)(*(long *)(this + 0x78) + (long)param_1 * 8);
}
return local_8;
}
| |
45,626 | diag | eloqsql/unittest/mytap/tap.c | void
diag(char const *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
fprintf(tapout, "# ");
vfprintf(tapout, fmt, ap);
emit_endl();
va_end(ap);
} | O0 | c | diag:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x24c85
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0xd0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq 0x1a82e4(%rip), %rax # 0x1ccfb8
movq %rax, -0xd8(%rbp)
movq (%rax), %rdi
leaq 0x5443d(%rip), %rsi # 0x79122
xorl %eax, %eax
callq 0x24400
movq -0xd8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x243d0
callq 0x25540
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| diag:
push rbp
mov rbp, rsp
sub rsp, 0E0h
test al, al
jz short loc_24C85
movaps [rbp+var_A0], xmm0
movaps [rbp+var_90], xmm1
movaps [rbp+var_80], xmm2
movaps [rbp+var_70], xmm3
movaps [rbp+var_60], xmm4
movaps [rbp+var_50], xmm5
movaps [rbp+var_40], xmm6
movaps [rbp+var_30], xmm7
loc_24C85:
mov [rbp+var_A8], r9
mov [rbp+var_B0], r8
mov [rbp+var_B8], rcx
mov [rbp+var_C0], rdx
mov [rbp+var_C8], rsi
mov [rbp+var_8], rdi
lea rax, [rbp+var_D0]
mov [rbp+var_10], rax
lea rax, [rbp+arg_0]
mov [rbp+var_18], rax
mov [rbp+var_1C], 30h ; '0'
mov [rbp+var_20], 8
mov rax, cs:stdout_ptr
mov [rbp+var_D8], rax
mov rdi, [rax]
lea rsi, asc_79122; "# "
xor eax, eax
call _fprintf
mov rax, [rbp+var_D8]
mov rdi, [rax]
mov rsi, [rbp+var_8]
lea rdx, [rbp+var_20]
call _vfprintf
call emit_endl
add rsp, 0E0h
pop rbp
retn
| long long diag(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
char v16; // [rsp+10h] [rbp-D0h] BYREF
long long v17; // [rsp+18h] [rbp-C8h]
long long v18; // [rsp+20h] [rbp-C0h]
long long v19; // [rsp+28h] [rbp-B8h]
long long v20; // [rsp+30h] [rbp-B0h]
long long v21; // [rsp+38h] [rbp-A8h]
__m128 v22; // [rsp+40h] [rbp-A0h]
__m128 v23; // [rsp+50h] [rbp-90h]
__m128 v24; // [rsp+60h] [rbp-80h]
__m128 v25; // [rsp+70h] [rbp-70h]
__m128 v26; // [rsp+80h] [rbp-60h]
__m128 v27; // [rsp+90h] [rbp-50h]
__m128 v28; // [rsp+A0h] [rbp-40h]
__m128 v29; // [rsp+B0h] [rbp-30h]
_DWORD v30[2]; // [rsp+C0h] [rbp-20h] BYREF
char *v31; // [rsp+C8h] [rbp-18h]
char *v32; // [rsp+D0h] [rbp-10h]
long long v33; // [rsp+D8h] [rbp-8h]
v22 = a7;
v23 = a8;
v24 = a9;
v25 = a10;
v26 = a11;
v27 = a12;
v28 = a13;
v29 = a14;
v21 = a6;
v20 = a5;
v19 = a4;
v18 = a3;
v17 = a2;
v33 = a1;
v32 = &v16;
v31 = &a15;
v30[1] = 48;
v30[0] = 8;
fprintf(stdout, "# ");
vfprintf(stdout, v33, v30);
return emit_endl();
}
| diag:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xe0
TEST AL,AL
JZ 0x00124c85
MOVAPS xmmword ptr [RBP + -0xa0],XMM0
MOVAPS xmmword ptr [RBP + -0x90],XMM1
MOVAPS xmmword ptr [RBP + -0x80],XMM2
MOVAPS xmmword ptr [RBP + -0x70],XMM3
MOVAPS xmmword ptr [RBP + -0x60],XMM4
MOVAPS xmmword ptr [RBP + -0x50],XMM5
MOVAPS xmmword ptr [RBP + -0x40],XMM6
MOVAPS xmmword ptr [RBP + -0x30],XMM7
LAB_00124c85:
MOV qword ptr [RBP + -0xa8],R9
MOV qword ptr [RBP + -0xb0],R8
MOV qword ptr [RBP + -0xb8],RCX
MOV qword ptr [RBP + -0xc0],RDX
MOV qword ptr [RBP + -0xc8],RSI
MOV qword ptr [RBP + -0x8],RDI
LEA RAX,[RBP + -0xd0]
MOV qword ptr [RBP + -0x10],RAX
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x1c],0x30
MOV dword ptr [RBP + -0x20],0x8
MOV RAX,qword ptr [0x002ccfb8]
MOV qword ptr [RBP + -0xd8],RAX
MOV RDI,qword ptr [RAX]
LEA RSI,[0x179122]
XOR EAX,EAX
CALL 0x00124400
MOV RAX,qword ptr [RBP + -0xd8]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x8]
LEA RDX,[RBP + -0x20]
CALL 0x001243d0
CALL 0x00125540
ADD RSP,0xe0
POP RBP
RET
|
void diag(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,char *param_9,
int8 param_10,int8 param_11,int8 param_12,int8 param_13,
int8 param_14)
{
int *puVar1;
char in_AL;
int1 local_d8 [8];
int8 local_d0;
int8 local_c8;
int8 local_c0;
int8 local_b8;
int8 local_b0;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int8 local_38;
int4 local_28;
int4 local_24;
int1 *local_20;
int1 *local_18;
char *local_10;
puVar1 = PTR_stdout_002ccfb8;
if (in_AL != '\0') {
local_a8 = param_1;
local_98 = param_2;
local_88 = param_3;
local_78 = param_4;
local_68 = param_5;
local_58 = param_6;
local_48 = param_7;
local_38 = param_8;
}
local_18 = local_d8;
local_20 = &stack0x00000008;
local_24 = 0x30;
local_28 = 8;
local_d0 = param_10;
local_c8 = param_11;
local_c0 = param_12;
local_b8 = param_13;
local_b0 = param_14;
local_10 = param_9;
fprintf(*(FILE **)PTR_stdout_002ccfb8,"# ");
vfprintf(*(FILE **)puVar1,local_10,&local_28);
emit_endl();
return;
}
| |
45,627 | minja::ExpressionTemplateToken::~ExpressionTemplateToken() | monkey531[P]llama/common/minja.hpp | ExpressionTemplateToken(const Location & location, SpaceHandling pre, SpaceHandling post, std::shared_ptr<Expression> && e) : TemplateToken(Type::Expression, location, pre, post), expr(std::move(e)) {} | O3 | cpp | minja::ExpressionTemplateToken::~ExpressionTemplateToken():
pushq %rbx
movq %rdi, %rbx
leaq 0x8287b(%rip), %rax # 0xdbb08
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x592a2
callq 0x2f99c
leaq 0x81f0f(%rip), %rax # 0xdb1b8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x592bf
popq %rbx
jmp 0x2f99c
popq %rbx
retq
nop
| _ZN5minja23ExpressionTemplateTokenD2Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja23ExpressionTemplateTokenE; `vtable for'minja::ExpressionTemplateToken
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+38h]
test rdi, rdi
jz short loc_592A2
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_592A2:
lea rax, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_592BF
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_592BF:
pop rbx
retn
| void minja::ExpressionTemplateToken::~ExpressionTemplateToken(minja::ExpressionTemplateToken *this)
{
volatile signed __int32 *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::ExpressionTemplateToken + 2;
v2 = (volatile signed __int32 *)*((_QWORD *)this + 7);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
*(_QWORD *)this = &`vtable for'minja::TemplateToken + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 3);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
}
| ~ExpressionTemplateToken:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x1dbb08]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x38]
TEST RDI,RDI
JZ 0x001592a2
CALL 0x0012f99c
LAB_001592a2:
LEA RAX,[0x1db1b8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x18]
TEST RDI,RDI
JZ 0x001592bf
POP RBX
JMP 0x0012f99c
LAB_001592bf:
POP RBX
RET
|
/* minja::ExpressionTemplateToken::~ExpressionTemplateToken() */
void __thiscall
minja::ExpressionTemplateToken::~ExpressionTemplateToken(ExpressionTemplateToken *this)
{
*(int ***)this = &PTR__ExpressionTemplateToken_001dbb18;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38));
}
*(int ***)this = &PTR__TemplateToken_001db1c8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18));
return;
}
return;
}
| |
45,628 | MainWindow::add_newstair(int, Elevetor&, QPushButton*) | LeafBlue[P]myElevetor/mainwindow.cpp | void MainWindow::add_newstair(int newstair, Elevetor &thisele,QPushButton *btn1)
{
bool ispress = btn1->property("pressedState").toBool();
if(ispress){
int iscancel = thisele.cancel_stair(newstair);
if(iscancel == 1){
btn1->setProperty("pressedState","false");
btn1->style()->unpolish(btn1);
btn1->style()->polish(btn1);
btn1->update();
}
return;
}
//变颜色
btn1->setProperty("pressedState","true");
btn1->style()->unpolish(btn1);
btn1->style()->polish(btn1);
btn1->update();
int add_result = thisele.add_stair(newstair);
if(add_result == 1){
thisele.status = 3;
move_ele(thisele);
}else if(add_result == 2){
//理论上这里不需要修改状态
if(thisele.direct == 1 && newstair < thisele.endstair){
thisele.endstair = newstair;
update_endstair(thisele);
}else if(thisele.direct == 2 && newstair > thisele.endstair){
thisele.endstair = newstair;
update_endstair(thisele);
}
}
} | O2 | cpp | MainWindow::add_newstair(int, Elevetor&, QPushButton*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
leaq 0x4561(%rip), %rdx # 0xa2b5
movq %rsp, %r12
movq %r12, %rdi
movq %rcx, %rsi
callq 0x43b0
movq %r12, %rdi
callq 0x4200
movl %eax, %r12d
movq %rsp, %rdi
callq 0x4170
testb %r12b, %r12b
je 0x5dee
movq %r14, %rdi
movl %ebp, %esi
callq 0x844a
cmpl $0x1, %eax
jne 0x5e96
leaq 0x452e(%rip), %rsi # 0xa2c2
movq %rsp, %r14
movq %r14, %rdi
callq 0x7006
leaq 0x450f(%rip), %rsi # 0xa2b5
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4190
movq %rsp, %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4450
movq (%rax), %rcx
movq %rax, %rdi
movq %rbx, %rsi
callq *0x68(%rcx)
movq %rbx, %rdi
callq 0x4450
movq (%rax), %rcx
movq %rax, %rdi
movq %rbx, %rsi
callq *0x60(%rcx)
movq %rbx, %rdi
callq 0x4120
jmp 0x5e96
leaq 0x48a1(%rip), %rsi # 0xa696
movq %rsp, %r12
movq %r12, %rdi
callq 0x7006
leaq 0x44ae(%rip), %rsi # 0xa2b5
movq %rbx, %rdi
movq %r12, %rdx
callq 0x4190
movq %rsp, %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4450
movq (%rax), %rcx
movq %rax, %rdi
movq %rbx, %rsi
callq *0x68(%rcx)
movq %rbx, %rdi
callq 0x4450
movq (%rax), %rcx
movq %rax, %rdi
movq %rbx, %rsi
callq *0x60(%rcx)
movq %rbx, %rdi
callq 0x4120
movq %r14, %rdi
movl %ebp, %esi
callq 0x8390
cmpl $0x2, %eax
je 0x5e73
cmpl $0x1, %eax
jne 0x5e96
movl $0x3, 0x4c(%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0x5ec2
jmp 0x5e96
movl 0x48(%r14), %eax
cmpl $0x2, %eax
je 0x5ea3
cmpl $0x1, %eax
jne 0x5e96
cmpl %ebp, 0x44(%r14)
jle 0x5e96
movl %ebp, 0x44(%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0x4bf8
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl %ebp, 0x44(%r14)
jl 0x5e87
jmp 0x5e96
jmp 0x5eaf
jmp 0x5eaf
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x41d0
| _ZN10MainWindow12add_newstairEiR8ElevetorP11QPushButton:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 20h
mov rbx, rcx
mov r14, rdx
mov ebp, esi
mov r15, rdi
lea rdx, aPressedstate; "pressedState"
mov r12, rsp
mov rdi, r12; this
mov rsi, rcx; char *
call __ZNK7QObject8propertyEPKc; QObject::property(char const*)
mov rdi, r12; this
call __ZNK8QVariant6toBoolEv; QVariant::toBool(void)
mov r12d, eax
mov rdi, rsp; this
call __ZN8QVariantD1Ev; QVariant::~QVariant()
test r12b, r12b
jz short loc_5DEE
mov rdi, r14; this
mov esi, ebp; int
call _ZN8Elevetor12cancel_stairEi; Elevetor::cancel_stair(int)
cmp eax, 1
jnz loc_5E96
lea rsi, aFalse; "false"
mov r14, rsp
mov rdi, r14; this
call _ZN8QVariantC2EPKc; QVariant::QVariant(char const*)
lea rsi, aPressedstate; "pressedState"
mov rdi, rbx; this
mov rdx, r14; QVariant *
call __ZN7QObject11setPropertyEPKcRK8QVariant; QObject::setProperty(char const*,QVariant const&)
mov rdi, rsp; this
call __ZN8QVariantD1Ev; QVariant::~QVariant()
mov rdi, rbx; this
call __ZNK7QWidget5styleEv; QWidget::style(void)
mov rcx, [rax]
mov rdi, rax
mov rsi, rbx
call qword ptr [rcx+68h]
mov rdi, rbx; this
call __ZNK7QWidget5styleEv; QWidget::style(void)
mov rcx, [rax]
mov rdi, rax
mov rsi, rbx
call qword ptr [rcx+60h]
mov rdi, rbx; this
call __ZN7QWidget6updateEv; QWidget::update(void)
jmp loc_5E96
loc_5DEE:
lea rsi, aTrue; "true"
mov r12, rsp
mov rdi, r12; this
call _ZN8QVariantC2EPKc; QVariant::QVariant(char const*)
lea rsi, aPressedstate; "pressedState"
mov rdi, rbx; this
mov rdx, r12; QVariant *
call __ZN7QObject11setPropertyEPKcRK8QVariant; QObject::setProperty(char const*,QVariant const&)
mov rdi, rsp; this
call __ZN8QVariantD1Ev; QVariant::~QVariant()
mov rdi, rbx; this
call __ZNK7QWidget5styleEv; QWidget::style(void)
mov rcx, [rax]
mov rdi, rax
mov rsi, rbx
call qword ptr [rcx+68h]
mov rdi, rbx; this
call __ZNK7QWidget5styleEv; QWidget::style(void)
mov rcx, [rax]
mov rdi, rax
mov rsi, rbx
call qword ptr [rcx+60h]
mov rdi, rbx; this
call __ZN7QWidget6updateEv; QWidget::update(void)
mov rdi, r14; this
mov esi, ebp; int
call _ZN8Elevetor9add_stairEi; Elevetor::add_stair(int)
cmp eax, 2
jz short loc_5E73
cmp eax, 1
jnz short loc_5E96
mov dword ptr [r14+4Ch], 3
mov rdi, r15; this
mov rsi, r14; Elevetor *
call _ZN10MainWindow8move_eleER8Elevetor; MainWindow::move_ele(Elevetor &)
jmp short loc_5E96
loc_5E73:
mov eax, [r14+48h]
cmp eax, 2
jz short loc_5EA3
cmp eax, 1
jnz short loc_5E96
cmp [r14+44h], ebp
jle short loc_5E96
loc_5E87:
mov [r14+44h], ebp
mov rdi, r15; this
mov rsi, r14; Elevetor *
call _ZN10MainWindow15update_endstairER8Elevetor; MainWindow::update_endstair(Elevetor &)
loc_5E96:
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_5EA3:
cmp [r14+44h], ebp
jl short loc_5E87
jmp short loc_5E96
jmp short loc_5EAF
jmp short $+2
loc_5EAF:
mov rbx, rax
mov rdi, rsp; this
call __ZN8QVariantD1Ev; QVariant::~QVariant()
mov rdi, rbx
call __Unwind_Resume
| void MainWindow::add_newstair(MainWindow *this, int a2, Elevetor *a3, QPushButton *a4)
{
char v6; // r12
long long v7; // rax
long long v8; // rax
long long v9; // rax
long long v10; // rax
int v11; // eax
int v12; // eax
_BYTE v13[72]; // [rsp+0h] [rbp-48h] BYREF
QObject::property((QObject *)v13, (const char *)a4);
v6 = QVariant::toBool((QVariant *)v13);
QVariant::~QVariant((QVariant *)v13);
if ( v6 )
{
if ( (unsigned int)Elevetor::cancel_stair(a3, a2) == 1 )
{
QVariant::QVariant((QVariant *)v13, "false");
QObject::setProperty(a4, "pressedState", (const QVariant *)v13);
QVariant::~QVariant((QVariant *)v13);
v7 = QWidget::style(a4);
(*(void ( **)(long long, QPushButton *))(*(_QWORD *)v7 + 104LL))(v7, a4);
v8 = QWidget::style(a4);
(*(void ( **)(long long, QPushButton *))(*(_QWORD *)v8 + 96LL))(v8, a4);
QWidget::update(a4);
}
return;
}
QVariant::QVariant((QVariant *)v13, "true");
QObject::setProperty(a4, "pressedState", (const QVariant *)v13);
QVariant::~QVariant((QVariant *)v13);
v9 = QWidget::style(a4);
(*(void ( **)(long long, QPushButton *))(*(_QWORD *)v9 + 104LL))(v9, a4);
v10 = QWidget::style(a4);
(*(void ( **)(long long, QPushButton *))(*(_QWORD *)v10 + 96LL))(v10, a4);
QWidget::update(a4);
v11 = Elevetor::add_stair(a3, a2);
if ( v11 == 2 )
{
v12 = *((_DWORD *)a3 + 18);
if ( v12 == 2 )
{
if ( *((_DWORD *)a3 + 17) >= a2 )
return;
}
else if ( v12 != 1 || *((_DWORD *)a3 + 17) <= a2 )
{
return;
}
*((_DWORD *)a3 + 17) = a2;
MainWindow::update_endstair(this, (QWidget **)a3);
return;
}
if ( v11 == 1 )
{
*((_DWORD *)a3 + 19) = 3;
MainWindow::move_ele(this, a3);
}
}
| add_newstair:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV RBX,RCX
MOV R14,RDX
MOV EBP,ESI
MOV R15,RDI
LEA RDX,[0x10a2b5]
MOV R12,RSP
MOV RDI,R12
MOV RSI,RCX
CALL 0x001043b0
LAB_00105d62:
MOV RDI,R12
CALL 0x00104200
LAB_00105d6a:
MOV R12D,EAX
MOV RDI,RSP
CALL 0x00104170
TEST R12B,R12B
JZ 0x00105dee
MOV RDI,R14
MOV ESI,EBP
CALL 0x0010844a
CMP EAX,0x1
JNZ 0x00105e96
LEA RSI,[0x10a2c2]
MOV R14,RSP
MOV RDI,R14
CALL 0x00107006
LAB_00105d9f:
LEA RSI,[0x10a2b5]
MOV RDI,RBX
MOV RDX,R14
CALL 0x00104190
LAB_00105db1:
MOV RDI,RSP
CALL 0x00104170
MOV RDI,RBX
CALL 0x00104450
MOV RCX,qword ptr [RAX]
MOV RDI,RAX
MOV RSI,RBX
CALL qword ptr [RCX + 0x68]
MOV RDI,RBX
CALL 0x00104450
MOV RCX,qword ptr [RAX]
MOV RDI,RAX
MOV RSI,RBX
CALL qword ptr [RCX + 0x60]
MOV RDI,RBX
CALL 0x00104120
JMP 0x00105e96
LAB_00105dee:
LEA RSI,[0x10a696]
MOV R12,RSP
MOV RDI,R12
CALL 0x00107006
LAB_00105e00:
LEA RSI,[0x10a2b5]
MOV RDI,RBX
MOV RDX,R12
CALL 0x00104190
LAB_00105e12:
MOV RDI,RSP
CALL 0x00104170
MOV RDI,RBX
CALL 0x00104450
MOV RCX,qword ptr [RAX]
MOV RDI,RAX
MOV RSI,RBX
CALL qword ptr [RCX + 0x68]
MOV RDI,RBX
CALL 0x00104450
MOV RCX,qword ptr [RAX]
MOV RDI,RAX
MOV RSI,RBX
CALL qword ptr [RCX + 0x60]
MOV RDI,RBX
CALL 0x00104120
MOV RDI,R14
MOV ESI,EBP
CALL 0x00108390
CMP EAX,0x2
JZ 0x00105e73
CMP EAX,0x1
JNZ 0x00105e96
MOV dword ptr [R14 + 0x4c],0x3
MOV RDI,R15
MOV RSI,R14
CALL 0x00105ec2
JMP 0x00105e96
LAB_00105e73:
MOV EAX,dword ptr [R14 + 0x48]
CMP EAX,0x2
JZ 0x00105ea3
CMP EAX,0x1
JNZ 0x00105e96
CMP dword ptr [R14 + 0x44],EBP
JLE 0x00105e96
LAB_00105e87:
MOV dword ptr [R14 + 0x44],EBP
MOV RDI,R15
MOV RSI,R14
CALL 0x00104bf8
LAB_00105e96:
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00105ea3:
CMP dword ptr [R14 + 0x44],EBP
JL 0x00105e87
JMP 0x00105e96
|
/* MainWindow::add_newstair(int, Elevetor&, QPushButton*) */
void __thiscall
MainWindow::add_newstair(MainWindow *this,int param_1,Elevetor *param_2,QPushButton *param_3)
{
char cVar1;
int iVar2;
long *plVar3;
QVariant aQStack_48 [32];
QObject::property((char *)aQStack_48);
/* try { // try from 00105d62 to 00105d69 has its CatchHandler @ 00105eaf */
cVar1 = QVariant::toBool();
QVariant::~QVariant(aQStack_48);
if (cVar1 == '\0') {
QVariant::QVariant(aQStack_48,"true");
/* try { // try from 00105e00 to 00105e11 has its CatchHandler @ 00105ead */
QObject::setProperty((char *)param_3,(QVariant *)"pressedState");
QVariant::~QVariant(aQStack_48);
plVar3 = (long *)QWidget::style();
(**(code **)(*plVar3 + 0x68))(plVar3,param_3);
plVar3 = (long *)QWidget::style();
(**(code **)(*plVar3 + 0x60))(plVar3,param_3);
QWidget::update();
iVar2 = Elevetor::add_stair(param_2,param_1);
if (iVar2 == 2) {
if (*(int *)(param_2 + 0x48) == 2) {
if (param_1 <= *(int *)(param_2 + 0x44)) {
return;
}
}
else {
if (*(int *)(param_2 + 0x48) != 1) {
return;
}
if (*(int *)(param_2 + 0x44) <= param_1) {
return;
}
}
*(int *)(param_2 + 0x44) = param_1;
update_endstair(this,param_2);
}
else if (iVar2 == 1) {
*(int4 *)(param_2 + 0x4c) = 3;
move_ele(this,param_2);
}
}
else {
iVar2 = Elevetor::cancel_stair(param_2,param_1);
if (iVar2 == 1) {
QVariant::QVariant(aQStack_48,"false");
/* try { // try from 00105d9f to 00105db0 has its CatchHandler @ 00105eab */
QObject::setProperty((char *)param_3,(QVariant *)"pressedState");
QVariant::~QVariant(aQStack_48);
plVar3 = (long *)QWidget::style();
(**(code **)(*plVar3 + 0x68))(plVar3,param_3);
plVar3 = (long *)QWidget::style();
(**(code **)(*plVar3 + 0x60))(plVar3,param_3);
QWidget::update();
}
}
return;
}
| |
45,629 | JS_AddIntrinsicDate | bluesky950520[P]quickjs/quickjs.c | void JS_AddIntrinsicDate(JSContext *ctx)
{
JSValue obj;
/* Date */
ctx->class_proto[JS_CLASS_DATE] = JS_NewObject(ctx);
JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_DATE], js_date_proto_funcs,
countof(js_date_proto_funcs));
obj = JS_NewGlobalCConstructor(ctx, "Date", js_date_constructor, 7,
ctx->class_proto[JS_CLASS_DATE]);
JS_SetPropertyFunctionList(ctx, obj, js_date_funcs, countof(js_date_funcs));
} | O0 | c | JS_AddIntrinsicDate:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0x292b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0xa0(%rax)
movq 0x28(%rsp), %rcx
movq %rcx, 0xa8(%rax)
movq 0x40(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x40(%rax), %rax
movq 0xa0(%rax), %rsi
movq 0xa8(%rax), %rdx
leaq 0x10bc12(%rip), %rcx # 0x1308f0
movl $0x2f, %r8d
callq 0x4b840
movq 0x40(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x40(%rax), %rax
movq 0xa0(%rax), %r8
movq 0xa8(%rax), %r9
leaq 0xe925b(%rip), %rsi # 0x10df67
leaq 0x2f19d(%rip), %rdx # 0x53eb0
movl $0x7, %ecx
callq 0x4ceb0
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
leaq 0x10a1cf(%rip), %rcx # 0x12ef20
movl $0x3, %r8d
callq 0x4b840
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
| JS_AddIntrinsicDate:
sub rsp, 48h
mov [rsp+48h+var_8], rdi
mov rax, [rsp+48h+var_8]
mov rax, [rax+40h]
mov [rsp+48h+var_40], rax
mov rdi, [rsp+48h+var_8]
call JS_NewObject
mov rcx, rax
mov rax, [rsp+48h+var_40]
mov [rsp+48h+var_28], rcx
mov [rsp+48h+var_20], rdx
mov rcx, [rsp+48h+var_28]
mov [rax+0A0h], rcx
mov rcx, [rsp+48h+var_20]
mov [rax+0A8h], rcx
mov rdi, [rsp+48h+var_8]
mov rax, [rsp+48h+var_8]
mov rax, [rax+40h]
mov rsi, [rax+0A0h]
mov rdx, [rax+0A8h]
lea rcx, js_date_proto_funcs
mov r8d, 2Fh ; '/'
call JS_SetPropertyFunctionList
mov rdi, [rsp+48h+var_8]
mov rax, [rsp+48h+var_8]
mov rax, [rax+40h]
mov r8, [rax+0A0h]
mov r9, [rax+0A8h]
lea rsi, aInvalidDate+8; "Date"
lea rdx, js_date_constructor
mov ecx, 7
call JS_NewGlobalCConstructor
mov [rsp+48h+var_38], rax
mov [rsp+48h+var_30], rdx
mov rax, [rsp+48h+var_38]
mov [rsp+48h+var_18], rax
mov rax, [rsp+48h+var_30]
mov [rsp+48h+var_10], rax
mov rdi, [rsp+48h+var_8]
mov rsi, [rsp+48h+var_18]
mov rdx, [rsp+48h+var_10]
lea rcx, js_date_funcs
mov r8d, 3
call JS_SetPropertyFunctionList
add rsp, 48h
retn
| long long JS_AddIntrinsicDate(long long a1)
{
long long v1; // rdx
long long v2; // rdx
long long v4; // [rsp+8h] [rbp-40h]
long long v5; // [rsp+10h] [rbp-38h]
v4 = *(_QWORD *)(a1 + 64);
*(_QWORD *)(v4 + 160) = JS_NewObject(a1);
*(_QWORD *)(v4 + 168) = v1;
JS_SetPropertyFunctionList(
a1,
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 160LL),
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 168LL),
&js_date_proto_funcs,
47LL);
v5 = JS_NewGlobalCConstructor(
a1,
"Date",
js_date_constructor,
7LL,
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 160LL),
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 168LL));
return JS_SetPropertyFunctionList(a1, v5, v2, &js_date_funcs, 3LL);
}
| JS_AddIntrinsicDate:
SUB RSP,0x48
MOV qword ptr [RSP + 0x40],RDI
MOV RAX,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RAX + 0x40]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x40]
CALL 0x001292b0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x20],RCX
MOV qword ptr [RSP + 0x28],RDX
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + 0xa0],RCX
MOV RCX,qword ptr [RSP + 0x28]
MOV qword ptr [RAX + 0xa8],RCX
MOV RDI,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RAX + 0xa0]
MOV RDX,qword ptr [RAX + 0xa8]
LEA RCX,[0x2308f0]
MOV R8D,0x2f
CALL 0x0014b840
MOV RDI,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RAX + 0x40]
MOV R8,qword ptr [RAX + 0xa0]
MOV R9,qword ptr [RAX + 0xa8]
LEA RSI,[0x20df67]
LEA RDX,[0x153eb0]
MOV ECX,0x7
CALL 0x0014ceb0
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],RDX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
LEA RCX,[0x22ef20]
MOV R8D,0x3
CALL 0x0014b840
ADD RSP,0x48
RET
|
void JS_AddIntrinsicDate(long param_1)
{
long lVar1;
int1 auVar2 [16];
lVar1 = *(long *)(param_1 + 0x40);
auVar2 = JS_NewObject(param_1);
*(int1 (*) [16])(lVar1 + 0xa0) = auVar2;
JS_SetPropertyFunctionList
(param_1,*(int8 *)(*(long *)(param_1 + 0x40) + 0xa0),
*(int8 *)(*(long *)(param_1 + 0x40) + 0xa8),js_date_proto_funcs,0x2f);
auVar2 = JS_NewGlobalCConstructor
(param_1,"Date",js_date_constructor,7,
*(int8 *)(*(long *)(param_1 + 0x40) + 0xa0),
*(int8 *)(*(long *)(param_1 + 0x40) + 0xa8));
JS_SetPropertyFunctionList(param_1,auVar2._0_8_,auVar2._8_8_,js_date_funcs,3);
return;
}
| |
45,630 | JS_AddIntrinsicDate | bluesky950520[P]quickjs/quickjs.c | void JS_AddIntrinsicDate(JSContext *ctx)
{
JSValue obj;
/* Date */
ctx->class_proto[JS_CLASS_DATE] = JS_NewObject(ctx);
JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_DATE], js_date_proto_funcs,
countof(js_date_proto_funcs));
obj = JS_NewGlobalCConstructor(ctx, "Date", js_date_constructor, 7,
ctx->class_proto[JS_CLASS_DATE]);
JS_SetPropertyFunctionList(ctx, obj, js_date_funcs, countof(js_date_funcs));
} | O2 | c | JS_AddIntrinsicDate:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %r14
callq 0x1a74d
movq %rax, 0xa0(%r14)
movq %rdx, 0xa8(%r14)
movq 0x40(%rbx), %rax
movq 0xa0(%rax), %rsi
movq 0xa8(%rax), %rdx
leaq 0x9d234(%rip), %rcx # 0xb5810
pushq $0x2f
popq %r8
movq %rbx, %rdi
callq 0x2b883
movq 0x40(%rbx), %rax
movq 0xa0(%rax), %r8
movq 0xa8(%rax), %r9
leaq 0x6d8b4(%rip), %rsi # 0x85eb5
leaq 0x1746a(%rip), %rdx # 0x2fa72
pushq $0x7
popq %rcx
movq %rbx, %rdi
callq 0x2c210
leaq 0x9b836(%rip), %rcx # 0xb3e50
pushq $0x3
popq %r8
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2b883
| JS_AddIntrinsicDate:
push r14
push rbx
push rax
mov rbx, rdi
mov r14, [rdi+40h]
call JS_NewObject
mov [r14+0A0h], rax
mov [r14+0A8h], rdx
mov rax, [rbx+40h]
mov rsi, [rax+0A0h]
mov rdx, [rax+0A8h]
lea rcx, js_date_proto_funcs
push 2Fh ; '/'
pop r8
mov rdi, rbx
call JS_SetPropertyFunctionList
mov rax, [rbx+40h]
mov r8, [rax+0A0h]
mov r9, [rax+0A8h]
lea rsi, aInvalidDate+8; "Date"
lea rdx, js_date_constructor
push 7
pop rcx
mov rdi, rbx
call JS_NewGlobalCConstructor
lea rcx, js_date_funcs
push 3
pop r8
mov rdi, rbx
mov rsi, rax
add rsp, 8
pop rbx
pop r14
jmp JS_SetPropertyFunctionList
| long long JS_AddIntrinsicDate(long long a1)
{
long long v1; // r14
long long v2; // rdx
long long v3; // rax
long long v4; // rdx
v1 = *(_QWORD *)(a1 + 64);
*(_QWORD *)(v1 + 160) = JS_NewObject(a1);
*(_QWORD *)(v1 + 168) = v2;
JS_SetPropertyFunctionList(
a1,
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 160LL),
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 168LL),
&js_date_proto_funcs,
47LL);
v3 = JS_NewGlobalCConstructor(
a1,
"Date",
js_date_constructor,
7LL,
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 160LL),
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 168LL));
return JS_SetPropertyFunctionList(a1, v3, v4, &js_date_funcs, 3LL);
}
| JS_AddIntrinsicDate:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R14,qword ptr [RDI + 0x40]
CALL 0x0011a74d
MOV qword ptr [R14 + 0xa0],RAX
MOV qword ptr [R14 + 0xa8],RDX
MOV RAX,qword ptr [RBX + 0x40]
MOV RSI,qword ptr [RAX + 0xa0]
MOV RDX,qword ptr [RAX + 0xa8]
LEA RCX,[0x1b5810]
PUSH 0x2f
POP R8
MOV RDI,RBX
CALL 0x0012b883
MOV RAX,qword ptr [RBX + 0x40]
MOV R8,qword ptr [RAX + 0xa0]
MOV R9,qword ptr [RAX + 0xa8]
LEA RSI,[0x185eb5]
LEA RDX,[0x12fa72]
PUSH 0x7
POP RCX
MOV RDI,RBX
CALL 0x0012c210
LEA RCX,[0x1b3e50]
PUSH 0x3
POP R8
MOV RDI,RBX
MOV RSI,RAX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x0012b883
|
void JS_AddIntrinsicDate(long param_1)
{
long lVar1;
int1 auVar2 [16];
lVar1 = *(long *)(param_1 + 0x40);
auVar2 = JS_NewObject();
*(int1 (*) [16])(lVar1 + 0xa0) = auVar2;
JS_SetPropertyFunctionList
(param_1,*(int8 *)(*(long *)(param_1 + 0x40) + 0xa0),
*(int8 *)(*(long *)(param_1 + 0x40) + 0xa8),js_date_proto_funcs,0x2f);
auVar2 = JS_NewGlobalCConstructor
(param_1,"Date",js_date_constructor,7,
*(int8 *)(*(long *)(param_1 + 0x40) + 0xa0),
*(int8 *)(*(long *)(param_1 + 0x40) + 0xa8));
JS_SetPropertyFunctionList(param_1,auVar2._0_8_,auVar2._8_8_,js_date_funcs,3);
return;
}
| |
45,631 | JS_AddIntrinsicDate | bluesky950520[P]quickjs/quickjs.c | void JS_AddIntrinsicDate(JSContext *ctx)
{
JSValue obj;
/* Date */
ctx->class_proto[JS_CLASS_DATE] = JS_NewObject(ctx);
JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_DATE], js_date_proto_funcs,
countof(js_date_proto_funcs));
obj = JS_NewGlobalCConstructor(ctx, "Date", js_date_constructor, 7,
ctx->class_proto[JS_CLASS_DATE]);
JS_SetPropertyFunctionList(ctx, obj, js_date_funcs, countof(js_date_funcs));
} | O3 | c | JS_AddIntrinsicDate:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %r14
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movl $0x1, %ecx
callq 0x20a15
movq %rax, 0xa0(%r14)
movq %rdx, 0xa8(%r14)
movq 0x40(%rbx), %rax
movq 0xa0(%rax), %rsi
movq 0xa8(%rax), %rdx
leaq 0xac3df(%rip), %rcx # 0xca810
movq %rbx, %rdi
movl $0x2f, %r8d
callq 0x3302c
movq 0x40(%rbx), %rax
movq 0xa0(%rax), %r8
movq 0xa8(%rax), %r9
leaq 0x83acd(%rip), %rsi # 0xa1f25
leaq 0x191c9(%rip), %rdx # 0x37628
movq %rbx, %rdi
movl $0x7, %ecx
callq 0x339eb
leaq 0xaa9dd(%rip), %rcx # 0xc8e50
movq %rbx, %rdi
movq %rax, %rsi
movl $0x3, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3302c
| JS_AddIntrinsicDate:
push r14
push rbx
push rax
mov rbx, rdi
mov r14, [rdi+40h]
mov rsi, [r14+10h]
mov rdx, [r14+18h]
mov ecx, 1
call JS_NewObjectProtoClass
mov [r14+0A0h], rax
mov [r14+0A8h], rdx
mov rax, [rbx+40h]
mov rsi, [rax+0A0h]
mov rdx, [rax+0A8h]
lea rcx, js_date_proto_funcs
mov rdi, rbx
mov r8d, 2Fh ; '/'
call JS_SetPropertyFunctionList
mov rax, [rbx+40h]
mov r8, [rax+0A0h]
mov r9, [rax+0A8h]
lea rsi, aInvalidDate+8; "Date"
lea rdx, js_date_constructor
mov rdi, rbx
mov ecx, 7
call JS_NewGlobalCConstructor
lea rcx, js_date_funcs
mov rdi, rbx
mov rsi, rax
mov r8d, 3
add rsp, 8
pop rbx
pop r14
jmp JS_SetPropertyFunctionList
| long long JS_AddIntrinsicDate(long long a1)
{
_QWORD *v1; // r14
long long v2; // rdx
long long v3; // rax
long long v4; // rdx
v1 = *(_QWORD **)(a1 + 64);
v1[20] = JS_NewObjectProtoClass(a1, v1[2], v1[3], 1LL);
v1[21] = v2;
JS_SetPropertyFunctionList(
a1,
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 160LL),
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 168LL),
&js_date_proto_funcs,
47LL);
v3 = JS_NewGlobalCConstructor(
a1,
"Date",
js_date_constructor,
7LL,
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 160LL),
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 168LL));
return JS_SetPropertyFunctionList(a1, v3, v4, &js_date_funcs, 3LL);
}
| JS_AddIntrinsicDate:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R14,qword ptr [RDI + 0x40]
MOV RSI,qword ptr [R14 + 0x10]
MOV RDX,qword ptr [R14 + 0x18]
MOV ECX,0x1
CALL 0x00120a15
MOV qword ptr [R14 + 0xa0],RAX
MOV qword ptr [R14 + 0xa8],RDX
MOV RAX,qword ptr [RBX + 0x40]
MOV RSI,qword ptr [RAX + 0xa0]
MOV RDX,qword ptr [RAX + 0xa8]
LEA RCX,[0x1ca810]
MOV RDI,RBX
MOV R8D,0x2f
CALL 0x0013302c
MOV RAX,qword ptr [RBX + 0x40]
MOV R8,qword ptr [RAX + 0xa0]
MOV R9,qword ptr [RAX + 0xa8]
LEA RSI,[0x1a1f25]
LEA RDX,[0x137628]
MOV RDI,RBX
MOV ECX,0x7
CALL 0x001339eb
LEA RCX,[0x1c8e50]
MOV RDI,RBX
MOV RSI,RAX
MOV R8D,0x3
ADD RSP,0x8
POP RBX
POP R14
JMP 0x0013302c
|
void JS_AddIntrinsicDate(long param_1)
{
long lVar1;
int1 auVar2 [16];
lVar1 = *(long *)(param_1 + 0x40);
auVar2 = JS_NewObjectProtoClass
(param_1,*(int8 *)(lVar1 + 0x10),*(int8 *)(lVar1 + 0x18),1);
*(int1 (*) [16])(lVar1 + 0xa0) = auVar2;
JS_SetPropertyFunctionList
(param_1,*(int8 *)(*(long *)(param_1 + 0x40) + 0xa0),
*(int8 *)(*(long *)(param_1 + 0x40) + 0xa8),js_date_proto_funcs,0x2f);
auVar2 = JS_NewGlobalCConstructor
(param_1,"Date",js_date_constructor,7,
*(int8 *)(*(long *)(param_1 + 0x40) + 0xa0),
*(int8 *)(*(long *)(param_1 + 0x40) + 0xa8));
JS_SetPropertyFunctionList(param_1,auVar2._0_8_,auVar2._8_8_,js_date_funcs,3);
return;
}
| |
45,632 | POINTonE2_precompute_w5 | corpus-core[P]colibri-stateless/build_O0/_deps/blst-src/src/e2.c | POINT_AFFINE_MULT_SCALAR_IMPL(POINTonE2)
DECLARE_PRIVATE_POINTXZ(POINTonE2, 384x)
POINT_LADDER_PRE_IMPL(POINTonE2, 384x, fp2)
POINT_LADDER_STEP_IMPL_A0(POINTonE2, 384x, fp2, onE2)
POINT_LADDER_POST_IMPL_A0(POINTonE2, 384x, fp2, onE2)
POINT_MULT_SCALAR_LADDER_IMPL(POINTonE2)
#endif
static void psi(POINTonE2 *out, const POINTonE2 *in)
{
static const vec384x frobenius_x = { /* 1/(1 + i)^((P-1)/3) */
{ 0 },
{ /* (0x1a0111ea397fe699ec02408663d4de85aa0d857d89759ad4
897d29650fb85f9b409427eb4f49fffd8bfd00000000aaad << 384) % P */
TO_LIMB_T(0x890dc9e4867545c3), TO_LIMB_T(0x2af322533285a5d5),
TO_LIMB_T(0x50880866309b7e2c), TO_LIMB_T(0xa20d1b8c7e881024),
TO_LIMB_T(0x14e4f04fe2db9068), TO_LIMB_T(0x14e56d3f1564853a) }
};
static const vec384x frobenius_y = { /* 1/(1 + i)^((P-1)/2) */
{ /* (0x135203e60180a68ee2e9c448d77a2cd91c3dedd930b1cf60
ef396489f61eb45e304466cf3e67fa0af1ee7b04121bdea2 << 384) % P */
TO_LIMB_T(0x3e2f585da55c9ad1), TO_LIMB_T(0x4294213d86c18183),
TO_LIMB_T(0x382844c88b623732), TO_LIMB_T(0x92ad2afd19103e18),
TO_LIMB_T(0x1d794e4fac7cf0b9), TO_LIMB_T(0x0bd592fc7d825ec8) },
{ /* (0x06af0e0437ff400b6831e36d6bd17ffe48395dabc2d3435e
77f76e17009241c5ee67992f72ec05f4c81084fbede3cc09 << 384) % P */
TO_LIMB_T(0x7bcfa7a25aa30fda), TO_LIMB_T(0xdc17dec12a927e7c),
TO_LIMB_T(0x2f088dd86b4ebef1), TO_LIMB_T(0xd1ca2087da74d4a7),
TO_LIMB_T(0x2da2596696cebc1d), TO_LIMB_T(0x0e2b7eedbbfd87d2) },
};
vec_copy(out, in, sizeof(*out));
cneg_fp(out->X[1], out->X[1], 1); mul_fp2(out->X, out->X, frobenius_x);
cneg_fp(out->Y[1], out->Y[1], 1); mul_fp2(out->Y, out->Y, frobenius_y);
cneg_fp(out->Z[1], out->Z[1], 1);
}
/* Galbraith-Lin-Scott, ~67% faster than POINTonE2_mul_w5 */
static void POINTonE2_mult_gls(POINTonE2 *out, const POINTonE2 *in,
const pow256 SK)
{
union { vec256 l; pow256 s; } val;
/* break down SK to "digits" with |z| as radix [in constant time] */
limbs_from_le_bytes(val.l, SK, 32);
div_by_zz(val.l);
div_by_z(val.l);
div_by_z(val.l + NLIMBS(256)/2);
le_bytes_from_limbs(val.s, val.l, 32);
{
const byte *scalars[2] = { val.s, NULL };
POINTonE2 table[4][1<<(5-1)]; /* 18KB */
size_t i;
POINTonE2_precompute_w5(table[0], in);
for (i = 0; i < 1<<(5-1); i++) {
psi(&table[1][i], &table[0][i]);
psi(&table[2][i], &table[1][i]);
psi(&table[3][i], &table[2][i]);
POINTonE2_cneg(&table[1][i], 1); /* account for z being negative */
POINTonE2_cneg(&table[3][i], 1);
}
POINTonE2s_mult_w5(out, NULL, 4, scalars, 64, table);
}
vec_zero(val.l, sizeof(val)); /* scrub the copy of SK */
} | O0 | c | POINTonE2_precompute_w5:
pushq %rbp
movq %rsp, %rbp
subq $0x2f0, %rsp # imm = 0x2F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xbc1ab
movq -0x18(%rbp), %rax
shlq $0x9, %rax
leaq (%rax,%rax,8), %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xbc245
movq $0x0, -0x2d0(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xbc243
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xbc1f8
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rax
movq %rax, -0x2d8(%rbp)
jmp 0xbc20c
movq -0x2d0(%rbp), %rax
addq $0x120, %rax # imm = 0x120
movq %rax, -0x2d8(%rbp)
movq -0x2d8(%rbp), %rax
movq %rax, -0x2d0(%rbp)
movq -0x30(%rbp), %rdi
imulq $0x1200, -0x48(%rbp), %rax # imm = 0x1200
addq %rax, %rdi
movq -0x2d0(%rbp), %rsi
callq 0xbbfc0
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0xbc1c9
jmp 0xbc245
movq -0x28(%rbp), %rax
addq $0x7, %rax
shrq $0x3, %rax
movq %rax, -0x60(%rbp)
movq -0x70(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x70(%rbp)
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rax
movl $0x5, %ecx
xorl %edx, %edx
divq %rcx
movq %rdx, -0x58(%rbp)
movq -0x58(%rbp), %rcx
addq $0x1, %rcx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x58(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0xbc2ce
movq -0x68(%rbp), %rdi
movq -0x28(%rbp), %rsi
subq $0x1, %rsi
movq -0x58(%rbp), %rdx
addq $0x1, %rdx
callq 0xb9450
andq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0xbc2e1
movq -0x68(%rbp), %rax
movzbl (%rax), %eax
shll %eax
cltq
andq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movl $0x5, %esi
callq 0xb94b0
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0xbc670
movq %rax, -0x2c8(%rbp)
movq $0x1, -0x48(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0xbc4f4
jmp 0xbc320
movq -0x48(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xbc486
movq -0x70(%rbp), %rax
cmpq $0x0, (%rax)
je 0xbc353
movq -0x70(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x70(%rbp)
movq (%rax), %rax
movq %rax, -0x2e0(%rbp)
jmp 0xbc362
movq -0x68(%rbp), %rax
addq -0x60(%rbp), %rax
movq %rax, -0x2e0(%rbp)
movq -0x2e0(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
movq -0x28(%rbp), %rsi
subq $0x1, %rsi
movq -0x58(%rbp), %rdx
addq $0x1, %rdx
callq 0xb9450
andq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movl $0x5, %esi
callq 0xb94b0
movq %rax, -0x40(%rbp)
leaq -0x2b0(%rbp), %rdi
movq -0x30(%rbp), %rsi
imulq $0x1200, -0x48(%rbp), %rax # imm = 0x1200
addq %rax, %rsi
movq -0x40(%rbp), %rdx
callq 0xbc670
movq %rax, -0x2c0(%rbp)
leaq -0x190(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq -0x2b0(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xac870
movq -0x8(%rbp), %rdi
leaq -0x190(%rbp), %rsi
movq -0x2c8(%rbp), %rdx
orq -0x2c0(%rbp), %rdx
xorq $0x1, %rdx
callq 0xbbed0
movq -0x8(%rbp), %rdi
addq $0xc0, %rdi
movl $0x60, %esi
callq 0xa8cd0
movq %rax, -0x2b8(%rbp)
movq -0x2b8(%rbp), %rax
orq -0x2c8(%rbp), %rax
movq %rax, -0x2c8(%rbp)
movq -0x2b8(%rbp), %rax
orq -0x2c0(%rbp), %rax
movq %rax, -0x2c0(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x2b0(%rbp), %rsi
movq -0x2c8(%rbp), %rdx
callq 0xbbed0
movq -0x2c0(%rbp), %rax
andq -0x2c8(%rbp), %rax
movq %rax, -0x2c8(%rbp)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0xbc320
movq $0x0, -0x50(%rbp)
cmpq $0x5, -0x50(%rbp)
jae 0xbc4b0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xad560
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0xbc48e
movq $0x5, -0x58(%rbp)
movq -0x58(%rbp), %rcx
addq $0x1, %rcx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x58(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0xbc313
jmp 0xbc4f6
movq -0x48(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xbc64e
movq -0x70(%rbp), %rax
cmpq $0x0, (%rax)
je 0xbc529
movq -0x70(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x70(%rbp)
movq (%rax), %rax
movq %rax, -0x2e8(%rbp)
jmp 0xbc538
movq -0x68(%rbp), %rax
addq -0x60(%rbp), %rax
movq %rax, -0x2e8(%rbp)
movq -0x2e8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movzbl (%rax), %eax
shll %eax
cltq
andq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movl $0x5, %esi
callq 0xb94b0
movq %rax, -0x40(%rbp)
leaq -0x2b0(%rbp), %rdi
movq -0x30(%rbp), %rsi
imulq $0x1200, -0x48(%rbp), %rax # imm = 0x1200
addq %rax, %rsi
movq -0x40(%rbp), %rdx
callq 0xbc670
movq %rax, -0x2c0(%rbp)
leaq -0x190(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq -0x2b0(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xac870
movq -0x8(%rbp), %rdi
leaq -0x190(%rbp), %rsi
movq -0x2c8(%rbp), %rdx
orq -0x2c0(%rbp), %rdx
xorq $0x1, %rdx
callq 0xbbed0
movq -0x8(%rbp), %rdi
addq $0xc0, %rdi
movl $0x60, %esi
callq 0xa8cd0
movq %rax, -0x2b8(%rbp)
movq -0x2b8(%rbp), %rax
orq -0x2c8(%rbp), %rax
movq %rax, -0x2c8(%rbp)
movq -0x2b8(%rbp), %rax
orq -0x2c0(%rbp), %rax
movq %rax, -0x2c0(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x2b0(%rbp), %rsi
movq -0x2c8(%rbp), %rdx
callq 0xbbed0
movq -0x2c0(%rbp), %rax
andq -0x2c8(%rbp), %rax
movq %rax, -0x2c8(%rbp)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0xbc4f6
movq -0x8(%rbp), %rdi
addq $0xc0, %rdi
movq -0x2c8(%rbp), %rdx
movl $0x60, %esi
callq 0xb9600
movq %rbp, %rsp
popq %rbp
retq
nop
| POINTonE2s_mult_w5:
push rbp
mov rbp, rsp
sub rsp, 2F0h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_20]
mov [rbp+var_70], rax
cmp [rbp+var_30], 0
jnz short loc_BC1AB
mov rax, [rbp+var_18]
shl rax, 9
lea rcx, [rax+rax*8]
mov rax, rsp
sub rax, rcx
mov rsp, rax
mov [rbp+var_30], rax
loc_BC1AB:
cmp [rbp+var_10], 0
jz loc_BC245
mov [rbp+var_2D0], 0
mov [rbp+var_48], 0
loc_BC1C9:
mov rax, [rbp+var_48]
cmp rax, [rbp+var_18]
jnb short loc_BC243
mov rax, [rbp+var_10]
cmp qword ptr [rax], 0
jz short loc_BC1F8
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 8
mov [rbp+var_10], rcx
mov rax, [rax]
mov [rbp+var_2D8], rax
jmp short loc_BC20C
loc_BC1F8:
mov rax, [rbp+var_2D0]
add rax, 120h
mov [rbp+var_2D8], rax
loc_BC20C:
mov rax, [rbp+var_2D8]
mov [rbp+var_2D0], rax
mov rdi, [rbp+var_30]
imul rax, [rbp+var_48], 1200h
add rdi, rax
mov rsi, [rbp+var_2D0]
call POINTonE2_precompute_w5
mov rax, [rbp+var_48]
add rax, 1
mov [rbp+var_48], rax
jmp short loc_BC1C9
loc_BC243:
jmp short $+2
loc_BC245:
mov rax, [rbp+var_28]
add rax, 7
shr rax, 3
mov [rbp+var_60], rax
mov rax, [rbp+var_70]
mov rcx, rax
add rcx, 8
mov [rbp+var_70], rcx
mov rax, [rax]
mov [rbp+var_68], rax
mov rax, [rbp+var_28]
mov ecx, 5
xor edx, edx
div rcx
mov [rbp+var_58], rdx
mov rcx, [rbp+var_58]
add rcx, 1
mov eax, 1
shl rax, cl
sub rax, 1
mov [rbp+var_38], rax
mov rcx, [rbp+var_58]
mov rax, [rbp+var_28]
sub rax, rcx
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jbe short loc_BC2CE
mov rdi, [rbp+var_68]
mov rsi, [rbp+var_28]
sub rsi, 1
mov rdx, [rbp+var_58]
add rdx, 1
call get_wval
and rax, [rbp+var_38]
mov [rbp+var_40], rax
jmp short loc_BC2E1
loc_BC2CE:
mov rax, [rbp+var_68]
movzx eax, byte ptr [rax]
shl eax, 1
cdqe
and rax, [rbp+var_38]
mov [rbp+var_40], rax
loc_BC2E1:
mov rdi, [rbp+var_40]
mov esi, 5
call booth_encode
mov [rbp+var_40], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_40]
call POINTonE2_gather_booth_w5
mov [rbp+var_2C8], rax
mov [rbp+var_48], 1
loc_BC313:
cmp [rbp+var_28], 0
jbe loc_BC4F4
jmp short $+2
loc_BC320:
mov rax, [rbp+var_48]
cmp rax, [rbp+var_18]
jnb loc_BC486
mov rax, [rbp+var_70]
cmp qword ptr [rax], 0
jz short loc_BC353
mov rax, [rbp+var_70]
mov rcx, rax
add rcx, 8
mov [rbp+var_70], rcx
mov rax, [rax]
mov [rbp+var_2E0], rax
jmp short loc_BC362
loc_BC353:
mov rax, [rbp+var_68]
add rax, [rbp+var_60]
mov [rbp+var_2E0], rax
loc_BC362:
mov rax, [rbp+var_2E0]
mov [rbp+var_68], rax
mov rdi, [rbp+var_68]
mov rsi, [rbp+var_28]
sub rsi, 1
mov rdx, [rbp+var_58]
add rdx, 1
call get_wval
and rax, [rbp+var_38]
mov [rbp+var_40], rax
mov rdi, [rbp+var_40]
mov esi, 5
call booth_encode
mov [rbp+var_40], rax
lea rdi, [rbp+var_2B0]
mov rsi, [rbp+var_30]
imul rax, [rbp+var_48], 1200h
add rsi, rax
mov rdx, [rbp+var_40]
call POINTonE2_gather_booth_w5
mov [rbp+var_2C0], rax
lea rdi, [rbp+var_190]
mov rsi, [rbp+var_8]
lea rdx, [rbp+var_2B0]
xor eax, eax
mov ecx, eax
call POINTonE2_dadd
mov rdi, [rbp+var_8]
lea rsi, [rbp+var_190]
mov rdx, [rbp+var_2C8]
or rdx, [rbp+var_2C0]
xor rdx, 1
call POINTonE2_ccopy
mov rdi, [rbp+var_8]
add rdi, 0C0h
mov esi, 60h ; '`'
call vec_is_zero
mov [rbp+var_2B8], rax
mov rax, [rbp+var_2B8]
or rax, [rbp+var_2C8]
mov [rbp+var_2C8], rax
mov rax, [rbp+var_2B8]
or rax, [rbp+var_2C0]
mov [rbp+var_2C0], rax
mov rdi, [rbp+var_8]
lea rsi, [rbp+var_2B0]
mov rdx, [rbp+var_2C8]
call POINTonE2_ccopy
mov rax, [rbp+var_2C0]
and rax, [rbp+var_2C8]
mov [rbp+var_2C8], rax
mov rax, [rbp+var_48]
add rax, 1
mov [rbp+var_48], rax
jmp loc_BC320
loc_BC486:
mov [rbp+var_50], 0
loc_BC48E:
cmp [rbp+var_50], 5
jnb short loc_BC4B0
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_8]
call POINTonE2_double
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_50], rax
jmp short loc_BC48E
loc_BC4B0:
mov [rbp+var_58], 5
mov rcx, [rbp+var_58]
add rcx, 1
mov eax, 1
shl rax, cl
sub rax, 1
mov [rbp+var_38], rax
mov rcx, [rbp+var_58]
mov rax, [rbp+var_28]
sub rax, rcx
mov [rbp+var_28], rax
mov [rbp+var_48], 0
mov rax, [rbp+var_20]
mov [rbp+var_70], rax
jmp loc_BC313
loc_BC4F4:
jmp short $+2
loc_BC4F6:
mov rax, [rbp+var_48]
cmp rax, [rbp+var_18]
jnb loc_BC64E
mov rax, [rbp+var_70]
cmp qword ptr [rax], 0
jz short loc_BC529
mov rax, [rbp+var_70]
mov rcx, rax
add rcx, 8
mov [rbp+var_70], rcx
mov rax, [rax]
mov [rbp+var_2E8], rax
jmp short loc_BC538
loc_BC529:
mov rax, [rbp+var_68]
add rax, [rbp+var_60]
mov [rbp+var_2E8], rax
loc_BC538:
mov rax, [rbp+var_2E8]
mov [rbp+var_68], rax
mov rax, [rbp+var_68]
movzx eax, byte ptr [rax]
shl eax, 1
cdqe
and rax, [rbp+var_38]
mov [rbp+var_40], rax
mov rdi, [rbp+var_40]
mov esi, 5
call booth_encode
mov [rbp+var_40], rax
lea rdi, [rbp+var_2B0]
mov rsi, [rbp+var_30]
imul rax, [rbp+var_48], 1200h
add rsi, rax
mov rdx, [rbp+var_40]
call POINTonE2_gather_booth_w5
mov [rbp+var_2C0], rax
lea rdi, [rbp+var_190]
mov rsi, [rbp+var_8]
lea rdx, [rbp+var_2B0]
xor eax, eax
mov ecx, eax
call POINTonE2_dadd
mov rdi, [rbp+var_8]
lea rsi, [rbp+var_190]
mov rdx, [rbp+var_2C8]
or rdx, [rbp+var_2C0]
xor rdx, 1
call POINTonE2_ccopy
mov rdi, [rbp+var_8]
add rdi, 0C0h
mov esi, 60h ; '`'
call vec_is_zero
mov [rbp+var_2B8], rax
mov rax, [rbp+var_2B8]
or rax, [rbp+var_2C8]
mov [rbp+var_2C8], rax
mov rax, [rbp+var_2B8]
or rax, [rbp+var_2C0]
mov [rbp+var_2C0], rax
mov rdi, [rbp+var_8]
lea rsi, [rbp+var_2B0]
mov rdx, [rbp+var_2C8]
call POINTonE2_ccopy
mov rax, [rbp+var_2C0]
and rax, [rbp+var_2C8]
mov [rbp+var_2C8], rax
mov rax, [rbp+var_48]
add rax, 1
mov [rbp+var_48], rax
jmp loc_BC4F6
loc_BC64E:
mov rdi, [rbp+var_8]
add rdi, 0C0h
mov rdx, [rbp+var_2C8]
mov esi, 60h ; '`'
call vec_czero
mov rsp, rbp
pop rbp
retn
| unsigned long long POINTonE2s_mult_w5(
long long a1,
long long *a2,
unsigned long long a3,
unsigned __int8 **a4,
unsigned long long a5,
long long *a6)
{
long long *v6; // rax
unsigned __int8 **v7; // rax
unsigned long long wval; // rax
unsigned __int8 **v9; // rax
unsigned long long v10; // rax
unsigned __int8 **v11; // rax
long long v13; // [rsp+0h] [rbp-2F0h] BYREF
unsigned __int8 *v14; // [rsp+8h] [rbp-2E8h]
unsigned __int8 *v15; // [rsp+10h] [rbp-2E0h]
long long v16; // [rsp+18h] [rbp-2D8h]
long long v17; // [rsp+20h] [rbp-2D0h]
long long v18; // [rsp+28h] [rbp-2C8h]
long long v19; // [rsp+30h] [rbp-2C0h]
unsigned long long is_zero; // [rsp+38h] [rbp-2B8h]
_BYTE v21[288]; // [rsp+40h] [rbp-2B0h] BYREF
_BYTE v22[288]; // [rsp+160h] [rbp-190h] BYREF
unsigned __int8 **v23; // [rsp+280h] [rbp-70h]
unsigned __int8 *v24; // [rsp+288h] [rbp-68h]
unsigned long long v25; // [rsp+290h] [rbp-60h]
unsigned long long v26; // [rsp+298h] [rbp-58h]
unsigned long long j; // [rsp+2A0h] [rbp-50h]
unsigned long long i; // [rsp+2A8h] [rbp-48h]
unsigned long long v29; // [rsp+2B0h] [rbp-40h]
long long v30; // [rsp+2B8h] [rbp-38h]
long long *v31; // [rsp+2C0h] [rbp-30h]
unsigned long long v32; // [rsp+2C8h] [rbp-28h]
unsigned __int8 **v33; // [rsp+2D0h] [rbp-20h]
unsigned long long v34; // [rsp+2D8h] [rbp-18h]
long long *v35; // [rsp+2E0h] [rbp-10h]
long long v36; // [rsp+2E8h] [rbp-8h]
v36 = a1;
v35 = a2;
v34 = a3;
v33 = a4;
v32 = a5;
v31 = a6;
v23 = a4;
if ( !a6 )
v31 = &v13 - 576 * v34;
if ( v35 )
{
v17 = 0LL;
for ( i = 0LL; i < v34; ++i )
{
if ( *v35 )
{
v6 = v35++;
v16 = *v6;
}
else
{
v16 = v17 + 288;
}
v17 = v16;
POINTonE2_precompute_w5((long long)&v31[576 * i], v16);
}
}
v25 = (v32 + 7) >> 3;
v7 = v23++;
v24 = *v7;
v26 = v32 % 5;
v30 = (1LL << ((unsigned __int8)(v32 % 5) + 1)) - 1;
v32 -= v32 % 5;
if ( v32 )
{
wval = get_wval((long long)v24, v32 - 1, v26 + 1);
v29 = v30 & wval;
}
else
{
v29 = v30 & (2 * *v24);
}
v29 = booth_encode(v29, 5);
v18 = POINTonE2_gather_booth_w5(v36, v31, v29);
i = 1LL;
while ( v32 )
{
while ( i < v34 )
{
if ( *v23 )
{
v9 = v23++;
v15 = *v9;
}
else
{
v15 = &v24[v25];
}
v24 = v15;
v10 = get_wval((long long)v15, v32 - 1, v26 + 1);
v29 = v30 & v10;
v29 = booth_encode(v30 & v10, 5);
v19 = POINTonE2_gather_booth_w5(v21, &v31[576 * i], v29);
POINTonE2_dadd((long long)v22, v36, (long long)v21, 0LL);
POINTonE2_ccopy(v36, (long long)v22, (v19 | v18) ^ 1);
is_zero = vec_is_zero(v36 + 192, 0x60uLL);
v18 |= is_zero;
v19 |= is_zero;
POINTonE2_ccopy(v36, (long long)v21, v18);
v18 &= v19;
++i;
}
for ( j = 0LL; j < 5; ++j )
POINTonE2_double(v36, v36);
v26 = 5LL;
v30 = 63LL;
v32 -= 5LL;
i = 0LL;
v23 = v33;
}
while ( i < v34 )
{
if ( *v23 )
{
v11 = v23++;
v14 = *v11;
}
else
{
v14 = &v24[v25];
}
v24 = v14;
v29 = v30 & (2 * *v14);
v29 = booth_encode(v29, 5);
v19 = POINTonE2_gather_booth_w5(v21, &v31[576 * i], v29);
POINTonE2_dadd((long long)v22, v36, (long long)v21, 0LL);
POINTonE2_ccopy(v36, (long long)v22, (v19 | v18) ^ 1);
is_zero = vec_is_zero(v36 + 192, 0x60uLL);
v18 |= is_zero;
v19 |= is_zero;
POINTonE2_ccopy(v36, (long long)v21, v18);
v18 &= v19;
++i;
}
return vec_czero(v36 + 192, 0x60uLL, v18);
}
| POINTonE2s_mult_w5:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x2f0
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x70],RAX
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x001bc1ab
MOV RAX,qword ptr [RBP + -0x18]
SHL RAX,0x9
LEA RCX,[RAX + RAX*0x8]
MOV RAX,RSP
SUB RAX,RCX
MOV RSP,RAX
MOV qword ptr [RBP + -0x30],RAX
LAB_001bc1ab:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x001bc245
MOV qword ptr [RBP + -0x2d0],0x0
MOV qword ptr [RBP + -0x48],0x0
LAB_001bc1c9:
MOV RAX,qword ptr [RBP + -0x48]
CMP RAX,qword ptr [RBP + -0x18]
JNC 0x001bc243
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX],0x0
JZ 0x001bc1f8
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x8
MOV qword ptr [RBP + -0x10],RCX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x2d8],RAX
JMP 0x001bc20c
LAB_001bc1f8:
MOV RAX,qword ptr [RBP + -0x2d0]
ADD RAX,0x120
MOV qword ptr [RBP + -0x2d8],RAX
LAB_001bc20c:
MOV RAX,qword ptr [RBP + -0x2d8]
MOV qword ptr [RBP + -0x2d0],RAX
MOV RDI,qword ptr [RBP + -0x30]
IMUL RAX,qword ptr [RBP + -0x48],0x1200
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x2d0]
CALL 0x001bbfc0
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,0x1
MOV qword ptr [RBP + -0x48],RAX
JMP 0x001bc1c9
LAB_001bc243:
JMP 0x001bc245
LAB_001bc245:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x7
SHR RAX,0x3
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x70]
MOV RCX,RAX
ADD RCX,0x8
MOV qword ptr [RBP + -0x70],RCX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,0x5
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x58],RDX
MOV RCX,qword ptr [RBP + -0x58]
ADD RCX,0x1
MOV EAX,0x1
SHL RAX,CL
SUB RAX,0x1
MOV qword ptr [RBP + -0x38],RAX
MOV RCX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JBE 0x001bc2ce
MOV RDI,qword ptr [RBP + -0x68]
MOV RSI,qword ptr [RBP + -0x28]
SUB RSI,0x1
MOV RDX,qword ptr [RBP + -0x58]
ADD RDX,0x1
CALL 0x001b9450
AND RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x40],RAX
JMP 0x001bc2e1
LAB_001bc2ce:
MOV RAX,qword ptr [RBP + -0x68]
MOVZX EAX,byte ptr [RAX]
SHL EAX,0x1
CDQE
AND RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x40],RAX
LAB_001bc2e1:
MOV RDI,qword ptr [RBP + -0x40]
MOV ESI,0x5
CALL 0x001b94b0
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x40]
CALL 0x001bc670
MOV qword ptr [RBP + -0x2c8],RAX
MOV qword ptr [RBP + -0x48],0x1
LAB_001bc313:
CMP qword ptr [RBP + -0x28],0x0
JBE 0x001bc4f4
JMP 0x001bc320
LAB_001bc320:
MOV RAX,qword ptr [RBP + -0x48]
CMP RAX,qword ptr [RBP + -0x18]
JNC 0x001bc486
MOV RAX,qword ptr [RBP + -0x70]
CMP qword ptr [RAX],0x0
JZ 0x001bc353
MOV RAX,qword ptr [RBP + -0x70]
MOV RCX,RAX
ADD RCX,0x8
MOV qword ptr [RBP + -0x70],RCX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x2e0],RAX
JMP 0x001bc362
LAB_001bc353:
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x2e0],RAX
LAB_001bc362:
MOV RAX,qword ptr [RBP + -0x2e0]
MOV qword ptr [RBP + -0x68],RAX
MOV RDI,qword ptr [RBP + -0x68]
MOV RSI,qword ptr [RBP + -0x28]
SUB RSI,0x1
MOV RDX,qword ptr [RBP + -0x58]
ADD RDX,0x1
CALL 0x001b9450
AND RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x40]
MOV ESI,0x5
CALL 0x001b94b0
MOV qword ptr [RBP + -0x40],RAX
LEA RDI,[RBP + -0x2b0]
MOV RSI,qword ptr [RBP + -0x30]
IMUL RAX,qword ptr [RBP + -0x48],0x1200
ADD RSI,RAX
MOV RDX,qword ptr [RBP + -0x40]
CALL 0x001bc670
MOV qword ptr [RBP + -0x2c0],RAX
LEA RDI,[RBP + -0x190]
MOV RSI,qword ptr [RBP + -0x8]
LEA RDX,[RBP + -0x2b0]
XOR EAX,EAX
MOV ECX,EAX
CALL 0x001ac870
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[RBP + -0x190]
MOV RDX,qword ptr [RBP + -0x2c8]
OR RDX,qword ptr [RBP + -0x2c0]
XOR RDX,0x1
CALL 0x001bbed0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc0
MOV ESI,0x60
CALL 0x001a8cd0
MOV qword ptr [RBP + -0x2b8],RAX
MOV RAX,qword ptr [RBP + -0x2b8]
OR RAX,qword ptr [RBP + -0x2c8]
MOV qword ptr [RBP + -0x2c8],RAX
MOV RAX,qword ptr [RBP + -0x2b8]
OR RAX,qword ptr [RBP + -0x2c0]
MOV qword ptr [RBP + -0x2c0],RAX
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[RBP + -0x2b0]
MOV RDX,qword ptr [RBP + -0x2c8]
CALL 0x001bbed0
MOV RAX,qword ptr [RBP + -0x2c0]
AND RAX,qword ptr [RBP + -0x2c8]
MOV qword ptr [RBP + -0x2c8],RAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,0x1
MOV qword ptr [RBP + -0x48],RAX
JMP 0x001bc320
LAB_001bc486:
MOV qword ptr [RBP + -0x50],0x0
LAB_001bc48e:
CMP qword ptr [RBP + -0x50],0x5
JNC 0x001bc4b0
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x8]
CALL 0x001ad560
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
JMP 0x001bc48e
LAB_001bc4b0:
MOV qword ptr [RBP + -0x58],0x5
MOV RCX,qword ptr [RBP + -0x58]
ADD RCX,0x1
MOV EAX,0x1
SHL RAX,CL
SUB RAX,0x1
MOV qword ptr [RBP + -0x38],RAX
MOV RCX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV qword ptr [RBP + -0x48],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x70],RAX
JMP 0x001bc313
LAB_001bc4f4:
JMP 0x001bc4f6
LAB_001bc4f6:
MOV RAX,qword ptr [RBP + -0x48]
CMP RAX,qword ptr [RBP + -0x18]
JNC 0x001bc64e
MOV RAX,qword ptr [RBP + -0x70]
CMP qword ptr [RAX],0x0
JZ 0x001bc529
MOV RAX,qword ptr [RBP + -0x70]
MOV RCX,RAX
ADD RCX,0x8
MOV qword ptr [RBP + -0x70],RCX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x2e8],RAX
JMP 0x001bc538
LAB_001bc529:
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x2e8],RAX
LAB_001bc538:
MOV RAX,qword ptr [RBP + -0x2e8]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x68]
MOVZX EAX,byte ptr [RAX]
SHL EAX,0x1
CDQE
AND RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x40]
MOV ESI,0x5
CALL 0x001b94b0
MOV qword ptr [RBP + -0x40],RAX
LEA RDI,[RBP + -0x2b0]
MOV RSI,qword ptr [RBP + -0x30]
IMUL RAX,qword ptr [RBP + -0x48],0x1200
ADD RSI,RAX
MOV RDX,qword ptr [RBP + -0x40]
CALL 0x001bc670
MOV qword ptr [RBP + -0x2c0],RAX
LEA RDI,[RBP + -0x190]
MOV RSI,qword ptr [RBP + -0x8]
LEA RDX,[RBP + -0x2b0]
XOR EAX,EAX
MOV ECX,EAX
CALL 0x001ac870
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[RBP + -0x190]
MOV RDX,qword ptr [RBP + -0x2c8]
OR RDX,qword ptr [RBP + -0x2c0]
XOR RDX,0x1
CALL 0x001bbed0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc0
MOV ESI,0x60
CALL 0x001a8cd0
MOV qword ptr [RBP + -0x2b8],RAX
MOV RAX,qword ptr [RBP + -0x2b8]
OR RAX,qword ptr [RBP + -0x2c8]
MOV qword ptr [RBP + -0x2c8],RAX
MOV RAX,qword ptr [RBP + -0x2b8]
OR RAX,qword ptr [RBP + -0x2c0]
MOV qword ptr [RBP + -0x2c0],RAX
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[RBP + -0x2b0]
MOV RDX,qword ptr [RBP + -0x2c8]
CALL 0x001bbed0
MOV RAX,qword ptr [RBP + -0x2c0]
AND RAX,qword ptr [RBP + -0x2c8]
MOV qword ptr [RBP + -0x2c8],RAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,0x1
MOV qword ptr [RBP + -0x48],RAX
JMP 0x001bc4f6
LAB_001bc64e:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc0
MOV RDX,qword ptr [RBP + -0x2c8]
MOV ESI,0x60
CALL 0x001b9600
MOV RSP,RBP
POP RBP
RET
|
void POINTonE2s_mult_w5(long param_1,long *param_2,ulong param_3,long *param_4,ulong param_5,
int1 *param_6)
{
byte *pbVar1;
int8 uVar2;
ulong uVar3;
long lVar4;
int1 *puVar5;
long lVar6;
int1 *puVar7;
int1 auStack_2f8 [8];
byte *local_2f0;
byte *local_2e8;
long local_2e0;
long local_2d8;
ulong local_2d0;
ulong local_2c8;
ulong local_2c0;
int1 local_2b8 [288];
int1 local_198 [288];
long *local_78;
byte *local_70;
ulong local_68;
ulong local_60;
ulong local_58;
ulong local_50;
ulong local_48;
ulong local_40;
int1 *local_38;
ulong local_30;
long *local_28;
ulong local_20;
long *local_18;
long local_10;
puVar5 = auStack_2f8;
local_38 = param_6;
if (param_6 == (int1 *)0x0) {
puVar5 = auStack_2f8 + param_3 * -0x1200;
local_38 = puVar5;
}
local_78 = param_4;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
if (param_2 != (long *)0x0) {
local_2d8 = 0;
for (local_50 = 0; local_50 < local_20; local_50 = local_50 + 1) {
if (*local_18 == 0) {
local_2e0 = local_2d8 + 0x120;
}
else {
local_2e0 = *local_18;
local_18 = local_18 + 1;
}
lVar4 = local_2e0;
local_2d8 = local_2e0;
puVar7 = local_38 + local_50 * 0x1200;
*(int8 *)(puVar5 + -8) = 0x1bc235;
POINTonE2_precompute_w5(puVar7,lVar4);
}
}
local_68 = local_30 + 7 >> 3;
pbVar1 = (byte *)*local_78;
local_60 = local_30 % 5;
local_40 = (1L << (char)local_60 + 1) - 1;
local_30 = local_30 - local_60;
local_70 = pbVar1;
if (local_30 == 0) {
local_48 = (long)(int)((uint)*pbVar1 << 1) & local_40;
local_78 = local_78 + 1;
}
else {
lVar6 = local_30 + -1;
lVar4 = local_60 + 1;
local_78 = local_78 + 1;
*(int8 *)(puVar5 + -8) = 0x1bc2c4;
local_48 = get_wval(pbVar1,lVar6,lVar4);
local_48 = local_48 & local_40;
}
uVar3 = local_48;
*(int8 *)(puVar5 + -8) = 0x1bc2ef;
uVar2 = booth_encode(uVar3,5);
lVar4 = local_10;
puVar7 = local_38;
local_48 = uVar2;
*(int8 *)(puVar5 + -8) = 0x1bc304;
local_2d0 = POINTonE2_gather_booth_w5(lVar4,puVar7,uVar2);
local_50 = 1;
for (; local_30 != 0; local_30 = local_30 + -5) {
for (; local_50 < local_20; local_50 = local_50 + 1) {
if (*local_78 == 0) {
local_2e8 = local_70 + local_68;
}
else {
local_2e8 = (byte *)*local_78;
local_78 = local_78 + 1;
}
pbVar1 = local_2e8;
local_70 = local_2e8;
lVar6 = local_30 + -1;
lVar4 = local_60 + 1;
*(int8 *)(puVar5 + -8) = 0x1bc386;
uVar3 = get_wval(pbVar1,lVar6,lVar4);
uVar3 = uVar3 & local_40;
local_48 = uVar3;
*(int8 *)(puVar5 + -8) = 0x1bc39c;
uVar2 = booth_encode(uVar3,5);
puVar7 = local_38 + local_50 * 0x1200;
local_48 = uVar2;
*(int8 *)(puVar5 + -8) = 0x1bc3bf;
local_2c8 = POINTonE2_gather_booth_w5(local_2b8,puVar7,uVar2);
lVar4 = local_10;
*(int8 *)(puVar5 + -8) = 0x1bc3e1;
POINTonE2_dadd(local_198,lVar4,local_2b8,0);
lVar4 = local_10;
uVar3 = local_2d0 | local_2c8;
*(int8 *)(puVar5 + -8) = 0x1bc403;
POINTonE2_ccopy(lVar4,local_198,uVar3 ^ 1);
lVar4 = local_10 + 0xc0;
*(int8 *)(puVar5 + -8) = 0x1bc418;
local_2c0 = vec_is_zero(lVar4,0x60);
lVar4 = local_10;
uVar3 = local_2c0 | local_2d0;
local_2c8 = local_2c0 | local_2c8;
local_2d0 = uVar3;
*(int8 *)(puVar5 + -8) = 0x1bc460;
POINTonE2_ccopy(lVar4,local_2b8,uVar3);
local_2d0 = local_2c8 & local_2d0;
}
for (local_58 = 0; lVar4 = local_10, local_58 < 5; local_58 = local_58 + 1) {
*(int8 *)(puVar5 + -8) = 0x1bc4a2;
POINTonE2_double(lVar4,lVar4);
}
local_60 = 5;
local_40 = 0x3f;
local_50 = 0;
local_78 = local_28;
}
for (; uVar3 = local_2d0, local_50 < local_20; local_50 = local_50 + 1) {
if (*local_78 == 0) {
local_2f0 = local_70 + local_68;
}
else {
local_2f0 = (byte *)*local_78;
local_78 = local_78 + 1;
}
local_70 = local_2f0;
uVar3 = (long)(int)((uint)*local_2f0 << 1) & local_40;
local_48 = uVar3;
*(int8 *)(puVar5 + -8) = 0x1bc564;
uVar2 = booth_encode(uVar3,5);
puVar7 = local_38 + local_50 * 0x1200;
local_48 = uVar2;
*(int8 *)(puVar5 + -8) = 0x1bc587;
local_2c8 = POINTonE2_gather_booth_w5(local_2b8,puVar7,uVar2);
lVar4 = local_10;
*(int8 *)(puVar5 + -8) = 0x1bc5a9;
POINTonE2_dadd(local_198,lVar4,local_2b8,0);
lVar4 = local_10;
uVar3 = local_2d0 | local_2c8;
*(int8 *)(puVar5 + -8) = 0x1bc5cb;
POINTonE2_ccopy(lVar4,local_198,uVar3 ^ 1);
lVar4 = local_10 + 0xc0;
*(int8 *)(puVar5 + -8) = 0x1bc5e0;
local_2c0 = vec_is_zero(lVar4,0x60);
lVar4 = local_10;
uVar3 = local_2c0 | local_2d0;
local_2c8 = local_2c0 | local_2c8;
local_2d0 = uVar3;
*(int8 *)(puVar5 + -8) = 0x1bc628;
POINTonE2_ccopy(lVar4,local_2b8,uVar3);
local_2d0 = local_2c8 & local_2d0;
}
lVar4 = local_10 + 0xc0;
*(int8 *)(puVar5 + -8) = 0x1bc66a;
vec_czero(lVar4,0x60,uVar3);
return;
}
| |
45,633 | partitioned_key_cache_insert | eloqsql/mysys/mf_keycache.c | static
int partitioned_key_cache_insert(PARTITIONED_KEY_CACHE_CB *keycache,
File file, my_off_t filepos, int level,
uchar *buff, uint length)
{
uint w_length;
uint offset= (uint) (filepos % keycache->key_cache_block_size);
DBUG_ENTER("partitioned_key_cache_insert");
DBUG_PRINT("enter", ("fd: %u pos: %lu length: %u",
(uint) file,(ulong) filepos, length));
/* Write data in key_cache_block_size increments */
do
{
SIMPLE_KEY_CACHE_CB *partition= get_key_cache_partition(keycache,
file, filepos);
w_length= length;
set_if_smaller(w_length, keycache->key_cache_block_size - offset);
if (simple_key_cache_insert((void *) partition,
file, filepos, level,
buff, w_length))
DBUG_RETURN(1);
filepos+= w_length;
buff+= w_length;
offset = 0;
} while ((length-= w_length));
DBUG_RETURN(0);
} | O3 | c | partitioned_key_cache_insert:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebx
movq %r8, %r14
movl %ecx, -0x2c(%rbp)
movq %rdx, %r12
movq %rdi, %r13
movl 0x18(%rdi), %ecx
movq %rdx, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %rcx
movslq %esi, %rax
movq %rax, -0x38(%rbp)
movl 0x18(%r13), %r15d
movq %r12, %rax
xorl %edx, %edx
divq %r15
movq -0x38(%rbp), %rsi
addq %rsi, %rax
movl 0x1c(%r13), %edi
xorl %edx, %edx
divq %rdi
movq 0x8(%r13), %rax
movq (%rax,%rdx,8), %rdi
subl %ecx, %r15d
cmpl %r15d, %ebx
cmovbl %ebx, %r15d
movq %r12, %rdx
movl -0x2c(%rbp), %ecx
movq %r14, %r8
movl %r15d, %r9d
callq 0x991ef
testl %eax, %eax
jne 0x9ab02
movl %r15d, %eax
addq %rax, %r14
addq %rax, %r12
xorl %ecx, %ecx
subl %r15d, %ebx
jne 0x9aaad
jmp 0x9ab07
movl $0x1, %ecx
movl %ecx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| partitioned_key_cache_insert:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov ebx, r9d
mov r14, r8
mov [rbp+var_2C], ecx
mov r12, rdx
mov r13, rdi
mov ecx, [rdi+18h]
mov rax, rdx
xor edx, edx
div rcx
mov rcx, rdx
movsxd rax, esi
mov [rbp+var_38], rax
loc_9AAAD:
mov r15d, [r13+18h]
mov rax, r12
xor edx, edx
div r15
mov rsi, [rbp+var_38]
add rax, rsi
mov edi, [r13+1Ch]
xor edx, edx
div rdi
mov rax, [r13+8]
mov rdi, [rax+rdx*8]
sub r15d, ecx
cmp ebx, r15d
cmovb r15d, ebx
mov rdx, r12
mov ecx, [rbp+var_2C]
mov r8, r14
mov r9d, r15d
call simple_key_cache_insert
test eax, eax
jnz short loc_9AB02
mov eax, r15d
add r14, rax
add r12, rax
xor ecx, ecx
sub ebx, r15d
jnz short loc_9AAAD
jmp short loc_9AB07
loc_9AB02:
mov ecx, 1
loc_9AB07:
mov eax, ecx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long partitioned_key_cache_insert(
long long a1,
signed int a2,
unsigned long long a3,
int a4,
long long a5,
unsigned int a6)
{
unsigned long long v8; // r12
unsigned long long v9; // rcx
unsigned int v10; // r15d
v8 = a3;
v9 = a3 % *(unsigned int *)(a1 + 24);
while ( 1 )
{
v10 = *(_DWORD *)(a1 + 24) - v9;
if ( a6 < v10 )
v10 = a6;
if ( (unsigned int)simple_key_cache_insert(
*(__m128i **)(*(_QWORD *)(a1 + 8)
+ 8 * ((a2 + v8 / *(unsigned int *)(a1 + 24)) % *(unsigned int *)(a1 + 28))),
a2,
v8,
a4,
a5,
v10) )
break;
a5 += v10;
v8 += v10;
LODWORD(v9) = 0;
a6 -= v10;
if ( !a6 )
return (unsigned int)v9;
}
LODWORD(v9) = 1;
return (unsigned int)v9;
}
| partitioned_key_cache_insert:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV EBX,R9D
MOV R14,R8
MOV dword ptr [RBP + -0x2c],ECX
MOV R12,RDX
MOV R13,RDI
MOV ECX,dword ptr [RDI + 0x18]
MOV RAX,RDX
XOR EDX,EDX
DIV RCX
MOV RCX,RDX
MOVSXD RAX,ESI
MOV qword ptr [RBP + -0x38],RAX
LAB_0019aaad:
MOV R15D,dword ptr [R13 + 0x18]
MOV RAX,R12
XOR EDX,EDX
DIV R15
MOV RSI,qword ptr [RBP + -0x38]
ADD RAX,RSI
MOV EDI,dword ptr [R13 + 0x1c]
XOR EDX,EDX
DIV RDI
MOV RAX,qword ptr [R13 + 0x8]
MOV RDI,qword ptr [RAX + RDX*0x8]
SUB R15D,ECX
CMP EBX,R15D
CMOVC R15D,EBX
MOV RDX,R12
MOV ECX,dword ptr [RBP + -0x2c]
MOV R8,R14
MOV R9D,R15D
CALL 0x001991ef
TEST EAX,EAX
JNZ 0x0019ab02
MOV EAX,R15D
ADD R14,RAX
ADD R12,RAX
XOR ECX,ECX
SUB EBX,R15D
JNZ 0x0019aaad
JMP 0x0019ab07
LAB_0019ab02:
MOV ECX,0x1
LAB_0019ab07:
MOV EAX,ECX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
partitioned_key_cache_insert
(long param_1,int param_2,ulong param_3,int4 param_4,long param_5,uint param_6)
{
int iVar1;
ulong uVar2;
uint uVar3;
uVar2 = param_3 % (ulong)*(uint *)(param_1 + 0x18);
while( true ) {
uVar3 = *(uint *)(param_1 + 0x18) - (int)uVar2;
if (param_6 < uVar3) {
uVar3 = param_6;
}
iVar1 = simple_key_cache_insert
(*(int8 *)
(*(long *)(param_1 + 8) +
((param_3 / *(uint *)(param_1 + 0x18) + (long)param_2) %
(ulong)*(uint *)(param_1 + 0x1c)) * 8),(long)param_2,param_3,param_4,param_5
,uVar3);
if (iVar1 != 0) break;
param_5 = param_5 + (ulong)uVar3;
param_3 = param_3 + uVar3;
uVar2 = 0;
param_6 = param_6 - uVar3;
if (param_6 == 0) {
return 0;
}
}
return 1;
}
| |
45,634 | MNN::CreateLSTMBlockCell(flatbuffers::FlatBufferBuilder&, MNN::LSTMBlockCellT const*, std::__1::function<unsigned long (void*)> const*) | mnn-tts/MNN/schema/current/TensorflowOp_generated.h | inline flatbuffers::Offset<LSTMBlockCell> CreateLSTMBlockCell(flatbuffers::FlatBufferBuilder &_fbb, const LSTMBlockCellT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LSTMBlockCellT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _cell_clip = _o->cell_clip;
auto _forget_bias = _o->forget_bias;
auto _use_peephole = _o->use_peephole;
return MNN::CreateLSTMBlockCell(
_fbb,
_cell_clip,
_forget_bias,
_use_peephole);
} | O0 | c | MNN::CreateLSTMBlockCell(flatbuffers::FlatBufferBuilder&, MNN::LSTMBlockCellT const*, std::__1::function<unsigned long (void*)> const*):
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x30(%rsp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, 0x8(%rsp)
movq 0x30(%rsp), %rax
movb 0x8(%rax), %al
andb $0x1, %al
movb %al, 0x7(%rsp)
movq 0x38(%rsp), %rdi
movss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
movb 0x7(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x58650
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
| _ZN3MNN19CreateLSTMBlockCellERN11flatbuffers17FlatBufferBuilderEPKNS_14LSTMBlockCellTEPKNSt3__18functionIFmPvEEE:
sub rsp, 48h
mov [rsp+48h+var_10], rdi
mov [rsp+48h+var_18], rsi
mov [rsp+48h+var_20], rdx
mov rax, [rsp+48h+var_10]
mov [rsp+48h+var_38], rax
mov rax, [rsp+48h+var_18]
mov [rsp+48h+var_30], rax
mov rax, [rsp+48h+var_20]
mov [rsp+48h+var_28], rax
mov rax, [rsp+48h+var_18]
movss xmm0, dword ptr [rax]
movss [rsp+48h+var_3C], xmm0
mov rax, [rsp+48h+var_18]
movss xmm0, dword ptr [rax+4]
movss [rsp+48h+var_40], xmm0
mov rax, [rsp+48h+var_18]
mov al, [rax+8]
and al, 1
mov [rsp+48h+var_41], al
mov rdi, [rsp+48h+var_10]; this
movss xmm0, [rsp+48h+var_3C]; float
movss xmm1, [rsp+48h+var_40]; float
mov al, [rsp+48h+var_41]
and al, 1
movzx esi, al; flatbuffers::FlatBufferBuilder *
call _ZN3MNN19CreateLSTMBlockCellERN11flatbuffers17FlatBufferBuilderEffb; MNN::CreateLSTMBlockCell(flatbuffers::FlatBufferBuilder &,float,float,bool)
mov [rsp+48h+var_4], eax
mov eax, [rsp+48h+var_4]
add rsp, 48h
retn
| long long MNN::CreateLSTMBlockCell(MNN *a1, long long a2, bool a3)
{
return (unsigned int)MNN::CreateLSTMBlockCell(
a1,
(flatbuffers::FlatBufferBuilder *)(*(_BYTE *)(a2 + 8) & 1),
*(float *)a2,
*(float *)(a2 + 4),
a3);
}
| CreateLSTMBlockCell:
SUB RSP,0x48
MOV qword ptr [RSP + 0x38],RDI
MOV qword ptr [RSP + 0x30],RSI
MOV qword ptr [RSP + 0x28],RDX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x30]
MOVSS XMM0,dword ptr [RAX]
MOVSS dword ptr [RSP + 0xc],XMM0
MOV RAX,qword ptr [RSP + 0x30]
MOVSS XMM0,dword ptr [RAX + 0x4]
MOVSS dword ptr [RSP + 0x8],XMM0
MOV RAX,qword ptr [RSP + 0x30]
MOV AL,byte ptr [RAX + 0x8]
AND AL,0x1
MOV byte ptr [RSP + 0x7],AL
MOV RDI,qword ptr [RSP + 0x38]
MOVSS XMM0,dword ptr [RSP + 0xc]
MOVSS XMM1,dword ptr [RSP + 0x8]
MOV AL,byte ptr [RSP + 0x7]
AND AL,0x1
MOVZX ESI,AL
CALL 0x00158650
MOV dword ptr [RSP + 0x44],EAX
MOV EAX,dword ptr [RSP + 0x44]
ADD RSP,0x48
RET
|
/* MNN::CreateLSTMBlockCell(flatbuffers::FlatBufferBuilder&, MNN::LSTMBlockCellT const*,
std::function<unsigned long (void*)> const*) */
int4
MNN::CreateLSTMBlockCell(FlatBufferBuilder *param_1,LSTMBlockCellT *param_2,function *param_3)
{
int4 uVar1;
uVar1 = CreateLSTMBlockCell(param_1,*(float *)param_2,*(float *)(param_2 + 4),
(bool)((byte)param_2[8] & 1));
return uVar1;
}
| |
45,635 | my_strnncoll_win1250ch | eloqsql/strings/ctype-win1250ch.c | static int my_strnncoll_win1250ch(CHARSET_INFO *cs __attribute__((unused)),
const uchar *s1, size_t len1,
const uchar *s2, size_t len2,
my_bool s2_is_prefix)
{
int v1, v2;
const uchar *p1, * p2;
int pass1 = 0, pass2 = 0;
int diff;
if (s2_is_prefix && len1 > len2)
len1=len2;
p1 = s1; p2 = s2;
do
{
NEXT_CMP_VALUE(s1, p1, pass1, v1, (int)len1);
NEXT_CMP_VALUE(s2, p2, pass2, v2, (int)len2);
if ((diff = v1 - v2))
return diff;
} while (v1);
return 0;
} | O3 | c | my_strnncoll_win1250ch:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpq %r8, %rdx
movq %r8, %rax
cmovbq %rdx, %rax
testb %r9b, %r9b
cmoveq %rdx, %rax
movq %rax, -0x70(%rbp)
movslq %eax, %rdx
movq %r8, -0x78(%rbp)
movslq %r8d, %r9
movl $0x1, %eax
movl $0x1, %edi
subq %rsi, %rdi
movq %rdi, -0x60(%rbp)
subq %rcx, %rax
movq %rax, -0x68(%rbp)
xorl %r13d, %r13d
leaq 0x285106(%rip), %r14 # 0x2dec90
movq %rsi, %r15
movq %rcx, %r12
xorl %ebx, %ebx
movq %rcx, -0x48(%rbp)
movq %rsi, -0x58(%rbp)
movq %r15, %rax
subq %rsi, %rax
cmpq %rdx, %rax
jge 0x59bb2
testl %r13d, %r13d
je 0x59be0
movl $0x9, %r8d
jmp 0x59bdb
testl %r13d, %r13d
sete %r8b
cmpl $0x0, -0x70(%rbp)
setg %dil
xorl %eax, %eax
testb %r8b, %dil
je 0x59ca6
movl $0x1, %r13d
movl $0x9, %r8d
movq %rsi, %r15
movq %r14, %rax
jmp 0x59bf0
xorl %r13d, %r13d
movl $0x8, %r8d
leaq 0x284fa0(%rip), %rax # 0x2deb90
movzbl (%r15), %edi
movb (%rax,%rdi), %al
cmpb $-0x1, %al
jne 0x59ca0
movq %r8, -0x50(%rbp)
movq %r12, -0x38(%rbp)
movl %ebx, -0x2c(%rbp)
movq %r13, -0x40(%rbp)
movq %r15, %r11
subq %rsi, %r11
movq -0x60(%rbp), %rax
leaq (%rax,%r15), %rcx
xorl %edi, %edi
movq %r15, %r12
movq %rdi, %r8
shlq $0x4, %r8
leaq 0x29b8f1(%rip), %rax # 0x2f5520
movq (%r8,%rax), %r13
movb (%r13), %r10b
testb %r10b, %r10b
je 0x59c67
cmpq %rdx, %r11
jge 0x59c67
incq %r13
movq %rcx, %rbx
cmpb (%r15), %r10b
jne 0x59c6c
incq %r15
movb (%r13), %r10b
testb %r10b, %r10b
je 0x59c67
leaq 0x1(%rbx), %rax
incq %r13
cmpq %rdx, %rbx
movq %rax, %rbx
jl 0x59c47
testb %r10b, %r10b
je 0x59c7c
incq %rdi
cmpq $0x50, %rdi
movq %r12, %r15
jne 0x59c21
movb $-0x1, %al
jmp 0x59c91
leaq 0x29b89d(%rip), %rax # 0x2f5520
addq %rax, %r8
movq -0x50(%rbp), %rax
movb (%r8,%rax), %al
decq %r15
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %r13
movl -0x2c(%rbp), %ebx
movq -0x38(%rbp), %r12
movzbl %al, %eax
incq %r15
movq %r12, %rdi
subq %rcx, %rdi
cmpq %r9, %rdi
jge 0x59cbd
testl %ebx, %ebx
je 0x59cea
movl $0x9, %r10d
jmp 0x59ce5
testl %ebx, %ebx
sete %dil
cmpl $0x0, -0x78(%rbp)
setg %r8b
xorl %r10d, %r10d
testb %dil, %r8b
je 0x59de4
movl $0x1, %ebx
movl $0x9, %r10d
movq %rcx, %r12
movq %r14, %r8
jmp 0x59cf9
xorl %ebx, %ebx
movl $0x8, %r10d
leaq 0x284e97(%rip), %r8 # 0x2deb90
movzbl (%r12), %edi
movb (%r8,%rdi), %dil
cmpb $-0x1, %dil
jne 0x59ddd
movq %r10, -0x50(%rbp)
movq %r15, -0x38(%rbp)
movl %ebx, -0x2c(%rbp)
movq %r13, -0x40(%rbp)
movq %r12, %r14
subq %rcx, %r14
movq -0x68(%rbp), %rcx
movq %r12, %r11
leaq (%rcx,%r12), %rsi
xorl %r8d, %r8d
movq %r8, %r15
shlq $0x4, %r15
leaq 0x29b7e3(%rip), %rcx # 0x2f5520
movq (%r15,%rcx), %rbx
movb (%rbx), %r13b
testb %r13b, %r13b
je 0x59d78
cmpq %r9, %r14
jge 0x59d78
incq %rbx
movq %rsi, %rdi
movq %r11, %r10
cmpb (%r10), %r13b
jne 0x59d80
incq %r10
movb (%rbx), %r13b
testb %r13b, %r13b
je 0x59d7b
leaq 0x1(%rdi), %r12
incq %rbx
cmpq %r9, %rdi
movq %r12, %rdi
jl 0x59d57
jmp 0x59d7b
movq %r11, %r10
testb %r13b, %r13b
je 0x59dab
incq %r8
cmpq $0x50, %r8
jne 0x59d2f
movb $-0x1, %dil
movq -0x48(%rbp), %rcx
movq -0x58(%rbp), %rsi
leaq 0x284ef5(%rip), %r14 # 0x2dec90
movq -0x40(%rbp), %r13
movl -0x2c(%rbp), %ebx
movq -0x38(%rbp), %r15
movq %r11, %r12
jmp 0x59ddd
leaq 0x29b76e(%rip), %rcx # 0x2f5520
addq %rcx, %r15
movq -0x50(%rbp), %rcx
movb (%r15,%rcx), %dil
decq %r10
movq %r10, %r12
movq -0x48(%rbp), %rcx
movq -0x58(%rbp), %rsi
leaq 0x284ebe(%rip), %r14 # 0x2dec90
movq -0x40(%rbp), %r13
movl -0x2c(%rbp), %ebx
movq -0x38(%rbp), %r15
movzbl %dil, %r10d
incq %r12
testl %eax, %eax
je 0x59df1
cmpl %r10d, %eax
je 0x59b9a
subl %r10d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_strnncoll_win1250ch:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
cmp rdx, r8
mov rax, r8
cmovb rax, rdx
test r9b, r9b
cmovz rax, rdx
mov [rbp+var_70], rax
movsxd rdx, eax
mov [rbp+var_78], r8
movsxd r9, r8d
mov eax, 1
mov edi, 1
sub rdi, rsi
mov [rbp+var_60], rdi
sub rax, rcx
mov [rbp+var_68], rax
xor r13d, r13d
lea r14, _sort_order_win1250ch2
mov r15, rsi
mov r12, rcx
xor ebx, ebx
mov [rbp+var_48], rcx
mov [rbp+var_58], rsi
loc_59B9A:
mov rax, r15
sub rax, rsi
cmp rax, rdx
jge short loc_59BB2
test r13d, r13d
jz short loc_59BE0
mov r8d, 9
jmp short loc_59BDB
loc_59BB2:
test r13d, r13d
setz r8b
cmp dword ptr [rbp+var_70], 0
setnle dil
xor eax, eax
test dil, r8b
jz loc_59CA6
mov r13d, 1
mov r8d, 9
mov r15, rsi
loc_59BDB:
mov rax, r14
jmp short loc_59BF0
loc_59BE0:
xor r13d, r13d
mov r8d, 8
lea rax, _sort_order_win1250ch1
loc_59BF0:
movzx edi, byte ptr [r15]
mov al, [rax+rdi]
cmp al, 0FFh
jnz loc_59CA0
mov [rbp+var_50], r8
mov [rbp+var_38], r12
mov [rbp+var_2C], ebx
mov [rbp+var_40], r13
mov r11, r15
sub r11, rsi
mov rax, [rbp+var_60]
lea rcx, [rax+r15]
xor edi, edi
mov r12, r15
loc_59C21:
mov r8, rdi
shl r8, 4
lea rax, doubles_0
mov r13, [r8+rax]
mov r10b, [r13+0]
test r10b, r10b
jz short loc_59C67
cmp r11, rdx
jge short loc_59C67
inc r13
mov rbx, rcx
loc_59C47:
cmp r10b, [r15]
jnz short loc_59C6C
inc r15
mov r10b, [r13+0]
test r10b, r10b
jz short loc_59C67
lea rax, [rbx+1]
inc r13
cmp rbx, rdx
mov rbx, rax
jl short loc_59C47
loc_59C67:
test r10b, r10b
jz short loc_59C7C
loc_59C6C:
inc rdi
cmp rdi, 50h ; 'P'
mov r15, r12
jnz short loc_59C21
mov al, 0FFh
jmp short loc_59C91
loc_59C7C:
lea rax, doubles_0
add r8, rax
mov rax, [rbp+var_50]
mov al, [r8+rax]
dec r15
loc_59C91:
mov rcx, [rbp+var_48]
mov r13, [rbp+var_40]
mov ebx, [rbp+var_2C]
mov r12, [rbp+var_38]
loc_59CA0:
movzx eax, al
inc r15
loc_59CA6:
mov rdi, r12
sub rdi, rcx
cmp rdi, r9
jge short loc_59CBD
test ebx, ebx
jz short loc_59CEA
mov r10d, 9
jmp short loc_59CE5
loc_59CBD:
test ebx, ebx
setz dil
cmp dword ptr [rbp+var_78], 0
setnle r8b
xor r10d, r10d
test r8b, dil
jz loc_59DE4
mov ebx, 1
mov r10d, 9
mov r12, rcx
loc_59CE5:
mov r8, r14
jmp short loc_59CF9
loc_59CEA:
xor ebx, ebx
mov r10d, 8
lea r8, _sort_order_win1250ch1
loc_59CF9:
movzx edi, byte ptr [r12]
mov dil, [r8+rdi]
cmp dil, 0FFh
jnz loc_59DDD
mov [rbp+var_50], r10
mov [rbp+var_38], r15
mov [rbp+var_2C], ebx
mov [rbp+var_40], r13
mov r14, r12
sub r14, rcx
mov rcx, [rbp+var_68]
mov r11, r12
lea rsi, [rcx+r12]
xor r8d, r8d
loc_59D2F:
mov r15, r8
shl r15, 4
lea rcx, doubles_0
mov rbx, [r15+rcx]
mov r13b, [rbx]
test r13b, r13b
jz short loc_59D78
cmp r14, r9
jge short loc_59D78
inc rbx
mov rdi, rsi
mov r10, r11
loc_59D57:
cmp r13b, [r10]
jnz short loc_59D80
inc r10
mov r13b, [rbx]
test r13b, r13b
jz short loc_59D7B
lea r12, [rdi+1]
inc rbx
cmp rdi, r9
mov rdi, r12
jl short loc_59D57
jmp short loc_59D7B
loc_59D78:
mov r10, r11
loc_59D7B:
test r13b, r13b
jz short loc_59DAB
loc_59D80:
inc r8
cmp r8, 50h ; 'P'
jnz short loc_59D2F
mov dil, 0FFh
mov rcx, [rbp+var_48]
mov rsi, [rbp+var_58]
lea r14, _sort_order_win1250ch2
mov r13, [rbp+var_40]
mov ebx, [rbp+var_2C]
mov r15, [rbp+var_38]
mov r12, r11
jmp short loc_59DDD
loc_59DAB:
lea rcx, doubles_0
add r15, rcx
mov rcx, [rbp+var_50]
mov dil, [r15+rcx]
dec r10
mov r12, r10
mov rcx, [rbp+var_48]
mov rsi, [rbp+var_58]
lea r14, _sort_order_win1250ch2
mov r13, [rbp+var_40]
mov ebx, [rbp+var_2C]
mov r15, [rbp+var_38]
loc_59DDD:
movzx r10d, dil
inc r12
loc_59DE4:
test eax, eax
jz short loc_59DF1
cmp eax, r10d
jz loc_59B9A
loc_59DF1:
sub eax, r10d
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_strnncoll_win1250ch(
long long a1,
_BYTE *a2,
unsigned long long a3,
unsigned __int8 *a4,
unsigned long long a5,
char a6)
{
int v6; // eax
long long v7; // rdx
long long v8; // r9
long long v9; // r13
_BYTE *v10; // r15
unsigned __int8 *v11; // r12
int v12; // ebx
long long v13; // r8
_BYTE *v14; // rax
_BYTE *v15; // r11
_BYTE *v16; // rcx
long long v17; // rdi
_BYTE *v18; // r12
char *v19; // r13
char v20; // r10
char *v21; // r13
_BYTE *v22; // rbx
bool v23; // cc
long long v24; // r10
int v25; // r10d
_BYTE *v26; // r8
unsigned __int8 v27; // di
long long v28; // r8
char *v29; // rbx
char v30; // r13
char *v31; // rbx
unsigned __int8 *v32; // rdi
_BYTE *v33; // r10
int v35; // [rsp+0h] [rbp-78h]
int v36; // [rsp+8h] [rbp-70h]
long long v37; // [rsp+10h] [rbp-68h]
long long v38; // [rsp+18h] [rbp-60h]
_BYTE *v39; // [rsp+20h] [rbp-58h]
long long v40; // [rsp+28h] [rbp-50h]
unsigned __int8 *v41; // [rsp+30h] [rbp-48h]
long long v42; // [rsp+38h] [rbp-40h]
long long v43; // [rsp+38h] [rbp-40h]
unsigned __int8 *v44; // [rsp+40h] [rbp-38h]
int v45; // [rsp+4Ch] [rbp-2Ch]
int v46; // [rsp+4Ch] [rbp-2Ch]
v6 = a5;
if ( a3 < a5 )
v6 = a3;
if ( !a6 )
v6 = a3;
v36 = v6;
v7 = v6;
v35 = a5;
v8 = (int)a5;
v38 = 1LL - (_QWORD)a2;
v37 = 1LL - (_QWORD)a4;
v9 = 0LL;
v10 = a2;
v11 = a4;
v12 = 0;
v41 = a4;
v39 = a2;
do
{
if ( v10 - a2 >= v7 )
{
LODWORD(v14) = 0;
if ( (_DWORD)v9 != 0 || v36 <= 0 )
goto LABEL_27;
v9 = 1LL;
v13 = 9LL;
v10 = a2;
}
else
{
if ( !(_DWORD)v9 )
{
v9 = 0LL;
v13 = 8LL;
v14 = &sort_order_win1250ch1;
goto LABEL_13;
}
v13 = 9LL;
}
v14 = &sort_order_win1250ch2;
LABEL_13:
LOBYTE(v14) = v14[(unsigned __int8)*v10];
if ( (_BYTE)v14 != 0xFF )
goto LABEL_26;
v44 = v11;
v45 = v12;
v42 = v9;
v15 = (_BYTE *)(v10 - a2);
v16 = &v10[v38];
v17 = 0LL;
v18 = v10;
while ( 1 )
{
v19 = (char *)*(&doubles_0 + 2 * v17);
v20 = *v19;
if ( *v19 && (long long)v15 < v7 )
{
v21 = v19 + 1;
v22 = v16;
while ( v20 == *v10 )
{
++v10;
v20 = *v21;
if ( *v21 )
{
++v21;
v23 = (long long)v22++ < v7;
if ( v23 )
continue;
}
goto LABEL_21;
}
goto LABEL_22;
}
LABEL_21:
if ( !v20 )
break;
LABEL_22:
++v17;
v10 = v18;
if ( v17 == 80 )
{
LOBYTE(v14) = -1;
goto LABEL_25;
}
}
LOBYTE(v14) = *((_BYTE *)&doubles_0 + 16 * v17 + v13);
--v10;
LABEL_25:
a4 = v41;
v9 = v42;
v12 = v45;
v11 = v44;
LABEL_26:
LODWORD(v14) = (unsigned __int8)v14;
++v10;
LABEL_27:
if ( v11 - a4 >= v8 )
{
v25 = 0;
if ( v12 != 0 || v35 <= 0 )
continue;
v12 = 1;
v24 = 9LL;
v11 = a4;
LABEL_32:
v26 = &sort_order_win1250ch2;
}
else
{
if ( v12 )
{
v24 = 9LL;
goto LABEL_32;
}
v12 = 0;
v24 = 8LL;
v26 = &sort_order_win1250ch1;
}
v27 = v26[*v11];
if ( v27 != 0xFF )
goto LABEL_48;
v40 = v24;
v46 = v12;
v43 = v9;
v28 = 0LL;
while ( 2 )
{
v29 = (char *)*(&doubles_0 + 2 * v28);
v30 = *v29;
if ( *v29 && v11 - a4 < v8 )
{
v31 = v29 + 1;
v32 = &v11[v37];
v33 = v11;
while ( v30 == *v33 )
{
++v33;
v30 = *v31;
if ( *v31 )
{
++v31;
v23 = (long long)v32++ < v8;
if ( v23 )
continue;
}
goto LABEL_44;
}
goto LABEL_45;
}
v33 = v11;
LABEL_44:
if ( v30 )
{
LABEL_45:
if ( ++v28 == 80 )
{
v27 = -1;
a4 = v41;
a2 = v39;
v9 = v43;
v12 = v46;
goto LABEL_48;
}
continue;
}
break;
}
v27 = *((_BYTE *)&doubles_0 + 16 * v28 + v40);
v11 = v33 - 1;
a4 = v41;
a2 = v39;
v9 = v43;
v12 = v46;
LABEL_48:
v25 = v27;
++v11;
}
while ( (_DWORD)v14 && (_DWORD)v14 == v25 );
return (unsigned int)((_DWORD)v14 - v25);
}
| my_strnncoll_win1250ch:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
CMP RDX,R8
MOV RAX,R8
CMOVC RAX,RDX
TEST R9B,R9B
CMOVZ RAX,RDX
MOV qword ptr [RBP + -0x70],RAX
MOVSXD RDX,EAX
MOV qword ptr [RBP + -0x78],R8
MOVSXD R9,R8D
MOV EAX,0x1
MOV EDI,0x1
SUB RDI,RSI
MOV qword ptr [RBP + -0x60],RDI
SUB RAX,RCX
MOV qword ptr [RBP + -0x68],RAX
XOR R13D,R13D
LEA R14,[0x3dec90]
MOV R15,RSI
MOV R12,RCX
XOR EBX,EBX
MOV qword ptr [RBP + -0x48],RCX
MOV qword ptr [RBP + -0x58],RSI
LAB_00159b9a:
MOV RAX,R15
SUB RAX,RSI
CMP RAX,RDX
JGE 0x00159bb2
TEST R13D,R13D
JZ 0x00159be0
MOV R8D,0x9
JMP 0x00159bdb
LAB_00159bb2:
TEST R13D,R13D
SETZ R8B
CMP dword ptr [RBP + -0x70],0x0
SETG DIL
XOR EAX,EAX
TEST DIL,R8B
JZ 0x00159ca6
MOV R13D,0x1
MOV R8D,0x9
MOV R15,RSI
LAB_00159bdb:
MOV RAX,R14
JMP 0x00159bf0
LAB_00159be0:
XOR R13D,R13D
MOV R8D,0x8
LEA RAX,[0x3deb90]
LAB_00159bf0:
MOVZX EDI,byte ptr [R15]
MOV AL,byte ptr [RAX + RDI*0x1]
CMP AL,0xff
JNZ 0x00159ca0
MOV qword ptr [RBP + -0x50],R8
MOV qword ptr [RBP + -0x38],R12
MOV dword ptr [RBP + -0x2c],EBX
MOV qword ptr [RBP + -0x40],R13
MOV R11,R15
SUB R11,RSI
MOV RAX,qword ptr [RBP + -0x60]
LEA RCX,[RAX + R15*0x1]
XOR EDI,EDI
MOV R12,R15
LAB_00159c21:
MOV R8,RDI
SHL R8,0x4
LEA RAX,[0x3f5520]
MOV R13,qword ptr [R8 + RAX*0x1]
MOV R10B,byte ptr [R13]
TEST R10B,R10B
JZ 0x00159c67
CMP R11,RDX
JGE 0x00159c67
INC R13
MOV RBX,RCX
LAB_00159c47:
CMP R10B,byte ptr [R15]
JNZ 0x00159c6c
INC R15
MOV R10B,byte ptr [R13]
TEST R10B,R10B
JZ 0x00159c67
LEA RAX,[RBX + 0x1]
INC R13
CMP RBX,RDX
MOV RBX,RAX
JL 0x00159c47
LAB_00159c67:
TEST R10B,R10B
JZ 0x00159c7c
LAB_00159c6c:
INC RDI
CMP RDI,0x50
MOV R15,R12
JNZ 0x00159c21
MOV AL,0xff
JMP 0x00159c91
LAB_00159c7c:
LEA RAX,[0x3f5520]
ADD R8,RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV AL,byte ptr [R8 + RAX*0x1]
DEC R15
LAB_00159c91:
MOV RCX,qword ptr [RBP + -0x48]
MOV R13,qword ptr [RBP + -0x40]
MOV EBX,dword ptr [RBP + -0x2c]
MOV R12,qword ptr [RBP + -0x38]
LAB_00159ca0:
MOVZX EAX,AL
INC R15
LAB_00159ca6:
MOV RDI,R12
SUB RDI,RCX
CMP RDI,R9
JGE 0x00159cbd
TEST EBX,EBX
JZ 0x00159cea
MOV R10D,0x9
JMP 0x00159ce5
LAB_00159cbd:
TEST EBX,EBX
SETZ DIL
CMP dword ptr [RBP + -0x78],0x0
SETG R8B
XOR R10D,R10D
TEST R8B,DIL
JZ 0x00159de4
MOV EBX,0x1
MOV R10D,0x9
MOV R12,RCX
LAB_00159ce5:
MOV R8,R14
JMP 0x00159cf9
LAB_00159cea:
XOR EBX,EBX
MOV R10D,0x8
LEA R8,[0x3deb90]
LAB_00159cf9:
MOVZX EDI,byte ptr [R12]
MOV DIL,byte ptr [R8 + RDI*0x1]
CMP DIL,0xff
JNZ 0x00159ddd
MOV qword ptr [RBP + -0x50],R10
MOV qword ptr [RBP + -0x38],R15
MOV dword ptr [RBP + -0x2c],EBX
MOV qword ptr [RBP + -0x40],R13
MOV R14,R12
SUB R14,RCX
MOV RCX,qword ptr [RBP + -0x68]
MOV R11,R12
LEA RSI,[RCX + R12*0x1]
XOR R8D,R8D
LAB_00159d2f:
MOV R15,R8
SHL R15,0x4
LEA RCX,[0x3f5520]
MOV RBX,qword ptr [R15 + RCX*0x1]
MOV R13B,byte ptr [RBX]
TEST R13B,R13B
JZ 0x00159d78
CMP R14,R9
JGE 0x00159d78
INC RBX
MOV RDI,RSI
MOV R10,R11
LAB_00159d57:
CMP R13B,byte ptr [R10]
JNZ 0x00159d80
INC R10
MOV R13B,byte ptr [RBX]
TEST R13B,R13B
JZ 0x00159d7b
LEA R12,[RDI + 0x1]
INC RBX
CMP RDI,R9
MOV RDI,R12
JL 0x00159d57
JMP 0x00159d7b
LAB_00159d78:
MOV R10,R11
LAB_00159d7b:
TEST R13B,R13B
JZ 0x00159dab
LAB_00159d80:
INC R8
CMP R8,0x50
JNZ 0x00159d2f
MOV DIL,0xff
MOV RCX,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x58]
LEA R14,[0x3dec90]
MOV R13,qword ptr [RBP + -0x40]
MOV EBX,dword ptr [RBP + -0x2c]
MOV R15,qword ptr [RBP + -0x38]
MOV R12,R11
JMP 0x00159ddd
LAB_00159dab:
LEA RCX,[0x3f5520]
ADD R15,RCX
MOV RCX,qword ptr [RBP + -0x50]
MOV DIL,byte ptr [R15 + RCX*0x1]
DEC R10
MOV R12,R10
MOV RCX,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x58]
LEA R14,[0x3dec90]
MOV R13,qword ptr [RBP + -0x40]
MOV EBX,dword ptr [RBP + -0x2c]
MOV R15,qword ptr [RBP + -0x38]
LAB_00159ddd:
MOVZX R10D,DIL
INC R12
LAB_00159de4:
TEST EAX,EAX
JZ 0x00159df1
CMP EAX,R10D
JZ 0x00159b9a
LAB_00159df1:
SUB EAX,R10D
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int my_strnncoll_win1250ch
(int8 param_1,byte *param_2,ulong param_3,byte *param_4,ulong param_5,
char param_6)
{
bool bVar1;
bool bVar2;
byte *pbVar3;
byte *pbVar4;
byte *pbVar5;
byte bVar6;
int iVar7;
ulong uVar9;
int1 *puVar10;
long lVar11;
int iVar12;
uint uVar13;
long lVar14;
byte *pbVar15;
byte *pbVar16;
byte *pbVar17;
byte *pbVar18;
uint uVar8;
uVar9 = param_5;
if (param_3 < param_5) {
uVar9 = param_3;
}
if (param_6 == '\0') {
uVar9 = param_3;
}
iVar7 = (int)uVar9;
iVar12 = (int)param_5;
bVar2 = false;
bVar1 = false;
pbVar15 = param_4;
pbVar18 = param_2;
do {
if ((long)pbVar18 - (long)param_2 < (long)iVar7) {
if (bVar2) {
LAB_00159bdb:
lVar14 = 9;
puVar10 = _sort_order_win1250ch2;
}
else {
bVar2 = false;
lVar14 = 8;
puVar10 = _sort_order_win1250ch1;
}
bVar6 = puVar10[*pbVar18];
if (bVar6 == 0xff) {
lVar11 = 0;
do {
pbVar16 = (&doubles)[lVar11 * 2];
bVar6 = *pbVar16;
pbVar17 = pbVar18;
pbVar5 = pbVar18 + (1 - (long)param_2);
pbVar4 = pbVar18 + -(long)param_2;
if (bVar6 != 0) {
while (pbVar3 = pbVar5, (long)pbVar4 < (long)iVar7) {
pbVar16 = pbVar16 + 1;
if (bVar6 != *pbVar17) goto LAB_00159c6c;
pbVar17 = pbVar17 + 1;
bVar6 = *pbVar16;
if (bVar6 == 0) break;
pbVar5 = pbVar3 + 1;
pbVar4 = pbVar3;
}
}
if (bVar6 == 0) {
bVar6 = *(byte *)((long)&doubles + lVar14 + lVar11 * 0x10);
pbVar18 = pbVar17 + -1;
goto LAB_00159ca0;
}
LAB_00159c6c:
lVar11 = lVar11 + 1;
} while (lVar11 != 0x50);
bVar6 = 0xff;
}
LAB_00159ca0:
uVar8 = (uint)bVar6;
pbVar18 = pbVar18 + 1;
}
else {
uVar8 = 0;
if (0 < iVar7 && !bVar2) {
bVar2 = true;
pbVar18 = param_2;
goto LAB_00159bdb;
}
}
if ((long)pbVar15 - (long)param_4 < (long)iVar12) {
if (bVar1) {
LAB_00159ce5:
lVar14 = 9;
puVar10 = _sort_order_win1250ch2;
}
else {
bVar1 = false;
lVar14 = 8;
puVar10 = _sort_order_win1250ch1;
}
bVar6 = puVar10[*pbVar15];
if (bVar6 == 0xff) {
lVar11 = 0;
do {
pbVar16 = (&doubles)[lVar11 * 2];
bVar6 = *pbVar16;
pbVar17 = pbVar15;
pbVar5 = pbVar15 + (1 - (long)param_4);
pbVar4 = pbVar15 + -(long)param_4;
if (bVar6 != 0) {
while (pbVar3 = pbVar5, (long)pbVar4 < (long)iVar12) {
pbVar16 = pbVar16 + 1;
if (bVar6 != *pbVar17) goto LAB_00159d80;
pbVar17 = pbVar17 + 1;
bVar6 = *pbVar16;
if (bVar6 == 0) break;
pbVar5 = pbVar3 + 1;
pbVar4 = pbVar3;
}
}
if (bVar6 == 0) {
bVar6 = *(byte *)((long)&doubles + lVar14 + lVar11 * 0x10);
pbVar15 = pbVar17 + -1;
goto LAB_00159ddd;
}
LAB_00159d80:
lVar11 = lVar11 + 1;
} while (lVar11 != 0x50);
bVar6 = 0xff;
}
LAB_00159ddd:
uVar13 = (uint)bVar6;
pbVar15 = pbVar15 + 1;
}
else {
uVar13 = 0;
if (0 < iVar12 && !bVar1) {
bVar1 = true;
pbVar15 = param_4;
goto LAB_00159ce5;
}
}
if ((uVar8 == 0) || (uVar8 != uVar13)) {
return uVar8 - uVar13;
}
} while( true );
}
| |
45,636 | js_free_desc | bluesky950520[P]quickjs/quickjs.c | static void js_free_desc(JSContext *ctx, JSPropertyDescriptor *desc)
{
JS_FreeValue(ctx, desc->getter);
JS_FreeValue(ctx, desc->setter);
JS_FreeValue(ctx, desc->value);
} | O1 | c | js_free_desc:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rsi
movq 0x20(%rbx), %rdx
movq 0x18(%rdi), %rdi
callq 0x1d8c6
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
movq 0x18(%r14), %rdi
callq 0x1d8c6
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq 0x18(%r14), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1d8c6
| js_free_desc:
push r14
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov rsi, [rsi+18h]
mov rdx, [rbx+20h]
mov rdi, [rdi+18h]
call JS_FreeValueRT
mov rsi, [rbx+28h]
mov rdx, [rbx+30h]
mov rdi, [r14+18h]
call JS_FreeValueRT
mov rsi, [rbx+8]
mov rdx, [rbx+10h]
mov rdi, [r14+18h]
add rsp, 8
pop rbx
pop r14
jmp JS_FreeValueRT
| long long js_free_desc(long long a1, long long a2)
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), *(_DWORD **)(a2 + 24), *(_QWORD *)(a2 + 32));
JS_FreeValueRT(*(_QWORD *)(a1 + 24), *(_DWORD **)(a2 + 40), *(_QWORD *)(a2 + 48));
return JS_FreeValueRT(*(_QWORD *)(a1 + 24), *(_DWORD **)(a2 + 8), *(_QWORD *)(a2 + 16));
}
| js_free_desc:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV RSI,qword ptr [RSI + 0x18]
MOV RDX,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RDI + 0x18]
CALL 0x0011d8c6
MOV RSI,qword ptr [RBX + 0x28]
MOV RDX,qword ptr [RBX + 0x30]
MOV RDI,qword ptr [R14 + 0x18]
CALL 0x0011d8c6
MOV RSI,qword ptr [RBX + 0x8]
MOV RDX,qword ptr [RBX + 0x10]
MOV RDI,qword ptr [R14 + 0x18]
ADD RSP,0x8
POP RBX
POP R14
JMP 0x0011d8c6
|
void js_free_desc(long param_1,long param_2)
{
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),*(int8 *)(param_2 + 0x18),
*(int8 *)(param_2 + 0x20));
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),*(int8 *)(param_2 + 0x28),
*(int8 *)(param_2 + 0x30));
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),*(int8 *)(param_2 + 8),
*(int8 *)(param_2 + 0x10));
return;
}
| |
45,637 | set_prealloc_root | eloqsql/mysys/my_alloc.c | void set_prealloc_root(MEM_ROOT *root, char *ptr)
{
USED_MEM *next;
for (next=root->used; next ; next=next->next)
{
if ((char*) next <= ptr && (char*) next + next->size > ptr)
{
root->pre_alloc=next;
return;
}
}
for (next=root->free ; next ; next=next->next)
{
if ((char*) next <= ptr && (char*) next + next->size > ptr)
{
root->pre_alloc=next;
return;
}
}
} | O3 | c | set_prealloc_root:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x57a5a
cmpq %rsi, %rax
ja 0x57a55
movq 0x10(%rax), %rcx
addq %rax, %rcx
cmpq %rsi, %rcx
ja 0x57a78
movq (%rax), %rax
jmp 0x57a3f
movq (%rdi), %rax
testq %rax, %rax
je 0x57a7c
cmpq %rsi, %rax
ja 0x57a73
movq 0x10(%rax), %rcx
addq %rax, %rcx
cmpq %rsi, %rcx
ja 0x57a78
movq (%rax), %rax
jmp 0x57a5d
movq %rax, 0x10(%rdi)
popq %rbp
retq
| set_prealloc_root:
push rbp
mov rbp, rsp
mov rax, [rdi+8]
loc_57A3F:
test rax, rax
jz short loc_57A5A
cmp rax, rsi
ja short loc_57A55
mov rcx, [rax+10h]
add rcx, rax
cmp rcx, rsi
ja short loc_57A78
loc_57A55:
mov rax, [rax]
jmp short loc_57A3F
loc_57A5A:
mov rax, [rdi]
loc_57A5D:
test rax, rax
jz short loc_57A7C
cmp rax, rsi
ja short loc_57A73
mov rcx, [rax+10h]
add rcx, rax
cmp rcx, rsi
ja short loc_57A78
loc_57A73:
mov rax, [rax]
jmp short loc_57A5D
loc_57A78:
mov [rdi+10h], rax
loc_57A7C:
pop rbp
retn
| _QWORD * set_prealloc_root(_QWORD *a1, unsigned long long a2)
{
_QWORD *result; // rax
for ( result = (_QWORD *)a1[1]; result; result = (_QWORD *)*result )
{
if ( (unsigned long long)result <= a2 && (unsigned long long)result + result[2] > a2 )
{
LABEL_11:
a1[2] = result;
return result;
}
}
for ( result = (_QWORD *)*a1; result; result = (_QWORD *)*result )
{
if ( (unsigned long long)result <= a2 && (unsigned long long)result + result[2] > a2 )
goto LABEL_11;
}
return result;
}
| set_prealloc_root:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI + 0x8]
LAB_00157a3f:
TEST RAX,RAX
JZ 0x00157a5a
CMP RAX,RSI
JA 0x00157a55
MOV RCX,qword ptr [RAX + 0x10]
ADD RCX,RAX
CMP RCX,RSI
JA 0x00157a78
LAB_00157a55:
MOV RAX,qword ptr [RAX]
JMP 0x00157a3f
LAB_00157a5a:
MOV RAX,qword ptr [RDI]
LAB_00157a5d:
TEST RAX,RAX
JZ 0x00157a7c
CMP RAX,RSI
JA 0x00157a73
MOV RCX,qword ptr [RAX + 0x10]
ADD RCX,RAX
CMP RCX,RSI
JA 0x00157a78
LAB_00157a73:
MOV RAX,qword ptr [RAX]
JMP 0x00157a5d
LAB_00157a78:
MOV qword ptr [RDI + 0x10],RAX
LAB_00157a7c:
POP RBP
RET
|
void set_prealloc_root(int8 *param_1,int8 *param_2)
{
int8 *puVar1;
for (puVar1 = (int8 *)param_1[1]; puVar1 != (int8 *)0x0;
puVar1 = (int8 *)*puVar1) {
if ((puVar1 <= param_2) && (param_2 < (int8 *)(puVar1[2] + (long)puVar1)))
goto LAB_00157a78;
}
puVar1 = (int8 *)*param_1;
while( true ) {
if (puVar1 == (int8 *)0x0) {
return;
}
if ((puVar1 <= param_2) && (param_2 < (int8 *)(puVar1[2] + (long)puVar1))) break;
puVar1 = (int8 *)*puVar1;
}
LAB_00157a78:
param_1[2] = puVar1;
return;
}
| |
45,638 | OpenSubdiv::v3_6_0::Tmr::SurfaceTable::GetDomain(int) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/tmr/surfaceTable.cpp | Domain
SurfaceTable::GetDomain(Index surfaceIndex) const {
switch (topologyMap.GetTraits().getSchemeType()) {
case Sdc::SCHEME_CATMARK: {
SubdivisionPlan const& plan = GetSubdivisionPlan(surfaceIndex);
return plan.IsRegularFace() ? Domain::Quad : Domain::Quad_Subface;
}
case Sdc::SCHEME_LOOP: {
return Domain::Tri;
}
default:
break;
}
assert(0);
return Domain::Quad;
} | O0 | cpp | OpenSubdiv::v3_6_0::Tmr::SurfaceTable::GetDomain(int) const:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x30(%rax), %rdi
callq 0xc85c0
movq %rax, %rdi
callq 0xd7c10
movl %eax, %ecx
movl %ecx, -0x24(%rbp)
subl $0x1, %eax
je 0x1dd51e
jmp 0x1dd514
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x1dd556
jmp 0x1dd55c
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xc7de0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xc7130
movb %al, %cl
movb $0x1, %al
movb $0x2, %dl
movb %dl, -0x32(%rbp)
testb $0x1, %cl
movb %al, -0x31(%rbp)
jne 0x1dd54e
movb -0x32(%rbp), %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x1dd57d
movb $0x0, -0x1(%rbp)
jmp 0x1dd57d
jmp 0x1dd55e
leaq 0xcae2(%rip), %rdi # 0x1ea047
leaq 0x21b0d(%rip), %rsi # 0x1ff079
movl $0x4d, %edx
leaq 0x21b5f(%rip), %rcx # 0x1ff0d7
callq 0xc9440
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZNK10OpenSubdiv6v3_6_03Tmr12SurfaceTable9GetDomainEi:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov rax, [rbp+var_10]
mov [rbp+var_30], rax
mov rdi, [rax+30h]; this
call __ZNK10OpenSubdiv6v3_6_03Tmr11TopologyMap9GetTraitsEv; OpenSubdiv::v3_6_0::Tmr::TopologyMap::GetTraits(void)
mov rdi, rax; this
call __ZNK10OpenSubdiv6v3_6_03Tmr11TopologyMap6Traits13getSchemeTypeEv; OpenSubdiv::v3_6_0::Tmr::TopologyMap::Traits::getSchemeType(void)
mov ecx, eax
mov [rbp+var_24], ecx
sub eax, 1
jz short loc_1DD51E
jmp short $+2
loc_1DD514:
mov eax, [rbp+var_24]
sub eax, 2
jz short loc_1DD556
jmp short loc_1DD55C
loc_1DD51E:
mov rdi, [rbp+var_30]; this
mov esi, [rbp+var_14]; int
call __ZNK10OpenSubdiv6v3_6_03Tmr12SurfaceTable18GetSubdivisionPlanEi; OpenSubdiv::v3_6_0::Tmr::SurfaceTable::GetSubdivisionPlan(int)
mov [rbp+var_20], rax
mov rdi, [rbp+var_20]; this
call __ZNK10OpenSubdiv6v3_6_03Tmr15SubdivisionPlan13IsRegularFaceEv; OpenSubdiv::v3_6_0::Tmr::SubdivisionPlan::IsRegularFace(void)
mov cl, al
mov al, 1
mov dl, 2
mov [rbp+var_32], dl
test cl, 1
mov [rbp+var_31], al
jnz short loc_1DD54E
mov al, [rbp+var_32]
mov [rbp+var_31], al
loc_1DD54E:
mov al, [rbp+var_31]
mov [rbp+var_1], al
jmp short loc_1DD57D
loc_1DD556:
mov [rbp+var_1], 0
jmp short loc_1DD57D
loc_1DD55C:
jmp short $+2
loc_1DD55E:
lea rdi, aVspanSize0+0Fh; "0"
lea rsi, aWorkspaceLlm4b_50; "/workspace/llm4binary/github/2025_star3"...
mov edx, 4Dh ; 'M'
lea rcx, aDomainOpensubd; "Domain OpenSubdiv::v3_6_0::Tmr::Surface"...
call ___assert_fail
loc_1DD57D:
mov al, [rbp+var_1]
add rsp, 40h
pop rbp
retn
| char OpenSubdiv::v3_6_0::Tmr::SurfaceTable::GetDomain(OpenSubdiv::v3_6_0::Tmr::TopologyMap **this, int a2)
{
OpenSubdiv::v3_6_0::Tmr::TopologyMap::Traits *Traits; // rax
char v4; // [rsp+Fh] [rbp-31h]
int SchemeType; // [rsp+1Ch] [rbp-24h]
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlan *SubdivisionPlan; // [rsp+20h] [rbp-20h]
Traits = (OpenSubdiv::v3_6_0::Tmr::TopologyMap::Traits *)OpenSubdiv::v3_6_0::Tmr::TopologyMap::GetTraits(this[6]);
SchemeType = OpenSubdiv::v3_6_0::Tmr::TopologyMap::Traits::getSchemeType(Traits);
if ( SchemeType == 1 )
{
SubdivisionPlan = (OpenSubdiv::v3_6_0::Tmr::SubdivisionPlan *)OpenSubdiv::v3_6_0::Tmr::SurfaceTable::GetSubdivisionPlan(
(OpenSubdiv::v3_6_0::Tmr::SurfaceTable *)this,
a2);
v4 = 1;
if ( (OpenSubdiv::v3_6_0::Tmr::SubdivisionPlan::IsRegularFace(SubdivisionPlan) & 1) == 0 )
return 2;
return v4;
}
else
{
if ( SchemeType != 2 )
__assert_fail(
"0",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/tmr/surfaceTable.cpp",
77LL,
"Domain OpenSubdiv::v3_6_0::Tmr::SurfaceTable::GetDomain(Index) const");
return 0;
}
}
| |||
45,639 | OpenSubdiv::v3_6_0::Tmr::SurfaceTable::GetDomain(int) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/tmr/surfaceTable.cpp | Domain
SurfaceTable::GetDomain(Index surfaceIndex) const {
switch (topologyMap.GetTraits().getSchemeType()) {
case Sdc::SCHEME_CATMARK: {
SubdivisionPlan const& plan = GetSubdivisionPlan(surfaceIndex);
return plan.IsRegularFace() ? Domain::Quad : Domain::Quad_Subface;
}
case Sdc::SCHEME_LOOP: {
return Domain::Tri;
}
default:
break;
}
assert(0);
return Domain::Quad;
} | O2 | cpp | OpenSubdiv::v3_6_0::Tmr::SurfaceTable::GetDomain(int) const:
movq 0x30(%rdi), %rax
testb $0x1, (%rax)
jne 0xb7973
movslq %esi, %rcx
movq (%rdi), %rdx
movl (%rdx,%rcx,8), %ecx
movq 0x70(%rax), %rax
shrl $0xc, %ecx
movq (%rax,%rcx,8), %rax
movq 0x40(%rax), %rax
movb (%rax), %cl
andb $0x1, %cl
movb $0x2, %al
subb %cl, %al
retq
xorl %eax, %eax
retq
| _ZNK10OpenSubdiv6v3_6_03Tmr12SurfaceTable9GetDomainEi:
mov rax, [rdi+30h]
test byte ptr [rax], 1
jnz short loc_B7973
movsxd rcx, esi
mov rdx, [rdi]
mov ecx, [rdx+rcx*8]
mov rax, [rax+70h]
shr ecx, 0Ch
mov rax, [rax+rcx*8]
mov rax, [rax+40h]
mov cl, [rax]
and cl, 1
mov al, 2
sub al, cl
retn
loc_B7973:
xor eax, eax
retn
| char OpenSubdiv::v3_6_0::Tmr::SurfaceTable::GetDomain(OpenSubdiv::v3_6_0::Tmr::SurfaceTable *this, int a2)
{
long long v2; // rax
v2 = *((_QWORD *)this + 6);
if ( (*(_BYTE *)v2 & 1) != 0 )
return 0;
else
return 2
- (**(_BYTE **)(*(_QWORD *)(*(_QWORD *)(v2 + 112) + 8LL * (*(_DWORD *)(*(_QWORD *)this + 8LL * a2) >> 12))
+ 64LL) & 1);
}
| GetDomain:
MOV RAX,qword ptr [RDI + 0x30]
TEST byte ptr [RAX],0x1
JNZ 0x001b7973
MOVSXD RCX,ESI
MOV RDX,qword ptr [RDI]
MOV ECX,dword ptr [RDX + RCX*0x8]
MOV RAX,qword ptr [RAX + 0x70]
SHR ECX,0xc
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV RAX,qword ptr [RAX + 0x40]
MOV CL,byte ptr [RAX]
AND CL,0x1
MOV AL,0x2
SUB AL,CL
RET
LAB_001b7973:
XOR EAX,EAX
RET
|
/* OpenSubdiv::v3_6_0::Tmr::SurfaceTable::GetDomain(int) const */
int8 __thiscall
OpenSubdiv::v3_6_0::Tmr::SurfaceTable::GetDomain(SurfaceTable *this,int param_1)
{
byte *pbVar1;
if ((**(byte **)(this + 0x30) & 1) == 0) {
pbVar1 = *(byte **)(*(long *)(*(long *)(*(byte **)(this + 0x30) + 0x70) +
(ulong)(*(uint *)(*(long *)this + (long)param_1 * 8) >> 0xc) * 8) +
0x40);
return CONCAT71((int7)((ulong)pbVar1 >> 8),'\x02' - (*pbVar1 & 1));
}
return 0;
}
| |
45,640 | JS_OrdinaryIsInstanceOf | bluesky950520[P]quickjs/quickjs.c | static int JS_OrdinaryIsInstanceOf(JSContext *ctx, JSValue val,
JSValue obj)
{
JSValue obj_proto;
JSObject *proto;
const JSObject *p, *proto1;
BOOL ret;
if (!JS_IsFunction(ctx, obj))
return FALSE;
p = JS_VALUE_GET_OBJ(obj);
if (p->class_id == JS_CLASS_BOUND_FUNCTION) {
JSBoundFunction *s = p->u.bound_function;
return JS_IsInstanceOf(ctx, val, s->func_obj);
}
/* Only explicitly boxed values are instances of constructors */
if (JS_VALUE_GET_TAG(val) != JS_TAG_OBJECT)
return FALSE;
obj_proto = JS_GetProperty(ctx, obj, JS_ATOM_prototype);
if (JS_VALUE_GET_TAG(obj_proto) != JS_TAG_OBJECT) {
if (!JS_IsException(obj_proto))
JS_ThrowTypeError(ctx, "operand 'prototype' property is not an object");
ret = -1;
goto done;
}
proto = JS_VALUE_GET_OBJ(obj_proto);
p = JS_VALUE_GET_OBJ(val);
for(;;) {
proto1 = p->shape->proto;
if (!proto1) {
/* slow case if proxy in the prototype chain */
if (unlikely(p->class_id == JS_CLASS_PROXY)) {
JSValue obj1;
obj1 = js_dup(JS_MKPTR(JS_TAG_OBJECT, (JSObject *)p));
for(;;) {
obj1 = JS_GetPrototypeFree(ctx, obj1);
if (JS_IsException(obj1)) {
ret = -1;
break;
}
if (JS_IsNull(obj1)) {
ret = FALSE;
break;
}
if (proto == JS_VALUE_GET_OBJ(obj1)) {
JS_FreeValue(ctx, obj1);
ret = TRUE;
break;
}
/* must check for timeout to avoid infinite loop */
if (js_poll_interrupts(ctx)) {
JS_FreeValue(ctx, obj1);
ret = -1;
break;
}
}
} else {
ret = FALSE;
}
break;
}
p = proto1;
if (proto == p) {
ret = TRUE;
break;
}
}
done:
JS_FreeValue(ctx, obj_proto);
return ret;
} | O0 | c | JS_OrdinaryIsInstanceOf:
subq $0xc8, %rsp
movq %rsi, 0xb0(%rsp)
movq %rdx, 0xb8(%rsp)
movq %rcx, 0xa0(%rsp)
movq %r8, 0xa8(%rsp)
movq %rdi, 0x98(%rsp)
movq 0x98(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
callq 0x34800
cmpl $0x0, %eax
jne 0x34901
movl $0x0, 0xc4(%rsp)
jmp 0x34bed
movq 0xa0(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
movzwl 0x6(%rax), %eax
cmpl $0xe, %eax
jne 0x3495f
movq 0x78(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x60(%rsp)
movq 0x98(%rsp), %rdi
movq 0x60(%rsp), %rax
movq 0xb0(%rsp), %rsi
movq 0xb8(%rsp), %rdx
movq (%rax), %rcx
movq 0x8(%rax), %r8
callq 0x34390
movl %eax, 0xc4(%rsp)
jmp 0x34bed
movq 0xb8(%rsp), %rax
cmpl $-0x1, %eax
je 0x3497c
movl $0x0, 0xc4(%rsp)
jmp 0x34bed
movq 0x98(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
movl $0x3c, %ecx
callq 0x30070
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rax
cmpl $-0x1, %eax
je 0x34a16
movq 0x88(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
jne 0x34a09
movq 0x98(%rsp), %rdi
leaq 0xdf871(%rip), %rsi # 0x114269
movb $0x0, %al
callq 0x335f0
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movl $0xffffffff, 0x6c(%rsp) # imm = 0xFFFFFFFF
jmp 0x34bc5
movq 0x88(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x38(%rax), %rax
movq %rax, 0x70(%rsp)
cmpq $0x0, 0x70(%rsp)
jne 0x34b9b
movq 0x78(%rsp), %rax
movzwl 0x6(%rax), %eax
cmpl $0x30, %eax
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x34b91
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $-0x1, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x279c0
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x98(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x66550
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0x34b09
movl $0xffffffff, 0x6c(%rsp) # imm = 0xFFFFFFFF
jmp 0x34b8f
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x34530
cmpl $0x0, %eax
je 0x34b27
movl $0x0, 0x6c(%rsp)
jmp 0x34b8f
movq 0x80(%rsp), %rax
cmpq 0x30(%rsp), %rax
jne 0x34b57
movq 0x98(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x29f80
movl $0x1, 0x6c(%rsp)
jmp 0x34b8f
movq 0x98(%rsp), %rdi
callq 0x665b0
cmpl $0x0, %eax
je 0x34b8a
movq 0x98(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x29f80
movl $0xffffffff, 0x6c(%rsp) # imm = 0xFFFFFFFF
jmp 0x34b8f
jmp 0x34ab5
jmp 0x34b99
movl $0x0, 0x6c(%rsp)
jmp 0x34bc3
movq 0x70(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x80(%rsp), %rax
cmpq 0x78(%rsp), %rax
jne 0x34bbe
movl $0x1, 0x6c(%rsp)
jmp 0x34bc3
jmp 0x34a33
jmp 0x34bc5
movq 0x98(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
callq 0x29f80
movl 0x6c(%rsp), %eax
movl %eax, 0xc4(%rsp)
movl 0xc4(%rsp), %eax
addq $0xc8, %rsp
retq
nopl (%rax)
| JS_OrdinaryIsInstanceOf:
sub rsp, 0C8h
mov [rsp+0C8h+var_18], rsi
mov [rsp+0C8h+var_10], rdx
mov [rsp+0C8h+var_28], rcx
mov [rsp+0C8h+var_20], r8
mov [rsp+0C8h+var_30], rdi
mov rdi, [rsp+0C8h+var_30]
mov rsi, [rsp+0C8h+var_28]
mov rdx, [rsp+0C8h+var_20]
call JS_IsFunction
cmp eax, 0
jnz short loc_34901
mov [rsp+0C8h+var_4], 0
jmp loc_34BED
loc_34901:
mov rax, [rsp+0C8h+var_28]
mov [rsp+0C8h+var_50], rax
mov rax, [rsp+0C8h+var_50]
movzx eax, word ptr [rax+6]
cmp eax, 0Eh
jnz short loc_3495F
mov rax, [rsp+0C8h+var_50]
mov rax, [rax+30h]
mov [rsp+0C8h+var_68], rax
mov rdi, [rsp+0C8h+var_30]
mov rax, [rsp+0C8h+var_68]
mov rsi, [rsp+0C8h+var_18]
mov rdx, [rsp+0C8h+var_10]
mov rcx, [rax]
mov r8, [rax+8]
call JS_IsInstanceOf
mov [rsp+0C8h+var_4], eax
jmp loc_34BED
loc_3495F:
mov rax, [rsp+0C8h+var_10]
cmp eax, 0FFFFFFFFh
jz short loc_3497C
mov [rsp+0C8h+var_4], 0
jmp loc_34BED
loc_3497C:
mov rdi, [rsp+0C8h+var_30]
mov rsi, [rsp+0C8h+var_28]
mov rdx, [rsp+0C8h+var_20]
mov ecx, 3Ch ; '<'
call JS_GetProperty
mov [rsp+0C8h+var_78], rax
mov [rsp+0C8h+var_70], rdx
mov rax, [rsp+0C8h+var_78]
mov [rsp+0C8h+var_40], rax
mov rax, [rsp+0C8h+var_70]
mov [rsp+0C8h+var_38], rax
mov rax, [rsp+0C8h+var_38]
cmp eax, 0FFFFFFFFh
jz short loc_34A16
mov rdi, [rsp+0C8h+var_40]
mov rsi, [rsp+0C8h+var_38]
call JS_IsException_1
cmp eax, 0
jnz short loc_34A09
mov rdi, [rsp+0C8h+var_30]
lea rsi, aOperandPrototy; "operand 'prototype' property is not an "...
mov al, 0
call JS_ThrowTypeError
mov [rsp+0C8h+var_88], rax
mov [rsp+0C8h+var_80], rdx
loc_34A09:
mov [rsp+0C8h+var_5C], 0FFFFFFFFh
jmp loc_34BC5
loc_34A16:
mov rax, [rsp+0C8h+var_40]
mov [rsp+0C8h+var_48], rax
mov rax, [rsp+0C8h+var_18]
mov [rsp+0C8h+var_50], rax
loc_34A33:
mov rax, [rsp+0C8h+var_50]
mov rax, [rax+18h]
mov rax, [rax+38h]
mov [rsp+0C8h+var_58], rax
cmp [rsp+0C8h+var_58], 0
jnz loc_34B9B
mov rax, [rsp+0C8h+var_50]
movzx eax, word ptr [rax+6]
cmp eax, 30h ; '0'
setz al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz loc_34B91
mov rax, [rsp+0C8h+var_50]
mov [rsp+0C8h+var_B8], rax
mov [rsp+0C8h+var_B0], 0FFFFFFFFFFFFFFFFh
mov rdi, [rsp+0C8h+var_B8]
mov rsi, [rsp+0C8h+var_B0]
call js_dup
mov [rsp+0C8h+var_A8], rax
mov [rsp+0C8h+var_A0], rdx
mov rax, [rsp+0C8h+var_A8]
mov [rsp+0C8h+var_98], rax
mov rax, [rsp+0C8h+var_A0]
mov [rsp+0C8h+var_90], rax
loc_34AB5:
mov rdi, [rsp+0C8h+var_30]
mov rsi, [rsp+0C8h+var_98]
mov rdx, [rsp+0C8h+var_90]
call JS_GetPrototypeFree
mov [rsp+0C8h+var_C8], rax
mov [rsp+0C8h+var_C0], rdx
mov rax, [rsp+0C8h+var_C8]
mov [rsp+0C8h+var_98], rax
mov rax, [rsp+0C8h+var_C0]
mov [rsp+0C8h+var_90], rax
mov rdi, [rsp+0C8h+var_98]
mov rsi, [rsp+0C8h+var_90]
call JS_IsException_1
cmp eax, 0
jz short loc_34B09
mov [rsp+0C8h+var_5C], 0FFFFFFFFh
jmp loc_34B8F
loc_34B09:
mov rdi, [rsp+0C8h+var_98]
mov rsi, [rsp+0C8h+var_90]
call JS_IsNull_1
cmp eax, 0
jz short loc_34B27
mov [rsp+0C8h+var_5C], 0
jmp short loc_34B8F
loc_34B27:
mov rax, [rsp+0C8h+var_48]
cmp rax, [rsp+0C8h+var_98]
jnz short loc_34B57
mov rdi, [rsp+0C8h+var_30]
mov rsi, [rsp+0C8h+var_98]
mov rdx, [rsp+0C8h+var_90]
call JS_FreeValue
mov [rsp+0C8h+var_5C], 1
jmp short loc_34B8F
loc_34B57:
mov rdi, [rsp+0C8h+var_30]
call js_poll_interrupts
cmp eax, 0
jz short loc_34B8A
mov rdi, [rsp+0C8h+var_30]
mov rsi, [rsp+0C8h+var_98]
mov rdx, [rsp+0C8h+var_90]
call JS_FreeValue
mov [rsp+0C8h+var_5C], 0FFFFFFFFh
jmp short loc_34B8F
loc_34B8A:
jmp loc_34AB5
loc_34B8F:
jmp short loc_34B99
loc_34B91:
mov [rsp+0C8h+var_5C], 0
loc_34B99:
jmp short loc_34BC3
loc_34B9B:
mov rax, [rsp+0C8h+var_58]
mov [rsp+0C8h+var_50], rax
mov rax, [rsp+0C8h+var_48]
cmp rax, [rsp+0C8h+var_50]
jnz short loc_34BBE
mov [rsp+0C8h+var_5C], 1
jmp short loc_34BC3
loc_34BBE:
jmp loc_34A33
loc_34BC3:
jmp short $+2
loc_34BC5:
mov rdi, [rsp+0C8h+var_30]
mov rsi, [rsp+0C8h+var_40]
mov rdx, [rsp+0C8h+var_38]
call JS_FreeValue
mov eax, [rsp+0C8h+var_5C]
mov [rsp+0C8h+var_4], eax
loc_34BED:
mov eax, [rsp+0C8h+var_4]
add rsp, 0C8h
retn
| long long JS_OrdinaryIsInstanceOf(
long long a1,
long long a2,
long long a3,
long long a4,
int a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
double v13; // xmm4_8
double v14; // xmm5_8
long long v15; // rdx
long long v16; // rdx
long long v17; // rcx
long long v18; // r8
long long v19; // r9
__m128 v20; // xmm4
__m128 v21; // xmm5
long long v22; // rdx
long long v23; // rdx
long long v24; // rdx
long long v25; // rcx
long long v26; // r8
long long v27; // r9
char v29; // [rsp+0h] [rbp-C8h]
long long PrototypeFree; // [rsp+0h] [rbp-C8h]
long long v31; // [rsp+8h] [rbp-C0h]
long long v32; // [rsp+10h] [rbp-B8h]
long long v33; // [rsp+18h] [rbp-B0h]
_DWORD *v34; // [rsp+20h] [rbp-A8h]
long long v35; // [rsp+28h] [rbp-A0h]
long long v36; // [rsp+30h] [rbp-98h]
long long v37; // [rsp+38h] [rbp-90h]
long long Property; // [rsp+50h] [rbp-78h]
unsigned int v39; // [rsp+6Ch] [rbp-5Ch]
long long v40; // [rsp+70h] [rbp-58h]
long long v41; // [rsp+78h] [rbp-50h]
long long v42; // [rsp+90h] [rbp-38h]
if ( (unsigned int)JS_IsFunction(a1, a4, a5) )
{
if ( *(_WORD *)(a4 + 6) == 14 )
{
return (unsigned int)JS_IsInstanceOf(
a1,
a2,
a3,
**(_QWORD **)(a4 + 48),
*(_QWORD *)(*(_QWORD *)(a4 + 48) + 8LL),
a6,
a7,
a8,
a9,
v13,
v14,
a12,
a13);
}
else if ( (_DWORD)a3 == -1 )
{
Property = JS_GetProperty(a1, a4, a5, 60);
v42 = v15;
if ( (_DWORD)v15 == -1 )
{
v41 = a2;
while ( 1 )
{
v40 = *(_QWORD *)(*(_QWORD *)(v41 + 24) + 56LL);
if ( !v40 )
break;
v41 = *(_QWORD *)(*(_QWORD *)(v41 + 24) + 56LL);
if ( Property == v40 )
{
v39 = 1;
goto LABEL_28;
}
}
if ( *(_WORD *)(v41 + 6) == 48 )
{
v32 = v41;
v33 = -1LL;
v34 = js_dup((_DWORD *)v41, 0xFFFFFFFF);
v35 = v22;
v36 = (long long)v34;
v37 = v22;
do
{
PrototypeFree = JS_GetPrototypeFree(a1, v36, v37);
v31 = v23;
v36 = PrototypeFree;
v37 = v23;
if ( JS_IsException_1(PrototypeFree, v23) )
{
v39 = -1;
goto LABEL_28;
}
if ( JS_IsNull_1(PrototypeFree, v37) )
{
v39 = 0;
goto LABEL_28;
}
if ( Property == PrototypeFree )
{
JS_FreeValue(a1, PrototypeFree, v37);
v39 = 1;
goto LABEL_28;
}
}
while ( !(unsigned int)js_poll_interrupts(a1, v37, v24, v25, v26, v27, PrototypeFree, v31, v32, v33, v34, v35) );
JS_FreeValue(a1, v36, v37);
v39 = -1;
}
else
{
v39 = 0;
}
}
else
{
if ( !JS_IsException_1(Property, v15) )
JS_ThrowTypeError(
a1,
(long long)"operand 'prototype' property is not an object",
v16,
v17,
v18,
v19,
a6,
a7,
a8,
a9,
v20,
v21,
a12,
a13,
v29);
v39 = -1;
}
LABEL_28:
JS_FreeValue(a1, Property, v42);
return v39;
}
else
{
return 0;
}
}
else
{
return 0;
}
}
| JS_OrdinaryIsInstanceOf:
SUB RSP,0xc8
MOV qword ptr [RSP + 0xb0],RSI
MOV qword ptr [RSP + 0xb8],RDX
MOV qword ptr [RSP + 0xa0],RCX
MOV qword ptr [RSP + 0xa8],R8
MOV qword ptr [RSP + 0x98],RDI
MOV RDI,qword ptr [RSP + 0x98]
MOV RSI,qword ptr [RSP + 0xa0]
MOV RDX,qword ptr [RSP + 0xa8]
CALL 0x00134800
CMP EAX,0x0
JNZ 0x00134901
MOV dword ptr [RSP + 0xc4],0x0
JMP 0x00134bed
LAB_00134901:
MOV RAX,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0x78],RAX
MOV RAX,qword ptr [RSP + 0x78]
MOVZX EAX,word ptr [RAX + 0x6]
CMP EAX,0xe
JNZ 0x0013495f
MOV RAX,qword ptr [RSP + 0x78]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RSP + 0x60],RAX
MOV RDI,qword ptr [RSP + 0x98]
MOV RAX,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0xb0]
MOV RDX,qword ptr [RSP + 0xb8]
MOV RCX,qword ptr [RAX]
MOV R8,qword ptr [RAX + 0x8]
CALL 0x00134390
MOV dword ptr [RSP + 0xc4],EAX
JMP 0x00134bed
LAB_0013495f:
MOV RAX,qword ptr [RSP + 0xb8]
CMP EAX,-0x1
JZ 0x0013497c
MOV dword ptr [RSP + 0xc4],0x0
JMP 0x00134bed
LAB_0013497c:
MOV RDI,qword ptr [RSP + 0x98]
MOV RSI,qword ptr [RSP + 0xa0]
MOV RDX,qword ptr [RSP + 0xa8]
MOV ECX,0x3c
CALL 0x00130070
MOV qword ptr [RSP + 0x50],RAX
MOV qword ptr [RSP + 0x58],RDX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x88],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x90],RAX
MOV RAX,qword ptr [RSP + 0x90]
CMP EAX,-0x1
JZ 0x00134a16
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x90]
CALL 0x00129fb0
CMP EAX,0x0
JNZ 0x00134a09
MOV RDI,qword ptr [RSP + 0x98]
LEA RSI,[0x214269]
MOV AL,0x0
CALL 0x001335f0
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
LAB_00134a09:
MOV dword ptr [RSP + 0x6c],0xffffffff
JMP 0x00134bc5
LAB_00134a16:
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0x80],RAX
MOV RAX,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0x78],RAX
LAB_00134a33:
MOV RAX,qword ptr [RSP + 0x78]
MOV RAX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV qword ptr [RSP + 0x70],RAX
CMP qword ptr [RSP + 0x70],0x0
JNZ 0x00134b9b
MOV RAX,qword ptr [RSP + 0x78]
MOVZX EAX,word ptr [RAX + 0x6]
CMP EAX,0x30
SETZ AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x00134b91
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],-0x1
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x001279c0
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],RDX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x38],RAX
LAB_00134ab5:
MOV RDI,qword ptr [RSP + 0x98]
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
CALL 0x00166550
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x38]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x00134b09
MOV dword ptr [RSP + 0x6c],0xffffffff
JMP 0x00134b8f
LAB_00134b09:
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x38]
CALL 0x00134530
CMP EAX,0x0
JZ 0x00134b27
MOV dword ptr [RSP + 0x6c],0x0
JMP 0x00134b8f
LAB_00134b27:
MOV RAX,qword ptr [RSP + 0x80]
CMP RAX,qword ptr [RSP + 0x30]
JNZ 0x00134b57
MOV RDI,qword ptr [RSP + 0x98]
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
CALL 0x00129f80
MOV dword ptr [RSP + 0x6c],0x1
JMP 0x00134b8f
LAB_00134b57:
MOV RDI,qword ptr [RSP + 0x98]
CALL 0x001665b0
CMP EAX,0x0
JZ 0x00134b8a
MOV RDI,qword ptr [RSP + 0x98]
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
CALL 0x00129f80
MOV dword ptr [RSP + 0x6c],0xffffffff
JMP 0x00134b8f
LAB_00134b8a:
JMP 0x00134ab5
LAB_00134b8f:
JMP 0x00134b99
LAB_00134b91:
MOV dword ptr [RSP + 0x6c],0x0
LAB_00134b99:
JMP 0x00134bc3
LAB_00134b9b:
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x78],RAX
MOV RAX,qword ptr [RSP + 0x80]
CMP RAX,qword ptr [RSP + 0x78]
JNZ 0x00134bbe
MOV dword ptr [RSP + 0x6c],0x1
JMP 0x00134bc3
LAB_00134bbe:
JMP 0x00134a33
LAB_00134bc3:
JMP 0x00134bc5
LAB_00134bc5:
MOV RDI,qword ptr [RSP + 0x98]
MOV RSI,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x90]
CALL 0x00129f80
MOV EAX,dword ptr [RSP + 0x6c]
MOV dword ptr [RSP + 0xc4],EAX
LAB_00134bed:
MOV EAX,dword ptr [RSP + 0xc4]
ADD RSP,0xc8
RET
|
int4
JS_OrdinaryIsInstanceOf
(int8 param_1,long param_2,int8 param_3,long param_4,int8 param_5)
{
int iVar1;
int4 uVar2;
long lVar3;
long lVar4;
int8 uVar5;
int1 auVar6 [16];
int1 auVar7 [16];
int8 local_98;
int8 local_90;
int4 local_5c;
long local_50;
iVar1 = JS_IsFunction(param_1,param_4,param_5);
if (iVar1 == 0) {
return 0;
}
if (*(short *)(param_4 + 6) == 0xe) {
uVar2 = JS_IsInstanceOf(param_1,param_2,param_3,**(int8 **)(param_4 + 0x30),
(*(int8 **)(param_4 + 0x30))[1]);
return uVar2;
}
if ((int)param_3 != -1) {
return 0;
}
auVar6 = JS_GetProperty(param_1,param_4,param_5,0x3c);
lVar3 = auVar6._0_8_;
local_50 = param_2;
if (auVar6._8_4_ == -1) {
do {
lVar4 = *(long *)(*(long *)(local_50 + 0x18) + 0x38);
if (lVar4 == 0) {
if (*(short *)(local_50 + 6) != 0x30) {
local_5c = 0;
goto LAB_00134bc5;
}
auVar7 = js_dup(local_50,0xffffffffffffffff);
goto LAB_00134ab5;
}
local_50 = lVar4;
} while (lVar3 != lVar4);
local_5c = 1;
}
else {
iVar1 = JS_IsException(lVar3,auVar6._8_8_);
if (iVar1 == 0) {
JS_ThrowTypeError(param_1,"operand \'prototype\' property is not an object");
}
local_5c = 0xffffffff;
}
goto LAB_00134bc5;
while( true ) {
if (lVar3 == lVar4) {
JS_FreeValue(param_1,lVar4,uVar5);
local_5c = 1;
goto LAB_00134bc5;
}
iVar1 = js_poll_interrupts(param_1);
if (iVar1 != 0) break;
LAB_00134ab5:
local_90 = auVar7._8_8_;
local_98 = auVar7._0_8_;
auVar7 = JS_GetPrototypeFree(param_1,local_98,local_90);
uVar5 = auVar7._8_8_;
lVar4 = auVar7._0_8_;
iVar1 = JS_IsException(lVar4,uVar5);
if (iVar1 != 0) {
local_5c = 0xffffffff;
goto LAB_00134bc5;
}
iVar1 = JS_IsNull(lVar4,uVar5);
if (iVar1 != 0) {
local_5c = 0;
goto LAB_00134bc5;
}
}
JS_FreeValue(param_1,lVar4,uVar5);
local_5c = 0xffffffff;
LAB_00134bc5:
JS_FreeValue(param_1,lVar3,auVar6._8_8_);
return local_5c;
}
| |
45,641 | JS_OrdinaryIsInstanceOf | bluesky950520[P]quickjs/quickjs.c | static int JS_OrdinaryIsInstanceOf(JSContext *ctx, JSValue val,
JSValue obj)
{
JSValue obj_proto;
JSObject *proto;
const JSObject *p, *proto1;
BOOL ret;
if (!JS_IsFunction(ctx, obj))
return FALSE;
p = JS_VALUE_GET_OBJ(obj);
if (p->class_id == JS_CLASS_BOUND_FUNCTION) {
JSBoundFunction *s = p->u.bound_function;
return JS_IsInstanceOf(ctx, val, s->func_obj);
}
/* Only explicitly boxed values are instances of constructors */
if (JS_VALUE_GET_TAG(val) != JS_TAG_OBJECT)
return FALSE;
obj_proto = JS_GetProperty(ctx, obj, JS_ATOM_prototype);
if (JS_VALUE_GET_TAG(obj_proto) != JS_TAG_OBJECT) {
if (!JS_IsException(obj_proto))
JS_ThrowTypeError(ctx, "operand 'prototype' property is not an object");
ret = -1;
goto done;
}
proto = JS_VALUE_GET_OBJ(obj_proto);
p = JS_VALUE_GET_OBJ(val);
for(;;) {
proto1 = p->shape->proto;
if (!proto1) {
/* slow case if proxy in the prototype chain */
if (unlikely(p->class_id == JS_CLASS_PROXY)) {
JSValue obj1;
obj1 = js_dup(JS_MKPTR(JS_TAG_OBJECT, (JSObject *)p));
for(;;) {
obj1 = JS_GetPrototypeFree(ctx, obj1);
if (JS_IsException(obj1)) {
ret = -1;
break;
}
if (JS_IsNull(obj1)) {
ret = FALSE;
break;
}
if (proto == JS_VALUE_GET_OBJ(obj1)) {
JS_FreeValue(ctx, obj1);
ret = TRUE;
break;
}
/* must check for timeout to avoid infinite loop */
if (js_poll_interrupts(ctx)) {
JS_FreeValue(ctx, obj1);
ret = -1;
break;
}
}
} else {
ret = FALSE;
}
break;
}
p = proto1;
if (proto == p) {
ret = TRUE;
break;
}
}
done:
JS_FreeValue(ctx, obj_proto);
return ret;
} | O2 | c | JS_OrdinaryIsInstanceOf:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
movq %rcx, %rsi
movq %r8, %rdx
callq 0x20a2d
xorl %ebp, %ebp
testl %eax, %eax
je 0x20b3f
cmpw $0xe, 0x6(%r15)
jne 0x20ac8
movq 0x30(%r15), %rax
movq (%rax), %rcx
movq 0x8(%rax), %r8
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2086b
cmpl $-0x1, %r13d
jne 0x20b3f
pushq $0x3c
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1ebf3
movq %rax, %r15
movq %rdx, %r14
pushq $-0x1
popq %rbp
cmpl $0x6, %r14d
je 0x20b31
cmpl $-0x1, %r14d
jne 0x20b13
pushq $0x1
popq %r13
movq 0x18(%r12), %rax
movq 0x38(%rax), %rax
testq %rax, %rax
je 0x20b26
movq %rax, %r12
cmpq %r15, %rax
jne 0x20af8
movl %r13d, %ebp
jmp 0x20b31
leaq 0x686b3(%rip), %rsi # 0x891cd
movq %rbx, %rdi
xorl %eax, %eax
callq 0x201fd
jmp 0x20b31
cmpw $0x30, 0x6(%r12)
je 0x20b50
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1bbce
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
incl (%r12)
pushq $-0x1
popq %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq (%rsp), %rdx
callq 0x3995d
cmpl $0x2, %edx
je 0x20b2f
movq %rdx, (%rsp)
cmpl $0x6, %edx
je 0x20b31
movq %rax, %r12
movq %rbx, %rdi
cmpq %rax, %r15
je 0x20b9d
callq 0x39998
testl %eax, %eax
je 0x20b5b
movq %rbx, %rdi
movq %r12, %rsi
movq (%rsp), %rdx
callq 0x1bbce
jmp 0x20b31
movq %r12, %rsi
movq (%rsp), %rdx
callq 0x1bbce
jmp 0x20b0e
| JS_OrdinaryIsInstanceOf:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, r8
mov r15, rcx
mov r13, rdx
mov r12, rsi
mov rbx, rdi
mov rsi, rcx
mov rdx, r8
call JS_IsFunction
xor ebp, ebp
test eax, eax
jz loc_20B3F
cmp word ptr [r15+6], 0Eh
jnz short loc_20AC8
mov rax, [r15+30h]
mov rcx, [rax]
mov r8, [rax+8]
mov rdi, rbx
mov rsi, r12
mov rdx, r13
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp JS_IsInstanceOf
loc_20AC8:
cmp r13d, 0FFFFFFFFh
jnz short loc_20B3F
push 3Ch ; '<'
pop rcx
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_GetProperty
mov r15, rax
mov r14, rdx
push 0FFFFFFFFFFFFFFFFh
pop rbp
cmp r14d, 6
jz short loc_20B31
cmp r14d, 0FFFFFFFFh
jnz short loc_20B13
push 1
pop r13
loc_20AF8:
mov rax, [r12+18h]
mov rax, [rax+38h]
test rax, rax
jz short loc_20B26
mov r12, rax
cmp rax, r15
jnz short loc_20AF8
loc_20B0E:
mov ebp, r13d
jmp short loc_20B31
loc_20B13:
lea rsi, aOperandPrototy; "operand 'prototype' property is not an "...
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
jmp short loc_20B31
loc_20B26:
cmp word ptr [r12+6], 30h ; '0'
jz short loc_20B50
loc_20B2F:
xor ebp, ebp
loc_20B31:
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_FreeValue
loc_20B3F:
mov eax, ebp
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_20B50:
inc dword ptr [r12]
push 0FFFFFFFFFFFFFFFFh
pop rax
mov [rsp+38h+var_38], rax
loc_20B5B:
mov rdi, rbx
mov rsi, r12
mov rdx, [rsp+38h+var_38]
call JS_GetPrototypeFree
cmp edx, 2
jz short loc_20B2F
mov [rsp+38h+var_38], rdx
cmp edx, 6
jz short loc_20B31
mov r12, rax
mov rdi, rbx
cmp r15, rax
jz short loc_20B9D
call js_poll_interrupts
test eax, eax
jz short loc_20B5B
mov rdi, rbx
mov rsi, r12
mov rdx, [rsp+38h+var_38]
call JS_FreeValue
jmp short loc_20B31
loc_20B9D:
mov rsi, r12
mov rdx, [rsp+38h+var_38]
call JS_FreeValue
jmp loc_20B0E
| long long JS_OrdinaryIsInstanceOf(
long long a1,
long long a2,
long long a3,
long long a4,
int a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
char v13; // al
long long v17; // r12
long long v18; // r9
__m128 v19; // xmm4
__m128 v20; // xmm5
unsigned int v21; // ebp
long long v23; // rdx
long long v24; // rcx
long long v25; // r8
long long v26; // r9
long long Property; // r15
__m128 v28; // xmm4
__m128 v29; // xmm5
long long v30; // r14
long long v31; // rax
long long PrototypeFree; // rax
long long v33; // rdx
char v34; // [rsp+0h] [rbp-38h]
long long v35; // [rsp+0h] [rbp-38h]
v34 = v13;
v17 = a2;
v21 = 0;
if ( (unsigned int)JS_IsFunction(a1, a4, a5) )
{
if ( *(_WORD *)(a4 + 6) == 14 )
return JS_IsInstanceOf(
a1,
a2,
a3,
**(_QWORD **)(a4 + 48),
*(_QWORD *)(*(_QWORD *)(a4 + 48) + 8LL),
v18,
a6,
a7,
a8,
a9,
v19,
v20,
a12,
a13);
if ( (_DWORD)a3 == -1 )
{
Property = JS_GetProperty(a1, a4, a5, 60);
v30 = v23;
v21 = -1;
if ( (_DWORD)v23 != 6 )
{
if ( (_DWORD)v23 == -1 )
{
while ( 1 )
{
v31 = *(_QWORD *)(*(_QWORD *)(v17 + 24) + 56LL);
if ( !v31 )
break;
v17 = *(_QWORD *)(*(_QWORD *)(v17 + 24) + 56LL);
if ( v31 == Property )
{
LABEL_9:
v21 = 1;
goto LABEL_13;
}
}
if ( *(_WORD *)(v17 + 6) == 48 )
{
++*(_DWORD *)v17;
v35 = -1LL;
while ( 1 )
{
PrototypeFree = JS_GetPrototypeFree(a1, v17, v35);
if ( (_DWORD)v33 == 2 )
break;
v35 = v33;
if ( (_DWORD)v33 == 6 )
goto LABEL_13;
v17 = PrototypeFree;
if ( Property == PrototypeFree )
{
JS_FreeValue(a1, PrototypeFree, v33);
goto LABEL_9;
}
if ( (unsigned int)js_poll_interrupts(a1) )
{
JS_FreeValue(a1, v17, v35);
goto LABEL_13;
}
}
}
v21 = 0;
}
else
{
JS_ThrowTypeError(
a1,
(long long)"operand 'prototype' property is not an object",
v23,
v24,
v25,
v26,
a6,
a7,
a8,
a9,
v28,
v29,
a12,
a13,
v34);
}
}
LABEL_13:
JS_FreeValue(a1, Property, v30);
}
}
return v21;
}
| JS_OrdinaryIsInstanceOf:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R8
MOV R15,RCX
MOV R13,RDX
MOV R12,RSI
MOV RBX,RDI
MOV RSI,RCX
MOV RDX,R8
CALL 0x00120a2d
XOR EBP,EBP
TEST EAX,EAX
JZ 0x00120b3f
CMP word ptr [R15 + 0x6],0xe
JNZ 0x00120ac8
MOV RAX,qword ptr [R15 + 0x30]
MOV RCX,qword ptr [RAX]
MOV R8,qword ptr [RAX + 0x8]
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R13
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0012086b
LAB_00120ac8:
CMP R13D,-0x1
JNZ 0x00120b3f
PUSH 0x3c
POP RCX
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x0011ebf3
MOV R15,RAX
MOV R14,RDX
PUSH -0x1
POP RBP
CMP R14D,0x6
JZ 0x00120b31
CMP R14D,-0x1
JNZ 0x00120b13
PUSH 0x1
POP R13
LAB_00120af8:
MOV RAX,qword ptr [R12 + 0x18]
MOV RAX,qword ptr [RAX + 0x38]
TEST RAX,RAX
JZ 0x00120b26
MOV R12,RAX
CMP RAX,R15
JNZ 0x00120af8
LAB_00120b0e:
MOV EBP,R13D
JMP 0x00120b31
LAB_00120b13:
LEA RSI,[0x1891cd]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x001201fd
JMP 0x00120b31
LAB_00120b26:
CMP word ptr [R12 + 0x6],0x30
JZ 0x00120b50
LAB_00120b2f:
XOR EBP,EBP
LAB_00120b31:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x0011bbce
LAB_00120b3f:
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00120b50:
INC dword ptr [R12]
PUSH -0x1
POP RAX
MOV qword ptr [RSP],RAX
LAB_00120b5b:
MOV RDI,RBX
MOV RSI,R12
MOV RDX,qword ptr [RSP]
CALL 0x0013995d
CMP EDX,0x2
JZ 0x00120b2f
MOV qword ptr [RSP],RDX
CMP EDX,0x6
JZ 0x00120b31
MOV R12,RAX
MOV RDI,RBX
CMP R15,RAX
JZ 0x00120b9d
CALL 0x00139998
TEST EAX,EAX
JZ 0x00120b5b
MOV RDI,RBX
MOV RSI,R12
MOV RDX,qword ptr [RSP]
CALL 0x0011bbce
JMP 0x00120b31
LAB_00120b9d:
MOV RSI,R12
MOV RDX,qword ptr [RSP]
CALL 0x0011bbce
JMP 0x00120b0e
|
ulong JS_OrdinaryIsInstanceOf
(int8 param_1,int *param_2,int8 param_3,long param_4,int8 param_5)
{
int iVar1;
ulong uVar2;
int *piVar3;
int1 auVar5 [16];
int1 auVar6 [16];
int8 local_38;
int *piVar4;
iVar1 = JS_IsFunction(param_1,param_4,param_5);
uVar2 = 0;
if (iVar1 == 0) goto LAB_00120b3f;
if (*(short *)(param_4 + 6) == 0xe) {
uVar2 = JS_IsInstanceOf(param_1,param_2,param_3,**(int8 **)(param_4 + 0x30),
(*(int8 **)(param_4 + 0x30))[1]);
return uVar2;
}
if ((int)param_3 != -1) goto LAB_00120b3f;
auVar5 = JS_GetProperty(param_1,param_4,param_5,0x3c);
piVar3 = auVar5._0_8_;
uVar2 = 0xffffffffffffffff;
if (auVar5._8_4_ != 6) {
if (auVar5._8_4_ == -1) {
do {
piVar4 = *(int **)(*(long *)(param_2 + 6) + 0x38);
if (piVar4 == (int *)0x0) {
if (*(short *)((long)param_2 + 6) != 0x30) goto LAB_00120b2f;
*param_2 = *param_2 + 1;
auVar6._8_8_ = 0xffffffffffffffff;
auVar6._0_8_ = param_2;
goto LAB_00120b5b;
}
param_2 = piVar4;
} while (piVar4 != piVar3);
LAB_00120b0e:
uVar2 = 1;
}
else {
JS_ThrowTypeError(param_1,"operand \'prototype\' property is not an object");
}
}
goto LAB_00120b31;
LAB_00120b2f:
uVar2 = 0;
goto LAB_00120b31;
while( true ) {
if (auVar6._8_4_ == 6) goto LAB_00120b31;
if (piVar3 == piVar4) {
JS_FreeValue(param_1,piVar4,auVar6._8_8_);
goto LAB_00120b0e;
}
iVar1 = js_poll_interrupts();
if (iVar1 != 0) break;
LAB_00120b5b:
local_38 = auVar6._8_8_;
auVar6 = JS_GetPrototypeFree(param_1,auVar6._0_8_,local_38);
piVar4 = auVar6._0_8_;
if (auVar6._8_4_ == 2) goto LAB_00120b2f;
}
JS_FreeValue(param_1,piVar4,auVar6._8_8_);
LAB_00120b31:
JS_FreeValue(param_1,piVar3,auVar5._8_8_);
LAB_00120b3f:
return uVar2 & 0xffffffff;
}
| |
45,642 | JS_OrdinaryIsInstanceOf | bluesky950520[P]quickjs/quickjs.c | static int JS_OrdinaryIsInstanceOf(JSContext *ctx, JSValue val,
JSValue obj)
{
JSValue obj_proto;
JSObject *proto;
const JSObject *p, *proto1;
BOOL ret;
if (!JS_IsFunction(ctx, obj))
return FALSE;
p = JS_VALUE_GET_OBJ(obj);
if (p->class_id == JS_CLASS_BOUND_FUNCTION) {
JSBoundFunction *s = p->u.bound_function;
return JS_IsInstanceOf(ctx, val, s->func_obj);
}
/* Only explicitly boxed values are instances of constructors */
if (JS_VALUE_GET_TAG(val) != JS_TAG_OBJECT)
return FALSE;
obj_proto = JS_GetProperty(ctx, obj, JS_ATOM_prototype);
if (JS_VALUE_GET_TAG(obj_proto) != JS_TAG_OBJECT) {
if (!JS_IsException(obj_proto))
JS_ThrowTypeError(ctx, "operand 'prototype' property is not an object");
ret = -1;
goto done;
}
proto = JS_VALUE_GET_OBJ(obj_proto);
p = JS_VALUE_GET_OBJ(val);
for(;;) {
proto1 = p->shape->proto;
if (!proto1) {
/* slow case if proxy in the prototype chain */
if (unlikely(p->class_id == JS_CLASS_PROXY)) {
JSValue obj1;
obj1 = js_dup(JS_MKPTR(JS_TAG_OBJECT, (JSObject *)p));
for(;;) {
obj1 = JS_GetPrototypeFree(ctx, obj1);
if (JS_IsException(obj1)) {
ret = -1;
break;
}
if (JS_IsNull(obj1)) {
ret = FALSE;
break;
}
if (proto == JS_VALUE_GET_OBJ(obj1)) {
JS_FreeValue(ctx, obj1);
ret = TRUE;
break;
}
/* must check for timeout to avoid infinite loop */
if (js_poll_interrupts(ctx)) {
JS_FreeValue(ctx, obj1);
ret = -1;
break;
}
}
} else {
ret = FALSE;
}
break;
}
p = proto1;
if (proto == p) {
ret = TRUE;
break;
}
}
done:
JS_FreeValue(ctx, obj_proto);
return ret;
} | O3 | c | JS_OrdinaryIsInstanceOf:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r9
xorl %ebp, %ebp
cmpl $-0x1, %r9d
jne 0x27795
movq %rcx, %r8
movq %rsi, %r12
movq %rdi, %rbx
movzwl 0x6(%rcx), %eax
cmpl $0xd, %eax
je 0x276f5
cmpl $0x30, %eax
jne 0x276b1
movq 0x30(%r8), %rax
cmpb $0x0, 0x20(%rax)
setne %al
cmpl $-0x1, %edx
sete %cl
testb %cl, %al
jne 0x276fe
jmp 0x27795
movq 0x18(%rbx), %rcx
movq 0x80(%rcx), %rcx
leaq (%rax,%rax,4), %rsi
cmpq $0x0, 0x18(%rcx,%rsi,8)
je 0x27795
cmpl $0xe, %eax
jne 0x276f5
movq 0x30(%r8), %rax
movq (%rax), %rcx
movq 0x8(%rax), %r8
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x273da
cmpl $-0x1, %edx
jne 0x27795
movq %rbx, %rdi
movq %r8, %rsi
movq %r9, %rdx
movl $0x3c, %ecx
pushq $0x0
pushq $0x0
callq 0x27857
addq $0x10, %rsp
movq %rdx, %r15
cmpl $0x6, %r15d
je 0x27748
movq %rax, %r14
cmpl $-0x1, %r15d
jne 0x2774f
movq 0x18(%r12), %rax
movq 0x38(%rax), %rax
testq %rax, %rax
je 0x27767
movq %rax, %r12
cmpq %r14, %rax
jne 0x2772b
movl $0x1, %ebp
jmp 0x27772
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
jmp 0x27795
leaq 0x7eab7(%rip), %rsi # 0xa620d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x26d97
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
jmp 0x27772
xorl %ebp, %ebp
cmpw $0x30, 0x6(%r12)
je 0x277a6
cmpl $-0x9, %r15d
jb 0x27795
movq 0x18(%rbx), %rdi
movl (%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r14)
cmpl $0x1, %eax
jg 0x27795
movq %r14, %rsi
movq %r15, %rdx
callq 0x259d8
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
incl (%r12)
movq $-0x1, %r13
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x42a98
movq %rdx, %r13
cmpl $0x2, %r13d
je 0x27772
cmpl $0x6, %r13d
je 0x27760
movq %rax, %r12
cmpq %rax, %r14
je 0x27822
movl 0x1d8(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x1d8(%rbx)
cmpl $0x1, %eax
jg 0x277b1
movq %rbx, %rdi
callq 0x42ae7
testl %eax, %eax
je 0x277b1
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpl $-0x9, %r13d
jb 0x27772
movq 0x18(%rbx), %rdi
movl (%r12), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r12)
cmpl $0x1, %eax
jg 0x27772
movq %r12, %rsi
jmp 0x2784a
movl $0x1, %ebp
cmpl $-0x9, %r13d
jb 0x27772
movq 0x18(%rbx), %rdi
movl (%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r14)
cmpl $0x1, %eax
jg 0x27772
movq %r14, %rsi
movq %r13, %rdx
callq 0x259d8
jmp 0x27772
| JS_OrdinaryIsInstanceOf:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r9, r8
xor ebp, ebp
cmp r9d, 0FFFFFFFFh
jnz loc_27795
mov r8, rcx
mov r12, rsi
mov rbx, rdi
movzx eax, word ptr [rcx+6]
cmp eax, 0Dh
jz short loc_276F5
cmp eax, 30h ; '0'
jnz short loc_276B1
mov rax, [r8+30h]
cmp byte ptr [rax+20h], 0
setnz al
cmp edx, 0FFFFFFFFh
setz cl
test al, cl
jnz short loc_276FE
jmp loc_27795
loc_276B1:
mov rcx, [rbx+18h]
mov rcx, [rcx+80h]
lea rsi, [rax+rax*4]
cmp qword ptr [rcx+rsi*8+18h], 0
jz loc_27795
cmp eax, 0Eh
jnz short loc_276F5
mov rax, [r8+30h]
mov rcx, [rax]
mov r8, [rax+8]
mov rdi, rbx
mov rsi, r12
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp JS_IsInstanceOf
loc_276F5:
cmp edx, 0FFFFFFFFh
jnz loc_27795
loc_276FE:
mov rdi, rbx
mov rsi, r8
mov rdx, r9
mov ecx, 3Ch ; '<'
push 0
push 0
call JS_GetPropertyInternal2
add rsp, 10h
mov r15, rdx
cmp r15d, 6
jz short loc_27748
mov r14, rax
cmp r15d, 0FFFFFFFFh
jnz short loc_2774F
loc_2772B:
mov rax, [r12+18h]
mov rax, [rax+38h]
test rax, rax
jz short loc_27767
mov r12, rax
cmp rax, r14
jnz short loc_2772B
mov ebp, 1
jmp short loc_27772
loc_27748:
mov ebp, 0FFFFFFFFh
jmp short loc_27795
loc_2774F:
lea rsi, aOperandPrototy; "operand 'prototype' property is not an "...
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
loc_27760:
mov ebp, 0FFFFFFFFh
jmp short loc_27772
loc_27767:
xor ebp, ebp
cmp word ptr [r12+6], 30h ; '0'
jz short loc_277A6
loc_27772:
cmp r15d, 0FFFFFFF7h
jb short loc_27795
mov rdi, [rbx+18h]
mov eax, [r14]
lea ecx, [rax-1]
mov [r14], ecx
cmp eax, 1
jg short loc_27795
mov rsi, r14
mov rdx, r15
call js_free_value_rt
loc_27795:
mov eax, ebp
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_277A6:
inc dword ptr [r12]
mov r13, 0FFFFFFFFFFFFFFFFh
loc_277B1:
mov rdi, rbx
mov rsi, r12
mov rdx, r13
call JS_GetPrototypeFree
mov r13, rdx
cmp r13d, 2
jz short loc_27772
cmp r13d, 6
jz short loc_27760
mov r12, rax
cmp r14, rax
jz short loc_27822
mov eax, [rbx+1D8h]
lea ecx, [rax-1]
mov [rbx+1D8h], ecx
cmp eax, 1
jg short loc_277B1
mov rdi, rbx
call __js_poll_interrupts
test eax, eax
jz short loc_277B1
mov ebp, 0FFFFFFFFh
cmp r13d, 0FFFFFFF7h
jb loc_27772
mov rdi, [rbx+18h]
mov eax, [r12]
lea ecx, [rax-1]
mov [r12], ecx
cmp eax, 1
jg loc_27772
mov rsi, r12
jmp short loc_2784A
loc_27822:
mov ebp, 1
cmp r13d, 0FFFFFFF7h
jb loc_27772
mov rdi, [rbx+18h]
mov eax, [r14]
lea ecx, [rax-1]
mov [r14], ecx
cmp eax, 1
jg loc_27772
mov rsi, r14
loc_2784A:
mov rdx, r13
call js_free_value_rt
jmp loc_27772
| long long JS_OrdinaryIsInstanceOf(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13)
{
char v13; // al
unsigned int v14; // ebp
long long v15; // r12
long long v17; // rax
long long PropertyInternal2; // rax
long long v20; // rdx
long long v21; // rcx
long long v22; // r8
long long v23; // r9
__m128 v24; // xmm4
__m128 v25; // xmm5
long long v26; // r15
_QWORD *v27; // r14
_QWORD *v28; // rax
long long v29; // rdi
int v30; // eax
long long v31; // rcx
long long v32; // r13
long long PrototypeFree; // rax
long long v34; // rdx
int v35; // eax
long long v36; // rdi
int v37; // eax
long long v38; // rcx
_QWORD *v39; // rsi
int v40; // eax
char v41; // [rsp-8h] [rbp-38h]
v41 = v13;
v14 = 0;
if ( (_DWORD)a5 != -1 )
return v14;
v15 = a2;
v17 = *(unsigned __int16 *)(a4 + 6);
if ( (_DWORD)v17 == 13 )
{
LABEL_9:
if ( (_DWORD)a3 == -1 )
goto LABEL_10;
return v14;
}
if ( (_DWORD)v17 == 48 )
{
if ( (_DWORD)a3 != -1 || *(_BYTE *)(*(_QWORD *)(a4 + 48) + 32LL) == 0 )
return v14;
LABEL_10:
PropertyInternal2 = JS_GetPropertyInternal2(a1, a4, a5, 60, a4, a5, 0LL, 0);
v26 = v20;
if ( (_DWORD)v20 == 6 )
{
return (unsigned int)-1;
}
else
{
v27 = (_QWORD *)PropertyInternal2;
if ( (_DWORD)v20 == -1 )
{
while ( 1 )
{
v28 = *(_QWORD **)(*(_QWORD *)(v15 + 24) + 56LL);
if ( !v28 )
break;
v15 = *(_QWORD *)(*(_QWORD *)(v15 + 24) + 56LL);
if ( v28 == v27 )
{
v14 = 1;
goto LABEL_19;
}
}
v14 = 0;
if ( *(_WORD *)(v15 + 6) == 48 )
{
++*(_DWORD *)v15;
v32 = -1LL;
while ( 1 )
{
PrototypeFree = JS_GetPrototypeFree(a1, v15, v32);
v32 = v34;
if ( (_DWORD)v34 == 2 )
goto LABEL_19;
if ( (_DWORD)v34 == 6 )
goto LABEL_17;
v15 = PrototypeFree;
if ( v27 == (_QWORD *)PrototypeFree )
break;
v35 = *(_DWORD *)(a1 + 472);
*(_DWORD *)(a1 + 472) = v35 - 1;
if ( v35 <= 1 && (unsigned int)_js_poll_interrupts(a1) )
{
v14 = -1;
if ( (unsigned int)v32 >= 0xFFFFFFF7 )
{
v36 = *(_QWORD *)(a1 + 24);
v37 = *(_DWORD *)v15;
v38 = (unsigned int)(*(_DWORD *)v15 - 1);
*(_DWORD *)v15 = v38;
if ( v37 <= 1 )
{
v39 = (_QWORD *)v15;
LABEL_35:
js_free_value_rt(v36, v39, v32, v38, v22, v23);
goto LABEL_19;
}
}
goto LABEL_19;
}
}
v14 = 1;
if ( (unsigned int)v34 >= 0xFFFFFFF7 )
{
v36 = *(_QWORD *)(a1 + 24);
v40 = *(_DWORD *)v27;
v38 = (unsigned int)(*(_DWORD *)v27 - 1);
*(_DWORD *)v27 = v38;
if ( v40 <= 1 )
{
v39 = v27;
goto LABEL_35;
}
}
}
}
else
{
JS_ThrowTypeError(
a1,
(long long)"operand 'prototype' property is not an object",
v20,
v21,
v22,
v23,
a6,
a7,
a8,
a9,
v24,
v25,
a12,
a13,
v41);
LABEL_17:
v14 = -1;
}
LABEL_19:
if ( (unsigned int)v26 >= 0xFFFFFFF7 )
{
v29 = *(_QWORD *)(a1 + 24);
v30 = *(_DWORD *)v27;
v31 = (unsigned int)(*(_DWORD *)v27 - 1);
*(_DWORD *)v27 = v31;
if ( v30 <= 1 )
js_free_value_rt(v29, v27, v26, v31, v22, v23);
}
}
return v14;
}
if ( *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 128LL) + 40 * v17 + 24) )
{
if ( (_DWORD)v17 == 14 )
return JS_IsInstanceOf(
a1,
a2,
a3,
**(_QWORD **)(a4 + 48),
*(_QWORD *)(*(_QWORD *)(a4 + 48) + 8LL),
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13);
goto LABEL_9;
}
return v14;
}
| JS_OrdinaryIsInstanceOf:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R9,R8
XOR EBP,EBP
CMP R9D,-0x1
JNZ 0x00127795
MOV R8,RCX
MOV R12,RSI
MOV RBX,RDI
MOVZX EAX,word ptr [RCX + 0x6]
CMP EAX,0xd
JZ 0x001276f5
CMP EAX,0x30
JNZ 0x001276b1
MOV RAX,qword ptr [R8 + 0x30]
CMP byte ptr [RAX + 0x20],0x0
SETNZ AL
CMP EDX,-0x1
SETZ CL
TEST AL,CL
JNZ 0x001276fe
JMP 0x00127795
LAB_001276b1:
MOV RCX,qword ptr [RBX + 0x18]
MOV RCX,qword ptr [RCX + 0x80]
LEA RSI,[RAX + RAX*0x4]
CMP qword ptr [RCX + RSI*0x8 + 0x18],0x0
JZ 0x00127795
CMP EAX,0xe
JNZ 0x001276f5
MOV RAX,qword ptr [R8 + 0x30]
MOV RCX,qword ptr [RAX]
MOV R8,qword ptr [RAX + 0x8]
MOV RDI,RBX
MOV RSI,R12
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001273da
LAB_001276f5:
CMP EDX,-0x1
JNZ 0x00127795
LAB_001276fe:
MOV RDI,RBX
MOV RSI,R8
MOV RDX,R9
MOV ECX,0x3c
PUSH 0x0
PUSH 0x0
CALL 0x00127857
ADD RSP,0x10
MOV R15,RDX
CMP R15D,0x6
JZ 0x00127748
MOV R14,RAX
CMP R15D,-0x1
JNZ 0x0012774f
LAB_0012772b:
MOV RAX,qword ptr [R12 + 0x18]
MOV RAX,qword ptr [RAX + 0x38]
TEST RAX,RAX
JZ 0x00127767
MOV R12,RAX
CMP RAX,R14
JNZ 0x0012772b
MOV EBP,0x1
JMP 0x00127772
LAB_00127748:
MOV EBP,0xffffffff
JMP 0x00127795
LAB_0012774f:
LEA RSI,[0x1a620d]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00126d97
LAB_00127760:
MOV EBP,0xffffffff
JMP 0x00127772
LAB_00127767:
XOR EBP,EBP
CMP word ptr [R12 + 0x6],0x30
JZ 0x001277a6
LAB_00127772:
CMP R15D,-0x9
JC 0x00127795
MOV RDI,qword ptr [RBX + 0x18]
MOV EAX,dword ptr [R14]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R14],ECX
CMP EAX,0x1
JG 0x00127795
MOV RSI,R14
MOV RDX,R15
CALL 0x001259d8
LAB_00127795:
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001277a6:
INC dword ptr [R12]
MOV R13,-0x1
LAB_001277b1:
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R13
CALL 0x00142a98
MOV R13,RDX
CMP R13D,0x2
JZ 0x00127772
CMP R13D,0x6
JZ 0x00127760
MOV R12,RAX
CMP R14,RAX
JZ 0x00127822
MOV EAX,dword ptr [RBX + 0x1d8]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RBX + 0x1d8],ECX
CMP EAX,0x1
JG 0x001277b1
MOV RDI,RBX
CALL 0x00142ae7
TEST EAX,EAX
JZ 0x001277b1
MOV EBP,0xffffffff
CMP R13D,-0x9
JC 0x00127772
MOV RDI,qword ptr [RBX + 0x18]
MOV EAX,dword ptr [R12]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R12],ECX
CMP EAX,0x1
JG 0x00127772
MOV RSI,R12
JMP 0x0012784a
LAB_00127822:
MOV EBP,0x1
CMP R13D,-0x9
JC 0x00127772
MOV RDI,qword ptr [RBX + 0x18]
MOV EAX,dword ptr [R14]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R14],ECX
CMP EAX,0x1
JG 0x00127772
MOV RSI,R14
LAB_0012784a:
MOV RDX,R13
CALL 0x001259d8
JMP 0x00127772
|
int8
JS_OrdinaryIsInstanceOf
(long param_1,int *param_2,int8 param_3,long param_4,int8 param_5)
{
ushort uVar1;
int8 uVar2;
int iVar3;
int *piVar4;
int8 uVar6;
uint uVar7;
uint uVar8;
int1 auVar9 [16];
int1 auVar10 [16];
int *piVar5;
if ((int)param_5 != -1) {
return 0;
}
uVar1 = *(ushort *)(param_4 + 6);
if (uVar1 == 0xd) {
LAB_001276f5:
if ((int)param_3 != -1) {
return 0;
}
}
else {
if (uVar1 != 0x30) {
if (*(long *)(*(long *)(*(long *)(param_1 + 0x18) + 0x80) + 0x18 + (ulong)uVar1 * 0x28) == 0)
{
return 0;
}
if (uVar1 == 0xe) {
uVar6 = JS_IsInstanceOf(param_1,param_2,param_3,**(int8 **)(param_4 + 0x30),
(*(int8 **)(param_4 + 0x30))[1]);
return uVar6;
}
goto LAB_001276f5;
}
if (*(char *)(*(long *)(param_4 + 0x30) + 0x20) == '\0' || (int)param_3 != -1) {
return 0;
}
}
auVar9 = JS_GetPropertyInternal2(param_1,param_4,param_5,0x3c,param_4,param_5,0,0);
piVar4 = auVar9._0_8_;
uVar8 = auVar9._8_4_;
if (uVar8 == 6) {
return 0xffffffff;
}
if (uVar8 == 0xffffffff) {
do {
piVar5 = *(int **)(*(long *)(param_2 + 6) + 0x38);
if (piVar5 == (int *)0x0) {
uVar6 = 0;
if (*(short *)((long)param_2 + 6) != 0x30) goto LAB_00127772;
*param_2 = *param_2 + 1;
auVar10._8_8_ = 0xffffffffffffffff;
auVar10._0_8_ = param_2;
goto LAB_001277b1;
}
param_2 = piVar5;
} while (piVar5 != piVar4);
uVar6 = 1;
}
else {
JS_ThrowTypeError(param_1,"operand \'prototype\' property is not an object");
LAB_00127760:
uVar6 = 0xffffffff;
}
LAB_00127772:
if (0xfffffff6 < uVar8) {
uVar2 = *(int8 *)(param_1 + 0x18);
iVar3 = *piVar4;
*piVar4 = iVar3 + -1;
if (iVar3 < 2) {
js_free_value_rt(uVar2,piVar4,auVar9._8_8_);
}
}
return uVar6;
while( true ) {
if (uVar7 == 6) goto LAB_00127760;
if (piVar4 == piVar5) {
uVar6 = 1;
if (uVar7 < 0xfffffff7) goto LAB_00127772;
uVar2 = *(int8 *)(param_1 + 0x18);
iVar3 = *piVar4;
*piVar4 = iVar3 + -1;
piVar5 = piVar4;
goto joined_r0x00127841;
}
iVar3 = *(int *)(param_1 + 0x1d8);
*(int *)(param_1 + 0x1d8) = iVar3 + -1;
if ((iVar3 < 2) && (iVar3 = __js_poll_interrupts(param_1), iVar3 != 0)) break;
LAB_001277b1:
auVar10 = JS_GetPrototypeFree(param_1,auVar10._0_8_,auVar10._8_8_);
piVar5 = auVar10._0_8_;
uVar7 = auVar10._8_4_;
if (uVar7 == 2) goto LAB_00127772;
}
uVar6 = 0xffffffff;
if (0xfffffff6 < uVar7) {
uVar2 = *(int8 *)(param_1 + 0x18);
iVar3 = *piVar5;
*piVar5 = iVar3 + -1;
joined_r0x00127841:
if (iVar3 < 2) {
js_free_value_rt(uVar2,piVar5,auVar10._8_8_);
}
}
goto LAB_00127772;
}
| |
45,643 | mysql_net_store_length | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | unsigned char *mysql_net_store_length(unsigned char *packet, size_t length)
{
if (length < (unsigned long long) L64(251)) {
*packet = (unsigned char) length;
return packet + 1;
}
if (length < (unsigned long long) L64(65536)) {
*packet++ = 252;
int2store(packet,(uint) length);
return packet + 2;
}
if (length < (unsigned long long) L64(16777216)) {
*packet++ = 253;
int3store(packet,(ulong) length);
return packet + 3;
}
*packet++ = 254;
int8store(packet, length);
return packet + 8;
} | O0 | c | mysql_net_store_length:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0xfb, -0x18(%rbp)
jae 0x26743
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x26891
cmpq $0x10000, -0x18(%rbp) # imm = 0x10000
jae 0x26791
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $-0x4, (%rax)
movq -0x18(%rbp), %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x26891
cmpq $0x1000000, -0x18(%rbp) # imm = 0x1000000
jae 0x267ec
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $-0x3, (%rax)
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x18(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x10(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x8(%rbp)
jmp 0x26891
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $-0x2, (%rax)
movq -0x18(%rbp), %rax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
shrq $0x20, %rax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x20(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x20(%rbp), %eax
shrl $0x10, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x20(%rbp), %eax
shrl $0x18, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
jmp 0x2684a
movl -0x24(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x4(%rax)
movl -0x24(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x5(%rax)
movl -0x24(%rbp), %eax
shrl $0x10, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x6(%rax)
movl -0x24(%rbp), %eax
shrl $0x18, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x7(%rax)
jmp 0x26885
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
| mysql_net_store_length:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
cmp [rbp+var_18], 0FBh
jnb short loc_26743
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_8], rax
jmp loc_26891
loc_26743:
cmp [rbp+var_18], offset stru_10000
jnb short loc_26791
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov byte ptr [rax], 0FCh
mov rax, [rbp+var_18]
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
mov eax, [rbp+var_1C]
shr eax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax+1], cl
mov rax, [rbp+var_10]
add rax, 2
mov [rbp+var_8], rax
jmp loc_26891
loc_26791:
cmp [rbp+var_18], 1000000h
jnb short loc_267EC
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov byte ptr [rax], 0FDh
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
mov rax, [rbp+var_18]
shr rax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax+1], cl
mov rax, [rbp+var_18]
shr rax, 10h
mov cl, al
mov rax, [rbp+var_10]
mov [rax+2], cl
mov rax, [rbp+var_10]
add rax, 3
mov [rbp+var_8], rax
jmp loc_26891
loc_267EC:
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov byte ptr [rax], 0FEh
mov rax, [rbp+var_18]
mov [rbp+var_20], eax
mov rax, [rbp+var_18]
shr rax, 20h
mov [rbp+var_24], eax
mov eax, [rbp+var_20]
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
mov eax, [rbp+var_20]
shr eax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax+1], cl
mov eax, [rbp+var_20]
shr eax, 10h
mov cl, al
mov rax, [rbp+var_10]
mov [rax+2], cl
mov eax, [rbp+var_20]
shr eax, 18h
mov cl, al
mov rax, [rbp+var_10]
mov [rax+3], cl
jmp short $+2
loc_2684A:
mov eax, [rbp+var_24]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+4], cl
mov eax, [rbp+var_24]
shr eax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax+5], cl
mov eax, [rbp+var_24]
shr eax, 10h
mov cl, al
mov rax, [rbp+var_10]
mov [rax+6], cl
mov eax, [rbp+var_24]
shr eax, 18h
mov cl, al
mov rax, [rbp+var_10]
mov [rax+7], cl
jmp short $+2
loc_26885:
mov rax, [rbp+var_10]
add rax, 8
mov [rbp+var_8], rax
loc_26891:
mov rax, [rbp+var_8]
pop rbp
retn
| long long mysql_net_store_length(long long a1, unsigned long long a2)
{
_BYTE *v3; // [rsp+14h] [rbp-10h]
if ( a2 >= 0xFB )
{
if ( a2 >= (unsigned long long)&stru_10000 )
{
v3 = (_BYTE *)(a1 + 1);
if ( a2 >= 0x1000000 )
{
*(_BYTE *)a1 = -2;
*v3 = a2;
*(_WORD *)(a1 + 2) = (unsigned int)a2 >> 8;
*(_BYTE *)(a1 + 4) = BYTE3(a2);
*(_WORD *)(a1 + 5) = WORD2(a2);
*(_BYTE *)(a1 + 7) = BYTE6(a2);
*(_BYTE *)(a1 + 8) = HIBYTE(a2);
return a1 + 9;
}
else
{
*(_BYTE *)a1 = -3;
*(_WORD *)v3 = a2;
*(_BYTE *)(a1 + 3) = BYTE2(a2);
return a1 + 4;
}
}
else
{
*(_BYTE *)a1 = -4;
*(_WORD *)(a1 + 1) = a2;
return a1 + 3;
}
}
else
{
*(_BYTE *)a1 = a2;
return a1 + 1;
}
}
| mysql_net_store_length:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
CMP qword ptr [RBP + -0x18],0xfb
JNC 0x00126743
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00126891
LAB_00126743:
CMP qword ptr [RBP + -0x18],0x10000
JNC 0x00126791
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV byte ptr [RAX],0xfc
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x1c]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x2
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00126891
LAB_00126791:
CMP qword ptr [RBP + -0x18],0x1000000
JNC 0x001267ec
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV byte ptr [RAX],0xfd
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x3
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00126891
LAB_001267ec:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV byte ptr [RAX],0xfe
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x20],EAX
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x20
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x20]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x20]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x1],CL
MOV EAX,dword ptr [RBP + -0x20]
SHR EAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x2],CL
MOV EAX,dword ptr [RBP + -0x20]
SHR EAX,0x18
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x3],CL
JMP 0x0012684a
LAB_0012684a:
MOV EAX,dword ptr [RBP + -0x24]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x4],CL
MOV EAX,dword ptr [RBP + -0x24]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x5],CL
MOV EAX,dword ptr [RBP + -0x24]
SHR EAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x6],CL
MOV EAX,dword ptr [RBP + -0x24]
SHR EAX,0x18
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x7],CL
JMP 0x00126885
LAB_00126885:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x8
MOV qword ptr [RBP + -0x8],RAX
LAB_00126891:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
int1 * mysql_net_store_length(int1 *param_1,ulong param_2)
{
int1 uVar1;
int1 uVar2;
int1 uVar3;
int1 *local_10;
uVar1 = (int1)param_2;
if (param_2 < 0xfb) {
*param_1 = uVar1;
local_10 = param_1 + 1;
}
else {
uVar3 = (int1)(param_2 >> 8);
if (param_2 < 0x10000) {
*param_1 = 0xfc;
param_1[1] = uVar1;
param_1[2] = uVar3;
local_10 = param_1 + 3;
}
else {
uVar2 = (int1)(param_2 >> 0x10);
if (param_2 < 0x1000000) {
*param_1 = 0xfd;
param_1[1] = uVar1;
param_1[2] = uVar3;
param_1[3] = uVar2;
local_10 = param_1 + 4;
}
else {
*param_1 = 0xfe;
param_1[1] = uVar1;
param_1[2] = uVar3;
param_1[3] = uVar2;
param_1[4] = (char)(param_2 >> 0x18);
param_1[5] = (char)(param_2 >> 0x20);
param_1[6] = (char)(param_2 >> 0x28);
param_1[7] = (char)(param_2 >> 0x30);
param_1[8] = (char)(param_2 >> 0x38);
local_10 = param_1 + 9;
}
}
}
return local_10;
}
| |
45,644 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> aimrt::common::util::JoinVec<std::basic_string_view<char, std::char_traits<char>>>(std::vector<T, std::allocator<T>> const&, std::basic_string_view<char, std::char_traits<char>>) | aimrt_mujoco_sim/_deps/aimrt-src/src/common/util/../util/string_util.h | inline std::string JoinVec(const std::vector<StringType>& vec, std::string_view sep) {
std::string result;
for (auto itr = vec.begin(); itr != vec.end(); ++itr) {
if (itr != vec.begin()) result += sep;
result += *itr;
}
return result;
} | O0 | c | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> aimrt::common::util::JoinVec<std::basic_string_view<char, std::char_traits<char>>>(std::vector<T, std::allocator<T>> const&, std::basic_string_view<char, std::char_traits<char>>):
subq $0x68, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x60(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x58(%rsp)
movq %rsi, 0x48(%rsp)
movb $0x0, 0x47(%rsp)
callq 0x1c50a0
movq 0x48(%rsp), %rdi
callq 0x1ccd90
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rdi
callq 0x1d9710
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1df6d0
xorb $-0x1, %al
testb $0x1, %al
jne 0x5ebdc4
jmp 0x5ebe41
movq 0x48(%rsp), %rdi
callq 0x1ccd90
movq %rax, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1df6d0
xorb $-0x1, %al
testb $0x1, %al
jne 0x5ebdea
jmp 0x5ebe17
movq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x1d8100
jmp 0x5ebdfb
jmp 0x5ebe17
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x1e03b0
jmp 0x5ebe61
leaq 0x38(%rsp), %rdi
callq 0x1ddc40
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x1d8100
jmp 0x5ebe30
jmp 0x5ebe32
leaq 0x38(%rsp), %rdi
callq 0x1c4780
jmp 0x5ebd9e
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x5ebe57
movq 0x8(%rsp), %rdi
callq 0x1e03b0
movq 0x10(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x1d0790
nopl (%rax,%rax)
| _ZN5aimrt6common4util7JoinVecISt17basic_string_viewIcSt11char_traitsIcEEQoosr3stdE9is_same_vIT_S6_Esr3stdE9is_same_vIS7_NSt7__cxx1112basic_stringIcS5_SaIcEEEEEESB_RKSt6vectorIS7_SaIS7_EES6_:
sub rsp, 68h
mov [rsp+68h+var_60], rdi
mov rax, rdi
mov [rsp+68h+var_58], rax
mov [rsp+68h+var_8], rdi
mov [rsp+68h+var_18], rdx
mov [rsp+68h+var_10], rcx
mov [rsp+68h+var_20], rsi
mov [rsp+68h+var_21], 0
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2Ev; std::string::basic_string(void)
mov rdi, [rsp+68h+var_20]
call __ZNKSt6vectorISt17basic_string_viewIcSt11char_traitsIcEESaIS3_EE5beginEv; std::vector<std::string_view>::begin(void)
mov [rsp+68h+var_30], rax
loc_5EBD9E:
mov rdi, [rsp+68h+var_20]
call __ZNKSt6vectorISt17basic_string_viewIcSt11char_traitsIcEESaIS3_EE3endEv; std::vector<std::string_view>::end(void)
mov [rsp+68h+var_38], rax
lea rdi, [rsp+68h+var_30]
lea rsi, [rsp+68h+var_38]
call __ZN9__gnu_cxxeqIPKSt17basic_string_viewIcSt11char_traitsIcEESt6vectorIS4_SaIS4_EEEEbRKNS_17__normal_iteratorIT_T0_EESF_QrqXeqcldtfp_4baseEcldtfp0_4baseERSt14convertible_toIbEE
xor al, 0FFh
test al, 1
jnz short loc_5EBDC4
jmp short loc_5EBE41
loc_5EBDC4:
mov rdi, [rsp+68h+var_20]
call __ZNKSt6vectorISt17basic_string_viewIcSt11char_traitsIcEESaIS3_EE5beginEv; std::vector<std::string_view>::begin(void)
mov [rsp+68h+var_40], rax
lea rdi, [rsp+68h+var_30]
lea rsi, [rsp+68h+var_40]
call __ZN9__gnu_cxxeqIPKSt17basic_string_viewIcSt11char_traitsIcEESt6vectorIS4_SaIS4_EEEEbRKNS_17__normal_iteratorIT_T0_EESF_QrqXeqcldtfp_4baseEcldtfp0_4baseERSt14convertible_toIbEE
xor al, 0FFh
test al, 1
jnz short loc_5EBDEA
jmp short loc_5EBE17
loc_5EBDEA:
mov rdi, [rsp+68h+var_60]
lea rsi, [rsp+68h+var_18]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEpLISt17basic_string_viewIcS2_EEENSt9enable_ifIXsr6__and_ISt14is_convertibleIRKT_S7_ESt6__not_IS9_IPSB_PKS4_EESE_IS9_ISC_PKcEEEE5valueERS4_E4typeESC_
jmp short $+2
loc_5EBDFB:
jmp short loc_5EBE17
mov rdi, [rsp+arg_0]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_18], rcx
mov [rsp+arg_14], eax
call j__ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_5EBE61
loc_5EBE17:
lea rdi, [rsp+68h+var_30]
call __ZNK9__gnu_cxx17__normal_iteratorIPKSt17basic_string_viewIcSt11char_traitsIcEESt6vectorIS4_SaIS4_EEEdeEv; __gnu_cxx::__normal_iterator<std::string_view const*,std::vector<std::string_view>>::operator*(void)
mov rdi, [rsp+68h+var_60]
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEpLISt17basic_string_viewIcS2_EEENSt9enable_ifIXsr6__and_ISt14is_convertibleIRKT_S7_ESt6__not_IS9_IPSB_PKS4_EESE_IS9_ISC_PKcEEEE5valueERS4_E4typeESC_
jmp short $+2
loc_5EBE30:
jmp short $+2
loc_5EBE32:
lea rdi, [rsp+68h+var_30]
call __ZN9__gnu_cxx17__normal_iteratorIPKSt17basic_string_viewIcSt11char_traitsIcEESt6vectorIS4_SaIS4_EEEppEv; __gnu_cxx::__normal_iterator<std::string_view const*,std::vector<std::string_view>>::operator++(void)
jmp loc_5EBD9E
loc_5EBE41:
mov [rsp+68h+var_21], 1
test [rsp+68h+var_21], 1
jnz short loc_5EBE57
mov rdi, [rsp+68h+var_60]; void *
call j__ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_5EBE57:
mov rax, [rsp+68h+var_58]
add rsp, 68h
retn
loc_5EBE61:
mov rdi, [rsp+arg_18]
call __Unwind_Resume
| long long ZN5aimrt6common4util7JoinVecISt17basic_string_viewIcSt11char_traitsIcEEQoosr3stdE9is_same_vIT_S6_Esr3stdE9is_same_vIS7_NSt7__cxx1112basic_stringIcS5_SaIcEEEEEESB_RKSt6vectorIS7_SaIS7_EES6_(
long long a1,
long long a2,
long long a3,
long long a4)
{
long long v4; // rax
long long v6; // [rsp+28h] [rbp-40h] BYREF
long long v7; // [rsp+30h] [rbp-38h] BYREF
long long i; // [rsp+38h] [rbp-30h] BYREF
char v9; // [rsp+47h] [rbp-21h]
long long v10; // [rsp+48h] [rbp-20h]
_QWORD v11[3]; // [rsp+50h] [rbp-18h] BYREF
v11[2] = a1;
v11[0] = a3;
v11[1] = a4;
v10 = a2;
v9 = 0;
std::string::basic_string(a1);
for ( i = std::vector<std::string_view>::begin(a2);
;
__gnu_cxx::__normal_iterator<std::string_view const*,std::vector<std::string_view>>::operator++(&i) )
{
v7 = std::vector<std::string_view>::end(v10);
if ( (__gnu_cxx::operator==<std::string_view const*,std::vector<std::string_view>>(&i, &v7) & 1) != 0 )
break;
v6 = std::vector<std::string_view>::begin(v10);
if ( (__gnu_cxx::operator==<std::string_view const*,std::vector<std::string_view>>(&i, &v6) & 1) == 0 )
std::string::operator+=<std::string_view>(a1, v11);
v4 = __gnu_cxx::__normal_iterator<std::string_view const*,std::vector<std::string_view>>::operator*(&i);
std::string::operator+=<std::string_view>(a1, v4);
}
return a1;
}
| ~binder1:
PUSH RAX
MOV qword ptr [RSP],RDI
MOV RDI,qword ptr [RSP]
CALL 0x005e9790
POP RAX
RET
|
/* boost::asio::detail::binder1<boost::beast::basic_stream<boost::asio::ip::tcp,
boost::asio::any_io_executor, boost::beast::unlimited_rate_policy>::ops::transfer_op<false,
boost::beast::detail::buffers_ref<boost::beast::buffers_prefix_view<boost::beast::buffers_suffix<boost::beast::buffers_cat_view<boost::beast::detail::buffers_ref<boost::beast::buffers_cat_view<boost::asio::const_buffer,
boost::asio::const_buffer, boost::asio::const_buffer,
boost::beast::http::basic_fields<std::allocator<char> >::writer::field_range,
boost::beast::http::chunk_crlf> >, boost::beast::http::detail::chunk_size,
boost::asio::const_buffer, boost::beast::http::chunk_crlf, boost::asio::const_buffer,
boost::beast::http::chunk_crlf> > const&> >,
boost::beast::http::detail::write_some_op<boost::beast::http::detail::write_op<boost::beast::http::detail::write_msg_op<boost::asio::detail::awaitable_handler<boost::asio::any_io_executor,
boost::system::error_code, unsigned long>, boost::beast::basic_stream<boost::asio::ip::tcp,
boost::asio::any_io_executor, boost::beast::unlimited_rate_policy>, false,
boost::beast::http::empty_body, boost::beast::http::basic_fields<std::allocator<char> > >,
boost::beast::basic_stream<boost::asio::ip::tcp, boost::asio::any_io_executor,
boost::beast::unlimited_rate_policy>, boost::beast::http::detail::serializer_is_done, false,
boost::beast::http::empty_body, boost::beast::http::basic_fields<std::allocator<char> > >,
boost::beast::basic_stream<boost::asio::ip::tcp, boost::asio::any_io_executor,
boost::beast::unlimited_rate_policy>, false, boost::beast::http::empty_body,
boost::beast::http::basic_fields<std::allocator<char> > > >,
boost::system::error_code>::~binder1() */
binder1<boost::beast::basic_stream<boost::asio::ip::tcp,boost::asio::any_io_executor,boost::beast::unlimited_rate_policy>::ops::transfer_op<false,boost::beast::detail::buffers_ref<boost::beast::buffers_prefix_view<boost::beast::buffers_suffix<boost::beast::buffers_cat_view<boost::beast::detail::buffers_ref<boost::beast::buffers_cat_view<boost::asio::const_buffer,boost::asio::const_buffer,boost::asio::const_buffer,boost::beast::http::basic_fields<std::allocator<char>>::writer::field_range,boost::beast::http::chunk_crlf>>,boost::beast::http::detail::chunk_size,boost::asio::const_buffer,boost::beast::http::chunk_crlf,boost::asio::const_buffer,boost::beast::http::chunk_crlf>>const&>>,boost::beast::http::detail::write_some_op<boost::beast::http::detail::write_op<boost::beast::http::detail::write_msg_op<boost::asio::detail::awaitable_handler<boost::asio::any_io_executor,boost::system::error_code,unsigned_long>,boost::beast::basic_stream<boost::asio::ip::tcp,boost::asio::any_io_executor,boost::beast::unlimited_rate_policy>,false,boost::beast::http::empty_body,boost::beast::http::basic_fields<std::allocator<char>>>,boost::beast::basic_stream<boost::asio::ip::tcp,boost::asio::any_io_executor,boost::beast::unlimited_rate_policy>,boost::beast::http::detail::serializer_is_done,false,boost::beast::http::empty_body,boost::beast::http::basic_fields<std::allocator<char>>>,boost::beast::basic_stream<boost::asio::ip::tcp,boost::asio::any_io_executor,boost::beast::unlimited_rate_policy>,false,boost::beast::http::empty_body,boost::beast::http::basic_fields<std::allocator<char>>>>,boost::system::error_code>
* __thiscall
boost::asio::detail::
binder1<boost::beast::basic_stream<boost::asio::ip::tcp,boost::asio::any_io_executor,boost::beast::unlimited_rate_policy>::ops::transfer_op<false,boost::beast::detail::buffers_ref<boost::beast::buffers_prefix_view<boost::beast::buffers_suffix<boost::beast::buffers_cat_view<boost::beast::detail::buffers_ref<boost::beast::buffers_cat_view<boost::asio::const_buffer,boost::asio::const_buffer,boost::asio::const_buffer,boost::beast::http::basic_fields<std::allocator<char>>::writer::field_range,boost::beast::http::chunk_crlf>>,boost::beast::http::detail::chunk_size,boost::asio::const_buffer,boost::beast::http::chunk_crlf,boost::asio::const_buffer,boost::beast::http::chunk_crlf>>const&>>,boost::beast::http::detail::write_some_op<boost::beast::http::detail::write_op<boost::beast::http::detail::write_msg_op<boost::asio::detail::awaitable_handler<boost::asio::any_io_executor,boost::system::error_code,unsigned_long>,boost::beast::basic_stream<boost::asio::ip::tcp,boost::asio::any_io_executor,boost::beast::unlimited_rate_policy>,false,boost::beast::http::empty_body,boost::beast::http::basic_fields<std::allocator<char>>>,boost::beast::basic_stream<boost::asio::ip::tcp,boost::asio::any_io_executor,boost::beast::unlimited_rate_policy>,boost::beast::http::detail::serializer_is_done,false,boost::beast::http::empty_body,boost::beast::http::basic_fields<std::allocator<char>>>,boost::beast::basic_stream<boost::asio::ip::tcp,boost::asio::any_io_executor,boost::beast::unlimited_rate_policy>,false,boost::beast::http::empty_body,boost::beast::http::basic_fields<std::allocator<char>>>>,boost::system::error_code>
::~binder1(binder1<boost::beast::basic_stream<boost::asio::ip::tcp,boost::asio::any_io_executor,boost::beast::unlimited_rate_policy>::ops::transfer_op<false,boost::beast::detail::buffers_ref<boost::beast::buffers_prefix_view<boost::beast::buffers_suffix<boost::beast::buffers_cat_view<boost::beast::detail::buffers_ref<boost::beast::buffers_cat_view<boost::asio::const_buffer,boost::asio::const_buffer,boost::asio::const_buffer,boost::beast::http::basic_fields<std::allocator<char>>::writer::field_range,boost::beast::http::chunk_crlf>>,boost::beast::http::detail::chunk_size,boost::asio::const_buffer,boost::beast::http::chunk_crlf,boost::asio::const_buffer,boost::beast::http::chunk_crlf>>const&>>,boost::beast::http::detail::write_some_op<boost::beast::http::detail::write_op<boost::beast::http::detail::write_msg_op<boost::asio::detail::awaitable_handler<boost::asio::any_io_executor,boost::system::error_code,unsigned_long>,boost::beast::basic_stream<boost::asio::ip::tcp,boost::asio::any_io_executor,boost::beast::unlimited_rate_policy>,false,boost::beast::http::empty_body,boost::beast::http::basic_fields<std::allocator<char>>>,boost::beast::basic_stream<boost::asio::ip::tcp,boost::asio::any_io_executor,boost::beast::unlimited_rate_policy>,boost::beast::http::detail::serializer_is_done,false,boost::beast::http::empty_body,boost::beast::http::basic_fields<std::allocator<char>>>,boost::beast::basic_stream<boost::asio::ip::tcp,boost::asio::any_io_executor,boost::beast::unlimited_rate_policy>,false,boost::beast::http::empty_body,boost::beast::http::basic_fields<std::allocator<char>>>>,boost::system::error_code>
*this)
{
boost::beast::
basic_stream<boost::asio::ip::tcp,boost::asio::any_io_executor,boost::beast::unlimited_rate_policy>
::ops::
transfer_op<false,boost::beast::detail::buffers_ref<boost::beast::buffers_prefix_view<boost::beast::buffers_suffix<boost::beast::buffers_cat_view<boost::beast::detail::buffers_ref<boost::beast::buffers_cat_view<boost::asio::const_buffer,boost::asio::const_buffer,boost::asio::const_buffer,boost::beast::http::basic_fields<std::allocator<char>>::writer::field_range,boost::beast::http::chunk_crlf>>,boost::beast::http::detail::chunk_size,boost::asio::const_buffer,boost::beast::http::chunk_crlf,boost::asio::const_buffer,boost::beast::http::chunk_crlf>>const&>>,boost::beast::http::detail::write_some_op<boost::beast::http::detail::write_op<boost::beast::http::detail::write_msg_op<boost::asio::detail::awaitable_handler<boost::asio::any_io_executor,boost::system::error_code,unsigned_long>,boost::beast::basic_stream<boost::asio::ip::tcp,boost::asio::any_io_executor,boost::beast::unlimited_rate_policy>,false,boost::beast::http::empty_body,boost::beast::http::basic_fields<std::allocator<char>>>,boost::beast::basic_stream<boost::asio::ip::tcp,boost::asio::any_io_executor,boost::beast::unlimited_rate_policy>,boost::beast::http::detail::serializer_is_done,false,boost::beast::http::empty_body,boost::beast::http::basic_fields<std::allocator<char>>>,boost::beast::basic_stream<boost::asio::ip::tcp,boost::asio::any_io_executor,boost::beast::unlimited_rate_policy>,false,boost::beast::http::empty_body,boost::beast::http::basic_fields<std::allocator<char>>>>
::~transfer_op((transfer_op<false,boost::beast::detail::buffers_ref<boost::beast::buffers_prefix_view<boost::beast::buffers_suffix<boost::beast::buffers_cat_view<boost::beast::detail::buffers_ref<boost::beast::buffers_cat_view<boost::asio::const_buffer,boost::asio::const_buffer,boost::asio::const_buffer,boost::beast::http::basic_fields<std::allocator<char>>::writer::field_range,boost::beast::http::chunk_crlf>>,boost::beast::http::detail::chunk_size,boost::asio::const_buffer,boost::beast::http::chunk_crlf,boost::asio::const_buffer,boost::beast::http::chunk_crlf>>const&>>,boost::beast::http::detail::write_some_op<boost::beast::http::detail::write_op<boost::beast::http::detail::write_msg_op<boost::asio::detail::awaitable_handler<boost::asio::any_io_executor,boost::system::error_code,unsigned_long>,boost::beast::basic_stream<boost::asio::ip::tcp,boost::asio::any_io_executor,boost::beast::unlimited_rate_policy>,false,boost::beast::http::empty_body,boost::beast::http::basic_fields<std::allocator<char>>>,boost::beast::basic_stream<boost::asio::ip::tcp,boost::asio::any_io_executor,boost::beast::unlimited_rate_policy>,boost::beast::http::detail::serializer_is_done,false,boost::beast::http::empty_body,boost::beast::http::basic_fields<std::allocator<char>>>,boost::beast::basic_stream<boost::asio::ip::tcp,boost::asio::any_io_executor,boost::beast::unlimited_rate_policy>,false,boost::beast::http::empty_body,boost::beast::http::basic_fields<std::allocator<char>>>>
*)this);
return this;
}
| |
45,645 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> aimrt::common::util::JoinVec<std::basic_string_view<char, std::char_traits<char>>>(std::vector<T, std::allocator<T>> const&, std::basic_string_view<char, std::char_traits<char>>) | aimrt_mujoco_sim/_deps/aimrt-src/src/common/util/../util/string_util.h | inline std::string JoinVec(const std::vector<StringType>& vec, std::string_view sep) {
std::string result;
for (auto itr = vec.begin(); itr != vec.end(); ++itr) {
if (itr != vec.begin()) result += sep;
result += *itr;
}
return result;
} | O3 | c | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> aimrt::common::util::JoinVec<std::basic_string_view<char, std::char_traits<char>>>(std::vector<T, std::allocator<T>> const&, std::basic_string_view<char, std::char_traits<char>>):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %rbp
cmpq 0x8(%rsi), %rbp
je 0x1ec0c1
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
cmpq (%r12), %rbp
je 0x1ec0a6
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x90610
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
movq %rbx, %rdi
callq 0x94a60
addq $0x20, %rbp
cmpq 0x8(%r12), %rbp
jne 0x1ec092
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x1ec0ea
movq (%r13), %rsi
incq %rsi
callq 0x927a0
movq %r14, %rdi
callq 0x945e0
| _ZN5aimrt6common4util7JoinVecINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEQoosr3stdE9is_same_vIT_St17basic_string_viewIcS6_EEsr3stdE9is_same_vIS9_S8_EEES8_RKSt6vectorIS9_SaIS9_EESB_:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
lea r13, [rdi+10h]
mov [rdi], r13
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rbp, [rsi]
cmp rbp, [rsi+8]
jz short loc_1EC0C1
mov r14, rcx
mov r15, rdx
mov r12, rsi
loc_1EC092:
cmp rbp, [r12]
jz short loc_1EC0A6
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
loc_1EC0A6:
mov rsi, [rbp+0]
mov rdx, [rbp+8]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
add rbp, 20h ; ' '
cmp rbp, [r12+8]
jnz short loc_1EC092
loc_1EC0C1:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, r13
jz short loc_1EC0EA
mov rsi, [r13+0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1EC0EA:
mov rdi, r14
call __Unwind_Resume
| long long ZN5aimrt6common4util7JoinVecINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEQoosr3stdE9is_same_vIT_St17basic_string_viewIcS6_EEsr3stdE9is_same_vIS9_S8_EEES8_RKSt6vectorIS9_SaIS9_EESB_(
long long a1,
_QWORD *a2,
long long a3,
long long a4)
{
_QWORD *i; // rbp
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
for ( i = (_QWORD *)*a2; i != (_QWORD *)a2[1]; i += 4 )
{
if ( i != (_QWORD *)*a2 )
std::string::append(a1, a4, a3);
std::string::_M_append(a1, *i);
}
return a1;
}
| |||
45,646 | string_format[abi:cxx11](char const*, ...) | llama.cpp/common/common.cpp | std::string string_format(const char * fmt, ...) {
va_list ap;
va_list ap2;
va_start(ap, fmt);
va_copy(ap2, ap);
int size = vsnprintf(NULL, 0, fmt, ap);
GGML_ASSERT(size >= 0 && size < INT_MAX); // NOLINT
std::vector<char> buf(size + 1);
int size2 = vsnprintf(buf.data(), size + 1, fmt, ap2);
GGML_ASSERT(size2 == size);
va_end(ap2);
va_end(ap);
return std::string(buf.data(), size);
} | O3 | cpp | string_format[abi:cxx11](char const*, ...):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x60(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0xf69e6
movaps %xmm0, 0x90(%rsp)
movaps %xmm1, 0xa0(%rsp)
movaps %xmm2, 0xb0(%rsp)
movaps %xmm3, 0xc0(%rsp)
movaps %xmm4, 0xd0(%rsp)
movaps %xmm5, 0xe0(%rsp)
movaps %xmm6, 0xf0(%rsp)
movaps %xmm7, 0x100(%rsp)
movabsq $0x3000000010, %rax # imm = 0x3000000010
leaq 0x40(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x140(%rsp), %rax
movq %rax, 0x8(%rcx)
movq %rsi, 0x10(%rcx)
movq %rsi, 0x30(%rsp)
movq (%rcx), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rcx), %rax
movq %rax, 0x28(%rsp)
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x214c8
cmpl $0x7fffffff, %eax # imm = 0x7FFFFFFF
jae 0xf6aa6
movl %eax, %r15d
leal 0x1(%r15), %r12d
leaq 0x8(%rsp), %r13
leaq 0x7(%rsp), %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0xcedce
movq (%r13), %rdi
leaq 0x20(%rsp), %rcx
movq %r12, %rsi
movq %r14, %rdx
callq 0x214c8
cmpl %r15d, %eax
jne 0xf6ac7
movq 0x8(%rsp), %rsi
movl %r15d, %edx
leaq 0x7(%rsp), %rcx
movq %rbx, %rdi
callq 0x20e70
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xf6a92
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20180
movq %rbx, %rax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2d978(%rip), %rdi # 0x124425
leaq 0x1b759(%rip), %rdx # 0x11220d
leaq 0x2d9a7(%rip), %rcx # 0x124462
movl $0x188, %esi # imm = 0x188
xorl %eax, %eax
callq 0x20e60
leaq 0x2d957(%rip), %rdi # 0x124425
leaq 0x1b738(%rip), %rdx # 0x11220d
leaq 0x2d9a2(%rip), %rcx # 0x12447e
movl $0x18b, %esi # imm = 0x18B
xorl %eax, %eax
callq 0x20e60
jmp 0xf6aea
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xf6b04
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20180
movq %rbx, %rdi
callq 0x20ae0
| _Z13string_formatB5cxx11PKcz:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 110h
mov r14, rsi
mov rbx, rdi
lea rsi, [rsp+138h+var_D8]
mov [rsi+10h], rdx
mov [rsi+18h], rcx
mov [rsi+20h], r8
mov [rsi+28h], r9
test al, al
jz short loc_F69E6
movaps [rsp+138h+var_A8], xmm0
movaps [rsp+138h+var_98], xmm1
movaps [rsp+138h+var_88], xmm2
movaps [rsp+138h+var_78], xmm3
movaps [rsp+138h+var_68], xmm4
movaps [rsp+138h+var_58], xmm5
movaps [rsp+138h+var_48], xmm6
movaps [rsp+138h+var_38], xmm7
loc_F69E6:
mov rax, 3000000010h
lea rcx, [rsp+138h+var_F8]
mov [rcx], rax
lea rax, [rsp+138h+arg_0]
mov [rcx+8], rax
mov [rcx+10h], rsi
mov [rsp+138h+var_108], rsi
mov rax, [rcx]
mov [rsp+138h+var_118], rax
mov rax, [rcx+8]
mov [rsp+138h+var_110], rax
xor edi, edi
xor esi, esi
mov rdx, r14
call vsnprintf
cmp eax, 7FFFFFFFh
jnb short loc_F6AA6
mov r15d, eax
lea r12d, [r15+1]
lea r13, [rsp+138h+var_130]
lea rdx, [rsp+138h+var_131]
mov rdi, r13
mov rsi, r12
call _ZNSt6vectorIcSaIcEEC2EmRKS0_; std::vector<char>::vector(ulong,std::allocator<char> const&)
mov rdi, [r13+0]
lea rcx, [rsp+138h+var_118]
mov rsi, r12
mov rdx, r14
call vsnprintf
cmp eax, r15d
jnz short loc_F6AC7
mov rsi, [rsp+138h+var_130]
mov edx, r15d
lea rcx, [rsp+138h+var_131]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2EPKcmRKS3_; std::string::basic_string(char const*,ulong,std::allocator<char> const&)
mov rdi, [rsp+138h+var_130]; void *
test rdi, rdi
jz short loc_F6A92
mov rsi, [rsp+138h+var_120]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_F6A92:
mov rax, rbx
add rsp, 110h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_F6AA6:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aSize0SizeIntMa; "size >= 0 && size < INT_MAX"
mov esi, 188h
xor eax, eax
call _ggml_abort
loc_F6AC7:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aSize2Size; "size2 == size"
mov esi, 18Bh
xor eax, eax
call _ggml_abort
jmp short $+2
loc_F6AEA:
mov rbx, rax
mov rdi, [rsp+138h+var_130]; void *
test rdi, rdi
jz short loc_F6B04
mov rsi, [rsp+138h+var_120]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_F6B04:
mov rdi, rbx
call __Unwind_Resume
| long long string_format[abi:cxx11](
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
unsigned int v15; // eax
unsigned int v16; // r15d
signed long long v17; // r12
long long v19; // rax
long long v20; // rbx
char v21; // [rsp+7h] [rbp-131h] BYREF
void *v22; // [rsp+8h] [rbp-130h] BYREF
long long v23; // [rsp+18h] [rbp-120h]
_QWORD v24[4]; // [rsp+20h] [rbp-118h] BYREF
_QWORD v25[4]; // [rsp+40h] [rbp-F8h] BYREF
_BYTE v26[16]; // [rsp+60h] [rbp-D8h] BYREF
long long v27; // [rsp+70h] [rbp-C8h]
long long v28; // [rsp+78h] [rbp-C0h]
long long v29; // [rsp+80h] [rbp-B8h]
long long v30; // [rsp+88h] [rbp-B0h]
__m128 v31; // [rsp+90h] [rbp-A8h]
__m128 v32; // [rsp+A0h] [rbp-98h]
__m128 v33; // [rsp+B0h] [rbp-88h]
__m128 v34; // [rsp+C0h] [rbp-78h]
__m128 v35; // [rsp+D0h] [rbp-68h]
__m128 v36; // [rsp+E0h] [rbp-58h]
__m128 v37; // [rsp+F0h] [rbp-48h]
__m128 v38; // [rsp+100h] [rbp-38h]
v31 = a7;
v32 = a8;
v33 = a9;
v34 = a10;
v35 = a11;
v36 = a12;
v37 = a13;
v38 = a14;
v27 = a3;
v28 = a4;
v29 = a5;
v30 = a6;
v25[0] = 0x3000000010LL;
v25[1] = &a15;
v25[2] = v26;
v24[2] = v26;
v24[0] = 0x3000000010LL;
v24[1] = &a15;
v15 = vsnprintf(0LL, 0LL, a2, v25);
if ( v15 >= 0x7FFFFFFF )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/common.cpp",
392LL,
"GGML_ASSERT(%s) failed",
"size >= 0 && size < INT_MAX");
LABEL_7:
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/common.cpp",
395LL,
"GGML_ASSERT(%s) failed",
"size2 == size");
v20 = v19;
if ( v22 )
operator delete(v22, v23 - (_QWORD)v22);
_Unwind_Resume(v20);
}
v16 = v15;
v17 = v15 + 1;
std::vector<char>::vector(&v22, v17);
if ( (unsigned int)vsnprintf(v22, v17, a2, v24) != v16 )
goto LABEL_7;
std::string::basic_string(a1, v22, v16, &v21);
if ( v22 )
operator delete(v22, v23 - (_QWORD)v22);
return a1;
}
| string_format[abi:cxx11]:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x110
MOV R14,RSI
MOV RBX,RDI
LEA RSI,[RSP + 0x60]
MOV qword ptr [RSI + 0x10],RDX
MOV qword ptr [RSI + 0x18],RCX
MOV qword ptr [RSI + 0x20],R8
MOV qword ptr [RSI + 0x28],R9
TEST AL,AL
JZ 0x001f69e6
MOVAPS xmmword ptr [RSP + 0x90],XMM0
MOVAPS xmmword ptr [RSP + 0xa0],XMM1
MOVAPS xmmword ptr [RSP + 0xb0],XMM2
MOVAPS xmmword ptr [RSP + 0xc0],XMM3
MOVAPS xmmword ptr [RSP + 0xd0],XMM4
MOVAPS xmmword ptr [RSP + 0xe0],XMM5
MOVAPS xmmword ptr [RSP + 0xf0],XMM6
MOVAPS xmmword ptr [RSP + 0x100],XMM7
LAB_001f69e6:
MOV RAX,0x3000000010
LEA RCX,[RSP + 0x40]
MOV qword ptr [RCX],RAX
LEA RAX,[RSP + 0x140]
MOV qword ptr [RCX + 0x8],RAX
MOV qword ptr [RCX + 0x10],RSI
MOV qword ptr [RSP + 0x30],RSI
MOV RAX,qword ptr [RCX]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RCX + 0x8]
MOV qword ptr [RSP + 0x28],RAX
XOR EDI,EDI
XOR ESI,ESI
MOV RDX,R14
CALL 0x001214c8
CMP EAX,0x7fffffff
JNC 0x001f6aa6
MOV R15D,EAX
LEA R12D,[R15 + 0x1]
LEA R13,[RSP + 0x8]
LEA RDX,[RSP + 0x7]
MOV RDI,R13
MOV RSI,R12
CALL 0x001cedce
MOV RDI,qword ptr [R13]
LEA RCX,[RSP + 0x20]
MOV RSI,R12
MOV RDX,R14
CALL 0x001214c8
CMP EAX,R15D
JNZ 0x001f6ac7
MOV RSI,qword ptr [RSP + 0x8]
MOV EDX,R15D
LAB_001f6a6e:
LEA RCX,[RSP + 0x7]
MOV RDI,RBX
CALL 0x00120e70
LAB_001f6a7b:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x001f6a92
MOV RSI,qword ptr [RSP + 0x18]
SUB RSI,RDI
CALL 0x00120180
LAB_001f6a92:
MOV RAX,RBX
ADD RSP,0x110
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_001f6aa6:
LEA RDI,[0x224425]
LEA RDX,[0x21220d]
LEA RCX,[0x224462]
MOV ESI,0x188
XOR EAX,EAX
CALL 0x00120e60
LAB_001f6ac7:
LEA RDI,[0x224425]
LEA RDX,[0x21220d]
LEA RCX,[0x22447e]
MOV ESI,0x18b
XOR EAX,EAX
CALL 0x00120e60
|
/* string_format[abi:cxx11](char const*, ...) */
char * string_format_abi_cxx11_(char *param_1,...)
{
char in_AL;
uint uVar1;
uint uVar2;
int8 in_RCX;
int8 in_RDX;
char *in_RSI;
int8 in_R8;
int8 in_R9;
int8 in_XMM0_Qa;
int8 in_XMM1_Qa;
int8 in_XMM2_Qa;
int8 in_XMM3_Qa;
int8 in_XMM4_Qa;
int8 in_XMM5_Qa;
int8 in_XMM6_Qa;
int8 in_XMM7_Qa;
allocator local_131;
char *local_130 [2];
long local_120;
int8 local_118;
int1 *local_110;
int1 *local_108;
int8 local_f8;
int1 *local_f0;
int1 *local_e8;
int1 local_d8 [16];
int8 local_c8;
int8 local_c0;
int8 local_b8;
int8 local_b0;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int8 local_38;
local_108 = local_d8;
if (in_AL != '\0') {
local_a8 = in_XMM0_Qa;
local_98 = in_XMM1_Qa;
local_88 = in_XMM2_Qa;
local_78 = in_XMM3_Qa;
local_68 = in_XMM4_Qa;
local_58 = in_XMM5_Qa;
local_48 = in_XMM6_Qa;
local_38 = in_XMM7_Qa;
}
local_f8 = 0x3000000010;
local_110 = &stack0x00000008;
local_118 = 0x3000000010;
local_f0 = local_110;
local_e8 = local_108;
local_c8 = in_RDX;
local_c0 = in_RCX;
local_b8 = in_R8;
local_b0 = in_R9;
uVar1 = vsnprintf((char *)0x0,0,in_RSI,&local_f8);
if (uVar1 < 0x7fffffff) {
std::vector<char,std::allocator<char>>::vector((ulong)local_130,(allocator *)(ulong)(uVar1 + 1))
;
uVar2 = vsnprintf(local_130[0],(size_t)(ulong)(uVar1 + 1),in_RSI,&local_118);
if (uVar2 == uVar1) {
/* try { // try from 001f6a6e to 001f6a7a has its CatchHandler @ 001f6ae8 */
std::__cxx11::string::string((string *)param_1,local_130[0],(ulong)uVar1,&local_131);
if (local_130[0] != (char *)0x0) {
operator_delete(local_130[0],local_120 - (long)local_130[0]);
}
return param_1;
}
/* try { // try from 001f6ac7 to 001f6ae7 has its CatchHandler @ 001f6aea */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/common.cpp",0x18b,
"GGML_ASSERT(%s) failed","size2 == size");
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/common.cpp",0x188,
"GGML_ASSERT(%s) failed","size >= 0 && size < INT_MAX");
}
| |
45,647 | insert_at | eloqsql/mysys/queues.c | static void insert_at(QUEUE *queue, uchar *element, uint idx)
{
uint next_index, offset_to_key= queue->offset_to_key;
uint offset_to_queue_pos= queue->offset_to_queue_pos;
/* max_at_top swaps the comparison if we want to order by desc */
while ((next_index= idx >> 1) > 0 &&
queue->compare(queue->first_cmp_arg,
element + offset_to_key,
queue->root[next_index] + offset_to_key) *
queue->max_at_top < 0)
{
queue->root[idx]= queue->root[next_index];
if (offset_to_queue_pos)
(*(uint*) (queue->root[idx] + offset_to_queue_pos-1))= idx;
idx= next_index;
}
queue->root[idx]= element;
if (offset_to_queue_pos)
(*(uint*) (element + offset_to_queue_pos-1))= idx;
} | O0 | c | insert_at:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
shrl %ecx
movl %ecx, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
jbe 0x8e80a
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %ecx
addq %rcx, %rsi
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl -0x18(%rbp), %edx
movq (%rcx,%rdx,8), %rdx
movl -0x1c(%rbp), %ecx
addq %rcx, %rdx
callq *%rax
movq -0x8(%rbp), %rcx
imull 0x24(%rcx), %eax
cmpl $0x0, %eax
setl %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x8e813
jmp 0x8e858
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x18(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
cmpl $0x0, -0x20(%rbp)
je 0x8e84d
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x20(%rbp), %ecx
movl %edx, -0x1(%rax,%rcx)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x8e7b7
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
cmpl $0x0, -0x20(%rbp)
je 0x8e87e
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %edx, -0x1(%rax,%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| insert_at:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov rax, [rbp+var_8]
mov eax, [rax+18h]
mov [rbp+var_1C], eax
mov rax, [rbp+var_8]
mov eax, [rax+1Ch]
mov [rbp+var_20], eax
loc_8E7B7:
mov ecx, [rbp+var_14]
shr ecx, 1
mov [rbp+var_18], ecx
xor eax, eax
cmp ecx, 0
mov [rbp+var_21], al
jbe short loc_8E80A
mov rax, [rbp+var_8]
mov rax, [rax+28h]
mov rcx, [rbp+var_8]
mov rdi, [rcx+8]
mov rsi, [rbp+var_10]
mov ecx, [rbp+var_1C]
add rsi, rcx
mov rcx, [rbp+var_8]
mov rcx, [rcx]
mov edx, [rbp+var_18]
mov rdx, [rcx+rdx*8]
mov ecx, [rbp+var_1C]
add rdx, rcx
call rax
mov rcx, [rbp+var_8]
imul eax, [rcx+24h]
cmp eax, 0
setl al
mov [rbp+var_21], al
loc_8E80A:
mov al, [rbp+var_21]
test al, 1
jnz short loc_8E813
jmp short loc_8E858
loc_8E813:
mov rax, [rbp+var_8]
mov rax, [rax]
mov ecx, [rbp+var_18]
mov rdx, [rax+rcx*8]
mov rax, [rbp+var_8]
mov rax, [rax]
mov ecx, [rbp+var_14]
mov [rax+rcx*8], rdx
cmp [rbp+var_20], 0
jz short loc_8E84D
mov edx, [rbp+var_14]
mov rax, [rbp+var_8]
mov rax, [rax]
mov ecx, [rbp+var_14]
mov rax, [rax+rcx*8]
mov ecx, [rbp+var_20]
mov [rax+rcx-1], edx
loc_8E84D:
mov eax, [rbp+var_18]
mov [rbp+var_14], eax
jmp loc_8E7B7
loc_8E858:
mov rdx, [rbp+var_10]
mov rax, [rbp+var_8]
mov rax, [rax]
mov ecx, [rbp+var_14]
mov [rax+rcx*8], rdx
cmp [rbp+var_20], 0
jz short loc_8E87E
mov edx, [rbp+var_14]
mov rax, [rbp+var_10]
mov ecx, [rbp+var_20]
mov [rax+rcx-1], edx
loc_8E87E:
add rsp, 30h
pop rbp
retn
| long long insert_at(long long *a1, long long a2, unsigned int a3)
{
long long result; // rax
bool v4; // [rsp+Fh] [rbp-21h]
unsigned int v5; // [rsp+10h] [rbp-20h]
unsigned int v6; // [rsp+14h] [rbp-1Ch]
unsigned int v7; // [rsp+18h] [rbp-18h]
v6 = *((_DWORD *)a1 + 6);
v5 = *((_DWORD *)a1 + 7);
while ( 1 )
{
v7 = a3 >> 1;
v4 = 0;
if ( a3 >> 1 )
v4 = (int)(*((_DWORD *)a1 + 9)
* ((long long ( *)(long long, long long, _QWORD))a1[5])(
a1[1],
v6 + a2,
v6 + *(_QWORD *)(*a1 + 8LL * v7))) < 0;
if ( !v4 )
break;
*(_QWORD *)(*a1 + 8LL * a3) = *(_QWORD *)(*a1 + 8LL * v7);
if ( v5 )
*(_DWORD *)(*(_QWORD *)(*a1 + 8LL * a3) + v5 - 1LL) = a3;
a3 >>= 1;
}
result = *a1;
*(_QWORD *)(*a1 + 8LL * a3) = a2;
if ( v5 )
{
result = a2;
*(_DWORD *)(a2 + v5 - 1) = a3;
}
return result;
}
| insert_at:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x18]
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x1c]
MOV dword ptr [RBP + -0x20],EAX
LAB_0018e7b7:
MOV ECX,dword ptr [RBP + -0x14]
SHR ECX,0x1
MOV dword ptr [RBP + -0x18],ECX
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x21],AL
JBE 0x0018e80a
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x28]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RCX + 0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x1c]
ADD RSI,RCX
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX]
MOV EDX,dword ptr [RBP + -0x18]
MOV RDX,qword ptr [RCX + RDX*0x8]
MOV ECX,dword ptr [RBP + -0x1c]
ADD RDX,RCX
CALL RAX
MOV RCX,qword ptr [RBP + -0x8]
IMUL EAX,dword ptr [RCX + 0x24]
CMP EAX,0x0
SETL AL
MOV byte ptr [RBP + -0x21],AL
LAB_0018e80a:
MOV AL,byte ptr [RBP + -0x21]
TEST AL,0x1
JNZ 0x0018e813
JMP 0x0018e858
LAB_0018e813:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x18]
MOV RDX,qword ptr [RAX + RCX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x14]
MOV qword ptr [RAX + RCX*0x8],RDX
CMP dword ptr [RBP + -0x20],0x0
JZ 0x0018e84d
MOV EDX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV ECX,dword ptr [RBP + -0x20]
MOV dword ptr [RAX + RCX*0x1 + -0x1],EDX
LAB_0018e84d:
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0018e7b7
LAB_0018e858:
MOV RDX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x14]
MOV qword ptr [RAX + RCX*0x8],RDX
CMP dword ptr [RBP + -0x20],0x0
JZ 0x0018e87e
MOV EDX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x20]
MOV dword ptr [RAX + RCX*0x1 + -0x1],EDX
LAB_0018e87e:
ADD RSP,0x30
POP RBP
RET
|
void insert_at(long *param_1,long param_2,uint param_3)
{
uint uVar1;
uint uVar2;
int iVar3;
uint uVar4;
bool bVar5;
uint local_1c;
uVar1 = *(uint *)(param_1 + 3);
uVar2 = *(uint *)((long)param_1 + 0x1c);
uVar4 = param_3;
while( true ) {
local_1c = uVar4;
uVar4 = local_1c >> 1;
bVar5 = false;
if (uVar4 != 0) {
iVar3 = (*(code *)param_1[5])
(param_1[1],param_2 + (ulong)uVar1,
*(long *)(*param_1 + (ulong)uVar4 * 8) + (ulong)uVar1);
bVar5 = iVar3 * *(int *)((long)param_1 + 0x24) < 0;
}
if (!bVar5) break;
*(int8 *)(*param_1 + (ulong)local_1c * 8) = *(int8 *)(*param_1 + (ulong)uVar4 * 8);
if (uVar2 != 0) {
*(uint *)(*(long *)(*param_1 + (ulong)local_1c * 8) + -1 + (ulong)uVar2) = local_1c;
}
}
*(long *)(*param_1 + (ulong)local_1c * 8) = param_2;
if (uVar2 != 0) {
*(uint *)(param_2 + -1 + (ulong)uVar2) = local_1c;
}
return;
}
| |
45,648 | insert_at | eloqsql/mysys/queues.c | static void insert_at(QUEUE *queue, uchar *element, uint idx)
{
uint next_index, offset_to_key= queue->offset_to_key;
uint offset_to_queue_pos= queue->offset_to_queue_pos;
/* max_at_top swaps the comparison if we want to order by desc */
while ((next_index= idx >> 1) > 0 &&
queue->compare(queue->first_cmp_arg,
element + offset_to_key,
queue->root[next_index] + offset_to_key) *
queue->max_at_top < 0)
{
queue->root[idx]= queue->root[next_index];
if (offset_to_queue_pos)
(*(uint*) (queue->root[idx] + offset_to_queue_pos-1))= idx;
idx= next_index;
}
queue->root[idx]= element;
if (offset_to_queue_pos)
(*(uint*) (element + offset_to_queue_pos-1))= idx;
} | O3 | c | insert_at:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r15d
movq %rdi, %r14
movl 0x1c(%rdi), %r13d
cmpl $0x2, %edx
movq %rsi, -0x30(%rbp)
jae 0x62b4f
movl %r15d, %ebx
jmp 0x62ba7
movl 0x18(%r14), %r12d
leaq (%rsi,%r12), %rax
movq %rax, -0x38(%rbp)
movl %r15d, %ebx
shrl %ebx
movq (%r14), %rax
movq 0x8(%r14), %rdi
movq (%rax,%rbx,8), %rdx
addq %r12, %rdx
movq -0x38(%rbp), %rsi
callq *0x28(%r14)
imull 0x24(%r14), %eax
testl %eax, %eax
jns 0x62b4a
movq (%r14), %rcx
movq (%rcx,%rbx,8), %rdx
movl %r15d, %eax
movq %rdx, (%rcx,%rax,8)
testq %r13, %r13
je 0x62b9e
movq (%r14), %rcx
movq (%rcx,%rax,8), %rax
movl %r15d, -0x1(%rax,%r13)
cmpl $0x3, %r15d
movl %ebx, %r15d
ja 0x62b5e
movq (%r14), %rax
movl %ebx, %ecx
movq -0x30(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
testq %r13, %r13
je 0x62bbe
movl %ebx, -0x1(%rdx,%r13)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| insert_at:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15d, edx
mov r14, rdi
mov r13d, [rdi+1Ch]
cmp edx, 2
mov [rbp+var_30], rsi
jnb short loc_62B4F
loc_62B4A:
mov ebx, r15d
jmp short loc_62BA7
loc_62B4F:
mov r12d, [r14+18h]
lea rax, [rsi+r12]
mov [rbp+var_38], rax
mov ebx, r15d
loc_62B5E:
shr ebx, 1
mov rax, [r14]
mov rdi, [r14+8]
mov rdx, [rax+rbx*8]
add rdx, r12
mov rsi, [rbp+var_38]
call qword ptr [r14+28h]
imul eax, [r14+24h]
test eax, eax
jns short loc_62B4A
mov rcx, [r14]
mov rdx, [rcx+rbx*8]
mov eax, r15d
mov [rcx+rax*8], rdx
test r13, r13
jz short loc_62B9E
mov rcx, [r14]
mov rax, [rcx+rax*8]
mov [rax+r13-1], r15d
loc_62B9E:
cmp r15d, 3
mov r15d, ebx
ja short loc_62B5E
loc_62BA7:
mov rax, [r14]
mov ecx, ebx
mov rdx, [rbp+var_30]
mov [rax+rcx*8], rdx
test r13, r13
jz short loc_62BBE
mov [rdx+r13-1], ebx
loc_62BBE:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long insert_at(long long *a1, long long a2, unsigned int a3)
{
unsigned int v3; // r15d
long long v4; // r13
long long v5; // rbx
long long v6; // r12
bool v7; // cc
long long result; // rax
v3 = a3;
v4 = *((unsigned int *)a1 + 7);
if ( a3 >= 2 )
{
v6 = *((unsigned int *)a1 + 6);
LODWORD(v5) = a3;
while ( 1 )
{
v5 = (unsigned int)v5 >> 1;
if ( (int)(*((_DWORD *)a1 + 9)
* ((long long ( *)(long long, long long, long long))a1[5])(
a1[1],
a2 + v6,
v6 + *(_QWORD *)(*a1 + 8 * v5))) >= 0 )
break;
*(_QWORD *)(*a1 + 8LL * v3) = *(_QWORD *)(*a1 + 8 * v5);
if ( v4 )
*(_DWORD *)(*(_QWORD *)(*a1 + 8LL * v3) + v4 - 1) = v3;
v7 = v3 <= 3;
v3 = v5;
if ( v7 )
goto LABEL_8;
}
}
LODWORD(v5) = v3;
LABEL_8:
result = *a1;
*(_QWORD *)(*a1 + 8LL * (unsigned int)v5) = a2;
if ( v4 )
*(_DWORD *)(a2 + v4 - 1) = v5;
return result;
}
| insert_at:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15D,EDX
MOV R14,RDI
MOV R13D,dword ptr [RDI + 0x1c]
CMP EDX,0x2
MOV qword ptr [RBP + -0x30],RSI
JNC 0x00162b4f
LAB_00162b4a:
MOV EBX,R15D
JMP 0x00162ba7
LAB_00162b4f:
MOV R12D,dword ptr [R14 + 0x18]
LEA RAX,[RSI + R12*0x1]
MOV qword ptr [RBP + -0x38],RAX
MOV EBX,R15D
LAB_00162b5e:
SHR EBX,0x1
MOV RAX,qword ptr [R14]
MOV RDI,qword ptr [R14 + 0x8]
MOV RDX,qword ptr [RAX + RBX*0x8]
ADD RDX,R12
MOV RSI,qword ptr [RBP + -0x38]
CALL qword ptr [R14 + 0x28]
IMUL EAX,dword ptr [R14 + 0x24]
TEST EAX,EAX
JNS 0x00162b4a
MOV RCX,qword ptr [R14]
MOV RDX,qword ptr [RCX + RBX*0x8]
MOV EAX,R15D
MOV qword ptr [RCX + RAX*0x8],RDX
TEST R13,R13
JZ 0x00162b9e
MOV RCX,qword ptr [R14]
MOV RAX,qword ptr [RCX + RAX*0x8]
MOV dword ptr [RAX + R13*0x1 + -0x1],R15D
LAB_00162b9e:
CMP R15D,0x3
MOV R15D,EBX
JA 0x00162b5e
LAB_00162ba7:
MOV RAX,qword ptr [R14]
MOV ECX,EBX
MOV RDX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + RCX*0x8],RDX
TEST R13,R13
JZ 0x00162bbe
MOV dword ptr [RDX + R13*0x1 + -0x1],EBX
LAB_00162bbe:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void insert_at(long *param_1,long param_2,uint param_3)
{
uint uVar1;
ulong uVar2;
int iVar3;
ulong uVar4;
ulong uVar5;
uint uVar6;
uVar4 = (ulong)param_3;
uVar5 = (ulong)*(uint *)((long)param_1 + 0x1c);
if (1 < param_3) {
uVar1 = *(uint *)(param_1 + 3);
do {
uVar2 = uVar4 >> 1;
iVar3 = (*(code *)param_1[5])
(param_1[1],param_2 + (ulong)uVar1,
*(long *)(*param_1 + uVar2 * 8) + (ulong)uVar1);
if (-1 < iVar3 * *(int *)((long)param_1 + 0x24)) break;
uVar6 = (uint)uVar4;
*(int8 *)(*param_1 + uVar4 * 8) = *(int8 *)(*param_1 + uVar2 * 8);
if (uVar5 != 0) {
*(uint *)(*(long *)(*param_1 + uVar4 * 8) + -1 + uVar5) = uVar6;
}
uVar4 = uVar2;
} while (3 < uVar6);
}
*(long *)(*param_1 + uVar4 * 8) = param_2;
if (uVar5 != 0) {
*(int *)(param_2 + -1 + uVar5) = (int)uVar4;
}
return;
}
| |
45,649 | ok | eloqsql/unittest/mytap/tap.c | void
ok(int pass, char const *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
if (!pass && *g_test.todo == '\0')
++g_test.failed;
vemit_tap(pass, fmt, ap);
va_end(ap);
if (*g_test.todo != '\0')
emit_dir("todo", g_test.todo);
emit_endl();
} | O0 | c | ok:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0xd9e18
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
cmpl $0x0, -0x4(%rbp)
jne 0xd9e80
movsbl 0xba08d0(%rip), %eax # 0xc7a73c
cmpl $0x0, %eax
jne 0xd9e80
movl 0xba08c1(%rip), %eax # 0xc7a738
addl $0x1, %eax
movl %eax, 0xba08b8(%rip) # 0xc7a738
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xd9ed0
leaq -0x30(%rbp), %rax
movsbl 0xba08a1(%rip), %eax # 0xc7a73c
cmpl $0x0, %eax
je 0xd9eb7
leaq 0x79d20(%rip), %rdi # 0x153bc7
leaq 0xba0882(%rip), %rsi # 0xc7a730
addq $0xc, %rsi
callq 0xd9fb0
callq 0xda410
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ok:
push rbp
mov rbp, rsp
sub rsp, 0E0h
test al, al
jz short loc_D9E18
movaps [rbp+var_B0], xmm0
movaps [rbp+var_A0], xmm1
movaps [rbp+var_90], xmm2
movaps [rbp+var_80], xmm3
movaps [rbp+var_70], xmm4
movaps [rbp+var_60], xmm5
movaps [rbp+var_50], xmm6
movaps [rbp+var_40], xmm7
loc_D9E18:
mov [rbp+var_B8], r9
mov [rbp+var_C0], r8
mov [rbp+var_C8], rcx
mov [rbp+var_D0], rdx
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
lea rax, [rbp+var_30]
lea rcx, [rbp+var_E0]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 10h
cmp [rbp+var_4], 0
jnz short loc_D9E80
movsx eax, cs:byte_C7A73C
cmp eax, 0
jnz short loc_D9E80
mov eax, cs:dword_C7A738
add eax, 1
mov cs:dword_C7A738, eax
loc_D9E80:
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
lea rdx, [rbp+var_30]
call vemit_tap
lea rax, [rbp+var_30]
movsx eax, cs:byte_C7A73C
cmp eax, 0
jz short loc_D9EB7
lea rdi, aTodo; "todo"
lea rsi, g_test
add rsi, 0Ch
call emit_dir
loc_D9EB7:
call emit_endl
add rsp, 0E0h
pop rbp
retn
| long long ok(unsigned int a1, long long a2, ...)
{
va_list va; // [rsp+B0h] [rbp-30h] BYREF
long long v4; // [rsp+D0h] [rbp-10h]
unsigned int v5; // [rsp+DCh] [rbp-4h]
va_start(va, a2);
v5 = a1;
v4 = a2;
if ( !a1 && !byte_C7A73C )
++dword_C7A738;
vemit_tap(v5, v4, va);
if ( byte_C7A73C )
emit_dir("todo", &g_test + 3);
return emit_endl();
}
| ok:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xe0
TEST AL,AL
JZ 0x001d9e18
MOVAPS xmmword ptr [RBP + -0xb0],XMM0
MOVAPS xmmword ptr [RBP + -0xa0],XMM1
MOVAPS xmmword ptr [RBP + -0x90],XMM2
MOVAPS xmmword ptr [RBP + -0x80],XMM3
MOVAPS xmmword ptr [RBP + -0x70],XMM4
MOVAPS xmmword ptr [RBP + -0x60],XMM5
MOVAPS xmmword ptr [RBP + -0x50],XMM6
MOVAPS xmmword ptr [RBP + -0x40],XMM7
LAB_001d9e18:
MOV qword ptr [RBP + -0xb8],R9
MOV qword ptr [RBP + -0xc0],R8
MOV qword ptr [RBP + -0xc8],RCX
MOV qword ptr [RBP + -0xd0],RDX
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
LEA RAX,[RBP + -0x30]
LEA RCX,[RBP + -0xe0]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x10
CMP dword ptr [RBP + -0x4],0x0
JNZ 0x001d9e80
MOVSX EAX,byte ptr [0x00d7a73c]
CMP EAX,0x0
JNZ 0x001d9e80
MOV EAX,dword ptr [0x00d7a738]
ADD EAX,0x1
MOV dword ptr [0x00d7a738],EAX
LAB_001d9e80:
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDX,[RBP + -0x30]
CALL 0x001d9ed0
LEA RAX,[RBP + -0x30]
MOVSX EAX,byte ptr [0x00d7a73c]
CMP EAX,0x0
JZ 0x001d9eb7
LEA RDI,[0x253bc7]
LEA RSI,[0xd7a730]
ADD RSI,0xc
CALL 0x001d9fb0
LAB_001d9eb7:
CALL 0x001da410
ADD RSP,0xe0
POP RBP
RET
|
void ok(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,int param_9,
int8 param_10,int8 param_11,int8 param_12,int8 param_13,
int8 param_14)
{
char in_AL;
int1 local_e8 [16];
int8 local_d8;
int8 local_d0;
int8 local_c8;
int8 local_c0;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int4 local_38;
int4 local_34;
int1 *local_30;
int1 *local_28;
int8 local_18;
int local_c;
if (in_AL != '\0') {
local_b8 = param_1;
local_a8 = param_2;
local_98 = param_3;
local_88 = param_4;
local_78 = param_5;
local_68 = param_6;
local_58 = param_7;
local_48 = param_8;
}
local_28 = local_e8;
local_30 = &stack0x00000008;
local_34 = 0x30;
local_38 = 0x10;
if ((param_9 == 0) && (DAT_00d7a73c == '\0')) {
DAT_00d7a738 = DAT_00d7a738 + 1;
}
local_d8 = param_11;
local_d0 = param_12;
local_c8 = param_13;
local_c0 = param_14;
local_18 = param_10;
local_c = param_9;
vemit_tap(param_9,param_10,&local_38);
if (DAT_00d7a73c != '\0') {
emit_dir(&DAT_00253bc7,&DAT_00d7a73c);
}
emit_endl();
return;
}
| |
45,650 | double minja::Value::get<double>() const | llama.cpp/common/minja/minja.hpp | T get() const {
if (is_primitive()) return primitive_.get<T>();
throw std::runtime_error("get<T> not defined for this value type: " + dump());
} | O3 | cpp | double minja::Value::get<double>() const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
jne 0xbda14
cmpq $0x0, 0x20(%r14)
jne 0xbda14
cmpq $0x0, 0x30(%r14)
jne 0xbda14
addq $0x40, %r14
leaq 0x20(%rsp), %rbx
movq $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbddc4
movsd (%rbx), %xmm0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x20610
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0xb4ad4
leaq 0x60c00(%rip), %rsi # 0x11e63a
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xae374
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x20440
xorl %ebp, %ebp
movq 0xa3560(%rip), %rsi # 0x160fc0
movq 0xa3519(%rip), %rdx # 0x160f80
movq %rbx, %rdi
callq 0x20a10
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbda8d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x20170
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbdaa8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x20170
testb %bpl, %bpl
jne 0xbdad2
jmp 0xbdada
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbdad2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x20170
jmp 0xbdad2
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e90
movq %r14, %rdi
callq 0x20ab0
| _ZNK5minja5Value3getIdEET_v:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rdi
cmp qword ptr [rdi+10h], 0
jnz short loc_BDA14
cmp qword ptr [r14+20h], 0
jnz short loc_BDA14
cmp qword ptr [r14+30h], 0
jnz short loc_BDA14
add r14, 40h ; '@'
lea rbx, [rsp+58h+var_38]
mov qword ptr [rbx], 0
mov rdi, r14
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEdTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
movsd xmm0, qword ptr [rbx]
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
loc_BDA14:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aGetTNotDefined; "get<T> not defined for this value type:"...
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BDA8D
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_BDA8D:
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BDAA8
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_BDAA8:
test bpl, bpl
jnz short loc_BDAD2
jmp short loc_BDADA
mov r14, rax
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BDAD2
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_BDAD2
mov r14, rax
loc_BDAD2:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_BDADA:
mov rdi, r14
call __Unwind_Resume
| double minja::Value::get<double>(_QWORD *a1)
{
void *exception; // rbx
_BYTE v3[16]; // [rsp+0h] [rbp-58h] BYREF
double v4[2]; // [rsp+20h] [rbp-38h] BYREF
if ( a1[2] || a1[4] || a1[6] )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v3, (long long)a1, 0xFFFFFFFF, 0);
std::operator+<char>(v4, (long long)"get<T> not defined for this value type: ", (long long)v3);
std::runtime_error::runtime_error(exception, v4);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v4[0] = 0.0;
ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEdTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_(
a1 + 8,
v4);
return v4[0];
}
| get<double>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
CMP qword ptr [RDI + 0x10],0x0
JNZ 0x001bda14
CMP qword ptr [R14 + 0x20],0x0
JNZ 0x001bda14
CMP qword ptr [R14 + 0x30],0x0
JNZ 0x001bda14
ADD R14,0x40
LEA RBX,[RSP + 0x20]
MOV qword ptr [RBX],0x0
MOV RDI,R14
MOV RSI,RBX
CALL 0x001bddc4
MOVSD XMM0,qword ptr [RBX]
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
LAB_001bda14:
MOV EDI,0x10
CALL 0x00120610
MOV RBX,RAX
LAB_001bda21:
MOV RDI,RSP
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001b4ad4
LAB_001bda33:
LEA RSI,[0x21e63a]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x001ae374
MOV BPL,0x1
LAB_001bda4a:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00120440
XOR EBP,EBP
MOV RSI,qword ptr [0x00260fc0]
MOV RDX,qword ptr [0x00260f80]
MOV RDI,RBX
CALL 0x00120a10
|
/* double minja::Value::get<double>() const */
double __thiscall minja::Value::get<double>(Value *this)
{
runtime_error *this_00;
int1 auStack_58 [32];
double local_38 [4];
if (((*(long *)(this + 0x10) == 0) && (*(long *)(this + 0x20) == 0)) &&
(*(long *)(this + 0x30) == 0)) {
local_38[0] = 0.0;
_ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEdTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
(this + 0x40,local_38);
return local_38[0];
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001bda21 to 001bda32 has its CatchHandler @ 001bdacf */
dump_abi_cxx11_((int)auStack_58,SUB81(this,0));
/* try { // try from 001bda33 to 001bda46 has its CatchHandler @ 001bdaaf */
std::operator+((char *)local_38,(string *)"get<T> not defined for this value type: ");
/* try { // try from 001bda4a to 001bda6e has its CatchHandler @ 001bda6f */
std::runtime_error::runtime_error(this_00,(string *)local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_00260fc0,PTR__runtime_error_00260f80);
}
| |
45,651 | 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++);
} | O0 | c | bitmap_subtract:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xee374
jmp 0xee376
jmp 0xee378
jmp 0xee37a
jmp 0xee37c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
ja 0xee3bb
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x20(%rbp)
movl (%rax), %ecx
xorl $-0x1, %ecx
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x18(%rbp)
andl (%rax), %ecx
movl %ecx, (%rax)
jmp 0xee388
popq %rbp
retq
nopl (%rax)
| bitmap_subtract:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_20], rax
jmp short $+2
loc_EE374:
jmp short $+2
loc_EE376:
jmp short $+2
loc_EE378:
jmp short $+2
loc_EE37A:
jmp short $+2
loc_EE37C:
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_28], rax
loc_EE388:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_28]
ja short loc_EE3BB
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 4
mov [rbp+var_20], rcx
mov ecx, [rax]
xor ecx, 0FFFFFFFFh
mov rax, [rbp+var_18]
mov rdx, rax
add rdx, 4
mov [rbp+var_18], rdx
and ecx, [rax]
mov [rax], ecx
jmp short loc_EE388
loc_EE3BB:
pop rbp
retn
| _DWORD * bitmap_subtract(_QWORD *a1, _QWORD *a2)
{
_DWORD *result; // rax
_DWORD *v3; // rax
int v4; // ecx
_DWORD *v5; // rax
unsigned long long v6; // [rsp+0h] [rbp-28h]
_DWORD *v7; // [rsp+8h] [rbp-20h]
_DWORD *v8; // [rsp+10h] [rbp-18h]
v8 = (_DWORD *)*a1;
v7 = (_DWORD *)*a2;
v6 = a1[1];
while ( 1 )
{
result = v8;
if ( (unsigned long long)v8 > v6 )
break;
v3 = v7++;
v4 = ~*v3;
v5 = v8++;
*v5 &= v4;
}
return result;
}
| bitmap_subtract:
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 qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001ee374
LAB_001ee374:
JMP 0x001ee376
LAB_001ee376:
JMP 0x001ee378
LAB_001ee378:
JMP 0x001ee37a
LAB_001ee37a:
JMP 0x001ee37c
LAB_001ee37c:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x28],RAX
LAB_001ee388:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x28]
JA 0x001ee3bb
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x20],RCX
MOV ECX,dword ptr [RAX]
XOR ECX,0xffffffff
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,RAX
ADD RDX,0x4
MOV qword ptr [RBP + -0x18],RDX
AND ECX,dword ptr [RAX]
MOV dword ptr [RAX],ECX
JMP 0x001ee388
LAB_001ee3bb:
POP RBP
RET
|
void bitmap_subtract(int8 *param_1,int8 *param_2)
{
uint *puVar1;
uint *local_28;
uint *local_20;
puVar1 = (uint *)param_1[1];
local_28 = (uint *)*param_2;
local_20 = (uint *)*param_1;
while (local_20 <= puVar1) {
*local_20 = (*local_28 ^ 0xffffffff) & *local_20;
local_28 = local_28 + 1;
local_20 = local_20 + 1;
}
return;
}
| |
45,652 | stbi__de_iphone(stbi__png*) | llama.cpp/examples/llava/../../common/stb_image.h | static void stbi__de_iphone(stbi__png *z)
{
stbi__context *s = z->s;
stbi__uint32 i, pixel_count = s->img_x * s->img_y;
stbi_uc *p = z->out;
if (s->img_out_n == 3) { // convert bgr to rgb
for (i=0; i < pixel_count; ++i) {
stbi_uc t = p[0];
p[0] = p[2];
p[2] = t;
p += 3;
}
} else {
STBI_ASSERT(s->img_out_n == 4);
if (stbi__unpremultiply_on_load) {
// convert bgr to rgb and unpremultiply
for (i=0; i < pixel_count; ++i) {
stbi_uc a = p[3];
stbi_uc t = p[0];
if (a) {
stbi_uc half = a / 2;
p[0] = (p[2] * 255 + half) / a;
p[1] = (p[1] * 255 + half) / a;
p[2] = ( t * 255 + half) / a;
} else {
p[0] = p[2];
p[2] = t;
}
p += 4;
}
} else {
// convert bgr to rgb
for (i=0; i < pixel_count; ++i) {
stbi_uc t = p[0];
p[0] = p[2];
p[2] = t;
p += 4;
}
}
}
} | O3 | c | stbi__de_iphone(stbi__png*):
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rdi), %ebp
imull (%rdi), %ebp
cmpl $0x3, 0xc(%rdi)
jne 0x3e9d4
testl %ebp, %ebp
je 0x3ea99
movb (%rbx), %al
movb 0x2(%rbx), %cl
movb %cl, (%rbx)
movb %al, 0x2(%rbx)
addq $0x3, %rbx
decl %ebp
jne 0x3e9bd
jmp 0x3ea99
movq %fs:0x0, %rax
cmpl $0x0, -0xc(%rax)
leaq -0x10(%rax), %rax
leaq 0x151977(%rip), %rcx # 0x19036c
cmovneq %rax, %rcx
cmpl $0x0, (%rcx)
je 0x3ea7a
testl %ebp, %ebp
je 0x3ea99
movl %ebp, %ecx
xorl %esi, %esi
movzbl 0x3(%rbx,%rsi,4), %edi
movb (%rbx,%rsi,4), %al
testl %edi, %edi
je 0x3ea66
movzbl %al, %r9d
movl %edi, %r8d
shrl %r8d
movzbl 0x2(%rbx,%rsi,4), %edx
movl %edx, %eax
shll $0x8, %eax
subl %edx, %eax
addl %r8d, %eax
xorl %edx, %edx
divw %di
movb %al, (%rbx,%rsi,4)
movzbl 0x1(%rbx,%rsi,4), %edx
movl %edx, %eax
shll $0x8, %eax
subl %edx, %eax
addl %r8d, %eax
xorl %edx, %edx
divw %di
movb %al, 0x1(%rbx,%rsi,4)
movl %r9d, %eax
shll $0x8, %eax
subl %r9d, %eax
addl %r8d, %eax
xorl %edx, %edx
divw %di
movb %al, 0x2(%rbx,%rsi,4)
jmp 0x3ea71
movb 0x2(%rbx,%rsi,4), %dl
movb %dl, (%rbx,%rsi,4)
movb %al, 0x2(%rbx,%rsi,4)
incq %rsi
cmpl %esi, %ecx
jne 0x3ea0a
jmp 0x3ea99
testl %ebp, %ebp
je 0x3ea99
movl %ebp, %eax
xorl %ecx, %ecx
movb (%rbx,%rcx,4), %dl
movb 0x2(%rbx,%rcx,4), %sil
movb %sil, (%rbx,%rcx,4)
movb %dl, 0x2(%rbx,%rcx,4)
incq %rcx
cmpl %ecx, %eax
jne 0x3ea82
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| _ZL15stbi__de_iphoneP9stbi__png:
push rbp
push rbx
push rax
mov rbx, rsi
mov ebp, [rdi+4]
imul ebp, [rdi]
cmp dword ptr [rdi+0Ch], 3
jnz short loc_3E9D4
test ebp, ebp
jz loc_3EA99
loc_3E9BD:
mov al, [rbx]
mov cl, [rbx+2]
mov [rbx], cl
mov [rbx+2], al
add rbx, 3
dec ebp
jnz short loc_3E9BD
jmp loc_3EA99
loc_3E9D4:
mov rax, fs:0
cmp dword ptr [rax-0Ch], 0
lea rax, [rax-10h]
lea rcx, _ZL34stbi__unpremultiply_on_load_global; stbi__unpremultiply_on_load_global
cmovnz rcx, rax
cmp dword ptr [rcx], 0
jz short loc_3EA7A
test ebp, ebp
jz loc_3EA99
mov ecx, ebp
xor esi, esi
loc_3EA0A:
movzx edi, byte ptr [rbx+rsi*4+3]
mov al, [rbx+rsi*4]
test edi, edi
jz short loc_3EA66
movzx r9d, al
mov r8d, edi
shr r8d, 1
movzx edx, byte ptr [rbx+rsi*4+2]
mov eax, edx
shl eax, 8
sub eax, edx
add eax, r8d
xor edx, edx
div di
mov [rbx+rsi*4], al
movzx edx, byte ptr [rbx+rsi*4+1]
mov eax, edx
shl eax, 8
sub eax, edx
add eax, r8d
xor edx, edx
div di
mov [rbx+rsi*4+1], al
mov eax, r9d
shl eax, 8
sub eax, r9d
add eax, r8d
xor edx, edx
div di
mov [rbx+rsi*4+2], al
jmp short loc_3EA71
loc_3EA66:
mov dl, [rbx+rsi*4+2]
mov [rbx+rsi*4], dl
mov [rbx+rsi*4+2], al
loc_3EA71:
inc rsi
cmp ecx, esi
jnz short loc_3EA0A
jmp short loc_3EA99
loc_3EA7A:
test ebp, ebp
jz short loc_3EA99
mov eax, ebp
xor ecx, ecx
loc_3EA82:
mov dl, [rbx+rcx*4]
mov sil, [rbx+rcx*4+2]
mov [rbx+rcx*4], sil
mov [rbx+rcx*4+2], dl
inc rcx
cmp eax, ecx
jnz short loc_3EA82
loc_3EA99:
add rsp, 8
pop rbx
pop rbp
retn
| char stbi__de_iphone(_DWORD *a1, _BYTE *a2)
{
int *v2; // rax
_BYTE *v3; // rbx
int v4; // ebp
unsigned long long v5; // rax
bool v6; // zf
int *v7; // rcx
long long v8; // rsi
unsigned int v9; // edi
long long v10; // rcx
char v11; // dl
v3 = a2;
v4 = *a1 * a1[1];
if ( a1[3] == 3 )
{
for ( ; v4; --v4 )
{
LOBYTE(v2) = *v3;
*v3 = v3[2];
v3[2] = (_BYTE)v2;
v3 += 3;
}
}
else
{
v5 = __readfsqword(0);
v6 = *(_DWORD *)(v5 - 12) == 0;
v2 = (int *)(v5 - 16);
v7 = &stbi__unpremultiply_on_load_global;
if ( !v6 )
v7 = v2;
if ( *v7 )
{
if ( v4 )
{
v8 = 0LL;
do
{
v9 = (unsigned __int8)v3[4 * v8 + 3];
LOBYTE(v2) = v3[4 * v8];
if ( v3[4 * v8 + 3] )
{
v3[4 * v8] = (unsigned __int16)((v9 >> 1) + 255 * (unsigned __int8)v3[4 * v8 + 2]) / (unsigned __int16)v9;
v3[4 * v8 + 1] = (unsigned __int16)((v9 >> 1) + 255 * (unsigned __int8)v3[4 * v8 + 1])
/ (unsigned __int16)v9;
LOWORD(v2) = (unsigned __int16)((v9 >> 1) + 255 * (unsigned __int8)v2) / (unsigned __int16)v9;
}
else
{
v3[4 * v8] = v3[4 * v8 + 2];
}
v3[4 * v8++ + 2] = (_BYTE)v2;
}
while ( v4 != (_DWORD)v8 );
}
}
else if ( v4 )
{
LODWORD(v2) = *a1 * a1[1];
v10 = 0LL;
do
{
v11 = a2[4 * v10];
a2[4 * v10] = a2[4 * v10 + 2];
a2[4 * v10++ + 2] = v11;
}
while ( v4 != (_DWORD)v10 );
}
}
return (char)v2;
}
| stbi__de_iphone:
PUSH RBP
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV EBP,dword ptr [RDI + 0x4]
IMUL EBP,dword ptr [RDI]
CMP dword ptr [RDI + 0xc],0x3
JNZ 0x0013e9d4
TEST EBP,EBP
JZ 0x0013ea99
LAB_0013e9bd:
MOV AL,byte ptr [RBX]
MOV CL,byte ptr [RBX + 0x2]
MOV byte ptr [RBX],CL
MOV byte ptr [RBX + 0x2],AL
ADD RBX,0x3
DEC EBP
JNZ 0x0013e9bd
JMP 0x0013ea99
LAB_0013e9d4:
MOV RAX,qword ptr FS:[0x0]
CMP dword ptr [RAX + -0xc],0x0
LEA RAX,[RAX + -0x10]
LEA RCX,[0x29036c]
CMOVNZ RCX,RAX
CMP dword ptr [RCX],0x0
JZ 0x0013ea7a
TEST EBP,EBP
JZ 0x0013ea99
MOV ECX,EBP
XOR ESI,ESI
LAB_0013ea0a:
MOVZX EDI,byte ptr [RBX + RSI*0x4 + 0x3]
MOV AL,byte ptr [RBX + RSI*0x4]
TEST EDI,EDI
JZ 0x0013ea66
MOVZX R9D,AL
MOV R8D,EDI
SHR R8D,0x1
MOVZX EDX,byte ptr [RBX + RSI*0x4 + 0x2]
MOV EAX,EDX
SHL EAX,0x8
SUB EAX,EDX
ADD EAX,R8D
XOR EDX,EDX
DIV DI
MOV byte ptr [RBX + RSI*0x4],AL
MOVZX EDX,byte ptr [RBX + RSI*0x4 + 0x1]
MOV EAX,EDX
SHL EAX,0x8
SUB EAX,EDX
ADD EAX,R8D
XOR EDX,EDX
DIV DI
MOV byte ptr [RBX + RSI*0x4 + 0x1],AL
MOV EAX,R9D
SHL EAX,0x8
SUB EAX,R9D
ADD EAX,R8D
XOR EDX,EDX
DIV DI
MOV byte ptr [RBX + RSI*0x4 + 0x2],AL
JMP 0x0013ea71
LAB_0013ea66:
MOV DL,byte ptr [RBX + RSI*0x4 + 0x2]
MOV byte ptr [RBX + RSI*0x4],DL
MOV byte ptr [RBX + RSI*0x4 + 0x2],AL
LAB_0013ea71:
INC RSI
CMP ECX,ESI
JNZ 0x0013ea0a
JMP 0x0013ea99
LAB_0013ea7a:
TEST EBP,EBP
JZ 0x0013ea99
MOV EAX,EBP
XOR ECX,ECX
LAB_0013ea82:
MOV DL,byte ptr [RBX + RCX*0x4]
MOV SIL,byte ptr [RBX + RCX*0x4 + 0x2]
MOV byte ptr [RBX + RCX*0x4],SIL
MOV byte ptr [RBX + RCX*0x4 + 0x2],DL
INC RCX
CMP EAX,ECX
JNZ 0x0013ea82
LAB_0013ea99:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
/* stbi__de_iphone(stbi__png*) */
void stbi__de_iphone(stbi__png *param_1)
{
int1 uVar1;
byte bVar2;
byte bVar3;
int *piVar4;
int iVar5;
int1 *in_RSI;
long lVar6;
ushort uVar7;
uint uVar8;
long *in_FS_OFFSET;
iVar5 = *(int *)(param_1 + 4) * *(int *)param_1;
if (*(int *)(param_1 + 0xc) == 3) {
for (; iVar5 != 0; iVar5 = iVar5 + -1) {
uVar1 = *in_RSI;
*in_RSI = in_RSI[2];
in_RSI[2] = uVar1;
in_RSI = in_RSI + 3;
}
}
else {
piVar4 = &stbi__unpremultiply_on_load_global;
if (*(int *)(*in_FS_OFFSET + -0xc) != 0) {
piVar4 = (int *)(*in_FS_OFFSET + -0x10);
}
if (*piVar4 == 0) {
if (iVar5 != 0) {
lVar6 = 0;
do {
uVar1 = in_RSI[lVar6 * 4];
in_RSI[lVar6 * 4] = in_RSI[lVar6 * 4 + 2];
in_RSI[lVar6 * 4 + 2] = uVar1;
lVar6 = lVar6 + 1;
} while (iVar5 != (int)lVar6);
}
}
else if (iVar5 != 0) {
lVar6 = 0;
do {
bVar3 = in_RSI[lVar6 * 4 + 3];
bVar2 = in_RSI[lVar6 * 4];
if (bVar3 == 0) {
in_RSI[lVar6 * 4] = in_RSI[lVar6 * 4 + 2];
in_RSI[lVar6 * 4 + 2] = bVar2;
}
else {
uVar8 = (uint)(bVar3 >> 1);
uVar7 = (ushort)bVar3;
in_RSI[lVar6 * 4] =
(char)((((uint)(byte)in_RSI[lVar6 * 4 + 2] * 0x100 -
(uint)(byte)in_RSI[lVar6 * 4 + 2]) + uVar8 & 0xffff) / (uint)uVar7);
in_RSI[lVar6 * 4 + 1] =
(char)((((uint)(byte)in_RSI[lVar6 * 4 + 1] * 0x100 -
(uint)(byte)in_RSI[lVar6 * 4 + 1]) + uVar8 & 0xffff) / (uint)uVar7);
in_RSI[lVar6 * 4 + 2] =
(char)((((uint)bVar2 * 0x100 - (uint)bVar2) + uVar8 & 0xffff) / (uint)uVar7);
}
lVar6 = lVar6 + 1;
} while (iVar5 != (int)lVar6);
}
}
return;
}
| |
45,653 | ma_reset_status | eloqsql/storage/maria/ma_delete_all.c | void _ma_reset_status(MARIA_HA *info)
{
MARIA_SHARE *share= info->s;
MARIA_STATE_INFO *state= &share->state;
uint i;
DBUG_ENTER("_ma_reset_status");
state->split= 0;
state->state.records= state->state.del= 0;
state->changed= 0; /* File is optimized */
state->dellink= HA_OFFSET_ERROR;
state->sortkey= (ushort) ~0;
state->state.key_file_length= share->base.keystart;
state->state.data_file_length= 0;
state->state.empty= state->state.key_empty= 0;
state->state.checksum= 0;
share->state.open_count= 0;
share->global_changed= 0;
share->changed= 1; /* We must write state */
*info->state= state->state;
/* Drop the delete key chain. */
state->key_del= HA_OFFSET_ERROR;
/* Clear all keys */
for (i=0 ; i < share->base.keys ; i++)
state->key_root[i]= HA_OFFSET_ERROR;
DBUG_VOID_RETURN;
} | O0 | c | ma_reset_status:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0xc0(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x170(%rax)
movq -0x18(%rbp), %rax
movq $-0x1, 0xc8(%rax)
movq -0x18(%rbp), %rax
movl $0xffff, 0x168(%rax) # imm = 0xFFFF
movq -0x10(%rbp), %rax
movq 0x360(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x48(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x16c(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x7df(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x7de(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
movl $0x38, %edx
callq 0x2a090
movq -0x18(%rbp), %rax
movq $-0x1, 0x120(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x3e8(%rcx), %eax
jae 0x768d7
movq -0x18(%rbp), %rax
movq 0x118(%rax), %rax
movl -0x1c(%rbp), %ecx
movq $-0x1, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x768a7
jmp 0x768d9
jmp 0x768db
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ma_reset_status:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov qword ptr [rax+0C0h], 0
mov rax, [rbp+var_18]
mov qword ptr [rax+20h], 0
mov rax, [rbp+var_18]
mov qword ptr [rax+18h], 0
mov rax, [rbp+var_18]
mov dword ptr [rax+170h], 0
mov rax, [rbp+var_18]
mov qword ptr [rax+0C8h], 0FFFFFFFFFFFFFFFFh
mov rax, [rbp+var_18]
mov dword ptr [rax+168h], 0FFFFh
mov rax, [rbp+var_10]
mov rcx, [rax+360h]
mov rax, [rbp+var_18]
mov [rax+38h], rcx
mov rax, [rbp+var_18]
mov qword ptr [rax+40h], 0
mov rax, [rbp+var_18]
mov qword ptr [rax+30h], 0
mov rax, [rbp+var_18]
mov qword ptr [rax+28h], 0
mov rax, [rbp+var_18]
mov dword ptr [rax+48h], 0
mov rax, [rbp+var_10]
mov dword ptr [rax+16Ch], 0
mov rax, [rbp+var_10]
mov byte ptr [rax+7DFh], 0
mov rax, [rbp+var_10]
mov byte ptr [rax+7DEh], 1
mov rax, [rbp+var_8]
mov rdi, [rax+20h]
mov rsi, [rbp+var_18]
add rsi, 18h
mov edx, 38h ; '8'
call _memcpy
mov rax, [rbp+var_18]
mov qword ptr [rax+120h], 0FFFFFFFFFFFFFFFFh
mov [rbp+var_1C], 0
loc_768A7:
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_10]
cmp eax, [rcx+3E8h]
jnb short loc_768D7
mov rax, [rbp+var_18]
mov rax, [rax+118h]
mov ecx, [rbp+var_1C]
mov qword ptr [rax+rcx*8], 0FFFFFFFFFFFFFFFFh
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
jmp short loc_768A7
loc_768D7:
jmp short $+2
loc_768D9:
jmp short $+2
loc_768DB:
add rsp, 20h
pop rbp
retn
| long long ma_reset_status(long long *a1)
{
long long result; // rax
unsigned int i; // [rsp+4h] [rbp-1Ch]
long long v3; // [rsp+10h] [rbp-10h]
v3 = *a1;
*(_QWORD *)(v3 + 192) = 0LL;
*(_QWORD *)(v3 + 32) = 0LL;
*(_QWORD *)(v3 + 24) = 0LL;
*(_DWORD *)(v3 + 368) = 0;
*(_QWORD *)(v3 + 200) = -1LL;
*(_DWORD *)(v3 + 360) = 0xFFFF;
*(_QWORD *)(v3 + 56) = *(_QWORD *)(v3 + 864);
*(_QWORD *)(v3 + 64) = 0LL;
*(_QWORD *)(v3 + 48) = 0LL;
*(_QWORD *)(v3 + 40) = 0LL;
*(_DWORD *)(v3 + 72) = 0;
*(_DWORD *)(v3 + 364) = 0;
*(_BYTE *)(v3 + 2015) = 0;
*(_BYTE *)(v3 + 2014) = 1;
memcpy(a1[4], v3 + 24, 56LL);
*(_QWORD *)(v3 + 288) = -1LL;
for ( i = 0; ; ++i )
{
result = i;
if ( i >= *(_DWORD *)(v3 + 1000) )
break;
*(_QWORD *)(*(_QWORD *)(v3 + 280) + 8LL * i) = -1LL;
}
return result;
}
| _ma_reset_status:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0xc0],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x20],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x18],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x170],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0xc8],-0x1
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x168],0xffff
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x360]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x38],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x40],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x30],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x28],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x48],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x16c],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x7df],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x7de],0x1
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x20]
MOV RSI,qword ptr [RBP + -0x18]
ADD RSI,0x18
MOV EDX,0x38
CALL 0x0012a090
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x120],-0x1
MOV dword ptr [RBP + -0x1c],0x0
LAB_001768a7:
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0x3e8]
JNC 0x001768d7
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x118]
MOV ECX,dword ptr [RBP + -0x1c]
MOV qword ptr [RAX + RCX*0x8],-0x1
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x001768a7
LAB_001768d7:
JMP 0x001768d9
LAB_001768d9:
JMP 0x001768db
LAB_001768db:
ADD RSP,0x20
POP RBP
RET
|
void _ma_reset_status(long *param_1)
{
long lVar1;
uint local_24;
lVar1 = *param_1;
*(int8 *)(lVar1 + 0xc0) = 0;
*(int8 *)(lVar1 + 0x20) = 0;
*(int8 *)(lVar1 + 0x18) = 0;
*(int4 *)(lVar1 + 0x170) = 0;
*(int8 *)(lVar1 + 200) = 0xffffffffffffffff;
*(int4 *)(lVar1 + 0x168) = 0xffff;
*(int8 *)(lVar1 + 0x38) = *(int8 *)(lVar1 + 0x360);
*(int8 *)(lVar1 + 0x40) = 0;
*(int8 *)(lVar1 + 0x30) = 0;
*(int8 *)(lVar1 + 0x28) = 0;
*(int4 *)(lVar1 + 0x48) = 0;
*(int4 *)(lVar1 + 0x16c) = 0;
*(int1 *)(lVar1 + 0x7df) = 0;
*(int1 *)(lVar1 + 0x7de) = 1;
memcpy((void *)param_1[4],(void *)(lVar1 + 0x18),0x38);
*(int8 *)(lVar1 + 0x120) = 0xffffffffffffffff;
for (local_24 = 0; local_24 < *(uint *)(lVar1 + 1000); local_24 = local_24 + 1) {
*(int8 *)(*(long *)(lVar1 + 0x118) + (ulong)local_24 * 8) = 0xffffffffffffffff;
}
return;
}
| |
45,654 | ma_reset_status | eloqsql/storage/maria/ma_delete_all.c | void _ma_reset_status(MARIA_HA *info)
{
MARIA_SHARE *share= info->s;
MARIA_STATE_INFO *state= &share->state;
uint i;
DBUG_ENTER("_ma_reset_status");
state->split= 0;
state->state.records= state->state.del= 0;
state->changed= 0; /* File is optimized */
state->dellink= HA_OFFSET_ERROR;
state->sortkey= (ushort) ~0;
state->state.key_file_length= share->base.keystart;
state->state.data_file_length= 0;
state->state.empty= state->state.key_empty= 0;
state->state.checksum= 0;
share->state.open_count= 0;
share->global_changed= 0;
share->changed= 1; /* We must write state */
*info->state= state->state;
/* Drop the delete key chain. */
state->key_del= HA_OFFSET_ERROR;
/* Clear all keys */
for (i=0 ; i < share->base.keys ; i++)
state->key_root[i]= HA_OFFSET_ERROR;
DBUG_VOID_RETURN;
} | O3 | c | ma_reset_status:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
xorl %ecx, %ecx
movq %rcx, 0xc0(%rax)
movl %ecx, 0x170(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movq $-0x1, %rdx
movq %rdx, 0xc8(%rax)
movq $0xffff, 0x168(%rax) # imm = 0xFFFF
movq 0x360(%rax), %rsi
movq %rsi, 0x38(%rax)
movq %rcx, 0x40(%rax)
movl %ecx, 0x48(%rax)
movups %xmm0, 0x28(%rax)
movw $0x1, 0x7de(%rax)
movq 0x20(%rdi), %rsi
movups %xmm0, 0x10(%rsi)
movq 0x48(%rax), %rdi
movq %rdi, 0x30(%rsi)
movups 0x38(%rax), %xmm1
movups %xmm1, 0x20(%rsi)
movups %xmm0, (%rsi)
movq %rdx, 0x120(%rax)
cmpl %ecx, 0x3e8(%rax)
je 0x5f1ef
xorl %ecx, %ecx
movq 0x118(%rax), %rdx
movq $-0x1, (%rdx,%rcx,8)
incq %rcx
movl 0x3e8(%rax), %edx
cmpq %rdx, %rcx
jb 0x5f1d2
popq %rbp
retq
| _ma_reset_status:
push rbp
mov rbp, rsp
mov rax, [rdi]
xor ecx, ecx
mov [rax+0C0h], rcx
mov [rax+170h], ecx
xorps xmm0, xmm0
movups xmmword ptr [rax+18h], xmm0
mov rdx, 0FFFFFFFFFFFFFFFFh
mov [rax+0C8h], rdx
mov qword ptr [rax+168h], 0FFFFh
mov rsi, [rax+360h]
mov [rax+38h], rsi
mov [rax+40h], rcx
mov [rax+48h], ecx
movups xmmword ptr [rax+28h], xmm0
mov word ptr [rax+7DEh], 1
mov rsi, [rdi+20h]
movups xmmword ptr [rsi+10h], xmm0
mov rdi, [rax+48h]
mov [rsi+30h], rdi
movups xmm1, xmmword ptr [rax+38h]
movups xmmword ptr [rsi+20h], xmm1
movups xmmword ptr [rsi], xmm0
mov [rax+120h], rdx
cmp [rax+3E8h], ecx
jz short loc_5F1EF
xor ecx, ecx
loc_5F1D2:
mov rdx, [rax+118h]
mov qword ptr [rdx+rcx*8], 0FFFFFFFFFFFFFFFFh
inc rcx
mov edx, [rax+3E8h]
cmp rcx, rdx
jb short loc_5F1D2
loc_5F1EF:
pop rbp
retn
| long long ma_reset_status(long long *a1)
{
long long result; // rax
long long v2; // rsi
unsigned long long v3; // rcx
result = *a1;
*(_QWORD *)(result + 192) = 0LL;
*(_DWORD *)(result + 368) = 0;
*(_OWORD *)(result + 24) = 0LL;
*(_QWORD *)(result + 200) = -1LL;
*(_QWORD *)(result + 360) = 0xFFFFLL;
*(_QWORD *)(result + 56) = *(_QWORD *)(result + 864);
*(_QWORD *)(result + 64) = 0LL;
*(_DWORD *)(result + 72) = 0;
*(_OWORD *)(result + 40) = 0LL;
*(_WORD *)(result + 2014) = 1;
v2 = a1[4];
*(_OWORD *)(v2 + 16) = 0LL;
*(_QWORD *)(v2 + 48) = *(_QWORD *)(result + 72);
*(_OWORD *)(v2 + 32) = *(_OWORD *)(result + 56);
*(_OWORD *)v2 = 0LL;
*(_QWORD *)(result + 288) = -1LL;
if ( *(_DWORD *)(result + 1000) )
{
v3 = 0LL;
do
*(_QWORD *)(*(_QWORD *)(result + 280) + 8 * v3++) = -1LL;
while ( v3 < *(unsigned int *)(result + 1000) );
}
return result;
}
| _ma_reset_status:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI]
XOR ECX,ECX
MOV qword ptr [RAX + 0xc0],RCX
MOV dword ptr [RAX + 0x170],ECX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX + 0x18],XMM0
MOV RDX,-0x1
MOV qword ptr [RAX + 0xc8],RDX
MOV qword ptr [RAX + 0x168],0xffff
MOV RSI,qword ptr [RAX + 0x360]
MOV qword ptr [RAX + 0x38],RSI
MOV qword ptr [RAX + 0x40],RCX
MOV dword ptr [RAX + 0x48],ECX
MOVUPS xmmword ptr [RAX + 0x28],XMM0
MOV word ptr [RAX + 0x7de],0x1
MOV RSI,qword ptr [RDI + 0x20]
MOVUPS xmmword ptr [RSI + 0x10],XMM0
MOV RDI,qword ptr [RAX + 0x48]
MOV qword ptr [RSI + 0x30],RDI
MOVUPS XMM1,xmmword ptr [RAX + 0x38]
MOVUPS xmmword ptr [RSI + 0x20],XMM1
MOVUPS xmmword ptr [RSI],XMM0
MOV qword ptr [RAX + 0x120],RDX
CMP dword ptr [RAX + 0x3e8],ECX
JZ 0x0015f1ef
XOR ECX,ECX
LAB_0015f1d2:
MOV RDX,qword ptr [RAX + 0x118]
MOV qword ptr [RDX + RCX*0x8],-0x1
INC RCX
MOV EDX,dword ptr [RAX + 0x3e8]
CMP RCX,RDX
JC 0x0015f1d2
LAB_0015f1ef:
POP RBP
RET
|
void _ma_reset_status(long *param_1)
{
long lVar1;
int8 *puVar2;
int8 uVar3;
ulong uVar4;
lVar1 = *param_1;
*(int8 *)(lVar1 + 0xc0) = 0;
*(int4 *)(lVar1 + 0x170) = 0;
*(int8 *)(lVar1 + 0x18) = 0;
*(int8 *)(lVar1 + 0x20) = 0;
*(int8 *)(lVar1 + 200) = 0xffffffffffffffff;
*(int8 *)(lVar1 + 0x168) = 0xffff;
*(int8 *)(lVar1 + 0x38) = *(int8 *)(lVar1 + 0x360);
*(int8 *)(lVar1 + 0x40) = 0;
*(int4 *)(lVar1 + 0x48) = 0;
*(int8 *)(lVar1 + 0x28) = 0;
*(int8 *)(lVar1 + 0x30) = 0;
*(int2 *)(lVar1 + 0x7de) = 1;
puVar2 = (int8 *)param_1[4];
puVar2[2] = 0;
puVar2[3] = 0;
puVar2[6] = *(int8 *)(lVar1 + 0x48);
uVar3 = *(int8 *)(lVar1 + 0x40);
puVar2[4] = *(int8 *)(lVar1 + 0x38);
puVar2[5] = uVar3;
*puVar2 = 0;
puVar2[1] = 0;
*(int8 *)(lVar1 + 0x120) = 0xffffffffffffffff;
if (*(int *)(lVar1 + 1000) != 0) {
uVar4 = 0;
do {
*(int8 *)(*(long *)(lVar1 + 0x118) + uVar4 * 8) = 0xffffffffffffffff;
uVar4 = uVar4 + 1;
} while (uVar4 < *(uint *)(lVar1 + 1000));
}
return;
}
| |
45,655 | ma_log_del_prefix | eloqsql/storage/maria/ma_write.c | static my_bool _ma_log_del_prefix(MARIA_PAGE *ma_page,
uint org_length, uint new_length,
const uchar *key_pos, uint key_length,
int move_length)
{
LSN lsn;
uchar log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE + 2 + 2 + 12 + 7];
uchar *log_pos;
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 4];
uint offset= (uint) (key_pos - ma_page->buff);
uint diff_length= org_length + move_length - new_length;
uint translog_parts, extra_length;
MARIA_HA *info= ma_page->info;
my_off_t page= ma_page->pos / info->s->block_size;
DBUG_ENTER("_ma_log_del_prefix");
DBUG_PRINT("enter", ("page: %lu org_length: %u new_length: %u",
(ulong) page, org_length, new_length));
DBUG_ASSERT((int) diff_length > 0);
DBUG_ASSERT(ma_page->org_size == org_length);
DBUG_ASSERT(ma_page->size == new_length);
log_pos= log_data + FILEID_STORE_SIZE;
page_store(log_pos, page);
log_pos+= PAGE_STORE_SIZE;
translog_parts= 1;
extra_length= 0;
#ifdef EXTRA_DEBUG_KEY_CHANGES
*log_pos++= KEY_OP_DEBUG;
*log_pos++= KEY_OP_DEBUG_LOG_DEL_PREFIX;
#endif
/* Store keypage_flag */
*log_pos++= KEY_OP_SET_PAGEFLAG;
*log_pos++= _ma_get_keypage_flag(info->s, ma_page->buff);
if (offset < diff_length + info->s->keypage_header)
{
/*
Key is not anymore on page. Move data down, but take into account that
the original page had grown with 'move_length bytes'
*/
DBUG_ASSERT(offset + key_length <= diff_length + info->s->keypage_header);
log_pos[0]= KEY_OP_DEL_PREFIX;
int2store(log_pos+1, diff_length - move_length);
log_pos+= 3;
}
else
{
/*
Correct position to key, as data before key has been delete and key
has thus been moved down
*/
offset-= diff_length;
key_pos-= diff_length;
/* Move data down */
log_pos[0]= KEY_OP_DEL_PREFIX;
int2store(log_pos+1, diff_length);
log_pos+= 3;
log_pos[0]= KEY_OP_OFFSET;
int2store(log_pos+1, offset);
log_pos+= 3;
if (move_length)
{
log_pos[0]= KEY_OP_SHIFT;
int2store(log_pos+1, move_length);
log_pos+= 3;
}
log_pos[0]= KEY_OP_CHANGE;
int2store(log_pos+1, key_length);
log_pos+= 3;
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= key_pos;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= key_length;
translog_parts= 2;
extra_length= key_length;
}
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= (uint) (log_pos -
log_data);
_ma_log_key_changes(ma_page,
log_array + TRANSLOG_INTERNAL_PARTS + translog_parts,
log_pos, &extra_length, &translog_parts);
/* Remember new page length for future log entires for same page */
ma_page->org_size= ma_page->size;
DBUG_RETURN(translog_write_record(&lsn, LOGREC_REDO_INDEX,
info->trn, info,
(translog_size_t)
log_array[TRANSLOG_INTERNAL_PARTS +
0].length + extra_length,
TRANSLOG_INTERNAL_PARTS + translog_parts,
log_array, log_data, NULL));
} | O3 | c | ma_log_del_prefix:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rcx, %r10
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
movq (%rdi), %rcx
movq 0x10(%rdi), %r14
movl %r10d, %r11d
subl %r14d, %r11d
subl %edx, %esi
leal (%rsi,%r9), %ebx
movq 0x18(%rdi), %rax
movq (%rcx), %r15
movl 0x7bc(%r15), %r12d
xorl %edx, %edx
divq %r12
movl %eax, -0x4e(%rbp)
shrq $0x20, %rax
movb %al, -0x4a(%rbp)
movb $0xa, -0x49(%rbp)
movl 0x744(%r15), %eax
leal -0x3(%rax), %edx
movb (%r14,%rdx), %dl
movb %dl, -0x48(%rbp)
addl %ebx, %eax
cmpl %r11d, %eax
jbe 0x68146
leaq -0x44(%rbp), %rax
movb $0x5, -0x3(%rax)
movw %si, -0x2(%rax)
movl $0x3, %r9d
xorl %r8d, %r8d
jmp 0x6819a
subl %ebx, %r11d
movl %ebx, %eax
subq %rax, %r10
movb $0x5, -0x47(%rbp)
movw %bx, -0x46(%rbp)
movb $0x1, -0x44(%rbp)
movw %r11w, -0x43(%rbp)
testl %r9d, %r9d
je 0x68173
leaq -0x3e(%rbp), %rax
movb $0x2, -0x3(%rax)
movw %r9w, -0x2(%rax)
jmp 0x68177
leaq -0x41(%rbp), %rax
movb $0x3, (%rax)
movw %r8w, 0x1(%rax)
addq $0x3, %rax
movq %r10, -0x90(%rbp)
movl %r8d, %edx
movq %rdx, -0x88(%rbp)
movl $0x4, %r9d
leaq -0x50(%rbp), %r10
leaq -0xc0(%rbp), %r11
movq %r10, 0x20(%r11)
subq %r10, %rax
movl %eax, %edx
movq %rdx, 0x28(%r11)
movl 0x20(%rdi), %edx
movl %edx, 0x24(%rdi)
movq 0x8(%rcx), %rdx
addl %eax, %r8d
subq $0x8, %rsp
leaq -0x58(%rbp), %rdi
movl $0xc, %esi
pushq $0x0
pushq %r10
pushq %r11
callq 0x2a8ac
addq $0x20, %rsp
movq %fs:0x28, %rcx
cmpq -0x28(%rbp), %rcx
jne 0x681fa
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x29270
nop
| _ma_log_del_prefix:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 0A0h
mov r10, rcx
mov rax, fs:28h
mov [rbp+var_28], rax
mov rcx, [rdi]
mov r14, [rdi+10h]
mov r11d, r10d
sub r11d, r14d
sub esi, edx
lea ebx, [rsi+r9]
mov rax, [rdi+18h]
mov r15, [rcx]
mov r12d, [r15+7BCh]
xor edx, edx
div r12
mov [rbp+var_4E], eax
shr rax, 20h
mov [rbp+var_4A], al
mov [rbp+var_49], 0Ah
mov eax, [r15+744h]
lea edx, [rax-3]
mov dl, [r14+rdx]
mov [rbp+var_48], dl
add eax, ebx
cmp eax, r11d
jbe short loc_68146
lea rax, [rbp+var_44]
mov byte ptr [rax-3], 5
mov [rax-2], si
mov r9d, 3
xor r8d, r8d
jmp short loc_6819A
loc_68146:
sub r11d, ebx
mov eax, ebx
sub r10, rax
mov [rbp+var_47], 5
mov [rbp+var_46], bx
mov [rbp+var_44], 1
mov [rbp+var_43], r11w
test r9d, r9d
jz short loc_68173
lea rax, [rbp+var_3E]
mov byte ptr [rax-3], 2
mov [rax-2], r9w
jmp short loc_68177
loc_68173:
lea rax, [rbp+var_41]
loc_68177:
mov byte ptr [rax], 3
mov [rax+1], r8w
add rax, 3
mov [rbp+var_90], r10
mov edx, r8d
mov [rbp+var_88], rdx
mov r9d, 4
loc_6819A:
lea r10, [rbp+var_50]
lea r11, [rbp+var_C0]
mov [r11+20h], r10
sub rax, r10
mov edx, eax
mov [r11+28h], rdx
mov edx, [rdi+20h]
mov [rdi+24h], edx
mov rdx, [rcx+8]
add r8d, eax
sub rsp, 8
lea rdi, [rbp+var_58]
mov esi, 0Ch
push 0
push r10
push r11
call translog_write_record
add rsp, 20h
mov rcx, fs:28h
cmp rcx, [rbp+var_28]
jnz short loc_681FA
add rsp, 0A0h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_681FA:
call ___stack_chk_fail
| long long ma_log_del_prefix(long long **a1, int a2, int a3, long long a4, unsigned int a5, int a6)
{
long long *v7; // rcx
long long *v8; // r14
__int16 v9; // r11
int v10; // esi
unsigned int v11; // ebx
long long v12; // r15
unsigned long long v13; // rax
char *v14; // rax
int v15; // r9d
long long v16; // r10
char *v17; // rax
signed long long v18; // rax
__int128 v20; // [rsp+0h] [rbp-C0h] BYREF
__int16 *v21; // [rsp+20h] [rbp-A0h]
long long v22; // [rsp+28h] [rbp-98h]
long long v23; // [rsp+30h] [rbp-90h]
long long v24; // [rsp+38h] [rbp-88h]
_BYTE v25[8]; // [rsp+68h] [rbp-58h] BYREF
__int16 v26; // [rsp+70h] [rbp-50h] BYREF
int v27; // [rsp+72h] [rbp-4Eh]
char v28; // [rsp+76h] [rbp-4Ah]
char v29; // [rsp+77h] [rbp-49h]
char v30; // [rsp+78h] [rbp-48h]
char v31; // [rsp+79h] [rbp-47h]
__int16 v32; // [rsp+7Ah] [rbp-46h]
char v33; // [rsp+7Ch] [rbp-44h] BYREF
__int16 v34; // [rsp+7Dh] [rbp-43h]
char v35; // [rsp+7Fh] [rbp-41h] BYREF
__int16 v36; // [rsp+80h] [rbp-40h]
char v37; // [rsp+82h] [rbp-3Eh] BYREF
unsigned long long v38; // [rsp+98h] [rbp-28h]
v38 = __readfsqword(0x28u);
v7 = *a1;
v8 = a1[2];
v9 = a4 - (_WORD)v8;
v10 = a2 - a3;
v11 = v10 + a6;
v12 = **a1;
v13 = (unsigned long long)a1[3] / *(unsigned int *)(v12 + 1980);
v27 = v13;
v28 = BYTE4(v13);
v29 = 10;
LODWORD(v13) = *(_DWORD *)(v12 + 1860);
v30 = *((_BYTE *)v8 + (unsigned int)(v13 - 3));
if ( v10 + a6 + (int)v13 <= (unsigned int)(a4 - (_DWORD)v8) )
{
v16 = a4 - v11;
v31 = 5;
v32 = v10 + a6;
v33 = 1;
v34 = v9 - v11;
if ( a6 )
{
v17 = &v37;
v35 = 2;
v36 = a6;
}
else
{
v17 = &v35;
}
*v17 = 3;
*(_WORD *)(v17 + 1) = a5;
v14 = v17 + 3;
v23 = v16;
v24 = a5;
v15 = 4;
}
else
{
v14 = &v33;
v31 = 5;
v32 = v10;
v15 = 3;
a5 = 0;
}
v21 = &v26;
v18 = v14 - (char *)&v26;
v22 = (unsigned int)v18;
*((_DWORD *)a1 + 9) = *((_DWORD *)a1 + 8);
return translog_write_record(
(unsigned long long)v25,
&byte_9[3],
v7[1],
v7,
(unsigned int)v18 + a5,
v15,
&v20,
&v26,
0LL);
}
| _ma_log_del_prefix:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0xa0
MOV R10,RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV RCX,qword ptr [RDI]
MOV R14,qword ptr [RDI + 0x10]
MOV R11D,R10D
SUB R11D,R14D
SUB ESI,EDX
LEA EBX,[RSI + R9*0x1]
MOV RAX,qword ptr [RDI + 0x18]
MOV R15,qword ptr [RCX]
MOV R12D,dword ptr [R15 + 0x7bc]
XOR EDX,EDX
DIV R12
MOV dword ptr [RBP + -0x4e],EAX
SHR RAX,0x20
MOV byte ptr [RBP + -0x4a],AL
MOV byte ptr [RBP + -0x49],0xa
MOV EAX,dword ptr [R15 + 0x744]
LEA EDX,[RAX + -0x3]
MOV DL,byte ptr [R14 + RDX*0x1]
MOV byte ptr [RBP + -0x48],DL
ADD EAX,EBX
CMP EAX,R11D
JBE 0x00168146
LEA RAX,[RBP + -0x44]
MOV byte ptr [RAX + -0x3],0x5
MOV word ptr [RAX + -0x2],SI
MOV R9D,0x3
XOR R8D,R8D
JMP 0x0016819a
LAB_00168146:
SUB R11D,EBX
MOV EAX,EBX
SUB R10,RAX
MOV byte ptr [RBP + -0x47],0x5
MOV word ptr [RBP + -0x46],BX
MOV byte ptr [RBP + -0x44],0x1
MOV word ptr [RBP + -0x43],R11W
TEST R9D,R9D
JZ 0x00168173
LEA RAX,[RBP + -0x3e]
MOV byte ptr [RAX + -0x3],0x2
MOV word ptr [RAX + -0x2],R9W
JMP 0x00168177
LAB_00168173:
LEA RAX,[RBP + -0x41]
LAB_00168177:
MOV byte ptr [RAX],0x3
MOV word ptr [RAX + 0x1],R8W
ADD RAX,0x3
MOV qword ptr [RBP + -0x90],R10
MOV EDX,R8D
MOV qword ptr [RBP + -0x88],RDX
MOV R9D,0x4
LAB_0016819a:
LEA R10,[RBP + -0x50]
LEA R11,[RBP + -0xc0]
MOV qword ptr [R11 + 0x20],R10
SUB RAX,R10
MOV EDX,EAX
MOV qword ptr [R11 + 0x28],RDX
MOV EDX,dword ptr [RDI + 0x20]
MOV dword ptr [RDI + 0x24],EDX
MOV RDX,qword ptr [RCX + 0x8]
ADD R8D,EAX
SUB RSP,0x8
LEA RDI,[RBP + -0x58]
MOV ESI,0xc
PUSH 0x0
PUSH R10
PUSH R11
CALL 0x0012a8ac
ADD RSP,0x20
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x28]
JNZ 0x001681fa
ADD RSP,0xa0
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001681fa:
CALL 0x00129270
|
void _ma_log_del_prefix(long *param_1,int param_2,int param_3,long param_4,uint param_5,int param_6)
{
long *plVar1;
int1 auVar2 [16];
int iVar3;
uint uVar4;
int1 *puVar5;
int8 uVar6;
uint uVar7;
long in_FS_OFFSET;
int1 local_c8 [32];
int1 *local_a8;
ulong local_a0;
long local_98;
ulong local_90;
int1 local_60 [8];
int1 local_58 [2];
int4 local_56;
int1 local_52;
int1 local_51;
int1 local_50;
int1 local_4f;
short local_4e;
int1 local_4c;
short local_4b;
int1 local_49;
int2 local_48;
int1 local_46 [22];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
plVar1 = (long *)*param_1;
uVar7 = (int)param_4 - (int)param_1[2];
uVar4 = (param_2 - param_3) + param_6;
auVar2._8_8_ = 0;
auVar2._0_8_ = param_1[3];
auVar2 = auVar2 / ZEXT416(*(uint *)(*plVar1 + 0x7bc));
local_56 = auVar2._0_4_;
local_52 = auVar2[4];
local_51 = 10;
iVar3 = *(int *)(*plVar1 + 0x744);
local_50 = *(int1 *)(param_1[2] + (ulong)(iVar3 - 3));
if (uVar7 < iVar3 + uVar4) {
iVar3 = (int)&local_4c;
local_4e = (short)(param_2 - param_3);
uVar6 = 3;
param_5 = 0;
}
else {
local_4e = (short)uVar4;
local_4b = (short)uVar7 - local_4e;
local_98 = param_4 - (ulong)uVar4;
local_4c = 1;
if (param_6 == 0) {
puVar5 = &local_49;
}
else {
puVar5 = local_46;
local_49 = 2;
local_48 = (int2)param_6;
}
*puVar5 = 3;
*(short *)(puVar5 + 1) = (short)param_5;
iVar3 = (int)puVar5 + 3;
local_90 = (ulong)param_5;
uVar6 = 4;
}
local_4f = 5;
local_a8 = local_58;
uVar4 = iVar3 - (int)local_a8;
local_a0 = (ulong)uVar4;
*(int *)((long)param_1 + 0x24) = (int)param_1[4];
translog_write_record(local_60,0xc,plVar1[1],plVar1,param_5 + uVar4,uVar6,local_c8,local_a8,0);
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
45,656 | my_pwrite | eloqsql/mysys/my_pread.c | size_t my_pwrite(int Filedes, const uchar *Buffer, size_t Count,
my_off_t offset, myf MyFlags)
{
size_t writtenbytes, written;
uint errors;
DBUG_ENTER("my_pwrite");
DBUG_PRINT("my",("fd: %d Seek: %llu Buffer: %p Count: %lu MyFlags: %lu",
Filedes, (ulonglong)offset, Buffer, (ulong)Count, MyFlags));
errors= 0;
written= 0;
if (!(MyFlags & (MY_WME | MY_FAE | MY_FNABP)))
MyFlags|= my_global_flags;
for (;;)
{
#ifdef _WIN32
writtenbytes= my_win_pwrite(Filedes, Buffer, Count,offset);
#else
writtenbytes= pwrite(Filedes, Buffer, Count, offset);
#endif
if (writtenbytes == Count)
break;
my_errno= errno;
if (writtenbytes != (size_t) -1)
{ /* Safegueard */
written+=writtenbytes;
Buffer+=writtenbytes;
Count-=writtenbytes;
offset+=writtenbytes;
}
DBUG_PRINT("error",("Write only %u bytes", (uint) writtenbytes));
#ifndef NO_BACKGROUND
if (my_thread_var->abort)
MyFlags&= ~ MY_WAIT_IF_FULL; /* End if aborted by user */
if ((my_errno == ENOSPC || my_errno == EDQUOT) &&
(MyFlags & MY_WAIT_IF_FULL))
{
wait_for_free_space(my_filename(Filedes), errors);
errors++;
continue;
}
if ((writtenbytes && writtenbytes != (size_t) -1) || my_errno == EINTR)
continue; /* Retry */
#endif
/* Don't give a warning if it's ok that we only write part of the data */
if (MyFlags & (MY_NABP | MY_FNABP))
{
if (MyFlags & (MY_WME | MY_FAE | MY_FNABP))
my_error(EE_WRITE, MYF(ME_BELL | (MyFlags & (ME_NOTE | ME_ERROR_LOG))),
my_filename(Filedes),my_errno);
DBUG_RETURN(MY_FILE_ERROR); /* Error on write */
}
break; /* Return bytes written */
}
DBUG_EXECUTE_IF("check", my_seek(Filedes, -1, SEEK_SET, MYF(0)););
if (MyFlags & (MY_NABP | MY_FNABP))
DBUG_RETURN(0); /* Want only errors */
DBUG_RETURN(writtenbytes+written); /* purecov: inspected */
} | O3 | c | my_pwrite:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, -0x38(%rbp)
movl %edi, -0x2c(%rbp)
movq $0x0, -0x40(%rbp)
movl $0x0, %r14d
testb $0x1a, %r8b
jne 0x60e0e
leaq 0x35793d(%rip), %rax # 0x3b8748
movq (%rax), %r14
orq %r8, %r14
movl -0x2c(%rbp), %edi
movq -0x38(%rbp), %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x28790
cmpq %rbx, %rax
jne 0x60e3a
testb $0x6, %r14b
je 0x60f1c
xorl %r15d, %r15d
jmp 0x60f23
movq %rax, %r15
movq $0x0, -0x48(%rbp)
callq 0x28050
movq %rax, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq %r13, %r12
movq -0x50(%rbp), %rax
movl (%rax), %r13d
callq 0x624a2
movl %r13d, (%rax)
cmpq $-0x1, %r15
je 0x60e81
addq %r15, -0x40(%rbp)
addq %r15, -0x38(%rbp)
subq %r15, %rbx
movq %r12, %r13
addq %r15, %r13
jmp 0x60e84
movq %r12, %r13
callq 0x624a2
movl %r14d, %ecx
andl $-0x21, %ecx
cmpl $0x0, 0xe0(%rax)
cmovneq %rcx, %r14
callq 0x624a2
cmpl $0x1c, (%rax)
jne 0x60eac
testb $0x20, %r14b
je 0x60ebe
jmp 0x60ef5
callq 0x624a2
cmpl $0x7a, (%rax)
jne 0x60ebe
movl %r14d, %eax
andl $0x20, %eax
jne 0x60ef5
leaq -0x1(%r15), %rax
cmpq $-0x2, %rax
jb 0x60ed2
callq 0x624a2
cmpl $0x4, (%rax)
jne 0x60f35
movl -0x2c(%rbp), %edi
movq -0x38(%rbp), %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x28790
movq %rax, %r15
cmpq %rbx, %rax
jne 0x60e56
jmp 0x60e28
movl -0x2c(%rbp), %r15d
movl %r15d, %edi
callq 0x683ec
movq %rax, %rdi
movq -0x48(%rbp), %r12
movl %r12d, %esi
callq 0x67d12
incl %r12d
movq %r12, -0x48(%rbp)
movl %r15d, %edi
jmp 0x60ed5
movq -0x40(%rbp), %r15
addq %rbx, %r15
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testb $0x6, %r14b
je 0x60f79
movq $-0x1, %r15
testb $0x1a, %r14b
je 0x60f23
andl $0x440, %r14d # imm = 0x440
orq $0x4, %r14
movl -0x2c(%rbp), %edi
callq 0x683ec
movq %rax, %rbx
callq 0x624a2
movl (%rax), %ecx
movl $0x3, %edi
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x5bf1f
jmp 0x60f23
movq %r15, %rbx
jmp 0x60e28
nopl (%rax)
| my_pwrite:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r13, rcx
mov rbx, rdx
mov [rbp+var_38], rsi
mov [rbp+var_2C], edi
mov [rbp+var_40], 0
mov r14d, 0
test r8b, 1Ah
jnz short loc_60E0E
lea rax, my_global_flags
mov r14, [rax]
loc_60E0E:
or r14, r8
mov edi, [rbp+var_2C]
mov rsi, [rbp+var_38]
mov rdx, rbx
mov rcx, r13
call _pwrite64
cmp rax, rbx
jnz short loc_60E3A
loc_60E28:
test r14b, 6
jz loc_60F1C
xor r15d, r15d
jmp loc_60F23
loc_60E3A:
mov r15, rax
mov [rbp+var_48], 0
call ___errno_location
mov [rbp+var_50], rax
mov [rbp+var_40], 0
loc_60E56:
mov r12, r13
mov rax, [rbp+var_50]
mov r13d, [rax]
call _my_thread_var
mov [rax], r13d
cmp r15, 0FFFFFFFFFFFFFFFFh
jz short loc_60E81
add [rbp+var_40], r15
add [rbp+var_38], r15
sub rbx, r15
mov r13, r12
add r13, r15
jmp short loc_60E84
loc_60E81:
mov r13, r12
loc_60E84:
call _my_thread_var
mov ecx, r14d
and ecx, 0FFFFFFDFh
cmp dword ptr [rax+0E0h], 0
cmovnz r14, rcx
call _my_thread_var
cmp dword ptr [rax], 1Ch
jnz short loc_60EAC
test r14b, 20h
jz short loc_60EBE
jmp short loc_60EF5
loc_60EAC:
call _my_thread_var
cmp dword ptr [rax], 7Ah ; 'z'
jnz short loc_60EBE
mov eax, r14d
and eax, 20h
jnz short loc_60EF5
loc_60EBE:
lea rax, [r15-1]
cmp rax, 0FFFFFFFFFFFFFFFEh
jb short loc_60ED2
call _my_thread_var
cmp dword ptr [rax], 4
jnz short loc_60F35
loc_60ED2:
mov edi, [rbp+var_2C]
loc_60ED5:
mov rsi, [rbp+var_38]
mov rdx, rbx
mov rcx, r13
call _pwrite64
mov r15, rax
cmp rax, rbx
jnz loc_60E56
jmp loc_60E28
loc_60EF5:
mov r15d, [rbp+var_2C]
mov edi, r15d
call my_filename
mov rdi, rax
mov r12, [rbp+var_48]
mov esi, r12d
call wait_for_free_space
inc r12d
mov [rbp+var_48], r12
mov edi, r15d
jmp short loc_60ED5
loc_60F1C:
mov r15, [rbp+var_40]
add r15, rbx
loc_60F23:
mov rax, r15
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_60F35:
test r14b, 6
jz short loc_60F79
mov r15, 0FFFFFFFFFFFFFFFFh
test r14b, 1Ah
jz short loc_60F23
and r14d, 440h
or r14, 4
mov edi, [rbp+var_2C]
call my_filename
mov rbx, rax
call _my_thread_var
mov ecx, [rax]
mov edi, 3
mov rsi, r14
mov rdx, rbx
xor eax, eax
call my_error
jmp short loc_60F23
loc_60F79:
mov rbx, r15
jmp loc_60E28
| long long my_pwrite(long long a1, long long a2, long long a3, long long a4, __int16 a5)
{
long long v5; // r13
long long v6; // rbx
__int16 v7; // r14
__int16 v8; // r14
long long v9; // rax
long long v10; // r15
long long v11; // r15
long long v12; // rdx
long long v13; // r12
int v14; // r13d
long long v15; // rdx
long long v16; // rdx
long long v17; // rdx
long long v18; // rax
long long v20; // rbx
long long v21; // rdx
unsigned int *v22; // rax
int *v23; // [rsp+0h] [rbp-50h]
unsigned int v24; // [rsp+8h] [rbp-48h]
long long v25; // [rsp+10h] [rbp-40h]
long long v26; // [rsp+18h] [rbp-38h]
unsigned int v27; // [rsp+24h] [rbp-2Ch]
v5 = a4;
v6 = a3;
v26 = a2;
v27 = a1;
v25 = 0LL;
v7 = 0;
if ( (a5 & 0x1A) == 0 )
v7 = my_global_flags;
v8 = a5 | v7;
a1 = (unsigned int)a1;
v9 = pwrite64((unsigned int)a1, a2, a3, a4);
if ( v9 == v6 )
goto LABEL_4;
v11 = v9;
v24 = 0;
v23 = (int *)__errno_location((unsigned int)a1);
v25 = 0LL;
while ( 1 )
{
v13 = v5;
v14 = *v23;
*(_DWORD *)my_thread_var(a1, a2, v12) = v14;
if ( v11 == -1 )
{
v5 = v13;
}
else
{
v25 += v11;
v26 += v11;
v6 -= v11;
v5 = v11 + v13;
}
if ( *(_DWORD *)(my_thread_var(a1, a2, v15) + 224) )
v8 &= ~0x20u;
if ( *(_DWORD *)my_thread_var(a1, a2, v16) == 28 )
{
if ( (v8 & 0x20) != 0 )
goto LABEL_22;
}
else if ( *(_DWORD *)my_thread_var(a1, a2, v17) == 122 && (v8 & 0x20) != 0 )
{
LABEL_22:
v18 = my_filename(v27);
wait_for_free_space(v18, v24++);
a1 = v27;
goto LABEL_20;
}
if ( (unsigned long long)(v11 - 1) >= 0xFFFFFFFFFFFFFFFELL && *(_DWORD *)my_thread_var(a1, a2, v17) != 4 )
break;
a1 = v27;
LABEL_20:
a2 = v26;
v11 = pwrite64(a1, v26, v6, v5);
if ( v11 == v6 )
goto LABEL_4;
}
if ( (v8 & 6) == 0 )
{
v6 = v11;
LABEL_4:
if ( (v8 & 6) != 0 )
return 0LL;
else
return v6 + v25;
}
v10 = -1LL;
if ( (v8 & 0x1A) != 0 )
{
v20 = my_filename(v27);
v22 = (unsigned int *)my_thread_var(v27, a2, v21);
my_error(3u, v8 & 0x440 | 4LL, v20, *v22);
}
return v10;
}
| my_pwrite:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R13,RCX
MOV RBX,RDX
MOV qword ptr [RBP + -0x38],RSI
MOV dword ptr [RBP + -0x2c],EDI
MOV qword ptr [RBP + -0x40],0x0
MOV R14D,0x0
TEST R8B,0x1a
JNZ 0x00160e0e
LEA RAX,[0x4b8748]
MOV R14,qword ptr [RAX]
LAB_00160e0e:
OR R14,R8
MOV EDI,dword ptr [RBP + -0x2c]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,RBX
MOV RCX,R13
CALL 0x00128790
CMP RAX,RBX
JNZ 0x00160e3a
LAB_00160e28:
TEST R14B,0x6
JZ 0x00160f1c
XOR R15D,R15D
JMP 0x00160f23
LAB_00160e3a:
MOV R15,RAX
MOV qword ptr [RBP + -0x48],0x0
CALL 0x00128050
MOV qword ptr [RBP + -0x50],RAX
MOV qword ptr [RBP + -0x40],0x0
LAB_00160e56:
MOV R12,R13
MOV RAX,qword ptr [RBP + -0x50]
MOV R13D,dword ptr [RAX]
CALL 0x001624a2
MOV dword ptr [RAX],R13D
CMP R15,-0x1
JZ 0x00160e81
ADD qword ptr [RBP + -0x40],R15
ADD qword ptr [RBP + -0x38],R15
SUB RBX,R15
MOV R13,R12
ADD R13,R15
JMP 0x00160e84
LAB_00160e81:
MOV R13,R12
LAB_00160e84:
CALL 0x001624a2
MOV ECX,R14D
AND ECX,0xffffffdf
CMP dword ptr [RAX + 0xe0],0x0
CMOVNZ R14,RCX
CALL 0x001624a2
CMP dword ptr [RAX],0x1c
JNZ 0x00160eac
TEST R14B,0x20
JZ 0x00160ebe
JMP 0x00160ef5
LAB_00160eac:
CALL 0x001624a2
CMP dword ptr [RAX],0x7a
JNZ 0x00160ebe
MOV EAX,R14D
AND EAX,0x20
JNZ 0x00160ef5
LAB_00160ebe:
LEA RAX,[R15 + -0x1]
CMP RAX,-0x2
JC 0x00160ed2
CALL 0x001624a2
CMP dword ptr [RAX],0x4
JNZ 0x00160f35
LAB_00160ed2:
MOV EDI,dword ptr [RBP + -0x2c]
LAB_00160ed5:
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,RBX
MOV RCX,R13
CALL 0x00128790
MOV R15,RAX
CMP RAX,RBX
JNZ 0x00160e56
JMP 0x00160e28
LAB_00160ef5:
MOV R15D,dword ptr [RBP + -0x2c]
MOV EDI,R15D
CALL 0x001683ec
MOV RDI,RAX
MOV R12,qword ptr [RBP + -0x48]
MOV ESI,R12D
CALL 0x00167d12
INC R12D
MOV qword ptr [RBP + -0x48],R12
MOV EDI,R15D
JMP 0x00160ed5
LAB_00160f1c:
MOV R15,qword ptr [RBP + -0x40]
ADD R15,RBX
LAB_00160f23:
MOV RAX,R15
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00160f35:
TEST R14B,0x6
JZ 0x00160f79
MOV R15,-0x1
TEST R14B,0x1a
JZ 0x00160f23
AND R14D,0x440
OR R14,0x4
MOV EDI,dword ptr [RBP + -0x2c]
CALL 0x001683ec
MOV RBX,RAX
CALL 0x001624a2
MOV ECX,dword ptr [RAX]
MOV EDI,0x3
MOV RSI,R14
MOV RDX,RBX
XOR EAX,EAX
CALL 0x0015bf1f
JMP 0x00160f23
LAB_00160f79:
MOV RBX,R15
JMP 0x00160e28
|
long my_pwrite(int param_1,void *param_2,size_t param_3,__off64_t param_4,ulong param_5)
{
int iVar1;
size_t sVar2;
int *piVar3;
int *piVar4;
long lVar5;
int8 uVar6;
int4 *puVar7;
int iVar8;
ulong uVar9;
long local_48;
void *local_40;
local_48 = 0;
uVar9 = 0;
if ((param_5 & 0x1a) == 0) {
uVar9 = my_global_flags;
}
uVar9 = uVar9 | param_5;
sVar2 = pwrite64(param_1,param_2,param_3,param_4);
if (sVar2 != param_3) {
iVar8 = 0;
piVar3 = __errno_location();
local_48 = 0;
local_40 = param_2;
do {
iVar1 = *piVar3;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar1;
if (sVar2 != 0xffffffffffffffff) {
local_48 = local_48 + sVar2;
local_40 = (void *)((long)local_40 + sVar2);
param_3 = param_3 - sVar2;
param_4 = param_4 + sVar2;
}
lVar5 = _my_thread_var();
if (*(int *)(lVar5 + 0xe0) != 0) {
uVar9 = (ulong)((uint)uVar9 & 0xffffffdf);
}
piVar4 = (int *)_my_thread_var();
if (*piVar4 == 0x1c) {
if ((uVar9 & 0x20) != 0) goto LAB_00160ef5;
LAB_00160ebe:
if ((0xfffffffffffffffd < sVar2 - 1) && (piVar4 = (int *)_my_thread_var(), *piVar4 != 4)) {
param_3 = sVar2;
if ((uVar9 & 6) != 0) {
if ((uVar9 & 0x1a) == 0) {
return -1;
}
uVar6 = my_filename(param_1);
puVar7 = (int4 *)_my_thread_var();
my_error(3,(uint)uVar9 & 0x440 | 4,uVar6,*puVar7);
return -1;
}
break;
}
}
else {
piVar4 = (int *)_my_thread_var();
if ((*piVar4 != 0x7a) || ((uVar9 & 0x20) == 0)) goto LAB_00160ebe;
LAB_00160ef5:
uVar6 = my_filename(param_1);
wait_for_free_space(uVar6,iVar8);
iVar8 = iVar8 + 1;
}
sVar2 = pwrite64(param_1,local_40,param_3,param_4);
} while (sVar2 != param_3);
}
if ((uVar9 & 6) == 0) {
local_48 = local_48 + param_3;
}
else {
local_48 = 0;
}
return local_48;
}
| |
45,657 | my_thread_global_init | eloqsql/mysys/my_thr_init.c | my_bool my_thread_global_init(void)
{
int pth_ret;
/* Normally this should never be called twice */
DBUG_ASSERT(my_thread_global_init_done == 0);
if (my_thread_global_init_done)
return 0;
my_thread_global_init_done= 1;
/*
THR_KEY_mysys is deleted in my_end() as DBUG libraries are using it even
after my_thread_global_end() is called.
my_thr_key_mysys_exist is used to protect against application like QT
that calls my_thread_global_init() + my_thread_global_end() multiple times
without calling my_init() + my_end().
*/
if (!my_thr_key_mysys_exists &&
(pth_ret= pthread_key_create(&THR_KEY_mysys, NULL)) != 0)
{
fprintf(stderr, "Can't initialize threads: error %d\n", pth_ret);
return 1;
}
my_thr_key_mysys_exists= 1;
/* Mutex used by my_thread_init() and after my_thread_destroy_mutex() */
my_thread_init_internal_mutex();
if (my_thread_init())
return 1;
my_thread_init_common_mutex();
return 0;
} | O0 | c | my_thread_global_init:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0x26b5a
cmpb $0x0, 0x35fa37(%rip) # 0x386598
je 0x26b69
movb $0x0, -0x1(%rbp)
jmp 0x26bdc
movb $0x1, 0x35fa28(%rip) # 0x386598
leaq 0x35f75d(%rip), %rax # 0x3862d4
cmpb $0x0, (%rax)
jne 0x26bb5
leaq 0x35fa19(%rip), %rdi # 0x38659c
xorl %eax, %eax
movl %eax, %esi
callq 0x244d0
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
je 0x26bb5
movq 0x1a743d(%rip), %rax # 0x1cdfd8
movq (%rax), %rdi
movl -0x8(%rbp), %edx
leaq 0x52a50(%rip), %rsi # 0x795f8
movb $0x0, %al
callq 0x24400
movb $0x1, -0x1(%rbp)
jmp 0x26bdc
leaq 0x35f718(%rip), %rax # 0x3862d4
movb $0x1, (%rax)
callq 0x26a50
callq 0x26bf0
cmpb $0x0, %al
je 0x26bd3
movb $0x1, -0x1(%rbp)
jmp 0x26bdc
callq 0x26980
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_thread_global_init:
push rbp
mov rbp, rsp
sub rsp, 10h
jmp short $+2
loc_26B5A:
cmp cs:my_thread_global_init_done, 0
jz short loc_26B69
mov [rbp+var_1], 0
jmp short loc_26BDC
loc_26B69:
mov cs:my_thread_global_init_done, 1
lea rax, my_thr_key_mysys_exists
cmp byte ptr [rax], 0
jnz short loc_26BB5
lea rdi, THR_KEY_mysys
xor eax, eax
mov esi, eax
call _pthread_key_create
mov [rbp+var_8], eax
cmp eax, 0
jz short loc_26BB5
mov rax, cs:stderr_ptr
mov rdi, [rax]
mov edx, [rbp+var_8]
lea rsi, aCanTInitialize_0; "Can't initialize threads: error %d\n"
mov al, 0
call _fprintf
mov [rbp+var_1], 1
jmp short loc_26BDC
loc_26BB5:
lea rax, my_thr_key_mysys_exists
mov byte ptr [rax], 1
call my_thread_init_internal_mutex
call my_thread_init
cmp al, 0
jz short loc_26BD3
mov [rbp+var_1], 1
jmp short loc_26BDC
loc_26BD3:
call my_thread_init_common_mutex
mov [rbp+var_1], 0
loc_26BDC:
mov al, [rbp+var_1]
add rsp, 10h
pop rbp
retn
| char my_thread_global_init()
{
int v1; // [rsp+8h] [rbp-8h]
if ( my_thread_global_init_done )
return 0;
my_thread_global_init_done = 1;
if ( my_thr_key_mysys_exists || (v1 = pthread_key_create(&THR_KEY_mysys, 0LL)) == 0 )
{
my_thr_key_mysys_exists = 1;
my_thread_init_internal_mutex();
if ( (unsigned __int8)my_thread_init() )
{
return 1;
}
else
{
my_thread_init_common_mutex();
return 0;
}
}
else
{
fprintf(stderr, "Can't initialize threads: error %d\n", v1);
return 1;
}
}
| my_thread_global_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
JMP 0x00126b5a
LAB_00126b5a:
CMP byte ptr [0x00486598],0x0
JZ 0x00126b69
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00126bdc
LAB_00126b69:
MOV byte ptr [0x00486598],0x1
LEA RAX,[0x4862d4]
CMP byte ptr [RAX],0x0
JNZ 0x00126bb5
LEA RDI,[0x48659c]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x001244d0
MOV dword ptr [RBP + -0x8],EAX
CMP EAX,0x0
JZ 0x00126bb5
MOV RAX,qword ptr [0x002cdfd8]
MOV RDI,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x8]
LEA RSI,[0x1795f8]
MOV AL,0x0
CALL 0x00124400
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00126bdc
LAB_00126bb5:
LEA RAX,[0x4862d4]
MOV byte ptr [RAX],0x1
CALL 0x00126a50
CALL 0x00126bf0
CMP AL,0x0
JZ 0x00126bd3
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00126bdc
LAB_00126bd3:
CALL 0x00126980
MOV byte ptr [RBP + -0x1],0x0
LAB_00126bdc:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x10
POP RBP
RET
|
int1 my_thread_global_init(void)
{
char cVar1;
uint uVar2;
int1 local_9;
if (my_thread_global_init_done == '\0') {
my_thread_global_init_done = '\x01';
if ((my_thr_key_mysys_exists == '\0') &&
(uVar2 = pthread_key_create(&THR_KEY_mysys,(__destr_function *)0x0), uVar2 != 0)) {
fprintf(*(FILE **)PTR_stderr_002cdfd8,"Can\'t initialize threads: error %d\n",(ulong)uVar2);
return 1;
}
my_thr_key_mysys_exists = '\x01';
my_thread_init_internal_mutex();
cVar1 = my_thread_init();
if (cVar1 == '\0') {
my_thread_init_common_mutex();
local_9 = 0;
}
else {
local_9 = 1;
}
}
else {
local_9 = 0;
}
return local_9;
}
| |
45,658 | my_thread_global_init | eloqsql/mysys/my_thr_init.c | my_bool my_thread_global_init(void)
{
int pth_ret;
/* Normally this should never be called twice */
DBUG_ASSERT(my_thread_global_init_done == 0);
if (my_thread_global_init_done)
return 0;
my_thread_global_init_done= 1;
/*
THR_KEY_mysys is deleted in my_end() as DBUG libraries are using it even
after my_thread_global_end() is called.
my_thr_key_mysys_exist is used to protect against application like QT
that calls my_thread_global_init() + my_thread_global_end() multiple times
without calling my_init() + my_end().
*/
if (!my_thr_key_mysys_exists &&
(pth_ret= pthread_key_create(&THR_KEY_mysys, NULL)) != 0)
{
fprintf(stderr, "Can't initialize threads: error %d\n", pth_ret);
return 1;
}
my_thr_key_mysys_exists= 1;
/* Mutex used by my_thread_init() and after my_thread_destroy_mutex() */
my_thread_init_internal_mutex();
if (my_thread_init())
return 1;
my_thread_init_common_mutex();
return 0;
} | O3 | c | my_thread_global_init:
cmpb $0x0, 0x3400e1(%rip) # 0x366a48
je 0x2696c
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movb $0x1, 0x3400cf(%rip) # 0x366a48
leaq 0x33fe04(%rip), %rbx # 0x366784
cmpb $0x0, (%rbx)
je 0x269a3
movb $0x1, (%rbx)
callq 0x267bb
callq 0x269dd
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x269d6
callq 0x2662e
xorl %eax, %eax
jmp 0x269d6
leaq 0x3400a2(%rip), %rdi # 0x366a4c
xorl %esi, %esi
callq 0x24500
testl %eax, %eax
je 0x26985
movq 0x2c8614(%rip), %rcx # 0x2eefd0
movq (%rcx), %rdi
leaq 0x35c4a(%rip), %rdx # 0x5c610
movl $0x1, %esi
movl %eax, %ecx
xorl %eax, %eax
callq 0x24540
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| my_thread_global_init:
cmp cs:my_thread_global_init_done, 0
jz short loc_2696C
xor eax, eax
retn
loc_2696C:
push rbp
mov rbp, rsp
push rbx
push rax
mov cs:my_thread_global_init_done, 1
lea rbx, my_thr_key_mysys_exists
cmp byte ptr [rbx], 0
jz short loc_269A3
loc_26985:
mov byte ptr [rbx], 1
call my_thread_init_internal_mutex
call my_thread_init
mov ecx, eax
mov al, 1
test cl, cl
jnz short loc_269D6
call my_thread_init_common_mutex
xor eax, eax
jmp short loc_269D6
loc_269A3:
lea rdi, THR_KEY_mysys
xor esi, esi
call _pthread_key_create
test eax, eax
jz short loc_26985
mov rcx, cs:stderr_ptr
mov rdi, [rcx]
lea rdx, aCanTInitialize_0; "Can't initialize threads: error %d\n"
mov esi, 1
mov ecx, eax
xor eax, eax
call ___fprintf_chk
mov al, 1
loc_269D6:
add rsp, 8
pop rbx
pop rbp
retn
| char my_thread_global_init(void *a1)
{
char result; // al
char v2; // cl
int v3; // eax
if ( my_thread_global_init_done )
return 0;
my_thread_global_init_done = 1;
if ( my_thr_key_mysys_exists || (a1 = &THR_KEY_mysys, (v3 = pthread_key_create(&THR_KEY_mysys, 0LL)) == 0) )
{
my_thr_key_mysys_exists = 1;
my_thread_init_internal_mutex();
v2 = my_thread_init(a1);
result = 1;
if ( !v2 )
{
my_thread_init_common_mutex();
return 0;
}
}
else
{
__fprintf_chk(stderr, 1LL, "Can't initialize threads: error %d\n", v3);
return 1;
}
return result;
}
| my_thread_global_init:
CMP byte ptr [0x00466a48],0x0
JZ 0x0012696c
XOR EAX,EAX
RET
LAB_0012696c:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV byte ptr [0x00466a48],0x1
LEA RBX,[0x466784]
CMP byte ptr [RBX],0x0
JZ 0x001269a3
LAB_00126985:
MOV byte ptr [RBX],0x1
CALL 0x001267bb
CALL 0x001269dd
MOV ECX,EAX
MOV AL,0x1
TEST CL,CL
JNZ 0x001269d6
CALL 0x0012662e
XOR EAX,EAX
JMP 0x001269d6
LAB_001269a3:
LEA RDI,[0x466a4c]
XOR ESI,ESI
CALL 0x00124500
TEST EAX,EAX
JZ 0x00126985
MOV RCX,qword ptr [0x003eefd0]
MOV RDI,qword ptr [RCX]
LEA RDX,[0x15c610]
MOV ESI,0x1
MOV ECX,EAX
XOR EAX,EAX
CALL 0x00124540
MOV AL,0x1
LAB_001269d6:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
bool my_thread_global_init(void)
{
char cVar1;
int iVar2;
if (my_thread_global_init_done != '\0') {
return false;
}
my_thread_global_init_done = 1;
if ((my_thr_key_mysys_exists == '\0') &&
(iVar2 = pthread_key_create(&THR_KEY_mysys,(__destr_function *)0x0), iVar2 != 0)) {
__fprintf_chk(*(int8 *)PTR_stderr_003eefd0,1,"Can\'t initialize threads: error %d\n",iVar2
);
return true;
}
my_thr_key_mysys_exists = 1;
my_thread_init_internal_mutex();
cVar1 = my_thread_init();
if (cVar1 == '\0') {
my_thread_init_common_mutex();
}
return cVar1 != '\0';
}
| |
45,659 | (anonymous namespace)::msgpack23_ArrayTypePacking_Test::msgpack23_ArrayTypePacking_Test() | msgpack23/tests/type_packing_tests.cpp | TEST(msgpack23, ArrayTypePacking) {
msgpack23::Packer packer{};
std::list<std::string> const expected{"one", "two", "three"};
std::vector<std::byte> const expected_data{
static_cast<std::byte>(0b10010000 | 3),
static_cast<std::byte>(0b10100000 | 3),
static_cast<std::byte>('o'),
static_cast<std::byte>('n'),
static_cast<std::byte>('e'),
static_cast<std::byte>(0b10100000 | 3),
static_cast<std::byte>('t'),
static_cast<std::byte>('w'),
static_cast<std::byte>('o'),
static_cast<std::byte>(0b10100000 | 5),
static_cast<std::byte>('t'),
static_cast<std::byte>('h'),
static_cast<std::byte>('r'),
static_cast<std::byte>('e'),
static_cast<std::byte>('e'),
};
auto const data = packer(expected);
EXPECT_EQ(data, expected_data);
msgpack23::Unpacker unpacker{data};
std::list<std::string> actual{};
unpacker(actual);
EXPECT_EQ(expected, actual);
} | O0 | cpp | (anonymous namespace)::msgpack23_ArrayTypePacking_Test::msgpack23_ArrayTypePacking_Test():
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x9f1a0
movq -0x10(%rbp), %rax
leaq 0xbca9c(%rip), %rcx # 0x1337e0
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN12_GLOBAL__N_131msgpack23_ArrayTypePacking_TestC2Ev:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]; this
mov [rbp+var_10], rdi
call _ZN7testing4TestC2Ev; testing::Test::Test(void)
mov rax, [rbp+var_10]
lea rcx, _ZTVN12_GLOBAL__N_131msgpack23_ArrayTypePacking_TestE; `vtable for'`anonymous namespace'::msgpack23_ArrayTypePacking_Test
add rcx, 10h
mov [rax], rcx
add rsp, 10h
pop rbp
retn
| _anonymous_namespace_::msgpack23_ArrayTypePacking_Test * `anonymous namespace'::msgpack23_ArrayTypePacking_Test::msgpack23_ArrayTypePacking_Test(
_anonymous_namespace_::msgpack23_ArrayTypePacking_Test *this)
{
_anonymous_namespace_::msgpack23_ArrayTypePacking_Test *result; // rax
testing::Test::Test(this);
result = this;
*(_QWORD *)this = &`vtable for'`anonymous namespace'::msgpack23_ArrayTypePacking_Test + 2;
return result;
}
| msgpack23_ArrayTypePacking_Test:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RDI
CALL 0x0019f1a0
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x2337e0]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
ADD RSP,0x10
POP RBP
RET
|
/* (anonymous namespace)::msgpack23_ArrayTypePacking_Test::msgpack23_ArrayTypePacking_Test() */
void __thiscall
(anonymous_namespace)::msgpack23_ArrayTypePacking_Test::msgpack23_ArrayTypePacking_Test
(msgpack23_ArrayTypePacking_Test *this)
{
testing::Test::Test((Test *)this);
*(int ***)this = &PTR__msgpack23_ArrayTypePacking_Test_002337f0;
return;
}
| |
45,660 | ScanDirectoryFilesRecursively | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rcore.c | static void ScanDirectoryFilesRecursively(const char *basePath, FilePathList *files, const char *filter)
{
char path[MAX_FILEPATH_LENGTH] = { 0 };
memset(path, 0, MAX_FILEPATH_LENGTH);
struct dirent *dp = NULL;
DIR *dir = opendir(basePath);
if (dir != NULL)
{
while (((dp = readdir(dir)) != NULL) && (files->count < files->capacity))
{
if ((strcmp(dp->d_name, ".") != 0) && (strcmp(dp->d_name, "..") != 0))
{
// Construct new path from our base path
#if defined(_WIN32)
sprintf(path, "%s\\%s", basePath, dp->d_name);
#else
sprintf(path, "%s/%s", basePath, dp->d_name);
#endif
if (IsPathFile(path))
{
if (filter != NULL)
{
if (IsFileExtension(path, filter))
{
strcpy(files->paths[files->count], path);
files->count++;
}
}
else
{
strcpy(files->paths[files->count], path);
files->count++;
}
if (files->count >= files->capacity)
{
TRACELOG(LOG_WARNING, "FILEIO: Maximum filepath scan capacity reached (%i files)", files->capacity);
break;
}
}
else
{
if ((filter != NULL) && (TextFindIndex(filter, DIRECTORY_FILTER_TAG) >= 0))
{
strcpy(files->paths[files->count], path);
files->count++;
}
if (files->count >= files->capacity)
{
TRACELOG(LOG_WARNING, "FILEIO: Maximum filepath scan capacity reached (%i files)", files->capacity);
break;
}
ScanDirectoryFilesRecursively(path, files, filter);
}
}
}
closedir(dir);
}
else TRACELOG(LOG_WARNING, "FILEIO: Directory cannot be opened (%s)", basePath);
} | O0 | c | ScanDirectoryFilesRecursively:
pushq %rbp
movq %rsp, %rbp
subq $0x1040, %rsp # imm = 0x1040
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x1020(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx # imm = 0x1000
callq 0xa2d0
leaq -0x1020(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx # imm = 0x1000
callq 0xa2d0
movq $0x0, -0x1028(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa810
movq %rax, -0x1030(%rbp)
cmpq $0x0, -0x1030(%rbp)
je 0xd1d0e
jmp 0xd1b08
movq -0x1030(%rbp), %rdi
callq 0xa860
movq %rax, %rcx
movq %rcx, -0x1028(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x1031(%rbp)
je 0xd1b42
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
setb %al
movb %al, -0x1031(%rbp)
movb -0x1031(%rbp), %al
testb $0x1, %al
jne 0xd1b51
jmp 0xd1d00
movq -0x1028(%rbp), %rdi
addq $0x13, %rdi
leaq 0xec993(%rip), %rsi # 0x1be4f6
callq 0xa750
cmpl $0x0, %eax
je 0xd1cfb
movq -0x1028(%rbp), %rdi
addq $0x13, %rdi
leaq 0xec972(%rip), %rsi # 0x1be4f5
callq 0xa750
cmpl $0x0, %eax
je 0xd1cfb
leaq -0x1020(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x1028(%rbp), %rcx
addq $0x13, %rcx
leaq 0xe4069(%rip), %rsi # 0x1b5c17
movb $0x0, %al
callq 0xa0f0
leaq -0x1020(%rbp), %rdi
callq 0xd1f50
testb $0x1, %al
jne 0xd1bca
jmp 0xd1c73
cmpq $0x0, -0x18(%rbp)
je 0xd1c15
leaq -0x1020(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd10c0
testb $0x1, %al
jne 0xd1be7
jmp 0xd1c13
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
movq (%rax,%rcx,8), %rdi
leaq -0x1020(%rbp), %rsi
callq 0xa4a0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
jmp 0xd1c41
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
movq (%rax,%rcx,8), %rdi
leaq -0x1020(%rbp), %rsi
callq 0xa4a0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jb 0xd1c6e
movq -0x10(%rbp), %rax
movl (%rax), %edx
movl $0x4, %edi
leaq 0xeaac6(%rip), %rsi # 0x1bc728
movb $0x0, %al
callq 0x182c40
jmp 0xd1d00
jmp 0xd1cf9
cmpq $0x0, -0x18(%rbp)
je 0xd1cbb
movq -0x18(%rbp), %rdi
leaq 0xeaa77(%rip), %rsi # 0x1bc6fc
callq 0xe7460
cmpl $0x0, %eax
jl 0xd1cbb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
movq (%rax,%rcx,8), %rdi
leaq -0x1020(%rbp), %rsi
callq 0xa4a0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jb 0xd1ce5
movq -0x10(%rbp), %rax
movl (%rax), %edx
movl $0x4, %edi
leaq 0xeaa4c(%rip), %rsi # 0x1bc728
movb $0x0, %al
callq 0x182c40
jmp 0xd1d00
leaq -0x1020(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xd1aa0
jmp 0xd1cfb
jmp 0xd1b08
movq -0x1030(%rbp), %rdi
callq 0xa910
jmp 0xd1d25
movq -0x8(%rbp), %rdx
movl $0x4, %edi
leaq 0xea9e2(%rip), %rsi # 0x1bc700
movb $0x0, %al
callq 0x182c40
addq $0x1040, %rsp # imm = 0x1040
popq %rbp
retq
nop
| ScanDirectoryFilesRecursively:
push rbp
mov rbp, rsp
sub rsp, 1040h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
lea rdi, [rbp+var_1020]
xor esi, esi
mov edx, 1000h
call _memset
lea rdi, [rbp+var_1020]
xor esi, esi
mov edx, 1000h
call _memset
mov [rbp+var_1028], 0
mov rdi, [rbp+var_8]
call _opendir
mov [rbp+var_1030], rax
cmp [rbp+var_1030], 0
jz loc_D1D0E
jmp short $+2
loc_D1B08:
mov rdi, [rbp+var_1030]
call _readdir
mov rcx, rax
mov [rbp+var_1028], rcx
xor eax, eax
cmp rcx, 0
mov [rbp+var_1031], al
jz short loc_D1B42
mov rax, [rbp+var_10]
mov eax, [rax+4]
mov rcx, [rbp+var_10]
cmp eax, [rcx]
setb al
mov [rbp+var_1031], al
loc_D1B42:
mov al, [rbp+var_1031]
test al, 1
jnz short loc_D1B51
jmp loc_D1D00
loc_D1B51:
mov rdi, [rbp+var_1028]
add rdi, 13h
lea rsi, asc_1BE4F4+2; "."
call _strcmp
cmp eax, 0
jz loc_D1CFB
mov rdi, [rbp+var_1028]
add rdi, 13h
lea rsi, asc_1BE4F4+1; ".."
call _strcmp
cmp eax, 0
jz loc_D1CFB
lea rdi, [rbp+var_1020]
mov rdx, [rbp+var_8]
mov rcx, [rbp+var_1028]
add rcx, 13h
lea rsi, aSS_0; "%s/%s"
mov al, 0
call _sprintf
lea rdi, [rbp+var_1020]
call IsPathFile
test al, 1
jnz short loc_D1BCA
jmp loc_D1C73
loc_D1BCA:
cmp [rbp+var_18], 0
jz short loc_D1C15
lea rdi, [rbp+var_1020]
mov rsi, [rbp+var_18]
call IsFileExtension
test al, 1
jnz short loc_D1BE7
jmp short loc_D1C13
loc_D1BE7:
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov rcx, [rbp+var_10]
mov ecx, [rcx+4]
mov rdi, [rax+rcx*8]
lea rsi, [rbp+var_1020]
call _strcpy
mov rax, [rbp+var_10]
mov ecx, [rax+4]
add ecx, 1
mov [rax+4], ecx
loc_D1C13:
jmp short loc_D1C41
loc_D1C15:
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov rcx, [rbp+var_10]
mov ecx, [rcx+4]
mov rdi, [rax+rcx*8]
lea rsi, [rbp+var_1020]
call _strcpy
mov rax, [rbp+var_10]
mov ecx, [rax+4]
add ecx, 1
mov [rax+4], ecx
loc_D1C41:
mov rax, [rbp+var_10]
mov eax, [rax+4]
mov rcx, [rbp+var_10]
cmp eax, [rcx]
jb short loc_D1C6E
mov rax, [rbp+var_10]
mov edx, [rax]
mov edi, 4
lea rsi, aFileioMaximumF; "FILEIO: Maximum filepath scan capacity "...
mov al, 0
call TraceLog
jmp loc_D1D00
loc_D1C6E:
jmp loc_D1CF9
loc_D1C73:
cmp [rbp+var_18], 0
jz short loc_D1CBB
mov rdi, [rbp+var_18]
lea rsi, aDir; "DIR"
call TextFindIndex
cmp eax, 0
jl short loc_D1CBB
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov rcx, [rbp+var_10]
mov ecx, [rcx+4]
mov rdi, [rax+rcx*8]
lea rsi, [rbp+var_1020]
call _strcpy
mov rax, [rbp+var_10]
mov ecx, [rax+4]
add ecx, 1
mov [rax+4], ecx
loc_D1CBB:
mov rax, [rbp+var_10]
mov eax, [rax+4]
mov rcx, [rbp+var_10]
cmp eax, [rcx]
jb short loc_D1CE5
mov rax, [rbp+var_10]
mov edx, [rax]
mov edi, 4
lea rsi, aFileioMaximumF; "FILEIO: Maximum filepath scan capacity "...
mov al, 0
call TraceLog
jmp short loc_D1D00
loc_D1CE5:
lea rdi, [rbp+var_1020]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call ScanDirectoryFilesRecursively
loc_D1CF9:
jmp short $+2
loc_D1CFB:
jmp loc_D1B08
loc_D1D00:
mov rdi, [rbp+var_1030]
call _closedir
jmp short loc_D1D25
loc_D1D0E:
mov rdx, [rbp+var_8]
mov edi, 4
lea rsi, aFileioDirector; "FILEIO: Directory cannot be opened (%s)"
mov al, 0
call TraceLog
loc_D1D25:
add rsp, 1040h
pop rbp
retn
| long long ScanDirectoryFilesRecursively(const char *a1, long long a2, long long a3)
{
int v3; // ecx
int v4; // r8d
int v5; // r9d
int v6; // r8d
int v7; // r9d
int v8; // ecx
bool v10; // [rsp+Fh] [rbp-1031h]
long long v11; // [rsp+10h] [rbp-1030h]
long long v12; // [rsp+18h] [rbp-1028h]
_BYTE v13[4104]; // [rsp+20h] [rbp-1020h] BYREF
long long v14; // [rsp+1028h] [rbp-18h]
long long v15; // [rsp+1030h] [rbp-10h]
const char *v16; // [rsp+1038h] [rbp-8h]
v16 = a1;
v15 = a2;
v14 = a3;
memset(v13, 0LL, 4096LL);
memset(v13, 0LL, 4096LL);
v11 = opendir(v16);
if ( !v11 )
return TraceLog(4, (unsigned int)"FILEIO: Directory cannot be opened (%s)", (_DWORD)v16, v3, v4, v5);
while ( 1 )
{
v12 = readdir(v11);
v10 = 0;
if ( v12 )
v10 = *(_DWORD *)(v15 + 4) < *(_DWORD *)v15;
if ( !v10 )
return closedir(v11);
if ( (unsigned int)strcmp(v12 + 19, ".") && (unsigned int)strcmp(v12 + 19, "..") )
{
sprintf(v13, "%s/%s", v16, (const char *)(v12 + 19));
if ( (IsPathFile(v13) & 1) != 0 )
{
if ( v14 )
{
if ( (IsFileExtension((long long)v13, v14) & 1) != 0 )
{
strcpy(*(_QWORD *)(*(_QWORD *)(v15 + 8) + 8LL * *(unsigned int *)(v15 + 4)), v13);
++*(_DWORD *)(v15 + 4);
}
}
else
{
strcpy(*(_QWORD *)(*(_QWORD *)(v15 + 8) + 8LL * *(unsigned int *)(v15 + 4)), v13);
++*(_DWORD *)(v15 + 4);
}
v8 = v15;
if ( *(_DWORD *)(v15 + 4) >= *(_DWORD *)v15 )
goto LABEL_14;
}
else
{
if ( v14 && (int)TextFindIndex(v14, "DIR") >= 0 )
{
strcpy(*(_QWORD *)(*(_QWORD *)(v15 + 8) + 8LL * *(unsigned int *)(v15 + 4)), v13);
++*(_DWORD *)(v15 + 4);
}
v8 = v15;
if ( *(_DWORD *)(v15 + 4) >= *(_DWORD *)v15 )
{
LABEL_14:
TraceLog(
4,
(unsigned int)"FILEIO: Maximum filepath scan capacity reached (%i files)",
*(_DWORD *)v15,
v8,
v6,
v7);
return closedir(v11);
}
ScanDirectoryFilesRecursively(v13, v15, v14);
}
}
}
}
| ScanDirectoryFilesRecursively:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1040
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
LEA RDI,[RBP + -0x1020]
XOR ESI,ESI
MOV EDX,0x1000
CALL 0x0010a2d0
LEA RDI,[RBP + -0x1020]
XOR ESI,ESI
MOV EDX,0x1000
CALL 0x0010a2d0
MOV qword ptr [RBP + -0x1028],0x0
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0010a810
MOV qword ptr [RBP + -0x1030],RAX
CMP qword ptr [RBP + -0x1030],0x0
JZ 0x001d1d0e
JMP 0x001d1b08
LAB_001d1b08:
MOV RDI,qword ptr [RBP + -0x1030]
CALL 0x0010a860
MOV RCX,RAX
MOV qword ptr [RBP + -0x1028],RCX
XOR EAX,EAX
CMP RCX,0x0
MOV byte ptr [RBP + -0x1031],AL
JZ 0x001d1b42
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x4]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX]
SETC AL
MOV byte ptr [RBP + -0x1031],AL
LAB_001d1b42:
MOV AL,byte ptr [RBP + -0x1031]
TEST AL,0x1
JNZ 0x001d1b51
JMP 0x001d1d00
LAB_001d1b51:
MOV RDI,qword ptr [RBP + -0x1028]
ADD RDI,0x13
LEA RSI,[0x2be4f6]
CALL 0x0010a750
CMP EAX,0x0
JZ 0x001d1cfb
MOV RDI,qword ptr [RBP + -0x1028]
ADD RDI,0x13
LEA RSI,[0x2be4f5]
CALL 0x0010a750
CMP EAX,0x0
JZ 0x001d1cfb
LEA RDI,[RBP + -0x1020]
MOV RDX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x1028]
ADD RCX,0x13
LEA RSI,[0x2b5c17]
MOV AL,0x0
CALL 0x0010a0f0
LEA RDI,[RBP + -0x1020]
CALL 0x001d1f50
TEST AL,0x1
JNZ 0x001d1bca
JMP 0x001d1c73
LAB_001d1bca:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001d1c15
LEA RDI,[RBP + -0x1020]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001d10c0
TEST AL,0x1
JNZ 0x001d1be7
JMP 0x001d1c13
LAB_001d1be7:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x4]
MOV RDI,qword ptr [RAX + RCX*0x8]
LEA RSI,[RBP + -0x1020]
CALL 0x0010a4a0
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x4]
ADD ECX,0x1
MOV dword ptr [RAX + 0x4],ECX
LAB_001d1c13:
JMP 0x001d1c41
LAB_001d1c15:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x4]
MOV RDI,qword ptr [RAX + RCX*0x8]
LEA RSI,[RBP + -0x1020]
CALL 0x0010a4a0
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x4]
ADD ECX,0x1
MOV dword ptr [RAX + 0x4],ECX
LAB_001d1c41:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x4]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX]
JC 0x001d1c6e
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX]
MOV EDI,0x4
LEA RSI,[0x2bc728]
MOV AL,0x0
CALL 0x00282c40
JMP 0x001d1d00
LAB_001d1c6e:
JMP 0x001d1cf9
LAB_001d1c73:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001d1cbb
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x2bc6fc]
CALL 0x001e7460
CMP EAX,0x0
JL 0x001d1cbb
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x4]
MOV RDI,qword ptr [RAX + RCX*0x8]
LEA RSI,[RBP + -0x1020]
CALL 0x0010a4a0
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x4]
ADD ECX,0x1
MOV dword ptr [RAX + 0x4],ECX
LAB_001d1cbb:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x4]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX]
JC 0x001d1ce5
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX]
MOV EDI,0x4
LEA RSI,[0x2bc728]
MOV AL,0x0
CALL 0x00282c40
JMP 0x001d1d00
LAB_001d1ce5:
LEA RDI,[RBP + -0x1020]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x001d1aa0
LAB_001d1cf9:
JMP 0x001d1cfb
LAB_001d1cfb:
JMP 0x001d1b08
LAB_001d1d00:
MOV RDI,qword ptr [RBP + -0x1030]
CALL 0x0010a910
JMP 0x001d1d25
LAB_001d1d0e:
MOV RDX,qword ptr [RBP + -0x8]
MOV EDI,0x4
LEA RSI,[0x2bc700]
MOV AL,0x0
CALL 0x00282c40
LAB_001d1d25:
ADD RSP,0x1040
POP RBP
RET
|
void ScanDirectoryFilesRecursively(char *param_1,uint *param_2,long param_3)
{
int iVar1;
DIR *__dirp;
dirent *pdVar2;
ulong uVar3;
bool bVar4;
char local_1028 [4104];
long local_20;
uint *local_18;
char *local_10;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
memset(local_1028,0,0x1000);
memset(local_1028,0,0x1000);
__dirp = opendir(local_10);
if (__dirp == (DIR *)0x0) {
TraceLog(4,"FILEIO: Directory cannot be opened (%s)",local_10);
}
else {
do {
while( true ) {
do {
pdVar2 = readdir(__dirp);
bVar4 = false;
if (pdVar2 != (dirent *)0x0) {
bVar4 = local_18[1] < *local_18;
}
if (!bVar4) goto LAB_001d1d00;
iVar1 = strcmp(pdVar2->d_name,".");
} while ((iVar1 == 0) || (iVar1 = strcmp(pdVar2->d_name,".."), iVar1 == 0));
sprintf(local_1028,"%s/%s",local_10,pdVar2->d_name);
uVar3 = IsPathFile(local_1028);
if ((uVar3 & 1) != 0) break;
if ((local_20 != 0) && (iVar1 = TextFindIndex(local_20,&DAT_002bc6fc), -1 < iVar1)) {
strcpy(*(char **)(*(long *)(local_18 + 2) + (ulong)local_18[1] * 8),local_1028);
local_18[1] = local_18[1] + 1;
}
if (*local_18 <= local_18[1]) {
TraceLog(4,"FILEIO: Maximum filepath scan capacity reached (%i files)",*local_18);
goto LAB_001d1d00;
}
ScanDirectoryFilesRecursively(local_1028,local_18,local_20);
}
if (local_20 == 0) {
strcpy(*(char **)(*(long *)(local_18 + 2) + (ulong)local_18[1] * 8),local_1028);
local_18[1] = local_18[1] + 1;
}
else {
uVar3 = IsFileExtension(local_1028,local_20);
if ((uVar3 & 1) != 0) {
strcpy(*(char **)(*(long *)(local_18 + 2) + (ulong)local_18[1] * 8),local_1028);
local_18[1] = local_18[1] + 1;
}
}
} while (local_18[1] < *local_18);
TraceLog(4,"FILEIO: Maximum filepath scan capacity reached (%i files)",*local_18);
LAB_001d1d00:
closedir(__dirp);
}
return;
}
| |
45,661 | ScanDirectoryFilesRecursively | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rcore.c | static void ScanDirectoryFilesRecursively(const char *basePath, FilePathList *files, const char *filter)
{
char path[MAX_FILEPATH_LENGTH] = { 0 };
memset(path, 0, MAX_FILEPATH_LENGTH);
struct dirent *dp = NULL;
DIR *dir = opendir(basePath);
if (dir != NULL)
{
while (((dp = readdir(dir)) != NULL) && (files->count < files->capacity))
{
if ((strcmp(dp->d_name, ".") != 0) && (strcmp(dp->d_name, "..") != 0))
{
// Construct new path from our base path
#if defined(_WIN32)
sprintf(path, "%s\\%s", basePath, dp->d_name);
#else
sprintf(path, "%s/%s", basePath, dp->d_name);
#endif
if (IsPathFile(path))
{
if (filter != NULL)
{
if (IsFileExtension(path, filter))
{
strcpy(files->paths[files->count], path);
files->count++;
}
}
else
{
strcpy(files->paths[files->count], path);
files->count++;
}
if (files->count >= files->capacity)
{
TRACELOG(LOG_WARNING, "FILEIO: Maximum filepath scan capacity reached (%i files)", files->capacity);
break;
}
}
else
{
if ((filter != NULL) && (TextFindIndex(filter, DIRECTORY_FILTER_TAG) >= 0))
{
strcpy(files->paths[files->count], path);
files->count++;
}
if (files->count >= files->capacity)
{
TRACELOG(LOG_WARNING, "FILEIO: Maximum filepath scan capacity reached (%i files)", files->capacity);
break;
}
ScanDirectoryFilesRecursively(path, files, filter);
}
}
}
closedir(dir);
}
else TRACELOG(LOG_WARNING, "FILEIO: Directory cannot be opened (%s)", basePath);
} | O2 | c | ScanDirectoryFilesRecursively:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1008, %rsp # imm = 0x1008
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %rsp, %rdi
movl $0x1000, %edx # imm = 0x1000
xorl %esi, %esi
callq 0x92c0
movq %rbx, %rdi
callq 0x9800
testq %rax, %rax
je 0x63dac
movq %rax, %r15
leaq 0x62666(%rip), %r13 # 0xc630b
movq %rsp, %rbp
movq %r15, %rdi
callq 0x9850
testq %rax, %rax
je 0x63de2
movl 0x4(%r12), %ecx
cmpl (%r12), %ecx
jae 0x63de2
cmpb $0x2e, 0x13(%rax)
jne 0x63ce0
cmpb $0x0, 0x14(%rax)
je 0x63ca8
cmpb $0x2e, 0x14(%rax)
jne 0x63ce0
cmpb $0x0, 0x15(%rax)
je 0x63ca8
addq $0x13, %rax
movq %rbp, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x90d0
movq %rbp, %rdi
callq 0x63f36
testb %al, %al
je 0x63d1e
testq %r14, %r14
je 0x63d5a
movq %rbp, %rdi
movq %r14, %rsi
callq 0x63627
movl 0x4(%r12), %ecx
testb %al, %al
jne 0x63d5f
jmp 0x63d7e
testq %r14, %r14
je 0x63d8c
movq %r14, %rdi
leaq 0x690a3(%rip), %rsi # 0xccdd0
callq 0x7289e
movl 0x4(%r12), %ecx
testl %eax, %eax
js 0x63d91
movq 0x8(%r12), %rax
movq (%rax,%rcx,8), %rdi
movq %rbp, %rsi
callq 0x94a0
movl 0x4(%r12), %ecx
incl %ecx
movl %ecx, 0x4(%r12)
jmp 0x63d91
movl 0x4(%r12), %ecx
movq 0x8(%r12), %rax
movl %ecx, %ecx
movq (%rax,%rcx,8), %rdi
movq %rbp, %rsi
callq 0x94a0
movl 0x4(%r12), %ecx
incl %ecx
movl %ecx, 0x4(%r12)
movl (%r12), %edx
cmpl %edx, %ecx
jb 0x63ca8
jmp 0x63dd1
movl 0x4(%r12), %ecx
movl (%r12), %edx
cmpl %edx, %ecx
jae 0x63dd1
movq %rbp, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x63c61
jmp 0x63ca8
leaq 0x69021(%rip), %rsi # 0xccdd4
pushq $0x4
popq %rdi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x1008, %rsp # imm = 0x1008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa128b
leaq 0x69024(%rip), %rsi # 0xccdfc
pushq $0x4
popq %rdi
xorl %eax, %eax
callq 0xa128b
movq %r15, %rdi
callq 0x98f0
addq $0x1008, %rsp # imm = 0x1008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ScanDirectoryFilesRecursively:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1008h
mov r14, rdx
mov r12, rsi
mov rbx, rdi
mov rdi, rsp
mov edx, 1000h
xor esi, esi
call _memset
mov rdi, rbx
call _opendir
test rax, rax
jz loc_63DAC
mov r15, rax
lea r13, aSS_0; "%s/%s"
mov rbp, rsp
loc_63CA8:
mov rdi, r15
call _readdir
test rax, rax
jz loc_63DE2
mov ecx, [r12+4]
cmp ecx, [r12]
jnb loc_63DE2
cmp byte ptr [rax+13h], 2Eh ; '.'
jnz short loc_63CE0
cmp byte ptr [rax+14h], 0
jz short loc_63CA8
cmp byte ptr [rax+14h], 2Eh ; '.'
jnz short loc_63CE0
cmp byte ptr [rax+15h], 0
jz short loc_63CA8
loc_63CE0:
add rax, 13h
mov rdi, rbp
mov rsi, r13
mov rdx, rbx
mov rcx, rax
xor eax, eax
call _sprintf
mov rdi, rbp
call IsPathFile
test al, al
jz short loc_63D1E
test r14, r14
jz short loc_63D5A
mov rdi, rbp
mov rsi, r14
call IsFileExtension
mov ecx, [r12+4]
test al, al
jnz short loc_63D5F
jmp short loc_63D7E
loc_63D1E:
test r14, r14
jz short loc_63D8C
mov rdi, r14
lea rsi, aDir; "DIR"
call TextFindIndex
mov ecx, [r12+4]
test eax, eax
js short loc_63D91
mov rax, [r12+8]
mov rdi, [rax+rcx*8]
mov rsi, rbp
call _strcpy
mov ecx, [r12+4]
inc ecx
mov [r12+4], ecx
jmp short loc_63D91
loc_63D5A:
mov ecx, [r12+4]
loc_63D5F:
mov rax, [r12+8]
mov ecx, ecx
mov rdi, [rax+rcx*8]
mov rsi, rbp
call _strcpy
mov ecx, [r12+4]
inc ecx
mov [r12+4], ecx
loc_63D7E:
mov edx, [r12]
cmp ecx, edx
jb loc_63CA8
jmp short loc_63DD1
loc_63D8C:
mov ecx, [r12+4]
loc_63D91:
mov edx, [r12]
cmp ecx, edx
jnb short loc_63DD1
mov rdi, rbp
mov rsi, r12
mov rdx, r14
call ScanDirectoryFilesRecursively
jmp loc_63CA8
loc_63DAC:
lea rsi, aFileioDirector; "FILEIO: Directory cannot be opened (%s)"
push 4
pop rdi
mov rdx, rbx
xor eax, eax
add rsp, 1008h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp TraceLog
loc_63DD1:
lea rsi, aFileioMaximumF; "FILEIO: Maximum filepath scan capacity "...
push 4
pop rdi
xor eax, eax
call TraceLog
loc_63DE2:
mov rdi, r15
call _closedir
add rsp, 1008h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ScanDirectoryFilesRecursively(const char *a1, int *a2, long long a3)
{
long long v4; // rax
int v5; // ecx
int v6; // r8d
int v7; // r9d
long long v8; // r15
long long v9; // rax
int v10; // r8d
int v11; // r9d
char v12; // al
long long v13; // rcx
int Index; // eax
int v15; // edx
_BYTE v17[4152]; // [rsp+0h] [rbp-1038h] BYREF
memset(v17, 0LL, 4096LL);
v4 = opendir(a1);
if ( !v4 )
return TraceLog(4, (unsigned int)"FILEIO: Directory cannot be opened (%s)", (_DWORD)a1, v5, v6, v7);
v8 = v4;
while ( 1 )
{
v9 = readdir(v8);
if ( !v9 || a2[1] >= (unsigned int)*a2 )
return closedir(v8);
if ( *(_BYTE *)(v9 + 19) != 46 || *(_BYTE *)(v9 + 20) && (*(_BYTE *)(v9 + 20) != 46 || *(_BYTE *)(v9 + 21)) )
{
sprintf(v17, "%s/%s", a1, (const char *)(v9 + 19));
if ( (unsigned __int8)IsPathFile(v17) )
{
if ( a3 )
{
v12 = IsFileExtension((long long)v17, a3);
LODWORD(v13) = a2[1];
if ( !v12 )
goto LABEL_18;
}
else
{
LODWORD(v13) = a2[1];
}
strcpy(*(_QWORD *)(*((_QWORD *)a2 + 1) + 8LL * (unsigned int)v13), v17);
LODWORD(v13) = a2[1] + 1;
a2[1] = v13;
LABEL_18:
v15 = *a2;
if ( (unsigned int)v13 >= *a2 )
goto LABEL_24;
}
else
{
if ( a3 )
{
Index = TextFindIndex(a3, "DIR");
v13 = (unsigned int)a2[1];
if ( Index >= 0 )
{
strcpy(*(_QWORD *)(*((_QWORD *)a2 + 1) + 8 * v13), v17);
LODWORD(v13) = a2[1] + 1;
a2[1] = v13;
}
}
else
{
LODWORD(v13) = a2[1];
}
v15 = *a2;
if ( (unsigned int)v13 >= *a2 )
{
LABEL_24:
TraceLog(4, (unsigned int)"FILEIO: Maximum filepath scan capacity reached (%i files)", v15, v13, v10, v11);
return closedir(v8);
}
ScanDirectoryFilesRecursively(v17, a2, a3);
}
}
}
}
| ScanDirectoryFilesRecursively:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1008
MOV R14,RDX
MOV R12,RSI
MOV RBX,RDI
MOV RDI,RSP
MOV EDX,0x1000
XOR ESI,ESI
CALL 0x001092c0
MOV RDI,RBX
CALL 0x00109800
TEST RAX,RAX
JZ 0x00163dac
MOV R15,RAX
LEA R13,[0x1c630b]
MOV RBP,RSP
LAB_00163ca8:
MOV RDI,R15
CALL 0x00109850
TEST RAX,RAX
JZ 0x00163de2
MOV ECX,dword ptr [R12 + 0x4]
CMP ECX,dword ptr [R12]
JNC 0x00163de2
CMP byte ptr [RAX + 0x13],0x2e
JNZ 0x00163ce0
CMP byte ptr [RAX + 0x14],0x0
JZ 0x00163ca8
CMP byte ptr [RAX + 0x14],0x2e
JNZ 0x00163ce0
CMP byte ptr [RAX + 0x15],0x0
JZ 0x00163ca8
LAB_00163ce0:
ADD RAX,0x13
MOV RDI,RBP
MOV RSI,R13
MOV RDX,RBX
MOV RCX,RAX
XOR EAX,EAX
CALL 0x001090d0
MOV RDI,RBP
CALL 0x00163f36
TEST AL,AL
JZ 0x00163d1e
TEST R14,R14
JZ 0x00163d5a
MOV RDI,RBP
MOV RSI,R14
CALL 0x00163627
MOV ECX,dword ptr [R12 + 0x4]
TEST AL,AL
JNZ 0x00163d5f
JMP 0x00163d7e
LAB_00163d1e:
TEST R14,R14
JZ 0x00163d8c
MOV RDI,R14
LEA RSI,[0x1ccdd0]
CALL 0x0017289e
MOV ECX,dword ptr [R12 + 0x4]
TEST EAX,EAX
JS 0x00163d91
MOV RAX,qword ptr [R12 + 0x8]
MOV RDI,qword ptr [RAX + RCX*0x8]
MOV RSI,RBP
CALL 0x001094a0
MOV ECX,dword ptr [R12 + 0x4]
INC ECX
MOV dword ptr [R12 + 0x4],ECX
JMP 0x00163d91
LAB_00163d5a:
MOV ECX,dword ptr [R12 + 0x4]
LAB_00163d5f:
MOV RAX,qword ptr [R12 + 0x8]
MOV ECX,ECX
MOV RDI,qword ptr [RAX + RCX*0x8]
MOV RSI,RBP
CALL 0x001094a0
MOV ECX,dword ptr [R12 + 0x4]
INC ECX
MOV dword ptr [R12 + 0x4],ECX
LAB_00163d7e:
MOV EDX,dword ptr [R12]
CMP ECX,EDX
JC 0x00163ca8
JMP 0x00163dd1
LAB_00163d8c:
MOV ECX,dword ptr [R12 + 0x4]
LAB_00163d91:
MOV EDX,dword ptr [R12]
CMP ECX,EDX
JNC 0x00163dd1
MOV RDI,RBP
MOV RSI,R12
MOV RDX,R14
CALL 0x00163c61
JMP 0x00163ca8
LAB_00163dac:
LEA RSI,[0x1ccdd4]
PUSH 0x4
POP RDI
MOV RDX,RBX
XOR EAX,EAX
ADD RSP,0x1008
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001a128b
LAB_00163dd1:
LEA RSI,[0x1ccdfc]
PUSH 0x4
POP RDI
XOR EAX,EAX
CALL 0x001a128b
LAB_00163de2:
MOV RDI,R15
CALL 0x001098f0
ADD RSP,0x1008
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void ScanDirectoryFilesRecursively(char *param_1,uint *param_2,long param_3)
{
char cVar1;
int iVar2;
DIR *__dirp;
dirent *pdVar3;
uint uVar4;
char acStack_1038 [4104];
memset(acStack_1038,0,0x1000);
__dirp = opendir(param_1);
if (__dirp == (DIR *)0x0) {
TraceLog(4,"FILEIO: Directory cannot be opened (%s)",param_1);
return;
}
do {
while( true ) {
do {
pdVar3 = readdir(__dirp);
if ((pdVar3 == (dirent *)0x0) || (*param_2 <= param_2[1])) goto LAB_00163de2;
} while ((pdVar3->d_name[0] == '.') &&
((pdVar3->d_name[1] == '\0' ||
((pdVar3->d_name[1] == '.' && (pdVar3->d_name[2] == '\0'))))));
sprintf(acStack_1038,"%s/%s",param_1,pdVar3->d_name);
cVar1 = IsPathFile(acStack_1038);
if (cVar1 != '\0') break;
if (param_3 == 0) {
uVar4 = param_2[1];
}
else {
iVar2 = TextFindIndex(param_3,&DAT_001ccdd0);
uVar4 = param_2[1];
if (-1 < iVar2) {
strcpy(*(char **)(*(long *)(param_2 + 2) + (ulong)uVar4 * 8),acStack_1038);
uVar4 = param_2[1] + 1;
param_2[1] = uVar4;
}
}
if (*param_2 <= uVar4) goto LAB_00163dd1;
ScanDirectoryFilesRecursively(acStack_1038,param_2,param_3);
}
if (param_3 == 0) {
uVar4 = param_2[1];
LAB_00163d5f:
strcpy(*(char **)(*(long *)(param_2 + 2) + (ulong)uVar4 * 8),acStack_1038);
uVar4 = param_2[1] + 1;
param_2[1] = uVar4;
}
else {
cVar1 = IsFileExtension(acStack_1038,param_3);
uVar4 = param_2[1];
if (cVar1 != '\0') goto LAB_00163d5f;
}
} while (uVar4 < *param_2);
LAB_00163dd1:
TraceLog(4,"FILEIO: Maximum filepath scan capacity reached (%i files)");
LAB_00163de2:
closedir(__dirp);
return;
}
| |
45,662 | my_b_read | eloqsql/mysys/mf_iocache.c | int _my_b_read(IO_CACHE *info, uchar *Buffer, size_t Count)
{
size_t left_length;
int res;
/* If the buffer is not empty yet, copy what is available. */
if ((left_length= (size_t) (info->read_end - info->read_pos)))
{
DBUG_ASSERT(Count > left_length);
memcpy(Buffer, info->read_pos, left_length);
Buffer+=left_length;
Count-=left_length;
}
res= info->read_function(info, Buffer, Count);
if (res && info->error >= 0)
info->error+= (int)left_length; /* update number or read bytes */
return res;
} | O0 | c | my_b_read:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xe2e15
jmp 0xe2de3
jmp 0xe2de5
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x2a0b0
movq -0x20(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0xe2e5a
movq -0x8(%rbp), %rax
cmpl $0x0, 0xe4(%rax)
jl 0xe2e5a
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addl 0xe4(%rax), %ecx
movl %ecx, 0xe4(%rax)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _my_b_read:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov rax, [rax+18h]
mov rcx, [rbp+var_8]
mov rcx, [rcx+10h]
sub rax, rcx
mov [rbp+var_20], rax
cmp rax, 0
jz short loc_E2E15
jmp short $+2
loc_E2DE3:
jmp short $+2
loc_E2DE5:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
mov rsi, [rax+10h]
mov rdx, [rbp+var_20]
call _memcpy
mov rax, [rbp+var_20]
add rax, [rbp+var_10]
mov [rbp+var_10], rax
mov rcx, [rbp+var_20]
mov rax, [rbp+var_18]
sub rax, rcx
mov [rbp+var_18], rax
loc_E2E15:
mov rax, [rbp+var_8]
mov rax, [rax+0A0h]
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call rax
mov [rbp+var_24], eax
cmp [rbp+var_24], 0
jz short loc_E2E5A
mov rax, [rbp+var_8]
cmp dword ptr [rax+0E4h], 0
jl short loc_E2E5A
mov rax, [rbp+var_20]
mov ecx, eax
mov rax, [rbp+var_8]
add ecx, [rax+0E4h]
mov [rax+0E4h], ecx
loc_E2E5A:
mov eax, [rbp+var_24]
add rsp, 30h
pop rbp
retn
| long long my_b_read(long long a1, long long a2, long long a3)
{
unsigned int v4; // [rsp+Ch] [rbp-24h]
long long v5; // [rsp+10h] [rbp-20h]
long long v7; // [rsp+20h] [rbp-10h]
v7 = a2;
v5 = *(_QWORD *)(a1 + 24) - *(_QWORD *)(a1 + 16);
if ( v5 )
{
memcpy(a2, *(_QWORD *)(a1 + 16), v5);
v7 = a2 + v5;
a3 -= v5;
}
v4 = (*(long long ( **)(long long, long long, long long))(a1 + 160))(a1, v7, a3);
if ( v4 && *(int *)(a1 + 228) >= 0 )
*(_DWORD *)(a1 + 228) += v5;
return v4;
}
| _my_b_read:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX + 0x10]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JZ 0x001e2e15
JMP 0x001e2de3
LAB_001e2de3:
JMP 0x001e2de5
LAB_001e2de5:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0012a0b0
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x10],RAX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
LAB_001e2e15:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xa0]
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL RAX
MOV dword ptr [RBP + -0x24],EAX
CMP dword ptr [RBP + -0x24],0x0
JZ 0x001e2e5a
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0xe4],0x0
JL 0x001e2e5a
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD ECX,dword ptr [RAX + 0xe4]
MOV dword ptr [RAX + 0xe4],ECX
LAB_001e2e5a:
MOV EAX,dword ptr [RBP + -0x24]
ADD RSP,0x30
POP RBP
RET
|
int _my_b_read(long param_1,void *param_2,long param_3)
{
int iVar1;
size_t __n;
int8 local_20;
int8 local_18;
__n = *(long *)(param_1 + 0x18) - *(long *)(param_1 + 0x10);
local_20 = param_3;
local_18 = param_2;
if (__n != 0) {
memcpy(param_2,*(void **)(param_1 + 0x10),__n);
local_18 = (void *)(__n + (long)param_2);
local_20 = param_3 - __n;
}
iVar1 = (**(code **)(param_1 + 0xa0))(param_1,local_18,local_20);
if ((iVar1 != 0) && (-1 < *(int *)(param_1 + 0xe4))) {
*(int *)(param_1 + 0xe4) = (int)__n + *(int *)(param_1 + 0xe4);
}
return iVar1;
}
| |
45,663 | Catch::trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AlayaLite/build_O3/_deps/libcoro-src/test/catch_amalgamated.cpp | std::string trim( std::string const& str ) {
static char const* whitespaceChars = "\n\r\t ";
std::string::size_type start = str.find_first_not_of( whitespaceChars );
std::string::size_type end = str.find_last_not_of( whitespaceChars );
return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
} | O3 | cpp | Catch::trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x9251e(%rip), %r12 # 0xddda9
movl $0x4, %ecx
movq %rsi, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x87f9c
movq %rax, %r15
movl $0x4, %ecx
movq %r14, %rdi
movq %r12, %rsi
movq $-0x1, %rdx
callq 0x88008
cmpq $-0x1, %r15
je 0x4b8d6
subq %r15, %rax
incq %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x77522
jmp 0x4b8e9
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| _ZN5Catch4trimERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push r12
push rbx
push rax
mov r14, rsi
mov rbx, rdi
lea r12, asc_DDDA9; "\n\r\t "
mov ecx, 4
mov rdi, rsi
mov rsi, r12
xor edx, edx
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE17find_first_not_ofEPKcmm; std::string::find_first_not_of(char const*,ulong,ulong)
mov r15, rax
mov ecx, 4
mov rdi, r14
mov rsi, r12
mov rdx, 0FFFFFFFFFFFFFFFFh
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE16find_last_not_ofEPKcmm; std::string::find_last_not_of(char const*,ulong,ulong)
cmp r15, 0FFFFFFFFFFFFFFFFh
jz short loc_4B8D6
sub rax, r15
inc rax
mov rdi, rbx
mov rsi, r14
mov rdx, r15
mov rcx, rax
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
jmp short loc_4B8E9
loc_4B8D6:
lea rax, [rbx+10h]
mov [rbx], rax
mov qword ptr [rbx+8], 0
mov byte ptr [rbx+10h], 0
loc_4B8E9:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long Catch::trim(long long a1, long long a2)
{
long long first_not_of; // r15
long long last_not_of; // rax
first_not_of = std::string::find_first_not_of(a2, "\n\r\t ", 0LL, 4LL);
last_not_of = std::string::find_last_not_of(a2, "\n\r\t ", -1LL, 4LL);
if ( first_not_of == -1 )
{
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
}
else
{
std::string::substr(a1, a2, first_not_of, last_not_of - first_not_of + 1);
}
return a1;
}
| trim:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
LEA R12,[0x1ddda9]
MOV ECX,0x4
MOV RDI,RSI
MOV RSI,R12
XOR EDX,EDX
CALL 0x00187f9c
MOV R15,RAX
MOV ECX,0x4
MOV RDI,R14
MOV RSI,R12
MOV RDX,-0x1
CALL 0x00188008
CMP R15,-0x1
JZ 0x0014b8d6
SUB RAX,R15
INC RAX
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
MOV RCX,RAX
CALL 0x00177522
JMP 0x0014b8e9
LAB_0014b8d6:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
MOV qword ptr [RBX + 0x8],0x0
MOV byte ptr [RBX + 0x10],0x0
LAB_0014b8e9:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* Catch::trim(std::__cxx11::string const&) */
Catch * __thiscall Catch::trim(Catch *this,string *param_1)
{
long lVar1;
lVar1 = std::__cxx11::string::find_first_not_of(param_1,"\n\r\t ",0,4);
std::__cxx11::string::find_last_not_of(param_1,"\n\r\t ",0xffffffffffffffff,4);
if (lVar1 == -1) {
*(Catch **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (Catch)0x0;
}
else {
std::__cxx11::string::substr((ulong)this,(ulong)param_1);
}
return this;
}
| |
45,664 | copy_decode_table | eloqsql/storage/myisam/mi_packrec.c | static uint copy_decode_table(uint16 *to_pos, uint offset,
uint16 *decode_table)
{
uint prev_offset= offset;
DBUG_ENTER("copy_decode_table");
/* Descent on the left side. */
if (!(*decode_table & IS_CHAR))
{
/* Set a pointer to the next target node. */
to_pos[offset]=2;
/* Copy the left hand subtree there. */
offset=copy_decode_table(to_pos,offset+2,decode_table+ *decode_table);
}
else
{
/* Copy the byte value. */
to_pos[offset]= *decode_table;
/* Step behind this node. */
offset+=2;
}
/* Descent on the right side. */
decode_table++;
if (!(*decode_table & IS_CHAR))
{
/* Set a pointer to the next free target node. */
to_pos[prev_offset+1]=(uint16) (offset-prev_offset-1);
/* Copy the right hand subtree to the entry of that node. */
offset=copy_decode_table(to_pos,offset,decode_table+ *decode_table);
}
else
{
/* Copy the byte value. */
to_pos[prev_offset+1]= *decode_table;
}
DBUG_RETURN(offset);
} | O0 | c | copy_decode_table:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
andl $0x8000, %eax # imm = 0x8000
cmpl $0x0, %eax
jne 0xbe45e
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movw $0x2, (%rax,%rcx,2)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
cltq
shlq %rax
addq %rax, %rdx
callq 0xbe400
movl %eax, -0xc(%rbp)
jmp 0xbe479
movq -0x18(%rbp), %rax
movw (%rax), %dx
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movw %dx, (%rax,%rcx,2)
movl -0xc(%rbp), %eax
addl $0x2, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
andl $0x8000, %eax # imm = 0x8000
cmpl $0x0, %eax
jne 0xbe4d6
movl -0xc(%rbp), %eax
subl -0x1c(%rbp), %eax
subl $0x1, %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movw %dx, (%rax,%rcx,2)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
cltq
shlq %rax
addq %rax, %rdx
callq 0xbe400
movl %eax, -0xc(%rbp)
jmp 0xbe4ed
movq -0x18(%rbp), %rax
movw (%rax), %dx
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movw %dx, (%rax,%rcx,2)
jmp 0xbe4ef
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
| copy_decode_table_0:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov eax, [rbp+var_C]
mov [rbp+var_1C], eax
mov rax, [rbp+var_18]
movzx eax, word ptr [rax]
and eax, 8000h
cmp eax, 0
jnz short loc_BE45E
mov rax, [rbp+var_8]
mov ecx, [rbp+var_C]
mov word ptr [rax+rcx*2], 2
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
add esi, 2
mov rdx, [rbp+var_18]
mov rax, [rbp+var_18]
movzx eax, word ptr [rax]
cdqe
shl rax, 1
add rdx, rax
call copy_decode_table_0
mov [rbp+var_C], eax
jmp short loc_BE479
loc_BE45E:
mov rax, [rbp+var_18]
mov dx, [rax]
mov rax, [rbp+var_8]
mov ecx, [rbp+var_C]
mov [rax+rcx*2], dx
mov eax, [rbp+var_C]
add eax, 2
mov [rbp+var_C], eax
loc_BE479:
mov rax, [rbp+var_18]
add rax, 2
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
movzx eax, word ptr [rax]
and eax, 8000h
cmp eax, 0
jnz short loc_BE4D6
mov eax, [rbp+var_C]
sub eax, [rbp+var_1C]
sub eax, 1
mov dx, ax
mov rax, [rbp+var_8]
mov ecx, [rbp+var_1C]
add ecx, 1
mov ecx, ecx
mov [rax+rcx*2], dx
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_18]
mov rax, [rbp+var_18]
movzx eax, word ptr [rax]
cdqe
shl rax, 1
add rdx, rax
call copy_decode_table_0
mov [rbp+var_C], eax
jmp short loc_BE4ED
loc_BE4D6:
mov rax, [rbp+var_18]
mov dx, [rax]
mov rax, [rbp+var_8]
mov ecx, [rbp+var_1C]
add ecx, 1
mov ecx, ecx
mov [rax+rcx*2], dx
loc_BE4ED:
jmp short $+2
loc_BE4EF:
mov eax, [rbp+var_C]
mov [rbp+var_20], eax
mov eax, [rbp+var_20]
add rsp, 20h
pop rbp
retn
| long long copy_decode_table_0(long long a1, unsigned int a2, _WORD *a3)
{
_WORD *v5; // [rsp+8h] [rbp-18h]
unsigned int v6; // [rsp+14h] [rbp-Ch]
if ( (*a3 & 0x8000) != 0 )
{
*(_WORD *)(a1 + 2LL * a2) = *a3;
v6 = a2 + 2;
}
else
{
*(_WORD *)(a1 + 2LL * a2) = 2;
v6 = copy_decode_table_0(a1, a2 + 2, &a3[(unsigned __int16)*a3]);
}
v5 = a3 + 1;
if ( (*v5 & 0x8000) != 0 )
{
*(_WORD *)(a1 + 2LL * (a2 + 1)) = *v5;
}
else
{
*(_WORD *)(a1 + 2LL * (a2 + 1)) = v6 - a2 - 1;
return (unsigned int)copy_decode_table_0(a1, v6, &v5[(unsigned __int16)*v5]);
}
return v6;
}
| copy_decode_table:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX]
AND EAX,0x8000
CMP EAX,0x0
JNZ 0x001be45e
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0xc]
MOV word ptr [RAX + RCX*0x2],0x2
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
ADD ESI,0x2
MOV RDX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX]
CDQE
SHL RAX,0x1
ADD RDX,RAX
CALL 0x001be400
MOV dword ptr [RBP + -0xc],EAX
JMP 0x001be479
LAB_001be45e:
MOV RAX,qword ptr [RBP + -0x18]
MOV DX,word ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0xc]
MOV word ptr [RAX + RCX*0x2],DX
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x2
MOV dword ptr [RBP + -0xc],EAX
LAB_001be479:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x2
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX]
AND EAX,0x8000
CMP EAX,0x0
JNZ 0x001be4d6
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
MOV DX,AX
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0x1c]
ADD ECX,0x1
MOV ECX,ECX
MOV word ptr [RAX + RCX*0x2],DX
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX]
CDQE
SHL RAX,0x1
ADD RDX,RAX
CALL 0x001be400
MOV dword ptr [RBP + -0xc],EAX
JMP 0x001be4ed
LAB_001be4d6:
MOV RAX,qword ptr [RBP + -0x18]
MOV DX,word ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0x1c]
ADD ECX,0x1
MOV ECX,ECX
MOV word ptr [RAX + RCX*0x2],DX
LAB_001be4ed:
JMP 0x001be4ef
LAB_001be4ef:
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x20]
ADD RSP,0x20
POP RBP
RET
|
int copy_decode_table(long param_1,uint param_2,ushort *param_3)
{
int local_14;
if ((*param_3 & 0x8000) == 0) {
*(int2 *)(param_1 + (ulong)param_2 * 2) = 2;
local_14 = copy_decode_table(param_1,param_2 + 2,param_3 + (int)(uint)*param_3);
}
else {
*(ushort *)(param_1 + (ulong)param_2 * 2) = *param_3;
local_14 = param_2 + 2;
}
param_3 = param_3 + 1;
if ((*param_3 & 0x8000) == 0) {
*(short *)(param_1 + (ulong)(param_2 + 1) * 2) = ((short)local_14 - (short)param_2) + -1;
local_14 = copy_decode_table(param_1,local_14,param_3 + (int)(uint)*param_3);
}
else {
*(ushort *)(param_1 + (ulong)(param_2 + 1) * 2) = *param_3;
}
return local_14;
}
| |
45,665 | mi_rec_pack | eloqsql/storage/myisam/mi_dynrec.c | uint _mi_rec_pack(MI_INFO *info, register uchar *to,
register const uchar *from)
{
uint length,new_length,flag,bit,i;
uchar *pos,*end,*startpos,*packpos;
enum en_fieldtype type;
reg3 MI_COLUMNDEF *rec;
MI_BLOB *blob;
DBUG_ENTER("_mi_rec_pack");
flag=0 ; bit=1;
startpos=packpos=to; to+= info->s->base.pack_bits; blob=info->blobs;
rec=info->s->rec;
for (i=info->s->base.fields ; i-- > 0; from+= length,rec++)
{
length=(uint) rec->length;
if ((type = (enum en_fieldtype) rec->type) != FIELD_NORMAL)
{
if (type == FIELD_BLOB)
{
if (!blob->length)
flag|=bit;
else
{
char *temp_pos;
size_t tmp_length=length-portable_sizeof_char_ptr;
memcpy((uchar*) to,from,tmp_length);
memcpy(&temp_pos,from+tmp_length,sizeof(char*));
memcpy(to+tmp_length,temp_pos,(size_t) blob->length);
to+=tmp_length+blob->length;
}
blob++;
}
else if (type == FIELD_SKIP_ZERO)
{
if (memcmp((uchar*) from,zero_string,length) == 0)
flag|=bit;
else
{
memcpy((uchar*) to,from,(size_t) length); to+=length;
}
}
else if (type == FIELD_SKIP_ENDSPACE ||
type == FIELD_SKIP_PRESPACE)
{
pos= (uchar*) from; end= (uchar*) from + length;
if (type == FIELD_SKIP_ENDSPACE)
{ /* Pack trailing spaces */
while (end > from && *(end-1) == ' ')
end--;
}
else
{ /* Pack pref-spaces */
while (pos < end && *pos == ' ')
pos++;
}
new_length=(uint) (end-pos);
if (new_length + 1 + MY_TEST(rec->length > 255 && new_length > 127)
< length)
{
if (rec->length > 255 && new_length > 127)
{
to[0]= (uchar) ((new_length & 127) + 128);
to[1]= (uchar) (new_length >> 7);
to+=2;
}
else
*to++= (uchar) new_length;
memcpy((uchar*) to,pos,(size_t) new_length); to+=new_length;
flag|=bit;
}
else
{
memcpy(to,from,(size_t) length); to+=length;
}
}
else if (type == FIELD_VARCHAR)
{
uint pack_length= HA_VARCHAR_PACKLENGTH(rec->length -1);
uint tmp_length;
if (pack_length == 1)
{
tmp_length= (uint) *(uchar*) from;
*to++= *from;
}
else
{
tmp_length= uint2korr(from);
store_key_length_inc(to,tmp_length);
}
memcpy(to, from+pack_length,tmp_length);
to+= tmp_length;
continue;
}
else
{
memcpy(to,from,(size_t) length); to+=length;
continue; /* Normal field */
}
if ((bit= bit << 1) >= 256)
{
*packpos++= (uchar) flag;
bit=1; flag=0;
}
}
else
{
memcpy(to,from,(size_t) length); to+=length;
}
}
if (bit != 1)
*packpos= (uchar) flag;
if (info->s->calc_checksum)
*to++= (uchar) info->checksum;
DBUG_PRINT("exit",("packed length: %d",(int) (to-startpos)));
DBUG_RETURN((uint) (to-startpos));
} | O3 | c | mi_rec_pack:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq (%rdi), %rax
movl 0x168(%rax), %r13d
movl 0x18c(%rax), %ebx
addq %rsi, %rbx
testl %r13d, %r13d
je 0x78365
movq %rdx, %r12
movq 0x230(%rax), %r15
movq 0x48(%rdi), %rdx
movq %rsi, -0x58(%rbp)
movq %rsi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movl $0x1, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
decl %r13d
movzwl 0x4(%r15), %r8d
movl (%r15), %ecx
testl %ecx, %ecx
je 0x78121
cmpl $0x3, %ecx
je 0x780ea
cmpl $0x4, %ecx
jne 0x78151
cmpq $0x0, 0x10(%rdx)
je 0x781c8
movl %r13d, -0x3c(%rbp)
movq %rbx, %r13
leal -0x8(%r8), %ebx
movq %r13, %rdi
movq %r12, %rsi
movq %rdx, %r14
movq %rbx, %rdx
movq %r8, -0x60(%rbp)
callq 0x29080
movq (%r12,%rbx), %rsi
leaq (%rbx,%r13), %rdi
movq 0x10(%r14), %rdx
callq 0x29080
movq -0x60(%rbp), %r8
movq %r14, %rdx
addq 0x10(%r14), %rbx
addq %rbx, %r13
movq %r13, %rbx
movl -0x3c(%rbp), %r13d
jmp 0x781d1
movq %rdx, -0x38(%rbp)
movq %r12, %rdi
leaq 0xb89ba8(%rip), %rsi # 0xc01ca0
movq %r8, %rdx
movq %r8, %r14
callq 0x29560
testl %eax, %eax
je 0x781b6
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x29080
addq %r14, %rbx
jmp 0x781bf
movq %rbx, %rdi
movq %r12, %rsi
movq %rbx, -0x68(%rbp)
movq %rdx, %rbx
movq %r8, %rdx
movl %r13d, %r14d
movq %r8, %r13
callq 0x29080
movq %r13, %r8
movl %r14d, %r13d
movq %rbx, %rdx
movq -0x68(%rbp), %rbx
addq %r8, %rbx
jmp 0x781e8
cmpl $0x2, %ecx
ja 0x78181
leaq (%r12,%r8), %rax
cmpl $0x1, %ecx
movq %rdx, -0x38(%rbp)
jne 0x781fd
movq %rax, %rcx
cmpq %r12, %rax
jbe 0x78179
leaq -0x1(%rcx), %rax
cmpb $0x20, -0x1(%rcx)
je 0x78167
movq %rcx, %rax
jmp 0x78214
cmpl $0x8, %ecx
jne 0x78286
cmpl $0x100, %r8d # imm = 0x100
movl %r13d, -0x3c(%rbp)
movq %rdx, -0x38(%rbp)
ja 0x782d0
movq %r8, %r14
movzbl (%r12), %eax
movb %al, (%rbx)
incq %rbx
movl $0x1, %esi
jmp 0x782f8
movl -0x2c(%rbp), %eax
orl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rdx
movq %r14, %r8
jmp 0x781d5
movl -0x2c(%rbp), %eax
orl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
addq $0x18, %rdx
movl -0x30(%rbp), %eax
addl %eax, %eax
movl %eax, -0x30(%rbp)
cmpl $0xff, %eax
ja 0x78321
addq %r8, %r12
addq $0x30, %r15
testl %r13d, %r13d
jne 0x78073
jmp 0x7834e
movq %r12, %rsi
testq %r8, %r8
je 0x78214
cmpb $0x20, (%rsi)
jne 0x78217
incq %rsi
cmpq %rax, %rsi
jb 0x78205
jmp 0x78217
movq %r12, %rsi
subq %rsi, %rax
cmpl $0x100, %r8d # imm = 0x100
setae %dl
cmpl $0x7f, %eax
seta %cl
andb %dl, %cl
movzbl %cl, %edx
addl %eax, %edx
incl %edx
cmpl %r8d, %edx
jae 0x782b0
movq %rbx, %rdi
movl $0x1, %ebx
testb %cl, %cl
movq %r8, -0x60(%rbp)
movl %eax, %ecx
je 0x7825a
orb $-0x80, %cl
movl %eax, %edx
shrl $0x7, %edx
movb %dl, 0x1(%rdi)
movl $0x2, %ebx
addq %rdi, %rbx
movb %cl, (%rdi)
movl %eax, %r14d
movq %rbx, %rdi
movq %r14, %rdx
callq 0x29080
addq %r14, %rbx
movl -0x2c(%rbp), %eax
orl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rdx
movq -0x60(%rbp), %r8
jmp 0x781d5
movq %rbx, %rdi
movq %r12, %rsi
movq %rbx, -0x68(%rbp)
movq %rdx, %rbx
movq %r8, %rdx
movq %r8, %r14
callq 0x29080
movq %r14, %r8
movq %rbx, %rdx
movq -0x68(%rbp), %rbx
addq %r14, %rbx
jmp 0x781e8
movq %rbx, %rdi
movq %r12, %rsi
movq %r8, %rdx
movq %r8, %r14
callq 0x29080
movq %r14, %r8
addq %r14, %rbx
movq -0x38(%rbp), %rdx
jmp 0x781d5
movzwl (%r12), %eax
movq %r8, %r14
cmpl $0xfe, %eax
ja 0x782e6
movb %al, (%rbx)
incq %rbx
jmp 0x782f3
movb $-0x1, (%rbx)
movb %al, 0x2(%rbx)
movb %ah, 0x1(%rbx)
addq $0x3, %rbx
movl $0x2, %esi
movq %rbx, %r13
addq %r12, %rsi
movl %eax, %ebx
movq %r13, %rdi
movq %rbx, %rdx
callq 0x29080
addq %rbx, %r13
movq %r13, %rbx
movl -0x3c(%rbp), %r13d
movq -0x38(%rbp), %rdx
movq %r14, %r8
jmp 0x781e8
movq -0x58(%rbp), %rax
movl -0x2c(%rbp), %ecx
movb %cl, (%rax)
incq %rax
movq %rax, -0x58(%rbp)
movl %r8d, %eax
addq %rax, %r12
addq $0x30, %r15
testl %r13d, %r13d
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdi
jne 0x78065
jmp 0x78365
cmpl $0x1, -0x30(%rbp)
je 0x7835d
movq -0x58(%rbp), %rax
movl -0x2c(%rbp), %ecx
movb %cl, (%rax)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
cmpq $0x0, 0x2c8(%rax)
je 0x7837d
movb 0x1a8(%rdi), %al
movb %al, (%rbx)
incq %rbx
subl %esi, %ebx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _mi_rec_pack:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rax, [rdi]
mov r13d, [rax+168h]
mov ebx, [rax+18Ch]
add rbx, rsi
test r13d, r13d
jz loc_78365
mov r12, rdx
mov r15, [rax+230h]
mov rdx, [rdi+48h]
mov [rbp+var_58], rsi
mov [rbp+var_50], rsi
mov [rbp+var_48], rdi
loc_78065:
mov [rbp+var_30], 1
mov [rbp+var_2C], 0
loc_78073:
dec r13d
movzx r8d, word ptr [r15+4]
mov ecx, [r15]
test ecx, ecx
jz loc_78121
cmp ecx, 3
jz short loc_780EA
cmp ecx, 4
jnz loc_78151
cmp qword ptr [rdx+10h], 0
jz loc_781C8
mov [rbp+var_3C], r13d
mov r13, rbx
lea ebx, [r8-8]
mov rdi, r13
mov rsi, r12
mov r14, rdx
mov rdx, rbx
mov [rbp+var_60], r8
call _memcpy
mov rsi, [r12+rbx]
lea rdi, [rbx+r13]
mov rdx, [r14+10h]
call _memcpy
mov r8, [rbp+var_60]
mov rdx, r14
add rbx, [r14+10h]
add r13, rbx
mov rbx, r13
mov r13d, [rbp+var_3C]
jmp loc_781D1
loc_780EA:
mov [rbp+var_38], rdx
mov rdi, r12
lea rsi, zero_string
mov rdx, r8
mov r14, r8
call _bcmp
test eax, eax
jz loc_781B6
mov rdi, rbx
mov rsi, r12
mov rdx, r14
call _memcpy
add rbx, r14
jmp loc_781BF
loc_78121:
mov rdi, rbx
mov rsi, r12
mov [rbp+var_68], rbx
mov rbx, rdx
mov rdx, r8
mov r14d, r13d
mov r13, r8
call _memcpy
mov r8, r13
mov r13d, r14d
mov rdx, rbx
mov rbx, [rbp+var_68]
add rbx, r8
jmp loc_781E8
loc_78151:
cmp ecx, 2
ja short loc_78181
lea rax, [r12+r8]
cmp ecx, 1
mov [rbp+var_38], rdx
jnz loc_781FD
loc_78167:
mov rcx, rax
cmp rax, r12
jbe short loc_78179
lea rax, [rcx-1]
cmp byte ptr [rcx-1], 20h ; ' '
jz short loc_78167
loc_78179:
mov rax, rcx
jmp loc_78214
loc_78181:
cmp ecx, 8
jnz loc_78286
cmp r8d, 100h
mov [rbp+var_3C], r13d
mov [rbp+var_38], rdx
ja loc_782D0
mov r14, r8
movzx eax, byte ptr [r12]
mov [rbx], al
inc rbx
mov esi, 1
jmp loc_782F8
loc_781B6:
mov eax, [rbp+var_2C]
or eax, [rbp+var_30]
mov [rbp+var_2C], eax
loc_781BF:
mov rdx, [rbp+var_38]
mov r8, r14
jmp short loc_781D5
loc_781C8:
mov eax, [rbp+var_2C]
or eax, [rbp+var_30]
mov [rbp+var_2C], eax
loc_781D1:
add rdx, 18h
loc_781D5:
mov eax, [rbp+var_30]
add eax, eax
mov [rbp+var_30], eax
cmp eax, 0FFh
ja loc_78321
loc_781E8:
add r12, r8
add r15, 30h ; '0'
test r13d, r13d
jnz loc_78073
jmp loc_7834E
loc_781FD:
mov rsi, r12
test r8, r8
jz short loc_78214
loc_78205:
cmp byte ptr [rsi], 20h ; ' '
jnz short loc_78217
inc rsi
cmp rsi, rax
jb short loc_78205
jmp short loc_78217
loc_78214:
mov rsi, r12
loc_78217:
sub rax, rsi
cmp r8d, 100h
setnb dl
cmp eax, 7Fh
setnbe cl
and cl, dl
movzx edx, cl
add edx, eax
inc edx
cmp edx, r8d
jnb short loc_782B0
mov rdi, rbx
mov ebx, 1
test cl, cl
mov [rbp+var_60], r8
mov ecx, eax
jz short loc_7825A
or cl, 80h
mov edx, eax
shr edx, 7
mov [rdi+1], dl
mov ebx, 2
loc_7825A:
add rbx, rdi
mov [rdi], cl
mov r14d, eax
mov rdi, rbx
mov rdx, r14
call _memcpy
add rbx, r14
mov eax, [rbp+var_2C]
or eax, [rbp+var_30]
mov [rbp+var_2C], eax
mov rdx, [rbp+var_38]
mov r8, [rbp+var_60]
jmp loc_781D5
loc_78286:
mov rdi, rbx
mov rsi, r12
mov [rbp+var_68], rbx
mov rbx, rdx
mov rdx, r8
mov r14, r8
call _memcpy
mov r8, r14
mov rdx, rbx
mov rbx, [rbp+var_68]
add rbx, r14
jmp loc_781E8
loc_782B0:
mov rdi, rbx
mov rsi, r12
mov rdx, r8
mov r14, r8
call _memcpy
mov r8, r14
add rbx, r14
mov rdx, [rbp+var_38]
jmp loc_781D5
loc_782D0:
movzx eax, word ptr [r12]
mov r14, r8
cmp eax, 0FEh
ja short loc_782E6
mov [rbx], al
inc rbx
jmp short loc_782F3
loc_782E6:
mov byte ptr [rbx], 0FFh
mov [rbx+2], al
mov [rbx+1], ah
add rbx, 3
loc_782F3:
mov esi, 2
loc_782F8:
mov r13, rbx
add rsi, r12
mov ebx, eax
mov rdi, r13
mov rdx, rbx
call _memcpy
add r13, rbx
mov rbx, r13
mov r13d, [rbp+var_3C]
mov rdx, [rbp+var_38]
mov r8, r14
jmp loc_781E8
loc_78321:
mov rax, [rbp+var_58]
mov ecx, [rbp+var_2C]
mov [rax], cl
inc rax
mov [rbp+var_58], rax
mov eax, r8d
add r12, rax
add r15, 30h ; '0'
test r13d, r13d
mov rsi, [rbp+var_50]
mov rdi, [rbp+var_48]
jnz loc_78065
jmp short loc_78365
loc_7834E:
cmp [rbp+var_30], 1
jz short loc_7835D
mov rax, [rbp+var_58]
mov ecx, [rbp+var_2C]
mov [rax], cl
loc_7835D:
mov rsi, [rbp+var_50]
mov rdi, [rbp+var_48]
loc_78365:
mov rax, [rdi]
cmp qword ptr [rax+2C8h], 0
jz short loc_7837D
mov al, [rdi+1A8h]
mov [rbx], al
inc rbx
loc_7837D:
sub ebx, esi
mov eax, ebx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long mi_rec_pack(long long a1, _BYTE *a2, char *a3)
{
int v3; // r13d
_BYTE *v4; // rbx
long long v6; // r15
long long v7; // rdx
long long v8; // r8
unsigned int v9; // ecx
_BYTE *v10; // r13
long long v11; // rbx
long long v12; // r14
long long v13; // r14
_BYTE *v14; // rdi
long long v15; // rbx
int v16; // r14d
long long v17; // r13
char *v18; // rax
char *v19; // rcx
long long v20; // r14
unsigned int v21; // eax
_BYTE *v22; // rbx
long long v23; // rsi
char *v24; // rsi
unsigned int v25; // eax
bool v26; // cl
_BYTE *v27; // rdi
long long v28; // rbx
bool v29; // zf
char v30; // cl
_BYTE *v31; // rbx
long long v32; // r14
_BYTE *v33; // rdi
long long v34; // rbx
long long v35; // r14
long long v36; // r14
_BYTE *v37; // r13
long long v38; // rbx
_BYTE *v40; // [rsp+8h] [rbp-68h]
_BYTE *v41; // [rsp+8h] [rbp-68h]
long long v42; // [rsp+10h] [rbp-60h]
long long v43; // [rsp+10h] [rbp-60h]
_BYTE *v44; // [rsp+18h] [rbp-58h]
int v45; // [rsp+20h] [rbp-50h]
long long v46; // [rsp+28h] [rbp-48h]
int v47; // [rsp+34h] [rbp-3Ch]
int v48; // [rsp+34h] [rbp-3Ch]
long long v49; // [rsp+38h] [rbp-38h]
long long v50; // [rsp+38h] [rbp-38h]
long long v51; // [rsp+38h] [rbp-38h]
unsigned int v52; // [rsp+40h] [rbp-30h]
int v53; // [rsp+44h] [rbp-2Ch]
v3 = *(_DWORD *)(*(_QWORD *)a1 + 360LL);
v4 = &a2[*(unsigned int *)(*(_QWORD *)a1 + 396LL)];
if ( !v3 )
goto LABEL_48;
v6 = *(_QWORD *)(*(_QWORD *)a1 + 560LL);
v7 = *(_QWORD *)(a1 + 72);
v44 = a2;
v45 = (int)a2;
v46 = a1;
while ( 2 )
{
v52 = 1;
v53 = 0;
while ( 1 )
{
--v3;
v8 = *(unsigned __int16 *)(v6 + 4);
v9 = *(_DWORD *)v6;
if ( *(_DWORD *)v6 )
break;
v14 = v4;
v40 = v4;
v15 = v7;
v16 = v3;
v17 = *(unsigned __int16 *)(v6 + 4);
memcpy(v14, a3, v8);
v8 = v17;
v3 = v16;
v7 = v15;
v4 = &v40[v8];
LABEL_25:
a3 += v8;
v6 += 48LL;
if ( !v3 )
{
if ( v52 != 1 )
*v44 = v53;
LODWORD(a2) = v45;
a1 = v46;
goto LABEL_48;
}
}
if ( v9 == 3 )
{
v49 = v7;
v13 = *(unsigned __int16 *)(v6 + 4);
if ( (unsigned int)bcmp(a3, &zero_string, v8) )
{
memcpy(v4, a3, v13);
v4 += v13;
}
else
{
v53 |= v52;
}
v7 = v49;
v8 = v13;
goto LABEL_24;
}
if ( v9 == 4 )
{
if ( *(_QWORD *)(v7 + 16) )
{
v47 = v3;
v10 = v4;
v11 = (unsigned int)(v8 - 8);
v12 = v7;
v42 = *(unsigned __int16 *)(v6 + 4);
memcpy(v10, a3, v11);
memcpy(&v10[v11], *(_QWORD *)&a3[v11], *(_QWORD *)(v12 + 16));
v8 = v42;
v7 = v12;
v4 = &v10[*(_QWORD *)(v12 + 16) + v11];
v3 = v47;
}
else
{
v53 |= v52;
}
v7 += 24LL;
goto LABEL_24;
}
if ( v9 > 2 )
{
if ( v9 == 8 )
{
v48 = v3;
v51 = v7;
if ( (unsigned int)v8 > 0x100 )
{
v21 = *(unsigned __int16 *)a3;
v20 = *(unsigned __int16 *)(v6 + 4);
if ( v21 > 0xFE )
{
*v4 = -1;
v4[2] = v21;
v4[1] = BYTE1(v21);
v22 = v4 + 3;
}
else
{
*v4 = v21;
v22 = v4 + 1;
}
v23 = 2LL;
}
else
{
v20 = *(unsigned __int16 *)(v6 + 4);
v21 = (unsigned __int8)*a3;
*v4 = v21;
v22 = v4 + 1;
v23 = 1LL;
}
v37 = v22;
v38 = v21;
memcpy(v37, &a3[v23], v21);
v4 = &v37[v38];
v3 = v48;
v7 = v51;
v8 = v20;
}
else
{
v33 = v4;
v41 = v4;
v34 = v7;
v35 = *(unsigned __int16 *)(v6 + 4);
memcpy(v33, a3, v8);
v8 = v35;
v7 = v34;
v4 = &v41[v35];
}
goto LABEL_25;
}
v18 = &a3[v8];
v50 = v7;
if ( v9 == 1 )
{
do
{
v19 = v18;
if ( v18 <= a3 )
break;
--v18;
}
while ( *(v19 - 1) == 32 );
LODWORD(v18) = (_DWORD)v19;
goto LABEL_31;
}
v24 = a3;
if ( !*(_WORD *)(v6 + 4) )
{
LABEL_31:
v24 = a3;
goto LABEL_32;
}
do
{
if ( *v24 != 32 )
break;
++v24;
}
while ( v24 < v18 );
LABEL_32:
v25 = (_DWORD)v18 - (_DWORD)v24;
v26 = (unsigned int)v8 >= 0x100 && v25 > 0x7F;
if ( v25 + v26 + 1 >= (unsigned int)v8 )
{
v36 = *(unsigned __int16 *)(v6 + 4);
memcpy(v4, a3, v8);
v8 = v36;
v4 += v36;
v7 = v50;
}
else
{
v27 = v4;
v28 = 1LL;
v29 = !v26;
v43 = *(unsigned __int16 *)(v6 + 4);
v30 = v25;
if ( !v29 )
{
v30 = v25 | 0x80;
v27[1] = v25 >> 7;
v28 = 2LL;
}
v31 = &v27[v28];
*v27 = v30;
v32 = v25;
memcpy(v31, v24, v25);
v4 = &v31[v32];
v53 |= v52;
v7 = v50;
v8 = v43;
}
LABEL_24:
v52 *= 2;
if ( v52 <= 0xFF )
goto LABEL_25;
*v44++ = v53;
a3 += (unsigned int)v8;
v6 += 48LL;
LODWORD(a2) = v45;
a1 = v46;
if ( v3 )
continue;
break;
}
LABEL_48:
if ( *(_QWORD *)(*(_QWORD *)a1 + 712LL) )
{
*v4 = *(_BYTE *)(a1 + 424);
LODWORD(v4) = (_DWORD)v4 + 1;
}
return (unsigned int)((_DWORD)v4 - (_DWORD)a2);
}
| _mi_rec_pack:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RAX,qword ptr [RDI]
MOV R13D,dword ptr [RAX + 0x168]
MOV EBX,dword ptr [RAX + 0x18c]
ADD RBX,RSI
TEST R13D,R13D
JZ 0x00178365
MOV R12,RDX
MOV R15,qword ptr [RAX + 0x230]
MOV RDX,qword ptr [RDI + 0x48]
MOV qword ptr [RBP + -0x58],RSI
MOV qword ptr [RBP + -0x50],RSI
MOV qword ptr [RBP + -0x48],RDI
LAB_00178065:
MOV dword ptr [RBP + -0x30],0x1
MOV dword ptr [RBP + -0x2c],0x0
LAB_00178073:
DEC R13D
MOVZX R8D,word ptr [R15 + 0x4]
MOV ECX,dword ptr [R15]
TEST ECX,ECX
JZ 0x00178121
CMP ECX,0x3
JZ 0x001780ea
CMP ECX,0x4
JNZ 0x00178151
CMP qword ptr [RDX + 0x10],0x0
JZ 0x001781c8
MOV dword ptr [RBP + -0x3c],R13D
MOV R13,RBX
LEA EBX,[R8 + -0x8]
MOV RDI,R13
MOV RSI,R12
MOV R14,RDX
MOV RDX,RBX
MOV qword ptr [RBP + -0x60],R8
CALL 0x00129080
MOV RSI,qword ptr [R12 + RBX*0x1]
LEA RDI,[RBX + R13*0x1]
MOV RDX,qword ptr [R14 + 0x10]
CALL 0x00129080
MOV R8,qword ptr [RBP + -0x60]
MOV RDX,R14
ADD RBX,qword ptr [R14 + 0x10]
ADD R13,RBX
MOV RBX,R13
MOV R13D,dword ptr [RBP + -0x3c]
JMP 0x001781d1
LAB_001780ea:
MOV qword ptr [RBP + -0x38],RDX
MOV RDI,R12
LEA RSI,[0xd01ca0]
MOV RDX,R8
MOV R14,R8
CALL 0x00129560
TEST EAX,EAX
JZ 0x001781b6
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R14
CALL 0x00129080
ADD RBX,R14
JMP 0x001781bf
LAB_00178121:
MOV RDI,RBX
MOV RSI,R12
MOV qword ptr [RBP + -0x68],RBX
MOV RBX,RDX
MOV RDX,R8
MOV R14D,R13D
MOV R13,R8
CALL 0x00129080
MOV R8,R13
MOV R13D,R14D
MOV RDX,RBX
MOV RBX,qword ptr [RBP + -0x68]
ADD RBX,R8
JMP 0x001781e8
LAB_00178151:
CMP ECX,0x2
JA 0x00178181
LEA RAX,[R12 + R8*0x1]
CMP ECX,0x1
MOV qword ptr [RBP + -0x38],RDX
JNZ 0x001781fd
LAB_00178167:
MOV RCX,RAX
CMP RAX,R12
JBE 0x00178179
LEA RAX,[RCX + -0x1]
CMP byte ptr [RCX + -0x1],0x20
JZ 0x00178167
LAB_00178179:
MOV RAX,RCX
JMP 0x00178214
LAB_00178181:
CMP ECX,0x8
JNZ 0x00178286
CMP R8D,0x100
MOV dword ptr [RBP + -0x3c],R13D
MOV qword ptr [RBP + -0x38],RDX
JA 0x001782d0
MOV R14,R8
MOVZX EAX,byte ptr [R12]
MOV byte ptr [RBX],AL
INC RBX
MOV ESI,0x1
JMP 0x001782f8
LAB_001781b6:
MOV EAX,dword ptr [RBP + -0x2c]
OR EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x2c],EAX
LAB_001781bf:
MOV RDX,qword ptr [RBP + -0x38]
MOV R8,R14
JMP 0x001781d5
LAB_001781c8:
MOV EAX,dword ptr [RBP + -0x2c]
OR EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x2c],EAX
LAB_001781d1:
ADD RDX,0x18
LAB_001781d5:
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,EAX
MOV dword ptr [RBP + -0x30],EAX
CMP EAX,0xff
JA 0x00178321
LAB_001781e8:
ADD R12,R8
ADD R15,0x30
TEST R13D,R13D
JNZ 0x00178073
JMP 0x0017834e
LAB_001781fd:
MOV RSI,R12
TEST R8,R8
JZ 0x00178214
LAB_00178205:
CMP byte ptr [RSI],0x20
JNZ 0x00178217
INC RSI
CMP RSI,RAX
JC 0x00178205
JMP 0x00178217
LAB_00178214:
MOV RSI,R12
LAB_00178217:
SUB RAX,RSI
CMP R8D,0x100
SETNC DL
CMP EAX,0x7f
SETA CL
AND CL,DL
MOVZX EDX,CL
ADD EDX,EAX
INC EDX
CMP EDX,R8D
JNC 0x001782b0
MOV RDI,RBX
MOV EBX,0x1
TEST CL,CL
MOV qword ptr [RBP + -0x60],R8
MOV ECX,EAX
JZ 0x0017825a
OR CL,0x80
MOV EDX,EAX
SHR EDX,0x7
MOV byte ptr [RDI + 0x1],DL
MOV EBX,0x2
LAB_0017825a:
ADD RBX,RDI
MOV byte ptr [RDI],CL
MOV R14D,EAX
MOV RDI,RBX
MOV RDX,R14
CALL 0x00129080
ADD RBX,R14
MOV EAX,dword ptr [RBP + -0x2c]
OR EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x2c],EAX
MOV RDX,qword ptr [RBP + -0x38]
MOV R8,qword ptr [RBP + -0x60]
JMP 0x001781d5
LAB_00178286:
MOV RDI,RBX
MOV RSI,R12
MOV qword ptr [RBP + -0x68],RBX
MOV RBX,RDX
MOV RDX,R8
MOV R14,R8
CALL 0x00129080
MOV R8,R14
MOV RDX,RBX
MOV RBX,qword ptr [RBP + -0x68]
ADD RBX,R14
JMP 0x001781e8
LAB_001782b0:
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R8
MOV R14,R8
CALL 0x00129080
MOV R8,R14
ADD RBX,R14
MOV RDX,qword ptr [RBP + -0x38]
JMP 0x001781d5
LAB_001782d0:
MOVZX EAX,word ptr [R12]
MOV R14,R8
CMP EAX,0xfe
JA 0x001782e6
MOV byte ptr [RBX],AL
INC RBX
JMP 0x001782f3
LAB_001782e6:
MOV byte ptr [RBX],0xff
MOV byte ptr [RBX + 0x2],AL
MOV byte ptr [RBX + 0x1],AH
ADD RBX,0x3
LAB_001782f3:
MOV ESI,0x2
LAB_001782f8:
MOV R13,RBX
ADD RSI,R12
MOV EBX,EAX
MOV RDI,R13
MOV RDX,RBX
CALL 0x00129080
ADD R13,RBX
MOV RBX,R13
MOV R13D,dword ptr [RBP + -0x3c]
MOV RDX,qword ptr [RBP + -0x38]
MOV R8,R14
JMP 0x001781e8
LAB_00178321:
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RBP + -0x2c]
MOV byte ptr [RAX],CL
INC RAX
MOV qword ptr [RBP + -0x58],RAX
MOV EAX,R8D
ADD R12,RAX
ADD R15,0x30
TEST R13D,R13D
MOV RSI,qword ptr [RBP + -0x50]
MOV RDI,qword ptr [RBP + -0x48]
JNZ 0x00178065
JMP 0x00178365
LAB_0017834e:
CMP dword ptr [RBP + -0x30],0x1
JZ 0x0017835d
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RBP + -0x2c]
MOV byte ptr [RAX],CL
LAB_0017835d:
MOV RSI,qword ptr [RBP + -0x50]
MOV RDI,qword ptr [RBP + -0x48]
LAB_00178365:
MOV RAX,qword ptr [RDI]
CMP qword ptr [RAX + 0x2c8],0x0
JZ 0x0017837d
MOV AL,byte ptr [RDI + 0x1a8]
MOV byte ptr [RBX],AL
INC RBX
LAB_0017837d:
SUB EBX,ESI
MOV EAX,EBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int _mi_rec_pack(long *param_1,int1 *param_2,ushort *param_3)
{
ushort uVar1;
ushort *puVar2;
int iVar3;
uint uVar4;
ulong uVar5;
byte bVar7;
long lVar8;
byte *pbVar9;
long lVar10;
ushort *puVar11;
uint uVar12;
ulong __n;
int iVar13;
uint *puVar14;
int1 *local_60;
uint local_38;
uint local_34;
ushort *puVar6;
lVar8 = *param_1;
iVar13 = *(int *)(lVar8 + 0x168);
pbVar9 = param_2 + *(uint *)(lVar8 + 0x18c);
if (iVar13 == 0) {
LAB_00178365:
if (*(long *)(*param_1 + 0x2c8) != 0) {
*pbVar9 = *(byte *)(param_1 + 0x35);
pbVar9 = pbVar9 + 1;
}
return (int)pbVar9 - (int)param_2;
}
puVar14 = *(uint **)(lVar8 + 0x230);
lVar8 = param_1[9];
local_60 = param_2;
LAB_00178065:
local_38 = 1;
local_34 = 0;
do {
iVar13 = iVar13 + -1;
uVar1 = (ushort)puVar14[1];
__n = (ulong)uVar1;
uVar4 = *puVar14;
if (uVar4 == 0) {
memcpy(pbVar9,param_3,__n);
pbVar9 = pbVar9 + __n;
}
else {
if (uVar4 == 3) {
iVar3 = bcmp(param_3,zero_string,__n);
if (iVar3 == 0) {
local_34 = local_34 | local_38;
}
else {
memcpy(pbVar9,param_3,__n);
pbVar9 = pbVar9 + __n;
}
}
else if (uVar4 == 4) {
if (*(long *)(lVar8 + 0x10) == 0) {
local_34 = local_34 | local_38;
}
else {
uVar5 = (ulong)(uVar1 - 8);
memcpy(pbVar9,param_3,uVar5);
memcpy(pbVar9 + uVar5,*(void **)((long)param_3 + uVar5),*(size_t *)(lVar8 + 0x10));
pbVar9 = pbVar9 + uVar5 + *(long *)(lVar8 + 0x10);
}
lVar8 = lVar8 + 0x18;
}
else {
uVar12 = (uint)uVar1;
if (2 < uVar4) {
if (uVar4 == 8) {
if (uVar12 < 0x101) {
uVar4 = (uint)(byte)*param_3;
*pbVar9 = (byte)*param_3;
pbVar9 = pbVar9 + 1;
lVar10 = 1;
}
else {
uVar1 = *param_3;
uVar4 = (uint)uVar1;
if (uVar1 < 0xff) {
*pbVar9 = (byte)uVar1;
pbVar9 = pbVar9 + 1;
}
else {
*pbVar9 = 0xff;
pbVar9[2] = (byte)uVar1;
pbVar9[1] = (byte)(uVar1 >> 8);
pbVar9 = pbVar9 + 3;
}
lVar10 = 2;
}
memcpy(pbVar9,(byte *)(lVar10 + (long)param_3),(ulong)uVar4);
pbVar9 = pbVar9 + uVar4;
}
else {
memcpy(pbVar9,param_3,__n);
pbVar9 = pbVar9 + __n;
}
goto LAB_001781e8;
}
puVar6 = (ushort *)((long)param_3 + __n);
puVar2 = puVar6;
puVar11 = param_3;
if (uVar4 == 1) {
do {
puVar6 = puVar2;
if (puVar6 <= param_3) break;
puVar2 = (ushort *)((long)puVar6 + -1);
} while (*(byte *)((long)puVar6 + -1) == 0x20);
}
else if (__n != 0) {
do {
if ((byte)*puVar11 != 0x20) break;
puVar11 = (ushort *)((long)puVar11 + 1);
} while (puVar11 < puVar6);
}
uVar5 = (long)puVar6 - (long)puVar11;
uVar4 = (uint)uVar5;
if ((0x7f < uVar4 && 0xff < uVar12) + uVar4 + 1 < uVar12) {
lVar10 = 1;
bVar7 = (byte)uVar5;
if (0x7f < uVar4 && 0xff < uVar12) {
bVar7 = bVar7 | 0x80;
pbVar9[1] = (byte)(uVar5 >> 7);
lVar10 = 2;
}
*pbVar9 = bVar7;
memcpy(pbVar9 + lVar10,puVar11,uVar5 & 0xffffffff);
pbVar9 = pbVar9 + lVar10 + (uVar5 & 0xffffffff);
local_34 = local_34 | local_38;
}
else {
memcpy(pbVar9,param_3,__n);
pbVar9 = pbVar9 + __n;
}
}
local_38 = local_38 * 2;
if (0xff < local_38) break;
}
LAB_001781e8:
param_3 = (ushort *)((long)param_3 + __n);
puVar14 = puVar14 + 0xc;
if (iVar13 == 0) {
if (local_38 != 1) {
*local_60 = (char)local_34;
}
goto LAB_00178365;
}
} while( true );
*local_60 = (char)local_34;
local_60 = local_60 + 1;
param_3 = (ushort *)((long)param_3 + __n);
puVar14 = puVar14 + 0xc;
if (iVar13 == 0) goto LAB_00178365;
goto LAB_00178065;
}
| |
45,666 | unsigned long nlohmann::json_abi_v3_11_3::detail::hash<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&) | monkey531[P]llama/common/json.hpp | constexpr value_t type() const noexcept
{
return m_data.m_type;
} | O3 | cpp | unsigned long nlohmann::json_abi_v3_11_3::detail::hash<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movzbl (%rdi), %r12d
cmpq $0x9, %r12
ja 0x76a9f
movq %rdi, %r14
leaq 0x3262e(%rip), %rax # 0xa8d0c
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl %r12d, %eax
shll $0x6, %eax
movl %r12d, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
jmp 0x769d9
movq %r14, %rdi
callq 0x76bca
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x64200
jmp 0x76999
movl $0x9e3779b9, %r15d # imm = 0x9E3779B9
movq %r14, %rdi
callq 0x76b16
movl %r12d, %ecx
shll $0x6, %ecx
movl %r12d, %ebx
shrl $0x2, %ebx
orl %ecx, %ebx
addq 0x8(%rax), %rbx
addq %r15, %rbx
subq (%rax), %rbx
xorq %r12, %rbx
movq %r14, %rdi
callq 0x76b16
movzbl 0x20(%rax), %eax
movq %rbx, %rcx
shlq $0x6, %rcx
orq %rax, %rcx
movq %rbx, %r12
shrq $0x2, %r12
addq %r15, %r12
addq %rcx, %r12
xorq %rbx, %r12
movq %r14, %rdi
callq 0x76b16
movq 0x18(%rax), %rcx
addq %r15, %rcx
leaq -0x1(%r15), %rdx
cmpb $0x0, 0x20(%rax)
cmovneq %rcx, %rdx
movq %r12, %rax
shlq $0x6, %rax
addq %rdx, %rax
movq %r12, %rbx
shrq $0x2, %rbx
addq %rax, %rbx
xorq %r12, %rbx
movq %r14, %rdi
callq 0x76b16
movq (%rax), %rcx
movq 0x8(%rax), %rax
cmpq %rax, %rcx
je 0x76a24
movzbl (%rcx), %edx
movq %rbx, %rsi
shlq $0x6, %rsi
movq %rbx, %rdi
shrq $0x2, %rdi
addq %r15, %rsi
addq %rdi, %rsi
addq %rdx, %rsi
xorq %rsi, %rbx
incq %rcx
jmp 0x767a4
movl $0x9e3779b9, %r15d # imm = 0x9E3779B9
movq %r14, %rdi
callq 0x4a6d8
movq %rax, %rbx
movl %r12d, %eax
shll $0x6, %eax
movl %r12d, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
addq %r15, %rbx
addq %rcx, %rbx
xorq %r12, %rbx
leaq 0x78(%rsp), %r13
movq %r14, (%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r13)
movabsq $-0x8000000000000000, %rbp # imm = 0x8000000000000000
movq %rbp, 0x18(%r13)
movq %r13, %rdi
callq 0x4f534
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x7a4dc
leaq 0xe8(%rsp), %r13
movq %r14, (%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r13)
movq %rbp, 0x18(%r13)
movq %r13, %rdi
callq 0x4f87e
leaq 0x78(%rsp), %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x7a4dc
movq %r12, %rdi
leaq 0x78(%rsp), %rsi
callq 0x4f5a6
testb %al, %al
jne 0x76a39
movq %r12, %rdi
callq 0x6f3ca
movq %r13, %rdi
movq %rax, %rsi
callq 0x64200
movq %rax, %r14
movq %r12, %rdi
callq 0x4f23a
movq %rax, %rdi
callq 0x766b5
movq %rax, %rbp
movq %r12, %rdi
callq 0x4f1ec
movq %rbx, %rax
shlq $0x6, %rax
movq %rbx, %rcx
shrq $0x2, %rcx
addq %r15, %rax
addq %rcx, %rax
addq %r14, %rax
xorq %rbx, %rax
movq %rax, %rcx
shlq $0x6, %rcx
movq %rax, %rbx
shrq $0x2, %rbx
addq %r15, %rcx
addq %rbp, %rbx
addq %rcx, %rbx
xorq %rax, %rbx
incq 0x28(%rsp)
jmp 0x7685f
movl $0x9e3779b9, %r13d # imm = 0x9E3779B9
movq %r14, %rdi
callq 0x4a6d8
movq %rax, %r15
movl %r12d, %eax
shll $0x6, %eax
movl %r12d, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
addq %r13, %r15
addq %rcx, %r15
xorq %r12, %r15
leaq 0x8(%rsp), %rbx
movq %r14, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movabsq $-0x8000000000000000, %rbp # imm = 0x8000000000000000
movq %rbp, 0x18(%rbx)
movq %rbx, %rdi
callq 0x4f534
leaq 0x78(%rsp), %r12
movq %r14, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r12)
movq %rbp, 0x18(%r12)
movq %r12, %rdi
callq 0x4f87e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4f5a6
testb %al, %al
je 0x76a4f
movq %r15, %rbx
jmp 0x76a24
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x76d0a
jmp 0x769c8
leaq 0x8(%rsp), %rbx
movb $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40b27
movzbl (%rbx), %eax
movl %r12d, %ecx
shll $0x6, %ecx
movl %r12d, %edx
shrl $0x2, %edx
orl %ecx, %edx
movl $0x9e3779b9, %ebx # imm = 0x9E3779B9
addq %rax, %rbx
jmp 0x76a1e
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3f08d
movl %r12d, %eax
shll $0x6, %eax
movl %r12d, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
addq (%rbx), %rcx
movl $0x9e3779b9, %ebx # imm = 0x9E3779B9
addq %rcx, %rbx
jmp 0x76a21
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4073f
movsd (%rbx), %xmm0
leaq 0x8(%rsp), %rdi
callq 0x76ae4
movl %r12d, %ecx
shll $0x6, %ecx
movl %r12d, %edx
shrl $0x2, %edx
orl %ecx, %edx
addq %rax, %rdx
movl $0x9e3779b9, %ebx # imm = 0x9E3779B9
addq %rdx, %rbx
xorq %r12, %rbx
movq %rbx, %rax
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x78(%rsp), %rdi
callq 0x6f438
leaq 0x8(%rsp), %rdi
callq 0x6f438
jmp 0x76a24
leaq 0x8(%rsp), %r14
leaq 0x78(%rsp), %r12
movq %r15, %rbx
movq %r14, %rdi
callq 0x4f23a
movq %rax, %rdi
callq 0x766b5
shlq $0x6, %rbx
movq %r15, %rcx
shrq $0x2, %rcx
addq %r13, %rbx
addq %rcx, %rbx
addq %rax, %rbx
xorq %r15, %rbx
movq %r14, %rdi
callq 0x4f1ec
movq %r14, %rdi
movq %r12, %rsi
callq 0x4f5a6
movq %rbx, %r15
testb %al, %al
je 0x76a5c
jmp 0x76a24
leaq 0x33cf7(%rip), %rdi # 0xaa79d
leaq 0x324c4(%rip), %rdx # 0xa8f71
leaq 0x3251b(%rip), %rcx # 0xa8fcf
movl $0x17d9, %esi # imm = 0x17D9
xorl %eax, %eax
callq 0x18af0
jmp 0x76ac4
jmp 0x76ac4
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x6f438
leaq 0x8(%rsp), %rdi
callq 0x6f438
movq %rbx, %rdi
callq 0x18bc0
nop
| _ZN8nlohmann16json_abi_v3_11_36detail4hashINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEmRKT_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 108h
movzx r12d, byte ptr [rdi]
cmp r12, 9; switch 10 cases
ja def_766E5; jumptable 00000000000766E5 default case
mov r14, rdi
lea rax, jpt_766E5
movsxd rcx, ds:(jpt_766E5 - 0A8D0Ch)[rax+r12*4]
add rcx, rax
jmp rcx; switch jump
loc_766E7:
mov eax, r12d; jumptable 00000000000766E5 cases 0,9
shl eax, 6
mov ecx, r12d
shr ecx, 2
or ecx, eax
jmp loc_769D9
loc_766FA:
mov rdi, r14; jumptable 00000000000766E5 case 3
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12get_ref_implIRKS9_KSD_EET_RT0_; 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>::get_ref_impl<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> 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> const &)
lea rdi, [rsp+138h+var_130]
mov rsi, rax
call _ZNKSt4hashINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclERKS5_; std::hash<std::string>::operator()(std::string const&)
jmp loc_76999
loc_76714:
mov r15d, 9E3779B9h; jumptable 00000000000766E5 case 8
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10get_binaryEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::get_binary(void)
mov ecx, r12d
shl ecx, 6
mov ebx, r12d
shr ebx, 2
or ebx, ecx
add rbx, [rax+8]
add rbx, r15
sub rbx, [rax]
xor rbx, r12
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10get_binaryEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::get_binary(void)
movzx eax, byte ptr [rax+20h]
mov rcx, rbx
shl rcx, 6
or rcx, rax
mov r12, rbx
shr r12, 2
add r12, r15
add r12, rcx
xor r12, rbx
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10get_binaryEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::get_binary(void)
mov rcx, [rax+18h]
add rcx, r15
lea rdx, [r15-1]
cmp byte ptr [rax+20h], 0
cmovnz rdx, rcx
mov rax, r12
shl rax, 6
add rax, rdx
mov rbx, r12
shr rbx, 2
add rbx, rax
xor rbx, r12
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10get_binaryEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::get_binary(void)
mov rcx, [rax]
mov rax, [rax+8]
loc_767A4:
cmp rcx, rax
jz loc_76A24
movzx edx, byte ptr [rcx]
mov rsi, rbx
shl rsi, 6
mov rdi, rbx
shr rdi, 2
add rsi, r15
add rsi, rdi
add rsi, rdx
xor rbx, rsi
inc rcx
jmp short loc_767A4
loc_767CF:
mov r15d, 9E3779B9h; jumptable 00000000000766E5 case 1
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4sizeEv; 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>::size(void)
mov rbx, rax
mov eax, r12d
shl eax, 6
mov ecx, r12d
shr ecx, 2
or ecx, eax
add rbx, r15
add rbx, rcx
xor rbx, r12
lea r13, [rsp+138h+var_C0]
mov [r13+0], r14
xorps xmm0, xmm0
movups xmmword ptr [r13+8], xmm0
mov rbp, 8000000000000000h
mov [r13+18h], rbp
mov rdi, r13
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE9set_beginEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::set_begin(void)
lea r12, [rsp+138h+var_130]
mov rdi, r12
mov rsi, r13
xor edx, edx
call _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEEC2ESI_m; nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>,ulong)
lea r13, [rsp+138h+var_50]
mov [r13+0], r14
xorps xmm0, xmm0
movups xmmword ptr [r13+8], xmm0
mov [r13+18h], rbp
mov rdi, r13
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE7set_endEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::set_end(void)
lea rdi, [rsp+138h+var_C0]
mov rsi, r13
xor edx, edx
call _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEEC2ESI_m; nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>,ulong)
loc_7685F:
mov rdi, r12
lea rsi, [rsp+138h+var_C0]
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
test al, al
jnz loc_76A39
mov rdi, r12
call _ZNK8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEE3keyEv; nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>>::key(void)
mov rdi, r13
mov rsi, rax
call _ZNKSt4hashINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclERKS5_; std::hash<std::string>::operator()(std::string const&)
mov r14, rax
mov rdi, r12
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEdeEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator*(void)
mov rdi, rax
call _ZN8nlohmann16json_abi_v3_11_36detail4hashINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEmRKT_; nlohmann::json_abi_v3_11_3::detail::hash<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::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rbp, rax
mov rdi, r12
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator++(void)
mov rax, rbx
shl rax, 6
mov rcx, rbx
shr rcx, 2
add rax, r15
add rax, rcx
add rax, r14
xor rax, rbx
mov rcx, rax
shl rcx, 6
mov rbx, rax
shr rbx, 2
add rcx, r15
add rbx, rbp
add rbx, rcx
xor rbx, rax
inc [rsp+138h+var_110]
jmp loc_7685F
loc_768E3:
mov r13d, 9E3779B9h; jumptable 00000000000766E5 case 2
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4sizeEv; 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>::size(void)
mov r15, rax
mov eax, r12d
shl eax, 6
mov ecx, r12d
shr ecx, 2
or ecx, eax
add r15, r13
add r15, rcx
xor r15, r12
lea rbx, [rsp+138h+var_130]
mov [rbx], r14
xorps xmm0, xmm0
movups xmmword ptr [rbx+8], xmm0
mov rbp, 8000000000000000h
mov [rbx+18h], rbp
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE9set_beginEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::set_begin(void)
lea r12, [rsp+138h+var_C0]
mov [r12], r14
xorps xmm0, xmm0
movups xmmword ptr [r12+8], xmm0
mov [r12+18h], rbp
mov rdi, r12
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE7set_endEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::set_end(void)
mov rdi, rbx
mov rsi, r12
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
test al, al
jz loc_76A4F
mov rbx, r15
jmp loc_76A24
loc_7696A:
lea rbx, [rsp+138h+var_130]; jumptable 00000000000766E5 case 6
mov qword ptr [rbx], 0
mov rdi, r14
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEmTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
jmp short loc_769C8
loc_76983:
lea rbx, [rsp+138h+var_130]; jumptable 00000000000766E5 case 4
mov byte ptr [rbx], 0
mov rdi, r14
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEvRKT_RNSG_9boolean_tE; nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,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>::boolean_t &)
movzx eax, byte ptr [rbx]
loc_76999:
mov ecx, r12d
shl ecx, 6
mov edx, r12d
shr edx, 2
or edx, ecx
mov ebx, 9E3779B9h
add rbx, rax
jmp short loc_76A1E
loc_769B1:
lea rbx, [rsp+138h+var_130]; jumptable 00000000000766E5 case 5
mov qword ptr [rbx], 0
mov rdi, r14
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEElTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
loc_769C8:
mov eax, r12d
shl eax, 6
mov ecx, r12d
shr ecx, 2
or ecx, eax
add rcx, [rbx]
loc_769D9:
mov ebx, 9E3779B9h
add rbx, rcx
jmp short loc_76A21
loc_769E3:
lea rbx, [rsp+138h+var_130]; jumptable 00000000000766E5 case 7
mov qword ptr [rbx], 0
mov rdi, r14
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEdTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
movsd xmm0, qword ptr [rbx]
lea rdi, [rsp+138h+var_130]
call _ZNKSt4hashIdEclEd; std::hash<double>::operator()(double)
mov ecx, r12d
shl ecx, 6
mov edx, r12d
shr edx, 2
or edx, ecx
add rdx, rax
mov ebx, 9E3779B9h
loc_76A1E:
add rbx, rdx
loc_76A21:
xor rbx, r12
loc_76A24:
mov rax, rbx
add rsp, 108h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_76A39:
lea rdi, [rsp+138h+var_C0]
call _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEED2Ev; nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>>::~iteration_proxy_value()
lea rdi, [rsp+138h+var_130]
call _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEED2Ev; nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>>::~iteration_proxy_value()
jmp short loc_76A24
loc_76A4F:
lea r14, [rsp+138h+var_130]
lea r12, [rsp+138h+var_C0]
mov rbx, r15
loc_76A5C:
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEdeEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator*(void)
mov rdi, rax
call _ZN8nlohmann16json_abi_v3_11_36detail4hashINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEmRKT_; nlohmann::json_abi_v3_11_3::detail::hash<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::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
shl rbx, 6
mov rcx, r15
shr rcx, 2
add rbx, r13
add rbx, rcx
add rbx, rax
xor rbx, r15
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator++(void)
mov rdi, r14
mov rsi, r12
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
mov r15, rbx
test al, al
jz short loc_76A5C
jmp short loc_76A24
def_766E5:
lea rdi, aWorkspaceLlm4b_0; jumptable 00000000000766E5 default case
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aFalse; "false"
mov esi, 17D9h
xor eax, eax
call _ggml_abort
jmp short loc_76AC4
jmp short $+2
loc_76AC4:
mov rbx, rax
lea rdi, [rsp+138h+var_C0]
call _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEED2Ev; nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>>::~iteration_proxy_value()
lea rdi, [rsp+138h+var_130]
call _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEED2Ev; nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>>::~iteration_proxy_value()
mov rdi, rbx
call __Unwind_Resume
| unsigned long long nlohmann::json_abi_v3_11_3::detail::hash<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>>(
unsigned __int8 *a1)
{
long long v1; // r12
unsigned __int8 *v2; // rcx
long long v3; // rax
long long v4; // rax
_QWORD *binary; // rax
unsigned long long v6; // rbx
unsigned long long v7; // r12
long long v8; // rax
long long v9; // rdx
unsigned long long v10; // rbx
unsigned __int8 **v11; // rax
unsigned __int8 *v12; // rcx
unsigned __int8 *v13; // rax
long long v14; // rax
long long v15; // r14
long long v16; // rax
long long v17; // rbp
unsigned long long v18; // r15
long long v19; // rdx
long long v20; // rbx
long long v21; // rbx
long long v23; // rax
long long v24; // rbx
unsigned __int8 *v25; // [rsp+8h] [rbp-130h] BYREF
__int128 v26; // [rsp+10h] [rbp-128h]
unsigned long long v27; // [rsp+20h] [rbp-118h]
long long v28; // [rsp+28h] [rbp-110h]
unsigned __int8 *v29; // [rsp+78h] [rbp-C0h] BYREF
__int128 v30; // [rsp+80h] [rbp-B8h]
unsigned long long v31; // [rsp+90h] [rbp-A8h]
unsigned __int8 *v32; // [rsp+E8h] [rbp-50h] BYREF
__int128 v33; // [rsp+F0h] [rbp-48h]
unsigned long long v34; // [rsp+100h] [rbp-38h]
v1 = *a1;
switch ( *a1 )
{
case 0u:
case 9u:
v2 = (unsigned __int8 *)(((_DWORD)v1 << 6) | ((unsigned int)v1 >> 2));
goto LABEL_19;
case 1u:
v10 = v1 ^ ((((_DWORD)v1 << 6) | ((unsigned int)v1 >> 2))
+ 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>::size(a1)
+ 2654435769LL);
v29 = a1;
v30 = 0LL;
v31 = 0x8000000000000000LL;
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::set_begin(&v29);
nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::iteration_proxy_value(
&v25,
&v29,
0LL);
v32 = a1;
v33 = 0LL;
v34 = 0x8000000000000000LL;
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::set_end(&v32);
nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::iteration_proxy_value(
&v29,
&v32,
0LL);
while ( !(unsigned __int8)ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_(
&v25,
&v29) )
{
v14 = nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::key(&v25);
v15 = std::hash<std::string>::operator()((long long)&v32, v14);
v16 = nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator*(&v25);
v17 = nlohmann::json_abi_v3_11_3::detail::hash<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>>(v16);
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator++(&v25);
v10 ^= (v15 + (v10 >> 2) + (v10 << 6) + 2654435769u) ^ (((v10 ^ (v15 + (v10 >> 2) + (v10 << 6) + 2654435769u)) << 6)
+ 2654435769u
+ v17
+ ((v10 ^ (v15 + (v10 >> 2) + (v10 << 6) + 2654435769u)) >> 2));
++v28;
}
nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::~iteration_proxy_value(&v29);
nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::~iteration_proxy_value(&v25);
return v10;
case 2u:
v18 = v1 ^ ((((_DWORD)v1 << 6) | ((unsigned int)v1 >> 2))
+ 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>::size(a1)
+ 2654435769LL);
v25 = a1;
v26 = 0LL;
v27 = 0x8000000000000000LL;
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::set_begin(&v25);
v29 = a1;
v30 = 0LL;
v31 = 0x8000000000000000LL;
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::set_end(&v29);
if ( (unsigned __int8)ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_(
&v25,
&v29) )
return v18;
v10 = v18;
do
{
v23 = nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator*(&v25);
v10 = v18 ^ (nlohmann::json_abi_v3_11_3::detail::hash<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>>(v23)
+ (v18 >> 2)
+ (v10 << 6)
+ 2654435769u);
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator++(&v25);
v18 = v10;
}
while ( !(unsigned __int8)ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_(
&v25,
&v29) );
return v10;
case 3u:
v3 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::get_ref_impl<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> const>(a1);
v4 = std::hash<std::string>::operator()((long long)&v25, v3);
goto LABEL_16;
case 4u:
LOBYTE(v25) = 0;
nlohmann::json_abi_v3_11_3::detail::from_json<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>>(
a1,
(unsigned __int8 *)&v25);
v4 = (unsigned __int8)v25;
LABEL_16:
v19 = ((_DWORD)v1 << 6) | ((unsigned int)v1 >> 2);
v20 = v4 + 2654435769LL;
goto LABEL_21;
case 5u:
v25 = 0LL;
ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEElTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_(
a1,
&v25);
goto LABEL_18;
case 6u:
v25 = 0LL;
ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEmTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_(
a1,
&v25);
LABEL_18:
v2 = &v25[((_DWORD)v1 << 6) | ((unsigned int)v1 >> 2)];
LABEL_19:
v21 = (long long)(v2 + 2654435769LL);
goto LABEL_22;
case 7u:
v25 = 0LL;
ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEdTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_(
a1,
(double *)&v25);
v19 = std::hash<double>::operator()(&v25, *(double *)&v25) + (((_DWORD)v1 << 6) | ((unsigned int)v1 >> 2));
v20 = 2654435769LL;
LABEL_21:
v21 = v19 + v20;
LABEL_22:
v10 = v1 ^ v21;
break;
case 8u:
binary = (_QWORD *)nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::get_binary(a1);
v6 = v1 ^ (binary[1] + (((_DWORD)v1 << 6) | ((unsigned int)v1 >> 2)) + 2654435769LL - *binary);
v7 = v6 ^ ((*(unsigned __int8 *)(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::get_binary(a1)
+ 32) | (v6 << 6))
+ (v6 >> 2)
+ 2654435769u);
v8 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::get_binary(a1);
v9 = 2654435768LL;
if ( *(_BYTE *)(v8 + 32) )
v9 = *(_QWORD *)(v8 + 24) + 2654435769LL;
v10 = v7 ^ (v9 + (v7 << 6) + (v7 >> 2));
v11 = (unsigned __int8 **)nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::get_binary(a1);
v12 = *v11;
v13 = v11[1];
while ( v12 != v13 )
v10 ^= *v12++ + (v10 >> 2) + (v10 << 6) + 2654435769u;
break;
default:
v24 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
6105LL,
"GGML_ASSERT(%s) failed",
"false");
nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::~iteration_proxy_value(&v29);
nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::~iteration_proxy_value(&v25);
_Unwind_Resume(v24);
}
return v10;
}
| hash<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>>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x108
MOVZX R12D,byte ptr [RDI]
CMP R12,0x9
JA 0x00176a9f
MOV R14,RDI
LEA RAX,[0x1a8d0c]
MOVSXD RCX,dword ptr [RAX + R12*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_0:
MOV EAX,R12D
SHL EAX,0x6
MOV ECX,R12D
SHR ECX,0x2
OR ECX,EAX
JMP 0x001769d9
caseD_3:
MOV RDI,R14
CALL 0x00176bca
LEA RDI,[RSP + 0x8]
MOV RSI,RAX
CALL 0x00164200
JMP 0x00176999
caseD_8:
MOV R15D,0x9e3779b9
MOV RDI,R14
CALL 0x00176b16
MOV ECX,R12D
SHL ECX,0x6
MOV EBX,R12D
SHR EBX,0x2
OR EBX,ECX
ADD RBX,qword ptr [RAX + 0x8]
ADD RBX,R15
SUB RBX,qword ptr [RAX]
XOR RBX,R12
MOV RDI,R14
CALL 0x00176b16
MOVZX EAX,byte ptr [RAX + 0x20]
MOV RCX,RBX
SHL RCX,0x6
OR RCX,RAX
MOV R12,RBX
SHR R12,0x2
ADD R12,R15
ADD R12,RCX
XOR R12,RBX
MOV RDI,R14
CALL 0x00176b16
MOV RCX,qword ptr [RAX + 0x18]
ADD RCX,R15
LEA RDX,[R15 + -0x1]
CMP byte ptr [RAX + 0x20],0x0
CMOVNZ RDX,RCX
MOV RAX,R12
SHL RAX,0x6
ADD RAX,RDX
MOV RBX,R12
SHR RBX,0x2
ADD RBX,RAX
XOR RBX,R12
MOV RDI,R14
CALL 0x00176b16
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x8]
LAB_001767a4:
CMP RCX,RAX
JZ 0x00176a24
MOVZX EDX,byte ptr [RCX]
MOV RSI,RBX
SHL RSI,0x6
MOV RDI,RBX
SHR RDI,0x2
ADD RSI,R15
ADD RSI,RDI
ADD RSI,RDX
XOR RBX,RSI
INC RCX
JMP 0x001767a4
caseD_1:
MOV R15D,0x9e3779b9
MOV RDI,R14
CALL 0x0014a6d8
MOV RBX,RAX
MOV EAX,R12D
SHL EAX,0x6
MOV ECX,R12D
SHR ECX,0x2
OR ECX,EAX
ADD RBX,R15
ADD RBX,RCX
XOR RBX,R12
LEA R13,[RSP + 0x78]
MOV qword ptr [R13],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R13 + 0x8],XMM0
MOV RBP,-0x8000000000000000
MOV qword ptr [R13 + 0x18],RBP
MOV RDI,R13
CALL 0x0014f534
LEA R12,[RSP + 0x8]
MOV RDI,R12
MOV RSI,R13
XOR EDX,EDX
CALL 0x0017a4dc
LEA R13,[RSP + 0xe8]
MOV qword ptr [R13],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R13 + 0x8],XMM0
MOV qword ptr [R13 + 0x18],RBP
MOV RDI,R13
CALL 0x0014f87e
LEA RDI,[RSP + 0x78]
MOV RSI,R13
XOR EDX,EDX
CALL 0x0017a4dc
LAB_0017685f:
MOV RDI,R12
LEA RSI,[RSP + 0x78]
CALL 0x0014f5a6
TEST AL,AL
JNZ 0x00176a39
LAB_00176874:
MOV RDI,R12
CALL 0x0016f3ca
MOV RDI,R13
MOV RSI,RAX
CALL 0x00164200
MOV R14,RAX
LAB_0017688a:
MOV RDI,R12
CALL 0x0014f23a
MOV RDI,RAX
CALL 0x001766b5
LAB_0017689a:
MOV RBP,RAX
MOV RDI,R12
CALL 0x0014f1ec
LAB_001768a5:
MOV RAX,RBX
SHL RAX,0x6
MOV RCX,RBX
SHR RCX,0x2
ADD RAX,R15
ADD RAX,RCX
ADD RAX,R14
XOR RAX,RBX
MOV RCX,RAX
SHL RCX,0x6
MOV RBX,RAX
SHR RBX,0x2
ADD RCX,R15
ADD RBX,RBP
ADD RBX,RCX
XOR RBX,RAX
INC qword ptr [RSP + 0x28]
JMP 0x0017685f
caseD_2:
MOV R13D,0x9e3779b9
MOV RDI,R14
CALL 0x0014a6d8
MOV R15,RAX
MOV EAX,R12D
SHL EAX,0x6
MOV ECX,R12D
SHR ECX,0x2
OR ECX,EAX
ADD R15,R13
ADD R15,RCX
XOR R15,R12
LEA RBX,[RSP + 0x8]
MOV qword ptr [RBX],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x8],XMM0
MOV RBP,-0x8000000000000000
MOV qword ptr [RBX + 0x18],RBP
MOV RDI,RBX
CALL 0x0014f534
LEA R12,[RSP + 0x78]
MOV qword ptr [R12],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R12 + 0x8],XMM0
MOV qword ptr [R12 + 0x18],RBP
MOV RDI,R12
CALL 0x0014f87e
MOV RDI,RBX
MOV RSI,R12
CALL 0x0014f5a6
TEST AL,AL
JZ 0x00176a4f
MOV RBX,R15
JMP 0x00176a24
caseD_6:
LEA RBX,[RSP + 0x8]
MOV qword ptr [RBX],0x0
MOV RDI,R14
MOV RSI,RBX
CALL 0x00176d0a
JMP 0x001769c8
caseD_4:
LEA RBX,[RSP + 0x8]
MOV byte ptr [RBX],0x0
MOV RDI,R14
MOV RSI,RBX
CALL 0x00140b27
MOVZX EAX,byte ptr [RBX]
LAB_00176999:
MOV ECX,R12D
SHL ECX,0x6
MOV EDX,R12D
SHR EDX,0x2
OR EDX,ECX
MOV EBX,0x9e3779b9
ADD RBX,RAX
JMP 0x00176a1e
caseD_5:
LEA RBX,[RSP + 0x8]
MOV qword ptr [RBX],0x0
MOV RDI,R14
MOV RSI,RBX
CALL 0x0013f08d
LAB_001769c8:
MOV EAX,R12D
SHL EAX,0x6
MOV ECX,R12D
SHR ECX,0x2
OR ECX,EAX
ADD RCX,qword ptr [RBX]
LAB_001769d9:
MOV EBX,0x9e3779b9
ADD RBX,RCX
JMP 0x00176a21
caseD_7:
LEA RBX,[RSP + 0x8]
MOV qword ptr [RBX],0x0
MOV RDI,R14
MOV RSI,RBX
CALL 0x0014073f
MOVSD XMM0,qword ptr [RBX]
LEA RDI,[RSP + 0x8]
CALL 0x00176ae4
MOV ECX,R12D
SHL ECX,0x6
MOV EDX,R12D
SHR EDX,0x2
OR EDX,ECX
ADD RDX,RAX
MOV EBX,0x9e3779b9
LAB_00176a1e:
ADD RBX,RDX
LAB_00176a21:
XOR RBX,R12
LAB_00176a24:
MOV RAX,RBX
ADD RSP,0x108
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00176a39:
LEA RDI,[RSP + 0x78]
CALL 0x0016f438
LEA RDI,[RSP + 0x8]
CALL 0x0016f438
JMP 0x00176a24
LAB_00176a4f:
LEA R14,[RSP + 0x8]
LEA R12,[RSP + 0x78]
MOV RBX,R15
LAB_00176a5c:
MOV RDI,R14
CALL 0x0014f23a
MOV RDI,RAX
CALL 0x001766b5
SHL RBX,0x6
MOV RCX,R15
SHR RCX,0x2
ADD RBX,R13
ADD RBX,RCX
ADD RBX,RAX
XOR RBX,R15
MOV RDI,R14
CALL 0x0014f1ec
MOV RDI,R14
MOV RSI,R12
CALL 0x0014f5a6
MOV R15,RBX
TEST AL,AL
JZ 0x00176a5c
JMP 0x00176a24
default:
LEA RDI,[0x1aa79d]
LEA RDX,[0x1a8f71]
LEA RCX,[0x1a8fcf]
MOV ESI,0x17d9
XOR EAX,EAX
CALL 0x00118af0
|
/* unsigned long
nlohmann::json_abi_v3_11_3::detail::hash<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&) */
ulong nlohmann::json_abi_v3_11_3::detail::
hash<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(basic_json *param_1)
{
basic_json bVar1;
char cVar2;
string *psVar3;
ulong uVar4;
long *plVar5;
long lVar6;
long lVar7;
int8 *puVar8;
byte *pbVar9;
ulong uVar10;
basic_json *pbVar11;
ulong uVar12;
basic_json *local_130;
int8 local_128;
int8 uStack_120;
int8 local_118;
long local_110;
basic_json *local_c0;
int8 local_b8;
int8 uStack_b0;
int8 local_a8;
basic_json *local_50;
int8 local_48;
int8 uStack_40;
int8 local_38;
bVar1 = *param_1;
uVar12 = (ulong)(byte)bVar1;
local_c0 = param_1;
switch(uVar12) {
case 0:
case 9:
pbVar11 = (basic_json *)(ulong)((uint)((byte)bVar1 >> 2) | (uint)(byte)bVar1 << 6);
goto LAB_001769d9;
case 1:
lVar6 = 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>
::size((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1);
uVar12 = lVar6 + 0x9e3779b9 + (ulong)((uint)((byte)bVar1 >> 2) | (uint)(byte)bVar1 << 6) ^
uVar12;
local_b8 = 0;
uStack_b0 = 0;
local_a8 = 0x8000000000000000;
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::set_begin((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_c0);
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
::iteration_proxy_value
((iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
*)&local_130,
(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_c0,0);
local_48 = 0;
uStack_40 = 0;
local_38 = 0x8000000000000000;
local_50 = param_1;
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::set_end((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_50);
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
::iteration_proxy_value
((iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
*)&local_c0,
(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_50,0);
/* try { // try from 0017685f to 0017686b has its CatchHandler @ 00176ac4 */
while (cVar2 = _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
((iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
*)&local_130,&local_c0), cVar2 == '\0') {
/* try { // try from 00176874 to 0017687b has its CatchHandler @ 00176ac0 */
psVar3 = (string *)
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
::key((iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
*)&local_130);
lVar6 = std::hash<std::__cxx11::string>::operator()
((hash<std::__cxx11::string> *)&local_50,psVar3);
/* try { // try from 0017688a to 00176899 has its CatchHandler @ 00176ac2 */
pbVar11 = (basic_json *)
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator*((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_130);
uVar10 = hash<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>>
(pbVar11);
/* try { // try from 0017689a to 001768a4 has its CatchHandler @ 00176ac4 */
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator++((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_130);
uVar12 = uVar12 * 0x40 + 0x9e3779b9 + (uVar12 >> 2) + lVar6 ^ uVar12;
uVar12 = (uVar12 >> 2) + uVar10 + uVar12 * 0x40 + 0x9e3779b9 ^ uVar12;
local_110 = local_110 + 1;
}
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
::~iteration_proxy_value
((iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
*)&local_c0);
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
::~iteration_proxy_value
((iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
*)&local_130);
break;
case 2:
lVar6 = 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>
::size((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1);
uVar12 = lVar6 + 0x9e3779b9 + (ulong)((uint)((byte)bVar1 >> 2) | (uint)(byte)bVar1 << 6) ^
uVar12;
local_128 = 0;
uStack_120 = 0;
local_118 = 0x8000000000000000;
local_130 = param_1;
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::set_begin((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_130);
local_b8 = 0;
uStack_b0 = 0;
local_a8 = 0x8000000000000000;
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::set_end((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_c0);
cVar2 = _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_130,
(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_c0);
if (cVar2 == '\0') {
do {
pbVar11 = (basic_json *)
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator*((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_130);
uVar10 = hash<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>>
(pbVar11);
uVar12 = uVar12 * 0x40 + 0x9e3779b9 + (uVar12 >> 2) + uVar10 ^ uVar12;
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator++((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_130);
cVar2 = _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_130,&local_c0);
} while (cVar2 == '\0');
}
break;
case 3:
psVar3 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::
get_ref_impl<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>const>
(param_1);
uVar4 = std::hash<std::__cxx11::string>::operator()
((hash<std::__cxx11::string> *)&local_130,psVar3);
goto LAB_00176999;
case 4:
local_130 = (basic_json *)((ulong)local_130 & 0xffffffffffffff00);
from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(param_1,(boolean_t *)&local_130);
uVar4 = (ulong)local_130 & 0xff;
LAB_00176999:
uVar10 = (ulong)((uint)((byte)bVar1 >> 2) | (uint)(byte)bVar1 << 6);
lVar6 = uVar4 + 0x9e3779b9;
LAB_00176a1e:
pbVar11 = (basic_json *)(lVar6 + uVar10);
LAB_00176a21:
uVar12 = (ulong)pbVar11 ^ uVar12;
break;
case 5:
local_130 = (basic_json *)0x0;
_ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEElTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
(param_1,&local_130);
goto LAB_001769c8;
case 6:
local_130 = (basic_json *)0x0;
_ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEmTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
(param_1,&local_130);
LAB_001769c8:
pbVar11 = local_130 + ((uint)((byte)bVar1 >> 2) | (uint)(byte)bVar1 << 6);
LAB_001769d9:
pbVar11 = pbVar11 + 0x9e3779b9;
goto LAB_00176a21;
case 7:
local_130 = (basic_json *)0x0;
_ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEdTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
(param_1,&local_130);
lVar6 = std::hash<double>::operator()((hash<double> *)&local_130,(double)local_130);
uVar10 = (ulong)((uint)((byte)bVar1 >> 2) | (uint)(byte)bVar1 << 6) + lVar6;
lVar6 = 0x9e3779b9;
goto LAB_00176a1e;
case 8:
plVar5 = (long *)basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::get_binary((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1);
uVar12 = ((ulong)((uint)((byte)bVar1 >> 2) | (uint)(byte)bVar1 << 6) + plVar5[1] + 0x9e3779b9) -
*plVar5 ^ uVar12;
lVar6 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::get_binary((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1);
uVar12 = (uVar12 >> 2) + 0x9e3779b9 + (uVar12 << 6 | (ulong)*(byte *)(lVar6 + 0x20)) ^ uVar12;
lVar7 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::get_binary((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1);
lVar6 = 0x9e3779b8;
if (*(char *)(lVar7 + 0x20) != '\0') {
lVar6 = *(long *)(lVar7 + 0x18) + 0x9e3779b9;
}
uVar12 = (uVar12 >> 2) + uVar12 * 0x40 + lVar6 ^ uVar12;
puVar8 = (int8 *)
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::get_binary((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1);
for (pbVar9 = (byte *)*puVar8; pbVar9 != (byte *)puVar8[1]; pbVar9 = pbVar9 + 1) {
uVar12 = uVar12 ^ uVar12 * 0x40 + 0x9e3779b9 + (uVar12 >> 2) + (ulong)*pbVar9;
}
break;
default:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x17d9,
"GGML_ASSERT(%s) failed","false");
}
return uVar12;
}
| |
45,667 | JS_DeletePropertyInt64 | bluesky950520[P]quickjs/quickjs.c | int JS_DeletePropertyInt64(JSContext *ctx, JSValue obj, int64_t idx, int flags)
{
JSAtom prop;
int res;
if ((uint64_t)idx <= JS_ATOM_MAX_INT) {
/* fast path for fast arrays */
return JS_DeleteProperty(ctx, obj, __JS_AtomFromUInt32(idx), flags);
}
prop = JS_NewAtomInt64(ctx, idx);
if (prop == JS_ATOM_NULL)
return -1;
res = JS_DeleteProperty(ctx, obj, prop, flags);
JS_FreeAtom(ctx, prop);
return res;
} | O2 | c | JS_DeletePropertyInt64:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
cmpq $0x7fffffff, %rcx # imm = 0x7FFFFFFF
ja 0x24c95
orl $0x80000000, %ecx # imm = 0x80000000
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x246a7
movq %r14, %rdi
movq %rcx, %rsi
callq 0x21f56
testl %eax, %eax
je 0x24cc9
movl %eax, %ebp
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %eax, %ecx
movl %ebx, %r8d
callq 0x246a7
movl %eax, %ebx
movq %r14, %rdi
movl %ebp, %esi
callq 0x1e545
movl %ebx, %eax
jmp 0x24ccc
pushq $-0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| JS_DeletePropertyInt64:
push rbp
push r15
push r14
push r12
push rbx
mov ebx, r8d
mov r15, rdx
mov r12, rsi
mov r14, rdi
cmp rcx, 7FFFFFFFh
ja short loc_24C95
or ecx, 80000000h
mov rdi, r14
mov rsi, r12
mov rdx, r15
mov r8d, ebx
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp JS_DeleteProperty
loc_24C95:
mov rdi, r14
mov rsi, rcx
call JS_NewAtomInt64
test eax, eax
jz short loc_24CC9
mov ebp, eax
mov rdi, r14
mov rsi, r12
mov rdx, r15
mov ecx, eax
mov r8d, ebx
call JS_DeleteProperty
mov ebx, eax
mov rdi, r14
mov esi, ebp
call JS_FreeAtom
mov eax, ebx
jmp short loc_24CCC
loc_24CC9:
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_24CCC:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long JS_DeletePropertyInt64(
long long a1,
long long a2,
long long a3,
unsigned long long a4,
__int16 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
unsigned int v16; // eax
double v17; // xmm4_8
double v18; // xmm5_8
int v19; // ebp
unsigned int v20; // ebx
if ( a4 <= 0x7FFFFFFF )
return JS_DeleteProperty(a1, a6, a7, a8, a9, a10, a11, a12, a13, a2, a3, (unsigned int)a4 | 0x80000000, a5);
v16 = JS_NewAtomInt64(a1, a4);
if ( !v16 )
return -1LL;
v19 = v16;
v20 = JS_DeleteProperty(a1, a6, a7, a8, a9, v17, v18, a12, a13, a2, a3, v16, a5);
JS_FreeAtom(a1, v19);
return v20;
}
| JS_DeletePropertyInt64:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV EBX,R8D
MOV R15,RDX
MOV R12,RSI
MOV R14,RDI
CMP RCX,0x7fffffff
JA 0x00124c95
OR ECX,0x80000000
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
MOV R8D,EBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x001246a7
LAB_00124c95:
MOV RDI,R14
MOV RSI,RCX
CALL 0x00121f56
TEST EAX,EAX
JZ 0x00124cc9
MOV EBP,EAX
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
MOV ECX,EAX
MOV R8D,EBX
CALL 0x001246a7
MOV EBX,EAX
MOV RDI,R14
MOV ESI,EBP
CALL 0x0011e545
MOV EAX,EBX
JMP 0x00124ccc
LAB_00124cc9:
PUSH -0x1
POP RAX
LAB_00124ccc:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
ulong JS_DeletePropertyInt64
(int8 param_1,int8 param_2,int8 param_3,ulong param_4,
int4 param_5)
{
int iVar1;
uint uVar2;
ulong uVar3;
if (param_4 < 0x80000000) {
uVar3 = JS_DeleteProperty(param_1,param_2,param_3,(uint)param_4 | 0x80000000,param_5);
return uVar3;
}
iVar1 = JS_NewAtomInt64(param_1,param_4);
if (iVar1 == 0) {
uVar3 = 0xffffffffffffffff;
}
else {
uVar2 = JS_DeleteProperty(param_1,param_2,param_3,iVar1,param_5);
uVar3 = (ulong)uVar2;
JS_FreeAtom(param_1,iVar1);
}
return uVar3;
}
| |
45,668 | read_long_data2 | eloqsql/storage/maria/ma_blockrec.c | static my_bool read_long_data2(MARIA_HA *info, uchar *to, ulong length,
MARIA_EXTENT_CURSOR *extent,
uchar **data, uchar **end_of_data)
{
uint left_length= (uint) (*end_of_data - *data);
DBUG_ENTER("read_long_data2");
DBUG_PRINT("enter", ("length: %lu left_length: %u",
length, left_length));
DBUG_ASSERT(*data <= *end_of_data);
/*
Fields are never split in middle. This means that if length > rest-of-data
we should start reading from the next extent. The reason we may have
data left on the page is that if the fixed part of the row was less than
min_block_length the head block was extended to min_block_length.
This may change in the future, which is why we have the loop written
the way it's written.
*/
if (extent->first_extent && length > left_length)
{
*end_of_data= *data;
left_length= 0;
}
for(;;)
{
if (unlikely(left_length >= length))
{
memcpy(to, *data, length);
(*data)+= length;
DBUG_PRINT("info", ("left_length: %u", left_length - (uint) length));
DBUG_RETURN(0);
}
memcpy(to, *data, left_length);
to+= left_length;
length-= left_length;
if (!(*data= read_next_extent(info, extent, end_of_data)))
break;
left_length= (uint) (*end_of_data - *data);
}
DBUG_RETURN(1);
} | O0 | c | read_long_data2:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x3c(%rbp)
jmp 0x81756
jmp 0x81758
jmp 0x8175a
movq -0x28(%rbp), %rax
movsbl 0x34(%rax), %eax
cmpl $0x0, %eax
je 0x81788
movq -0x20(%rbp), %rax
movl -0x3c(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x81788
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x3c(%rbp)
jmp 0x8178a
movl -0x3c(%rbp), %eax
cmpq -0x20(%rbp), %rax
setae %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x817d8
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x2a0b0
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x817d0
jmp 0x817d2
movb $0x0, -0x1(%rbp)
jmp 0x8184c
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movl -0x3c(%rbp), %eax
movl %eax, %edx
callq 0x2a0b0
movl -0x3c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x79520
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x8182d
jmp 0x81846
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x3c(%rbp)
jmp 0x8178a
jmp 0x81848
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| read_long_data2:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov rax, [rbp+var_38]
mov rax, [rax]
mov rcx, [rbp+var_30]
mov rcx, [rcx]
sub rax, rcx
mov [rbp+var_3C], eax
jmp short $+2
loc_81756:
jmp short $+2
loc_81758:
jmp short $+2
loc_8175A:
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax+34h]
cmp eax, 0
jz short loc_81788
mov rax, [rbp+var_20]
mov ecx, [rbp+var_3C]
cmp rax, rcx
jbe short loc_81788
mov rax, [rbp+var_30]
mov rcx, [rax]
mov rax, [rbp+var_38]
mov [rax], rcx
mov [rbp+var_3C], 0
loc_81788:
jmp short $+2
loc_8178A:
mov eax, [rbp+var_3C]
cmp rax, [rbp+var_20]
setnb al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_817D8
mov rdi, [rbp+var_18]
mov rax, [rbp+var_30]
mov rsi, [rax]
mov rdx, [rbp+var_20]
call _memcpy
mov rcx, [rbp+var_20]
mov rax, [rbp+var_30]
add rcx, [rax]
mov [rax], rcx
jmp short $+2
loc_817D0:
jmp short $+2
loc_817D2:
mov [rbp+var_1], 0
jmp short loc_8184C
loc_817D8:
mov rdi, [rbp+var_18]
mov rax, [rbp+var_30]
mov rsi, [rax]
mov eax, [rbp+var_3C]
mov edx, eax
call _memcpy
mov ecx, [rbp+var_3C]
mov rax, [rbp+var_18]
mov ecx, ecx
add rax, rcx
mov [rbp+var_18], rax
mov eax, [rbp+var_3C]
mov ecx, eax
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_38]
call read_next_extent
mov rcx, [rbp+var_30]
mov [rcx], rax
cmp rax, 0
jnz short loc_8182D
jmp short loc_81846
loc_8182D:
mov rax, [rbp+var_38]
mov rax, [rax]
mov rcx, [rbp+var_30]
mov rcx, [rcx]
sub rax, rcx
mov [rbp+var_3C], eax
jmp loc_8178A
loc_81846:
jmp short $+2
loc_81848:
mov [rbp+var_1], 1
loc_8184C:
mov al, [rbp+var_1]
add rsp, 40h
pop rbp
retn
| char read_long_data2(_DWORD *a1, long long a2, unsigned long long a3, long long a4, long long *a5, _DWORD *a6)
{
long long v6; // r8
int v7; // r9d
long long next_extent; // rax
unsigned int v10; // [rsp+4h] [rbp-3Ch]
unsigned long long v14; // [rsp+20h] [rbp-20h]
v14 = a3;
v10 = *a6 - *(_DWORD *)a5;
if ( *(_BYTE *)(a4 + 52) && a3 > v10 )
{
*(_QWORD *)a6 = *a5;
v10 = 0;
}
while ( 1 )
{
if ( v10 >= v14 )
{
memcpy(a2, *a5, v14);
*a5 += v14;
return 0;
}
memcpy(a2, *a5, v10);
a2 += v10;
v14 -= v10;
next_extent = read_next_extent(a1, a4, (long long)a6, v10, v6, v7);
*a5 = next_extent;
if ( !next_extent )
break;
v10 = *a6 - *(_DWORD *)a5;
}
return 1;
}
| read_long_data2:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RCX]
SUB RAX,RCX
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x00181756
LAB_00181756:
JMP 0x00181758
LAB_00181758:
JMP 0x0018175a
LAB_0018175a:
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX + 0x34]
CMP EAX,0x0
JZ 0x00181788
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x3c]
CMP RAX,RCX
JBE 0x00181788
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x3c],0x0
LAB_00181788:
JMP 0x0018178a
LAB_0018178a:
MOV EAX,dword ptr [RBP + -0x3c]
CMP RAX,qword ptr [RBP + -0x20]
SETNC AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001817d8
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0012a0b0
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x30]
ADD RCX,qword ptr [RAX]
MOV qword ptr [RAX],RCX
JMP 0x001817d0
LAB_001817d0:
JMP 0x001817d2
LAB_001817d2:
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0018184c
LAB_001817d8:
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x3c]
MOV EDX,EAX
CALL 0x0012a0b0
MOV ECX,dword ptr [RBP + -0x3c]
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV EAX,dword ptr [RBP + -0x3c]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x00179520
MOV RCX,qword ptr [RBP + -0x30]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JNZ 0x0018182d
JMP 0x00181846
LAB_0018182d:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RCX]
SUB RAX,RCX
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x0018178a
LAB_00181846:
JMP 0x00181848
LAB_00181848:
MOV byte ptr [RBP + -0x1],0x1
LAB_0018184c:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x40
POP RBP
RET
|
int1
read_long_data2(int8 param_1,void *param_2,ulong param_3,long param_4,long *param_5,
long *param_6)
{
long lVar1;
uint local_44;
ulong local_28;
void *local_20;
local_44 = (int)*param_6 - (int)*param_5;
local_28 = param_3;
local_20 = param_2;
if ((*(char *)(param_4 + 0x34) != '\0') && (local_44 < param_3)) {
*param_6 = *param_5;
local_44 = 0;
}
while( true ) {
if (local_28 <= local_44) {
memcpy(local_20,(void *)*param_5,local_28);
*param_5 = local_28 + *param_5;
return 0;
}
memcpy(local_20,(void *)*param_5,(ulong)local_44);
local_20 = (void *)((long)local_20 + (ulong)local_44);
local_28 = local_28 - local_44;
lVar1 = read_next_extent(param_1,param_4,param_6);
*param_5 = lVar1;
if (lVar1 == 0) break;
local_44 = (int)*param_6 - (int)*param_5;
}
return 1;
}
| |
45,669 | js_string_pad | bluesky950520[P]quickjs/quickjs.c | static JSValue js_string_pad(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int padEnd)
{
JSValue str, v = JS_UNDEFINED;
StringBuffer b_s, *b = &b_s;
JSString *p, *p1 = NULL;
int n, len, c = ' ';
str = JS_ToStringCheckObject(ctx, this_val);
if (JS_IsException(str))
goto fail1;
if (JS_ToInt32Sat(ctx, &n, argv[0]))
goto fail2;
p = JS_VALUE_GET_STRING(str);
len = p->len;
if (len >= n)
return str;
if (argc > 1 && !JS_IsUndefined(argv[1])) {
v = JS_ToString(ctx, argv[1]);
if (JS_IsException(v))
goto fail2;
p1 = JS_VALUE_GET_STRING(v);
if (p1->len == 0) {
JS_FreeValue(ctx, v);
return str;
}
if (p1->len == 1) {
c = string_get(p1, 0);
p1 = NULL;
}
}
if (n > JS_STRING_LEN_MAX) {
JS_ThrowRangeError(ctx, "invalid string length");
goto fail2;
}
if (string_buffer_init(ctx, b, n))
goto fail3;
n -= len;
if (padEnd) {
if (string_buffer_concat(b, p, 0, len))
goto fail;
}
if (p1) {
while (n > 0) {
int chunk = min_int(n, p1->len);
if (string_buffer_concat(b, p1, 0, chunk))
goto fail;
n -= chunk;
}
} else {
if (string_buffer_fill(b, c, n))
goto fail;
}
if (!padEnd) {
if (string_buffer_concat(b, p, 0, len))
goto fail;
}
JS_FreeValue(ctx, v);
JS_FreeValue(ctx, str);
return string_buffer_end(b);
fail:
string_buffer_free(b);
fail3:
JS_FreeValue(ctx, v);
fail2:
JS_FreeValue(ctx, str);
fail1:
return JS_EXCEPTION;
} | O2 | c | js_string_pad:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %r13d
movq %r8, %rbp
movl %ecx, %r14d
movq %rdi, %r12
callq 0x3a290
movq %rdx, %r15
pushq $0x6
popq %rdx
cmpl $0x6, %r15d
jne 0x68ad2
xorl %ebx, %ebx
jmp 0x68b06
movq %rax, %rbx
movl %r13d, 0x10(%rsp)
movq (%rbp), %rdx
movq 0x8(%rbp), %rcx
leaq 0x14(%rsp), %rsi
movq %r12, %rdi
callq 0x2133d
testl %eax, %eax
je 0x68b18
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1801e
xorl %ebx, %ebx
pushq $0x6
popq %rdx
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
andl 0x4(%rbx), %eax
movl 0x14(%rsp), %r9d
movl %r9d, %r13d
subl %eax, %r13d
jle 0x68c3c
pushq $0x3
popq %r8
pushq $0x20
popq %rcx
xorl %esi, %esi
cmpl $0x2, %r14d
jl 0x68b4f
movq 0x18(%rbp), %rdx
xorl %esi, %esi
cmpl $0x3, %edx
jne 0x68bf9
xorl %r14d, %r14d
cmpl $0x40000000, %r9d # imm = 0x40000000
jb 0x68b6e
leaq 0x1cd5c(%rip), %rsi # 0x858be
movq %r12, %rdi
xorl %eax, %eax
callq 0x1acb3
jmp 0x68af3
movl %ecx, %ebp
movl %eax, 0xc(%rsp)
movq %rsi, 0x18(%rsp)
movq %r8, 0x20(%rsp)
leaq 0x28(%rsp), %rsi
movq %r12, %rdi
movl %r9d, %edx
callq 0x2e042
testl %eax, %eax
jne 0x68ce0
cmpl $0x0, 0x10(%rsp)
je 0x68bb8
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
movl 0xc(%rsp), %ecx
callq 0x39dad
testl %eax, %eax
jne 0x68cd6
testq %r14, %r14
je 0x68c6a
testl %r13d, %r13d
jle 0x68c7d
movq %r14, %rsi
movl 0x4(%r14), %ebp
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
andl %eax, %ebp
cmpl %ebp, %r13d
cmovbl %r13d, %ebp
leaq 0x28(%rsp), %rdi
xorl %edx, %edx
movl %ebp, %ecx
callq 0x39dad
subl %ebp, %r13d
testl %eax, %eax
je 0x68bc1
jmp 0x68cd6
movl %r9d, %r14d
movl %eax, 0xc(%rsp)
movq 0x10(%rbp), %rsi
movq %r12, %rdi
callq 0x1b03c
movq %rdx, %r8
cmpl $0x6, %r8d
je 0x68af3
movq %rax, %rsi
movq 0x4(%rax), %rax
movl %eax, %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
cmpl $0x1, %ecx
je 0x68c44
testl %ecx, %ecx
jne 0x68c58
movq %r12, %rdi
movq %r8, %rdx
callq 0x1801e
movq %r15, %rdx
jmp 0x68b06
testl %eax, %eax
movl 0xc(%rsp), %eax
movl %r14d, %r9d
js 0x68cb6
movzbl 0x18(%rsi), %ecx
jmp 0x68b4f
movl %r14d, %r9d
movq %rsi, %r14
movl 0xc(%rsp), %eax
pushq $0x20
popq %rcx
jmp 0x68b52
leaq 0x28(%rsp), %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x697c3
testl %eax, %eax
jne 0x68cd6
cmpl $0x0, 0x10(%rsp)
je 0x68cbf
movq %r12, %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x1801e
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1801e
leaq 0x28(%rsp), %rdi
callq 0x2cad4
movq %rax, %rbx
jmp 0x68b06
movzwl 0x18(%rsi), %ecx
jmp 0x68b4f
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
movl 0xc(%rsp), %ecx
callq 0x39dad
testl %eax, %eax
je 0x68c84
leaq 0x28(%rsp), %rdi
callq 0x2ef01
movq %r12, %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x1801e
jmp 0x68af3
| js_string_pad:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r13d, r9d
mov rbp, r8
mov r14d, ecx
mov r12, rdi
call JS_ToStringCheckObject
mov r15, rdx
push 6
pop rdx
cmp r15d, 6
jnz short loc_68AD2
xor ebx, ebx
jmp short loc_68B06
loc_68AD2:
mov rbx, rax
mov [rsp+78h+var_68], r13d
mov rdx, [rbp+0]
mov rcx, [rbp+8]
lea rsi, [rsp+78h+var_64]
mov rdi, r12
call JS_ToInt32Sat
test eax, eax
jz short loc_68B18
loc_68AF3:
mov rdi, r12
mov rsi, rbx
mov rdx, r15
call JS_FreeValue
xor ebx, ebx
push 6
pop rdx
loc_68B06:
mov rax, rbx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_68B18:
mov eax, 7FFFFFFFh
and eax, [rbx+4]
mov r9d, [rsp+78h+var_64]
mov r13d, r9d
sub r13d, eax
jle loc_68C3C
push 3
pop r8
push 20h ; ' '
pop rcx
xor esi, esi
cmp r14d, 2
jl short loc_68B4F
mov rdx, [rbp+18h]
xor esi, esi
cmp edx, 3
jnz loc_68BF9
loc_68B4F:
xor r14d, r14d
loc_68B52:
cmp r9d, 40000000h
jb short loc_68B6E
lea rsi, aInvalidStringL; "invalid string length"
mov rdi, r12
xor eax, eax
call JS_ThrowRangeError
jmp short loc_68AF3
loc_68B6E:
mov ebp, ecx
mov [rsp+78h+var_6C], eax
mov [rsp+78h+var_60], rsi
mov [rsp+78h+var_58], r8
lea rsi, [rsp+78h+var_50]
mov rdi, r12
mov edx, r9d
call string_buffer_init
test eax, eax
jnz loc_68CE0
cmp [rsp+78h+var_68], 0
jz short loc_68BB8
lea rdi, [rsp+78h+var_50]
mov rsi, rbx
xor edx, edx
mov ecx, [rsp+78h+var_6C]
call string_buffer_concat
test eax, eax
jnz loc_68CD6
loc_68BB8:
test r14, r14
jz loc_68C6A
loc_68BC1:
test r13d, r13d
jle loc_68C7D
mov rsi, r14
mov ebp, [r14+4]
mov eax, 7FFFFFFFh
and ebp, eax
cmp r13d, ebp
cmovb ebp, r13d
lea rdi, [rsp+78h+var_50]
xor edx, edx
mov ecx, ebp
call string_buffer_concat
sub r13d, ebp
test eax, eax
jz short loc_68BC1
jmp loc_68CD6
loc_68BF9:
mov r14d, r9d
mov [rsp+78h+var_6C], eax
mov rsi, [rbp+10h]
mov rdi, r12
call JS_ToString
mov r8, rdx
cmp r8d, 6
jz loc_68AF3
mov rsi, rax
mov rax, [rax+4]
mov ecx, eax
and ecx, 7FFFFFFFh
cmp ecx, 1
jz short loc_68C44
test ecx, ecx
jnz short loc_68C58
mov rdi, r12
mov rdx, r8
call JS_FreeValue
loc_68C3C:
mov rdx, r15
jmp loc_68B06
loc_68C44:
test eax, eax
mov eax, [rsp+78h+var_6C]
mov r9d, r14d
js short loc_68CB6
movzx ecx, byte ptr [rsi+18h]
jmp loc_68B4F
loc_68C58:
mov r9d, r14d
mov r14, rsi
mov eax, [rsp+78h+var_6C]
push 20h ; ' '
pop rcx
jmp loc_68B52
loc_68C6A:
lea rdi, [rsp+78h+var_50]
mov esi, ebp
mov edx, r13d
call string_buffer_fill
test eax, eax
jnz short loc_68CD6
loc_68C7D:
cmp [rsp+78h+var_68], 0
jz short loc_68CBF
loc_68C84:
mov rdi, r12
mov rsi, [rsp+78h+var_60]
mov rdx, [rsp+78h+var_58]
call JS_FreeValue
mov rdi, r12
mov rsi, rbx
mov rdx, r15
call JS_FreeValue
lea rdi, [rsp+78h+var_50]
call string_buffer_end
mov rbx, rax
jmp loc_68B06
loc_68CB6:
movzx ecx, word ptr [rsi+18h]
jmp loc_68B4F
loc_68CBF:
lea rdi, [rsp+78h+var_50]
mov rsi, rbx
xor edx, edx
mov ecx, [rsp+78h+var_6C]
call string_buffer_concat
test eax, eax
jz short loc_68C84
loc_68CD6:
lea rdi, [rsp+78h+var_50]
call string_buffer_free
loc_68CE0:
mov rdi, r12
mov rsi, [rsp+78h+var_60]
mov rdx, [rsp+78h+var_58]
call JS_FreeValue
jmp loc_68AF3
| long long js_string_pad(
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)
{
int v14; // r13d
int v16; // r14d
long long v17; // rax
long long v18; // rdx
long long v19; // r15
long long v20; // rbx
long long v21; // rdx
__m128 v22; // xmm4
__m128 v23; // xmm5
int v25; // eax
long long v26; // r9
int v27; // r13d
long long v28; // r8
long long v29; // rcx
long long v30; // rsi
long long v31; // r14
unsigned int v32; // ebp
unsigned int v33; // ebp
unsigned int v34; // r14d
long long v35; // rax
long long v36; // rax
bool v37; // sf
char v38; // [rsp+0h] [rbp-78h]
unsigned int v39; // [rsp+Ch] [rbp-6Ch]
int v40; // [rsp+Ch] [rbp-6Ch]
int v41; // [rsp+10h] [rbp-68h]
unsigned int v42; // [rsp+14h] [rbp-64h] BYREF
long long v43; // [rsp+18h] [rbp-60h]
long long v44; // [rsp+20h] [rbp-58h]
long long v45[10]; // [rsp+28h] [rbp-50h] BYREF
v14 = a6;
v16 = a4;
v17 = JS_ToStringCheckObject(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v19 = v18;
if ( (_DWORD)v18 != 6 )
{
v20 = v17;
v41 = v14;
if ( (unsigned int)JS_ToInt32Sat(a1, (long long)&v42, *(_DWORD **)a5, *(_QWORD *)(a5 + 8)) )
{
LABEL_4:
JS_FreeValue(a1, v20, v19);
return 0LL;
}
v25 = *(_DWORD *)(v20 + 4) & 0x7FFFFFFF;
v26 = v42;
v27 = v42 - v25;
if ( (int)v42 <= v25 )
return v20;
v28 = 3LL;
v29 = 32LL;
v30 = 0LL;
if ( v16 >= 2 )
{
v21 = *(_QWORD *)(a5 + 24);
v30 = 0LL;
if ( (_DWORD)v21 != 3 )
{
v34 = v42;
v40 = *(_DWORD *)(v20 + 4) & 0x7FFFFFFF;
v35 = JS_ToString(a1, *(_QWORD *)(a5 + 16), v21);
v28 = v21;
if ( (_DWORD)v21 == 6 )
goto LABEL_4;
v30 = v35;
v36 = *(_QWORD *)(v35 + 4);
if ( (v36 & 0x7FFFFFFF) != 1 )
{
if ( (v36 & 0x7FFFFFFF) == 0 )
{
JS_FreeValue(a1, v30, v21);
return v20;
}
v26 = v34;
v31 = v30;
v25 = v40;
v29 = 32LL;
LABEL_10:
if ( (unsigned int)v26 >= 0x40000000 )
{
JS_ThrowRangeError(
a1,
(long long)"invalid string length",
v21,
v29,
v28,
v26,
a7,
a8,
a9,
a10,
v22,
v23,
a13,
a14,
v38);
goto LABEL_4;
}
v32 = v29;
v39 = v25;
v43 = v30;
v44 = v28;
if ( (unsigned int)string_buffer_init(a1, (long long)v45, v26) )
{
LABEL_35:
JS_FreeValue(a1, v43, v44);
goto LABEL_4;
}
if ( !v41 || !(unsigned int)string_buffer_concat((long long)v45, v20, 0, v39) )
{
if ( v31 )
{
while ( v27 > 0 )
{
v33 = *(_DWORD *)(v31 + 4) & 0x7FFFFFFF;
if ( v27 < v33 )
v33 = v27;
v27 -= v33;
if ( (unsigned int)string_buffer_concat((long long)v45, v31, 0, v33) )
goto LABEL_34;
}
LABEL_30:
if ( v41 || !(unsigned int)string_buffer_concat((long long)v45, v20, 0, v39) )
{
JS_FreeValue(a1, v43, v44);
JS_FreeValue(a1, v20, v19);
return string_buffer_end(v45);
}
goto LABEL_34;
}
if ( !(unsigned int)string_buffer_fill(v45, v32, (unsigned int)v27) )
goto LABEL_30;
}
LABEL_34:
string_buffer_free(v45);
goto LABEL_35;
}
v37 = (int)v36 < 0;
v25 = v40;
v26 = v34;
if ( v37 )
v29 = *(unsigned __int16 *)(v30 + 24);
else
v29 = *(unsigned __int8 *)(v30 + 24);
}
}
v31 = 0LL;
goto LABEL_10;
}
return 0LL;
}
| js_string_pad:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R13D,R9D
MOV RBP,R8
MOV R14D,ECX
MOV R12,RDI
CALL 0x0013a290
MOV R15,RDX
PUSH 0x6
POP RDX
CMP R15D,0x6
JNZ 0x00168ad2
XOR EBX,EBX
JMP 0x00168b06
LAB_00168ad2:
MOV RBX,RAX
MOV dword ptr [RSP + 0x10],R13D
MOV RDX,qword ptr [RBP]
MOV RCX,qword ptr [RBP + 0x8]
LEA RSI,[RSP + 0x14]
MOV RDI,R12
CALL 0x0012133d
TEST EAX,EAX
JZ 0x00168b18
LAB_00168af3:
MOV RDI,R12
MOV RSI,RBX
MOV RDX,R15
CALL 0x0011801e
XOR EBX,EBX
PUSH 0x6
POP RDX
LAB_00168b06:
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00168b18:
MOV EAX,0x7fffffff
AND EAX,dword ptr [RBX + 0x4]
MOV R9D,dword ptr [RSP + 0x14]
MOV R13D,R9D
SUB R13D,EAX
JLE 0x00168c3c
PUSH 0x3
POP R8
PUSH 0x20
POP RCX
XOR ESI,ESI
CMP R14D,0x2
JL 0x00168b4f
MOV RDX,qword ptr [RBP + 0x18]
XOR ESI,ESI
CMP EDX,0x3
JNZ 0x00168bf9
LAB_00168b4f:
XOR R14D,R14D
LAB_00168b52:
CMP R9D,0x40000000
JC 0x00168b6e
LEA RSI,[0x1858be]
MOV RDI,R12
XOR EAX,EAX
CALL 0x0011acb3
JMP 0x00168af3
LAB_00168b6e:
MOV EBP,ECX
MOV dword ptr [RSP + 0xc],EAX
MOV qword ptr [RSP + 0x18],RSI
MOV qword ptr [RSP + 0x20],R8
LEA RSI,[RSP + 0x28]
MOV RDI,R12
MOV EDX,R9D
CALL 0x0012e042
TEST EAX,EAX
JNZ 0x00168ce0
CMP dword ptr [RSP + 0x10],0x0
JZ 0x00168bb8
LEA RDI,[RSP + 0x28]
MOV RSI,RBX
XOR EDX,EDX
MOV ECX,dword ptr [RSP + 0xc]
CALL 0x00139dad
TEST EAX,EAX
JNZ 0x00168cd6
LAB_00168bb8:
TEST R14,R14
JZ 0x00168c6a
LAB_00168bc1:
TEST R13D,R13D
JLE 0x00168c7d
MOV RSI,R14
MOV EBP,dword ptr [R14 + 0x4]
MOV EAX,0x7fffffff
AND EBP,EAX
CMP R13D,EBP
CMOVC EBP,R13D
LEA RDI,[RSP + 0x28]
XOR EDX,EDX
MOV ECX,EBP
CALL 0x00139dad
SUB R13D,EBP
TEST EAX,EAX
JZ 0x00168bc1
JMP 0x00168cd6
LAB_00168bf9:
MOV R14D,R9D
MOV dword ptr [RSP + 0xc],EAX
MOV RSI,qword ptr [RBP + 0x10]
MOV RDI,R12
CALL 0x0011b03c
MOV R8,RDX
CMP R8D,0x6
JZ 0x00168af3
MOV RSI,RAX
MOV RAX,qword ptr [RAX + 0x4]
MOV ECX,EAX
AND ECX,0x7fffffff
CMP ECX,0x1
JZ 0x00168c44
TEST ECX,ECX
JNZ 0x00168c58
MOV RDI,R12
MOV RDX,R8
CALL 0x0011801e
LAB_00168c3c:
MOV RDX,R15
JMP 0x00168b06
LAB_00168c44:
TEST EAX,EAX
MOV EAX,dword ptr [RSP + 0xc]
MOV R9D,R14D
JS 0x00168cb6
MOVZX ECX,byte ptr [RSI + 0x18]
JMP 0x00168b4f
LAB_00168c58:
MOV R9D,R14D
MOV R14,RSI
MOV EAX,dword ptr [RSP + 0xc]
PUSH 0x20
POP RCX
JMP 0x00168b52
LAB_00168c6a:
LEA RDI,[RSP + 0x28]
MOV ESI,EBP
MOV EDX,R13D
CALL 0x001697c3
TEST EAX,EAX
JNZ 0x00168cd6
LAB_00168c7d:
CMP dword ptr [RSP + 0x10],0x0
JZ 0x00168cbf
LAB_00168c84:
MOV RDI,R12
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x20]
CALL 0x0011801e
MOV RDI,R12
MOV RSI,RBX
MOV RDX,R15
CALL 0x0011801e
LEA RDI,[RSP + 0x28]
CALL 0x0012cad4
MOV RBX,RAX
JMP 0x00168b06
LAB_00168cb6:
MOVZX ECX,word ptr [RSI + 0x18]
JMP 0x00168b4f
LAB_00168cbf:
LEA RDI,[RSP + 0x28]
MOV RSI,RBX
XOR EDX,EDX
MOV ECX,dword ptr [RSP + 0xc]
CALL 0x00139dad
TEST EAX,EAX
JZ 0x00168c84
LAB_00168cd6:
LEA RDI,[RSP + 0x28]
CALL 0x0012ef01
LAB_00168ce0:
MOV RDI,R12
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x20]
CALL 0x0011801e
JMP 0x00168af3
|
long js_string_pad(int8 param_1,int8 param_2,int8 param_3,int param_4,
int8 *param_5,int param_6)
{
int iVar1;
uint uVar2;
long lVar3;
ushort uVar4;
uint uVar5;
uint uVar6;
long lVar7;
int1 auVar8 [16];
int1 auVar9 [16];
uint local_64;
int1 local_60 [16];
int1 local_50 [32];
auVar8 = JS_ToStringCheckObject();
lVar3 = auVar8._0_8_;
if (auVar8._8_4_ == 6) {
return 0;
}
iVar1 = JS_ToInt32Sat(param_1,&local_64,*param_5,param_5[1]);
if (iVar1 != 0) goto LAB_00168af3;
uVar2 = *(uint *)(lVar3 + 4) & 0x7fffffff;
uVar6 = local_64 - uVar2;
if (uVar6 == 0 || (int)local_64 < (int)uVar2) {
return lVar3;
}
uVar4 = 0x20;
auVar9 = ZEXT816(3) << 0x40;
if ((param_4 < 2) || (auVar9 = ZEXT816(3) << 0x40, (int)param_5[3] == 3)) {
LAB_00168b4f:
lVar7 = 0;
}
else {
auVar9 = JS_ToString(param_1,param_5[2]);
lVar7 = auVar9._0_8_;
if (auVar9._8_4_ == 6) goto LAB_00168af3;
uVar5 = (uint)*(ulong *)(lVar7 + 4);
if ((uVar5 & 0x7fffffff) == 1) {
if ((int)uVar5 < 0) {
uVar4 = *(ushort *)(lVar7 + 0x18);
}
else {
uVar4 = (ushort)*(byte *)(lVar7 + 0x18);
}
goto LAB_00168b4f;
}
if ((*(ulong *)(lVar7 + 4) & 0x7fffffff) == 0) {
JS_FreeValue(param_1,lVar7,auVar9._8_8_);
return lVar3;
}
uVar4 = 0x20;
}
if (0x3fffffff < local_64) {
JS_ThrowRangeError(param_1,"invalid string length");
goto LAB_00168af3;
}
local_60 = auVar9;
iVar1 = string_buffer_init(param_1,local_50,local_64);
if (iVar1 == 0) {
if (param_6 == 0) {
LAB_00168bb8:
if (lVar7 == 0) {
iVar1 = string_buffer_fill(local_50,uVar4,uVar6);
if (iVar1 == 0) {
LAB_00168c7d:
if (param_6 != 0) {
LAB_00168c84:
JS_FreeValue(param_1,local_60._0_8_,local_60._8_8_);
JS_FreeValue(param_1,lVar3,auVar8._8_8_);
lVar3 = string_buffer_end(local_50);
return lVar3;
}
iVar1 = string_buffer_concat(local_50,lVar3,0,uVar2);
if (iVar1 == 0) goto LAB_00168c84;
}
}
else {
do {
if ((int)uVar6 < 1) goto LAB_00168c7d;
uVar5 = *(uint *)(lVar7 + 4) & 0x7fffffff;
if (uVar6 < uVar5) {
uVar5 = uVar6;
}
iVar1 = string_buffer_concat(local_50,lVar7,0,uVar5);
uVar6 = uVar6 - uVar5;
} while (iVar1 == 0);
}
}
else {
iVar1 = string_buffer_concat(local_50,lVar3,0,uVar2);
if (iVar1 == 0) goto LAB_00168bb8;
}
string_buffer_free(local_50);
}
JS_FreeValue(param_1,local_60._0_8_,local_60._8_8_);
LAB_00168af3:
JS_FreeValue(param_1,lVar3,auVar8._8_8_);
return 0;
}
| |
45,670 | init_alloc_root | eloqsql/mysys/my_alloc.c | void init_alloc_root(PSI_memory_key key, MEM_ROOT *mem_root, size_t block_size,
size_t pre_alloc_size __attribute__((unused)),
myf my_flags)
{
DBUG_ENTER("init_alloc_root");
DBUG_PRINT("enter",("root: %p prealloc: %zu", mem_root, pre_alloc_size));
mem_root->free= mem_root->used= mem_root->pre_alloc= 0;
mem_root->min_malloc= 32;
mem_root->block_size= (block_size - ALLOC_ROOT_MIN_BLOCK_SIZE) & ~1;
if (my_flags & MY_THREAD_SPECIFIC)
mem_root->block_size|= 1;
mem_root->error_handler= 0;
mem_root->block_num= 4; /* We shift this with >>2 */
mem_root->first_block_usage= 0;
mem_root->m_psi_key= key;
#if !(defined(HAVE_valgrind) && defined(EXTRA_DEBUG))
if (pre_alloc_size)
{
size_t size= pre_alloc_size + ALIGN_SIZE(sizeof(USED_MEM));
if ((mem_root->free= mem_root->pre_alloc=
(USED_MEM*) my_malloc(key, size, MYF(my_flags))))
{
mem_root->free->size= size;
mem_root->free->left= pre_alloc_size;
mem_root->free->next= 0;
TRASH_MEM(mem_root->free);
}
}
#endif
DBUG_VOID_RETURN;
} | O3 | c | init_alloc_root:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
xorl %eax, %eax
movq %rax, 0x10(%rsi)
movq $0x20, 0x18(%rsi)
andq $-0x2, %rdx
movl %r8d, %ecx
shrl $0x10, %ecx
andl $0x1, %ecx
addq %rdx, %rcx
addq $-0x28, %rcx
movq %rcx, 0x20(%rsi)
movq %rax, 0x30(%rsi)
movq $0x4, 0x28(%rsi)
movl %edi, 0x38(%rsi)
testq %rbx, %rbx
je 0x67040
movq %rsi, %r14
leaq 0x18(%rbx), %r15
movq %r15, %rsi
movq %r8, %rdx
callq 0x6b029
movq %rax, 0x10(%r14)
movq %rax, (%r14)
testq %rax, %rax
je 0x67040
movq %r15, 0x10(%rax)
movq (%r14), %rax
movq %rbx, 0x8(%rax)
movq (%r14), %rax
movq $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| init_alloc_root:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rcx
xorps xmm0, xmm0
movups xmmword ptr [rsi], xmm0
xor eax, eax
mov [rsi+10h], rax
mov qword ptr [rsi+18h], 20h ; ' '
and rdx, 0FFFFFFFFFFFFFFFEh
mov ecx, r8d
shr ecx, 10h
and ecx, 1
add rcx, rdx
add rcx, 0FFFFFFFFFFFFFFD8h
mov [rsi+20h], rcx
mov [rsi+30h], rax
mov qword ptr [rsi+28h], 4
mov [rsi+38h], edi
test rbx, rbx
jz short loc_67040
mov r14, rsi
lea r15, [rbx+18h]
mov rsi, r15
mov rdx, r8
call my_malloc
mov [r14+10h], rax
mov [r14], rax
test rax, rax
jz short loc_67040
mov [rax+10h], r15
mov rax, [r14]
mov [rax+8], rbx
mov rax, [r14]
mov qword ptr [rax], 0
loc_67040:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long init_alloc_root(long long a1, long long *a2, long long a3, long long a4, unsigned int a5)
{
long long result; // rax
*(_OWORD *)a2 = 0LL;
result = 0LL;
a2[2] = 0LL;
a2[3] = 32LL;
a2[4] = (a3 & 0xFFFFFFFFFFFFFFFELL) + (HIWORD(a5) & 1) - 40;
a2[6] = 0LL;
a2[5] = 4LL;
*((_DWORD *)a2 + 14) = a1;
if ( a4 )
{
result = my_malloc(a1, a4 + 24);
a2[2] = result;
*a2 = result;
if ( result )
{
*(_QWORD *)(result + 16) = a4 + 24;
*(_QWORD *)(*a2 + 8) = a4;
result = *a2;
*(_QWORD *)*a2 = 0LL;
}
}
return result;
}
| init_alloc_root:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RCX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSI],XMM0
XOR EAX,EAX
MOV qword ptr [RSI + 0x10],RAX
MOV qword ptr [RSI + 0x18],0x20
AND RDX,-0x2
MOV ECX,R8D
SHR ECX,0x10
AND ECX,0x1
ADD RCX,RDX
ADD RCX,-0x28
MOV qword ptr [RSI + 0x20],RCX
MOV qword ptr [RSI + 0x30],RAX
MOV qword ptr [RSI + 0x28],0x4
MOV dword ptr [RSI + 0x38],EDI
TEST RBX,RBX
JZ 0x00167040
MOV R14,RSI
LEA R15,[RBX + 0x18]
MOV RSI,R15
MOV RDX,R8
CALL 0x0016b029
MOV qword ptr [R14 + 0x10],RAX
MOV qword ptr [R14],RAX
TEST RAX,RAX
JZ 0x00167040
MOV qword ptr [RAX + 0x10],R15
MOV RAX,qword ptr [R14]
MOV qword ptr [RAX + 0x8],RBX
MOV RAX,qword ptr [R14]
MOV qword ptr [RAX],0x0
LAB_00167040:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void init_alloc_root(int4 param_1,long *param_2,ulong param_3,long param_4,int8 param_5)
{
long lVar1;
*param_2 = 0;
param_2[1] = 0;
param_2[2] = 0;
param_2[3] = 0x20;
param_2[4] = (ulong)((uint)param_5 >> 0x10 & 1) + (param_3 & 0xfffffffffffffffe) + -0x28;
param_2[6] = 0;
param_2[5] = 4;
*(int4 *)(param_2 + 7) = param_1;
if (param_4 != 0) {
lVar1 = my_malloc(param_1,param_4 + 0x18,param_5);
param_2[2] = lVar1;
*param_2 = lVar1;
if (lVar1 != 0) {
*(long *)(lVar1 + 0x10) = param_4 + 0x18;
*(long *)(*param_2 + 8) = param_4;
*(int8 *)*param_2 = 0;
}
}
return;
}
| |
45,671 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::json_value::json_value(nlohmann::json_abi_v3_11_3::detail::value_t) | llama.cpp/common/json.hpp | json_value(value_t t)
{
switch (t)
{
case value_t::object:
{
object = create<object_t>();
break;
}
case value_t::array:
{
array = create<array_t>();
break;
}
case value_t::string:
{
string = create<string_t>("");
break;
}
case value_t::binary:
{
binary = create<binary_t>();
break;
}
case value_t::boolean:
{
boolean = static_cast<boolean_t>(false);
break;
}
case value_t::number_integer:
{
number_integer = static_cast<number_integer_t>(0);
break;
}
case value_t::number_unsigned:
{
number_unsigned = static_cast<number_unsigned_t>(0);
break;
}
case value_t::number_float:
{
number_float = static_cast<number_float_t>(0.0);
break;
}
case value_t::null:
{
object = nullptr; // silence warning, see #821
break;
}
case value_t::discarded:
default:
{
object = nullptr; // silence warning, see #821
if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
{
JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.11.3", nullptr)); // LCOV_EXCL_LINE
}
break;
}
}
} | O3 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::json_value::json_value(nlohmann::json_abi_v3_11_3::detail::value_t):
pushq %rbx
movq %rdi, %rbx
cmpl $0x8, %esi
ja 0x6b02f
movl %esi, %eax
leaq 0x6661a(%rip), %rcx # 0xd1640
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x0, (%rbx)
jmp 0x6b087
movl $0x20, %edi
jmp 0x6b049
movb $0x0, (%rbx)
jmp 0x6b087
movl $0x18, %edi
callq 0x1d1e0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
jmp 0x6b084
leaq 0x6752b(%rip), %rdi # 0xd2590
callq 0x6b08a
jmp 0x6b084
movl $0x28, %edi
callq 0x1d1e0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movb $0x0, 0x20(%rax)
movq %rax, (%rbx)
popq %rbx
retq
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10json_valueC2ENS0_6detail7value_tE:
push rbx
mov rbx, rdi
cmp esi, 8; switch 9 cases
ja short def_6B02D; jumptable 000000000006B02D default case, cases 0,5-7
mov eax, esi
lea rcx, jpt_6B02D
movsxd rax, ds:(jpt_6B02D - 0D1640h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
def_6B02D:
mov qword ptr [rbx], 0; jumptable 000000000006B02D default case, cases 0,5-7
jmp short loc_6B087
loc_6B038:
mov edi, 20h ; ' '; jumptable 000000000006B02D case 1
jmp short loc_6B049
loc_6B03F:
mov byte ptr [rbx], 0; jumptable 000000000006B02D case 4
jmp short loc_6B087
loc_6B044:
mov edi, 18h; jumptable 000000000006B02D case 2
loc_6B049:
call __Znwm; operator new(ulong)
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
jmp short loc_6B084
loc_6B05E:
lea rdi, aExampleToolCal+1Dh; jumptable 000000000006B02D case 3
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS9_JRA1_KcEEEPT_DpOT0_; 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>::create<std::string,char const(&)[1]>(char const(&)[1] &&)
jmp short loc_6B084
loc_6B06C:
mov edi, 28h ; '('; jumptable 000000000006B02D case 8
call __Znwm; operator new(ulong)
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
movups xmmword ptr [rax+10h], xmm0
mov byte ptr [rax+20h], 0
loc_6B084:
mov [rbx], rax
loc_6B087:
pop rbx
retn
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::json_value::json_value(
_BYTE *a1,
unsigned int a2)
{
long long result; // rax
unsigned long long v4; // rdi
result = a2;
switch ( a2 )
{
case 1u:
v4 = 32LL;
goto LABEL_6;
case 2u:
v4 = 24LL;
LABEL_6:
result = operator new(v4);
*(_OWORD *)result = 0LL;
*(_QWORD *)(result + 16) = 0LL;
goto LABEL_9;
case 3u:
result = 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>::create<std::string,char const(&)[1]>("");
goto LABEL_9;
case 4u:
*a1 = 0;
return result;
case 8u:
result = operator new(0x28uLL);
*(_OWORD *)result = 0LL;
*(_OWORD *)(result + 16) = 0LL;
*(_BYTE *)(result + 32) = 0;
LABEL_9:
*(_QWORD *)a1 = result;
break;
default:
*(_QWORD *)a1 = 0LL;
break;
}
return result;
}
| json_value:
PUSH RBX
MOV RBX,RDI
CMP ESI,0x8
JA 0x0016b02f
MOV EAX,ESI
LEA RCX,[0x1d1640]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
MOV qword ptr [RBX],0x0
JMP 0x0016b087
caseD_1:
MOV EDI,0x20
JMP 0x0016b049
caseD_4:
MOV byte ptr [RBX],0x0
JMP 0x0016b087
caseD_2:
MOV EDI,0x18
LAB_0016b049:
CALL 0x0011d1e0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
JMP 0x0016b084
caseD_3:
LEA RDI,[0x1d2590]
CALL 0x0016b08a
JMP 0x0016b084
caseD_8:
MOV EDI,0x28
CALL 0x0011d1e0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOVUPS xmmword ptr [RAX + 0x10],XMM0
MOV byte ptr [RAX + 0x20],0x0
LAB_0016b084:
MOV qword ptr [RBX],RAX
LAB_0016b087:
POP RBX
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::json_value::json_value(nlohmann::json_abi_v3_11_3::detail::value_t) */
void __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::json_value::json_value(json_value *this,int4 param_2)
{
string *psVar1;
ulong uVar2;
switch(param_2) {
default:
*(int8 *)this = 0;
return;
case 1:
uVar2 = 0x20;
break;
case 2:
uVar2 = 0x18;
break;
case 3:
psVar1 = create<std::__cxx11::string,char_const(&)[1]>("");
goto LAB_0016b084;
case 4:
*this = (json_value)0x0;
return;
case 8:
psVar1 = (string *)operator_new(0x28);
*(int8 *)psVar1 = 0;
*(int8 *)(psVar1 + 8) = 0;
*(int8 *)(psVar1 + 0x10) = 0;
*(int8 *)(psVar1 + 0x18) = 0;
psVar1[0x20] = (string)0x0;
goto LAB_0016b084;
}
psVar1 = (string *)operator_new(uVar2);
*(int8 *)psVar1 = 0;
*(int8 *)(psVar1 + 8) = 0;
*(int8 *)(psVar1 + 0x10) = 0;
LAB_0016b084:
*(string **)this = psVar1;
return;
}
| |
45,672 | 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 0x32447
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x32447
movl (%rcx), %edi
leaq -0x4(%rbp), %rcx
movl $0x1, %esi
movl $0x9, %edx
movl $0x4, %r8d
callq 0x137b0
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_32447
mov rcx, [rdi]
test rcx, rcx
jz short loc_32447
mov edi, [rcx]
lea rcx, [rbp+var_4]
mov esi, 1
mov edx, 9
mov r8d, 4
call _setsockopt
loc_32447:
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 0x00132447
MOV RCX,qword ptr [RDI]
TEST RCX,RCX
JZ 0x00132447
MOV EDI,dword ptr [RCX]
LEA RCX,[RBP + -0x4]
MOV ESI,0x1
MOV EDX,0x9
MOV R8D,0x4
CALL 0x001137b0
LAB_00132447:
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;
}
| |
45,673 | js_thisSymbolValue | bluesky950520[P]quickjs/quickjs.c | static JSValue js_thisSymbolValue(JSContext *ctx, JSValue this_val)
{
if (JS_VALUE_GET_TAG(this_val) == JS_TAG_SYMBOL)
return js_dup(this_val);
if (JS_VALUE_GET_TAG(this_val) == JS_TAG_OBJECT) {
JSObject *p = JS_VALUE_GET_OBJ(this_val);
if (p->class_id == JS_CLASS_SYMBOL) {
if (JS_VALUE_GET_TAG(p->u.object_data) == JS_TAG_SYMBOL)
return js_dup(p->u.object_data);
}
}
return JS_ThrowTypeError(ctx, "not a symbol");
} | O3 | c | js_thisSymbolValue:
pushq %rbx
movq %rsi, %rbx
cmpl $-0x1, %edx
je 0x80697
cmpl $-0x8, %edx
jne 0x806ad
incl (%rbx)
jmp 0x806c2
cmpw $0x7, 0x6(%rbx)
jne 0x806ad
movq 0x38(%rbx), %rdx
cmpl $-0x8, %edx
jne 0x806ad
movq 0x30(%rbx), %rbx
jmp 0x80693
leaq 0x206de(%rip), %rsi # 0xa0d92
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2214f
movl $0x6, %edx
movq %rbx, %rax
popq %rbx
retq
| js_thisSymbolValue:
push rbx
mov rbx, rsi
cmp edx, 0FFFFFFFFh
jz short loc_80697
cmp edx, 0FFFFFFF8h
jnz short loc_806AD
loc_80693:
inc dword ptr [rbx]
jmp short loc_806C2
loc_80697:
cmp word ptr [rbx+6], 7
jnz short loc_806AD
mov rdx, [rbx+38h]
cmp edx, 0FFFFFFF8h
jnz short loc_806AD
mov rbx, [rbx+30h]
jmp short loc_80693
loc_806AD:
lea rsi, aNotASymbol; "not a symbol"
xor ebx, ebx
xor eax, eax
call JS_ThrowTypeError
mov edx, 6
loc_806C2:
mov rax, rbx
pop rbx
retn
| _DWORD * js_thisSymbolValue(
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)
{
_DWORD *v14; // rbx
char v16; // [rsp+0h] [rbp-8h]
v14 = (_DWORD *)a2;
if ( (_DWORD)a3 == -1 )
{
if ( *(_WORD *)(a2 + 6) == 7 )
{
a3 = *(_QWORD *)(a2 + 56);
if ( (_DWORD)a3 == -8 )
{
v14 = *(_DWORD **)(a2 + 48);
goto LABEL_3;
}
}
LABEL_7:
v14 = 0LL;
JS_ThrowTypeError(a1, (long long)"not a symbol", a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v16);
return v14;
}
if ( (_DWORD)a3 != -8 )
goto LABEL_7;
LABEL_3:
++*v14;
return v14;
}
| js_thisSymbolValue:
PUSH RBX
MOV RBX,RSI
CMP EDX,-0x1
JZ 0x00180697
CMP EDX,-0x8
JNZ 0x001806ad
LAB_00180693:
INC dword ptr [RBX]
JMP 0x001806c2
LAB_00180697:
CMP word ptr [RBX + 0x6],0x7
JNZ 0x001806ad
MOV RDX,qword ptr [RBX + 0x38]
CMP EDX,-0x8
JNZ 0x001806ad
MOV RBX,qword ptr [RBX + 0x30]
JMP 0x00180693
LAB_001806ad:
LEA RSI,[0x1a0d92]
XOR EBX,EBX
XOR EAX,EAX
CALL 0x0012214f
MOV EDX,0x6
LAB_001806c2:
MOV RAX,RBX
POP RBX
RET
|
int1 [16] js_thisSymbolValue(int8 param_1,int *param_2,int8 param_3)
{
int1 auVar1 [16];
if ((int)param_3 == -1) {
if ((*(short *)((long)param_2 + 6) != 7) ||
(param_3 = *(int8 *)(param_2 + 0xe), (int)param_3 != -8)) goto LAB_001806ad;
param_2 = *(int **)(param_2 + 0xc);
}
else if ((int)param_3 != -8) {
LAB_001806ad:
param_2 = (int *)0x0;
JS_ThrowTypeError(param_1,"not a symbol");
param_3 = 6;
goto LAB_001806c2;
}
*param_2 = *param_2 + 1;
LAB_001806c2:
auVar1._8_8_ = param_3;
auVar1._0_8_ = param_2;
return auVar1;
}
| |
45,674 | my_hash_sort_ucs2_nopad | eloqsql/strings/ctype-ucs2.c | static void
my_hash_sort_ucs2_nopad(CHARSET_INFO *cs, const uchar *s, size_t slen,
ulong *nr1, ulong *nr2)
{
my_wc_t wc;
int res;
const uchar *e=s+slen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
register ulong m1= *nr1, m2= *nr2;
while ((s < e) && (res=my_ucs2_uni(cs,&wc, (uchar *)s, (uchar*)e)) >0)
{
my_tosort_ucs2(uni_plane, &wc);
MY_HASH_ADD_16(m1, m2, wc);
s+=res;
}
*nr1= m1;
*nr2= m2;
} | O0 | c | my_hash_sort_ucs2_nopad:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x59(%rbp)
jae 0x6aa0a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq 0x652e0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x6aa16
jmp 0x6aab0
movq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6aad0
jmp 0x6aa25
movq -0x50(%rbp), %rax
andq $0x3f, %rax
addq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
andq $0xff, %rcx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x58(%rbp)
jmp 0x6aa61
movq -0x50(%rbp), %rax
andq $0x3f, %rax
addq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
shrq $0x8, %rcx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x58(%rbp)
jmp 0x6aa9a
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x6a9da
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x58(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| my_hash_sort_ucs2_nopad:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_48], rax
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_50], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_58], rax
loc_6A9DA:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_59], al
jnb short loc_6AA0A
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_40]
lea rsi, [rbp+var_30]
call my_ucs2_uni
mov [rbp+var_34], eax
cmp eax, 0
setnle al
mov [rbp+var_59], al
loc_6AA0A:
mov al, [rbp+var_59]
test al, 1
jnz short loc_6AA16
jmp loc_6AAB0
loc_6AA16:
mov rdi, [rbp+var_48]
lea rsi, [rbp+var_30]
call my_tosort_ucs2
jmp short $+2
loc_6AA25:
mov rax, [rbp+var_50]
and rax, 3Fh
add rax, [rbp+var_58]
mov rcx, [rbp+var_30]
and rcx, 0FFh
imul rax, rcx
mov rcx, [rbp+var_50]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
add rax, 3
mov [rbp+var_58], rax
jmp short $+2
loc_6AA61:
mov rax, [rbp+var_50]
and rax, 3Fh
add rax, [rbp+var_58]
mov rcx, [rbp+var_30]
shr rcx, 8
imul rax, rcx
mov rcx, [rbp+var_50]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
add rax, 3
mov [rbp+var_58], rax
jmp short $+2
loc_6AA9A:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
jmp loc_6A9DA
loc_6AAB0:
mov rcx, [rbp+var_50]
mov rax, [rbp+var_20]
mov [rax], rcx
mov rcx, [rbp+var_58]
mov rax, [rbp+var_28]
mov [rax], rcx
add rsp, 60h
pop rbp
retn
| _QWORD * my_hash_sort_ucs2_nopad(
long long a1,
unsigned long long a2,
long long a3,
unsigned long long *a4,
_QWORD *a5,
long long a6)
{
_QWORD *result; // rax
bool v7; // [rsp+7h] [rbp-59h]
long long v8; // [rsp+8h] [rbp-58h]
long long v9; // [rsp+8h] [rbp-58h]
unsigned long long v10; // [rsp+10h] [rbp-50h]
long long v11; // [rsp+10h] [rbp-50h]
long long v12; // [rsp+18h] [rbp-48h]
unsigned long long v13; // [rsp+20h] [rbp-40h]
int v14; // [rsp+2Ch] [rbp-34h]
unsigned long long v15; // [rsp+30h] [rbp-30h] BYREF
_QWORD *v16; // [rsp+38h] [rbp-28h]
unsigned long long *v17; // [rsp+40h] [rbp-20h]
long long v18; // [rsp+48h] [rbp-18h]
unsigned long long v19; // [rsp+50h] [rbp-10h]
long long v20; // [rsp+58h] [rbp-8h]
v20 = a1;
v19 = a2;
v18 = a3;
v17 = a4;
v16 = a5;
v13 = a3 + a2;
v12 = *(_QWORD *)(a1 + 120);
v10 = *a4;
v8 = *a5;
while ( 1 )
{
v7 = 0;
if ( v19 < v13 )
{
v14 = my_ucs2_uni(v20, (long long)&v15, v19, v13, (long long)a5, a6);
v7 = v14 > 0;
}
if ( !v7 )
break;
my_tosort_ucs2(v12, &v15);
v11 = v10 ^ ((v10 << 8) + (unsigned __int8)v15 * (v8 + (v10 & 0x3F)));
v9 = v8 + 3;
v10 = v11 ^ ((v11 << 8) + (v15 >> 8) * (v9 + (v11 & 0x3F)));
v8 = v9 + 3;
v19 += v14;
}
*v17 = v10;
result = v16;
*v16 = v8;
return result;
}
| my_hash_sort_ucs2_nopad:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
LAB_0016a9da:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x59],AL
JNC 0x0016aa0a
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x30]
CALL 0x001652e0
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
SETG AL
MOV byte ptr [RBP + -0x59],AL
LAB_0016aa0a:
MOV AL,byte ptr [RBP + -0x59]
TEST AL,0x1
JNZ 0x0016aa16
JMP 0x0016aab0
LAB_0016aa16:
MOV RDI,qword ptr [RBP + -0x48]
LEA RSI,[RBP + -0x30]
CALL 0x0016aad0
JMP 0x0016aa25
LAB_0016aa25:
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x30]
AND RCX,0xff
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0016aa61
LAB_0016aa61:
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x30]
SHR RCX,0x8
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0016aa9a
LAB_0016aa9a:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0016a9da
LAB_0016aab0:
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
ADD RSP,0x60
POP RBP
RET
|
void my_hash_sort_ucs2_nopad(long param_1,ulong param_2,long param_3,ulong *param_4,long *param_5)
{
int8 uVar1;
bool bVar2;
long local_60;
ulong local_58;
int local_3c;
ulong local_38;
long *local_30;
ulong *local_28;
long local_20;
ulong local_18;
long local_10;
uVar1 = *(int8 *)(param_1 + 0x78);
local_58 = *param_4;
local_60 = *param_5;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar2 = false;
if (local_18 < param_2 + param_3) {
local_3c = my_ucs2_uni(local_10,&local_38,local_18,param_2 + param_3);
bVar2 = 0 < local_3c;
}
if (!bVar2) break;
my_tosort_ucs2(uVar1,&local_38);
local_58 = ((local_58 & 0x3f) + local_60) * (local_38 & 0xff) + local_58 * 0x100 ^ local_58;
local_58 = ((local_58 & 0x3f) + local_60 + 3) * (local_38 >> 8) + local_58 * 0x100 ^ local_58;
local_60 = local_60 + 6;
local_18 = local_18 + (long)local_3c;
}
*local_28 = local_58;
*local_30 = local_60;
return;
}
| |
45,675 | my_hash_sort_ucs2_nopad | eloqsql/strings/ctype-ucs2.c | static void
my_hash_sort_ucs2_nopad(CHARSET_INFO *cs, const uchar *s, size_t slen,
ulong *nr1, ulong *nr2)
{
my_wc_t wc;
int res;
const uchar *e=s+slen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
register ulong m1= *nr1, m2= *nr2;
while ((s < e) && (res=my_ucs2_uni(cs,&wc, (uchar *)s, (uchar*)e)) >0)
{
my_tosort_ucs2(uni_plane, &wc);
MY_HASH_ADD_16(m1, m2, wc);
s+=res;
}
*nr1= m1;
*nr2= m2;
} | O3 | c | my_hash_sort_ucs2_nopad:
movq (%rcx), %r9
movq (%r8), %rax
cmpq $0x2, %rdx
jl 0x51359
pushq %rbp
movq %rsp, %rbp
pushq %rbx
addq %rsi, %rdx
movq 0x78(%rdi), %rdi
movq 0x8(%rdi), %rdi
movzbl (%rsi), %r10d
movzbl 0x1(%rsi), %r11d
movq (%rdi,%r10,8), %rbx
testq %rbx, %rbx
je 0x512f5
leaq (%r11,%r11,2), %r10
movl 0x8(%rbx,%r10,4), %r10d
jmp 0x512fc
shll $0x8, %r10d
orq %r11, %r10
movl %r9d, %r11d
andl $0x3f, %r11d
addq %rax, %r11
movzbl %r10b, %ebx
imulq %r11, %rbx
movq %r9, %r11
shlq $0x8, %r11
addq %rbx, %r11
xorq %r9, %r11
movl %r11d, %r9d
andl $0x3f, %r9d
addq %rax, %r9
addq $0x3, %r9
shrl $0x8, %r10d
imulq %r9, %r10
movq %r11, %r9
shlq $0x8, %r9
addq %r10, %r9
xorq %r11, %r9
addq $0x6, %rax
leaq 0x2(%rsi), %r10
cmpq %rdx, %r10
jae 0x51357
addq $0x4, %rsi
cmpq %rdx, %rsi
movq %r10, %rsi
jbe 0x512d8
popq %rbx
popq %rbp
movq %r9, (%rcx)
movq %rax, (%r8)
retq
| my_hash_sort_ucs2_nopad:
mov r9, [rcx]
mov rax, [r8]
cmp rdx, 2
jl loc_51359
push rbp
mov rbp, rsp
push rbx
add rdx, rsi
mov rdi, [rdi+78h]
mov rdi, [rdi+8]
loc_512D8:
movzx r10d, byte ptr [rsi]
movzx r11d, byte ptr [rsi+1]
mov rbx, [rdi+r10*8]
test rbx, rbx
jz short loc_512F5
lea r10, [r11+r11*2]
mov r10d, [rbx+r10*4+8]
jmp short loc_512FC
loc_512F5:
shl r10d, 8
or r10, r11
loc_512FC:
mov r11d, r9d
and r11d, 3Fh
add r11, rax
movzx ebx, r10b
imul rbx, r11
mov r11, r9
shl r11, 8
add r11, rbx
xor r11, r9
mov r9d, r11d
and r9d, 3Fh
add r9, rax
add r9, 3
shr r10d, 8
imul r10, r9
mov r9, r11
shl r9, 8
add r9, r10
xor r9, r11
add rax, 6
lea r10, [rsi+2]
cmp r10, rdx
jnb short loc_51357
add rsi, 4
cmp rsi, rdx
mov rsi, r10
jbe short loc_512D8
loc_51357:
pop rbx
pop rbp
loc_51359:
mov [rcx], r9
mov [r8], rax
retn
| long long my_hash_sort_ucs2_nopad(long long a1, unsigned __int8 *a2, long long a3, long long *a4, long long *a5)
{
long long v5; // r9
long long result; // rax
unsigned long long v7; // rdx
long long v8; // rdi
long long v9; // r10
long long v10; // r11
long long v11; // rbx
unsigned int v12; // r10d
long long v13; // rbx
bool v14; // cc
v5 = *a4;
result = *a5;
if ( a3 >= 2 )
{
v7 = (unsigned long long)&a2[a3];
v8 = *(_QWORD *)(*(_QWORD *)(a1 + 120) + 8LL);
do
{
v9 = *a2;
v10 = a2[1];
v11 = *(_QWORD *)(v8 + 8 * v9);
if ( v11 )
v12 = *(_DWORD *)(v11 + 12 * v10 + 8);
else
v12 = v10 | ((_DWORD)v9 << 8);
v13 = (result + (v5 & 0x3F)) * (unsigned __int8)v12;
v5 ^= (v13 + (v5 << 8)) ^ ((result + (((unsigned __int8)v5 ^ (unsigned __int8)v13) & 0x3F) + 3) * (v12 >> 8)
+ ((v5 ^ (v13 + (v5 << 8))) << 8));
result += 6LL;
if ( (unsigned long long)(a2 + 2) >= v7 )
break;
v14 = (unsigned long long)(a2 + 4) <= v7;
a2 += 2;
}
while ( v14 );
}
*a4 = v5;
*a5 = result;
return result;
}
| my_hash_sort_ucs2_nopad:
MOV R9,qword ptr [RCX]
MOV RAX,qword ptr [R8]
CMP RDX,0x2
JL 0x00151359
PUSH RBP
MOV RBP,RSP
PUSH RBX
ADD RDX,RSI
MOV RDI,qword ptr [RDI + 0x78]
MOV RDI,qword ptr [RDI + 0x8]
LAB_001512d8:
MOVZX R10D,byte ptr [RSI]
MOVZX R11D,byte ptr [RSI + 0x1]
MOV RBX,qword ptr [RDI + R10*0x8]
TEST RBX,RBX
JZ 0x001512f5
LEA R10,[R11 + R11*0x2]
MOV R10D,dword ptr [RBX + R10*0x4 + 0x8]
JMP 0x001512fc
LAB_001512f5:
SHL R10D,0x8
OR R10,R11
LAB_001512fc:
MOV R11D,R9D
AND R11D,0x3f
ADD R11,RAX
MOVZX EBX,R10B
IMUL RBX,R11
MOV R11,R9
SHL R11,0x8
ADD R11,RBX
XOR R11,R9
MOV R9D,R11D
AND R9D,0x3f
ADD R9,RAX
ADD R9,0x3
SHR R10D,0x8
IMUL R10,R9
MOV R9,R11
SHL R9,0x8
ADD R9,R10
XOR R9,R11
ADD RAX,0x6
LEA R10,[RSI + 0x2]
CMP R10,RDX
JNC 0x00151357
ADD RSI,0x4
CMP RSI,RDX
MOV RSI,R10
JBE 0x001512d8
LAB_00151357:
POP RBX
POP RBP
LAB_00151359:
MOV qword ptr [RCX],R9
MOV qword ptr [R8],RAX
RET
|
void my_hash_sort_ucs2_nopad(long param_1,byte *param_2,long param_3,ulong *param_4,long *param_5)
{
long lVar1;
long lVar2;
byte *pbVar3;
byte *pbVar4;
ulong uVar5;
ulong uVar6;
uVar6 = *param_4;
lVar2 = *param_5;
if (1 < param_3) {
pbVar3 = param_2;
do {
lVar1 = *(long *)(*(long *)(*(long *)(param_1 + 0x78) + 8) + (ulong)*pbVar3 * 8);
if (lVar1 == 0) {
uVar5 = (ulong)CONCAT11(*pbVar3,pbVar3[1]);
}
else {
uVar5 = (ulong)*(uint *)(lVar1 + 8 + (ulong)pbVar3[1] * 0xc);
}
uVar6 = uVar6 * 0x100 + (uVar5 & 0xff) * ((ulong)((uint)uVar6 & 0x3f) + lVar2) ^ uVar6;
uVar6 = uVar6 * 0x100 + (uVar5 >> 8) * ((ulong)((uint)uVar6 & 0x3f) + lVar2 + 3) ^ uVar6;
lVar2 = lVar2 + 6;
} while ((pbVar3 + 2 < param_2 + param_3) &&
(pbVar4 = pbVar3 + 4, pbVar3 = pbVar3 + 2, pbVar4 <= param_2 + param_3));
}
*param_4 = uVar6;
*param_5 = lVar2;
return;
}
| |
45,676 | ftxui::ComponentBase::ActiveChild() | Andrewchistyakov[P]flashcards_lyc/build_O2/_deps/ftxui-src/src/ftxui/component/component.cpp | Component ComponentBase::ActiveChild() {
for (auto& child : children_) {
if (child->Focusable()) {
return child;
}
}
return nullptr;
} | O2 | cpp | ftxui::ComponentBase::ActiveChild():
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %r14
movq 0x10(%rsi), %r15
cmpq %r15, %r14
je 0x21d02
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
jne 0x21d0a
addq $0x10, %r14
jmp 0x21cea
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x21d15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1341e
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
| _ZN5ftxui13ComponentBase11ActiveChildEv:
push r15
push r14
push rbx
mov rbx, rdi
mov r14, [rsi+8]
mov r15, [rsi+10h]
loc_21CEA:
cmp r14, r15
jz short loc_21D02
mov rdi, [r14]
mov rax, [rdi]
call qword ptr [rax+30h]
test al, al
jnz short loc_21D0A
add r14, 10h
jmp short loc_21CEA
loc_21D02:
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
jmp short loc_21D15
loc_21D0A:
mov rdi, rbx
mov rsi, r14
call _ZNSt12__shared_ptrIN5ftxui13ComponentBaseELN9__gnu_cxx12_Lock_policyE2EEC2ERKS4_; std::__shared_ptr<ftxui::ComponentBase,(__gnu_cxx::_Lock_policy)2>::__shared_ptr(std::__shared_ptr<ftxui::ComponentBase,(__gnu_cxx::_Lock_policy)2> const&)
loc_21D15:
mov rax, rbx
pop rbx
pop r14
pop r15
retn
| ftxui::ComponentBase * ftxui::ComponentBase::ActiveChild(ftxui::ComponentBase *this, long long a2)
{
_QWORD *v2; // r14
_QWORD *v3; // r15
v2 = *(_QWORD **)(a2 + 8);
v3 = *(_QWORD **)(a2 + 16);
while ( 1 )
{
if ( v2 == v3 )
{
*(_OWORD *)this = 0LL;
return this;
}
if ( (*(unsigned __int8 ( **)(_QWORD))(*(_QWORD *)*v2 + 48LL))(*v2) )
break;
v2 += 2;
}
std::__shared_ptr<ftxui::ComponentBase,(__gnu_cxx::_Lock_policy)2>::__shared_ptr(this, v2);
return this;
}
| ActiveChild:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV R14,qword ptr [RSI + 0x8]
MOV R15,qword ptr [RSI + 0x10]
LAB_00121cea:
CMP R14,R15
JZ 0x00121d02
MOV RDI,qword ptr [R14]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x30]
TEST AL,AL
JNZ 0x00121d0a
ADD R14,0x10
JMP 0x00121cea
LAB_00121d02:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
JMP 0x00121d15
LAB_00121d0a:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011341e
LAB_00121d15:
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
|
/* ftxui::ComponentBase::ActiveChild() */
void ftxui::ComponentBase::ActiveChild(void)
{
__shared_ptr *p_Var1;
char cVar2;
long in_RSI;
__shared_ptr<ftxui::ComponentBase,(__gnu_cxx::_Lock_policy)2> *in_RDI;
__shared_ptr *p_Var3;
p_Var3 = *(__shared_ptr **)(in_RSI + 8);
p_Var1 = *(__shared_ptr **)(in_RSI + 0x10);
while( true ) {
if (p_Var3 == p_Var1) {
*(int8 *)in_RDI = 0;
*(int8 *)(in_RDI + 8) = 0;
return;
}
cVar2 = (**(code **)(**(long **)p_Var3 + 0x30))();
if (cVar2 != '\0') break;
p_Var3 = p_Var3 + 0x10;
}
std::__shared_ptr<ftxui::ComponentBase,(__gnu_cxx::_Lock_policy)2>::__shared_ptr(in_RDI,p_Var3);
return;
}
| |
45,677 | ftxui::Screen::RegisterHyperlink(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Andrewchistyakov[P]flashcards_lyc/build_O0/_deps/ftxui-src/src/ftxui/screen/screen.cpp | uint8_t Screen::RegisterHyperlink(const std::string& link) {
for (size_t i = 0; i < hyperlinks_.size(); ++i) {
if (hyperlinks_[i] == link) {
return i;
}
}
if (hyperlinks_.size() == std::numeric_limits<uint8_t>::max()) {
return 0;
}
hyperlinks_.push_back(link);
return hyperlinks_.size() - 1;
} | O0 | cpp | ftxui::Screen::RegisterHyperlink(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x40, %rdi
callq 0x18410
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x88f5d
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
movq -0x20(%rbp), %rsi
callq 0x184c0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x25400
testb $0x1, %al
jne 0x88f44
jmp 0x88f4d
movq -0x20(%rbp), %rax
movb %al, -0x1(%rbp)
jmp 0x88fac
jmp 0x88f4f
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x88f00
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
callq 0x18410
movq %rax, -0x38(%rbp)
callq 0x8c610
movb %al, %cl
movq -0x38(%rbp), %rax
movzbl %cl, %ecx
cmpq %rcx, %rax
jne 0x88f87
movb $0x0, -0x1(%rbp)
jmp 0x88fac
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
movq -0x18(%rbp), %rsi
callq 0x5db40
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
callq 0x18410
subq $0x1, %rax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN5ftxui6Screen17RegisterHyperlinkERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
mov [rbp+var_20], 0
loc_88F00:
mov rdi, [rbp+var_28]
mov rax, [rbp+var_20]
mov [rbp+var_30], rax
add rdi, 40h ; '@'
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE4sizeEv; std::vector<std::string>::size(void)
mov rcx, rax
mov rax, [rbp+var_30]
cmp rax, rcx
jnb short loc_88F5D
mov rdi, [rbp+var_28]
add rdi, 40h ; '@'
mov rsi, [rbp+var_20]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEixEm; std::vector<std::string>::operator[](ulong)
mov rdi, rax
mov rsi, [rbp+var_18]
call _ZSteqIcEN9__gnu_cxx11__enable_ifIXsr9__is_charIT_EE7__valueEbE6__typeERKNSt7__cxx1112basic_stringIS2_St11char_traitsIS2_ESaIS2_EEESC_
test al, 1
jnz short loc_88F44
jmp short loc_88F4D
loc_88F44:
mov rax, [rbp+var_20]
mov [rbp+var_1], al
jmp short loc_88FAC
loc_88F4D:
jmp short $+2
loc_88F4F:
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp short loc_88F00
loc_88F5D:
mov rdi, [rbp+var_28]
add rdi, 40h ; '@'
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE4sizeEv; std::vector<std::string>::size(void)
mov [rbp+var_38], rax
call _ZNSt14numeric_limitsIhE3maxEv; std::numeric_limits<uchar>::max(void)
mov cl, al
mov rax, [rbp+var_38]
movzx ecx, cl
cmp rax, rcx
jnz short loc_88F87
mov [rbp+var_1], 0
jmp short loc_88FAC
loc_88F87:
mov rdi, [rbp+var_28]
add rdi, 40h ; '@'
mov rsi, [rbp+var_18]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backERKS5_; std::vector<std::string>::push_back(std::string const&)
mov rdi, [rbp+var_28]
add rdi, 40h ; '@'
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE4sizeEv; std::vector<std::string>::size(void)
sub rax, 1
mov [rbp+var_1], al
loc_88FAC:
mov al, [rbp+var_1]
add rsp, 40h
pop rbp
retn
| char ftxui::Screen::RegisterHyperlink(long long a1, long long a2)
{
long long v2; // rax
long long v4; // [rsp+8h] [rbp-38h]
unsigned long long i; // [rsp+20h] [rbp-20h]
for ( i = 0LL; i < std::vector<std::string>::size((_QWORD *)(a1 + 64)); ++i )
{
v2 = std::vector<std::string>::operator[]((_QWORD *)(a1 + 64), i);
if ( (std::operator==<char>(v2, a2) & 1) != 0 )
return i;
}
v4 = std::vector<std::string>::size((_QWORD *)(a1 + 64));
if ( v4 == (unsigned __int8)std::numeric_limits<unsigned char>::max() )
return 0;
std::vector<std::string>::push_back(a1 + 64, a2);
return std::vector<std::string>::size((_QWORD *)(a1 + 64)) - 1;
}
| RegisterHyperlink:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
MOV qword ptr [RBP + -0x20],0x0
LAB_00188f00:
MOV RDI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x30],RAX
ADD RDI,0x40
CALL 0x00118410
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,RCX
JNC 0x00188f5d
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x40
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001184c0
MOV RDI,RAX
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00125400
TEST AL,0x1
JNZ 0x00188f44
JMP 0x00188f4d
LAB_00188f44:
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RBP + -0x1],AL
JMP 0x00188fac
LAB_00188f4d:
JMP 0x00188f4f
LAB_00188f4f:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00188f00
LAB_00188f5d:
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x40
CALL 0x00118410
MOV qword ptr [RBP + -0x38],RAX
CALL 0x0018c610
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x38]
MOVZX ECX,CL
CMP RAX,RCX
JNZ 0x00188f87
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00188fac
LAB_00188f87:
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x40
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0015db40
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x40
CALL 0x00118410
SUB RAX,0x1
MOV byte ptr [RBP + -0x1],AL
LAB_00188fac:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x40
POP RBP
RET
|
/* ftxui::Screen::RegisterHyperlink(std::__cxx11::string const&) */
char __thiscall ftxui::Screen::RegisterHyperlink(Screen *this,string *param_1)
{
byte bVar1;
ulong uVar2;
string *psVar3;
ulong local_28;
char local_9;
local_28 = 0;
while( true ) {
uVar2 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::size
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
(this + 0x40));
if (uVar2 <= local_28) {
uVar2 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::size
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
(this + 0x40));
bVar1 = std::numeric_limits<unsigned_char>::max();
if (uVar2 == bVar1) {
local_9 = '\0';
}
else {
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::push_back
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
(this + 0x40),param_1);
local_9 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::size
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
(this + 0x40));
local_9 = local_9 + -1;
}
return local_9;
}
psVar3 = (string *)
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::operator[]
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
(this + 0x40),local_28);
uVar2 = std::operator==(psVar3,param_1);
if ((uVar2 & 1) != 0) break;
local_28 = local_28 + 1;
}
return (char)local_28;
}
| |
45,678 | build_grammar[abi:cxx11](std::function<void (common_grammar_builder const&)> const&, common_grammar_options const&)::$_0::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | monkey531[P]llama/common/json-schema-to-grammar.cpp | std::string build_grammar(const std::function<void(const common_grammar_builder &)> & cb, const common_grammar_options & options) {
SchemaConverter converter([&](const std::string &) { return json(); }, options.dotall, options.compact_spaces);
common_grammar_builder builder {
/* .add_rule = */ [&](const std::string & name, const std::string & rule) {
return converter._add_rule(name, rule);
},
/* .add_schema = */ [&](const std::string & name, const nlohmann::ordered_json & schema) {
return converter.visit(schema, name == "root" ? "" : name);
},
/* .resolve_refs = */ [&](nlohmann::ordered_json & schema) {
converter.resolve_refs(schema, "");
}
};
cb(builder);
converter.check_errors();
return converter.format_grammar();
} | O0 | cpp | build_grammar[abi:cxx11](std::function<void (common_grammar_builder const&)> const&, common_grammar_options const&)::$_0::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const:
subq $0x28, %rsp
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0xa0130
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nop
| _ZZ13build_grammarB5cxx11RKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_optionsENK3$_0clERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
sub rsp, 28h
mov rax, rdi
mov [rsp+28h+var_20], rax
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
mov [rsp+28h+var_18], rdx
xor eax, eax
mov esi, eax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EDn; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(decltype(nullptr))
mov rax, [rsp+28h+var_20]
add rsp, 28h
retn
| long long build_grammar[abi:cxx11](std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_0::operator()(
long long a1)
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(a1);
return a1;
}
| end:
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
MOV RSI,qword ptr [RSP + 0x8]
ADD RSI,0x8
LEA RDI,[RSP + 0x10]
CALL 0x001fcae0
MOV RAX,qword ptr [RSP + 0x10]
ADD RSP,0x18
RET
|
/* std::vector<char const*, std::allocator<char const*> >::end() */
int8 __thiscall
std::vector<char_const*,std::allocator<char_const*>>::end
(vector<char_const*,std::allocator<char_const*>> *this)
{
int8 local_8;
__gnu_cxx::__normal_iterator<char_const**,std::vector<char_const*,std::allocator<char_const*>>>::
__normal_iterator((__normal_iterator<char_const**,std::vector<char_const*,std::allocator<char_const*>>>
*)&local_8,(char ***)(this + 8));
return local_8;
}
| |
45,679 | build_grammar[abi:cxx11](std::function<void (common_grammar_builder const&)> const&, common_grammar_options const&)::$_0::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | monkey531[P]llama/common/json-schema-to-grammar.cpp | std::string build_grammar(const std::function<void(const common_grammar_builder &)> & cb, const common_grammar_options & options) {
SchemaConverter converter([&](const std::string &) { return json(); }, options.dotall, options.compact_spaces);
common_grammar_builder builder {
/* .add_rule = */ [&](const std::string & name, const std::string & rule) {
return converter._add_rule(name, rule);
},
/* .add_schema = */ [&](const std::string & name, const nlohmann::ordered_json & schema) {
return converter.visit(schema, name == "root" ? "" : name);
},
/* .resolve_refs = */ [&](nlohmann::ordered_json & schema) {
converter.resolve_refs(schema, "");
}
};
cb(builder);
converter.check_errors();
return converter.format_grammar();
} | O1 | cpp | build_grammar[abi:cxx11](std::function<void (common_grammar_builder const&)> const&, common_grammar_options const&)::$_0::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x160, %rsp # imm = 0x160
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
leaq 0x304(%rip), %rax # 0xc0c50
movq %rax, 0x18(%rsi)
leaq 0x325(%rip), %rax # 0xc0c7c
movq %rax, 0x10(%rsi)
movzbl (%rdx), %eax
movzbl 0x1(%rdx), %ecx
leaq 0x68(%rsp), %r15
movq %r15, %rdi
movl %eax, %edx
callq 0xc3ece
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xc0988
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movq %r15, (%rsp)
leaq 0x2f5(%rip), %rax # 0xc0c94
movq %rax, 0x18(%rsp)
leaq 0x2fb(%rip), %rax # 0xc0ca6
movq %rax, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
movq %r15, 0x20(%rsp)
leaq 0x306(%rip), %rax # 0xc0ccc
movq %rax, 0x38(%rsp)
leaq 0x3ac(%rip), %rax # 0xc0d7e
movq %rax, 0x30(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x50(%rsp)
movq %r15, 0x40(%rsp)
leaq 0x2e37(%rip), %rax # 0xc3824
movq %rax, 0x58(%rsp)
leaq 0x2e95(%rip), %rax # 0xc388e
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x10(%r14)
je 0xc0adf
movq %rsp, %rsi
movq %r14, %rdi
callq *0x18(%r14)
leaq 0x68(%rsp), %rdi
callq 0xc40d0
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0xc4286
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0xc0a43
leaq 0x40(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xc0a5c
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xc0a73
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x148(%rsp), %rdi
callq 0x258d6
leaq 0x130(%rsp), %rdi
callq 0x258d6
leaq 0xf8(%rsp), %rdi
callq 0x83bbc
leaq 0xc0(%rsp), %rdi
callq 0xc4a9a
leaq 0x90(%rsp), %r14
movq %r14, %rdi
callq 0xc4b7c
movq -0x18(%r14), %rax
testq %rax, %rax
je 0xc0acf
leaq 0x68(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x160, %rsp # imm = 0x160
popq %rbx
popq %r14
popq %r15
retq
callq 0x1b330
jmp 0xc0b0a
jmp 0xc0b0a
jmp 0xc0b0a
jmp 0xc0b0a
jmp 0xc0b0a
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xc0b27
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xc0b27
movq %rax, %rdi
callq 0x25c97
movq %rax, %rbx
movq %rsp, %rdi
callq 0xc4392
leaq 0x68(%rsp), %rdi
callq 0xc43e8
movq %rbx, %rdi
callq 0x1c040
nop
| _Z13build_grammarB5cxx11RKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_options:
push r15
push r14
push rbx
sub rsp, 160h
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
mov rsi, rsp; int
movaps xmmword ptr [rsi], xmm0
lea rax, _ZNSt17_Function_handlerIFN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEERKSA_EZ13build_grammarRKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_optionsE3$_0E9_M_invokeERKSt9_Any_dataSG_; std::_Function_handler<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> ()(std::string const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_0>::_M_invoke(std::_Any_data const&,std::string const&)
mov [rsi+18h], rax
lea rax, _ZNSt17_Function_handlerIFN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEERKSA_EZ13build_grammarRKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_optionsE3$_0E10_M_managerERSt9_Any_dataRKSV_St18_Manager_operation; std::_Function_handler<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> ()(std::string const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_0>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rsi+10h], rax
movzx eax, byte ptr [rdx]
movzx ecx, byte ptr [rdx+1]; int
lea r15, [rsp+178h+var_110]
mov rdi, r15; int
mov edx, eax; int
call _ZN15SchemaConverterC2ERKSt8functionIFN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEERKSB_EEbb; SchemaConverter::SchemaConverter(std::function<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> ()(std::string const&)> const&,bool,bool)
mov rax, qword ptr [rsp+178h+var_168]
test rax, rax
jz short loc_C0988
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_C0988:
xorps xmm0, xmm0
movaps [rsp+178h+var_178], xmm0
movaps [rsp+178h+var_168], xmm0
mov qword ptr [rsp+178h+var_178], r15
lea rax, _ZNSt17_Function_handlerIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS5_S7_EZ13build_grammarRKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_optionsE3$_1E9_M_invokeERKSt9_Any_dataS7_S7_; std::_Function_handler<std::string ()(std::string const&,std::string const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_1>::_M_invoke(std::_Any_data const&,std::string const&,std::string const&)
mov qword ptr [rsp+178h+var_168+8], rax
lea rax, _ZNSt17_Function_handlerIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS5_S7_EZ13build_grammarRKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_optionsE3$_1E10_M_managerERSt9_Any_dataRKSM_St18_Manager_operation; std::_Function_handler<std::string ()(std::string const&,std::string const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_1>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov qword ptr [rsp+178h+var_168], rax
movaps [rsp+178h+var_158], xmm0
movaps [rsp+178h+var_148], xmm0
mov qword ptr [rsp+178h+var_158], r15
lea rax, _ZNSt17_Function_handlerIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS5_RKN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapESt6vectorS5_blmdSaNS9_14adl_serializerESC_IhSaIhEEvEEEZ13build_grammarRKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_optionsE3$_2E9_M_invokeERKSt9_Any_dataS7_SI_; std::_Function_handler<std::string ()(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> const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_2>::_M_invoke(std::_Any_data const&,std::string const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov qword ptr [rsp+178h+var_148+8], rax
lea rax, _ZNSt17_Function_handlerIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS5_RKN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapESt6vectorS5_blmdSaNS9_14adl_serializerESC_IhSaIhEEvEEEZ13build_grammarRKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_optionsE3$_2E10_M_managerERSt9_Any_dataRKSX_St18_Manager_operation; std::_Function_handler<std::string ()(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> const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_2>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov qword ptr [rsp+178h+var_148], rax
movaps [rsp+178h+var_138], xmm0
movaps [rsp+178h+var_128], xmm0
mov qword ptr [rsp+178h+var_138], r15
lea rax, _ZNSt17_Function_handlerIFvRN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEZ13build_grammarRKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_optionsE3$_3E9_M_invokeERKSt9_Any_dataSF_; std::_Function_handler<void ()(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_3>::_M_invoke(std::_Any_data const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)
mov qword ptr [rsp+178h+var_128+8], rax
lea rax, _ZNSt17_Function_handlerIFvRN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEZ13build_grammarRKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_optionsE3$_3E10_M_managerERSt9_Any_dataRKSU_St18_Manager_operation; std::_Function_handler<void ()(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_3>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov qword ptr [rsp+178h+var_128], rax
cmp qword ptr [r14+10h], 0
jz loc_C0ADF
mov rsi, rsp
mov rdi, r14
call qword ptr [r14+18h]
lea rdi, [rsp+178h+var_110]; this
call _ZN15SchemaConverter12check_errorsEv; SchemaConverter::check_errors(void)
lea rsi, [rsp+178h+var_110]
mov rdi, rbx
call _ZN15SchemaConverter14format_grammarB5cxx11Ev; SchemaConverter::format_grammar(void)
mov rax, qword ptr [rsp+178h+var_128]
test rax, rax
jz short loc_C0A43
lea rdi, [rsp+178h+var_138]
mov rsi, rdi
mov edx, 3
call rax
loc_C0A43:
mov rax, qword ptr [rsp+178h+var_148]
test rax, rax
jz short loc_C0A5C
lea rdi, [rsp+178h+var_158]
mov rsi, rdi
mov edx, 3
call rax
loc_C0A5C:
mov rax, qword ptr [rsp+178h+var_168]
test rax, rax
jz short loc_C0A73
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_C0A73:
lea rdi, [rsp+178h+var_30]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
lea rdi, [rsp+178h+var_48]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
lea rdi, [rsp+178h+var_80]
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_SaIS5_ENSt8__detail9_IdentityESt8equal_toIS5_ESt4hashIS5_ENS7_18_Mod_range_hashingENS7_20_Default_ranged_hashENS7_20_Prime_rehash_policyENS7_17_Hashtable_traitsILb1ELb1ELb1EEEED2Ev; std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::~_Hashtable()
lea rdi, [rsp+178h+var_B8]
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_N8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapESt6vectorS5_blmdSaNS9_14adl_serializerESC_IhSaIhEEvEEESaISH_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSJ_18_Mod_range_hashingENSJ_20_Default_ranged_hashENSJ_20_Prime_rehash_policyENSJ_17_Hashtable_traitsILb1ELb0ELb1EEEED2Ev; std::_Hashtable<std::string,std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::~_Hashtable()
lea r14, [rsp+178h+var_E8]
mov rdi, r14
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S5_ESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::~_Rb_tree()
mov rax, [r14-18h]
test rax, rax
jz short loc_C0ACF
lea rdi, [rsp+178h+var_110]
mov rsi, rdi
mov edx, 3
call rax
loc_C0ACF:
mov rax, rbx
add rsp, 160h
pop rbx
pop r14
pop r15
retn
loc_C0ADF:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
jmp short loc_C0B0A
jmp short loc_C0B0A
jmp short loc_C0B0A
jmp short loc_C0B0A
jmp short loc_C0B0A
mov rbx, rax
mov rax, qword ptr [rsp+178h+var_168]
test rax, rax
jz short loc_C0B27
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
jmp short loc_C0B27
loc_C0B0A:
mov rdi, rax
call __clang_call_terminate
mov rbx, rax
mov rdi, rsp; this
call _ZN22common_grammar_builderD2Ev; common_grammar_builder::~common_grammar_builder()
lea rdi, [rsp+178h+var_110]; this
call _ZN15SchemaConverterD2Ev; SchemaConverter::~SchemaConverter()
loc_C0B27:
mov rdi, rbx
call __Unwind_Resume
| long long build_grammar[abi:cxx11](long long a1, long long a2, unsigned __int8 *a3, long long a4, int a5, int a6)
{
int v6; // edx
int v7; // ecx
int v8; // r8d
int v9; // r9d
__int128 v11; // [rsp+0h] [rbp-178h] BYREF
long long ( *v12)(); // [rsp+10h] [rbp-168h]
void *v13; // [rsp+18h] [rbp-160h]
__int128 v14; // [rsp+20h] [rbp-158h] BYREF
long long ( *v15)(); // [rsp+30h] [rbp-148h]
long long ( *v16)(int, int, int, int, int, int, int, long long); // [rsp+38h] [rbp-140h]
__int128 v17; // [rsp+40h] [rbp-138h] BYREF
long long ( *v18)(); // [rsp+50h] [rbp-128h]
long long ( *v19)(int, int, int, int, int, int, void *, int, long long); // [rsp+58h] [rbp-120h]
int v20; // [rsp+60h] [rbp-118h]
int v21[4]; // [rsp+68h] [rbp-110h] BYREF
void ( *v22)(int *, int *, long long); // [rsp+78h] [rbp-100h]
_BYTE v23[48]; // [rsp+90h] [rbp-E8h] BYREF
_BYTE v24[56]; // [rsp+C0h] [rbp-B8h] BYREF
_BYTE v25[56]; // [rsp+F8h] [rbp-80h] BYREF
_QWORD v26[3]; // [rsp+130h] [rbp-48h] BYREF
_QWORD v27[6]; // [rsp+148h] [rbp-30h] BYREF
SchemaConverter::SchemaConverter(
(int)v21,
(int)&v11,
*a3,
a3[1],
a5,
a6,
0LL,
0,
(long long)std::_Function_handler<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::string const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_0>::_M_manager,
(int)std::_Function_handler<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::string const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_0>::_M_invoke,
(void *)v14,
SDWORD2(v14),
(long long)v15);
if ( v12 )
((void ( *)(__int128 *, __int128 *, long long))v12)(&v11, &v11, 3LL);
v11 = (unsigned long long)v21;
v13 = &std::_Function_handler<std::string ()(std::string const&,std::string const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_1>::_M_invoke;
v12 = std::_Function_handler<std::string ()(std::string const&,std::string const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_1>::_M_manager;
v14 = (unsigned long long)v21;
v16 = std::_Function_handler<std::string ()(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> const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_2>::_M_invoke;
v15 = std::_Function_handler<std::string ()(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> const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_2>::_M_manager;
v17 = (unsigned long long)v21;
v19 = std::_Function_handler<void ()(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_3>::_M_invoke;
v18 = std::_Function_handler<void ()(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_3>::_M_manager;
if ( !*(_QWORD *)(a2 + 16) )
std::__throw_bad_function_call();
(*(void ( **)(long long, __int128 *))(a2 + 24))(a2, &v11);
SchemaConverter::check_errors((SchemaConverter *)v21);
SchemaConverter::format_grammar[abi:cxx11](
a1,
(unsigned int)v21,
v6,
v7,
v8,
v9,
v11,
DWORD2(v11),
(_DWORD)v12,
(_DWORD)v13,
v14,
DWORD2(v14),
(_DWORD)v15,
(_DWORD)v16,
v17,
DWORD2(v17),
(_DWORD)v18,
(_DWORD)v19,
v20,
v21[0],
v21[2],
(char)v22);
if ( v18 )
((void ( *)(__int128 *, __int128 *, long long))v18)(&v17, &v17, 3LL);
if ( v15 )
((void ( *)(__int128 *, __int128 *, long long))v15)(&v14, &v14, 3LL);
if ( v12 )
((void ( *)(__int128 *, __int128 *, long long))v12)(&v11, &v11, 3LL);
std::vector<std::string>::~vector(v27);
std::vector<std::string>::~vector(v26);
std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::~_Hashtable((long long)v25);
std::_Hashtable<std::string,std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::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>>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::~_Hashtable(v24);
std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::~_Rb_tree(v23);
if ( v22 )
v22(v21, v21, 3LL);
return a1;
}
| build_grammar[abi:cxx11]:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x160
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOV RSI,RSP
MOVAPS xmmword ptr [RSI],XMM0
LEA RAX,[0x1c0c50]
MOV qword ptr [RSI + 0x18],RAX
LEA RAX,[0x1c0c7c]
MOV qword ptr [RSI + 0x10],RAX
MOVZX EAX,byte ptr [RDX]
MOVZX ECX,byte ptr [RDX + 0x1]
LAB_001c0962:
LEA R15,[RSP + 0x68]
MOV RDI,R15
MOV EDX,EAX
CALL 0x001c3ece
MOV RAX,qword ptr [RSP + 0x10]
TEST RAX,RAX
JZ 0x001c0988
LAB_001c097b:
MOV RDI,RSP
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001c0988:
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV qword ptr [RSP],R15
LEA RAX,[0x1c0c94]
MOV qword ptr [RSP + 0x18],RAX
LEA RAX,[0x1c0ca6]
MOV qword ptr [RSP + 0x10],RAX
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOV qword ptr [RSP + 0x20],R15
LEA RAX,[0x1c0ccc]
MOV qword ptr [RSP + 0x38],RAX
LEA RAX,[0x1c0d7e]
MOV qword ptr [RSP + 0x30],RAX
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOV qword ptr [RSP + 0x40],R15
LEA RAX,[0x1c3824]
MOV qword ptr [RSP + 0x58],RAX
LEA RAX,[0x1c388e]
MOV qword ptr [RSP + 0x50],RAX
CMP qword ptr [R14 + 0x10],0x0
JZ 0x001c0adf
LAB_001c0a09:
MOV RSI,RSP
MOV RDI,R14
CALL qword ptr [R14 + 0x18]
LEA RDI,[RSP + 0x68]
CALL 0x001c40d0
LEA RSI,[RSP + 0x68]
MOV RDI,RBX
CALL 0x001c4286
MOV RAX,qword ptr [RSP + 0x50]
TEST RAX,RAX
JZ 0x001c0a43
LEA RDI,[RSP + 0x40]
LAB_001c0a39:
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001c0a43:
MOV RAX,qword ptr [RSP + 0x30]
TEST RAX,RAX
JZ 0x001c0a5c
LEA RDI,[RSP + 0x20]
LAB_001c0a52:
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001c0a5c:
MOV RAX,qword ptr [RSP + 0x10]
TEST RAX,RAX
JZ 0x001c0a73
LAB_001c0a66:
MOV RDI,RSP
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001c0a73:
LEA RDI,[RSP + 0x148]
CALL 0x001258d6
LEA RDI,[RSP + 0x130]
CALL 0x001258d6
LEA RDI,[RSP + 0xf8]
CALL 0x00183bbc
LEA RDI,[RSP + 0xc0]
CALL 0x001c4a9a
LEA R14,[RSP + 0x90]
MOV RDI,R14
CALL 0x001c4b7c
MOV RAX,qword ptr [R14 + -0x18]
TEST RAX,RAX
JZ 0x001c0acf
LAB_001c0ac0:
LEA RDI,[RSP + 0x68]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001c0acf:
MOV RAX,RBX
ADD RSP,0x160
POP RBX
POP R14
POP R15
RET
LAB_001c0adf:
CALL 0x0011b330
|
/* build_grammar[abi:cxx11](std::function<void (common_grammar_builder const&)> const&,
common_grammar_options const&) */
function * build_grammar_abi_cxx11_(function *param_1,common_grammar_options *param_2)
{
long in_RDX;
SchemaConverter *local_178;
int8 uStack_170;
code *local_168;
code *pcStack_160;
SchemaConverter *local_158;
int8 uStack_150;
code *local_148;
code *pcStack_140;
SchemaConverter *local_138;
int8 uStack_130;
code *local_128;
code *pcStack_120;
SchemaConverter local_110 [16];
code *local_100;
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
local_e8 [48];
_Hashtable<std::__cxx11::string,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>>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
local_b8 [56];
_Hashtable<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>
local_80 [56];
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> local_48 [24];
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> local_30 [24];
local_178 = (SchemaConverter *)0x0;
uStack_170 = 0;
pcStack_160 = std::
_Function_handler<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::__cxx11::string_const&),build_grammar(std::function<void(common_grammar_builder_const&)>const&,common_grammar_options_const&)::$_0>
::_M_invoke;
local_168 = std::
_Function_handler<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::__cxx11::string_const&),build_grammar(std::function<void(common_grammar_builder_const&)>const&,common_grammar_options_const&)::$_0>
::_M_manager;
/* try { // try from 001c0962 to 001c0970 has its CatchHandler @ 001c0aee */
SchemaConverter::SchemaConverter
(local_110,(function *)&local_178,*(bool *)in_RDX,*(bool *)(in_RDX + 1));
if (local_168 != (code *)0x0) {
/* try { // try from 001c097b to 001c0987 has its CatchHandler @ 001c0aec */
(*local_168)(&local_178,&local_178,3);
}
uStack_170 = 0;
pcStack_160 = std::
_Function_handler<std::__cxx11::string(std::__cxx11::string_const&,std::__cxx11::string_const&),build_grammar(std::function<void(common_grammar_builder_const&)>const&,common_grammar_options_const&)::$_1>
::_M_invoke;
local_168 = std::
_Function_handler<std::__cxx11::string(std::__cxx11::string_const&,std::__cxx11::string_const&),build_grammar(std::function<void(common_grammar_builder_const&)>const&,common_grammar_options_const&)::$_1>
::_M_manager;
uStack_150 = 0;
pcStack_140 = std::
_Function_handler<std::__cxx11::string(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>const&),build_grammar(std::function<void(common_grammar_builder_const&)>const&,common_grammar_options_const&)::$_2>
::_M_invoke;
local_148 = std::
_Function_handler<std::__cxx11::string(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>const&),build_grammar(std::function<void(common_grammar_builder_const&)>const&,common_grammar_options_const&)::$_2>
::_M_manager;
uStack_130 = 0;
pcStack_120 = std::
_Function_handler<void(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&),build_grammar(std::function<void(common_grammar_builder_const&)>const&,common_grammar_options_const&)::$_3>
::_M_invoke;
local_128 = std::
_Function_handler<void(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&),build_grammar(std::function<void(common_grammar_builder_const&)>const&,common_grammar_options_const&)::$_3>
::_M_manager;
local_178 = local_110;
local_158 = local_110;
local_138 = local_110;
if (*(long *)(param_2 + 0x10) != 0) {
/* try { // try from 001c0a09 to 001c0a29 has its CatchHandler @ 001c0b12 */
(**(code **)(param_2 + 0x18))(param_2,&local_178);
SchemaConverter::check_errors(local_110);
SchemaConverter::format_grammar_abi_cxx11_();
if (local_128 != (code *)0x0) {
/* try { // try from 001c0a39 to 001c0a42 has its CatchHandler @ 001c0aea */
(*local_128)(&local_138,&local_138,3);
}
if (local_148 != (code *)0x0) {
/* try { // try from 001c0a52 to 001c0a5b has its CatchHandler @ 001c0ae8 */
(*local_148)(&local_158,&local_158,3);
}
if (local_168 != (code *)0x0) {
/* try { // try from 001c0a66 to 001c0a72 has its CatchHandler @ 001c0ae6 */
(*local_168)(&local_178,&local_178,3);
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector(local_30);
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector(local_48);
std::
_Hashtable<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>
::~_Hashtable(local_80);
std::
_Hashtable<std::__cxx11::string,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>>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::~_Hashtable(local_b8);
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
::~_Rb_tree(local_e8);
if (local_100 != (code *)0x0) {
/* try { // try from 001c0ac0 to 001c0ace has its CatchHandler @ 001c0ae4 */
(*local_100)(local_110,local_110,3);
}
return param_1;
}
/* WARNING: Subroutine does not return */
/* try { // try from 001c0adf to 001c0ae3 has its CatchHandler @ 001c0b12 */
std::__throw_bad_function_call();
}
| |
45,680 | build_grammar[abi:cxx11](std::function<void (common_grammar_builder const&)> const&, common_grammar_options const&)::$_0::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | monkey531[P]llama/common/json-schema-to-grammar.cpp | std::string build_grammar(const std::function<void(const common_grammar_builder &)> & cb, const common_grammar_options & options) {
SchemaConverter converter([&](const std::string &) { return json(); }, options.dotall, options.compact_spaces);
common_grammar_builder builder {
/* .add_rule = */ [&](const std::string & name, const std::string & rule) {
return converter._add_rule(name, rule);
},
/* .add_schema = */ [&](const std::string & name, const nlohmann::ordered_json & schema) {
return converter.visit(schema, name == "root" ? "" : name);
},
/* .resolve_refs = */ [&](nlohmann::ordered_json & schema) {
converter.resolve_refs(schema, "");
}
};
cb(builder);
converter.check_errors();
return converter.format_grammar();
} | O3 | cpp | build_grammar[abi:cxx11](std::function<void (common_grammar_builder const&)> const&, common_grammar_options const&)::$_0::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x160, %rsp # imm = 0x160
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
leaq 0x2f4(%rip), %rax # 0xbb066
movq %rax, 0x18(%rsi)
leaq 0x315(%rip), %rax # 0xbb092
movq %rax, 0x10(%rsi)
movzbl (%rdx), %eax
movzbl 0x1(%rdx), %ecx
leaq 0x68(%rsp), %r15
movq %r15, %rdi
movl %eax, %edx
callq 0xbe334
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xbadae
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %r15, (%rsp)
leaq 0x2ea(%rip), %rcx # 0xbb0aa
movq %rcx, 0x18(%rsp)
leaq 0x2f0(%rip), %rcx # 0xbb0bc
movq %rcx, 0x10(%rsp)
movq %rax, 0x28(%rsp)
movq %r15, 0x20(%rsp)
leaq 0x300(%rip), %rcx # 0xbb0e2
movq %rcx, 0x38(%rsp)
leaq 0x3a6(%rip), %rcx # 0xbb194
movq %rcx, 0x30(%rsp)
movq %rax, 0x48(%rsp)
movq %r15, 0x40(%rsp)
leaq 0x2e86(%rip), %rcx # 0xbdc8a
movq %rcx, 0x58(%rsp)
leaq 0x2ee4(%rip), %rcx # 0xbdcf4
movq %rcx, 0x50(%rsp)
cmpq %rax, 0x10(%r14)
je 0xbaef5
movq %rsp, %rsi
movq %r14, %rdi
callq *0x18(%r14)
leaq 0x68(%rsp), %rdi
callq 0xbe536
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0xbe6fe
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0xbae59
leaq 0x40(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xbae72
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xbae89
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x148(%rsp), %rdi
callq 0x2152e
leaq 0x130(%rsp), %rdi
callq 0x2152e
leaq 0xf8(%rsp), %rdi
callq 0x7e654
leaq 0xc0(%rsp), %rdi
callq 0xbef12
leaq 0x90(%rsp), %r14
movq %r14, %rdi
callq 0xbeff4
movq -0x18(%r14), %rax
testq %rax, %rax
je 0xbaee5
leaq 0x68(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x160, %rsp # imm = 0x160
popq %rbx
popq %r14
popq %r15
retq
callq 0x1a330
jmp 0xbaf20
jmp 0xbaf20
jmp 0xbaf20
jmp 0xbaf20
jmp 0xbaf20
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xbaf3d
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xbaf3d
movq %rax, %rdi
callq 0x218f5
movq %rax, %rbx
movq %rsp, %rdi
callq 0xbe80a
leaq 0x68(%rsp), %rdi
callq 0xbe860
movq %rbx, %rdi
callq 0x1afd0
nop
| _Z13build_grammarB5cxx11RKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_options:
push r15
push r14
push rbx
sub rsp, 160h
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
mov rsi, rsp; int
movaps xmmword ptr [rsi], xmm0
lea rax, _ZNSt17_Function_handlerIFN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEERKSA_EZ13build_grammarRKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_optionsE3$_0E9_M_invokeERKSt9_Any_dataSG_; std::_Function_handler<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> ()(std::string const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_0>::_M_invoke(std::_Any_data const&,std::string const&)
mov [rsi+18h], rax
lea rax, _ZNSt17_Function_handlerIFN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEERKSA_EZ13build_grammarRKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_optionsE3$_0E10_M_managerERSt9_Any_dataRKSV_St18_Manager_operation; std::_Function_handler<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> ()(std::string const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_0>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rsi+10h], rax
movzx eax, byte ptr [rdx]
movzx ecx, byte ptr [rdx+1]; int
lea r15, [rsp+178h+var_110]
mov rdi, r15; int
mov edx, eax; int
call _ZN15SchemaConverterC2ERKSt8functionIFN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEERKSB_EEbb; SchemaConverter::SchemaConverter(std::function<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> ()(std::string const&)> const&,bool,bool)
mov rax, [rsp+178h+var_168]
test rax, rax
jz short loc_BADAE
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_BADAE:
xor eax, eax
mov [rsp+178h+var_170], rax
mov [rsp+178h+var_178], r15
lea rcx, _ZNSt17_Function_handlerIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS5_S7_EZ13build_grammarRKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_optionsE3$_1E9_M_invokeERKSt9_Any_dataS7_S7_; std::_Function_handler<std::string ()(std::string const&,std::string const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_1>::_M_invoke(std::_Any_data const&,std::string const&,std::string const&)
mov [rsp+178h+var_160], rcx
lea rcx, _ZNSt17_Function_handlerIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS5_S7_EZ13build_grammarRKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_optionsE3$_1E10_M_managerERSt9_Any_dataRKSM_St18_Manager_operation; std::_Function_handler<std::string ()(std::string const&,std::string const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_1>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rsp+178h+var_168], rcx
mov [rsp+178h+var_150], rax
mov [rsp+178h+var_158], r15
lea rcx, _ZNSt17_Function_handlerIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS5_RKN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapESt6vectorS5_blmdSaNS9_14adl_serializerESC_IhSaIhEEvEEEZ13build_grammarRKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_optionsE3$_2E9_M_invokeERKSt9_Any_dataS7_SI_; std::_Function_handler<std::string ()(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> const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_2>::_M_invoke(std::_Any_data const&,std::string const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov [rsp+178h+var_140], rcx
lea rcx, _ZNSt17_Function_handlerIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS5_RKN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapESt6vectorS5_blmdSaNS9_14adl_serializerESC_IhSaIhEEvEEEZ13build_grammarRKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_optionsE3$_2E10_M_managerERSt9_Any_dataRKSX_St18_Manager_operation; std::_Function_handler<std::string ()(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> const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_2>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rsp+178h+var_148], rcx
mov [rsp+178h+var_130], rax
mov [rsp+178h+var_138], r15
lea rcx, _ZNSt17_Function_handlerIFvRN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEZ13build_grammarRKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_optionsE3$_3E9_M_invokeERKSt9_Any_dataSF_; std::_Function_handler<void ()(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_3>::_M_invoke(std::_Any_data const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)
mov [rsp+178h+var_120], rcx
lea rcx, _ZNSt17_Function_handlerIFvRN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEZ13build_grammarRKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_optionsE3$_3E10_M_managerERSt9_Any_dataRKSU_St18_Manager_operation; std::_Function_handler<void ()(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_3>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rsp+178h+var_128], rcx
cmp [r14+10h], rax
jz loc_BAEF5
mov rsi, rsp
mov rdi, r14
call qword ptr [r14+18h]
lea rdi, [rsp+178h+var_110]; this
call _ZN15SchemaConverter12check_errorsEv; SchemaConverter::check_errors(void)
lea rsi, [rsp+178h+var_110]
mov rdi, rbx
call _ZN15SchemaConverter14format_grammarB5cxx11Ev; SchemaConverter::format_grammar(void)
mov rax, [rsp+178h+var_128]
test rax, rax
jz short loc_BAE59
lea rdi, [rsp+178h+var_138]
mov rsi, rdi
mov edx, 3
call rax
loc_BAE59:
mov rax, [rsp+178h+var_148]
test rax, rax
jz short loc_BAE72
lea rdi, [rsp+178h+var_158]
mov rsi, rdi
mov edx, 3
call rax
loc_BAE72:
mov rax, [rsp+178h+var_168]
test rax, rax
jz short loc_BAE89
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_BAE89:
lea rdi, [rsp+178h+var_30]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
lea rdi, [rsp+178h+var_48]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
lea rdi, [rsp+178h+var_80]
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_SaIS5_ENSt8__detail9_IdentityESt8equal_toIS5_ESt4hashIS5_ENS7_18_Mod_range_hashingENS7_20_Default_ranged_hashENS7_20_Prime_rehash_policyENS7_17_Hashtable_traitsILb1ELb1ELb1EEEED2Ev; std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::~_Hashtable()
lea rdi, [rsp+178h+var_B8]
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_N8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapESt6vectorS5_blmdSaNS9_14adl_serializerESC_IhSaIhEEvEEESaISH_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSJ_18_Mod_range_hashingENSJ_20_Default_ranged_hashENSJ_20_Prime_rehash_policyENSJ_17_Hashtable_traitsILb1ELb0ELb1EEEED2Ev; std::_Hashtable<std::string,std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::~_Hashtable()
lea r14, [rsp+178h+var_E8]
mov rdi, r14
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S5_ESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::~_Rb_tree()
mov rax, [r14-18h]
test rax, rax
jz short loc_BAEE5
lea rdi, [rsp+178h+var_110]
mov rsi, rdi
mov edx, 3
call rax
loc_BAEE5:
mov rax, rbx
add rsp, 160h
pop rbx
pop r14
pop r15
retn
loc_BAEF5:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
jmp short loc_BAF20
jmp short loc_BAF20
jmp short loc_BAF20
jmp short loc_BAF20
jmp short loc_BAF20
mov rbx, rax
mov rax, [rsp+178h+var_168]
test rax, rax
jz short loc_BAF3D
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
jmp short loc_BAF3D
loc_BAF20:
mov rdi, rax
call __clang_call_terminate
mov rbx, rax
mov rdi, rsp; this
call _ZN22common_grammar_builderD2Ev; common_grammar_builder::~common_grammar_builder()
lea rdi, [rsp+178h+var_110]; this
call _ZN15SchemaConverterD2Ev; SchemaConverter::~SchemaConverter()
loc_BAF3D:
mov rdi, rbx
call __Unwind_Resume
| long long build_grammar[abi:cxx11](long long a1, long long a2, unsigned __int8 *a3, long long a4, int a5, int a6)
{
int v6; // edx
int v7; // ecx
int v8; // r8d
int v9; // r9d
int *v11; // [rsp+0h] [rbp-178h] BYREF
long long v12; // [rsp+8h] [rbp-170h]
long long ( *v13)(); // [rsp+10h] [rbp-168h]
void *v14; // [rsp+18h] [rbp-160h]
int *v15; // [rsp+20h] [rbp-158h] BYREF
long long v16; // [rsp+28h] [rbp-150h]
long long ( *v17)(); // [rsp+30h] [rbp-148h]
long long ( *v18)(int, int, int, int, int, int, int, long long); // [rsp+38h] [rbp-140h]
int *v19; // [rsp+40h] [rbp-138h] BYREF
long long v20; // [rsp+48h] [rbp-130h]
long long ( *v21)(); // [rsp+50h] [rbp-128h]
long long ( *v22)(int, int, int, int, int, int, void *, int, long long); // [rsp+58h] [rbp-120h]
int v23; // [rsp+60h] [rbp-118h]
int v24[4]; // [rsp+68h] [rbp-110h] BYREF
void ( *v25)(int *, int *, long long); // [rsp+78h] [rbp-100h]
_BYTE v26[48]; // [rsp+90h] [rbp-E8h] BYREF
_BYTE v27[56]; // [rsp+C0h] [rbp-B8h] BYREF
_BYTE v28[56]; // [rsp+F8h] [rbp-80h] BYREF
_BYTE v29[24]; // [rsp+130h] [rbp-48h] BYREF
_BYTE v30[48]; // [rsp+148h] [rbp-30h] BYREF
SchemaConverter::SchemaConverter(
(int)v24,
(int)&v11,
*a3,
a3[1],
a5,
a6,
0LL,
0,
(long long)std::_Function_handler<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::string const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_0>::_M_manager,
(int)std::_Function_handler<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::string const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_0>::_M_invoke,
v15,
v16,
(long long)v17);
if ( v13 )
((void ( *)(int **, int **, long long))v13)(&v11, &v11, 3LL);
v12 = 0LL;
v11 = v24;
v14 = &std::_Function_handler<std::string ()(std::string const&,std::string const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_1>::_M_invoke;
v13 = std::_Function_handler<std::string ()(std::string const&,std::string const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_1>::_M_manager;
v16 = 0LL;
v15 = v24;
v18 = std::_Function_handler<std::string ()(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> const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_2>::_M_invoke;
v17 = std::_Function_handler<std::string ()(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> const&),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_2>::_M_manager;
v20 = 0LL;
v19 = v24;
v22 = std::_Function_handler<void ()(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_3>::_M_invoke;
v21 = std::_Function_handler<void ()(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &),build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)::$_3>::_M_manager;
if ( !*(_QWORD *)(a2 + 16) )
std::__throw_bad_function_call();
(*(void ( **)(long long, int **))(a2 + 24))(a2, &v11);
SchemaConverter::check_errors((SchemaConverter *)v24);
SchemaConverter::format_grammar[abi:cxx11](
a1,
(unsigned int)v24,
v6,
v7,
v8,
v9,
(_DWORD)v11,
v12,
(_DWORD)v13,
(_DWORD)v14,
(_DWORD)v15,
v16,
(_DWORD)v17,
(_DWORD)v18,
(_DWORD)v19,
v20,
(_DWORD)v21,
(_DWORD)v22,
v23,
v24[0],
v24[2],
(char)v25);
if ( v21 )
((void ( *)(int **, int **, long long))v21)(&v19, &v19, 3LL);
if ( v17 )
((void ( *)(int **, int **, long long))v17)(&v15, &v15, 3LL);
if ( v13 )
((void ( *)(int **, int **, long long))v13)(&v11, &v11, 3LL);
std::vector<std::string>::~vector((long long)v30);
std::vector<std::string>::~vector((long long)v29);
std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::~_Hashtable((long long)v28);
std::_Hashtable<std::string,std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::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>>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::~_Hashtable(v27);
std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::~_Rb_tree(v26);
if ( v25 )
v25(v24, v24, 3LL);
return a1;
}
| |||
45,681 | foreach_function(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, std::function<void (nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&)> const&) | llama.cpp/common/chat.cpp | static void foreach_function(const json & tools, const std::function<void(const json &)> & fn) {
for (const auto & tool : tools) {
if (!tool.contains("type") || tool.at("type") != "function" || !tool.contains("function")) {
LOG_INF("Skipping tool without function: %s", tool.dump(2).c_str());
continue;
}
fn(tool);
}
} | O3 | cpp | foreach_function(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, std::function<void (nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&)> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, (%rsp)
movq %rdi, %r14
leaq 0x48(%rsp), %r15
movq %rdi, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
movabsq $-0x8000000000000000, %rbx # imm = 0x8000000000000000
movq %rbx, 0x18(%r15)
movq %r15, %rdi
callq 0xd0ac0
leaq 0x28(%rsp), %r12
movq %r14, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r12)
movq %rbx, 0x18(%r12)
movq %r12, %rdi
callq 0xd0b32
movq %r15, %rdi
movq %r12, %rsi
callq 0xced3e
testb %al, %al
jne 0x9d559
leaq 0x48(%rsp), %r14
leaq 0x7e015(%rip), %r15 # 0x11b482
leaq 0xc648c(%rip), %r12 # 0x163900
leaq 0x28(%rsp), %r13
movq %r14, %rdi
callq 0xafc1e
movq %rax, %rbp
movq %rax, %rdi
movq %r15, %rsi
callq 0xafe5a
testb %al, %al
je 0x9d4db
movq %rbp, %rdi
movq %r15, %rsi
callq 0xafebc
movq %rax, %rdi
leaq 0x7df21(%rip), %rsi # 0x11b3c9
callq 0xb0307
testb %al, %al
jne 0x9d4db
movq %rbp, %rdi
leaq 0x7df0e(%rip), %rsi # 0x11b3c9
callq 0xb063e
testb %al, %al
je 0x9d4db
movq (%rsp), %rdi
cmpq $0x0, 0x10(%rdi)
je 0x9d568
movq %rbp, %rsi
callq *0x18(%rdi)
jmp 0x9d53e
cmpl $0x0, (%r12)
js 0x9d53e
callq 0x10d357
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %rbp, %rsi
movl $0x2, %edx
movl $0x20, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xafaa2
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
movl $0x2, %esi
leaq 0x81f52(%rip), %rdx # 0x11f46d
xorl %eax, %eax
callq 0x10d3f4
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x9d53e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20180
movq %r14, %rdi
callq 0xb03b8
movq %r14, %rdi
movq %r13, %rsi
callq 0xced3e
testb %al, %al
je 0x9d479
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x212b0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x9d58c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20180
movq %rbx, %rdi
callq 0x20af0
| _ZL16foreach_functionRKN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEERKSt8functionIFvSF_EE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov [rsp+98h+var_98], rsi
mov r14, rdi
lea r15, [rsp+98h+var_50]
mov [r15], rdi
xorps xmm0, xmm0
movups xmmword ptr [r15+8], xmm0
mov rbx, 8000000000000000h
mov [r15+18h], rbx
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE9set_beginEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::set_begin(void)
lea r12, [rsp+98h+var_70]
mov [r12], r14
xorps xmm0, xmm0
movups xmmword ptr [r12+8], xmm0
mov [r12+18h], rbx
mov rdi, r12
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE7set_endEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::set_end(void)
mov rdi, r15
mov rsi, r12
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
test al, al
jnz loc_9D559
lea r14, [rsp+98h+var_50]
lea r15, aUnknownBufferT+0Fh; "type"
lea r12, common_log_verbosity_thold
lea r13, [rsp+98h+var_70]
loc_9D479:
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEdeEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator*(void)
mov rbp, rax
mov rdi, rax
mov rsi, r15
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA5_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
test al, al
jz short loc_9D4DB
mov rdi, rbp
mov rsi, r15
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA5_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
mov rdi, rax
lea rsi, aFailedToFindRp_0+1Eh; "function"
call _ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_
test al, al
jnz short loc_9D4DB
mov rdi, rbp
lea rsi, aFailedToFindRp_0+1Eh; "function"
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
test al, al
jz short loc_9D4DB
mov rdi, [rsp+98h+var_98]
cmp qword ptr [rdi+10h], 0
jz loc_9D568
mov rsi, rbp
call qword ptr [rdi+18h]
jmp short loc_9D53E
loc_9D4DB:
cmp dword ptr [r12], 0
js short loc_9D53E
call _Z15common_log_mainv; common_log_main(void)
mov rbx, rax
lea rdi, [rsp+98h+var_90]
mov rsi, rbp
mov edx, 2
mov ecx, 20h ; ' '
xor r8d, r8d
xor r9d, r9d
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dumpEicbNS0_6detail15error_handler_tE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::dump(int,char,bool,nlohmann::json_abi_v3_11_3::detail::error_handler_t)
mov rcx, [rsp+98h+var_90]
mov rdi, rbx
mov esi, 2
lea rdx, aSkippingToolWi; "Skipping tool without function: %s"
xor eax, eax
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
mov rdi, [rsp+98h+var_90]; void *
lea rax, [rsp+98h+var_80]
cmp rdi, rax
jz short loc_9D53E
mov rsi, [rsp+98h+var_80]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9D53E:
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator++(void)
mov rdi, r14
mov rsi, r13
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
test al, al
jz loc_9D479
loc_9D559:
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_9D568:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
mov rbx, rax
mov rdi, [rsp+98h+var_90]; void *
lea rax, [rsp+98h+var_80]
cmp rdi, rax
jz short loc_9D58C
mov rsi, [rsp+98h+var_80]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9D58C:
mov rdi, rbx
call __Unwind_Resume
| long long foreach_function(long long a1, long long a2)
{
long long result; // rax
long long v3; // rbp
long long v4; // rax
int v5; // ebx
int v6; // r8d
int v7; // r9d
void *v8; // [rsp+8h] [rbp-90h] BYREF
long long v9; // [rsp+18h] [rbp-80h] BYREF
long long v10; // [rsp+28h] [rbp-70h] BYREF
__int128 v11; // [rsp+30h] [rbp-68h]
unsigned long long v12; // [rsp+40h] [rbp-58h]
long long v13; // [rsp+48h] [rbp-50h] BYREF
__int128 v14; // [rsp+50h] [rbp-48h]
unsigned long long v15; // [rsp+60h] [rbp-38h]
v13 = a1;
v14 = 0LL;
v15 = 0x8000000000000000LL;
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::set_begin(&v13);
v10 = a1;
v11 = 0LL;
v12 = 0x8000000000000000LL;
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::set_end(&v10);
for ( result = ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_(
&v13,
&v10);
!(_BYTE)result;
result = ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_(
&v13,
&v10) )
{
v3 = nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator*(&v13);
if ( (unsigned __int8)ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA5_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_(
v3,
"type")
&& (v4 = ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA5_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_(
v3,
"type"),
!(unsigned __int8)ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_(
v4,
"function"))
&& (unsigned __int8)ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_(
v3,
"function") )
{
if ( !*(_QWORD *)(a2 + 16) )
std::__throw_bad_function_call();
(*(void ( **)(long long, long long))(a2 + 24))(a2, v3);
}
else if ( common_log_verbosity_thold >= 0 )
{
v5 = common_log_main();
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::dump(
(unsigned int)&v8,
v3,
2,
32,
0,
0);
common_log_add(v5, 2, (unsigned int)"Skipping tool without function: %s", (_DWORD)v8, v6, v7);
if ( v8 != &v9 )
operator delete(v8, v9 + 1);
}
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator++(&v13);
}
return result;
}
| foreach_function:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RSP],RSI
MOV R14,RDI
LEA R15,[RSP + 0x48]
MOV qword ptr [R15],RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R15 + 0x8],XMM0
MOV RBX,-0x8000000000000000
MOV qword ptr [R15 + 0x18],RBX
MOV RDI,R15
CALL 0x001d0ac0
LEA R12,[RSP + 0x28]
MOV qword ptr [R12],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R12 + 0x8],XMM0
MOV qword ptr [R12 + 0x18],RBX
MOV RDI,R12
CALL 0x001d0b32
MOV RDI,R15
MOV RSI,R12
CALL 0x001ced3e
TEST AL,AL
JNZ 0x0019d559
LEA R14,[RSP + 0x48]
LEA R15,[0x21b482]
LEA R12,[0x263900]
LEA R13,[RSP + 0x28]
LAB_0019d479:
MOV RDI,R14
CALL 0x001afc1e
MOV RBP,RAX
MOV RDI,RAX
MOV RSI,R15
CALL 0x001afe5a
TEST AL,AL
JZ 0x0019d4db
MOV RDI,RBP
MOV RSI,R15
CALL 0x001afebc
MOV RDI,RAX
LEA RSI,[0x21b3c9]
CALL 0x001b0307
TEST AL,AL
JNZ 0x0019d4db
MOV RDI,RBP
LEA RSI,[0x21b3c9]
CALL 0x001b063e
TEST AL,AL
JZ 0x0019d4db
MOV RDI,qword ptr [RSP]
CMP qword ptr [RDI + 0x10],0x0
JZ 0x0019d568
MOV RSI,RBP
CALL qword ptr [RDI + 0x18]
JMP 0x0019d53e
LAB_0019d4db:
CMP dword ptr [R12],0x0
JS 0x0019d53e
CALL 0x0020d357
MOV RBX,RAX
LEA RDI,[RSP + 0x8]
MOV RSI,RBP
MOV EDX,0x2
MOV ECX,0x20
XOR R8D,R8D
XOR R9D,R9D
CALL 0x001afaa2
MOV RCX,qword ptr [RSP + 0x8]
LAB_0019d50c:
MOV RDI,RBX
MOV ESI,0x2
LEA RDX,[0x21f46d]
XOR EAX,EAX
CALL 0x0020d3f4
LAB_0019d522:
MOV RDI,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x0019d53e
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00120180
LAB_0019d53e:
MOV RDI,R14
CALL 0x001b03b8
MOV RDI,R14
MOV RSI,R13
CALL 0x001ced3e
TEST AL,AL
JZ 0x0019d479
LAB_0019d559:
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0019d568:
CALL 0x001212b0
|
/* foreach_function(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&, std::function<void
(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&)> const&) */
void foreach_function(basic_json *param_1,function *param_2)
{
char cVar1;
int8 uVar2;
int8 uVar3;
long *local_90 [2];
long local_80 [2];
basic_json *local_70;
int8 local_68;
int8 uStack_60;
int8 local_58;
basic_json *local_50;
int8 local_48;
int8 uStack_40;
int8 local_38;
local_48 = 0;
uStack_40 = 0;
local_38 = 0x8000000000000000;
local_50 = param_1;
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::set_begin((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_50);
local_68 = 0;
uStack_60 = 0;
local_58 = 0x8000000000000000;
local_70 = param_1;
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::set_end((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_70);
cVar1 = _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_50,
(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_70);
if (cVar1 == '\0') {
do {
uVar2 = nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator*((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_50);
cVar1 = _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA5_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
(uVar2,"type");
if (cVar1 == '\0') {
LAB_0019d4db:
if (-1 < common_log_verbosity_thold) {
uVar3 = common_log_main();
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::dump(local_90,uVar2,2,0x20,0,0);
/* try { // try from 0019d50c to 0019d521 has its CatchHandler @ 0019d56d */
common_log_add(uVar3,2,"Skipping tool without function: %s",local_90[0]);
if (local_90[0] != local_80) {
operator_delete(local_90[0],local_80[0] + 1);
}
}
}
else {
uVar3 = _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA5_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
(uVar2,"type");
cVar1 = _ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_
(uVar3,"function");
if (cVar1 != '\0') goto LAB_0019d4db;
cVar1 = _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
(uVar2,"function");
if (cVar1 == '\0') goto LAB_0019d4db;
if (*(long *)(param_2 + 0x10) == 0) {
/* WARNING: Subroutine does not return */
std::__throw_bad_function_call();
}
(**(code **)(param_2 + 0x18))(param_2,uVar2);
}
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator++((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_50);
cVar1 = _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_50,&local_70);
} while (cVar1 == '\0');
}
return;
}
| |
45,682 | mi_get_status | eloqsql/storage/myisam/mi_locking.c | my_bool mi_get_status(void* param, my_bool concurrent_insert)
{
MI_INFO *info=(MI_INFO*) param;
DBUG_ENTER("mi_get_status");
DBUG_PRINT("info",("name: %s key_file: %lu data_file: %lu rows: %lu concurrent_insert: %d",
info->s->index_file_name,
(ulong) info->s->state.state.key_file_length,
(ulong) info->s->state.state.data_file_length,
(ulong) info->s->state.state.records,
concurrent_insert));
#ifndef DBUG_OFF
if (info->state->key_file_length > info->s->state.state.key_file_length ||
info->state->data_file_length > info->s->state.state.data_file_length)
DBUG_PRINT("warning",("old info: key_file: %ld data_file: %ld",
(long) info->state->key_file_length,
(long) info->state->data_file_length));
#endif
info->save_state=info->s->state.state;
info->state= &info->save_state;
info->append_insert_at_end= concurrent_insert;
if (concurrent_insert)
info->s->state.state.uncacheable= TRUE;
DBUG_RETURN(0);
} | O3 | c | mi_get_status:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rdi), %rcx
movq (%rdi), %rax
movups 0x18(%rax), %xmm0
movups 0x28(%rax), %xmm1
movups 0x38(%rax), %xmm2
movups %xmm0, 0x10(%rdi)
movups %xmm1, 0x20(%rdi)
movups %xmm2, 0x30(%rdi)
movq 0x48(%rax), %rdx
movq %rdx, 0x40(%rdi)
movq %rcx, 0x8(%rdi)
movb %sil, 0x33a(%rdi)
testb %sil, %sil
je 0x7d636
movb $0x1, 0x4c(%rax)
xorl %eax, %eax
popq %rbp
retq
| mi_get_status:
push rbp
mov rbp, rsp
lea rcx, [rdi+10h]
mov rax, [rdi]
movups xmm0, xmmword ptr [rax+18h]
movups xmm1, xmmword ptr [rax+28h]
movups xmm2, xmmword ptr [rax+38h]
movups xmmword ptr [rdi+10h], xmm0
movups xmmword ptr [rdi+20h], xmm1
movups xmmword ptr [rdi+30h], xmm2
mov rdx, [rax+48h]
mov [rdi+40h], rdx
mov [rdi+8], rcx
mov [rdi+33Ah], sil
test sil, sil
jz short loc_7D636
mov byte ptr [rax+4Ch], 1
loc_7D636:
xor eax, eax
pop rbp
retn
| long long mi_get_status(_OWORD *a1, char a2)
{
long long v2; // rax
__int128 v3; // xmm1
__int128 v4; // xmm2
v2 = *(_QWORD *)a1;
v3 = *(_OWORD *)(*(_QWORD *)a1 + 40LL);
v4 = *(_OWORD *)(*(_QWORD *)a1 + 56LL);
a1[1] = *(_OWORD *)(*(_QWORD *)a1 + 24LL);
a1[2] = v3;
a1[3] = v4;
*((_QWORD *)a1 + 8) = *(_QWORD *)(v2 + 72);
*((_QWORD *)a1 + 1) = a1 + 1;
*((_BYTE *)a1 + 826) = a2;
if ( a2 )
*(_BYTE *)(v2 + 76) = 1;
return 0LL;
}
| mi_get_status:
PUSH RBP
MOV RBP,RSP
LEA RCX,[RDI + 0x10]
MOV RAX,qword ptr [RDI]
MOVUPS XMM0,xmmword ptr [RAX + 0x18]
MOVUPS XMM1,xmmword ptr [RAX + 0x28]
MOVUPS XMM2,xmmword ptr [RAX + 0x38]
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM1
MOVUPS xmmword ptr [RDI + 0x30],XMM2
MOV RDX,qword ptr [RAX + 0x48]
MOV qword ptr [RDI + 0x40],RDX
MOV qword ptr [RDI + 0x8],RCX
MOV byte ptr [RDI + 0x33a],SIL
TEST SIL,SIL
JZ 0x0017d636
MOV byte ptr [RAX + 0x4c],0x1
LAB_0017d636:
XOR EAX,EAX
POP RBP
RET
|
int8 mi_get_status(long *param_1,char param_2)
{
long lVar1;
long lVar2;
long lVar3;
long lVar4;
long lVar5;
long lVar6;
lVar1 = *param_1;
lVar2 = *(long *)(lVar1 + 0x20);
lVar3 = *(long *)(lVar1 + 0x28);
lVar4 = *(long *)(lVar1 + 0x30);
lVar5 = *(long *)(lVar1 + 0x38);
lVar6 = *(long *)(lVar1 + 0x40);
param_1[2] = *(long *)(lVar1 + 0x18);
param_1[3] = lVar2;
param_1[4] = lVar3;
param_1[5] = lVar4;
param_1[6] = lVar5;
param_1[7] = lVar6;
param_1[8] = *(long *)(lVar1 + 0x48);
param_1[1] = (long)(param_1 + 2);
*(char *)((long)param_1 + 0x33a) = param_2;
if (param_2 != '\0') {
*(int1 *)(lVar1 + 0x4c) = 1;
}
return 0;
}
| |
45,683 | pvio_socket_change_timeout | eloqsql/libmariadb/plugins/pvio/pvio_socket.c | my_bool pvio_socket_change_timeout(MARIADB_PVIO *pvio, enum enum_pvio_timeout type, int timeout)
{
struct timeval tm;
int rc= 0;
struct st_pvio_socket *csock= NULL;
if (!pvio)
return 1;
if (!(csock= (struct st_pvio_socket *)pvio->data))
return 1;
tm.tv_sec= timeout / 1000;
tm.tv_usec= (timeout % 1000) * 1000;
switch(type)
{
case PVIO_WRITE_TIMEOUT:
#ifndef _WIN32
rc= setsockopt(csock->socket, SOL_SOCKET, SO_SNDTIMEO, (const char *)&tm, sizeof(tm));
#else
rc= setsockopt(csock->socket, SOL_SOCKET, SO_SNDTIMEO, (const char *)&timeout, sizeof(int));
#endif
break;
case PVIO_READ_TIMEOUT:
#ifndef _WIN32
rc= setsockopt(csock->socket, SOL_SOCKET, SO_RCVTIMEO, (const char *)&tm, sizeof(tm));
#else
rc= setsockopt(csock->socket, SOL_SOCKET, SO_RCVTIMEO, (const char *)&timeout, sizeof(int));
#endif
break;
default:
break;
}
return rc;
} | O0 | c | pvio_socket_change_timeout:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x2c(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x66421
movb $0x1, -0x1(%rbp)
jmp 0x664ee
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x6643b
movb $0x1, -0x1(%rbp)
jmp 0x664ee
movslq -0x18(%rbp), %rax
imulq $0x10624dd3, %rax, %rax # imm = 0x10624DD3
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x26, %rax
addl %ecx, %eax
cltq
movq %rax, -0x28(%rbp)
movslq -0x18(%rbp), %rcx
movl %ecx, %eax
imulq $0x10624dd3, %rcx, %rcx # imm = 0x10624DD3
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x26, %rcx
addl %edx, %ecx
imull $0x3e8, %ecx, %ecx # imm = 0x3E8
subl %ecx, %eax
imull $0x3e8, %eax, %eax # imm = 0x3E8
cltq
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
subl $0x1, %eax
je 0x664c2
jmp 0x66494
movl -0x3c(%rbp), %eax
subl $0x2, %eax
jne 0x664e6
jmp 0x6649e
movq -0x38(%rbp), %rax
movl (%rax), %edi
movl $0x1, %esi
movl $0x15, %edx
leaq -0x28(%rbp), %rcx
movl $0x10, %r8d
callq 0x36130
movl %eax, -0x2c(%rbp)
jmp 0x664e8
movq -0x38(%rbp), %rax
movl (%rax), %edi
movl $0x1, %esi
movl $0x14, %edx
leaq -0x28(%rbp), %rcx
movl $0x10, %r8d
callq 0x36130
movl %eax, -0x2c(%rbp)
jmp 0x664e8
jmp 0x664e8
movl -0x2c(%rbp), %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| pvio_socket_change_timeout:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_2C], 0
mov [rbp+var_38], 0
cmp [rbp+var_10], 0
jnz short loc_66421
mov [rbp+var_1], 1
jmp loc_664EE
loc_66421:
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_38], rax
cmp rax, 0
jnz short loc_6643B
mov [rbp+var_1], 1
jmp loc_664EE
loc_6643B:
movsxd rax, [rbp+var_18]
imul rax, 10624DD3h
mov rcx, rax
shr rcx, 3Fh
sar rax, 26h
add eax, ecx
cdqe
mov [rbp+var_28], rax
movsxd rcx, [rbp+var_18]
mov eax, ecx
imul rcx, 10624DD3h
mov rdx, rcx
shr rdx, 3Fh
sar rcx, 26h
add ecx, edx
imul ecx, 3E8h
sub eax, ecx
imul eax, 3E8h
cdqe
mov [rbp+var_20], rax
mov eax, [rbp+var_14]
mov [rbp+var_3C], eax
sub eax, 1
jz short loc_664C2
jmp short $+2
loc_66494:
mov eax, [rbp+var_3C]
sub eax, 2
jnz short loc_664E6
jmp short $+2
loc_6649E:
mov rax, [rbp+var_38]
mov edi, [rax]
mov esi, 1
mov edx, 15h
lea rcx, [rbp+var_28]
mov r8d, 10h
call _setsockopt
mov [rbp+var_2C], eax
jmp short loc_664E8
loc_664C2:
mov rax, [rbp+var_38]
mov edi, [rax]
mov esi, 1
mov edx, 14h
lea rcx, [rbp+var_28]
mov r8d, 10h
call _setsockopt
mov [rbp+var_2C], eax
jmp short loc_664E8
loc_664E6:
jmp short $+2
loc_664E8:
mov eax, [rbp+var_2C]
mov [rbp+var_1], al
loc_664EE:
mov al, [rbp+var_1]
add rsp, 40h
pop rbp
retn
| char pvio_socket_change_timeout(unsigned int **a1, int a2, int a3)
{
unsigned int *v4; // [rsp+8h] [rbp-38h]
char v5; // [rsp+14h] [rbp-2Ch]
_QWORD v6[2]; // [rsp+18h] [rbp-28h] BYREF
int v7; // [rsp+28h] [rbp-18h]
int v8; // [rsp+2Ch] [rbp-14h]
unsigned int **v9; // [rsp+30h] [rbp-10h]
v9 = a1;
v8 = a2;
v7 = a3;
v5 = 0;
if ( !a1 )
return 1;
v4 = *v9;
if ( !*v9 )
return 1;
v6[0] = v7 / 1000;
v6[1] = 1000 * (v7 % 1000);
if ( v8 == 1 )
return setsockopt(*v4, 1LL, 20LL, v6, 16LL);
if ( v8 == 2 )
return setsockopt(*v4, 1LL, 21LL, v6, 16LL);
return v5;
}
| pvio_socket_change_timeout:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV dword ptr [RBP + -0x2c],0x0
MOV qword ptr [RBP + -0x38],0x0
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x00166421
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001664ee
LAB_00166421:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JNZ 0x0016643b
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001664ee
LAB_0016643b:
MOVSXD RAX,dword ptr [RBP + -0x18]
IMUL RAX,RAX,0x10624dd3
MOV RCX,RAX
SHR RCX,0x3f
SAR RAX,0x26
ADD EAX,ECX
CDQE
MOV qword ptr [RBP + -0x28],RAX
MOVSXD RCX,dword ptr [RBP + -0x18]
MOV EAX,ECX
IMUL RCX,RCX,0x10624dd3
MOV RDX,RCX
SHR RDX,0x3f
SAR RCX,0x26
ADD ECX,EDX
IMUL ECX,ECX,0x3e8
SUB EAX,ECX
IMUL EAX,EAX,0x3e8
CDQE
MOV qword ptr [RBP + -0x20],RAX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x3c],EAX
SUB EAX,0x1
JZ 0x001664c2
JMP 0x00166494
LAB_00166494:
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,0x2
JNZ 0x001664e6
JMP 0x0016649e
LAB_0016649e:
MOV RAX,qword ptr [RBP + -0x38]
MOV EDI,dword ptr [RAX]
MOV ESI,0x1
MOV EDX,0x15
LEA RCX,[RBP + -0x28]
MOV R8D,0x10
CALL 0x00136130
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x001664e8
LAB_001664c2:
MOV RAX,qword ptr [RBP + -0x38]
MOV EDI,dword ptr [RAX]
MOV ESI,0x1
MOV EDX,0x14
LEA RCX,[RBP + -0x28]
MOV R8D,0x10
CALL 0x00136130
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x001664e8
LAB_001664e6:
JMP 0x001664e8
LAB_001664e8:
MOV EAX,dword ptr [RBP + -0x2c]
MOV byte ptr [RBP + -0x1],AL
LAB_001664ee:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x40
POP RBP
RET
|
int1 pvio_socket_change_timeout(int8 *param_1,int param_2,int param_3)
{
int *piVar1;
int iVar2;
int1 local_34;
long local_30;
long local_28;
int local_20;
int local_1c;
int8 *local_18;
int1 local_9;
local_34 = 0;
if (param_1 == (int8 *)0x0) {
local_9 = 1;
}
else {
piVar1 = (int *)*param_1;
if (piVar1 == (int *)0x0) {
local_9 = 1;
}
else {
local_30 = (long)(param_3 / 1000);
local_28 = (long)((param_3 % 1000) * 1000);
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
if (param_2 == 1) {
iVar2 = setsockopt(*piVar1,1,0x14,&local_30,0x10);
local_34 = (int1)iVar2;
}
else if (param_2 == 2) {
iVar2 = setsockopt(*piVar1,1,0x15,&local_30,0x10);
local_34 = (int1)iVar2;
}
local_9 = local_34;
}
}
return local_9;
}
| |
45,684 | tree_search_edge | eloqsql/mysys/tree.c | void *tree_search_edge(TREE *tree, TREE_ELEMENT **parents,
TREE_ELEMENT ***last_pos, int child_offs)
{
TREE_ELEMENT *element= tree->root;
*parents= &null_element;
while (element != &null_element)
{
*++parents= element;
element= ELEMENT_CHILD(element, child_offs);
}
*last_pos= parents;
return **last_pos != &null_element ?
ELEMENT_KEY(tree, **last_pos) : NULL;
} | O3 | c | tree_search_edge:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
leaq 0x2c8e0a(%rip), %r8 # 0x2f6458
movq %r8, (%rsi)
cmpq %r8, %rax
je 0x2d66a
movslq %ecx, %rcx
movq %rax, 0x8(%rsi)
addq $0x8, %rsi
movq (%rax,%rcx), %rax
cmpq %r8, %rax
jne 0x2d659
movq %rsi, (%rdx)
movq (%rsi), %rax
cmpq %r8, %rax
je 0x2d685
movl 0x208(%rdi), %ecx
testq %rcx, %rcx
je 0x2d689
addq %rcx, %rax
jmp 0x2d68d
xorl %eax, %eax
jmp 0x2d68d
movq 0x18(%rax), %rax
popq %rbp
retq
| tree_search_edge:
push rbp
mov rbp, rsp
mov rax, [rdi]
lea r8, null_element
mov [rsi], r8
cmp rax, r8
jz short loc_2D66A
movsxd rcx, ecx
loc_2D659:
mov [rsi+8], rax
add rsi, 8
mov rax, [rax+rcx]
cmp rax, r8
jnz short loc_2D659
loc_2D66A:
mov [rdx], rsi
mov rax, [rsi]
cmp rax, r8
jz short loc_2D685
mov ecx, [rdi+208h]
test rcx, rcx
jz short loc_2D689
add rax, rcx
jmp short loc_2D68D
loc_2D685:
xor eax, eax
jmp short loc_2D68D
loc_2D689:
mov rax, [rax+18h]
loc_2D68D:
pop rbp
retn
| char * tree_search_edge(char **a1, _QWORD *a2, _QWORD *a3, int a4)
{
char *v4; // rax
_QWORD *v5; // rax
v4 = *a1;
for ( *a2 = &null_element; v4 != (char *)&null_element; v4 = *(char **)&v4[a4] )
{
a2[1] = v4;
++a2;
}
*a3 = a2;
v5 = (_QWORD *)*a2;
if ( (_UNKNOWN *)*a2 == &null_element )
return 0LL;
if ( *((_DWORD *)a1 + 130) )
return (char *)v5 + *((unsigned int *)a1 + 130);
return (char *)v5[3];
}
| tree_search_edge:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI]
LEA R8,[0x3f6458]
MOV qword ptr [RSI],R8
CMP RAX,R8
JZ 0x0012d66a
MOVSXD RCX,ECX
LAB_0012d659:
MOV qword ptr [RSI + 0x8],RAX
ADD RSI,0x8
MOV RAX,qword ptr [RAX + RCX*0x1]
CMP RAX,R8
JNZ 0x0012d659
LAB_0012d66a:
MOV qword ptr [RDX],RSI
MOV RAX,qword ptr [RSI]
CMP RAX,R8
JZ 0x0012d685
MOV ECX,dword ptr [RDI + 0x208]
TEST RCX,RCX
JZ 0x0012d689
ADD RAX,RCX
JMP 0x0012d68d
LAB_0012d685:
XOR EAX,EAX
JMP 0x0012d68d
LAB_0012d689:
MOV RAX,qword ptr [RAX + 0x18]
LAB_0012d68d:
POP RBP
RET
|
int1 * tree_search_edge(long *param_1,long *param_2,int8 *param_3,int param_4)
{
int1 *puVar1;
puVar1 = (int1 *)*param_1;
*param_2 = (long)null_element;
if (puVar1 != null_element) {
do {
param_2[1] = (long)puVar1;
param_2 = param_2 + 1;
puVar1 = *(int1 **)(puVar1 + param_4);
} while (puVar1 != null_element);
}
*param_3 = param_2;
puVar1 = (int1 *)*param_2;
if (puVar1 == null_element) {
puVar1 = (int1 *)0x0;
}
else if ((ulong)*(uint *)(param_1 + 0x41) == 0) {
puVar1 = *(int1 **)(puVar1 + 0x18);
}
else {
puVar1 = puVar1 + *(uint *)(param_1 + 0x41);
}
return puVar1;
}
| |
45,685 | Bfree | eloqsql/strings/dtoa.c | static void Bfree(Bigint *v, Stack_alloc *alloc)
{
char *gptr= (char*) v; /* generic pointer */
if (gptr < alloc->begin || gptr >= alloc->end)
free(gptr);
else if (v->k <= Kmax)
{
/*
Maintain free lists only for stack objects: this way we don't
have to bother with freeing lists in the end of dtoa;
heap should not be used normally anyway.
*/
v->p.next= alloc->freelist[v->k];
alloc->freelist[v->k]= v;
}
} | O3 | c | Bfree:
pushq %rbp
movq %rsp, %rbp
cmpq %rdi, (%rsi)
ja 0xf4f05
cmpq %rdi, 0x10(%rsi)
jbe 0xf4f05
movslq 0x8(%rdi), %rax
cmpq $0xf, %rax
jg 0xf4f03
movq 0x18(%rsi,%rax,8), %rcx
movq %rcx, (%rdi)
movq %rdi, 0x18(%rsi,%rax,8)
popq %rbp
retq
popq %rbp
jmp 0x2a190
| Bfree:
push rbp
mov rbp, rsp
cmp [rsi], rdi
ja short loc_F4F05
cmp [rsi+10h], rdi
jbe short loc_F4F05
movsxd rax, dword ptr [rdi+8]
cmp rax, 0Fh
jg short loc_F4F03
mov rcx, [rsi+rax*8+18h]
mov [rdi], rcx
mov [rsi+rax*8+18h], rdi
loc_F4F03:
pop rbp
retn
loc_F4F05:
pop rbp
jmp _free
| long long Bfree(unsigned long long a1, unsigned long long *a2)
{
long long result; // rax
if ( *a2 > a1 || a2[2] <= a1 )
return free(a1);
result = *(int *)(a1 + 8);
if ( result <= 15 )
{
*(_QWORD *)a1 = a2[result + 3];
a2[result + 3] = a1;
}
return result;
}
| Bfree:
PUSH RBP
MOV RBP,RSP
CMP qword ptr [RSI],RDI
JA 0x001f4f05
CMP qword ptr [RSI + 0x10],RDI
JBE 0x001f4f05
MOVSXD RAX,dword ptr [RDI + 0x8]
CMP RAX,0xf
JG 0x001f4f03
MOV RCX,qword ptr [RSI + RAX*0x8 + 0x18]
MOV qword ptr [RDI],RCX
MOV qword ptr [RSI + RAX*0x8 + 0x18],RDI
LAB_001f4f03:
POP RBP
RET
LAB_001f4f05:
POP RBP
JMP 0x0012a190
|
void Bfree(ulong *param_1,ulong *param_2)
{
long lVar1;
if (((ulong *)*param_2 <= param_1) && (param_1 < (ulong *)param_2[2])) {
lVar1 = (long)(int)param_1[1];
if (lVar1 < 0x10) {
*param_1 = param_2[lVar1 + 3];
param_2[lVar1 + 3] = (ulong)param_1;
}
return;
}
free(param_1);
return;
}
| |
45,686 | mysql_client_find_plugin | eloqsql/build_O3/libmariadb/libmariadb/ma_client_plugin.c | struct st_mysql_client_plugin * STDCALL
mysql_client_find_plugin(MYSQL *mysql, const char *name, int type)
{
struct st_mysql_client_plugin *p;
int plugin_nr= get_plugin_nr(type);
if (is_not_initialized(mysql, name))
return NULL;
if (plugin_nr == -1)
{
my_set_error(mysql, CR_AUTH_PLUGIN_CANNOT_LOAD, SQLSTATE_UNKNOWN,
ER(CR_AUTH_PLUGIN_CANNOT_LOAD), name, "invalid type");
}
if ((p= find_plugin(name, type)))
return p;
/* not found, load it */
return mysql_load_plugin(mysql, name, type, 0);
} | O3 | c | mysql_client_find_plugin:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
leaq 0x91b03(%rip), %rcx # 0x116bc0
cmpl %r15d, (%rax,%rcx)
je 0x85109
addq $0x8, %rax
cmpq $0x30, %rax
jne 0x850bd
cmpb $0x0, 0x3dadac(%rip) # 0x45fe80
je 0x8513f
leaq 0x35fe43(%rip), %rax # 0x3e4f20
movq (%rax), %rdx
leaq 0x35fe49(%rip), %rax # 0x3e4f30
movq 0x1d8(%rax), %rcx
leaq 0x8a64a(%rip), %r9 # 0x10f73f
movq %r14, %rdi
movl $0x80b, %esi # imm = 0x80B
movq %rbx, %r8
xorl %eax, %eax
callq 0x72dd1
jmp 0x85112
cmpb $0x0, 0x3dad70(%rip) # 0x45fe80
je 0x8513f
movq %rbx, %rdi
movl %r15d, %esi
callq 0x84d1b
movq %rax, %r12
testq %rax, %rax
jne 0x85173
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
xorl %ecx, %ecx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x85031
leaq 0x35fdda(%rip), %rax # 0x3e4f20
movq (%rax), %rdx
leaq 0x35fde0(%rip), %rax # 0x3e4f30
movq 0x1d8(%rax), %rcx
leaq 0x8a63f(%rip), %r9 # 0x10f79d
xorl %r12d, %r12d
movq %r14, %rdi
movl $0x80b, %esi # imm = 0x80B
movq %rbx, %r8
xorl %eax, %eax
callq 0x72dd1
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| mysql_client_find_plugin:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r15d, edx
mov rbx, rsi
mov r14, rdi
xor eax, eax
lea rcx, valid_plugins
loc_850BD:
cmp [rax+rcx], r15d
jz short loc_85109
add rax, 8
cmp rax, 30h ; '0'
jnz short loc_850BD
cmp cs:initialized, 0
jz short loc_8513F
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+1D8h]
lea r9, aInvalidType; "invalid type"
mov rdi, r14
mov esi, 80Bh
mov r8, rbx
xor eax, eax
call my_set_error
jmp short loc_85112
loc_85109:
cmp cs:initialized, 0
jz short loc_8513F
loc_85112:
mov rdi, rbx
mov esi, r15d
call find_plugin
mov r12, rax
test rax, rax
jnz short loc_85173
mov rdi, r14
mov rsi, rbx
mov edx, r15d
xor ecx, ecx
xor eax, eax
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp mysql_load_plugin
loc_8513F:
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+1D8h]
lea r9, aNotInitialized; "not initialized"
xor r12d, r12d
mov rdi, r14
mov esi, 80Bh
mov r8, rbx
xor eax, eax
call my_set_error
loc_85173:
mov rax, r12
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long mysql_client_find_plugin(
long long a1,
const char *a2,
int a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11,
long long a12,
long long a13,
long long a14,
char a15)
{
long long v16; // rax
long long v17; // r8
long long v18; // r9
long long plugin; // r12
__m128 v20; // xmm4
__m128 v21; // xmm5
v16 = 0LL;
while ( valid_plugins[v16] != a3 )
{
v16 += 2LL;
if ( v16 == 12 )
{
if ( initialized )
{
my_set_error(a1, 2059, (long long)SQLSTATE_UNKNOWN, client_errors[59], a2, "invalid type");
goto LABEL_7;
}
LABEL_9:
plugin = 0LL;
my_set_error(a1, 2059, (long long)SQLSTATE_UNKNOWN, client_errors[59], a2, "not initialized");
return plugin;
}
}
if ( !initialized )
goto LABEL_9;
LABEL_7:
plugin = find_plugin((long long)a2, a3);
if ( !plugin )
return mysql_load_plugin(a1, a2, a3, 0, v17, v18, a4, a5, a6, a7, v20, v21, a10, a11, a15);
return plugin;
}
| mysql_client_find_plugin:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R15D,EDX
MOV RBX,RSI
MOV R14,RDI
XOR EAX,EAX
LEA RCX,[0x216bc0]
LAB_001850bd:
CMP dword ptr [RAX + RCX*0x1],R15D
JZ 0x00185109
ADD RAX,0x8
CMP RAX,0x30
JNZ 0x001850bd
CMP byte ptr [0x0055fe80],0x0
JZ 0x0018513f
LEA RAX,[0x4e4f20]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x4e4f30]
MOV RCX,qword ptr [RAX + 0x1d8]
LEA R9,[0x20f73f]
MOV RDI,R14
MOV ESI,0x80b
MOV R8,RBX
XOR EAX,EAX
CALL 0x00172dd1
JMP 0x00185112
LAB_00185109:
CMP byte ptr [0x0055fe80],0x0
JZ 0x0018513f
LAB_00185112:
MOV RDI,RBX
MOV ESI,R15D
CALL 0x00184d1b
MOV R12,RAX
TEST RAX,RAX
JNZ 0x00185173
MOV RDI,R14
MOV RSI,RBX
MOV EDX,R15D
XOR ECX,ECX
XOR EAX,EAX
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x00185031
LAB_0018513f:
LEA RAX,[0x4e4f20]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x4e4f30]
MOV RCX,qword ptr [RAX + 0x1d8]
LEA R9,[0x20f79d]
XOR R12D,R12D
MOV RDI,R14
MOV ESI,0x80b
MOV R8,RBX
XOR EAX,EAX
CALL 0x00172dd1
LAB_00185173:
MOV RAX,R12
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
long mysql_client_find_plugin(int8 param_1,int8 param_2,int param_3)
{
long lVar1;
lVar1 = 0;
do {
if (*(int *)((long)&valid_plugins + lVar1) == param_3) {
if (initialized != '\0') goto LAB_00185112;
goto LAB_0018513f;
}
lVar1 = lVar1 + 8;
} while (lVar1 != 0x30);
if (initialized == '\0') {
LAB_0018513f:
lVar1 = 0;
my_set_error(param_1,0x80b,SQLSTATE_UNKNOWN,PTR_s_Plugin__s_could_not_be_loaded____004e5108,
param_2,"not initialized");
}
else {
my_set_error(param_1,0x80b,SQLSTATE_UNKNOWN,PTR_s_Plugin__s_could_not_be_loaded____004e5108,
param_2,"invalid type");
LAB_00185112:
lVar1 = find_plugin(param_2,param_3);
if (lVar1 == 0) {
lVar1 = mysql_load_plugin(param_1,param_2,param_3,0);
return lVar1;
}
}
return lVar1;
}
| |
45,687 | Bfree | eloqsql/libmariadb/libmariadb/ma_dtoa.c | static void Bfree(Bigint *v, Stack_alloc *alloc)
{
char *gptr= (char*) v; /* generic pointer */
if (gptr < alloc->begin || gptr >= alloc->end)
free(gptr);
else if (v->k <= Kmax)
{
/*
Maintain free lists only for stack objects: this way we don't
have to bother with freeing lists in the end of dtoa;
heap should not be used normally anyway.
*/
v->p.next= alloc->freelist[v->k];
alloc->freelist[v->k]= v;
}
} | O3 | c | Bfree:
pushq %rbp
movq %rsp, %rbp
cmpq %rdi, (%rsi)
ja 0x29caa
cmpq %rdi, 0x10(%rsi)
jbe 0x29caa
movslq 0x8(%rdi), %rax
cmpq $0xf, %rax
jg 0x29ca8
movq 0x18(%rsi,%rax,8), %rcx
movq %rcx, (%rdi)
movq %rdi, 0x18(%rsi,%rax,8)
popq %rbp
retq
popq %rbp
jmp 0x13570
| Bfree:
push rbp
mov rbp, rsp
cmp [rsi], rdi
ja short loc_29CAA
cmp [rsi+10h], rdi
jbe short loc_29CAA
movsxd rax, dword ptr [rdi+8]
cmp rax, 0Fh
jg short loc_29CA8
mov rcx, [rsi+rax*8+18h]
mov [rdi], rcx
mov [rsi+rax*8+18h], rdi
loc_29CA8:
pop rbp
retn
loc_29CAA:
pop rbp
jmp _free
| long long Bfree(unsigned long long a1, unsigned long long *a2)
{
long long result; // rax
if ( *a2 > a1 || a2[2] <= a1 )
return free(a1);
result = *(int *)(a1 + 8);
if ( result <= 15 )
{
*(_QWORD *)a1 = a2[result + 3];
a2[result + 3] = a1;
}
return result;
}
| Bfree:
PUSH RBP
MOV RBP,RSP
CMP qword ptr [RSI],RDI
JA 0x00129caa
CMP qword ptr [RSI + 0x10],RDI
JBE 0x00129caa
MOVSXD RAX,dword ptr [RDI + 0x8]
CMP RAX,0xf
JG 0x00129ca8
MOV RCX,qword ptr [RSI + RAX*0x8 + 0x18]
MOV qword ptr [RDI],RCX
MOV qword ptr [RSI + RAX*0x8 + 0x18],RDI
LAB_00129ca8:
POP RBP
RET
LAB_00129caa:
POP RBP
JMP 0x00113570
|
void Bfree(ulong *param_1,ulong *param_2)
{
long lVar1;
if (((ulong *)*param_2 <= param_1) && (param_1 < (ulong *)param_2[2])) {
lVar1 = (long)(int)param_1[1];
if (lVar1 < 0x10) {
*param_1 = param_2[lVar1 + 3];
param_2[lVar1 + 3] = (ulong)param_1;
}
return;
}
free(param_1);
return;
}
| |
45,688 | dequantize_row_q3_K | 7CodeWizard[P]stablediffusion/ggml/src/ggml-quants.c | void dequantize_row_q3_K(const block_q3_K * restrict x, float * restrict y, int k) {
assert(k % QK_K == 0);
const int nb = k / QK_K;
const uint32_t kmask1 = 0x03030303;
const uint32_t kmask2 = 0x0f0f0f0f;
uint32_t aux[4];
const int8_t * scales = (const int8_t*)aux;
for (int i = 0; i < nb; i++) {
const float d_all = GGML_FP16_TO_FP32(x[i].d);
const uint8_t * restrict q = x[i].qs;
const uint8_t * restrict hm = x[i].hmask;
uint8_t m = 1;
memcpy(aux, x[i].scales, 12);
uint32_t tmp = aux[2];
aux[2] = ((aux[0] >> 4) & kmask2) | (((tmp >> 4) & kmask1) << 4);
aux[3] = ((aux[1] >> 4) & kmask2) | (((tmp >> 6) & kmask1) << 4);
aux[0] = (aux[0] & kmask2) | (((tmp >> 0) & kmask1) << 4);
aux[1] = (aux[1] & kmask2) | (((tmp >> 2) & kmask1) << 4);
int is = 0;
float dl;
for (int n = 0; n < QK_K; n += 128) {
int shift = 0;
for (int j = 0; j < 4; ++j) {
dl = d_all * (scales[is++] - 32);
for (int l = 0; l < 16; ++l) {
*y++ = dl * ((int8_t)((q[l+ 0] >> shift) & 3) - ((hm[l+ 0] & m) ? 0 : 4));
}
dl = d_all * (scales[is++] - 32);
for (int l = 0; l < 16; ++l) {
*y++ = dl * ((int8_t)((q[l+16] >> shift) & 3) - ((hm[l+16] & m) ? 0 : 4));
}
shift += 2;
m <<= 1;
}
q += 32;
}
}
} | O2 | c | dequantize_row_q3_K:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %eax
movq %rdi, %r10
movl $0x100, %ecx # imm = 0x100
cltd
idivl %ecx
xorl %edi, %edi
testl %eax, %eax
cmovlel %edi, %eax
movq %rax, -0x8(%rsp)
vmovdqa 0x11367(%rip), %xmm0 # 0xa4ee0
vpshufd $0x4e, %xmm0, %xmm1 # xmm1 = xmm0[2,3,0,1]
vpmovsxbd 0x111e5(%rip), %xmm2 # 0xa4d6c
movabsq $0x10, %r9
movq %r10, %rax
cmpq -0x8(%rsp), %rdi
je 0x93d01
imulq $0x6e, %rdi, %rcx
leaq (%rax,%rcx), %r11
movzwl 0x6c(%rax,%rcx), %ebx
leaq 0xc96dd(%rip), %r8 # 0x15d290
vmovss (%r8,%rbx,4), %xmm3
movq 0x60(%rax,%rcx), %rbx
movq %rbx, -0x18(%rsp)
movl 0x68(%rax,%rcx), %ecx
movl %ecx, -0x10(%rsp)
vmovdqa -0x18(%rsp), %xmm4
vmovd %ecx, %xmm5
shrl $0x2, %ecx
vpbroadcastd %xmm5, %xmm5
vpinsrd $0x1, %ecx, %xmm5, %xmm6
vpunpcklqdq %xmm6, %xmm4, %xmm4 # xmm4 = xmm4[0],xmm6[0]
vpand %xmm1, %xmm4, %xmm4
vpbroadcastq -0x18(%rsp), %xmm6
vpsllvd %xmm2, %xmm5, %xmm5
vpsrlvd %xmm2, %xmm6, %xmm6
vpblendd $0xc, %xmm6, %xmm5, %xmm5 # xmm5 = xmm5[0,1],xmm6[2,3]
vpand %xmm0, %xmm5, %xmm5
vpor %xmm4, %xmm5, %xmm4
vmovdqa %xmm4, -0x18(%rsp)
xorl %ebx, %ebx
movb $0x1, %bpl
xorl %r14d, %r14d
cmpl $0xff, %r14d
ja 0x93cf5
leaq 0x20(%r11), %r15
movslq %ebx, %rbx
xorl %ecx, %ecx
xorl %r12d, %r12d
cmpl $0x4, %r12d
je 0x93ce9
movsbl -0x18(%rsp,%rbx), %r13d
addl $-0x20, %r13d
vcvtsi2ss %r13d, %xmm7, %xmm4
vmulss %xmm4, %xmm3, %xmm4
xorl %r13d, %r13d
cmpq $0x10, %r13
je 0x93c89
movzbl 0x20(%r11,%r13), %r8d
shrl %cl, %r8d
andl $0x3, %r8d
xorl %edx, %edx
testb %bpl, (%r10,%r13)
setne %dl
leal (%r8,%rdx,4), %edx
addl $-0x4, %edx
vcvtsi2ss %edx, %xmm7, %xmm5
vmulss %xmm5, %xmm4, %xmm5
vmovss %xmm5, (%rsi)
addq $0x4, %rsi
incq %r13
jmp 0x93c51
movsbl -0x17(%rsp,%rbx), %r13d
addl $-0x20, %r13d
vcvtsi2ss %r13d, %xmm7, %xmm4
vmulss %xmm4, %xmm3, %xmm4
movq %r9, %r13
cmpq $0x20, %r13
je 0x93cd7
movzbl 0x20(%r11,%r13), %edx
shrl %cl, %edx
andl $0x3, %edx
xorl %r8d, %r8d
testb %bpl, (%r10,%r13)
setne %r8b
leal (%rdx,%r8,4), %edx
addl $-0x4, %edx
vcvtsi2ss %edx, %xmm7, %xmm5
vmulss %xmm5, %xmm4, %xmm5
vmovss %xmm5, (%rsi)
addq $0x4, %rsi
incq %r13
jmp 0x93c9f
addq $0x2, %rbx
addl $0x2, %ecx
addb %bpl, %bpl
incl %r12d
jmp 0x93c31
subl $-0x80, %r14d
movq %r15, %r11
jmp 0x93c18
incq %rdi
addq $0x6e, %r10
jmp 0x93b94
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| dequantize_row_q3_K:
push rbp
push r15
push r14
push r13
push r12
push rbx
mov eax, edx
mov r10, rdi
mov ecx, 100h
cdq
idiv ecx
xor edi, edi
test eax, eax
cmovle eax, edi
mov [rsp+30h+var_38], rax
vmovdqa xmm0, cs:xmmword_A4EE0
vpshufd xmm1, xmm0, 4Eh ; 'N'
vpmovsxbd xmm2, cs:dword_A4D6C
mov r9, 10h
mov rax, r10
loc_93B94:
cmp rdi, [rsp+30h+var_38]
jz loc_93D01
imul rcx, rdi, 6Eh ; 'n'
lea r11, [rax+rcx]
movzx ebx, word ptr [rax+rcx+6Ch]
lea r8, ggml_table_f32_f16
vmovss xmm3, dword ptr [r8+rbx*4]
mov rbx, [rax+rcx+60h]
mov qword ptr [rsp+30h+var_48], rbx
mov ecx, [rax+rcx+68h]
mov dword ptr [rsp+30h+var_48+8], ecx
vmovdqa xmm4, [rsp+30h+var_48]
vmovd xmm5, ecx
shr ecx, 2
vpbroadcastd xmm5, xmm5
vpinsrd xmm6, xmm5, ecx, 1
vpunpcklqdq xmm4, xmm4, xmm6
vpand xmm4, xmm4, xmm1
vpbroadcastq xmm6, qword ptr [rsp+30h+var_48]
vpsllvd xmm5, xmm5, xmm2
vpsrlvd xmm6, xmm6, xmm2
vpblendd xmm5, xmm5, xmm6, 0Ch
vpand xmm5, xmm5, xmm0
vpor xmm4, xmm5, xmm4
vmovdqa [rsp+30h+var_48], xmm4
xor ebx, ebx
mov bpl, 1
xor r14d, r14d
loc_93C18:
cmp r14d, 0FFh
ja loc_93CF5
lea r15, [r11+20h]
movsxd rbx, ebx
xor ecx, ecx
xor r12d, r12d
loc_93C31:
cmp r12d, 4
jz loc_93CE9
movsx r13d, byte ptr [rsp+rbx+30h+var_48]
add r13d, 0FFFFFFE0h
vcvtsi2ss xmm4, xmm7, r13d
vmulss xmm4, xmm3, xmm4
xor r13d, r13d
loc_93C51:
cmp r13, 10h
jz short loc_93C89
movzx r8d, byte ptr [r11+r13+20h]
shr r8d, cl
and r8d, 3
xor edx, edx
test [r10+r13], bpl
setnz dl
lea edx, [r8+rdx*4]
add edx, 0FFFFFFFCh
vcvtsi2ss xmm5, xmm7, edx
vmulss xmm5, xmm4, xmm5
vmovss dword ptr [rsi], xmm5
add rsi, 4
inc r13
jmp short loc_93C51
loc_93C89:
movsx r13d, byte ptr [rsp+rbx+30h+var_48+1]
add r13d, 0FFFFFFE0h
vcvtsi2ss xmm4, xmm7, r13d
vmulss xmm4, xmm3, xmm4
mov r13, r9
loc_93C9F:
cmp r13, 20h ; ' '
jz short loc_93CD7
movzx edx, byte ptr [r11+r13+20h]
shr edx, cl
and edx, 3
xor r8d, r8d
test [r10+r13], bpl
setnz r8b
lea edx, [rdx+r8*4]
add edx, 0FFFFFFFCh
vcvtsi2ss xmm5, xmm7, edx
vmulss xmm5, xmm4, xmm5
vmovss dword ptr [rsi], xmm5
add rsi, 4
inc r13
jmp short loc_93C9F
loc_93CD7:
add rbx, 2
add ecx, 2
add bpl, bpl
inc r12d
jmp loc_93C31
loc_93CE9:
sub r14d, 0FFFFFF80h
mov r11, r15
jmp loc_93C18
loc_93CF5:
inc rdi
add r10, 6Eh ; 'n'
jmp loc_93B94
loc_93D01:
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long dequantize_row_q3_K(
long long a1,
long long _RSI,
int a3,
double a4,
double a5,
double a6,
double a7,
double a8,
double a9,
double a10,
__m128 _XMM7)
{
long long v12; // rax
long long v13; // rdi
long long result; // rax
long long v18; // r11
int v34; // ebx
char v35; // bp
unsigned int i; // r14d
int v37; // ecx
int j; // r12d
long long k; // r13
long long m; // r13
__int128 v49; // [rsp+0h] [rbp-48h] BYREF
long long v50; // [rsp+10h] [rbp-38h]
v12 = (unsigned int)(a3 / 256);
v13 = 0LL;
if ( (int)v12 <= 0 )
v12 = 0LL;
v50 = v12;
__asm
{
vmovdqa xmm0, cs:xmmword_A4EE0
vpshufd xmm1, xmm0, 4Eh ; 'N'
vpmovsxbd xmm2, cs:dword_A4D6C
}
result = a1;
while ( v13 != v50 )
{
v18 = result + 110 * v13;
_RBX = *(unsigned __int16 *)(v18 + 108);
_R8 = &ggml_table_f32_f16;
__asm { vmovss xmm3, dword ptr [r8+rbx*4] }
*(_QWORD *)&v49 = *(_QWORD *)(v18 + 96);
DWORD2(v49) = *(_DWORD *)(v18 + 104);
__asm
{
vmovdqa xmm4, [rsp+30h+var_48]
vmovd xmm5, ecx
vpbroadcastd xmm5, xmm5
vpinsrd xmm6, xmm5, ecx, 1
vpunpcklqdq xmm4, xmm4, xmm6
vpand xmm4, xmm4, xmm1
vpbroadcastq xmm6, qword ptr [rsp+30h+var_48]
vpsllvd xmm5, xmm5, xmm2
vpsrlvd xmm6, xmm6, xmm2
vpblendd xmm5, xmm5, xmm6, 0Ch
vpand xmm5, xmm5, xmm0
vpor xmm4, xmm5, xmm4
vmovdqa [rsp+30h+var_48], xmm4
}
v34 = 0;
v35 = 1;
for ( i = 0; i <= 0xFF; i += 128 )
{
v37 = 0;
for ( j = 0; j != 4; ++j )
{
__asm
{
vcvtsi2ss xmm4, xmm7, r13d
vmulss xmm4, xmm3, xmm4
}
for ( k = 0LL; k != 16; ++k )
{
__asm
{
vcvtsi2ss xmm5, xmm7, edx
vmulss xmm5, xmm4, xmm5
vmovss dword ptr [rsi], xmm5
}
_RSI += 4LL;
}
__asm
{
vcvtsi2ss xmm4, xmm7, r13d
vmulss xmm4, xmm3, xmm4
}
for ( m = 16LL; m != 32; ++m )
{
__asm
{
vcvtsi2ss xmm5, xmm7, edx
vmulss xmm5, xmm4, xmm5
vmovss dword ptr [rsi], xmm5
}
_RSI += 4LL;
}
v34 += 2;
v37 += 2;
v35 *= 2;
}
v18 += 32LL;
}
++v13;
a1 += 110LL;
}
return result;
}
| dequantize_row_q3_K:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV EAX,EDX
MOV R10,RDI
MOV ECX,0x100
CDQ
IDIV ECX
XOR EDI,EDI
TEST EAX,EAX
CMOVLE EAX,EDI
MOV qword ptr [RSP + -0x8],RAX
VMOVDQA XMM0,xmmword ptr [0x001a4ee0]
VPSHUFD XMM1,XMM0,0x4e
VPMOVSXBD XMM2,dword ptr [0x001a4d6c]
MOV R9,0x10
MOV RAX,R10
LAB_00193b94:
CMP RDI,qword ptr [RSP + -0x8]
JZ 0x00193d01
IMUL RCX,RDI,0x6e
LEA R11,[RAX + RCX*0x1]
MOVZX EBX,word ptr [RAX + RCX*0x1 + 0x6c]
LEA R8,[0x25d290]
VMOVSS XMM3,dword ptr [R8 + RBX*0x4]
MOV RBX,qword ptr [RAX + RCX*0x1 + 0x60]
MOV qword ptr [RSP + -0x18],RBX
MOV ECX,dword ptr [RAX + RCX*0x1 + 0x68]
MOV dword ptr [RSP + -0x10],ECX
VMOVDQA XMM4,xmmword ptr [RSP + -0x18]
VMOVD XMM5,ECX
SHR ECX,0x2
VPBROADCASTD XMM5,XMM5
VPINSRD XMM6,XMM5,ECX,0x1
VPUNPCKLQDQ XMM4,XMM4,XMM6
VPAND XMM4,XMM4,XMM1
VPBROADCASTQ XMM6,qword ptr [RSP + -0x18]
VPSLLVD XMM5,XMM5,XMM2
VPSRLVD XMM6,XMM6,XMM2
VPBLENDD XMM5,XMM5,XMM6,0xc
VPAND XMM5,XMM5,XMM0
VPOR XMM4,XMM5,XMM4
VMOVDQA xmmword ptr [RSP + -0x18],XMM4
XOR EBX,EBX
MOV BPL,0x1
XOR R14D,R14D
LAB_00193c18:
CMP R14D,0xff
JA 0x00193cf5
LEA R15,[R11 + 0x20]
MOVSXD RBX,EBX
XOR ECX,ECX
XOR R12D,R12D
LAB_00193c31:
CMP R12D,0x4
JZ 0x00193ce9
MOVSX R13D,byte ptr [RSP + RBX*0x1 + -0x18]
ADD R13D,-0x20
VCVTSI2SS XMM4,XMM7,R13D
VMULSS XMM4,XMM3,XMM4
XOR R13D,R13D
LAB_00193c51:
CMP R13,0x10
JZ 0x00193c89
MOVZX R8D,byte ptr [R11 + R13*0x1 + 0x20]
SHR R8D,CL
AND R8D,0x3
XOR EDX,EDX
TEST byte ptr [R10 + R13*0x1],BPL
SETNZ DL
LEA EDX,[R8 + RDX*0x4]
ADD EDX,-0x4
VCVTSI2SS XMM5,XMM7,EDX
VMULSS XMM5,XMM4,XMM5
VMOVSS dword ptr [RSI],XMM5
ADD RSI,0x4
INC R13
JMP 0x00193c51
LAB_00193c89:
MOVSX R13D,byte ptr [RSP + RBX*0x1 + -0x17]
ADD R13D,-0x20
VCVTSI2SS XMM4,XMM7,R13D
VMULSS XMM4,XMM3,XMM4
MOV R13,R9
LAB_00193c9f:
CMP R13,0x20
JZ 0x00193cd7
MOVZX EDX,byte ptr [R11 + R13*0x1 + 0x20]
SHR EDX,CL
AND EDX,0x3
XOR R8D,R8D
TEST byte ptr [R10 + R13*0x1],BPL
SETNZ R8B
LEA EDX,[RDX + R8*0x4]
ADD EDX,-0x4
VCVTSI2SS XMM5,XMM7,EDX
VMULSS XMM5,XMM4,XMM5
VMOVSS dword ptr [RSI],XMM5
ADD RSI,0x4
INC R13
JMP 0x00193c9f
LAB_00193cd7:
ADD RBX,0x2
ADD ECX,0x2
ADD BPL,BPL
INC R12D
JMP 0x00193c31
LAB_00193ce9:
SUB R14D,-0x80
MOV R11,R15
JMP 0x00193c18
LAB_00193cf5:
INC RDI
ADD R10,0x6e
JMP 0x00193b94
LAB_00193d01:
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void dequantize_row_q3_K(long param_1,float *param_2,int param_3)
{
float fVar1;
char cVar2;
int8 uVar3;
int1 auVar4 [16];
int1 auVar5 [16];
int1 auVar6 [16];
int1 auVar7 [16];
byte bVar8;
long lVar9;
long lVar10;
byte bVar11;
ulong uVar12;
long lVar13;
int iVar14;
long lVar15;
uint uVar16;
int1 auVar17 [16];
int1 auVar18 [16];
int1 local_48 [16];
ulong local_38;
auVar7 = _DAT_001a4ee0;
uVar12 = 0;
local_38 = (long)param_3 / 0x100 & 0xffffffff;
if ((int)((long)param_3 / 0x100) < 1) {
local_38 = uVar12;
}
auVar6 = vpshufd_avx(_DAT_001a4ee0,0x4e);
auVar5 = vpmovsxbd_avx(ZEXT416(DAT_001a4d6c));
lVar13 = param_1;
for (; uVar12 != local_38; uVar12 = uVar12 + 1) {
lVar9 = uVar12 * 0x6e;
fVar1 = (float)(&ggml_table_f32_f16)[*(ushort *)(param_1 + 0x6c + lVar9)];
uVar3 = *(int8 *)(param_1 + 0x60 + lVar9);
uVar16 = *(uint *)(param_1 + 0x68 + lVar9);
local_48._8_4_ = uVar16;
local_48._0_8_ = uVar3;
auVar17._4_4_ = uVar16;
auVar17._0_4_ = uVar16;
auVar17._8_4_ = uVar16;
auVar17._12_4_ = uVar16;
auVar4 = vpinsrd_avx(auVar17,uVar16 >> 2,1);
auVar4 = vpunpcklqdq_avx(local_48,auVar4);
auVar4 = vpand_avx(auVar4,auVar6);
auVar18._8_8_ = uVar3;
auVar18._0_8_ = uVar3;
auVar17 = vpsllvd_avx2(auVar17,auVar5);
auVar18 = vpsrlvd_avx2(auVar18,auVar5);
auVar17 = vpblendd_avx2(auVar17,auVar18,0xc);
auVar17 = vpand_avx(auVar17,auVar7);
local_48 = vpor_avx(auVar17,auVar4);
lVar10 = 0;
bVar11 = 1;
lVar9 = param_1 + lVar9;
for (uVar16 = 0; uVar16 < 0x100; uVar16 = uVar16 + 0x80) {
lVar10 = (long)(int)lVar10;
bVar8 = 0;
for (iVar14 = 0; iVar14 != 4; iVar14 = iVar14 + 1) {
cVar2 = local_48[lVar10];
for (lVar15 = 0; lVar15 != 0x10; lVar15 = lVar15 + 1) {
*param_2 = fVar1 * (float)(cVar2 + -0x20) *
(float)(int)((*(byte *)(lVar9 + 0x20 + lVar15) >> (bVar8 & 0x1f) & 3) +
(uint)((*(byte *)(lVar13 + lVar15) & bVar11) != 0) * 4 + -4);
param_2 = param_2 + 1;
}
cVar2 = local_48[lVar10 + 1];
for (lVar15 = 0x10; lVar15 != 0x20; lVar15 = lVar15 + 1) {
*param_2 = fVar1 * (float)(cVar2 + -0x20) *
(float)(int)((*(byte *)(lVar9 + 0x20 + lVar15) >> (bVar8 & 0x1f) & 3) +
(uint)((*(byte *)(lVar13 + lVar15) & bVar11) != 0) * 4 + -4);
param_2 = param_2 + 1;
}
lVar10 = lVar10 + 2;
bVar8 = bVar8 + 2;
bVar11 = bVar11 * '\x02';
}
lVar9 = lVar9 + 0x20;
}
lVar13 = lVar13 + 0x6e;
}
return;
}
| |
45,689 | dequantize_row_q3_K | 7CodeWizard[P]stablediffusion/ggml/src/ggml-quants.c | void dequantize_row_q3_K(const block_q3_K * restrict x, float * restrict y, int k) {
assert(k % QK_K == 0);
const int nb = k / QK_K;
const uint32_t kmask1 = 0x03030303;
const uint32_t kmask2 = 0x0f0f0f0f;
uint32_t aux[4];
const int8_t * scales = (const int8_t*)aux;
for (int i = 0; i < nb; i++) {
const float d_all = GGML_FP16_TO_FP32(x[i].d);
const uint8_t * restrict q = x[i].qs;
const uint8_t * restrict hm = x[i].hmask;
uint8_t m = 1;
memcpy(aux, x[i].scales, 12);
uint32_t tmp = aux[2];
aux[2] = ((aux[0] >> 4) & kmask2) | (((tmp >> 4) & kmask1) << 4);
aux[3] = ((aux[1] >> 4) & kmask2) | (((tmp >> 6) & kmask1) << 4);
aux[0] = (aux[0] & kmask2) | (((tmp >> 0) & kmask1) << 4);
aux[1] = (aux[1] & kmask2) | (((tmp >> 2) & kmask1) << 4);
int is = 0;
float dl;
for (int n = 0; n < QK_K; n += 128) {
int shift = 0;
for (int j = 0; j < 4; ++j) {
dl = d_all * (scales[is++] - 32);
for (int l = 0; l < 16; ++l) {
*y++ = dl * ((int8_t)((q[l+ 0] >> shift) & 3) - ((hm[l+ 0] & m) ? 0 : 4));
}
dl = d_all * (scales[is++] - 32);
for (int l = 0; l < 16; ++l) {
*y++ = dl * ((int8_t)((q[l+16] >> shift) & 3) - ((hm[l+16] & m) ? 0 : 4));
}
shift += 2;
m <<= 1;
}
q += 32;
}
}
} | O3 | c | dequantize_row_q3_K:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, -0x20(%rsp)
cmpl $0x100, %edx # imm = 0x100
jl 0xb6a5e
movq -0x20(%rsp), %rax
shrl $0x8, %eax
movq %rax, -0x20(%rsp)
xorl %edx, %edx
vmovdqa 0x11a24(%rip), %xmm0 # 0xc8310
vpshufd $0x4e, %xmm0, %xmm1 # xmm1 = xmm0[2,3,0,1]
vpmovsxbd 0x116c6(%rip), %xmm2 # 0xc7fc0
movq %rdi, %r9
imulq $0x6e, %rdx, %rcx
leaq (%rdi,%rcx), %r10
movzwl 0x6c(%rdi,%rcx), %r11d
leaq 0xc596e(%rip), %rax # 0x17c280
vmovss (%rax,%r11,4), %xmm3
movq 0x60(%rdi,%rcx), %r11
movq %r11, -0x18(%rsp)
movl 0x68(%rdi,%rcx), %ecx
movl %ecx, -0x10(%rsp)
vmovdqa -0x18(%rsp), %xmm4
vmovd %ecx, %xmm5
shrl $0x2, %ecx
vpbroadcastd %xmm5, %xmm5
vpinsrd $0x1, %ecx, %xmm5, %xmm6
vpunpcklqdq %xmm6, %xmm4, %xmm4 # xmm4 = xmm4[0],xmm6[0]
vpand %xmm1, %xmm4, %xmm4
vpbroadcastq -0x18(%rsp), %xmm6
vpsllvd %xmm2, %xmm5, %xmm5
vpsrlvd %xmm2, %xmm6, %xmm6
vpblendd $0xc, %xmm6, %xmm5, %xmm5 # xmm5 = xmm5[0,1],xmm6[2,3]
vpand %xmm0, %xmm5, %xmm5
vpor %xmm4, %xmm5, %xmm4
vmovdqa %xmm4, -0x18(%rsp)
movb $0x1, %r11b
xorl %ebx, %ebx
movb $0x1, %bpl
leaq 0x20(%r10), %r14
movslq %ebx, %rbx
xorl %r15d, %r15d
xorl %ecx, %ecx
movsbl -0x18(%rsp,%rbx), %r12d
addl $-0x20, %r12d
vcvtsi2ss %r12d, %xmm7, %xmm4
vmulss %xmm4, %xmm3, %xmm4
xorl %r12d, %r12d
xorl %r13d, %r13d
movzbl 0x20(%r10,%r13), %r8d
shrl %cl, %r8d
andl $0x3, %r8d
xorl %eax, %eax
testb %bpl, (%r9,%r13)
setne %al
leal -0x4(%r8,%rax,4), %eax
vcvtsi2ss %eax, %xmm7, %xmm5
vmulss %xmm5, %xmm4, %xmm5
vmovss %xmm5, (%rsi,%r13,4)
incq %r13
addq $-0x4, %r12
cmpq $0x10, %r13
jne 0xb699c
movsbl -0x17(%rsp,%rbx), %r13d
addl $-0x20, %r13d
vcvtsi2ss %r13d, %xmm7, %xmm4
vmulss %xmm4, %xmm3, %xmm4
subq %r12, %rsi
movl $0x10, %r12d
movzbl 0x20(%r10,%r12), %eax
shrl %cl, %eax
andl $0x3, %eax
xorl %r8d, %r8d
testb %bpl, (%r9,%r12)
setne %r8b
leal -0x4(%rax,%r8,4), %eax
vcvtsi2ss %eax, %xmm7, %xmm5
vmulss %xmm5, %xmm4, %xmm5
vmovss %xmm5, (%rsi)
addq $0x4, %rsi
incq %r12
cmpq $0x20, %r12
jne 0xb69ee
addq $0x2, %rbx
addl $0x2, %ecx
addb %bpl, %bpl
incl %r15d
cmpl $0x4, %r15d
jne 0xb6983
movq %r14, %r10
testb $0x1, %r11b
movl $0x0, %r11d
jne 0xb6977
incq %rdx
addq $0x6e, %r9
cmpq -0x20(%rsp), %rdx
jne 0xb68fd
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| dequantize_row_q3_K:
push rbp
push r15
push r14
push r13
push r12
push rbx
mov [rsp+30h+var_50], rdx
cmp edx, 100h
jl loc_B6A5E
mov rax, [rsp+30h+var_50]
shr eax, 8
mov [rsp+30h+var_50], rax
xor edx, edx
vmovdqa xmm0, cs:xmmword_C8310
vpshufd xmm1, xmm0, 4Eh ; 'N'
vpmovsxbd xmm2, cs:dword_C7FC0
mov r9, rdi
loc_B68FD:
imul rcx, rdx, 6Eh ; 'n'
lea r10, [rdi+rcx]
movzx r11d, word ptr [rdi+rcx+6Ch]
lea rax, ggml_table_f32_f16
vmovss xmm3, dword ptr [rax+r11*4]
mov r11, [rdi+rcx+60h]
mov qword ptr [rsp+30h+var_48], r11
mov ecx, [rdi+rcx+68h]
mov dword ptr [rsp+30h+var_48+8], ecx
vmovdqa xmm4, [rsp+30h+var_48]
vmovd xmm5, ecx
shr ecx, 2
vpbroadcastd xmm5, xmm5
vpinsrd xmm6, xmm5, ecx, 1
vpunpcklqdq xmm4, xmm4, xmm6
vpand xmm4, xmm4, xmm1
vpbroadcastq xmm6, qword ptr [rsp+30h+var_48]
vpsllvd xmm5, xmm5, xmm2
vpsrlvd xmm6, xmm6, xmm2
vpblendd xmm5, xmm5, xmm6, 0Ch
vpand xmm5, xmm5, xmm0
vpor xmm4, xmm5, xmm4
vmovdqa [rsp+30h+var_48], xmm4
mov r11b, 1
xor ebx, ebx
mov bpl, 1
loc_B6977:
lea r14, [r10+20h]
movsxd rbx, ebx
xor r15d, r15d
xor ecx, ecx
loc_B6983:
movsx r12d, byte ptr [rsp+rbx+30h+var_48]
add r12d, 0FFFFFFE0h
vcvtsi2ss xmm4, xmm7, r12d
vmulss xmm4, xmm3, xmm4
xor r12d, r12d
xor r13d, r13d
loc_B699C:
movzx r8d, byte ptr [r10+r13+20h]
shr r8d, cl
and r8d, 3
xor eax, eax
test [r9+r13], bpl
setnz al
lea eax, [r8+rax*4-4]
vcvtsi2ss xmm5, xmm7, eax
vmulss xmm5, xmm4, xmm5
vmovss dword ptr [rsi+r13*4], xmm5
inc r13
add r12, 0FFFFFFFFFFFFFFFCh
cmp r13, 10h
jnz short loc_B699C
movsx r13d, byte ptr [rsp+rbx+30h+var_48+1]
add r13d, 0FFFFFFE0h
vcvtsi2ss xmm4, xmm7, r13d
vmulss xmm4, xmm3, xmm4
sub rsi, r12
mov r12d, 10h
loc_B69EE:
movzx eax, byte ptr [r10+r12+20h]
shr eax, cl
and eax, 3
xor r8d, r8d
test [r9+r12], bpl
setnz r8b
lea eax, [rax+r8*4-4]
vcvtsi2ss xmm5, xmm7, eax
vmulss xmm5, xmm4, xmm5
vmovss dword ptr [rsi], xmm5
add rsi, 4
inc r12
cmp r12, 20h ; ' '
jnz short loc_B69EE
add rbx, 2
add ecx, 2
add bpl, bpl
inc r15d
cmp r15d, 4
jnz loc_B6983
mov r10, r14
test r11b, 1
mov r11d, 0
jnz loc_B6977
inc rdx
add r9, 6Eh ; 'n'
cmp rdx, [rsp+30h+var_50]
jnz loc_B68FD
loc_B6A5E:
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long dequantize_row_q3_K(
long long a1,
long long _RSI,
int a3,
double a4,
double a5,
double a6,
double a7,
double a8,
double a9,
double a10,
__m128 _XMM7)
{
long long v11; // rdx
long long v15; // r9
long long v16; // r10
char v32; // r11
int v33; // ebx
char v34; // bp
int v35; // r15d
char v36; // cl
long long v39; // r12
long long i; // r12
long long result; // rax
bool v49; // zf
long long v50; // [rsp+0h] [rbp-50h]
__int128 v51; // [rsp+8h] [rbp-48h] BYREF
if ( a3 >= 256 )
{
v50 = (unsigned int)a3 >> 8;
v11 = 0LL;
__asm
{
vmovdqa xmm0, cs:xmmword_C8310
vpshufd xmm1, xmm0, 4Eh ; 'N'
vpmovsxbd xmm2, cs:dword_C7FC0
}
v15 = a1;
do
{
v16 = a1 + 110 * v11;
_R11 = *(unsigned __int16 *)(v16 + 108);
_RAX = &ggml_table_f32_f16;
__asm { vmovss xmm3, dword ptr [rax+r11*4] }
*(_QWORD *)&v51 = *(_QWORD *)(v16 + 96);
DWORD2(v51) = *(_DWORD *)(v16 + 104);
__asm
{
vmovdqa xmm4, [rsp+30h+var_48]
vmovd xmm5, ecx
vpbroadcastd xmm5, xmm5
vpinsrd xmm6, xmm5, ecx, 1
vpunpcklqdq xmm4, xmm4, xmm6
vpand xmm4, xmm4, xmm1
vpbroadcastq xmm6, qword ptr [rsp+30h+var_48]
vpsllvd xmm5, xmm5, xmm2
vpsrlvd xmm6, xmm6, xmm2
vpblendd xmm5, xmm5, xmm6, 0Ch
vpand xmm5, xmm5, xmm0
vpor xmm4, xmm5, xmm4
vmovdqa [rsp+30h+var_48], xmm4
}
v32 = 1;
v33 = 0;
v34 = 1;
do
{
v35 = 0;
v36 = 0;
do
{
__asm
{
vcvtsi2ss xmm4, xmm7, r12d
vmulss xmm4, xmm3, xmm4
}
v39 = 0LL;
for ( _R13 = 0LL; _R13 != 16; ++_R13 )
{
__asm
{
vcvtsi2ss xmm5, xmm7, eax
vmulss xmm5, xmm4, xmm5
vmovss dword ptr [rsi+r13*4], xmm5
}
v39 -= 4LL;
}
__asm
{
vcvtsi2ss xmm4, xmm7, r13d
vmulss xmm4, xmm3, xmm4
}
_RSI -= v39;
for ( i = 16LL; i != 32; ++i )
{
result = ((*(unsigned __int8 *)(v16 + i + 32) >> v36) & 3)
+ 4 * (unsigned int)(((unsigned __int8)v34 & *(_BYTE *)(v15 + i)) != 0)
- 4;
__asm
{
vcvtsi2ss xmm5, xmm7, eax
vmulss xmm5, xmm4, xmm5
vmovss dword ptr [rsi], xmm5
}
_RSI += 4LL;
}
v33 += 2;
v36 += 2;
v34 *= 2;
++v35;
}
while ( v35 != 4 );
v16 += 32LL;
v49 = (v32 & 1) == 0;
v32 = 0;
}
while ( !v49 );
++v11;
v15 += 110LL;
}
while ( v11 != v50 );
}
return result;
}
| |||
45,690 | js_global_encodeURI | bluesky950520[P]quickjs/quickjs.c | static JSValue js_global_encodeURI(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv,
int isComponent)
{
JSValue str;
StringBuffer b_s, *b = &b_s;
JSString *p;
int k, c, c1;
str = JS_ToString(ctx, argv[0]);
if (JS_IsException(str))
return str;
p = JS_VALUE_GET_STRING(str);
string_buffer_init(ctx, b, p->len);
for (k = 0; k < p->len;) {
c = string_get(p, k);
k++;
if (isURIUnescaped(c, isComponent)) {
string_buffer_putc16(b, c);
} else {
if (is_lo_surrogate(c)) {
js_throw_URIError(ctx, "invalid character");
goto fail;
} else if (is_hi_surrogate(c)) {
if (k >= p->len) {
js_throw_URIError(ctx, "expecting surrogate pair");
goto fail;
}
c1 = string_get(p, k);
k++;
if (!is_lo_surrogate(c1)) {
js_throw_URIError(ctx, "expecting surrogate pair");
goto fail;
}
c = from_surrogate(c, c1);
}
if (c < 0x80) {
encodeURI_hex(b, c);
} else {
/* XXX: use C UTF-8 conversion ? */
if (c < 0x800) {
encodeURI_hex(b, (c >> 6) | 0xc0);
} else {
if (c < 0x10000) {
encodeURI_hex(b, (c >> 12) | 0xe0);
} else {
encodeURI_hex(b, (c >> 18) | 0xf0);
encodeURI_hex(b, ((c >> 12) & 0x3f) | 0x80);
}
encodeURI_hex(b, ((c >> 6) & 0x3f) | 0x80);
}
encodeURI_hex(b, (c & 0x3f) | 0x80);
}
}
}
JS_FreeValue(ctx, str);
return string_buffer_end(b);
fail:
JS_FreeValue(ctx, str);
string_buffer_free(b);
return JS_EXCEPTION;
} | O3 | c | js_global_encodeURI:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, 0x14(%rsp)
movq %rdi, %rbx
movq (%r8), %rsi
movq 0x8(%r8), %rdx
xorl %ecx, %ecx
callq 0x27518
movq %rax, %r12
cmpl $0x6, %edx
je 0x7b74e
movq %rdx, 0x20(%rsp)
movl $0x7fffffff, %esi # imm = 0x7FFFFFFF
andl 0x4(%r12), %esi
movq %rbx, 0x28(%rsp)
movl %esi, 0x3c(%rsp)
movl $0x0, 0x38(%rsp)
movq $0x0, 0x40(%rsp)
movq %rbx, 0x18(%rsp)
movq %rbx, %rdi
xorl %edx, %edx
callq 0x20686
movq %rax, 0x30(%rsp)
testq %rax, %rax
je 0x7b760
movq 0x4(%r12), %rbp
movl %ebp, %ebx
andl $0x7fffffff, %ebx # imm = 0x7FFFFFFF
je 0x7b6ba
xorl %r15d, %r15d
leaq 0x28(%rsp), %r14
movq %r12, 0x8(%rsp)
movslq %r15d, %r13
leaq 0x1(%r13), %r15
testl %ebp, %ebp
js 0x7b51c
movzbl 0x18(%r12,%r13), %r12d
jmp 0x7b52b
movzwl 0x18(%r12,%r13,2), %r12d
cmpl $0xff, %r12d
ja 0x7b577
leal -0x30(%r12), %eax
cmpl $0xa, %eax
jb 0x7b55c
movl %r12d, %eax
andl $-0x21, %eax
addl $-0x41, %eax
cmpl $0x1a, %eax
jb 0x7b55c
movl $0x9, %edx
leaq 0x2822e(%rip), %rdi # 0xa377d
movl %r12d, %esi
callq 0xe430
testq %rax, %rax
je 0x7b56c
movq %r14, %rdi
movl %r12d, %esi
callq 0x4886d
jmp 0x7b69f
cmpl $0x0, 0x14(%rsp)
je 0x7b63a
movl %r12d, %eax
andl $0xfc00, %eax # imm = 0xFC00
cmpl $0xd800, %eax # imm = 0xD800
je 0x7b5b9
cmpl $0xdc00, %eax # imm = 0xDC00
je 0x7b6fd
cmpl $0x7f, %r12d
jbe 0x7b694
cmpl $0x7ff, %r12d # imm = 0x7FF
ja 0x7b65c
movl %r12d, %esi
shrl $0x6, %esi
orl $0xc0, %esi
jmp 0x7b681
cmpl %ebx, %r15d
jge 0x7b6f4
testl %ebp, %ebp
js 0x7b5d3
movq 0x8(%rsp), %rax
movzbl 0x18(%rax,%r15), %eax
jmp 0x7b5de
movq 0x8(%rsp), %rax
movzwl 0x1a(%rax,%r13,2), %eax
movl %eax, %ecx
andl $0xfc00, %ecx # imm = 0xFC00
cmpl $0xdc00, %ecx # imm = 0xDC00
jne 0x7b6f4
leal 0x2(%r13), %r15d
shll $0xa, %r12d
andl $0xffc00, %r12d # imm = 0xFFC00
andl $0x3ff, %eax # imm = 0x3FF
movl %r12d, %ebp
addl $0x10000, %ebp # imm = 0x10000
addl %eax, %r12d
addl $0x10000, %r12d # imm = 0x10000
movl %ebp, %esi
shrl $0x12, %esi
orl $0xf0, %esi
movq %r14, %rdi
callq 0x7bbd8
shrl $0xc, %ebp
andl $0x3f, %ebp
orl $0x80, %ebp
jmp 0x7b668
movl $0xb, %edx
leaq 0x28100(%rip), %rdi # 0xa3746
movl %r12d, %esi
callq 0xe430
testq %rax, %rax
jne 0x7b55c
jmp 0x7b577
movl %r12d, %ebp
shrl $0xc, %ebp
orl $0xe0, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x7bbd8
movl %r12d, %esi
shrl $0x6, %esi
andl $0x3f, %esi
orl $0x80, %esi
movq %r14, %rdi
callq 0x7bbd8
andl $0x3f, %r12d
orl $0x80, %r12d
movq %r14, %rdi
movl %r12d, %esi
callq 0x7bbd8
movq 0x8(%rsp), %r12
movq 0x4(%r12), %rbp
movl %ebp, %ebx
andl $0x7fffffff, %ebx # imm = 0x7FFFFFFF
cmpl %ebx, %r15d
jl 0x7b509
movq 0x20(%rsp), %rdx
cmpl $-0x9, %edx
jb 0x7b6e5
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
movl (%r12), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r12)
cmpl $0x1, %eax
jg 0x7b6e5
movq %r12, %rsi
callq 0x20d90
leaq 0x28(%rsp), %rdi
callq 0x33675
movq %rax, %r12
jmp 0x7b74e
leaq 0x28069(%rip), %rsi # 0xa3764
jmp 0x7b704
leaq 0x2804e(%rip), %rsi # 0xa3752
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7bae3
movq 0x20(%rsp), %rdx
cmpl $-0x9, %edx
movq 0x8(%rsp), %rsi
jb 0x7b737
movq 0x18(%rbx), %rdi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x7b737
callq 0x20d90
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1c845
movl $0x6, %edx
xorl %r12d, %r12d
movq %r12, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x0, 0x3c(%rsp)
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x7b4e9
| js_global_encodeURI:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov [rsp+78h+var_64], r9d
mov rbx, rdi
mov rsi, [r8]
mov rdx, [r8+8]
xor ecx, ecx
call JS_ToStringInternal
mov r12, rax
cmp edx, 6
jz loc_7B74E
mov [rsp+78h+var_58], rdx
mov esi, 7FFFFFFFh
and esi, [r12+4]
mov [rsp+78h+var_50], rbx
mov [rsp+78h+var_3C], esi
mov [rsp+78h+var_40], 0
mov [rsp+78h+var_38], 0
mov [rsp+78h+var_60], rbx
mov rdi, rbx
xor edx, edx
call js_alloc_string
mov [rsp+78h+var_48], rax
test rax, rax
jz loc_7B760
loc_7B4E9:
mov rbp, [r12+4]
mov ebx, ebp
and ebx, 7FFFFFFFh
jz loc_7B6BA
xor r15d, r15d
lea r14, [rsp+78h+var_50]
mov [rsp+78h+var_70], r12
loc_7B509:
movsxd r13, r15d
lea r15, [r13+1]
test ebp, ebp
js short loc_7B51C
movzx r12d, byte ptr [r12+r13+18h]
jmp short loc_7B52B
loc_7B51C:
movzx r12d, word ptr [r12+r13*2+18h]
cmp r12d, 0FFh
ja short loc_7B577
loc_7B52B:
lea eax, [r12-30h]
cmp eax, 0Ah
jb short loc_7B55C
mov eax, r12d
and eax, 0FFFFFFDFh
add eax, 0FFFFFFBFh
cmp eax, 1Ah
jb short loc_7B55C
mov edx, 9
lea rdi, asc_A377D; "-_.!~*'()"
mov esi, r12d
call _memchr
test rax, rax
jz short loc_7B56C
loc_7B55C:
mov rdi, r14
mov esi, r12d
call string_buffer_putc16
jmp loc_7B69F
loc_7B56C:
cmp [rsp+78h+var_64], 0
jz loc_7B63A
loc_7B577:
mov eax, r12d
and eax, 0FC00h
cmp eax, 0D800h
jz short loc_7B5B9
cmp eax, 0DC00h
jz loc_7B6FD
cmp r12d, 7Fh
jbe loc_7B694
cmp r12d, 7FFh
ja loc_7B65C
mov esi, r12d
shr esi, 6
or esi, 0C0h
jmp loc_7B681
loc_7B5B9:
cmp r15d, ebx
jge loc_7B6F4
test ebp, ebp
js short loc_7B5D3
mov rax, [rsp+78h+var_70]
movzx eax, byte ptr [rax+r15+18h]
jmp short loc_7B5DE
loc_7B5D3:
mov rax, [rsp+78h+var_70]
movzx eax, word ptr [rax+r13*2+1Ah]
loc_7B5DE:
mov ecx, eax
and ecx, 0FC00h
cmp ecx, 0DC00h
jnz loc_7B6F4
lea r15d, [r13+2]
shl r12d, 0Ah
and r12d, 0FFC00h
and eax, 3FFh
mov ebp, r12d
add ebp, 10000h
add r12d, eax
add r12d, 10000h
mov esi, ebp
shr esi, 12h
or esi, 0F0h
mov rdi, r14
call encodeURI_hex
shr ebp, 0Ch
and ebp, 3Fh
or ebp, 80h
jmp short loc_7B668
loc_7B63A:
mov edx, 0Bh
lea rdi, asc_A3746; ";/?:@&=+$,#"
mov esi, r12d
call _memchr
test rax, rax
jnz loc_7B55C
jmp loc_7B577
loc_7B65C:
mov ebp, r12d
shr ebp, 0Ch
or ebp, 0E0h
loc_7B668:
mov rdi, r14
mov esi, ebp
call encodeURI_hex
mov esi, r12d
shr esi, 6
and esi, 3Fh
or esi, 80h
loc_7B681:
mov rdi, r14
call encodeURI_hex
and r12d, 3Fh
or r12d, 80h
loc_7B694:
mov rdi, r14
mov esi, r12d
call encodeURI_hex
loc_7B69F:
mov r12, [rsp+78h+var_70]
mov rbp, [r12+4]
mov ebx, ebp
and ebx, 7FFFFFFFh
cmp r15d, ebx
jl loc_7B509
loc_7B6BA:
mov rdx, [rsp+78h+var_58]
cmp edx, 0FFFFFFF7h
jb short loc_7B6E5
mov rax, [rsp+78h+var_60]
mov rdi, [rax+18h]
mov eax, [r12]
lea ecx, [rax-1]
mov [r12], ecx
cmp eax, 1
jg short loc_7B6E5
mov rsi, r12
call js_free_value_rt
loc_7B6E5:
lea rdi, [rsp+78h+var_50]
call string_buffer_end
mov r12, rax
jmp short loc_7B74E
loc_7B6F4:
lea rsi, aExpectingSurro; "expecting surrogate pair"
jmp short loc_7B704
loc_7B6FD:
lea rsi, aInvalidCharact; "invalid character"
loc_7B704:
mov rbx, [rsp+78h+var_60]
mov rdi, rbx
xor eax, eax
call js_throw_URIError
mov rdx, [rsp+78h+var_58]
cmp edx, 0FFFFFFF7h
mov rsi, [rsp+78h+var_70]
jb short loc_7B737
mov rdi, [rbx+18h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_7B737
call js_free_value_rt
loc_7B737:
mov rdi, [rsp+78h+var_50]
mov rsi, [rsp+78h+var_48]
call js_free
mov edx, 6
xor r12d, r12d
loc_7B74E:
mov rax, r12
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7B760:
mov [rsp+78h+var_3C], 0
mov dword ptr [rsp+78h+var_38+4], 0FFFFFFFFh
jmp loc_7B4E9
| long long js_global_encodeURI(
long long a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
unsigned long long v14; // rax
long long v15; // rdx
_QWORD *v16; // r12
long long v17; // rsi
int v18; // edx
int v19; // ecx
long long v20; // r8
long long v21; // r9
long long v22; // rbp
int v23; // ebx
long long v24; // r15
long long v25; // r13
unsigned int v26; // r12d
int v27; // eax
long long v28; // rsi
__int16 v29; // ax
int v30; // r12d
unsigned int v31; // ebp
unsigned int v32; // ebp
long long v33; // rdi
int v34; // eax
long long v35; // rcx
const char *v36; // rsi
long long v37; // r8
long long v38; // r9
long long v39; // rdi
int v40; // eax
long long v41; // rcx
_QWORD *v43; // [rsp+8h] [rbp-70h]
int v44; // [rsp+14h] [rbp-64h]
long long v45; // [rsp+20h] [rbp-58h]
long long v46; // [rsp+28h] [rbp-50h] BYREF
long long v47; // [rsp+30h] [rbp-48h]
int v48; // [rsp+38h] [rbp-40h]
int v49; // [rsp+3Ch] [rbp-3Ch]
long long v50; // [rsp+40h] [rbp-38h]
v44 = a14;
v14 = JS_ToStringInternal(a1, *(_DWORD **)a13, *(_QWORD *)(a13 + 8), 0LL, a13, a14, a2, a3, a4, a5, a6, a7, a8, a9);
v16 = (_QWORD *)v14;
if ( (_DWORD)v15 == 6 )
return (long long)v16;
v45 = v15;
v17 = *(_DWORD *)(v14 + 4) & 0x7FFFFFFF;
v46 = a1;
v49 = v17;
v48 = 0;
v50 = 0LL;
v47 = js_alloc_string(a1, v17, 0);
if ( !v47 )
{
v49 = 0;
HIDWORD(v50) = -1;
}
v22 = *(_QWORD *)((char *)v16 + 4);
v23 = v22 & 0x7FFFFFFF;
if ( (v22 & 0x7FFFFFFF) == 0 )
{
LABEL_32:
if ( (unsigned int)v45 >= 0xFFFFFFF7 )
{
v33 = *(_QWORD *)(a1 + 24);
v34 = *(_DWORD *)v16;
v35 = (unsigned int)(*(_DWORD *)v16 - 1);
*(_DWORD *)v16 = v35;
if ( v34 <= 1 )
js_free_value_rt(v33, v16, v45, v35, v20, v21);
}
return string_buffer_end(&v46);
}
LODWORD(v24) = 0;
v43 = v16;
while ( 1 )
{
v25 = (int)v24;
v24 = (int)v24 + 1LL;
if ( (int)v22 < 0 )
{
v26 = *((unsigned __int16 *)v16 + v25 + 12);
if ( v26 > 0xFF )
break;
}
else
{
v26 = *((unsigned __int8 *)v16 + v25 + 24);
}
if ( v26 - 48 >= 0xA
&& (v26 & 0xFFFFFFDF) - 65 >= 0x1A
&& !memchr("-_.!~*'()", v26, 9LL)
&& (v44 || !memchr(";/?:@&=+$,#", v26, 11LL)) )
{
break;
}
string_buffer_putc16((long long)&v46, v26);
LABEL_31:
v16 = v43;
v22 = *(_QWORD *)((char *)v43 + 4);
v23 = v22 & 0x7FFFFFFF;
if ( (int)v24 >= (v22 & 0x7FFFFFFF) )
goto LABEL_32;
}
v27 = v26 & 0xFC00;
if ( v27 == 55296 )
{
if ( (int)v24 >= v23
|| ((int)v22 < 0 ? (v29 = *((_WORD *)v43 + v25 + 13)) : (v29 = *((unsigned __int8 *)v43 + v24 + 24)),
v19 = v29 & 0xFC00,
v19 != 56320) )
{
v36 = "expecting surrogate pair";
goto LABEL_38;
}
LODWORD(v24) = v25 + 2;
v30 = (v26 << 10) & 0xFFC00;
v31 = v30 + 0x10000;
v26 = (v29 & 0x3FF) + v30 + 0x10000;
encodeURI_hex(&v46, (v31 >> 18) | 0xF0);
v32 = (v31 >> 12) & 0x3F | 0x80;
goto LABEL_28;
}
if ( v27 != 56320 )
{
if ( v26 <= 0x7F )
{
LABEL_30:
encodeURI_hex(&v46, v26);
goto LABEL_31;
}
if ( v26 <= 0x7FF )
{
v28 = (v26 >> 6) | 0xC0;
LABEL_29:
encodeURI_hex(&v46, v28);
v26 = v26 & 0x3F | 0x80;
goto LABEL_30;
}
v32 = (v26 >> 12) | 0xE0;
LABEL_28:
encodeURI_hex(&v46, v32);
v28 = (v26 >> 6) & 0x3F | 0x80;
goto LABEL_29;
}
v36 = "invalid character";
LABEL_38:
js_throw_URIError(a1, (_DWORD)v36, v18, v19, v20, v21);
if ( (unsigned int)v45 >= 0xFFFFFFF7 )
{
v39 = *(_QWORD *)(a1 + 24);
v40 = *(_DWORD *)v43;
v41 = (unsigned int)(*(_DWORD *)v43 - 1);
*(_DWORD *)v43 = v41;
if ( v40 <= 1 )
js_free_value_rt(v39, v43, v45, v41, v37, v38);
}
js_free(v46, v47);
return 0LL;
}
| js_global_encodeURI:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV dword ptr [RSP + 0x14],R9D
MOV RBX,RDI
MOV RSI,qword ptr [R8]
MOV RDX,qword ptr [R8 + 0x8]
XOR ECX,ECX
CALL 0x00127518
MOV R12,RAX
CMP EDX,0x6
JZ 0x0017b74e
MOV qword ptr [RSP + 0x20],RDX
MOV ESI,0x7fffffff
AND ESI,dword ptr [R12 + 0x4]
MOV qword ptr [RSP + 0x28],RBX
MOV dword ptr [RSP + 0x3c],ESI
MOV dword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x0
MOV qword ptr [RSP + 0x18],RBX
MOV RDI,RBX
XOR EDX,EDX
CALL 0x00120686
MOV qword ptr [RSP + 0x30],RAX
TEST RAX,RAX
JZ 0x0017b760
LAB_0017b4e9:
MOV RBP,qword ptr [R12 + 0x4]
MOV EBX,EBP
AND EBX,0x7fffffff
JZ 0x0017b6ba
XOR R15D,R15D
LEA R14,[RSP + 0x28]
MOV qword ptr [RSP + 0x8],R12
LAB_0017b509:
MOVSXD R13,R15D
LEA R15,[R13 + 0x1]
TEST EBP,EBP
JS 0x0017b51c
MOVZX R12D,byte ptr [R12 + R13*0x1 + 0x18]
JMP 0x0017b52b
LAB_0017b51c:
MOVZX R12D,word ptr [R12 + R13*0x2 + 0x18]
CMP R12D,0xff
JA 0x0017b577
LAB_0017b52b:
LEA EAX,[R12 + -0x30]
CMP EAX,0xa
JC 0x0017b55c
MOV EAX,R12D
AND EAX,0xffffffdf
ADD EAX,-0x41
CMP EAX,0x1a
JC 0x0017b55c
MOV EDX,0x9
LEA RDI,[0x1a377d]
MOV ESI,R12D
CALL 0x0010e430
TEST RAX,RAX
JZ 0x0017b56c
LAB_0017b55c:
MOV RDI,R14
MOV ESI,R12D
CALL 0x0014886d
JMP 0x0017b69f
LAB_0017b56c:
CMP dword ptr [RSP + 0x14],0x0
JZ 0x0017b63a
LAB_0017b577:
MOV EAX,R12D
AND EAX,0xfc00
CMP EAX,0xd800
JZ 0x0017b5b9
CMP EAX,0xdc00
JZ 0x0017b6fd
CMP R12D,0x7f
JBE 0x0017b694
CMP R12D,0x7ff
JA 0x0017b65c
MOV ESI,R12D
SHR ESI,0x6
OR ESI,0xc0
JMP 0x0017b681
LAB_0017b5b9:
CMP R15D,EBX
JGE 0x0017b6f4
TEST EBP,EBP
JS 0x0017b5d3
MOV RAX,qword ptr [RSP + 0x8]
MOVZX EAX,byte ptr [RAX + R15*0x1 + 0x18]
JMP 0x0017b5de
LAB_0017b5d3:
MOV RAX,qword ptr [RSP + 0x8]
MOVZX EAX,word ptr [RAX + R13*0x2 + 0x1a]
LAB_0017b5de:
MOV ECX,EAX
AND ECX,0xfc00
CMP ECX,0xdc00
JNZ 0x0017b6f4
LEA R15D,[R13 + 0x2]
SHL R12D,0xa
AND R12D,0xffc00
AND EAX,0x3ff
MOV EBP,R12D
ADD EBP,0x10000
ADD R12D,EAX
ADD R12D,0x10000
MOV ESI,EBP
SHR ESI,0x12
OR ESI,0xf0
MOV RDI,R14
CALL 0x0017bbd8
SHR EBP,0xc
AND EBP,0x3f
OR EBP,0x80
JMP 0x0017b668
LAB_0017b63a:
MOV EDX,0xb
LEA RDI,[0x1a3746]
MOV ESI,R12D
CALL 0x0010e430
TEST RAX,RAX
JNZ 0x0017b55c
JMP 0x0017b577
LAB_0017b65c:
MOV EBP,R12D
SHR EBP,0xc
OR EBP,0xe0
LAB_0017b668:
MOV RDI,R14
MOV ESI,EBP
CALL 0x0017bbd8
MOV ESI,R12D
SHR ESI,0x6
AND ESI,0x3f
OR ESI,0x80
LAB_0017b681:
MOV RDI,R14
CALL 0x0017bbd8
AND R12D,0x3f
OR R12D,0x80
LAB_0017b694:
MOV RDI,R14
MOV ESI,R12D
CALL 0x0017bbd8
LAB_0017b69f:
MOV R12,qword ptr [RSP + 0x8]
MOV RBP,qword ptr [R12 + 0x4]
MOV EBX,EBP
AND EBX,0x7fffffff
CMP R15D,EBX
JL 0x0017b509
LAB_0017b6ba:
MOV RDX,qword ptr [RSP + 0x20]
CMP EDX,-0x9
JC 0x0017b6e5
MOV RAX,qword ptr [RSP + 0x18]
MOV RDI,qword ptr [RAX + 0x18]
MOV EAX,dword ptr [R12]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R12],ECX
CMP EAX,0x1
JG 0x0017b6e5
MOV RSI,R12
CALL 0x00120d90
LAB_0017b6e5:
LEA RDI,[RSP + 0x28]
CALL 0x00133675
MOV R12,RAX
JMP 0x0017b74e
LAB_0017b6f4:
LEA RSI,[0x1a3764]
JMP 0x0017b704
LAB_0017b6fd:
LEA RSI,[0x1a3752]
LAB_0017b704:
MOV RBX,qword ptr [RSP + 0x18]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x0017bae3
MOV RDX,qword ptr [RSP + 0x20]
CMP EDX,-0x9
MOV RSI,qword ptr [RSP + 0x8]
JC 0x0017b737
MOV RDI,qword ptr [RBX + 0x18]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x0017b737
CALL 0x00120d90
LAB_0017b737:
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x30]
CALL 0x0011c845
MOV EDX,0x6
XOR R12D,R12D
LAB_0017b74e:
MOV RAX,R12
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017b760:
MOV dword ptr [RSP + 0x3c],0x0
MOV dword ptr [RSP + 0x44],0xffffffff
JMP 0x0017b4e9
|
int * js_global_encodeURI(long param_1)
{
ushort uVar1;
int8 uVar2;
void *pvVar3;
int *piVar4;
uint uVar5;
uint uVar6;
uint uVar7;
ulong uVar8;
char *pcVar9;
int8 *in_R8;
int in_R9D;
int iVar10;
uint __c;
long lVar11;
ulong uVar12;
int1 auVar13 [12];
long local_50;
long local_48;
int4 local_40;
uint local_3c;
int8 local_38;
auVar13 = JS_ToStringInternal(param_1,*in_R8,in_R8[1],0);
uVar5 = auVar13._8_4_;
piVar4 = auVar13._0_8_;
if (uVar5 != 6) {
local_3c = piVar4[1] & 0x7fffffff;
local_40 = 0;
local_38 = 0;
local_50 = param_1;
local_48 = js_alloc_string(param_1,local_3c,0);
if (local_48 == 0) {
local_3c = 0;
local_38 = CONCAT44(0xffffffff,(int4)local_38);
}
uVar8 = *(ulong *)(piVar4 + 1);
uVar6 = (uint)uVar8 & 0x7fffffff;
if ((uVar8 & 0x7fffffff) != 0) {
uVar12 = 0;
do {
iVar10 = (int)uVar12;
lVar11 = (long)iVar10;
uVar12 = lVar11 + 1;
if ((int)uVar8 < 0) {
uVar1 = *(ushort *)((long)piVar4 + lVar11 * 2 + 0x18);
__c = (uint)uVar1;
if (uVar1 < 0x100) goto LAB_0017b52b;
LAB_0017b577:
if ((__c & 0xfc00) == 0xd800) {
if ((int)uVar12 < (int)uVar6) {
if ((int)uVar8 < 0) {
uVar6 = (uint)*(ushort *)((long)piVar4 + lVar11 * 2 + 0x1a);
}
else {
uVar6 = (uint)*(byte *)((long)piVar4 + lVar11 + 0x19);
}
if ((uVar6 & 0xfc00) == 0xdc00) {
uVar12 = (ulong)(iVar10 + 2);
iVar10 = (__c & 0x3ff) * 0x400;
uVar7 = iVar10 + 0x10000;
__c = iVar10 + (uVar6 & 0x3ff) + 0x10000;
encodeURI_hex(&local_50,uVar7 >> 0x12 | 0xf0);
uVar6 = uVar7 >> 0xc & 0x3f | 0x80;
LAB_0017b668:
encodeURI_hex(&local_50,uVar6);
uVar6 = __c >> 6 & 0x3f | 0x80;
goto LAB_0017b681;
}
}
pcVar9 = "expecting surrogate pair";
LAB_0017b704:
js_throw_URIError(param_1,pcVar9);
if (0xfffffff6 < uVar5) {
uVar2 = *(int8 *)(param_1 + 0x18);
iVar10 = *piVar4;
*piVar4 = iVar10 + -1;
if (iVar10 < 2) {
js_free_value_rt(uVar2);
}
}
js_free(local_50,local_48);
return (int *)0x0;
}
if ((__c & 0xfc00) == 0xdc00) {
pcVar9 = "invalid character";
goto LAB_0017b704;
}
if (0x7f < __c) {
if (0x7ff < __c) {
uVar6 = __c >> 0xc | 0xe0;
goto LAB_0017b668;
}
uVar6 = __c >> 6 | 0xc0;
LAB_0017b681:
encodeURI_hex(&local_50,uVar6);
__c = __c & 0x3f | 0x80;
}
encodeURI_hex(&local_50,__c);
}
else {
__c = (uint)*(byte *)((long)piVar4 + lVar11 + 0x18);
LAB_0017b52b:
if ((((9 < __c - 0x30) && (0x19 < (__c & 0xffffffdf) - 0x41)) &&
(pvVar3 = memchr(&DAT_001a377d,__c,9), pvVar3 == (void *)0x0)) &&
((in_R9D != 0 || (pvVar3 = memchr(";/?:@&=+$,#",__c,0xb), pvVar3 == (void *)0x0))))
goto LAB_0017b577;
string_buffer_putc16(&local_50,__c);
}
uVar8 = *(ulong *)(piVar4 + 1);
uVar6 = (uint)uVar8 & 0x7fffffff;
} while ((int)uVar12 < (int)uVar6);
}
if (0xfffffff6 < uVar5) {
uVar2 = *(int8 *)(param_1 + 0x18);
iVar10 = *piVar4;
*piVar4 = iVar10 + -1;
if (iVar10 < 2) {
js_free_value_rt(uVar2,piVar4);
}
}
piVar4 = (int *)string_buffer_end(&local_50);
}
return piVar4;
}
| |
45,691 | pvio_socket_async_write | eloqsql/libmariadb/plugins/pvio/pvio_socket.c | ssize_t pvio_socket_async_write(MARIADB_PVIO *pvio, const uchar *buffer, size_t length)
{
ssize_t r= -1;
struct st_pvio_socket *csock= NULL;
#ifndef _WIN32
int write_flags= MSG_DONTWAIT;
#ifdef MSG_NOSIGNAL
write_flags|= MSG_NOSIGNAL;
#endif
#endif
if (!pvio || !pvio->data)
return -1;
csock= (struct st_pvio_socket *)pvio->data;
#ifndef WIN32
r= ma_send(csock->socket, buffer, length, write_flags);
#else
/* Windows doesn't support MSG_DONTWAIT, so we need to set
socket to non blocking */
pvio_socket_blocking(pvio, 0, 0);
r= send(csock->socket, (const char *)buffer, (int)length, 0);
#endif
return r;
} | O0 | c | pvio_socket_async_write:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $-0x1, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x40, -0x34(%rbp)
movl -0x34(%rbp), %eax
orl $0x4000, %eax # imm = 0x4000
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x66527
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x66531
movq $-0x1, -0x8(%rbp)
jmp 0x6655e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x34(%rbp), %ecx
callq 0x679a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| pvio_socket_async_write:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], 0FFFFFFFFFFFFFFFFh
mov [rbp+var_30], 0
mov [rbp+var_34], 40h ; '@'
mov eax, [rbp+var_34]
or eax, 4000h
mov [rbp+var_34], eax
cmp [rbp+var_10], 0
jz short loc_66527
mov rax, [rbp+var_10]
cmp qword ptr [rax], 0
jnz short loc_66531
loc_66527:
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
jmp short loc_6655E
loc_66531:
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov edi, [rax]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov ecx, [rbp+var_34]
call ma_send
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
loc_6655E:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long pvio_socket_async_write(_QWORD *a1, long long a2, long long a3)
{
if ( a1 && *a1 )
return ma_send(*(unsigned int *)*a1, a2, a3, 16448LL);
else
return -1LL;
}
| pvio_socket_async_write:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],-0x1
MOV qword ptr [RBP + -0x30],0x0
MOV dword ptr [RBP + -0x34],0x40
MOV EAX,dword ptr [RBP + -0x34]
OR EAX,0x4000
MOV dword ptr [RBP + -0x34],EAX
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00166527
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX],0x0
JNZ 0x00166531
LAB_00166527:
MOV qword ptr [RBP + -0x8],-0x1
JMP 0x0016655e
LAB_00166531:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x34]
CALL 0x001679a0
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
LAB_0016655e:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
int8 pvio_socket_async_write(long *param_1,int8 param_2,int8 param_3)
{
int8 local_10;
if ((param_1 == (long *)0x0) || (*param_1 == 0)) {
local_10 = 0xffffffffffffffff;
}
else {
local_10 = ma_send(*(int4 *)*param_1,param_2,param_3,0x4040);
}
return local_10;
}
| |
45,692 | 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;
} | O0 | c | BC_add_object_ref1:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rax
movl 0x34(%rax), %eax
shll $0x8, %eax
sarl $0x18, %eax
cmpl $0x0, %eax
je 0x837e4
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
addq $0x38, %rsi
movq 0x8(%rsp), %rcx
addq $0x44, %rcx
movq 0x8(%rsp), %rax
movl 0x40(%rax), %r8d
addl $0x1, %r8d
movl $0x8, %edx
callq 0x79430
cmpl $0x0, %eax
je 0x837c0
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x837ec
movq (%rsp), %rdx
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rsp), %rsi
movl 0x40(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x40(%rsi)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| BC_add_object_ref1:
sub rsp, 18h
mov [rsp+18h+var_10], rdi
mov [rsp+18h+var_18], rsi
mov rax, [rsp+18h+var_10]
mov eax, [rax+34h]
shl eax, 8
sar eax, 18h
cmp eax, 0
jz short loc_837E4
mov rax, [rsp+18h+var_10]
mov rdi, [rax]
mov rsi, [rsp+18h+var_10]
add rsi, 38h ; '8'
mov rcx, [rsp+18h+var_10]
add rcx, 44h ; 'D'
mov rax, [rsp+18h+var_10]
mov r8d, [rax+40h]
add r8d, 1
mov edx, 8
call js_resize_array
cmp eax, 0
jz short loc_837C0
mov [rsp+18h+var_4], 0FFFFFFFFh
jmp short loc_837EC
loc_837C0:
mov rdx, [rsp+18h+var_18]
mov rax, [rsp+18h+var_10]
mov rax, [rax+38h]
mov rsi, [rsp+18h+var_10]
mov ecx, [rsi+40h]
mov edi, ecx
add edi, 1
mov [rsi+40h], edi
movsxd rcx, ecx
mov [rax+rcx*8], rdx
loc_837E4:
mov [rsp+18h+var_4], 0
loc_837EC:
mov eax, [rsp+18h+var_4]
add rsp, 18h
retn
| long long BC_add_object_ref1(long long a1, long long a2)
{
long long v2; // rax
int v3; // ecx
if ( !((int)(*(_DWORD *)(a1 + 52) << 8) >> 24) )
return 0;
if ( !(unsigned int)js_resize_array(*(_QWORD *)a1, a1 + 56, 8u, (_DWORD *)(a1 + 68), *(_DWORD *)(a1 + 64) + 1) )
{
v2 = *(_QWORD *)(a1 + 56);
v3 = *(_DWORD *)(a1 + 64);
*(_DWORD *)(a1 + 64) = v3 + 1;
*(_QWORD *)(v2 + 8LL * v3) = a2;
return 0;
}
return (unsigned int)-1;
}
| BC_add_object_ref1:
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
MOV qword ptr [RSP],RSI
MOV RAX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RAX + 0x34]
SHL EAX,0x8
SAR EAX,0x18
CMP EAX,0x0
JZ 0x001837e4
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RSP + 0x8]
ADD RSI,0x38
MOV RCX,qword ptr [RSP + 0x8]
ADD RCX,0x44
MOV RAX,qword ptr [RSP + 0x8]
MOV R8D,dword ptr [RAX + 0x40]
ADD R8D,0x1
MOV EDX,0x8
CALL 0x00179430
CMP EAX,0x0
JZ 0x001837c0
MOV dword ptr [RSP + 0x14],0xffffffff
JMP 0x001837ec
LAB_001837c0:
MOV RDX,qword ptr [RSP]
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x38]
MOV RSI,qword ptr [RSP + 0x8]
MOV ECX,dword ptr [RSI + 0x40]
MOV EDI,ECX
ADD EDI,0x1
MOV dword ptr [RSI + 0x40],EDI
MOVSXD RCX,ECX
MOV qword ptr [RAX + RCX*0x8],RDX
LAB_001837e4:
MOV dword ptr [RSP + 0x14],0x0
LAB_001837ec:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x18
RET
|
int4 BC_add_object_ref1(int8 *param_1,int8 param_2)
{
int iVar1;
if ((*(int *)((long)param_1 + 0x34) << 8) >> 0x18 != 0) {
iVar1 = js_resize_array(*param_1,param_1 + 7,8,(long)param_1 + 0x44,*(int *)(param_1 + 8) + 1);
if (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;
}
| |
45,693 | 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 0x41044
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 0x3ec9f
testl %eax, %eax
je 0x41031
pushq $-0x1
popq %rbx
jmp 0x41044
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_41044
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_41031
push 0FFFFFFFFFFFFFFFFh
pop rbx
jmp short loc_41044
loc_41031:
mov rax, [r15+38h]
movsxd rcx, dword ptr [r15+40h]
lea edx, [rcx+1]
mov [r15+40h], edx
mov [rax+rcx*8], r14
loc_41044:
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 0x00141044
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 0x0013ec9f
TEST EAX,EAX
JZ 0x00141031
PUSH -0x1
POP RBX
JMP 0x00141044
LAB_00141031:
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_00141044:
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;
}
| |
45,694 | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::json_sax_dom_callback_parser(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t, 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>&)>, bool) | monkey531[P]llama/common/json.hpp | json_sax_dom_callback_parser(BasicJsonType& r,
const parser_callback_t cb,
const bool allow_exceptions_ = true)
: root(r), callback(cb), allow_exceptions(allow_exceptions_)
{
keep_stack.push_back(true);
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::json_sax_dom_callback_parser(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t, 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>&)>, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdi, %rbx
movq %rsi, (%rdi)
leaq 0x20(%rdi), %r14
leaq 0x80(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
movups %xmm0, 0x68(%rdi)
movb $0x0, 0x78(%rdi)
movq %r12, %rdi
movq %rdx, %rsi
callq 0x493a8
movb %bpl, 0xa0(%rbx)
leaq 0xa8(%rbx), %r13
movb $0x9, 0xa8(%rbx)
movq $0x0, 0xb0(%rbx)
movq %r13, %rdi
movl $0x1, %esi
callq 0x426e2
movq %r14, %rdi
movl $0x1, %esi
callq 0x4caa8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r13, %rdi
xorl %esi, %esi
callq 0x426e2
movq %r13, %rdi
callq 0x4f2d0
movq 0x90(%rbx), %rax
testq %rax, %rax
je 0x4a824
movq %r12, %rdi
movq %r12, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x4a824
jmp 0x4a84b
movq %rax, %r15
leaq 0x48(%rbx), %rdi
callq 0x4ccb0
movq %r14, %rdi
callq 0x4ccb0
leaq 0x8(%rbx), %rdi
movq %rbx, %rsi
callq 0x1b5ca
movq %r15, %rdi
callq 0x1ad30
jmp 0x4a84b
movq %rax, %rdi
callq 0x20d77
nop
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2ERSF_St8functionIFbiNS1_13parse_event_tESH_EEb:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebp, ecx
mov rbx, rdi
mov [rdi], rsi
lea r14, [rdi+20h]
lea r12, [rdi+80h]
xorps xmm0, xmm0
movups xmmword ptr [rdi+8], xmm0
movups xmmword ptr [rdi+18h], xmm0
movups xmmword ptr [rdi+28h], xmm0
movups xmmword ptr [rdi+38h], xmm0
movups xmmword ptr [rdi+48h], xmm0
movups xmmword ptr [rdi+58h], xmm0
movups xmmword ptr [rdi+68h], xmm0
mov byte ptr [rdi+78h], 0
mov rdi, r12
mov rsi, rdx
call _ZNSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEC2ERKSJ_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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> &)>::function(std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)> const&)
mov [rbx+0A0h], bpl
lea r13, [rbx+0A8h]
mov byte ptr [rbx+0A8h], 9
mov qword ptr [rbx+0B0h], 0
mov rdi, r13
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
mov esi, 1
call _ZNSt6vectorIbSaIbEE9push_backEb; std::vector<bool>::push_back(bool)
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r15, rax
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 rax, [rbx+90h]
test rax, rax
jz short loc_4A824
mov rdi, r12
mov rsi, r12
mov edx, 3
call rax
jmp short loc_4A824
jmp short loc_4A84B
mov r15, rax
loc_4A824:
lea rdi, [rbx+48h]
call _ZNSt13_Bvector_baseISaIbEE13_M_deallocateEv; std::_Bvector_base<std::allocator<bool>>::_M_deallocate(void)
mov rdi, r14
call _ZNSt13_Bvector_baseISaIbEE13_M_deallocateEv; std::_Bvector_base<std::allocator<bool>>::_M_deallocate(void)
lea rdi, [rbx+8]
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2ERSF_St8functionIFbiNS1_13parse_event_tESH_EEb_cold_1; nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::json_sax_dom_callback_parser(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&,std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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>&)>,bool) [clone]
mov rdi, r15
call __Unwind_Resume
jmp short $+2
loc_4A84B:
mov rdi, rax
call __clang_call_terminate
| long long nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::json_sax_dom_callback_parser(
long long a1,
long long a2,
long long a3,
char a4)
{
*(_QWORD *)a1 = a2;
*(_OWORD *)(a1 + 8) = 0LL;
*(_OWORD *)(a1 + 24) = 0LL;
*(_OWORD *)(a1 + 40) = 0LL;
*(_OWORD *)(a1 + 56) = 0LL;
*(_OWORD *)(a1 + 72) = 0LL;
*(_OWORD *)(a1 + 88) = 0LL;
*(_OWORD *)(a1 + 104) = 0LL;
*(_BYTE *)(a1 + 120) = 0;
std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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> &)>::function(
(_OWORD *)(a1 + 128),
a3);
*(_BYTE *)(a1 + 160) = a4;
*(_BYTE *)(a1 + 168) = 9;
*(_QWORD *)(a1 + 176) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)(a1 + 168));
return std::vector<bool>::push_back(a1 + 32, 1LL);
}
| json_sax_dom_callback_parser:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBP,ECX
MOV RBX,RDI
MOV qword ptr [RDI],RSI
LEA R14,[RDI + 0x20]
LEA R12,[RDI + 0x80]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x8],XMM0
MOVUPS xmmword ptr [RDI + 0x18],XMM0
MOVUPS xmmword ptr [RDI + 0x28],XMM0
MOVUPS xmmword ptr [RDI + 0x38],XMM0
MOVUPS xmmword ptr [RDI + 0x48],XMM0
MOVUPS xmmword ptr [RDI + 0x58],XMM0
MOVUPS xmmword ptr [RDI + 0x68],XMM0
MOV byte ptr [RDI + 0x78],0x0
LAB_0014a79b:
MOV RDI,R12
MOV RSI,RDX
CALL 0x001493a8
MOV byte ptr [RBX + 0xa0],BPL
LEA R13,[RBX + 0xa8]
MOV byte ptr [RBX + 0xa8],0x9
MOV qword ptr [RBX + 0xb0],0x0
MOV RDI,R13
MOV ESI,0x1
CALL 0x001426e2
LAB_0014a7d3:
MOV RDI,R14
MOV ESI,0x1
CALL 0x0014caa8
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>
>::json_sax_dom_callback_parser(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>&, std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t,
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>&)>, bool) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::json_sax_dom_callback_parser
(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,int8 param_1,function *param_3,
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
param_4)
{
*(int8 *)this = param_1;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x50) = 0;
*(int8 *)(this + 0x58) = 0;
*(int8 *)(this + 0x60) = 0;
*(int8 *)(this + 0x68) = 0;
*(int8 *)(this + 0x70) = 0;
this[0x78] = (json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
)0x0;
/* try { // try from 0014a79b to 0014a7a5 has its CatchHandler @ 0014a821 */
std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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>&)>
::function((function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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 + 0x80),param_3);
this[0xa0] = param_4;
this[0xa8] = (json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
)0x9;
*(int8 *)(this + 0xb0) = 0;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant((bool)((char)this + -0x58));
/* try { // try from 0014a7d3 to 0014a7df has its CatchHandler @ 0014a7ef */
std::vector<bool,std::allocator<bool>>::push_back
((vector<bool,std::allocator<bool>> *)(this + 0x20),true);
return;
}
| |
45,695 | ftxui::(anonymous namespace)::Select::Select(std::vector<std::shared_ptr<ftxui::Node>, std::allocator<std::shared_ptr<ftxui::Node>>>) | Andrewchistyakov[P]flashcards_lyc/build_O3/_deps/ftxui-src/src/ftxui/dom/frame.cpp | explicit Select(Elements children) : Node(std::move(children)) {} | O3 | cpp | ftxui::(anonymous namespace)::Select::Select(std::vector<std::shared_ptr<ftxui::Node>, std::allocator<std::shared_ptr<ftxui::Node>>>):
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movups (%rsi), %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movq 0x10(%rsi), %rcx
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %rax, %rsi
callq 0x23e0a
movq %rsp, %rdi
callq 0x1503a
leaq 0x202dc(%rip), %rax # 0x589c0
movq %rax, (%rbx)
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1503a
movq %rbx, %rdi
callq 0xb780
| _ZN5ftxui12_GLOBAL__N_16SelectC2ESt6vectorISt10shared_ptrINS_4NodeEESaIS5_EE:
push rbx
sub rsp, 20h
mov rbx, rdi
movups xmm0, xmmword ptr [rsi]
mov rax, rsp
movaps xmmword ptr [rax], xmm0
mov rcx, [rsi+10h]
mov [rax+10h], rcx
xorps xmm0, xmm0
movups xmmword ptr [rsi], xmm0
mov qword ptr [rsi+10h], 0
mov rsi, rax
call _ZN5ftxui4NodeC2ESt6vectorISt10shared_ptrIS0_ESaIS3_EE; ftxui::Node::Node(std::vector<std::shared_ptr<ftxui::Node>>)
mov rdi, rsp
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
lea rax, off_589C0
mov [rbx], rax
add rsp, 20h
pop rbx
retn
mov rbx, rax
mov rdi, rsp
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
mov rdi, rbx
call __Unwind_Resume
| void ( ** ftxui::`anonymous namespace'::Select::Select(
_QWORD *a1,
__int128 *a2))(ftxui::Node *__hidden this)
{
void ( **result)(ftxui::Node *__hidden); // rax
__int128 v3; // [rsp+0h] [rbp-28h] BYREF
long long v4; // [rsp+10h] [rbp-18h]
v3 = *a2;
v4 = *((_QWORD *)a2 + 2);
*a2 = 0LL;
*((_QWORD *)a2 + 2) = 0LL;
ftxui::Node::Node((long long)a1, (long long)&v3);
std::vector<std::shared_ptr<ftxui::Node>>::~vector((long long)&v3);
result = off_589C0;
*a1 = off_589C0;
return result;
}
| Select:
PUSH RBX
SUB RSP,0x20
MOV RBX,RDI
MOVUPS XMM0,xmmword ptr [RSI]
MOV RAX,RSP
MOVAPS xmmword ptr [RAX],XMM0
MOV RCX,qword ptr [RSI + 0x10]
MOV qword ptr [RAX + 0x10],RCX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSI],XMM0
MOV qword ptr [RSI + 0x10],0x0
LAB_001386cd:
MOV RSI,RAX
CALL 0x00123e0a
LAB_001386d5:
MOV RDI,RSP
CALL 0x0011503a
LEA RAX,[0x1589c0]
MOV qword ptr [RBX],RAX
ADD RSP,0x20
POP RBX
RET
|
/* ftxui::(anonymous namespace)::Select::Select(std::vector<std::shared_ptr<ftxui::Node>,
std::allocator<std::shared_ptr<ftxui::Node> > >) */
void __thiscall ftxui::(anonymous_namespace)::Select::Select(Select *this,int8 *param_2)
{
int8 local_28;
int8 uStack_20;
int8 local_18;
local_28 = *param_2;
uStack_20 = param_2[1];
local_18 = param_2[2];
*param_2 = 0;
param_2[1] = 0;
param_2[2] = 0;
/* try { // try from 001386cd to 001386d4 has its CatchHandler @ 001386ed */
Node::Node((Node *)this,&local_28);
std::vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>::~vector
((vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>> *)
&local_28);
*(int ***)this = &PTR__Node_001589c0;
return;
}
| |
45,696 | my_b_seq_read | eloqsql/mysys/mf_iocache.c | static int _my_b_seq_read(IO_CACHE *info, uchar *Buffer, size_t Count)
{
size_t length, diff_length, save_count, max_length;
my_off_t pos_in_file;
save_count=Count;
lock_append_buffer(info);
/* pos_in_file always point on where info->buffer was read */
if ((pos_in_file=info->pos_in_file +
(size_t) (info->read_end - info->buffer)) >= info->end_of_file)
goto read_append_buffer;
/*
With read-append cache we must always do a seek before we read,
because the write could have moved the file pointer astray
*/
if (mysql_file_seek(info->file, pos_in_file, MY_SEEK_SET, MYF(0)) == MY_FILEPOS_ERROR)
{
info->error= -1;
unlock_append_buffer(info);
return (1);
}
info->seek_not_done=0;
diff_length= (size_t) (pos_in_file & (IO_SIZE-1));
/* now the second stage begins - read from file descriptor */
if (Count >= (size_t) (IO_SIZE+(IO_SIZE-diff_length)))
{
/* Fill first intern buffer */
size_t read_length;
length= IO_ROUND_DN(Count) - diff_length;
if ((read_length= mysql_file_read(info->file,Buffer, length,
info->myflags)) == (size_t) -1)
{
info->error= -1;
unlock_append_buffer(info);
return 1;
}
Count-=read_length;
Buffer+=read_length;
pos_in_file+=read_length;
if (read_length != length)
{
/*
We only got part of data; Read the rest of the data from the
write buffer
*/
goto read_append_buffer;
}
diff_length=0;
}
max_length= info->read_length-diff_length;
if (max_length > (info->end_of_file - pos_in_file))
max_length= (size_t) (info->end_of_file - pos_in_file);
if (!max_length)
{
if (Count)
goto read_append_buffer;
length=0; /* Didn't read any more chars */
}
else
{
length= mysql_file_read(info->file,info->buffer, max_length, info->myflags);
if (length == (size_t) -1)
{
info->error= -1;
unlock_append_buffer(info);
return 1;
}
if (length < Count)
{
memcpy(Buffer, info->buffer, length);
Count -= length;
Buffer += length;
/*
added the line below to make
DBUG_ASSERT(pos_in_file==info->end_of_file) pass.
otherwise this does not appear to be needed
*/
pos_in_file += length;
goto read_append_buffer;
}
}
unlock_append_buffer(info);
info->read_pos=info->buffer+Count;
info->read_end=info->buffer+length;
info->pos_in_file=pos_in_file;
memcpy(Buffer,info->buffer,(size_t) Count);
return 0;
read_append_buffer:
/*
Read data from the current write buffer.
Count should never be == 0 here (The code will work even if count is 0)
*/
{
/* First copy the data to Count */
size_t len_in_buff = (size_t) (info->write_pos - info->append_read_pos);
size_t copy_len;
size_t transfer_len;
DBUG_ASSERT(info->append_read_pos <= info->write_pos);
copy_len=MY_MIN(Count, len_in_buff);
memcpy(Buffer, info->append_read_pos, copy_len);
info->append_read_pos += copy_len;
Count -= copy_len;
if (Count)
info->error= (int) (save_count - Count);
/* Fill read buffer with data from write buffer */
memcpy(info->buffer, info->append_read_pos,
(size_t) (transfer_len=len_in_buff - copy_len));
info->read_pos= info->buffer;
info->read_end= info->buffer+transfer_len;
info->append_read_pos=info->write_pos;
info->pos_in_file=pos_in_file+copy_len;
info->end_of_file+=len_in_buff;
}
unlock_append_buffer(info);
return Count ? 1 : 0;
} | O0 | c | my_b_seq_read:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
leaq 0x71eea(%rip), %rsi # 0x1541a5
movl $0x54c, %edx # imm = 0x54C
callq 0xe1790
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq 0x20(%rdx), %rdx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0xe22f5
jmp 0xe259c
movq -0x10(%rbp), %rax
movl 0xd4(%rax), %edx
movq -0x48(%rbp), %rcx
leaq 0x71e9b(%rip), %rdi # 0x1541a5
movl $0x557, %esi # imm = 0x557
xorl %r8d, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0xe0230
cmpq $-0x1, %rax
jne 0xe2349
movq -0x10(%rbp), %rax
movl $0xffffffff, 0xe4(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0xe18c0
movl $0x1, -0x4(%rbp)
jmp 0xe26be
movq -0x10(%rbp), %rax
movl $0x0, 0xe0(%rax)
movq -0x48(%rbp), %rax
andq $0xfff, %rax # imm = 0xFFF
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movl $0x1000, %ecx # imm = 0x1000
subq -0x30(%rbp), %rcx
addq $0x1000, %rcx # imm = 0x1000
cmpq %rcx, %rax
jb 0xe2435
movabsq $0xfffff000, %rax # imm = 0xFFFFF000
andq -0x20(%rbp), %rax
subq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0xd4(%rax), %edx
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %r9
leaq 0x71de9(%rip), %rdi # 0x1541a5
movl $0x569, %esi # imm = 0x569
callq 0xe2c40
movq %rax, -0x50(%rbp)
cmpq $-0x1, %rax
jne 0xe23f7
movq -0x10(%rbp), %rax
movl $0xffffffff, 0xe4(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0xe18c0
movl $0x1, -0x4(%rbp)
jmp 0xe26be
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x50(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x50(%rbp), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0xe242d
jmp 0xe259c
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rax
subq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq -0x48(%rbp), %rcx
cmpq %rcx, %rax
jbe 0xe246d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
subq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0xe248d
cmpq $0x0, -0x20(%rbp)
je 0xe2480
jmp 0xe259c
movq $0x0, -0x28(%rbp)
jmp 0xe253b
movq -0x10(%rbp), %rax
movl 0xd4(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x40(%rbp), %r8
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %r9
leaq 0x71cf0(%rip), %rdi # 0x1541a5
movl $0x589, %esi # imm = 0x589
callq 0xe2c40
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0xe24f1
movq -0x10(%rbp), %rax
movl $0xffffffff, 0xe4(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0xe18c0
movl $0x1, -0x4(%rbp)
jmp 0xe26be
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xe2539
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0x2a090
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0xe259c
jmp 0xe253b
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0xe18c0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x48(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x2a090
movl $0x0, -0x4(%rbp)
jmp 0xe26be
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x58(%rbp)
jmp 0xe25b5
movq -0x20(%rbp), %rax
cmpq -0x58(%rbp), %rax
jae 0xe25c9
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0xe25d1
movq -0x58(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x60(%rbp), %rdx
callq 0x2a090
movq -0x60(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x38(%rax), %rcx
movq %rcx, 0x38(%rax)
movq -0x60(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xe2628
movq -0x38(%rbp), %rax
subq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xe4(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x58(%rbp), %rdx
subq -0x60(%rbp), %rdx
movq %rdx, -0x68(%rbp)
callq 0x2a090
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq -0x68(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x48(%rbp), %rcx
addq -0x60(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x58(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0xe18c0
movq -0x20(%rbp), %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _my_b_seq_read:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_20]
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
lea rsi, aWorkspaceLlm4b_35; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 54Ch
call inline_mysql_mutex_lock_23
mov rax, [rbp+var_10]
mov rax, [rax]
mov rcx, [rbp+var_10]
mov rcx, [rcx+18h]
mov rdx, [rbp+var_10]
mov rdx, [rdx+20h]
sub rcx, rdx
add rax, rcx
mov [rbp+var_48], rax
mov rcx, [rbp+var_10]
cmp rax, [rcx+8]
jb short loc_E22F5
jmp loc_E259C
loc_E22F5:
mov rax, [rbp+var_10]
mov edx, [rax+0D4h]
mov rcx, [rbp+var_48]
lea rdi, aWorkspaceLlm4b_35; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 557h
xor r8d, r8d
xor eax, eax
mov r9d, eax
call inline_mysql_file_seek_6
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_E2349
mov rax, [rbp+var_10]
mov dword ptr [rax+0E4h], 0FFFFFFFFh
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
call inline_mysql_mutex_unlock_24
mov [rbp+var_4], 1
jmp loc_E26BE
loc_E2349:
mov rax, [rbp+var_10]
mov dword ptr [rax+0E0h], 0
mov rax, [rbp+var_48]
and rax, 0FFFh
mov [rbp+var_30], rax
mov rax, [rbp+var_20]
mov ecx, 1000h
sub rcx, [rbp+var_30]
add rcx, 1000h
cmp rax, rcx
jb loc_E2435
mov rax, 0FFFFF000h
and rax, [rbp+var_20]
sub rax, [rbp+var_30]
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov edx, [rax+0D4h]
mov rcx, [rbp+var_18]
mov r8, [rbp+var_28]
mov rax, [rbp+var_10]
mov r9, [rax+0F8h]
lea rdi, aWorkspaceLlm4b_35; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 569h
call inline_mysql_file_read_5
mov [rbp+var_50], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_E23F7
mov rax, [rbp+var_10]
mov dword ptr [rax+0E4h], 0FFFFFFFFh
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
call inline_mysql_mutex_unlock_24
mov [rbp+var_4], 1
jmp loc_E26BE
loc_E23F7:
mov rcx, [rbp+var_50]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_50]
add rax, [rbp+var_18]
mov [rbp+var_18], rax
mov rax, [rbp+var_50]
add rax, [rbp+var_48]
mov [rbp+var_48], rax
mov rax, [rbp+var_50]
cmp rax, [rbp+var_28]
jz short loc_E242D
jmp loc_E259C
loc_E242D:
mov [rbp+var_30], 0
loc_E2435:
mov rax, [rbp+var_10]
mov rax, [rax+0F0h]
sub rax, [rbp+var_30]
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov rcx, [rbp+var_10]
mov rcx, [rcx+8]
sub rcx, [rbp+var_48]
cmp rax, rcx
jbe short loc_E246D
mov rax, [rbp+var_10]
mov rax, [rax+8]
sub rax, [rbp+var_48]
mov [rbp+var_40], rax
loc_E246D:
cmp [rbp+var_40], 0
jnz short loc_E248D
cmp [rbp+var_20], 0
jz short loc_E2480
jmp loc_E259C
loc_E2480:
mov [rbp+var_28], 0
jmp loc_E253B
loc_E248D:
mov rax, [rbp+var_10]
mov edx, [rax+0D4h]
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
mov r8, [rbp+var_40]
mov rax, [rbp+var_10]
mov r9, [rax+0F8h]
lea rdi, aWorkspaceLlm4b_35; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 589h
call inline_mysql_file_read_5
mov [rbp+var_28], rax
cmp [rbp+var_28], 0FFFFFFFFFFFFFFFFh
jnz short loc_E24F1
mov rax, [rbp+var_10]
mov dword ptr [rax+0E4h], 0FFFFFFFFh
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
call inline_mysql_mutex_unlock_24
mov [rbp+var_4], 1
jmp loc_E26BE
loc_E24F1:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_20]
jnb short loc_E2539
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rsi, [rax+20h]
mov rdx, [rbp+var_28]
call _memcpy
mov rcx, [rbp+var_28]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_28]
add rax, [rbp+var_18]
mov [rbp+var_18], rax
mov rax, [rbp+var_28]
add rax, [rbp+var_48]
mov [rbp+var_48], rax
jmp short loc_E259C
loc_E2539:
jmp short $+2
loc_E253B:
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
call inline_mysql_mutex_unlock_24
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
add rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax+10h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
add rcx, [rbp+var_28]
mov rax, [rbp+var_10]
mov [rax+18h], rcx
mov rcx, [rbp+var_48]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rsi, [rax+20h]
mov rdx, [rbp+var_20]
call _memcpy
mov [rbp+var_4], 0
jmp loc_E26BE
loc_E259C:
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rcx, [rbp+var_10]
mov rcx, [rcx+38h]
sub rax, rcx
mov [rbp+var_58], rax
jmp short $+2
loc_E25B5:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_58]
jnb short loc_E25C9
mov rax, [rbp+var_20]
mov [rbp+var_70], rax
jmp short loc_E25D1
loc_E25C9:
mov rax, [rbp+var_58]
mov [rbp+var_70], rax
loc_E25D1:
mov rax, [rbp+var_70]
mov [rbp+var_60], rax
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rsi, [rax+38h]
mov rdx, [rbp+var_60]
call _memcpy
mov rcx, [rbp+var_60]
mov rax, [rbp+var_10]
add rcx, [rax+38h]
mov [rax+38h], rcx
mov rcx, [rbp+var_60]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jz short loc_E2628
mov rax, [rbp+var_38]
sub rax, [rbp+var_20]
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax+0E4h], ecx
loc_E2628:
mov rax, [rbp+var_10]
mov rdi, [rax+20h]
mov rax, [rbp+var_10]
mov rsi, [rax+38h]
mov rdx, [rbp+var_58]
sub rdx, [rbp+var_60]
mov [rbp+var_68], rdx
call _memcpy
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
mov rax, [rbp+var_10]
mov [rax+10h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
add rcx, [rbp+var_68]
mov rax, [rbp+var_10]
mov [rax+18h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+40h]
mov rax, [rbp+var_10]
mov [rax+38h], rcx
mov rcx, [rbp+var_48]
add rcx, [rbp+var_60]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rcx, [rbp+var_58]
mov rax, [rbp+var_10]
add rcx, [rax+8]
mov [rax+8], rcx
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
call inline_mysql_mutex_unlock_24
mov rdx, [rbp+var_20]
xor eax, eax
mov ecx, 1
cmp rdx, 0
cmovnz eax, ecx
mov [rbp+var_4], eax
loc_E26BE:
mov eax, [rbp+var_4]
add rsp, 70h
pop rbp
retn
| _BOOL8 my_b_seq_read(long long a1, long long a2, unsigned long long a3)
{
unsigned long long v4; // [rsp+0h] [rbp-70h]
unsigned long long v5; // [rsp+18h] [rbp-58h]
long long v6; // [rsp+20h] [rbp-50h]
unsigned long long v7; // [rsp+28h] [rbp-48h]
unsigned long long v8; // [rsp+30h] [rbp-40h]
int v9; // [rsp+38h] [rbp-38h]
unsigned long long v10; // [rsp+40h] [rbp-30h]
unsigned long long v11; // [rsp+48h] [rbp-28h]
unsigned long long v12; // [rsp+48h] [rbp-28h]
unsigned long long v13; // [rsp+50h] [rbp-20h]
unsigned long long v14; // [rsp+50h] [rbp-20h]
long long v15; // [rsp+58h] [rbp-18h]
v15 = a2;
v13 = a3;
v9 = a3;
inline_mysql_mutex_lock_23(a1 + 80, (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c", 0x54Cu);
v7 = *(_QWORD *)(a1 + 24) - *(_QWORD *)(a1 + 32) + *(_QWORD *)a1;
if ( v7 >= *(_QWORD *)(a1 + 8) )
goto LABEL_18;
if ( inline_mysql_file_seek_6(
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
0x557u,
*(_DWORD *)(a1 + 212),
v7,
0,
0LL) == -1 )
goto LABEL_14;
*(_DWORD *)(a1 + 224) = 0;
v10 = v7 & 0xFFF;
if ( v13 >= 4096 - v10 + 4096 )
{
v11 = ((unsigned int)v13 & 0xFFFFF000) - v10;
v6 = inline_mysql_file_read_5(
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
1385LL,
*(unsigned int *)(a1 + 212),
a2,
v11,
*(_QWORD *)(a1 + 248));
if ( v6 == -1 )
goto LABEL_14;
v13 -= v6;
v15 = a2 + v6;
v7 += v6;
if ( v6 != v11 )
goto LABEL_18;
v10 = 0LL;
}
v8 = *(_QWORD *)(a1 + 240) - v10;
if ( v8 > *(_QWORD *)(a1 + 8) - v7 )
v8 = *(_QWORD *)(a1 + 8) - v7;
if ( v8 )
{
v12 = inline_mysql_file_read_5(
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
1417LL,
*(unsigned int *)(a1 + 212),
*(_QWORD *)(a1 + 32),
v8,
*(_QWORD *)(a1 + 248));
if ( v12 == -1LL )
{
LABEL_14:
*(_DWORD *)(a1 + 228) = -1;
inline_mysql_mutex_unlock_24(a1 + 80);
return 1;
}
if ( v12 >= v13 )
{
LABEL_17:
inline_mysql_mutex_unlock_24(a1 + 80);
*(_QWORD *)(a1 + 16) = v13 + *(_QWORD *)(a1 + 32);
*(_QWORD *)(a1 + 24) = v12 + *(_QWORD *)(a1 + 32);
*(_QWORD *)a1 = v7;
memcpy(v15, *(_QWORD *)(a1 + 32), v13);
return 0;
}
memcpy(v15, *(_QWORD *)(a1 + 32), v12);
v13 -= v12;
v15 += v12;
v7 += v12;
}
else if ( !v13 )
{
v12 = 0LL;
goto LABEL_17;
}
LABEL_18:
v5 = *(_QWORD *)(a1 + 64) - *(_QWORD *)(a1 + 56);
if ( v13 >= v5 )
v4 = *(_QWORD *)(a1 + 64) - *(_QWORD *)(a1 + 56);
else
v4 = v13;
memcpy(v15, *(_QWORD *)(a1 + 56), v4);
*(_QWORD *)(a1 + 56) += v4;
v14 = v13 - v4;
if ( v14 )
*(_DWORD *)(a1 + 228) = v9 - v14;
memcpy(*(_QWORD *)(a1 + 32), *(_QWORD *)(a1 + 56), v5 - v4);
*(_QWORD *)(a1 + 16) = *(_QWORD *)(a1 + 32);
*(_QWORD *)(a1 + 24) = v5 - v4 + *(_QWORD *)(a1 + 32);
*(_QWORD *)(a1 + 56) = *(_QWORD *)(a1 + 64);
*(_QWORD *)a1 = v4 + v7;
*(_QWORD *)(a1 + 8) += v5;
inline_mysql_mutex_unlock_24(a1 + 80);
return v14 != 0;
}
| _my_b_seq_read:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
LEA RSI,[0x2541a5]
MOV EDX,0x54c
CALL 0x001e1790
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x18]
MOV RDX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RDX + 0x20]
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x8]
JC 0x001e22f5
JMP 0x001e259c
LAB_001e22f5:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0xd4]
MOV RCX,qword ptr [RBP + -0x48]
LEA RDI,[0x2541a5]
MOV ESI,0x557
XOR R8D,R8D
XOR EAX,EAX
MOV R9D,EAX
CALL 0x001e0230
CMP RAX,-0x1
JNZ 0x001e2349
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],0xffffffff
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
CALL 0x001e18c0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001e26be
LAB_001e2349:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe0],0x0
MOV RAX,qword ptr [RBP + -0x48]
AND RAX,0xfff
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,0x1000
SUB RCX,qword ptr [RBP + -0x30]
ADD RCX,0x1000
CMP RAX,RCX
JC 0x001e2435
MOV RAX,0xfffff000
AND RAX,qword ptr [RBP + -0x20]
SUB RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0xd4]
MOV RCX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV R9,qword ptr [RAX + 0xf8]
LEA RDI,[0x2541a5]
MOV ESI,0x569
CALL 0x001e2c40
MOV qword ptr [RBP + -0x50],RAX
CMP RAX,-0x1
JNZ 0x001e23f7
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],0xffffffff
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
CALL 0x001e18c0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001e26be
LAB_001e23f7:
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x28]
JZ 0x001e242d
JMP 0x001e259c
LAB_001e242d:
MOV qword ptr [RBP + -0x30],0x0
LAB_001e2435:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xf0]
SUB RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x8]
SUB RCX,qword ptr [RBP + -0x48]
CMP RAX,RCX
JBE 0x001e246d
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
SUB RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x40],RAX
LAB_001e246d:
CMP qword ptr [RBP + -0x40],0x0
JNZ 0x001e248d
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001e2480
JMP 0x001e259c
LAB_001e2480:
MOV qword ptr [RBP + -0x28],0x0
JMP 0x001e253b
LAB_001e248d:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0xd4]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
MOV R8,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x10]
MOV R9,qword ptr [RAX + 0xf8]
LEA RDI,[0x2541a5]
MOV ESI,0x589
CALL 0x001e2c40
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],-0x1
JNZ 0x001e24f1
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],0xffffffff
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
CALL 0x001e18c0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001e26be
LAB_001e24f1:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x001e2539
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x20]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x0012a090
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x001e259c
LAB_001e2539:
JMP 0x001e253b
LAB_001e253b:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
CALL 0x001e18c0
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
ADD RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
ADD RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],RCX
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x20]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0012a090
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001e26be
LAB_001e259c:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x38]
SUB RAX,RCX
MOV qword ptr [RBP + -0x58],RAX
JMP 0x001e25b5
LAB_001e25b5:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x58]
JNC 0x001e25c9
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x70],RAX
JMP 0x001e25d1
LAB_001e25c9:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x70],RAX
LAB_001e25d1:
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x60],RAX
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x38]
MOV RDX,qword ptr [RBP + -0x60]
CALL 0x0012a090
MOV RCX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0x38]
MOV qword ptr [RAX + 0x38],RCX
MOV RCX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001e2628
MOV RAX,qword ptr [RBP + -0x38]
SUB RAX,qword ptr [RBP + -0x20]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],ECX
LAB_001e2628:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x38]
MOV RDX,qword ptr [RBP + -0x58]
SUB RDX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x68],RDX
CALL 0x0012a090
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
ADD RCX,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x38],RCX
MOV RCX,qword ptr [RBP + -0x48]
ADD RCX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
CALL 0x001e18c0
MOV RDX,qword ptr [RBP + -0x20]
XOR EAX,EAX
MOV ECX,0x1
CMP RDX,0x0
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
LAB_001e26be:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x70
POP RBP
RET
|
bool _my_b_seq_read(ulong *param_1,void *param_2,ulong param_3)
{
long lVar1;
ulong uVar2;
long lVar3;
size_t local_78;
ulong local_50;
ulong local_48;
ulong local_38;
ulong local_30;
ulong local_28;
void *local_20;
inline_mysql_mutex_lock
(param_1 + 10,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x54c);
local_50 = *param_1 + (param_1[3] - param_1[4]);
local_28 = param_3;
local_20 = param_2;
if (local_50 < param_1[1]) {
lVar3 = inline_mysql_file_seek
("/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x557,
*(int4 *)((long)param_1 + 0xd4),local_50,0,0);
if (lVar3 == -1) {
*(int4 *)((long)param_1 + 0xe4) = 0xffffffff;
inline_mysql_mutex_unlock(param_1 + 10);
return true;
}
*(int4 *)(param_1 + 0x1c) = 0;
local_38 = local_50 & 0xfff;
if (0x2000 - local_38 <= param_3) {
lVar3 = (param_3 & 0xfffff000) - local_38;
lVar1 = inline_mysql_file_read
("/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x569,
*(int4 *)((long)param_1 + 0xd4),param_2,lVar3,param_1[0x1f]);
if (lVar1 == -1) {
*(int4 *)((long)param_1 + 0xe4) = 0xffffffff;
inline_mysql_mutex_unlock(param_1 + 10);
return true;
}
local_28 = param_3 - lVar1;
local_20 = (void *)(lVar1 + (long)param_2);
local_50 = lVar1 + local_50;
if (lVar1 != lVar3) goto LAB_001e259c;
local_38 = 0;
}
local_48 = param_1[0x1e] - local_38;
if (param_1[1] - local_50 < local_48) {
local_48 = param_1[1] - local_50;
}
if (local_48 == 0) {
if (local_28 == 0) {
local_30 = 0;
LAB_001e253b:
inline_mysql_mutex_unlock(param_1 + 10);
param_1[2] = param_1[4] + local_28;
param_1[3] = param_1[4] + local_30;
*param_1 = local_50;
memcpy(local_20,(void *)param_1[4],local_28);
return false;
}
}
else {
local_30 = inline_mysql_file_read
("/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x589,
*(int4 *)((long)param_1 + 0xd4),param_1[4],local_48,param_1[0x1f])
;
if (local_30 == 0xffffffffffffffff) {
*(int4 *)((long)param_1 + 0xe4) = 0xffffffff;
inline_mysql_mutex_unlock(param_1 + 10);
return true;
}
if (local_28 <= local_30) goto LAB_001e253b;
memcpy(local_20,(void *)param_1[4],local_30);
local_28 = local_28 - local_30;
local_20 = (void *)(local_30 + (long)local_20);
local_50 = local_30 + local_50;
}
}
LAB_001e259c:
uVar2 = param_1[8] - param_1[7];
local_78 = uVar2;
if (local_28 < uVar2) {
local_78 = local_28;
}
memcpy(local_20,(void *)param_1[7],local_78);
param_1[7] = local_78 + param_1[7];
lVar3 = local_28 - local_78;
if (lVar3 != 0) {
*(int *)((long)param_1 + 0xe4) = (int)param_3 - (int)lVar3;
}
memcpy((void *)param_1[4],(void *)param_1[7],uVar2 - local_78);
param_1[2] = param_1[4];
param_1[3] = param_1[4] + (uVar2 - local_78);
param_1[7] = param_1[8];
*param_1 = local_50 + local_78;
param_1[1] = uVar2 + param_1[1];
inline_mysql_mutex_unlock(param_1 + 10);
return lVar3 != 0;
}
| |
45,697 | whitelist::matches(char const*, unsigned long) | untodesu[P]voxelius/game/server/whitelist.cc | bool whitelist::matches(const char *username, std::uint64_t password_hash)
{
const auto it = whitelist_map.find(username);
if(it == whitelist_map.cend()) {
// Not whitelisted, no match
return false;
}
if(it->second == password_hash)
return true;
return false;
} | O3 | cpp | whitelist::matches(char const*, unsigned long):
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %rsi
movq %rdi, (%rsi)
leaq 0xd4712(%rip), %rdi # 0x108e30
callq 0x35450
cmpl 0xd4727(%rip), %eax # 0x108e50
jne 0x3472f
xorl %eax, %eax
jmp 0x34744
cltq
movq 0xd4700(%rip), %rcx # 0x108e38
leaq (%rax,%rax,4), %rax
cmpq %rbx, 0x20(%rcx,%rax,8)
sete %al
addq $0x10, %rsp
popq %rbx
retq
| _ZN9whitelist7matchesEPKcm:
push rbx
sub rsp, 10h
mov rbx, rsi
lea rsi, [rsp+18h+var_10]
mov [rsi], rdi
lea rdi, _ZL13whitelist_mapB5cxx11; whitelist_map
call _ZNK7emhash87HashMapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEmSt4hashIS6_ESt8equal_toIS6_EE16find_filled_slotIPKcEEjRKT_; emhash8::HashMap<std::string,ulong,std::hash<std::string>,std::equal_to<std::string>>::find_filled_slot<char const*>(char const* const&)
cmp eax, dword ptr cs:xmmword_108E44+0Ch
jnz short loc_3472F
xor eax, eax
jmp short loc_34744
loc_3472F:
cdqe
mov rcx, qword ptr cs:_ZL13whitelist_mapB5cxx11+8; whitelist_map
lea rax, [rax+rax*4]
cmp [rcx+rax*8+20h], rbx
setz al
loc_34744:
add rsp, 10h
pop rbx
retn
| bool whitelist::matches(whitelist *this, const char *a2)
{
int filled; // eax
filled = emhash8::HashMap<std::string,unsigned long,std::hash<std::string>,std::equal_to<std::string>>::find_filled_slot<char const*>(&whitelist_map[abi:cxx11]);
return filled != HIDWORD(xmmword_108E44)
&& *(_QWORD *)(*((_QWORD *)&whitelist_map[abi:cxx11] + 1) + 40LL * filled + 32) == (_QWORD)a2;
}
| matches:
PUSH RBX
SUB RSP,0x10
MOV RBX,RSI
LEA RSI,[RSP + 0x8]
MOV qword ptr [RSI],RDI
LEA RDI,[0x208e30]
CALL 0x00135450
CMP EAX,dword ptr [0x00208e50]
JNZ 0x0013472f
XOR EAX,EAX
JMP 0x00134744
LAB_0013472f:
CDQE
MOV RCX,qword ptr [0x00208e38]
LEA RAX,[RAX + RAX*0x4]
CMP qword ptr [RCX + RAX*0x8 + 0x20],RBX
SETZ AL
LAB_00134744:
ADD RSP,0x10
POP RBX
RET
|
/* whitelist::matches(char const*, unsigned long) */
int8 whitelist::matches(char *param_1,ulong param_2)
{
uint uVar1;
int8 uVar2;
char *local_10;
local_10 = param_1;
uVar1 = emhash8::
HashMap<std::__cxx11::string,unsigned_long,std::hash<std::__cxx11::string>,std::equal_to<std::__cxx11::string>>
::find_filled_slot<char_const*>
((HashMap<std::__cxx11::string,unsigned_long,std::hash<std::__cxx11::string>,std::equal_to<std::__cxx11::string>>
*)whitelist_map_abi_cxx11_,&local_10);
if (uVar1 == whitelist_map_abi_cxx11_._32_4_) {
uVar2 = 0;
}
else {
uVar2 = CONCAT71((int7)((ulong)((long)(int)uVar1 * 5) >> 8),
*(ulong *)(whitelist_map_abi_cxx11_._8_8_ + 0x20 + (long)(int)uVar1 * 0x28) ==
param_2);
}
return uVar2;
}
| |
45,698 | my_readlink | eloqsql/mysys/my_symlink.c | int my_readlink(char *to, const char *filename, myf MyFlags)
{
#ifndef HAVE_READLINK
strmov(to,filename);
return 1;
#else
int result=0;
int length;
DBUG_ENTER("my_readlink");
if ((length=readlink(filename, to, FN_REFLEN-1)) < 0)
{
/* Don't give an error if this wasn't a symlink */
if ((my_errno=errno) == EINVAL)
{
result= 1;
strmov(to,filename);
}
else
{
if (MyFlags & MY_WME)
my_error(EE_CANT_READLINK, MYF(0), filename, errno);
result= -1;
}
}
else
to[length]=0;
DBUG_PRINT("exit" ,("result: %d", result));
DBUG_RETURN(result);
#endif /* HAVE_READLINK */
} | O3 | c | my_readlink:
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, %r14
movl $0x1ff, %edx # imm = 0x1FF
movq %rsi, %rdi
movq %r14, %rsi
callq 0x29260
testl %eax, %eax
js 0xa0cda
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movb $0x0, (%r14,%rax)
xorl %r14d, %r14d
jmp 0xa0d27
callq 0x297b0
movq %rax, %r12
movl (%rax), %r13d
callq 0xa1afa
movl %r13d, (%rax)
cmpl $0x16, %r13d
jne 0xa0d06
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29360
movl $0x1, %r14d
jmp 0xa0d27
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
testb $0x10, %r15b
je 0xa0d27
movl (%r12), %ecx
movl $0x18, %edi
xorl %esi, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x9e1af
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_readlink:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rdx
mov rbx, rsi
mov r14, rdi
mov edx, 1FFh
mov rdi, rsi
mov rsi, r14
call _readlink
test eax, eax
js short loc_A0CDA
and eax, 7FFFFFFFh
mov byte ptr [r14+rax], 0
xor r14d, r14d
jmp short loc_A0D27
loc_A0CDA:
call ___errno_location
mov r12, rax
mov r13d, [rax]
call _my_thread_var
mov [rax], r13d
cmp r13d, 16h
jnz short loc_A0D06
mov rdi, r14
mov rsi, rbx
call _strcpy
mov r14d, 1
jmp short loc_A0D27
loc_A0D06:
mov r14d, 0FFFFFFFFh
test r15b, 10h
jz short loc_A0D27
mov ecx, [r12]
mov edi, 18h
xor esi, esi
mov rdx, rbx
xor eax, eax
call my_error
loc_A0D27:
mov eax, r14d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_readlink(const char *a1, long long a2, char a3)
{
int v4; // eax
unsigned int v5; // r14d
unsigned int *v6; // r12
unsigned int v7; // r13d
v4 = readlink(a2, a1, 511LL);
if ( v4 < 0 )
{
v6 = (unsigned int *)__errno_location(a2);
v7 = *v6;
*(_DWORD *)my_thread_var(a2, a1) = v7;
if ( v7 == 22 )
{
strcpy(a1, a2);
return 1;
}
else
{
v5 = -1;
if ( (a3 & 0x10) != 0 )
my_error(0x18u, 0LL, a2, *v6);
}
}
else
{
a1[v4 & 0x7FFFFFFF] = 0;
return 0;
}
return v5;
}
| my_readlink:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV RBX,RSI
MOV R14,RDI
MOV EDX,0x1ff
MOV RDI,RSI
MOV RSI,R14
CALL 0x00129260
TEST EAX,EAX
JS 0x001a0cda
AND EAX,0x7fffffff
MOV byte ptr [R14 + RAX*0x1],0x0
XOR R14D,R14D
JMP 0x001a0d27
LAB_001a0cda:
CALL 0x001297b0
MOV R12,RAX
MOV R13D,dword ptr [RAX]
CALL 0x001a1afa
MOV dword ptr [RAX],R13D
CMP R13D,0x16
JNZ 0x001a0d06
MOV RDI,R14
MOV RSI,RBX
CALL 0x00129360
MOV R14D,0x1
JMP 0x001a0d27
LAB_001a0d06:
MOV R14D,0xffffffff
TEST R15B,0x10
JZ 0x001a0d27
MOV ECX,dword ptr [R12]
MOV EDI,0x18
XOR ESI,ESI
MOV RDX,RBX
XOR EAX,EAX
CALL 0x0019e1af
LAB_001a0d27:
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 my_readlink(char *param_1,char *param_2,ulong param_3)
{
int iVar1;
ssize_t sVar2;
int *piVar3;
int *piVar4;
int8 uVar5;
sVar2 = readlink(param_2,param_1,0x1ff);
if ((int)(uint)sVar2 < 0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar1;
if (iVar1 == 0x16) {
strcpy(param_1,param_2);
uVar5 = 1;
}
else {
uVar5 = 0xffffffff;
if ((param_3 & 0x10) != 0) {
my_error(0x18,0,param_2,*piVar3);
}
}
}
else {
param_1[(uint)sVar2 & 0x7fffffff] = '\0';
uVar5 = 0;
}
return uVar5;
}
| |
45,699 | test_debug_example | eloqsql/tests/mysql_client_test.c | static void test_debug_example()
{
int rc;
MYSQL_RES *result;
myheader("test_debug_example");
rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_debug_example");
myquery(rc);
rc= mysql_query(mysql, "CREATE TABLE test_debug_example("
"id INT PRIMARY KEY AUTO_INCREMENT, "
"name VARCHAR(20), xxx INT)");
myquery(rc);
rc= mysql_query(mysql, "INSERT INTO test_debug_example (name) "
"VALUES ('mysql')");
myquery(rc);
rc= mysql_query(mysql, "UPDATE test_debug_example SET name='updated' "
"WHERE name='deleted'");
myquery(rc);
rc= mysql_query(mysql, "SELECT * FROM test_debug_example where name='mysql'");
myquery(rc);
result= mysql_use_result(mysql);
mytest(result);
(void) my_process_result_set(result);
mysql_free_result(result);
rc= mysql_query(mysql, "DROP TABLE test_debug_example");
myquery(rc);
} | O3 | c | test_debug_example:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpb $0x1, 0x3d23c4(%rip) # 0x41a4c1
jg 0x48178
movq 0x357eba(%rip), %rbx # 0x39ffc0
movq (%rbx), %rdi
leaq 0x973b4(%rip), %rdx # 0xdf4c4
movl $0x1, %esi
xorl %eax, %eax
callq 0x39240
movq (%rbx), %rdi
movl 0x3d25e7(%rip), %ecx # 0x41a70c
leal 0x1(%rcx), %eax
movl %eax, 0x3d25de(%rip) # 0x41a70c
movl 0x3d25d3(%rip), %r8d # 0x41a708
movl 0x3d23b0(%rip), %r9d # 0x41a4ec
leaq 0x9c074(%rip), %rax # 0xe41b7
movq %rax, (%rsp)
leaq 0x9867e(%rip), %rdx # 0xe07cc
movl $0x1, %esi
xorl %eax, %eax
callq 0x39240
movq (%rbx), %rdi
leaq 0x97398(%rip), %rdx # 0xdf4fc
movl $0x1, %esi
xorl %eax, %eax
callq 0x39240
movq (%rbx), %rdi
callq 0x394b0
movq 0x3d2349(%rip), %rdi # 0x41a4c8
leaq 0x9bef3(%rip), %rsi # 0xe4079
callq 0x3b116
testl %eax, %eax
jne 0x48249
movq 0x3d232e(%rip), %rdi # 0x41a4c8
leaq 0x9bf00(%rip), %rsi # 0xe40a1
callq 0x3b116
testl %eax, %eax
jne 0x48268
movq 0x3d2313(%rip), %rdi # 0x41a4c8
leaq 0x9bf43(%rip), %rsi # 0xe40ff
callq 0x3b116
testl %eax, %eax
jne 0x48287
movq 0x3d22f8(%rip), %rdi # 0x41a4c8
leaq 0x9bf5f(%rip), %rsi # 0xe4136
callq 0x3b116
testl %eax, %eax
jne 0x482a6
movq 0x3d22dd(%rip), %rdi # 0x41a4c8
leaq 0x9bf86(%rip), %rsi # 0xe4178
callq 0x3b116
testl %eax, %eax
jne 0x482c5
movq 0x3d22c2(%rip), %rdi # 0x41a4c8
callq 0x8a68c
testq %rax, %rax
je 0x482e4
movq %rax, %rbx
movq %rax, %rdi
callq 0x3c0fe
movq %rbx, %rdi
callq 0x3b00f
movq 0x3d229a(%rip), %rdi # 0x41a4c8
leaq 0x9bf77(%rip), %rsi # 0xe41ac
callq 0x3b116
testl %eax, %eax
jne 0x48303
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %edi, %edi
callq 0x3ba57
leaq 0x96b55(%rip), %rdi # 0xdedac
leaq 0xace61(%rip), %rdx # 0xf50bf
movl $0x9b, %esi
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x96b36(%rip), %rdi # 0xdedac
leaq 0xace42(%rip), %rdx # 0xf50bf
movl $0xa0, %esi
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x96b17(%rip), %rdi # 0xdedac
leaq 0xace23(%rip), %rdx # 0xf50bf
movl $0xa4, %esi
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x96af8(%rip), %rdi # 0xdedac
leaq 0xace04(%rip), %rdx # 0xf50bf
movl $0xa8, %esi
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x96ad9(%rip), %rdi # 0xdedac
leaq 0xacde5(%rip), %rdx # 0xf50bf
movl $0xab, %esi
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x96aba(%rip), %rdi # 0xdedac
leaq 0x96883(%rip), %rdx # 0xdeb7c
movl $0xae, %esi
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x96a9b(%rip), %rdi # 0xdedac
leaq 0xacda7(%rip), %rdx # 0xf50bf
movl $0xb4, %esi
callq 0x3bb30
| test_debug_example:
push rbp
mov rbp, rsp
push rbx
push rax
cmp cs:opt_silent, 1
jg short loc_48178
mov rbx, cs:stdout_ptr
mov rdi, [rbx]
lea rdx, asc_DF4C4; "\n\n###################################"...
mov esi, 1
xor eax, eax
call ___fprintf_chk
mov rdi, [rbx]
mov ecx, cs:test_count
lea eax, [rcx+1]
mov cs:test_count, eax
mov r8d, cs:iter_count
mov r9d, cs:opt_count
lea rax, aDropTableTestD+0Bh; "test_debug_example"
mov [rsp+10h+var_10], rax
lea rdx, aUOfUUS; "%u of (%u/%u): %s"
mov esi, 1
xor eax, eax
call ___fprintf_chk
mov rdi, [rbx]
lea rdx, asc_DF4FC; " \n###################################"...
mov esi, 1
xor eax, eax
call ___fprintf_chk
mov rdi, [rbx]
call _fflush
loc_48178:
mov rdi, cs:mysql
lea rsi, aDropTableIfExi_16; "DROP TABLE IF EXISTS test_debug_example"
call wrap_mysql_query
test eax, eax
jnz loc_48249
mov rdi, cs:mysql
lea rsi, aCreateTableTes_22; "CREATE TABLE test_debug_example(id INT "...
call wrap_mysql_query
test eax, eax
jnz loc_48268
mov rdi, cs:mysql
lea rsi, aInsertIntoTest_16; "INSERT INTO test_debug_example (name) V"...
call wrap_mysql_query
test eax, eax
jnz loc_48287
mov rdi, cs:mysql
lea rsi, aUpdateTestDebu; "UPDATE test_debug_example SET name='upd"...
call wrap_mysql_query
test eax, eax
jnz loc_482A6
mov rdi, cs:mysql
lea rsi, aSelectFromTest_9; "SELECT * FROM test_debug_example where "...
call wrap_mysql_query
test eax, eax
jnz loc_482C5
mov rdi, cs:mysql
call mysql_use_result
test rax, rax
jz loc_482E4
mov rbx, rax
mov rdi, rax
call my_process_result_set
mov rdi, rbx
call wrap_mysql_free_result
mov rdi, cs:mysql
lea rsi, aDropTableTestD; "DROP TABLE test_debug_example"
call wrap_mysql_query
test eax, eax
jnz loc_48303
add rsp, 8
pop rbx
pop rbp
retn
loc_48249:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 9Bh
call die
loc_48268:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 0A0h
call die
loc_48287:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 0A4h
call die
loc_482A6:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 0A8h
call die
loc_482C5:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 0ABh
call die
loc_482E4:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aFalse; "FALSE"
mov esi, 0AEh
call die
loc_48303:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 0B4h
call die
| long long test_debug_example()
{
int v0; // ecx
long long v1; // rax
long long v2; // rbx
long long result; // rax
if ( opt_silent <= 1 )
{
__fprintf_chk(stdout, 1LL, "\n\n#####################################\n");
v0 = test_count++;
__fprintf_chk(stdout, 1LL, "%u of (%u/%u): %s", v0, iter_count, opt_count, "test_debug_example");
__fprintf_chk(stdout, 1LL, " \n#####################################\n");
fflush(stdout);
}
if ( (unsigned int)wrap_mysql_query(mysql, (long long)"DROP TABLE IF EXISTS test_debug_example") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 155, "r == 0");
}
if ( (unsigned int)wrap_mysql_query(
mysql,
(long long)"CREATE TABLE test_debug_example(id INT PRIMARY KEY AUTO_INCREMENT, name VARCHAR(20), xxx INT)") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 160, "r == 0");
}
if ( (unsigned int)wrap_mysql_query(mysql, (long long)"INSERT INTO test_debug_example (name) VALUES ('mysql')") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 164, "r == 0");
}
if ( (unsigned int)wrap_mysql_query(
mysql,
(long long)"UPDATE test_debug_example SET name='updated' WHERE name='deleted'") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 168, "r == 0");
}
if ( (unsigned int)wrap_mysql_query(mysql, (long long)"SELECT * FROM test_debug_example where name='mysql'") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 171, "r == 0");
}
v1 = mysql_use_result(mysql);
if ( !v1 )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 174, "FALSE");
}
v2 = v1;
my_process_result_set(v1);
wrap_mysql_free_result(v2);
result = wrap_mysql_query(mysql, (long long)"DROP TABLE test_debug_example");
if ( (_DWORD)result )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 180, "r == 0");
}
return result;
}
| test_debug_example:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
CMP byte ptr [0x0051a4c1],0x1
JG 0x00148178
MOV RBX,qword ptr [0x0049ffc0]
MOV RDI,qword ptr [RBX]
LEA RDX,[0x1df4c4]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x00139240
MOV RDI,qword ptr [RBX]
MOV ECX,dword ptr [0x0051a70c]
LEA EAX,[RCX + 0x1]
MOV dword ptr [0x0051a70c],EAX
MOV R8D,dword ptr [0x0051a708]
MOV R9D,dword ptr [0x0051a4ec]
LEA RAX,[0x1e41b7]
MOV qword ptr [RSP],RAX
LEA RDX,[0x1e07cc]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x00139240
MOV RDI,qword ptr [RBX]
LEA RDX,[0x1df4fc]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x00139240
MOV RDI,qword ptr [RBX]
CALL 0x001394b0
LAB_00148178:
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1e4079]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x00148249
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1e40a1]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x00148268
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1e40ff]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x00148287
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1e4136]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x001482a6
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1e4178]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x001482c5
MOV RDI,qword ptr [0x0051a4c8]
CALL 0x0018a68c
TEST RAX,RAX
JZ 0x001482e4
MOV RBX,RAX
MOV RDI,RAX
CALL 0x0013c0fe
MOV RDI,RBX
CALL 0x0013b00f
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1e41ac]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x00148303
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_00148249:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0x9b
CALL 0x0013bb30
LAB_00148268:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0xa0
CALL 0x0013bb30
LAB_00148287:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0xa4
CALL 0x0013bb30
LAB_001482a6:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0xa8
CALL 0x0013bb30
LAB_001482c5:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0xab
CALL 0x0013bb30
LAB_001482e4:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1deb7c]
MOV ESI,0xae
CALL 0x0013bb30
LAB_00148303:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0xb4
CALL 0x0013bb30
|
void test_debug_example(void)
{
int *puVar1;
int iVar2;
long lVar3;
puVar1 = PTR_stdout_0049ffc0;
if (opt_silent < '\x02') {
__fprintf_chk(*(int8 *)PTR_stdout_0049ffc0,1,"\n\n#####################################\n"
);
iVar2 = test_count;
test_count = test_count + 1;
__fprintf_chk(*(int8 *)puVar1,1,"%u of (%u/%u): %s",iVar2,iter_count,opt_count,
"test_debug_example");
__fprintf_chk(*(int8 *)puVar1,1," \n#####################################\n");
fflush(*(FILE **)puVar1);
}
iVar2 = wrap_mysql_query(mysql,"DROP TABLE IF EXISTS test_debug_example");
if (iVar2 != 0) {
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x9b,"r == 0");
}
iVar2 = wrap_mysql_query(mysql,
"CREATE TABLE test_debug_example(id INT PRIMARY KEY AUTO_INCREMENT, name VARCHAR(20), xxx INT)"
);
if (iVar2 != 0) {
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0xa0,"r == 0");
}
iVar2 = wrap_mysql_query(mysql,"INSERT INTO test_debug_example (name) VALUES (\'mysql\')");
if (iVar2 != 0) {
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0xa4,"r == 0");
}
iVar2 = wrap_mysql_query(mysql,
"UPDATE test_debug_example SET name=\'updated\' WHERE name=\'deleted\'");
if (iVar2 != 0) {
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0xa8,"r == 0");
}
iVar2 = wrap_mysql_query(mysql,"SELECT * FROM test_debug_example where name=\'mysql\'");
if (iVar2 != 0) {
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0xab,"r == 0");
}
lVar3 = mysql_use_result(mysql);
if (lVar3 == 0) {
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0xae,"FALSE");
}
my_process_result_set(lVar3);
wrap_mysql_free_result(lVar3);
iVar2 = wrap_mysql_query(mysql,"DROP TABLE test_debug_example");
if (iVar2 == 0) {
return;
}
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0xb4,"r == 0");
}
|
Subsets and Splits
C++ Functions With Standard Library Dependencies
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++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
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.