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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
38,600 | MatrixDeterminant | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/raymath.h | RMAPI float MatrixDeterminant(Matrix mat)
{
float result = 0.0f;
// Cache the matrix values (speed optimization)
float a00 = mat.m0, a01 = mat.m1, a02 = mat.m2, a03 = mat.m3;
float a10 = mat.m4, a11 = mat.m5, a12 = mat.m6, a13 = mat.m7;
float a20 = mat.m8, a21 = mat.m9, a22 = mat.m10, a23 = mat.m11;
float a30 = mat.m12, a31 = mat.m13, a32 = mat.m14, a33 = mat.m15;
result = a30*a21*a12*a03 - a20*a31*a12*a03 - a30*a11*a22*a03 + a10*a31*a22*a03 +
a20*a11*a32*a03 - a10*a21*a32*a03 - a30*a21*a02*a13 + a20*a31*a02*a13 +
a30*a01*a22*a13 - a00*a31*a22*a13 - a20*a01*a32*a13 + a00*a21*a32*a13 +
a30*a11*a02*a23 - a10*a31*a02*a23 - a30*a01*a12*a23 + a00*a31*a12*a23 +
a10*a01*a32*a23 - a00*a11*a32*a23 - a20*a11*a02*a33 + a10*a21*a02*a33 +
a20*a01*a12*a33 - a00*a21*a12*a33 - a10*a01*a22*a33 + a00*a11*a22*a33;
return result;
} | O2 | c | MatrixDeterminant:
movss 0x18(%rsp), %xmm3
movss 0x8(%rsp), %xmm5
movss 0xc(%rsp), %xmm7
movss 0x1c(%rsp), %xmm13
movss 0x10(%rsp), %xmm6
movss 0x20(%rsp), %xmm0
movss 0x30(%rsp), %xmm8
movss 0x14(%rsp), %xmm2
movss 0x24(%rsp), %xmm9
movaps %xmm0, %xmm4
movaps %xmm0, %xmm1
mulss %xmm2, %xmm4
movss %xmm4, -0x18(%rsp)
movaps %xmm6, %xmm0
mulss %xmm9, %xmm0
movaps %xmm0, %xmm4
movss %xmm0, -0x10(%rsp)
movss %xmm7, -0x20(%rsp)
movaps %xmm7, %xmm0
mulss %xmm9, %xmm0
movss %xmm0, -0x4(%rsp)
movaps %xmm13, %xmm14
mulss %xmm1, %xmm7
movss %xmm7, -0x14(%rsp)
mulss %xmm5, %xmm9
mulss %xmm5, %xmm1
mulss %xmm13, %xmm5
movss %xmm5, -0x1c(%rsp)
movaps %xmm2, %xmm10
mulss %xmm2, %xmm13
mulss %xmm6, %xmm14
movss %xmm14, -0xc(%rsp)
mulss %xmm3, %xmm10
movaps %xmm8, %xmm15
mulss %xmm10, %xmm15
movaps %xmm8, %xmm11
mulss %xmm9, %xmm11
mulss %xmm3, %xmm6
movss 0x34(%rsp), %xmm5
movaps %xmm5, %xmm7
mulss %xmm6, %xmm7
movss 0x2c(%rsp), %xmm2
mulss %xmm2, %xmm10
mulss %xmm2, %xmm9
mulss %xmm2, %xmm6
movaps %xmm1, %xmm12
mulss %xmm2, %xmm1
movss %xmm1, -0x8(%rsp)
movaps %xmm2, %xmm1
mulss -0x18(%rsp), %xmm2
mulss %xmm4, %xmm1
movss 0x38(%rsp), %xmm4
mulss %xmm4, %xmm1
mulss %xmm4, %xmm2
subss %xmm1, %xmm2
movaps %xmm8, %xmm1
mulss %xmm13, %xmm1
mulss %xmm4, %xmm1
subss %xmm1, %xmm2
movaps %xmm3, %xmm0
mulss -0x20(%rsp), %xmm0
movaps %xmm0, %xmm3
mulss %xmm8, %xmm0
movss %xmm0, -0x20(%rsp)
movaps %xmm14, %xmm1
mulss %xmm5, %xmm1
mulss %xmm5, %xmm12
mulss %xmm5, %xmm3
movaps %xmm5, %xmm14
movss -0x1c(%rsp), %xmm0
mulss %xmm0, %xmm5
mulss %xmm8, %xmm0
movss %xmm0, -0x1c(%rsp)
movaps %xmm8, %xmm0
movss -0x4(%rsp), %xmm8
mulss %xmm8, %xmm0
mulss %xmm4, %xmm0
addss %xmm2, %xmm0
mulss %xmm4, %xmm1
addss %xmm0, %xmm1
mulss -0x14(%rsp), %xmm14
mulss %xmm4, %xmm14
subss %xmm14, %xmm1
movss 0x28(%rsp), %xmm2
movss -0x18(%rsp), %xmm4
mulss %xmm2, %xmm4
movss 0x3c(%rsp), %xmm0
mulss %xmm0, %xmm4
subss %xmm4, %xmm1
movss -0x10(%rsp), %xmm4
mulss %xmm2, %xmm4
mulss %xmm0, %xmm4
addss %xmm1, %xmm4
mulss %xmm0, %xmm15
addss %xmm4, %xmm15
mulss %xmm0, %xmm11
subss %xmm11, %xmm15
mulss %xmm0, %xmm7
subss %xmm7, %xmm15
mulss %xmm0, %xmm12
addss %xmm15, %xmm12
movss 0x40(%rsp), %xmm0
mulss %xmm2, %xmm13
mulss %xmm0, %xmm13
addss %xmm12, %xmm13
movaps %xmm8, %xmm1
mulss %xmm2, %xmm1
mulss %xmm0, %xmm1
subss %xmm1, %xmm13
mulss %xmm0, %xmm10
subss %xmm10, %xmm13
mulss %xmm0, %xmm9
addss %xmm13, %xmm9
mulss %xmm0, %xmm3
addss %xmm9, %xmm3
mulss %xmm0, %xmm5
subss %xmm5, %xmm3
movss 0x44(%rsp), %xmm1
movss -0xc(%rsp), %xmm0
mulss %xmm2, %xmm0
mulss %xmm1, %xmm0
subss %xmm0, %xmm3
movss -0x14(%rsp), %xmm0
mulss %xmm2, %xmm0
mulss %xmm1, %xmm0
addss %xmm3, %xmm0
mulss %xmm1, %xmm6
addss %xmm0, %xmm6
movss -0x8(%rsp), %xmm0
mulss %xmm1, %xmm0
subss %xmm0, %xmm6
movss -0x20(%rsp), %xmm0
mulss %xmm1, %xmm0
subss %xmm0, %xmm6
movss -0x1c(%rsp), %xmm0
mulss %xmm1, %xmm0
addss %xmm6, %xmm0
retq
| MatrixDeterminant:
movss xmm3, [rsp+arg_10]
movss xmm5, [rsp+arg_0]
movss xmm7, [rsp+arg_4]
movss xmm13, [rsp+arg_14]
movss xmm6, [rsp+arg_8]
movss xmm0, [rsp+arg_18]
movss xmm8, [rsp+arg_28]
movss xmm2, [rsp+arg_C]
movss xmm9, [rsp+arg_1C]
movaps xmm4, xmm0
movaps xmm1, xmm0
mulss xmm4, xmm2
movss [rsp+var_18], xmm4
movaps xmm0, xmm6
mulss xmm0, xmm9
movaps xmm4, xmm0
movss [rsp+var_10], xmm0
movss [rsp+var_20], xmm7
movaps xmm0, xmm7
mulss xmm0, xmm9
movss [rsp+var_4], xmm0
movaps xmm14, xmm13
mulss xmm7, xmm1
movss [rsp+var_14], xmm7
mulss xmm9, xmm5
mulss xmm1, xmm5
mulss xmm5, xmm13
movss [rsp+var_1C], xmm5
movaps xmm10, xmm2
mulss xmm13, xmm2
mulss xmm14, xmm6
movss [rsp+var_C], xmm14
mulss xmm10, xmm3
movaps xmm15, xmm8
mulss xmm15, xmm10
movaps xmm11, xmm8
mulss xmm11, xmm9
mulss xmm6, xmm3
movss xmm5, [rsp+arg_2C]
movaps xmm7, xmm5
mulss xmm7, xmm6
movss xmm2, [rsp+arg_24]
mulss xmm10, xmm2
mulss xmm9, xmm2
mulss xmm6, xmm2
movaps xmm12, xmm1
mulss xmm1, xmm2
movss [rsp+var_8], xmm1
movaps xmm1, xmm2
mulss xmm2, [rsp+var_18]
mulss xmm1, xmm4
movss xmm4, [rsp+arg_30]
mulss xmm1, xmm4
mulss xmm2, xmm4
subss xmm2, xmm1
movaps xmm1, xmm8
mulss xmm1, xmm13
mulss xmm1, xmm4
subss xmm2, xmm1
movaps xmm0, xmm3
mulss xmm0, [rsp+var_20]
movaps xmm3, xmm0
mulss xmm0, xmm8
movss [rsp+var_20], xmm0
movaps xmm1, xmm14
mulss xmm1, xmm5
mulss xmm12, xmm5
mulss xmm3, xmm5
movaps xmm14, xmm5
movss xmm0, [rsp+var_1C]
mulss xmm5, xmm0
mulss xmm0, xmm8
movss [rsp+var_1C], xmm0
movaps xmm0, xmm8
movss xmm8, [rsp+var_4]
mulss xmm0, xmm8
mulss xmm0, xmm4
addss xmm0, xmm2
mulss xmm1, xmm4
addss xmm1, xmm0
mulss xmm14, [rsp+var_14]
mulss xmm14, xmm4
subss xmm1, xmm14
movss xmm2, [rsp+arg_20]
movss xmm4, [rsp+var_18]
mulss xmm4, xmm2
movss xmm0, [rsp+arg_34]
mulss xmm4, xmm0
subss xmm1, xmm4
movss xmm4, [rsp+var_10]
mulss xmm4, xmm2
mulss xmm4, xmm0
addss xmm4, xmm1
mulss xmm15, xmm0
addss xmm15, xmm4
mulss xmm11, xmm0
subss xmm15, xmm11
mulss xmm7, xmm0
subss xmm15, xmm7
mulss xmm12, xmm0
addss xmm12, xmm15
movss xmm0, [rsp+arg_38]
mulss xmm13, xmm2
mulss xmm13, xmm0
addss xmm13, xmm12
movaps xmm1, xmm8
mulss xmm1, xmm2
mulss xmm1, xmm0
subss xmm13, xmm1
mulss xmm10, xmm0
subss xmm13, xmm10
mulss xmm9, xmm0
addss xmm9, xmm13
mulss xmm3, xmm0
addss xmm3, xmm9
mulss xmm5, xmm0
subss xmm3, xmm5
movss xmm1, [rsp+arg_3C]
movss xmm0, [rsp+var_C]
mulss xmm0, xmm2
mulss xmm0, xmm1
subss xmm3, xmm0
movss xmm0, [rsp+var_14]
mulss xmm0, xmm2
mulss xmm0, xmm1
addss xmm0, xmm3
mulss xmm6, xmm1
addss xmm6, xmm0
movss xmm0, [rsp+var_8]
mulss xmm0, xmm1
subss xmm6, xmm0
movss xmm0, [rsp+var_20]
mulss xmm0, xmm1
subss xmm6, xmm0
movss xmm0, [rsp+var_1C]
mulss xmm0, xmm1
addss xmm0, xmm6
retn
| float MatrixDeterminant(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7,
long long a8,
long long a9,
long long a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
return (float)((float)((float)(*(float *)&a7 * *((float *)&a9 + 1)) * *(float *)&a12) * *((float *)&a14 + 1))
+ (float)((float)((float)((float)((float)((float)(*(float *)&a8 * *(float *)&a9) * *((float *)&a11 + 1))
* *((float *)&a14 + 1))
+ (float)((float)((float)((float)(*((float *)&a7 + 1) * *(float *)&a10) * *(float *)&a11)
* *((float *)&a14 + 1))
+ (float)((float)((float)((float)((float)((float)(*(float *)&a9
* *((float *)&a7 + 1))
* *((float *)&a12 + 1))
* *(float *)&a14)
+ (float)((float)((float)((float)(*((float *)&a10 + 1)
* *(float *)&a7)
* *((float *)&a11 + 1))
* *(float *)&a14)
+ (float)((float)((float)((float)((float)((float)(*((float *)&a9 + 1) * *((float *)&a8 + 1)) * *(float *)&a11) * *(float *)&a14)
+ (float)((float)((float)((float)(*(float *)&a10 * *(float *)&a7) * *((float *)&a12 + 1)) * *((float *)&a13 + 1)) + (float)((float)((float)((float)((float)(*(float *)&a12 * (float)(*((float *)&a8 + 1) * *(float *)&a9)) * *((float *)&a13 + 1)) + (float)((float)((float)((float)(*(float *)&a8 * *((float *)&a10 + 1)) * *(float *)&a11) * *((float *)&a13 + 1)) + (float)((float)((float)((float)((float)((float)(*((float *)&a9 + 1) * *(float *)&a8) * *((float *)&a12 + 1)) * *(float *)&a13) + (float)((float)((float)(*(float *)&a12 * (float)(*((float *)&a7 + 1) * *((float *)&a10 + 1))) * *(float *)&a13) + (float)((float)((float)((float)(*((float *)&a11 + 1) * (float)(*(float *)&a10 * *((float *)&a8 + 1))) * *(float *)&a13) - (float)((float)(*((float *)&a11 + 1) * (float)(*(float *)&a8 * *((float *)&a10 + 1))) * *(float *)&a13)) - (float)((float)(*(float *)&a12 * (float)(*((float *)&a9 + 1) * *((float *)&a8 + 1))) * *(float *)&a13)))) - (float)((float)(*((float *)&a12 + 1) * (float)(*((float *)&a7 + 1) * *(float *)&a10)) * *(float *)&a13)) - (float)((float)((float)(*(float *)&a10 * *((float *)&a8 + 1)) * *(float *)&a11) * *((float *)&a13 + 1))))) - (float)((float)(*(float *)&a12 * (float)(*((float *)&a10 + 1) * *(float *)&a7)) * *((float *)&a13 + 1))) - (float)((float)(*((float *)&a12 + 1) * (float)(*(float *)&a8 * *(float *)&a9)) * *((float *)&a13 + 1)))))
- (float)((float)((float)(*((float *)&a7 + 1) * *((float *)&a10 + 1)) * *(float *)&a11)
* *(float *)&a14))
- (float)((float)((float)(*((float *)&a8 + 1) * *(float *)&a9)
* *((float *)&a11 + 1))
* *(float *)&a14))))
- (float)((float)(*((float *)&a12 + 1)
* (float)(*(float *)&a7 * *((float *)&a9 + 1)))
* *(float *)&a14))
- (float)((float)((float)(*((float *)&a9 + 1) * *(float *)&a8)
* *(float *)&a11)
* *((float *)&a14 + 1)))))
- (float)((float)((float)(*(float *)&a10 * *(float *)&a7) * *((float *)&a11 + 1))
* *((float *)&a14 + 1)))
- (float)((float)((float)(*(float *)&a9 * *((float *)&a7 + 1)) * *(float *)&a12) * *((float *)&a14 + 1)));
}
| MatrixDeterminant:
MOVSS XMM3,dword ptr [RSP + 0x18]
MOVSS XMM5,dword ptr [RSP + 0x8]
MOVSS XMM7,dword ptr [RSP + 0xc]
MOVSS XMM13,dword ptr [RSP + 0x1c]
MOVSS XMM6,dword ptr [RSP + 0x10]
MOVSS XMM0,dword ptr [RSP + 0x20]
MOVSS XMM8,dword ptr [RSP + 0x30]
MOVSS XMM2,dword ptr [RSP + 0x14]
MOVSS XMM9,dword ptr [RSP + 0x24]
MOVAPS XMM4,XMM0
MOVAPS XMM1,XMM0
MULSS XMM4,XMM2
MOVSS dword ptr [RSP + -0x18],XMM4
MOVAPS XMM0,XMM6
MULSS XMM0,XMM9
MOVAPS XMM4,XMM0
MOVSS dword ptr [RSP + -0x10],XMM0
MOVSS dword ptr [RSP + -0x20],XMM7
MOVAPS XMM0,XMM7
MULSS XMM0,XMM9
MOVSS dword ptr [RSP + -0x4],XMM0
MOVAPS XMM14,XMM13
MULSS XMM7,XMM1
MOVSS dword ptr [RSP + -0x14],XMM7
MULSS XMM9,XMM5
MULSS XMM1,XMM5
MULSS XMM5,XMM13
MOVSS dword ptr [RSP + -0x1c],XMM5
MOVAPS XMM10,XMM2
MULSS XMM13,XMM2
MULSS XMM14,XMM6
MOVSS dword ptr [RSP + -0xc],XMM14
MULSS XMM10,XMM3
MOVAPS XMM15,XMM8
MULSS XMM15,XMM10
MOVAPS XMM11,XMM8
MULSS XMM11,XMM9
MULSS XMM6,XMM3
MOVSS XMM5,dword ptr [RSP + 0x34]
MOVAPS XMM7,XMM5
MULSS XMM7,XMM6
MOVSS XMM2,dword ptr [RSP + 0x2c]
MULSS XMM10,XMM2
MULSS XMM9,XMM2
MULSS XMM6,XMM2
MOVAPS XMM12,XMM1
MULSS XMM1,XMM2
MOVSS dword ptr [RSP + -0x8],XMM1
MOVAPS XMM1,XMM2
MULSS XMM2,dword ptr [RSP + -0x18]
MULSS XMM1,XMM4
MOVSS XMM4,dword ptr [RSP + 0x38]
MULSS XMM1,XMM4
MULSS XMM2,XMM4
SUBSS XMM2,XMM1
MOVAPS XMM1,XMM8
MULSS XMM1,XMM13
MULSS XMM1,XMM4
SUBSS XMM2,XMM1
MOVAPS XMM0,XMM3
MULSS XMM0,dword ptr [RSP + -0x20]
MOVAPS XMM3,XMM0
MULSS XMM0,XMM8
MOVSS dword ptr [RSP + -0x20],XMM0
MOVAPS XMM1,XMM14
MULSS XMM1,XMM5
MULSS XMM12,XMM5
MULSS XMM3,XMM5
MOVAPS XMM14,XMM5
MOVSS XMM0,dword ptr [RSP + -0x1c]
MULSS XMM5,XMM0
MULSS XMM0,XMM8
MOVSS dword ptr [RSP + -0x1c],XMM0
MOVAPS XMM0,XMM8
MOVSS XMM8,dword ptr [RSP + -0x4]
MULSS XMM0,XMM8
MULSS XMM0,XMM4
ADDSS XMM0,XMM2
MULSS XMM1,XMM4
ADDSS XMM1,XMM0
MULSS XMM14,dword ptr [RSP + -0x14]
MULSS XMM14,XMM4
SUBSS XMM1,XMM14
MOVSS XMM2,dword ptr [RSP + 0x28]
MOVSS XMM4,dword ptr [RSP + -0x18]
MULSS XMM4,XMM2
MOVSS XMM0,dword ptr [RSP + 0x3c]
MULSS XMM4,XMM0
SUBSS XMM1,XMM4
MOVSS XMM4,dword ptr [RSP + -0x10]
MULSS XMM4,XMM2
MULSS XMM4,XMM0
ADDSS XMM4,XMM1
MULSS XMM15,XMM0
ADDSS XMM15,XMM4
MULSS XMM11,XMM0
SUBSS XMM15,XMM11
MULSS XMM7,XMM0
SUBSS XMM15,XMM7
MULSS XMM12,XMM0
ADDSS XMM12,XMM15
MOVSS XMM0,dword ptr [RSP + 0x40]
MULSS XMM13,XMM2
MULSS XMM13,XMM0
ADDSS XMM13,XMM12
MOVAPS XMM1,XMM8
MULSS XMM1,XMM2
MULSS XMM1,XMM0
SUBSS XMM13,XMM1
MULSS XMM10,XMM0
SUBSS XMM13,XMM10
MULSS XMM9,XMM0
ADDSS XMM9,XMM13
MULSS XMM3,XMM0
ADDSS XMM3,XMM9
MULSS XMM5,XMM0
SUBSS XMM3,XMM5
MOVSS XMM1,dword ptr [RSP + 0x44]
MOVSS XMM0,dword ptr [RSP + -0xc]
MULSS XMM0,XMM2
MULSS XMM0,XMM1
SUBSS XMM3,XMM0
MOVSS XMM0,dword ptr [RSP + -0x14]
MULSS XMM0,XMM2
MULSS XMM0,XMM1
ADDSS XMM0,XMM3
MULSS XMM6,XMM1
ADDSS XMM6,XMM0
MOVSS XMM0,dword ptr [RSP + -0x8]
MULSS XMM0,XMM1
SUBSS XMM6,XMM0
MOVSS XMM0,dword ptr [RSP + -0x20]
MULSS XMM0,XMM1
SUBSS XMM6,XMM0
MOVSS XMM0,dword ptr [RSP + -0x1c]
MULSS XMM0,XMM1
ADDSS XMM0,XMM6
RET
|
float MatrixDeterminant(void)
{
float fStack0000000000000008;
float fStack000000000000000c;
float fStack0000000000000010;
float fStack0000000000000014;
float fStack0000000000000018;
float fStack000000000000001c;
float fStack0000000000000020;
float fStack0000000000000024;
float fStack0000000000000028;
float fStack000000000000002c;
float fStack0000000000000030;
float fStack0000000000000034;
float fStack0000000000000038;
float fStack000000000000003c;
float fStack0000000000000040;
float fStack0000000000000044;
return fStack0000000000000008 * fStack000000000000001c * fStack0000000000000030 *
fStack0000000000000044 +
(((fStack0000000000000010 * fStack0000000000000018 * fStack000000000000002c *
fStack0000000000000044 +
fStack000000000000000c * fStack0000000000000020 * fStack0000000000000028 *
fStack0000000000000044 +
(((fStack0000000000000018 * fStack000000000000000c * fStack0000000000000034 *
fStack0000000000000040 +
fStack0000000000000024 * fStack0000000000000008 * fStack000000000000002c *
fStack0000000000000040 +
(((fStack000000000000001c * fStack0000000000000014 * fStack0000000000000028 *
fStack0000000000000040 +
fStack0000000000000020 * fStack0000000000000008 * fStack0000000000000034 *
fStack000000000000003c +
(((fStack0000000000000030 * fStack0000000000000014 * fStack0000000000000018 *
fStack000000000000003c +
fStack0000000000000010 * fStack0000000000000024 * fStack0000000000000028 *
fStack000000000000003c +
(((fStack000000000000001c * fStack0000000000000010 * fStack0000000000000034 *
fStack0000000000000038 +
fStack0000000000000030 * fStack000000000000000c * fStack0000000000000024 *
fStack0000000000000038 +
((fStack000000000000002c * fStack0000000000000020 * fStack0000000000000014 *
fStack0000000000000038 -
fStack000000000000002c * fStack0000000000000010 * fStack0000000000000024 *
fStack0000000000000038) -
fStack0000000000000030 * fStack000000000000001c * fStack0000000000000014 *
fStack0000000000000038)) -
fStack0000000000000034 * fStack000000000000000c * fStack0000000000000020 *
fStack0000000000000038) -
fStack0000000000000020 * fStack0000000000000014 * fStack0000000000000028 *
fStack000000000000003c)) -
fStack0000000000000030 * fStack0000000000000024 * fStack0000000000000008 *
fStack000000000000003c) -
fStack0000000000000034 * fStack0000000000000010 * fStack0000000000000018 *
fStack000000000000003c)) -
fStack000000000000000c * fStack0000000000000024 * fStack0000000000000028 *
fStack0000000000000040) -
fStack0000000000000014 * fStack0000000000000018 * fStack000000000000002c *
fStack0000000000000040)) -
fStack0000000000000034 * fStack0000000000000008 * fStack000000000000001c *
fStack0000000000000040) -
fStack000000000000001c * fStack0000000000000010 * fStack0000000000000028 *
fStack0000000000000044)) -
fStack0000000000000020 * fStack0000000000000008 * fStack000000000000002c *
fStack0000000000000044) -
fStack0000000000000018 * fStack000000000000000c * fStack0000000000000030 *
fStack0000000000000044);
}
| |
38,601 | google::protobuf::internal::ExtensionSet::FindExtension(int, unsigned int, google::protobuf::Message const*, google::protobuf::internal::ParseContext const*, google::protobuf::internal::ExtensionInfo*, bool*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/extension_set_heavy.cc | bool ExtensionSet::FindExtension(int wire_type, uint32_t field,
const Message* containing_type,
const internal::ParseContext* ctx,
ExtensionInfo* extension,
bool* was_packed_on_wire) {
if (ctx->data().pool == nullptr) {
GeneratedExtensionFinder finder(containing_type);
if (!FindExtensionInfoFromFieldNumber(wire_type, field, &finder, extension,
was_packed_on_wire)) {
return false;
}
} else {
DescriptorPoolExtensionFinder finder(ctx->data().pool, ctx->data().factory,
containing_type->GetDescriptor());
if (!FindExtensionInfoFromFieldNumber(wire_type, field, &finder, extension,
was_packed_on_wire)) {
return false;
}
}
return true;
} | O0 | cpp | google::protobuf::internal::ExtensionSet::FindExtension(int, unsigned int, google::protobuf::Message const*, google::protobuf::internal::ParseContext const*, google::protobuf::internal::ExtensionInfo*, bool*):
subq $0x68, %rsp
movq 0x70(%rsp), %rax
movq %rdi, 0x58(%rsp)
movl %esi, 0x54(%rsp)
movl %edx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0x5611d0
cmpq $0x0, (%rax)
jne 0x55f4ec
movq 0x48(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x487ee0
movq 0x10(%rsp), %rdi
movl 0x54(%rsp), %esi
movl 0x50(%rsp), %edx
movq 0x38(%rsp), %r8
movq 0x70(%rsp), %r9
leaq 0x30(%rsp), %rcx
callq 0x487f60
testb $0x1, %al
jne 0x55f4ea
movb $0x0, 0x67(%rsp)
jmp 0x55f563
jmp 0x55f55e
movq 0x40(%rsp), %rdi
callq 0x5611d0
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rdi
callq 0x5611d0
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
callq 0x411a00
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rax, %rcx
leaq 0x18(%rsp), %rdi
callq 0x5611e0
movq 0x10(%rsp), %rdi
movl 0x54(%rsp), %esi
movl 0x50(%rsp), %edx
movq 0x38(%rsp), %r8
movq 0x70(%rsp), %r9
leaq 0x18(%rsp), %rcx
callq 0x561220
testb $0x1, %al
jne 0x55f55c
movb $0x0, 0x67(%rsp)
jmp 0x55f563
jmp 0x55f55e
movb $0x1, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nop
| _ZN6google8protobuf8internal12ExtensionSet13FindExtensionEijPKNS0_7MessageEPKNS1_12ParseContextEPNS1_13ExtensionInfoEPb:
sub rsp, 68h
mov rax, [rsp+68h+arg_0]
mov [rsp+68h+var_10], rdi
mov [rsp+68h+var_14], esi
mov [rsp+68h+var_18], edx
mov [rsp+68h+var_20], rcx
mov [rsp+68h+var_28], r8
mov [rsp+68h+var_30], r9
mov rax, [rsp+68h+var_10]
mov [rsp+68h+var_58], rax
mov rdi, [rsp+68h+var_28]; this
call _ZNK6google8protobuf8internal12ParseContext4dataEv; google::protobuf::internal::ParseContext::data(void)
cmp qword ptr [rax], 0
jnz short loc_55F4EC
mov rsi, [rsp+68h+var_20]; google::protobuf::MessageLite *
lea rdi, [rsp+68h+var_38]; this
call _ZN6google8protobuf8internal24GeneratedExtensionFinderC2EPKNS0_11MessageLiteE; google::protobuf::internal::GeneratedExtensionFinder::GeneratedExtensionFinder(google::protobuf::MessageLite const*)
mov rdi, [rsp+68h+var_58]
mov esi, [rsp+68h+var_14]
mov edx, [rsp+68h+var_18]
mov r8, [rsp+68h+var_30]
mov r9, [rsp+68h+arg_0]
lea rcx, [rsp+68h+var_38]
call _ZNK6google8protobuf8internal12ExtensionSet32FindExtensionInfoFromFieldNumberINS1_24GeneratedExtensionFinderEEEbiiPT_PNS1_13ExtensionInfoEPb; google::protobuf::internal::ExtensionSet::FindExtensionInfoFromFieldNumber<google::protobuf::internal::GeneratedExtensionFinder>(int,int,google::protobuf::internal::GeneratedExtensionFinder *,google::protobuf::internal::ExtensionInfo *,bool *)
test al, 1
jnz short loc_55F4EA
mov [rsp+68h+var_1], 0
jmp short loc_55F563
loc_55F4EA:
jmp short loc_55F55E
loc_55F4EC:
mov rdi, [rsp+68h+var_28]; this
call _ZNK6google8protobuf8internal12ParseContext4dataEv; google::protobuf::internal::ParseContext::data(void)
mov rax, [rax]
mov [rsp+68h+var_68], rax
mov rdi, [rsp+68h+var_28]; this
call _ZNK6google8protobuf8internal12ParseContext4dataEv; google::protobuf::internal::ParseContext::data(void)
mov rax, [rax+8]
mov [rsp+68h+var_60], rax
mov rdi, [rsp+68h+var_20]; this
call _ZNK6google8protobuf7Message13GetDescriptorEv; google::protobuf::Message::GetDescriptor(void)
mov rsi, [rsp+68h+var_68]; google::protobuf::DescriptorPool *
mov rdx, [rsp+68h+var_60]; google::protobuf::MessageFactory *
mov rcx, rax; google::protobuf::Descriptor *
lea rdi, [rsp+68h+var_50]; this
call _ZN6google8protobuf8internal29DescriptorPoolExtensionFinderC2EPKNS0_14DescriptorPoolEPNS0_14MessageFactoryEPKNS0_10DescriptorE; google::protobuf::internal::DescriptorPoolExtensionFinder::DescriptorPoolExtensionFinder(google::protobuf::DescriptorPool const*,google::protobuf::MessageFactory *,google::protobuf::Descriptor const*)
mov rdi, [rsp+68h+var_58]
mov esi, [rsp+68h+var_14]
mov edx, [rsp+68h+var_18]
mov r8, [rsp+68h+var_30]
mov r9, [rsp+68h+arg_0]
lea rcx, [rsp+68h+var_50]
call _ZNK6google8protobuf8internal12ExtensionSet32FindExtensionInfoFromFieldNumberINS1_29DescriptorPoolExtensionFinderEEEbiiPT_PNS1_13ExtensionInfoEPb; google::protobuf::internal::ExtensionSet::FindExtensionInfoFromFieldNumber<google::protobuf::internal::DescriptorPoolExtensionFinder>(int,int,google::protobuf::internal::DescriptorPoolExtensionFinder *,google::protobuf::internal::ExtensionInfo *,bool *)
test al, 1
jnz short loc_55F55C
mov [rsp+68h+var_1], 0
jmp short loc_55F563
loc_55F55C:
jmp short $+2
loc_55F55E:
mov [rsp+68h+var_1], 1
loc_55F563:
mov al, [rsp+68h+var_1]
and al, 1
add rsp, 68h
retn
| bool google::protobuf::internal::ExtensionSet::FindExtension(
google::protobuf::internal::ExtensionSet *this,
int a2,
unsigned int a3,
const google::protobuf::Message *a4,
const google::protobuf::internal::ParseContext *a5,
google::protobuf::internal::ExtensionInfo *a6,
bool *a7)
{
const google::protobuf::Descriptor *Descriptor; // rax
google::protobuf::DescriptorPool *v9; // [rsp+0h] [rbp-68h]
google::protobuf::MessageFactory *v10; // [rsp+8h] [rbp-60h]
long long v11; // [rsp+18h] [rbp-50h] BYREF
int v12; // [rsp+20h] [rbp-48h]
char v13; // [rsp+28h] [rbp-40h]
google::protobuf::internal::_anonymous_namespace_ *v14; // [rsp+30h] [rbp-38h] BYREF
unsigned __int8 *v15; // [rsp+38h] [rbp-30h]
google::protobuf::internal::ParseContext *v16; // [rsp+40h] [rbp-28h]
google::protobuf::Message *v17; // [rsp+48h] [rbp-20h]
unsigned int v18; // [rsp+50h] [rbp-18h]
int v19; // [rsp+54h] [rbp-14h]
google::protobuf::internal::ExtensionSet *v20; // [rsp+58h] [rbp-10h]
v20 = this;
v19 = a2;
v18 = a3;
v17 = a4;
v16 = a5;
v15 = (unsigned __int8 *)a6;
if ( *(_QWORD *)google::protobuf::internal::ParseContext::data(a5) )
{
v9 = *(google::protobuf::DescriptorPool **)google::protobuf::internal::ParseContext::data(v16);
v10 = *(google::protobuf::MessageFactory **)(google::protobuf::internal::ParseContext::data(v16) + 8);
Descriptor = (const google::protobuf::Descriptor *)google::protobuf::Message::GetDescriptor(v17);
google::protobuf::internal::DescriptorPoolExtensionFinder::DescriptorPoolExtensionFinder(
(google::protobuf::internal::DescriptorPoolExtensionFinder *)&v11,
v9,
v10,
Descriptor);
return (google::protobuf::internal::ExtensionSet::FindExtensionInfoFromFieldNumber<google::protobuf::internal::DescriptorPoolExtensionFinder>(
(_DWORD)this,
v19,
v18,
(unsigned int)&v11,
(_DWORD)v15,
(_DWORD)a7,
(_DWORD)v9,
(_DWORD)v10,
(_DWORD)this,
v11,
v12,
v13) & 1) != 0;
}
google::protobuf::internal::GeneratedExtensionFinder::GeneratedExtensionFinder(
(google::protobuf::internal::GeneratedExtensionFinder *)&v14,
v17);
return google::protobuf::internal::ExtensionSet::FindExtensionInfoFromFieldNumber<google::protobuf::internal::GeneratedExtensionFinder>(
(_DWORD)this,
v19,
v18,
&v14,
v15,
a7);
}
| move_backward<google::protobuf::Message_const**,__gnu_cxx::__normal_iterator<google::protobuf::Message_const**,std::vector<google::protobuf::Message_const*,std::allocator<google::protobuf::Message_const*>>>>:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDX
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x0055eef0
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x0055eef0
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x10],RAX
MOV RDX,qword ptr [RSP + 0x10]
CALL 0x0055f520
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x30]
ADD RSP,0x38
RET
|
/* __gnu_cxx::__normal_iterator<google::protobuf::Message const**,
std::vector<google::protobuf::Message const*, std::allocator<google::protobuf::Message const*> >
> std::move_backward<google::protobuf::Message const**,
__gnu_cxx::__normal_iterator<google::protobuf::Message const**,
std::vector<google::protobuf::Message const*, std::allocator<google::protobuf::Message const*> >
> >(google::protobuf::Message const**, google::protobuf::Message const**,
__gnu_cxx::__normal_iterator<google::protobuf::Message const**,
std::vector<google::protobuf::Message const*, std::allocator<google::protobuf::Message const*> >
>) */
int8
std::
move_backward<google::protobuf::Message_const**,__gnu_cxx::__normal_iterator<google::protobuf::Message_const**,std::vector<google::protobuf::Message_const*,std::allocator<google::protobuf::Message_const*>>>>
(Message **param_1,Message **param_2,int8 param_3)
{
Message **ppMVar1;
Message **ppMVar2;
int8 uVar3;
ppMVar1 = __miter_base<google::protobuf::Message_const**>(param_1);
ppMVar2 = __miter_base<google::protobuf::Message_const**>(param_2);
uVar3 = __copy_move_backward_a<true,google::protobuf::Message_const**,__gnu_cxx::__normal_iterator<google::protobuf::Message_const**,std::vector<google::protobuf::Message_const*,std::allocator<google::protobuf::Message_const*>>>>
(ppMVar1,ppMVar2,param_3);
return uVar3;
}
| |
38,602 | js_for_of_start | bluesky950520[P]quickjs/quickjs.c | static __exception int js_for_of_start(JSContext *ctx, JSValue *sp,
BOOL is_async)
{
JSValue op1, obj, method;
op1 = sp[-1];
obj = JS_GetIterator(ctx, op1, is_async);
if (JS_IsException(obj))
return -1;
JS_FreeValue(ctx, op1);
sp[-1] = obj;
method = JS_GetProperty(ctx, obj, JS_ATOM_next);
if (JS_IsException(method))
return -1;
sp[0] = method;
return 0;
} | O1 | c | js_for_of_start:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ecx
movq %rsi, %rbx
movq %rdi, %r14
movq -0x10(%rsi), %r13
movq -0x8(%rsi), %rbp
movq %r13, %rsi
movq %rbp, %rdx
callq 0x40bf7
movq %rdx, %r12
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmpl $0x6, %r12d
je 0x3ee84
movq %rax, %r15
movq 0x18(%r14), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x1ccb2
movq %r15, -0x10(%rbx)
movq %r12, -0x8(%rbx)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl $0x6b, %ecx
movq %r15, %r8
movq %r12, %r9
pushq $0x0
pushq $0x0
callq 0x2238f
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
addq $0x10, %rsp
cmpl $0x6, %edx
je 0x3ee84
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_for_of_start:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ecx, edx
mov rbx, rsi
mov r14, rdi
mov r13, [rsi-10h]
mov rbp, [rsi-8]
mov rsi, r13
mov rdx, rbp
call JS_GetIterator
mov r12, rdx
mov ecx, 0FFFFFFFFh
cmp r12d, 6
jz short loc_3EE84
mov r15, rax
mov rdi, [r14+18h]
mov rsi, r13
mov rdx, rbp
call JS_FreeValueRT
mov [rbx-10h], r15
mov [rbx-8], r12
mov rdi, r14
mov rsi, r15
mov rdx, r12
mov ecx, 6Bh ; 'k'
mov r8, r15
mov r9, r12
push 0
push 0
call JS_GetPropertyInternal2
mov ecx, 0FFFFFFFFh
add rsp, 10h
cmp edx, 6
jz short loc_3EE84
mov [rbx], rax
mov [rbx+8], rdx
xor ecx, ecx
loc_3EE84:
mov eax, ecx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long js_for_of_start(long long a1, unsigned long long *a2, unsigned int a3)
{
_DWORD *v3; // r13
long long v4; // rbp
long long Iterator; // rax
long long v6; // rdx
long long v7; // r12
unsigned int v8; // ecx
long long v9; // r15
unsigned long long PropertyInternal2; // rax
unsigned long long v11; // rdx
v3 = (_DWORD *)*(a2 - 2);
v4 = *(a2 - 1);
Iterator = JS_GetIterator(a1, v3, v4, a3);
v7 = v6;
v8 = -1;
if ( (_DWORD)v6 != 6 )
{
v9 = Iterator;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v3, v4);
*(a2 - 2) = v9;
*(a2 - 1) = v7;
PropertyInternal2 = JS_GetPropertyInternal2(a1, v9, v7, 0x6Bu, v9, v7, 0LL, 0);
v8 = -1;
if ( (_DWORD)v11 != 6 )
{
*a2 = PropertyInternal2;
a2[1] = v11;
return 0;
}
}
return v8;
}
| js_for_of_start:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV ECX,EDX
MOV RBX,RSI
MOV R14,RDI
MOV R13,qword ptr [RSI + -0x10]
MOV RBP,qword ptr [RSI + -0x8]
MOV RSI,R13
MOV RDX,RBP
CALL 0x00140bf7
MOV R12,RDX
MOV ECX,0xffffffff
CMP R12D,0x6
JZ 0x0013ee84
MOV R15,RAX
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,R13
MOV RDX,RBP
CALL 0x0011ccb2
MOV qword ptr [RBX + -0x10],R15
MOV qword ptr [RBX + -0x8],R12
MOV RDI,R14
MOV RSI,R15
MOV RDX,R12
MOV ECX,0x6b
MOV R8,R15
MOV R9,R12
PUSH 0x0
PUSH 0x0
CALL 0x0012238f
MOV ECX,0xffffffff
ADD RSP,0x10
CMP EDX,0x6
JZ 0x0013ee84
MOV qword ptr [RBX],RAX
MOV qword ptr [RBX + 0x8],RDX
XOR ECX,ECX
LAB_0013ee84:
MOV EAX,ECX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 js_for_of_start(long param_1,int1 (*param_2) [16],int4 param_3)
{
int8 uVar1;
int8 uVar2;
int8 uVar3;
int1 auVar4 [16];
uVar1 = *(int8 *)param_2[-1];
uVar2 = *(int8 *)(param_2[-1] + 8);
auVar4 = JS_GetIterator(param_1,uVar1,uVar2,param_3);
uVar3 = 0xffffffff;
if (auVar4._8_4_ != 6) {
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar1,uVar2);
param_2[-1] = auVar4;
auVar4 = JS_GetPropertyInternal2
(param_1,auVar4._0_8_,auVar4._8_8_,0x6b,auVar4._0_8_,auVar4._8_8_,0,0);
uVar3 = 0xffffffff;
if (auVar4._8_4_ != 6) {
*param_2 = auVar4;
uVar3 = 0;
}
}
return uVar3;
}
| |
38,603 | js_for_of_start | bluesky950520[P]quickjs/quickjs.c | static __exception int js_for_of_start(JSContext *ctx, JSValue *sp,
BOOL is_async)
{
JSValue op1, obj, method;
op1 = sp[-1];
obj = JS_GetIterator(ctx, op1, is_async);
if (JS_IsException(obj))
return -1;
JS_FreeValue(ctx, op1);
sp[-1] = obj;
method = JS_GetProperty(ctx, obj, JS_ATOM_next);
if (JS_IsException(method))
return -1;
sp[0] = method;
return 0;
} | O2 | c | js_for_of_start:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ecx
movq %rsi, %rbx
movq %rdi, %r14
movq -0x10(%rsi), %r15
movq -0x8(%rsi), %r12
movq %r15, %rsi
movq %r12, %rdx
callq 0x38b0b
movq %rdx, %rbp
pushq $-0x1
popq %rcx
cmpl $0x6, %ebp
je 0x371b4
movq %rax, %r13
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %ecx, %r15d
callq 0x174a2
movq %r13, -0x10(%rbx)
movq %rbp, -0x8(%rbx)
pushq $0x6b
popq %rcx
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x1a4c7
movl %r15d, %ecx
cmpl $0x6, %edx
je 0x371b4
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_for_of_start:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ecx, edx
mov rbx, rsi
mov r14, rdi
mov r15, [rsi-10h]
mov r12, [rsi-8]
mov rsi, r15
mov rdx, r12
call JS_GetIterator
mov rbp, rdx
push 0FFFFFFFFFFFFFFFFh
pop rcx
cmp ebp, 6
jz short loc_371B4
mov r13, rax
mov rdi, r14
mov rsi, r15
mov rdx, r12
mov r15d, ecx
call JS_FreeValue
mov [rbx-10h], r13
mov [rbx-8], rbp
push 6Bh ; 'k'
pop rcx
mov rdi, r14
mov rsi, r13
mov rdx, rbp
call JS_GetProperty
mov ecx, r15d
cmp edx, 6
jz short loc_371B4
mov [rbx], rax
mov [rbx+8], rdx
xor ecx, ecx
loc_371B4:
mov eax, ecx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long js_for_of_start(long long a1, long long *a2, unsigned int a3)
{
long long v3; // r15
long long v4; // r12
long long Iterator; // rax
long long v6; // rdx
long long v7; // rbp
unsigned int v8; // ecx
long long v9; // r13
long long Property; // rax
long long v11; // rdx
v3 = *(a2 - 2);
v4 = *(a2 - 1);
Iterator = JS_GetIterator(a1, v3, v4, a3);
v7 = v6;
v8 = -1;
if ( (_DWORD)v6 != 6 )
{
v9 = Iterator;
JS_FreeValue(a1, v3, v4);
*(a2 - 2) = v9;
*(a2 - 1) = v7;
Property = JS_GetProperty(a1, v9, v7, 107);
v8 = -1;
if ( (_DWORD)v11 != 6 )
{
*a2 = Property;
a2[1] = v11;
return 0;
}
}
return v8;
}
| js_for_of_start:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV ECX,EDX
MOV RBX,RSI
MOV R14,RDI
MOV R15,qword ptr [RSI + -0x10]
MOV R12,qword ptr [RSI + -0x8]
MOV RSI,R15
MOV RDX,R12
CALL 0x00138b0b
MOV RBP,RDX
PUSH -0x1
POP RCX
CMP EBP,0x6
JZ 0x001371b4
MOV R13,RAX
MOV RDI,R14
MOV RSI,R15
MOV RDX,R12
MOV R15D,ECX
CALL 0x001174a2
MOV qword ptr [RBX + -0x10],R13
MOV qword ptr [RBX + -0x8],RBP
PUSH 0x6b
POP RCX
MOV RDI,R14
MOV RSI,R13
MOV RDX,RBP
CALL 0x0011a4c7
MOV ECX,R15D
CMP EDX,0x6
JZ 0x001371b4
MOV qword ptr [RBX],RAX
MOV qword ptr [RBX + 0x8],RDX
XOR ECX,ECX
LAB_001371b4:
MOV EAX,ECX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int4 js_for_of_start(int8 param_1,int1 (*param_2) [16],int4 param_3)
{
int8 uVar1;
int8 uVar2;
int4 uVar3;
int1 auVar4 [16];
uVar1 = *(int8 *)param_2[-1];
uVar2 = *(int8 *)(param_2[-1] + 8);
auVar4 = JS_GetIterator(param_1,uVar1,uVar2,param_3);
uVar3 = 0xffffffff;
if (auVar4._8_4_ != 6) {
uVar3 = 0xffffffff;
JS_FreeValue(param_1,uVar1,uVar2);
param_2[-1] = auVar4;
auVar4 = JS_GetProperty(param_1,auVar4._0_8_,auVar4._8_8_,0x6b);
if (auVar4._8_4_ != 6) {
*param_2 = auVar4;
uVar3 = 0;
}
}
return uVar3;
}
| |
38,604 | YAML::detail::node_data::convert_sequence_to_map(std::shared_ptr<YAML::detail::memory_holder> const&) | aimrt_mujoco_sim/_deps/yaml-cpp-src/src/node_data.cpp | void node_data::convert_sequence_to_map(const shared_memory_holder& pMemory) {
assert(m_type == NodeType::Sequence);
reset_map();
for (std::size_t i = 0; i < m_sequence.size(); i++) {
std::stringstream stream;
stream << i;
node& key = pMemory->create_node();
key.set_scalar(stream.str());
insert_map_pair(key, *m_sequence[i]);
}
reset_sequence();
m_type = NodeType::Map;
} | O3 | cpp | YAML::detail::node_data::convert_sequence_to_map(std::shared_ptr<YAML::detail::memory_holder> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r15
movq %rdi, %r14
movq 0x80(%rdi), %rax
cmpq %rax, 0x88(%rdi)
je 0x81958
movq %rax, 0x88(%r14)
leaq 0x98(%r14), %rdi
callq 0x81cec
movq 0x60(%r14), %rax
movq 0x68(%r14), %rcx
cmpq %rax, %rcx
je 0x81a3c
xorl %ebp, %ebp
leaq 0x20(%rsp), %rbx
movq %rsp, %r12
movq %rbx, %rdi
callq 0x1eba0
leaq 0x30(%rsp), %rdi
movq %rbp, %rsi
callq 0x1eb40
movq (%r15), %rax
movq (%rax), %rdi
callq 0x80946
movq %rax, %r13
movq %r12, %rdi
leaq 0x38(%rsp), %rsi
callq 0x1ebf0
movq %r13, %rdi
callq 0x3614e
movq (%r13), %rax
movq (%rax), %rdi
movb $0x1, (%rdi)
movl $0x2, 0x10(%rdi)
addq $0x40, %rdi
movq %r12, %rsi
callq 0x1f200
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x819ef
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1f250
movq 0x60(%r14), %rax
movq (%rax,%rbp,8), %rdx
movq %r14, %rdi
movq %r13, %rsi
callq 0x8163c
movq %rbx, %rdi
movq 0x2e344(%rip), %rsi # 0xafd50
callq 0x1ec00
leaq 0xa0(%rsp), %rdi
callq 0x1e4d0
incq %rbp
movq 0x60(%r14), %rax
movq 0x68(%r14), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rbp
jb 0x8197f
cmpq %rax, %rcx
je 0x81a45
movq %rax, 0x68(%r14)
movq $0x0, 0x78(%r14)
movl $0x4, 0x10(%r14)
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x81a8b
jmp 0x81a8b
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x81a8e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1f250
jmp 0x81a8e
movq %rax, %rbx
movq 0x2e2bb(%rip), %rsi # 0xafd50
leaq 0x20(%rsp), %rdi
callq 0x1ec00
leaq 0xa0(%rsp), %rdi
callq 0x1e4d0
movq %rbx, %rdi
callq 0x1ffd0
| _ZN4YAML6detail9node_data23convert_sequence_to_mapERKSt10shared_ptrINS0_13memory_holderEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1A8h
mov r15, rsi
mov r14, rdi
mov rax, [rdi+80h]
cmp [rdi+88h], rax
jz short loc_81958
mov [r14+88h], rax
loc_81958:
lea rdi, [r14+98h]
call _ZNSt7__cxx114listISt4pairIPN4YAML6detail4nodeES5_ESaIS6_EE5clearEv; std::list<std::pair<YAML::detail::node *,YAML::detail::node *>>::clear(void)
mov rax, [r14+60h]
mov rcx, [r14+68h]
cmp rcx, rax
jz loc_81A3C
xor ebp, ebp
lea rbx, [rsp+1D8h+var_1B8]
mov r12, rsp
loc_8197F:
mov rdi, rbx
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(void)
lea rdi, [rsp+1D8h+var_1A8]
mov rsi, rbp
call __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
mov rax, [r15]
mov rdi, [rax]; this
call _ZN4YAML6detail6memory11create_nodeEv; YAML::detail::memory::create_node(void)
mov r13, rax
mov rdi, r12
lea rsi, [rsp+1D8h+var_1A0]
call __ZNKRSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov rdi, r13; this
call _ZN4YAML6detail4node12mark_definedEv; YAML::detail::node::mark_defined(void)
mov rax, [r13+0]
mov rdi, [rax]
mov byte ptr [rdi], 1
mov dword ptr [rdi+10h], 2
add rdi, 40h ; '@'
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
mov rdi, [rsp+1D8h+var_1D8]; void *
lea rax, [rsp+1D8h+var_1C8]
cmp rdi, rax
jz short loc_819EF
mov rsi, [rsp+1D8h+var_1C8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_819EF:
mov rax, [r14+60h]
mov rdx, [rax+rbp*8]; YAML::detail::node *
mov rdi, r14; this
mov rsi, r13; YAML::detail::node *
call _ZN4YAML6detail9node_data15insert_map_pairERNS0_4nodeES3_; YAML::detail::node_data::insert_map_pair(YAML::detail::node &,YAML::detail::node &)
mov rdi, rbx
mov rsi, cs:_ZTTNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE_ptr
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED2Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
lea rdi, [rsp+1D8h+var_138]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
inc rbp
mov rax, [r14+60h]
mov rcx, [r14+68h]
mov rdx, rcx
sub rdx, rax
sar rdx, 3
cmp rbp, rdx
jb loc_8197F
loc_81A3C:
cmp rcx, rax
jz short loc_81A45
mov [r14+68h], rax
loc_81A45:
mov qword ptr [r14+78h], 0
mov dword ptr [r14+10h], 4
add rsp, 1A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_81A8B
jmp short loc_81A8B
mov rbx, rax
mov rdi, [rsp+0]; void *
lea rax, [rsp+arg_8]
cmp rdi, rax
jz short loc_81A8E
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_81A8E
loc_81A8B:
mov rbx, rax
loc_81A8E:
mov rsi, cs:_ZTTNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+arg_18]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED2Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
lea rdi, [rsp+arg_98]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rdi, rbx
call __Unwind_Resume
| long long YAML::detail::node_data::convert_sequence_to_map(
YAML::detail::node_data *this,
YAML::detail::memory ***a2)
{
long long v3; // rax
long long result; // rax
long long v5; // rcx
unsigned long long v6; // rbp
YAML::detail::node *node; // r13
long long v8; // rdi
void *v9[2]; // [rsp+0h] [rbp-1D8h] BYREF
long long v10; // [rsp+10h] [rbp-1C8h] BYREF
_BYTE v11[16]; // [rsp+20h] [rbp-1B8h] BYREF
_BYTE v12[8]; // [rsp+30h] [rbp-1A8h] BYREF
_BYTE v13[104]; // [rsp+38h] [rbp-1A0h] BYREF
_BYTE v14[312]; // [rsp+A0h] [rbp-138h] BYREF
v3 = *((_QWORD *)this + 16);
if ( *((_QWORD *)this + 17) != v3 )
*((_QWORD *)this + 17) = v3;
std::list<std::pair<YAML::detail::node *,YAML::detail::node *>>::clear((char *)this + 152);
result = *((_QWORD *)this + 12);
v5 = *((_QWORD *)this + 13);
if ( v5 != result )
{
v6 = 0LL;
do
{
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v11);
std::ostream::_M_insert<unsigned long>(v12, v6);
node = YAML::detail::memory::create_node(**a2);
std::stringbuf::str(v9, v13);
YAML::detail::node::mark_defined(node);
v8 = **(_QWORD **)node;
*(_BYTE *)v8 = 1;
*(_DWORD *)(v8 + 16) = 2;
std::string::_M_assign(v8 + 64, v9);
if ( v9[0] != &v10 )
operator delete(v9[0], v10 + 1);
YAML::detail::node_data::insert_map_pair(this, node, *(long long ***)(*((_QWORD *)this + 12) + 8 * v6));
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream(
v11,
&`VTT for'std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>);
std::ios_base::~ios_base((std::ios_base *)v14);
++v6;
result = *((_QWORD *)this + 12);
v5 = *((_QWORD *)this + 13);
}
while ( v6 < (v5 - result) >> 3 );
}
if ( v5 != result )
*((_QWORD *)this + 13) = result;
*((_QWORD *)this + 15) = 0LL;
*((_DWORD *)this + 4) = 4;
return result;
}
| convert_sequence_to_map:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1a8
MOV R15,RSI
MOV R14,RDI
MOV RAX,qword ptr [RDI + 0x80]
CMP qword ptr [RDI + 0x88],RAX
JZ 0x00181958
MOV qword ptr [R14 + 0x88],RAX
LAB_00181958:
LEA RDI,[R14 + 0x98]
CALL 0x00181cec
MOV RAX,qword ptr [R14 + 0x60]
MOV RCX,qword ptr [R14 + 0x68]
CMP RCX,RAX
JZ 0x00181a3c
XOR EBP,EBP
LEA RBX,[RSP + 0x20]
MOV R12,RSP
LAB_0018197f:
MOV RDI,RBX
CALL 0x0011eba0
LAB_00181987:
LEA RDI,[RSP + 0x30]
MOV RSI,RBP
CALL 0x0011eb40
MOV RAX,qword ptr [R15]
MOV RDI,qword ptr [RAX]
LAB_0018199a:
CALL 0x00180946
LAB_0018199f:
MOV R13,RAX
MOV RDI,R12
LEA RSI,[RSP + 0x38]
CALL 0x0011ebf0
LAB_001819af:
MOV RDI,R13
CALL 0x0013614e
MOV RAX,qword ptr [R13]
MOV RDI,qword ptr [RAX]
MOV byte ptr [RDI],0x1
MOV dword ptr [RDI + 0x10],0x2
ADD RDI,0x40
MOV RSI,R12
CALL 0x0011f200
MOV RDI,qword ptr [RSP]
LEA RAX,[RSP + 0x10]
CMP RDI,RAX
JZ 0x001819ef
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x0011f250
LAB_001819ef:
MOV RAX,qword ptr [R14 + 0x60]
MOV RDX,qword ptr [RAX + RBP*0x8]
LAB_001819f7:
MOV RDI,R14
MOV RSI,R13
CALL 0x0018163c
LAB_00181a02:
MOV RDI,RBX
MOV RSI,qword ptr [0x001afd50]
CALL 0x0011ec00
LEA RDI,[RSP + 0xa0]
CALL 0x0011e4d0
INC RBP
MOV RAX,qword ptr [R14 + 0x60]
MOV RCX,qword ptr [R14 + 0x68]
MOV RDX,RCX
SUB RDX,RAX
SAR RDX,0x3
CMP RBP,RDX
JC 0x0018197f
LAB_00181a3c:
CMP RCX,RAX
JZ 0x00181a45
MOV qword ptr [R14 + 0x68],RAX
LAB_00181a45:
MOV qword ptr [R14 + 0x78],0x0
MOV dword ptr [R14 + 0x10],0x4
ADD RSP,0x1a8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* YAML::detail::node_data::convert_sequence_to_map(std::shared_ptr<YAML::detail::memory_holder>
const&) */
void __thiscall
YAML::detail::node_data::convert_sequence_to_map(node_data *this,shared_ptr *param_1)
{
int1 *puVar1;
node *this_00;
long lVar2;
long lVar3;
ulong uVar4;
long *local_1d8 [2];
long local_1c8 [2];
stringstream local_1b8 [16];
int1 local_1a8 [112];
ios_base local_138 [264];
if (*(long *)(this + 0x88) != *(long *)(this + 0x80)) {
*(long *)(this + 0x88) = *(long *)(this + 0x80);
}
std::__cxx11::
list<std::pair<YAML::detail::node*,YAML::detail::node*>,std::allocator<std::pair<YAML::detail::node*,YAML::detail::node*>>>
::clear((list<std::pair<YAML::detail::node*,YAML::detail::node*>,std::allocator<std::pair<YAML::detail::node*,YAML::detail::node*>>>
*)(this + 0x98));
lVar2 = *(long *)(this + 0x60);
lVar3 = *(long *)(this + 0x68);
if (lVar3 != lVar2) {
uVar4 = 0;
do {
std::__cxx11::stringstream::stringstream(local_1b8);
/* try { // try from 00181987 to 00181993 has its CatchHandler @ 00181a67 */
std::ostream::_M_insert<unsigned_long>((ulong)local_1a8);
/* try { // try from 0018199a to 0018199e has its CatchHandler @ 00181a8b */
this_00 = (node *)memory::create_node((memory *)**(int8 **)param_1);
/* try { // try from 0018199f to 001819ae has its CatchHandler @ 00181a69 */
std::__cxx11::stringbuf::str();
/* try { // try from 001819af to 001819d3 has its CatchHandler @ 00181a6b */
node::mark_defined(this_00);
puVar1 = (int1 *)**(int8 **)this_00;
*puVar1 = 1;
*(int4 *)(puVar1 + 0x10) = 2;
std::__cxx11::string::_M_assign((string *)(puVar1 + 0x40),(string *)local_1d8);
if (local_1d8[0] != local_1c8) {
operator_delete(local_1d8[0],local_1c8[0] + 1);
}
/* try { // try from 001819f7 to 00181a01 has its CatchHandler @ 00181a8b */
insert_map_pair(this,this_00,*(node **)(*(long *)(this + 0x60) + uVar4 * 8));
std::__cxx11::stringstream::~stringstream(local_1b8);
std::ios_base::~ios_base(local_138);
uVar4 = uVar4 + 1;
lVar2 = *(long *)(this + 0x60);
lVar3 = *(long *)(this + 0x68);
} while (uVar4 < (ulong)(lVar3 - lVar2 >> 3));
}
if (lVar3 != lVar2) {
*(long *)(this + 0x68) = lVar2;
}
*(int8 *)(this + 0x78) = 0;
*(int4 *)(this + 0x10) = 4;
return;
}
| |
38,605 | testing::internal::OsStackTraceGetter::CurrentStackTrace[abi:cxx11](int, int) | seiftnesse[P]memoryallocator/build_O1/_deps/googletest-src/googletest/src/gtest.cc | GTEST_LOCK_EXCLUDED_(mutex_) {
#if GTEST_HAS_ABSL
std::string result;
if (max_depth <= 0) {
return result;
}
max_depth = std::min(max_depth, kMaxStackTraceDepth);
std::vector<void*> raw_stack(max_depth);
// Skips the frames requested by the caller, plus this function.
const int raw_stack_size =
absl::GetStackTrace(&raw_stack[0], max_depth, skip_count + 1);
void* caller_frame = nullptr;
{
MutexLock lock(&mutex_);
caller_frame = caller_frame_;
}
for (int i = 0; i < raw_stack_size; ++i) {
if (raw_stack[i] == caller_frame &&
!GTEST_FLAG_GET(show_internal_stack_frames)) {
// Add a marker to the trace and stop adding frames.
absl::StrAppend(&result, kElidedFramesMarker, "\n");
break;
}
char tmp[1024];
const char* symbol = "(unknown)";
if (absl::Symbolize(raw_stack[i], tmp, sizeof(tmp))) {
symbol = tmp;
}
char line[1024];
snprintf(line, sizeof(line), " %p: %s\n", raw_stack[i], symbol);
result += line;
}
return result;
#else // !GTEST_HAS_ABSL
static_cast<void>(max_depth);
static_cast<void>(skip_count);
return "";
#endif // GTEST_HAS_ABSL
} | O1 | cpp | testing::internal::OsStackTraceGetter::CurrentStackTrace[abi:cxx11](int, int):
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0x1299e(%rip), %rdx # 0x435f0
movq %rdx, %rsi
callq 0xfdfe
movq %rbx, %rax
popq %rbx
retq
nop
| _ZN7testing8internal18OsStackTraceGetter17CurrentStackTraceB5cxx11Eii:
push rbx
mov rbx, rdi
lea rax, [rdi+10h]
mov [rdi], rax
lea rdx, aSFromSSMsTotal+1Ah; ""
mov rsi, rdx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rax, rbx
pop rbx
retn
| _QWORD * testing::internal::OsStackTraceGetter::CurrentStackTrace[abi:cxx11](_QWORD *a1)
{
*a1 = a1 + 2;
std::string::_M_construct<char const*>(a1, "", (long long)"");
return a1;
}
| CurrentStackTrace[abi:cxx11]:
PUSH RBX
MOV RBX,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
LEA RDX,[0x1435f0]
MOV RSI,RDX
CALL 0x0010fdfe
MOV RAX,RBX
POP RBX
RET
|
/* testing::internal::OsStackTraceGetter::CurrentStackTrace[abi:cxx11](int, int) */
int8
testing::internal::OsStackTraceGetter::CurrentStackTrace_abi_cxx11_(int param_1,int param_2)
{
int4 in_register_0000003c;
*(long *)CONCAT44(in_register_0000003c,param_1) = CONCAT44(in_register_0000003c,param_1) + 0x10;
std::__cxx11::string::_M_construct<char_const*>(param_1,"");
return CONCAT44(in_register_0000003c,param_1);
}
| |
38,606 | my_uca_contraction_find | eloqsql/strings/ctype-uca.c | static inline const MY_CONTRACTION *
my_uca_contraction_find(const MY_CONTRACTIONS *list, my_wc_t *wc, size_t len)
{
MY_CONTRACTION *c, *last;
DBUG_ASSERT(len <= MY_UCA_MAX_CONTRACTION);
for (c= list->item, last= c + list->nitems; c < last; c++)
{
if ((len >= MY_UCA_MAX_CONTRACTION || c->ch[len] == 0) &&
!c->with_context &&
!my_wmemcmp(c->ch, wc, len))
return c;
}
return NULL;
} | O0 | c | my_uca_contraction_find:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
jmp 0x5feb6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
imulq $0x58, (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x5ff2f
cmpq $0x6, -0x20(%rbp)
jae 0x5fef5
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x5ff1f
movq -0x28(%rbp), %rax
cmpb $0x0, 0x52(%rax)
jne 0x5ff1f
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5ff50
cmpl $0x0, %eax
jne 0x5ff1f
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5ff37
jmp 0x5ff21
movq -0x28(%rbp), %rax
addq $0x58, %rax
movq %rax, -0x28(%rbp)
jmp 0x5fed5
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_uca_contraction_find:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
jmp short $+2
loc_5FEB6:
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov rcx, [rbp+var_10]
imul rcx, [rcx], 58h ; 'X'
add rax, rcx
mov [rbp+var_30], rax
loc_5FED5:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jnb short loc_5FF2F
cmp [rbp+var_20], 6
jnb short loc_5FEF5
mov rax, [rbp+var_28]
mov rcx, [rbp+var_20]
cmp qword ptr [rax+rcx*8], 0
jnz short loc_5FF1F
loc_5FEF5:
mov rax, [rbp+var_28]
cmp byte ptr [rax+52h], 0
jnz short loc_5FF1F
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call my_wmemcmp
cmp eax, 0
jnz short loc_5FF1F
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
jmp short loc_5FF37
loc_5FF1F:
jmp short $+2
loc_5FF21:
mov rax, [rbp+var_28]
add rax, 58h ; 'X'
mov [rbp+var_28], rax
jmp short loc_5FED5
loc_5FF2F:
mov [rbp+var_8], 0
loc_5FF37:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| unsigned long long my_uca_contraction_find(_QWORD *a1, long long a2, unsigned long long a3)
{
unsigned long long v4; // [rsp+0h] [rbp-30h]
unsigned long long v5; // [rsp+8h] [rbp-28h]
v5 = a1[1];
v4 = 88LL * *a1 + v5;
while ( v5 < v4 )
{
if ( (a3 >= 6 || !*(_QWORD *)(v5 + 8 * a3)) && !*(_BYTE *)(v5 + 82) && !(unsigned int)my_wmemcmp(v5, a2, a3) )
return v5;
v5 += 88LL;
}
return 0LL;
}
| my_uca_contraction_find:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
JMP 0x0015feb6
LAB_0015feb6:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x10]
IMUL RCX,qword ptr [RCX],0x58
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
LAB_0015fed5:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x0015ff2f
CMP qword ptr [RBP + -0x20],0x6
JNC 0x0015fef5
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX + RCX*0x8],0x0
JNZ 0x0015ff1f
LAB_0015fef5:
MOV RAX,qword ptr [RBP + -0x28]
CMP byte ptr [RAX + 0x52],0x0
JNZ 0x0015ff1f
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0015ff50
CMP EAX,0x0
JNZ 0x0015ff1f
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0015ff37
LAB_0015ff1f:
JMP 0x0015ff21
LAB_0015ff21:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x58
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0015fed5
LAB_0015ff2f:
MOV qword ptr [RBP + -0x8],0x0
LAB_0015ff37:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
ulong my_uca_contraction_find(long *param_1,int8 param_2,ulong param_3)
{
int iVar1;
ulong uVar2;
ulong local_30;
local_30 = param_1[1];
uVar2 = local_30 + *param_1 * 0x58;
while( true ) {
if (uVar2 <= local_30) {
return 0;
}
if ((((5 < param_3) || (*(long *)(local_30 + param_3 * 8) == 0)) &&
(*(char *)(local_30 + 0x52) == '\0')) &&
(iVar1 = my_wmemcmp(local_30,param_2,param_3), iVar1 == 0)) break;
local_30 = local_30 + 0x58;
}
return local_30;
}
| |
38,607 | js_free_message_pipe | bluesky950520[P]quickjs/quickjs-libc.c | static void js_free_message_pipe(JSWorkerMessagePipe *ps)
{
struct list_head *el, *el1;
JSWorkerMessage *msg;
int ref_count;
if (!ps)
return;
ref_count = atomic_add_int(&ps->ref_count, -1);
assert(ref_count >= 0);
if (ref_count == 0) {
list_for_each_safe(el, el1, &ps->msg_queue) {
msg = list_entry(el, JSWorkerMessage, link);
js_free_message(msg);
}
pthread_mutex_destroy(&ps->mutex);
close(ps->read_fd);
close(ps->write_fd);
free(ps);
}
} | O1 | c | js_free_message_pipe:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1542d
movq %rdi, %rbx
lock
decl (%rdi)
jne 0x1542d
leaq 0x30(%rbx), %r14
movq 0x38(%rbx), %rdi
cmpq %r14, %rdi
je 0x15407
movq 0x8(%rdi), %r15
callq 0x1afc6
movq %r15, %rdi
cmpq %r14, %r15
jne 0x153f6
leaq 0x8(%rbx), %rdi
callq 0xe2a0
movl 0x40(%rbx), %edi
callq 0xe3a0
movl 0x44(%rbx), %edi
callq 0xe3a0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xe060
popq %rbx
popq %r14
popq %r15
retq
| js_free_message_pipe:
push r15
push r14
push rbx
test rdi, rdi
jz short loc_1542D
mov rbx, rdi
lock dec dword ptr [rdi]
jnz short loc_1542D
lea r14, [rbx+30h]
mov rdi, [rbx+38h]
cmp rdi, r14
jz short loc_15407
loc_153F6:
mov r15, [rdi+8]
call js_free_message
mov rdi, r15
cmp r15, r14
jnz short loc_153F6
loc_15407:
lea rdi, [rbx+8]
call _pthread_mutex_destroy
mov edi, [rbx+40h]
call _close
mov edi, [rbx+44h]
call _close
mov rdi, rbx
pop rbx
pop r14
pop r15
jmp _free
loc_1542D:
pop rbx
pop r14
pop r15
retn
| long long js_free_message_pipe(long long a1)
{
long long v2; // r14
long long v3; // rdi
long long v4; // r15
long long result; // rax
if ( a1 && !_InterlockedDecrement((volatile signed __int32 *)a1) )
{
v2 = a1 + 48;
v3 = *(_QWORD *)(a1 + 56);
if ( v3 != a1 + 48 )
{
do
{
v4 = *(_QWORD *)(v3 + 8);
js_free_message();
v3 = v4;
}
while ( v4 != v2 );
}
pthread_mutex_destroy(a1 + 8);
close(*(unsigned int *)(a1 + 64));
close(*(unsigned int *)(a1 + 68));
return free(a1);
}
return result;
}
| |||
38,608 | js_free_message_pipe | bluesky950520[P]quickjs/quickjs-libc.c | static void js_free_message_pipe(JSWorkerMessagePipe *ps)
{
struct list_head *el, *el1;
JSWorkerMessage *msg;
int ref_count;
if (!ps)
return;
ref_count = atomic_add_int(&ps->ref_count, -1);
assert(ref_count >= 0);
if (ref_count == 0) {
list_for_each_safe(el, el1, &ps->msg_queue) {
msg = list_entry(el, JSWorkerMessage, link);
js_free_message(msg);
}
pthread_mutex_destroy(&ps->mutex);
close(ps->read_fd);
close(ps->write_fd);
free(ps);
}
} | O2 | c | js_free_message_pipe:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1038d
movq %rdi, %rbx
lock
decl (%rdi)
jne 0x1038d
leaq 0x30(%rbx), %r14
movq 0x38(%rbx), %rdi
cmpq %r14, %rdi
je 0x10393
movq 0x8(%rdi), %r15
callq 0x1589c
movq %r15, %rdi
jmp 0x1037a
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%rbx), %rdi
callq 0xe2b0
movl 0x40(%rbx), %edi
callq 0xe3b0
movl 0x44(%rbx), %edi
callq 0xe3b0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xe060
| js_free_message_pipe:
push r15
push r14
push rbx
test rdi, rdi
jz short loc_1038D
mov rbx, rdi
lock dec dword ptr [rdi]
jnz short loc_1038D
lea r14, [rbx+30h]
mov rdi, [rbx+38h]
loc_1037A:
cmp rdi, r14
jz short loc_10393
mov r15, [rdi+8]
call js_free_message
mov rdi, r15
jmp short loc_1037A
loc_1038D:
pop rbx
pop r14
pop r15
retn
loc_10393:
lea rdi, [rbx+8]
call _pthread_mutex_destroy
mov edi, [rbx+40h]
call _close
mov edi, [rbx+44h]
call _close
mov rdi, rbx
pop rbx
pop r14
pop r15
jmp _free
| long long js_free_message_pipe(long long a1)
{
long long v2; // r14
long long i; // rdi
long long v4; // r15
long long result; // rax
if ( a1 && !_InterlockedDecrement((volatile signed __int32 *)a1) )
{
v2 = a1 + 48;
for ( i = *(_QWORD *)(a1 + 56); i != v2; i = v4 )
{
v4 = *(_QWORD *)(i + 8);
js_free_message();
}
pthread_mutex_destroy(a1 + 8);
close(*(unsigned int *)(a1 + 64));
close(*(unsigned int *)(a1 + 68));
return free(a1);
}
return result;
}
| js_free_message_pipe:
PUSH R15
PUSH R14
PUSH RBX
TEST RDI,RDI
JZ 0x0011038d
MOV RBX,RDI
DEC.LOCK dword ptr [RDI]
JNZ 0x0011038d
LEA R14,[RBX + 0x30]
MOV RDI,qword ptr [RBX + 0x38]
LAB_0011037a:
CMP RDI,R14
JZ 0x00110393
MOV R15,qword ptr [RDI + 0x8]
CALL 0x0011589c
MOV RDI,R15
JMP 0x0011037a
LAB_0011038d:
POP RBX
POP R14
POP R15
RET
LAB_00110393:
LEA RDI,[RBX + 0x8]
CALL 0x0010e2b0
MOV EDI,dword ptr [RBX + 0x40]
CALL 0x0010e3b0
MOV EDI,dword ptr [RBX + 0x44]
CALL 0x0010e3b0
MOV RDI,RBX
POP RBX
POP R14
POP R15
JMP 0x0010e060
|
void js_free_message_pipe(int *param_1)
{
int *piVar1;
if (param_1 != (int *)0x0) {
LOCK();
*param_1 = *param_1 + -1;
UNLOCK();
if (*param_1 == 0) {
piVar1 = *(int **)(param_1 + 0xe);
while (piVar1 != param_1 + 0xc) {
piVar1 = *(int **)(piVar1 + 2);
js_free_message();
}
pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 2));
close(param_1[0x10]);
close(param_1[0x11]);
free(param_1);
return;
}
}
return;
}
| |
38,609 | ma_once_init_pack_row | eloqsql/storage/maria/ma_packrec.c | my_bool _ma_once_init_pack_row(MARIA_SHARE *share, File dfile)
{
share->options|= HA_OPTION_READ_ONLY_DATA;
return (_ma_read_pack_info(share, dfile,
(pbool)
MY_TEST(!(share->options &
(HA_OPTION_PACK_RECORD |
HA_OPTION_TEMP_COMPRESS_RECORD)))));
} | O0 | c | ma_once_init_pack_row:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x720(%rax), %rcx
orq $0x10000, %rcx # imm = 0x10000
movq %rcx, 0x720(%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movq 0x720(%rax), %rax
andq $0x8001, %rax # imm = 0x8001
cmpq $0x0, %rax
setne %dl
xorb $-0x1, %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movsbl %al, %edx
callq 0x3c650
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ma_once_init_pack_row:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov rax, [rbp+var_8]
mov rcx, [rax+720h]
or rcx, 10000h
mov [rax+720h], rcx
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov rax, [rbp+var_8]
mov rax, [rax+720h]
and rax, 8001h
cmp rax, 0
setnz dl
xor dl, 0FFh
xor eax, eax
mov ecx, 1
test dl, 1
cmovnz eax, ecx
movsx edx, al
call _ma_read_pack_info
add rsp, 10h
pop rbp
retn
| long long ma_once_init_pack_row(long long a1, unsigned int a2)
{
*(_QWORD *)(a1 + 1824) |= 0x10000uLL;
return ma_read_pack_info(a1, a2, (*(_QWORD *)(a1 + 1824) & 0x8001LL) == 0);
}
| _ma_once_init_pack_row:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x720]
OR RCX,0x10000
MOV qword ptr [RAX + 0x720],RCX
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x720]
AND RAX,0x8001
CMP RAX,0x0
SETNZ DL
XOR DL,0xff
XOR EAX,EAX
MOV ECX,0x1
TEST DL,0x1
CMOVNZ EAX,ECX
MOVSX EDX,AL
CALL 0x0013c650
ADD RSP,0x10
POP RBP
RET
|
void _ma_once_init_pack_row(long param_1,int4 param_2)
{
*(ulong *)(param_1 + 0x720) = *(ulong *)(param_1 + 0x720) | 0x10000;
_ma_read_pack_info(param_1,param_2,(*(ulong *)(param_1 + 0x720) & 0x8001) == 0);
return;
}
| |
38,610 | my_wc_mb_utf8mb4_no_range | eloqsql/strings/ctype-utf8.c | static int
my_wc_mb_utf8mb4_no_range(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *r)
{
int count;
if (wc < 0x80)
count= 1;
else if (wc < 0x800)
count= 2;
else if (wc < 0x10000)
count= 3;
else if (wc < 0x200000)
count= 4;
else
return MY_CS_ILUNI;
switch (count)
{
case 4: r[3]= (uchar) (0x80 | (wc & 0x3f)); wc= wc >> 6; wc |= 0x10000;
/* fall through */
case 3: r[2]= (uchar) (0x80 | (wc & 0x3f)); wc= wc >> 6; wc |= 0x800;
/* fall through */
case 2: r[1]= (uchar) (0x80 | (wc & 0x3f)); wc= wc >> 6; wc |= 0xc0;
/* fall through */
case 1: r[0]= (uchar) wc;
}
return count;
} | O0 | c | my_wc_mb_utf8mb4_no_range:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x80, -0x18(%rbp)
jae 0x722a3
movl $0x1, -0x24(%rbp)
jmp 0x722ee
cmpq $0x800, -0x18(%rbp) # imm = 0x800
jae 0x722b6
movl $0x2, -0x24(%rbp)
jmp 0x722ec
cmpq $0x10000, -0x18(%rbp) # imm = 0x10000
jae 0x722c9
movl $0x3, -0x24(%rbp)
jmp 0x722ea
cmpq $0x200000, -0x18(%rbp) # imm = 0x200000
jae 0x722dc
movl $0x4, -0x24(%rbp)
jmp 0x722e8
movl $0x0, -0x4(%rbp)
jmp 0x723bb
jmp 0x722ea
jmp 0x722ec
jmp 0x722ee
movl -0x24(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x3, %eax
ja 0x723b5
movq -0x30(%rbp), %rax
leaq 0x149043(%rip), %rcx # 0x1bb350
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
andq $0x3f, %rax
orq $0x80, %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x18(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
orq $0x10000, %rax # imm = 0x10000
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x3f, %rax
orq $0x80, %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x18(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
orq $0x800, %rax # imm = 0x800
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x3f, %rax
orq $0x80, %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x18(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
orq $0xc0, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
| my_wc_mb_utf8mb4_no_range:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
cmp [rbp+var_18], 80h
jnb short loc_722A3
mov [rbp+var_24], 1
jmp short loc_722EE
loc_722A3:
cmp [rbp+var_18], 800h
jnb short loc_722B6
mov [rbp+var_24], 2
jmp short loc_722EC
loc_722B6:
cmp [rbp+var_18], 10000h
jnb short loc_722C9
mov [rbp+var_24], 3
jmp short loc_722EA
loc_722C9:
cmp [rbp+var_18], offset unk_200000
jnb short loc_722DC
mov [rbp+var_24], 4
jmp short loc_722E8
loc_722DC:
mov [rbp+var_4], 0
jmp loc_723BB
loc_722E8:
jmp short $+2
loc_722EA:
jmp short $+2
loc_722EC:
jmp short $+2
loc_722EE:
mov eax, [rbp+var_24]
dec eax; switch 4 cases
mov ecx, eax
mov [rbp+var_30], rcx
sub eax, 3
ja def_72314; jumptable 0000000000072314 default case
mov rax, [rbp+var_30]
lea rcx, jpt_72314
movsxd rax, ds:(jpt_72314 - 1BB350h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_72316:
mov rax, [rbp+var_18]; jumptable 0000000000072314 case 4
and rax, 3Fh
or rax, 80h
mov cl, al
mov rax, [rbp+var_20]
mov [rax+3], cl
mov rax, [rbp+var_18]
shr rax, 6
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
or rax, 10000h
mov [rbp+var_18], rax
loc_72347:
mov rax, [rbp+var_18]; jumptable 0000000000072314 case 3
and rax, 3Fh
or rax, 80h
mov cl, al
mov rax, [rbp+var_20]
mov [rax+2], cl
mov rax, [rbp+var_18]
shr rax, 6
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
or rax, 800h
mov [rbp+var_18], rax
loc_72378:
mov rax, [rbp+var_18]; jumptable 0000000000072314 case 2
and rax, 3Fh
or rax, 80h
mov cl, al
mov rax, [rbp+var_20]
mov [rax+1], cl
mov rax, [rbp+var_18]
shr rax, 6
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
or rax, 0C0h
mov [rbp+var_18], rax
loc_723A9:
mov rax, [rbp+var_18]; jumptable 0000000000072314 case 1
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
def_72314:
mov eax, [rbp+var_24]; jumptable 0000000000072314 default case
mov [rbp+var_4], eax
loc_723BB:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_wc_mb_utf8mb4_no_range(long long a1, unsigned long long a2, _BYTE *a3)
{
unsigned int v4; // [rsp+Ch] [rbp-24h]
unsigned long long v5; // [rsp+18h] [rbp-18h]
v5 = a2;
if ( a2 >= 0x80 )
{
if ( a2 >= 0x800 )
{
if ( a2 >= 0x10000 )
{
if ( a2 >= (unsigned long long)&unk_200000 )
return 0;
v4 = 4;
}
else
{
v4 = 3;
}
}
else
{
v4 = 2;
}
}
else
{
v4 = 1;
}
switch ( v4 )
{
case 1u:
goto LABEL_14;
case 2u:
goto LABEL_13;
case 3u:
goto LABEL_12;
case 4u:
a3[3] = a2 & 0x3F | 0x80;
v5 = (a2 >> 6) | 0x10000;
LABEL_12:
a3[2] = v5 & 0x3F | 0x80;
v5 = (v5 >> 6) | 0x800;
LABEL_13:
a3[1] = v5 & 0x3F | 0x80;
v5 = (v5 >> 6) | 0xC0;
LABEL_14:
*a3 = v5;
break;
default:
break;
}
return v4;
}
| my_wc_mb_utf8mb4_no_range:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
CMP qword ptr [RBP + -0x18],0x80
JNC 0x001722a3
MOV dword ptr [RBP + -0x24],0x1
JMP 0x001722ee
LAB_001722a3:
CMP qword ptr [RBP + -0x18],0x800
JNC 0x001722b6
MOV dword ptr [RBP + -0x24],0x2
JMP 0x001722ec
LAB_001722b6:
CMP qword ptr [RBP + -0x18],0x10000
JNC 0x001722c9
MOV dword ptr [RBP + -0x24],0x3
JMP 0x001722ea
LAB_001722c9:
CMP qword ptr [RBP + -0x18],0x200000
JNC 0x001722dc
MOV dword ptr [RBP + -0x24],0x4
JMP 0x001722e8
LAB_001722dc:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001723bb
LAB_001722e8:
JMP 0x001722ea
LAB_001722ea:
JMP 0x001722ec
LAB_001722ec:
JMP 0x001722ee
LAB_001722ee:
MOV EAX,dword ptr [RBP + -0x24]
DEC EAX
MOV ECX,EAX
MOV qword ptr [RBP + -0x30],RCX
SUB EAX,0x3
JA 0x001723b5
MOV RAX,qword ptr [RBP + -0x30]
LEA RCX,[0x2bb350]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_4:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x3f
OR RAX,0x80
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x3],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x6
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
OR RAX,0x10000
MOV qword ptr [RBP + -0x18],RAX
caseD_3:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x3f
OR RAX,0x80
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x6
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
OR RAX,0x800
MOV qword ptr [RBP + -0x18],RAX
caseD_2:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x3f
OR RAX,0x80
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x6
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
OR RAX,0xc0
MOV qword ptr [RBP + -0x18],RAX
caseD_1:
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
default:
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
LAB_001723bb:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_wc_mb_utf8mb4_no_range(int8 param_1,ulong param_2,int1 *param_3)
{
int4 local_2c;
ulong local_20;
if (param_2 < 0x80) {
local_2c = 1;
}
else if (param_2 < 0x800) {
local_2c = 2;
}
else if (param_2 < 0x10000) {
local_2c = 3;
}
else {
if (0x1fffff < param_2) {
return 0;
}
local_2c = 4;
}
local_20 = param_2;
switch(local_2c) {
case 4:
param_3[3] = (byte)param_2 & 0x3f | 0x80;
local_20 = param_2 >> 6 | 0x10000;
case 3:
param_3[2] = (byte)local_20 & 0x3f | 0x80;
local_20 = local_20 >> 6 | 0x800;
case 2:
param_3[1] = (byte)local_20 & 0x3f | 0x80;
local_20 = local_20 >> 6 | 0xc0;
case 1:
*param_3 = (char)local_20;
return local_2c;
default:
return local_2c;
}
}
| |
38,611 | my_wc_mb_utf8mb4_no_range | eloqsql/strings/ctype-utf8.c | static int
my_wc_mb_utf8mb4_no_range(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *r)
{
int count;
if (wc < 0x80)
count= 1;
else if (wc < 0x800)
count= 2;
else if (wc < 0x10000)
count= 3;
else if (wc < 0x200000)
count= 4;
else
return MY_CS_ILUNI;
switch (count)
{
case 4: r[3]= (uchar) (0x80 | (wc & 0x3f)); wc= wc >> 6; wc |= 0x10000;
/* fall through */
case 3: r[2]= (uchar) (0x80 | (wc & 0x3f)); wc= wc >> 6; wc |= 0x800;
/* fall through */
case 2: r[1]= (uchar) (0x80 | (wc & 0x3f)); wc= wc >> 6; wc |= 0xc0;
/* fall through */
case 1: r[0]= (uchar) wc;
}
return count;
} | O3 | c | my_wc_mb_utf8mb4_no_range:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %eax
cmpq $0x80, %rdi
jb 0x57789
movl $0x2, %eax
cmpq $0x800, %rdi # imm = 0x800
jb 0x57773
movl $0x3, %eax
cmpq $0x10000, %rdi # imm = 0x10000
jb 0x5775d
xorl %eax, %eax
cmpq $0x1fffff, %rdi # imm = 0x1FFFFF
ja 0x5778c
movl %edi, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x3(%rsi)
shrq $0x6, %rdi
orq $0x10000, %rdi # imm = 0x10000
movl $0x4, %eax
movl %edi, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x2(%rsi)
shrq $0x6, %rdi
orq $0x800, %rdi # imm = 0x800
movl %edi, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x1(%rsi)
shrq $0x6, %rdi
orq $0xc0, %rdi
movb %dil, (%rsi)
popq %rbp
retq
| my_wc_mb_utf8mb4_no_range:
push rbp
mov rbp, rsp
mov eax, 1
cmp rdi, 80h
jb short loc_57789
mov eax, 2
cmp rdi, 800h
jb short loc_57773
mov eax, 3
cmp rdi, 10000h
jb short loc_5775D
xor eax, eax
cmp rdi, offset unk_1FFFFF
ja short loc_5778C
mov eax, edi
and al, 3Fh
or al, 80h
mov [rsi+3], al
shr rdi, 6
or rdi, 10000h
mov eax, 4
loc_5775D:
mov ecx, edi
and cl, 3Fh
or cl, 80h
mov [rsi+2], cl
shr rdi, 6
or rdi, 800h
loc_57773:
mov ecx, edi
and cl, 3Fh
or cl, 80h
mov [rsi+1], cl
shr rdi, 6
or rdi, 0C0h
loc_57789:
mov [rsi], dil
loc_5778C:
pop rbp
retn
| long long my_wc_mb_utf8mb4_no_range(unsigned long long a1, _BYTE *a2)
{
long long result; // rax
result = 1LL;
if ( a1 >= 0x80 )
{
result = 2LL;
if ( a1 >= 0x800 )
{
result = 3LL;
if ( a1 >= 0x10000 )
{
result = 0LL;
if ( a1 > (unsigned long long)&unk_1FFFFF )
return result;
a2[3] = a1 & 0x3F | 0x80;
a1 = (a1 >> 6) | 0x10000;
result = 4LL;
}
a2[2] = a1 & 0x3F | 0x80;
a1 = (a1 >> 6) | 0x800;
}
a2[1] = a1 & 0x3F | 0x80;
a1 = (a1 >> 6) | 0xC0;
}
*a2 = a1;
return result;
}
| my_wc_mb_utf8mb4_no_range:
PUSH RBP
MOV RBP,RSP
MOV EAX,0x1
CMP RDI,0x80
JC 0x00157789
MOV EAX,0x2
CMP RDI,0x800
JC 0x00157773
MOV EAX,0x3
CMP RDI,0x10000
JC 0x0015775d
XOR EAX,EAX
CMP RDI,0x1fffff
JA 0x0015778c
MOV EAX,EDI
AND AL,0x3f
OR AL,0x80
MOV byte ptr [RSI + 0x3],AL
SHR RDI,0x6
OR RDI,0x10000
MOV EAX,0x4
LAB_0015775d:
MOV ECX,EDI
AND CL,0x3f
OR CL,0x80
MOV byte ptr [RSI + 0x2],CL
SHR RDI,0x6
OR RDI,0x800
LAB_00157773:
MOV ECX,EDI
AND CL,0x3f
OR CL,0x80
MOV byte ptr [RSI + 0x1],CL
SHR RDI,0x6
OR RDI,0xc0
LAB_00157789:
MOV byte ptr [RSI],DIL
LAB_0015778c:
POP RBP
RET
|
int8 my_wc_mb_utf8mb4_no_range(ulong param_1,int1 *param_2)
{
int8 uVar1;
uVar1 = 1;
if (0x7f < param_1) {
uVar1 = 2;
if (0x7ff < param_1) {
uVar1 = 3;
if (0xffff < param_1) {
if (0x1fffff < param_1) {
return 0;
}
param_2[3] = (byte)param_1 & 0x3f | 0x80;
param_1 = param_1 >> 6 | 0x10000;
uVar1 = 4;
}
param_2[2] = (byte)param_1 & 0x3f | 0x80;
param_1 = param_1 >> 6 | 0x800;
}
param_2[1] = (byte)param_1 & 0x3f | 0x80;
param_1 = param_1 >> 6 | 0xc0;
}
*param_2 = (char)param_1;
return uVar1;
}
| |
38,612 | ACT_update_seed | xtate/src/xcmd.c | static ActRes ACT_update_seed(void *conf) {
XConf *xconf = conf;
uint64_t old = xconf->seed;
xconf->seed = get_one_entropy();
LOG(LEVEL_HINT, "updated seed from %" PRIu64 " to %" PRIu64 "\n", old,
xconf->seed);
return ActRes_Next;
} | O3 | c | ACT_update_seed:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x6b8(%rdi), %r14
callq 0x43d0c
movq %rax, 0x6b8(%rbx)
leaq 0x1f1cc(%rip), %rsi # 0x764ec
movl $0xfffffffe, %edi # imm = 0xFFFFFFFE
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x536da
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| ACT_update_seed:
push r14
push rbx
push rax
mov rbx, rdi
mov r14, [rdi+6B8h]
call get_one_entropy
mov [rbx+6B8h], rax
lea rsi, aUpdatedSeedFro; "updated seed from %lu to %lu\n"
mov edi, 0FFFFFFFEh
mov rdx, r14
mov rcx, rax
xor eax, eax
call LOG
xor eax, eax
add rsp, 8
pop rbx
pop r14
retn
| long long ACT_update_seed(
long long a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
double a6,
double a7,
__m128 a8,
__m128 a9)
{
char v9; // al
long long v10; // r14
long long one_entropy; // rax
long long v12; // r8
long long v13; // r9
__m128 v14; // xmm4
__m128 v15; // xmm5
char v17; // [rsp-8h] [rbp-18h]
v17 = v9;
v10 = *(_QWORD *)(a1 + 1720);
one_entropy = get_one_entropy();
*(_QWORD *)(a1 + 1720) = one_entropy;
LOG(-2, (long long)"updated seed from %lu to %lu\n", v10, one_entropy, v12, v13, a2, a3, a4, a5, v14, v15, a8, a9, v17);
return 0LL;
}
| ACT_update_seed:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R14,qword ptr [RDI + 0x6b8]
CALL 0x00143d0c
MOV qword ptr [RBX + 0x6b8],RAX
LEA RSI,[0x1764ec]
MOV EDI,0xfffffffe
MOV RDX,R14
MOV RCX,RAX
XOR EAX,EAX
CALL 0x001536da
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R14
RET
|
int8 ACT_update_seed(long param_1)
{
int8 uVar1;
int8 uVar2;
uVar1 = *(int8 *)(param_1 + 0x6b8);
uVar2 = get_one_entropy();
*(int8 *)(param_1 + 0x6b8) = uVar2;
LOG(0xfffffffe,"updated seed from %lu to %lu\n",uVar1,uVar2);
return 0;
}
| |
38,613 | bf_set_ui | bluesky950520[P]quickjs/libbf.c | int bf_set_ui(bf_t *r, uint64_t a)
{
r->sign = 0;
if (a == 0) {
r->expn = BF_EXP_ZERO;
bf_resize(r, 0); /* cannot fail */
}
#if LIMB_BITS == 32
else if (a <= 0xffffffff)
#else
else
#endif
{
int shift;
if (bf_resize(r, 1))
goto fail;
shift = clz(a);
r->tab[0] = a << shift;
r->expn = LIMB_BITS - shift;
}
#if LIMB_BITS == 32
else {
uint32_t a1, a0;
int shift;
if (bf_resize(r, 2))
goto fail;
a0 = a;
a1 = a >> 32;
shift = clz(a1);
r->tab[0] = a0 << shift;
r->tab[1] = shld(a1, a0, shift);
r->expn = 2 * LIMB_BITS - shift;
}
#endif
return 0;
fail:
bf_set_nan(r);
return BF_ST_MEM_ERROR;
} | O0 | c | bf_set_ui:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl $0x0, 0x8(%rax)
cmpq $0x0, 0x10(%rsp)
jne 0xec3d5
movq 0x18(%rsp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xec2c0
jmp 0xec429
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0xec2c0
cmpl $0x0, %eax
je 0xec3eb
jmp 0xec433
movq 0x10(%rsp), %rdi
callq 0xec450
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
shlq %cl, %rax
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq %rcx, (%rax)
movl $0x40, %eax
subl 0xc(%rsp), %eax
movslq %eax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, 0x24(%rsp)
jmp 0xec445
movq 0x18(%rsp), %rdi
callq 0xec490
movl $0x20, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
| bf_set_ui:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_18], rsi
mov rax, [rsp+28h+var_10]
mov dword ptr [rax+8], 0
cmp [rsp+28h+var_18], 0
jnz short loc_EC3D5
mov rax, [rsp+28h+var_10]
mov rcx, 8000000000000000h
mov [rax+10h], rcx
mov rdi, [rsp+28h+var_10]
xor eax, eax
mov esi, eax
call bf_resize
jmp short loc_EC429
loc_EC3D5:
mov rdi, [rsp+28h+var_10]
mov esi, 1
call bf_resize
cmp eax, 0
jz short loc_EC3EB
jmp short loc_EC433
loc_EC3EB:
mov rdi, [rsp+28h+var_18]
call clz
mov [rsp+28h+var_1C], eax
mov rax, [rsp+28h+var_18]
mov ecx, [rsp+28h+var_1C]
shl rax, cl
mov rcx, rax
mov rax, [rsp+28h+var_10]
mov rax, [rax+20h]
mov [rax], rcx
mov eax, 40h ; '@'
sub eax, [rsp+28h+var_1C]
movsxd rcx, eax
mov rax, [rsp+28h+var_10]
mov [rax+10h], rcx
loc_EC429:
mov [rsp+28h+var_4], 0
jmp short loc_EC445
loc_EC433:
mov rdi, [rsp+28h+var_10]
call bf_set_nan
mov [rsp+28h+var_4], 20h ; ' '
loc_EC445:
mov eax, [rsp+28h+var_4]
add rsp, 28h
retn
| long long bf_set_ui(long long a1, long long a2)
{
int v2; // eax
*(_DWORD *)(a1 + 8) = 0;
if ( a2 )
{
if ( (unsigned int)bf_resize((_QWORD *)a1, 1LL) )
{
bf_set_nan(a1);
return 32;
}
v2 = clz(a2);
**(_QWORD **)(a1 + 32) = a2 << v2;
*(_QWORD *)(a1 + 16) = 64 - v2;
}
else
{
*(_QWORD *)(a1 + 16) = 0x8000000000000000LL;
bf_resize((_QWORD *)a1, 0LL);
}
return 0;
}
| bf_set_ui:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x10],RSI
MOV RAX,qword ptr [RSP + 0x18]
MOV dword ptr [RAX + 0x8],0x0
CMP qword ptr [RSP + 0x10],0x0
JNZ 0x001ec3d5
MOV RAX,qword ptr [RSP + 0x18]
MOV RCX,-0x8000000000000000
MOV qword ptr [RAX + 0x10],RCX
MOV RDI,qword ptr [RSP + 0x18]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x001ec2c0
JMP 0x001ec429
LAB_001ec3d5:
MOV RDI,qword ptr [RSP + 0x18]
MOV ESI,0x1
CALL 0x001ec2c0
CMP EAX,0x0
JZ 0x001ec3eb
JMP 0x001ec433
LAB_001ec3eb:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001ec450
MOV dword ptr [RSP + 0xc],EAX
MOV RAX,qword ptr [RSP + 0x10]
MOV ECX,dword ptr [RSP + 0xc]
SHL RAX,CL
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RAX],RCX
MOV EAX,0x40
SUB EAX,dword ptr [RSP + 0xc]
MOVSXD RCX,EAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x10],RCX
LAB_001ec429:
MOV dword ptr [RSP + 0x24],0x0
JMP 0x001ec445
LAB_001ec433:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001ec490
MOV dword ptr [RSP + 0x24],0x20
LAB_001ec445:
MOV EAX,dword ptr [RSP + 0x24]
ADD RSP,0x28
RET
|
int4 bf_set_ui(long param_1,long param_2)
{
int iVar1;
*(int4 *)(param_1 + 8) = 0;
if (param_2 == 0) {
*(int8 *)(param_1 + 0x10) = 0x8000000000000000;
bf_resize(param_1,0);
}
else {
iVar1 = bf_resize(param_1,1);
if (iVar1 != 0) {
bf_set_nan(param_1);
return 0x20;
}
iVar1 = clz(param_2);
**(long **)(param_1 + 0x20) = param_2 << ((byte)iVar1 & 0x3f);
*(long *)(param_1 + 0x10) = (long)(0x40 - iVar1);
}
return 0;
}
| |
38,614 | bf_set_ui | bluesky950520[P]quickjs/libbf.c | int bf_set_ui(bf_t *r, uint64_t a)
{
r->sign = 0;
if (a == 0) {
r->expn = BF_EXP_ZERO;
bf_resize(r, 0); /* cannot fail */
}
#if LIMB_BITS == 32
else if (a <= 0xffffffff)
#else
else
#endif
{
int shift;
if (bf_resize(r, 1))
goto fail;
shift = clz(a);
r->tab[0] = a << shift;
r->expn = LIMB_BITS - shift;
}
#if LIMB_BITS == 32
else {
uint32_t a1, a0;
int shift;
if (bf_resize(r, 2))
goto fail;
a0 = a;
a1 = a >> 32;
shift = clz(a1);
r->tab[0] = a0 << shift;
r->tab[1] = shld(a1, a0, shift);
r->expn = 2 * LIMB_BITS - shift;
}
#endif
return 0;
fail:
bf_set_nan(r);
return BF_ST_MEM_ERROR;
} | O2 | c | bf_set_ui:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andl $0x0, 0x8(%rdi)
testq %rsi, %rsi
je 0x73136
movq %rsi, %r14
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x730bf
testl %eax, %eax
je 0x73153
movq %rbx, %rdi
callq 0x7317d
pushq $0x20
popq %r14
jmp 0x73172
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x10(%rbx)
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x730bf
jmp 0x73172
bsrq %r14, %rcx
xorq $0x3f, %rcx
shlq %cl, %r14
movq 0x20(%rbx), %rax
movq %r14, (%rax)
pushq $0x40
popq %rax
subq %rcx, %rax
movq %rax, 0x10(%rbx)
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| bf_set_ui:
push r14
push rbx
push rax
mov rbx, rdi
and dword ptr [rdi+8], 0
test rsi, rsi
jz short loc_73136
mov r14, rsi
push 1
pop rsi
mov rdi, rbx
call bf_resize
test eax, eax
jz short loc_73153
mov rdi, rbx
call bf_set_nan
push 20h ; ' '
pop r14
jmp short loc_73172
loc_73136:
mov rax, 8000000000000000h
mov [rbx+10h], rax
xor r14d, r14d
mov rdi, rbx
xor esi, esi
call bf_resize
jmp short loc_73172
loc_73153:
bsr rcx, r14
xor rcx, 3Fh
shl r14, cl
mov rax, [rbx+20h]
mov [rax], r14
push 40h ; '@'
pop rax
sub rax, rcx
mov [rbx+10h], rax
xor r14d, r14d
loc_73172:
mov eax, r14d
add rsp, 8
pop rbx
pop r14
retn
| long long bf_set_ui(long long a1, unsigned long long a2)
{
unsigned int v2; // r14d
unsigned long long v3; // rcx
*(_DWORD *)(a1 + 8) = 0;
if ( a2 )
{
if ( (unsigned int)bf_resize(a1, 1LL) )
{
bf_set_nan(a1);
return 32;
}
else
{
_BitScanReverse64(&v3, a2);
v3 ^= 0x3FuLL;
**(_QWORD **)(a1 + 32) = a2 << v3;
*(_QWORD *)(a1 + 16) = 64 - v3;
return 0;
}
}
else
{
*(_QWORD *)(a1 + 16) = 0x8000000000000000LL;
v2 = 0;
bf_resize(a1, 0LL);
}
return v2;
}
| bf_set_ui:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
AND dword ptr [RDI + 0x8],0x0
TEST RSI,RSI
JZ 0x00173136
MOV R14,RSI
PUSH 0x1
POP RSI
MOV RDI,RBX
CALL 0x001730bf
TEST EAX,EAX
JZ 0x00173153
MOV RDI,RBX
CALL 0x0017317d
PUSH 0x20
POP R14
JMP 0x00173172
LAB_00173136:
MOV RAX,-0x8000000000000000
MOV qword ptr [RBX + 0x10],RAX
XOR R14D,R14D
MOV RDI,RBX
XOR ESI,ESI
CALL 0x001730bf
JMP 0x00173172
LAB_00173153:
BSR RCX,R14
XOR RCX,0x3f
SHL R14,CL
MOV RAX,qword ptr [RBX + 0x20]
MOV qword ptr [RAX],R14
PUSH 0x40
POP RAX
SUB RAX,RCX
MOV qword ptr [RBX + 0x10],RAX
XOR R14D,R14D
LAB_00173172:
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R14
RET
|
int8 bf_set_ui(long param_1,ulong param_2)
{
ulong uVar1;
int iVar2;
int8 uVar3;
*(int4 *)(param_1 + 8) = 0;
if (param_2 == 0) {
*(int8 *)(param_1 + 0x10) = 0x8000000000000000;
uVar3 = 0;
bf_resize(param_1,0);
}
else {
iVar2 = bf_resize(param_1,1);
if (iVar2 == 0) {
uVar1 = 0x3f;
if (param_2 != 0) {
for (; param_2 >> uVar1 == 0; uVar1 = uVar1 - 1) {
}
}
**(long **)(param_1 + 0x20) = param_2 << ((byte)(uVar1 ^ 0x3f) & 0x3f);
*(ulong *)(param_1 + 0x10) = 0x40 - (uVar1 ^ 0x3f);
uVar3 = 0;
}
else {
bf_set_nan(param_1);
uVar3 = 0x20;
}
}
return uVar3;
}
| |
38,615 | bf_set_ui | bluesky950520[P]quickjs/libbf.c | int bf_set_ui(bf_t *r, uint64_t a)
{
r->sign = 0;
if (a == 0) {
r->expn = BF_EXP_ZERO;
bf_resize(r, 0); /* cannot fail */
}
#if LIMB_BITS == 32
else if (a <= 0xffffffff)
#else
else
#endif
{
int shift;
if (bf_resize(r, 1))
goto fail;
shift = clz(a);
r->tab[0] = a << shift;
r->expn = LIMB_BITS - shift;
}
#if LIMB_BITS == 32
else {
uint32_t a1, a0;
int shift;
if (bf_resize(r, 2))
goto fail;
a0 = a;
a1 = a >> 32;
shift = clz(a1);
r->tab[0] = a0 << shift;
r->tab[1] = shld(a1, a0, shift);
r->expn = 2 * LIMB_BITS - shift;
}
#endif
return 0;
fail:
bf_set_nan(r);
return BF_ST_MEM_ERROR;
} | O3 | c | bf_set_ui:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x0, 0x8(%rdi)
testq %rsi, %rsi
je 0x8b533
movq %rsi, %r14
cmpq $0x1, 0x18(%rbx)
jne 0x8b56b
movq 0x20(%rbx), %rax
jmp 0x8b58e
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
incq %rax
movq %rax, 0x10(%rbx)
cmpq $0x0, 0x18(%rbx)
je 0x8b5a8
movq (%rbx), %rax
movq 0x20(%rbx), %rsi
movq (%rax), %rdi
xorl %r14d, %r14d
xorl %edx, %edx
callq *0x8(%rax)
movq %rax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
jmp 0x8b5ab
movq (%rbx), %rax
movq 0x20(%rbx), %rsi
movq (%rax), %rdi
movl $0x8, %edx
callq *0x8(%rax)
testq %rax, %rax
je 0x8b5b6
movq %rax, 0x20(%rbx)
movq $0x1, 0x18(%rbx)
bsrq %r14, %rcx
xorq $0x3f, %rcx
shlq %cl, %r14
movq %r14, (%rax)
movl $0x40, %eax
subq %rcx, %rax
movq %rax, 0x10(%rbx)
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpq $0x0, 0x18(%rbx)
je 0x8b5d8
movq (%rbx), %rax
movq 0x20(%rbx), %rsi
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
movq %rax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, 0x10(%rbx)
movl $0x0, 0x8(%rbx)
movl $0x20, %r14d
jmp 0x8b5ab
| bf_set_ui:
push r14
push rbx
push rax
mov rbx, rdi
mov dword ptr [rdi+8], 0
test rsi, rsi
jz short loc_8B533
mov r14, rsi
cmp qword ptr [rbx+18h], 1
jnz short loc_8B56B
mov rax, [rbx+20h]
jmp short loc_8B58E
loc_8B533:
mov rax, 7FFFFFFFFFFFFFFFh
inc rax
mov [rbx+10h], rax
cmp qword ptr [rbx+18h], 0
jz short loc_8B5A8
mov rax, [rbx]
mov rsi, [rbx+20h]
mov rdi, [rax]
xor r14d, r14d
xor edx, edx
call qword ptr [rax+8]
mov [rbx+20h], rax
mov qword ptr [rbx+18h], 0
jmp short loc_8B5AB
loc_8B56B:
mov rax, [rbx]
mov rsi, [rbx+20h]
mov rdi, [rax]
mov edx, 8
call qword ptr [rax+8]
test rax, rax
jz short loc_8B5B6
mov [rbx+20h], rax
mov qword ptr [rbx+18h], 1
loc_8B58E:
bsr rcx, r14
xor rcx, 3Fh
shl r14, cl
mov [rax], r14
mov eax, 40h ; '@'
sub rax, rcx
mov [rbx+10h], rax
loc_8B5A8:
xor r14d, r14d
loc_8B5AB:
mov eax, r14d
add rsp, 8
pop rbx
pop r14
retn
loc_8B5B6:
cmp qword ptr [rbx+18h], 0
jz short loc_8B5D8
mov rax, [rbx]
mov rsi, [rbx+20h]
mov rdi, [rax]
xor edx, edx
call qword ptr [rax+8]
mov [rbx+20h], rax
mov qword ptr [rbx+18h], 0
loc_8B5D8:
mov rax, 7FFFFFFFFFFFFFFFh
mov [rbx+10h], rax
mov dword ptr [rbx+8], 0
mov r14d, 20h ; ' '
jmp short loc_8B5AB
| long long bf_set_ui(_QWORD **a1, unsigned long long a2)
{
_QWORD *v2; // rax
unsigned int v3; // r14d
unsigned long long v4; // rcx
*((_DWORD *)a1 + 2) = 0;
if ( a2 )
{
if ( a1[3] == (_QWORD *)((char *)&dword_0 + 1) )
{
v2 = a1[4];
LABEL_8:
_BitScanReverse64(&v4, a2);
v4 ^= 0x3FuLL;
*v2 = a2 << v4;
a1[2] = (_QWORD *)(64 - v4);
return 0;
}
v2 = (_QWORD *)((long long ( *)(_QWORD, _QWORD *, long long))(*a1)[1])(**a1, a1[4], 8LL);
if ( v2 )
{
a1[4] = v2;
a1[3] = (_QWORD *)(&dword_0 + 1);
goto LABEL_8;
}
if ( a1[3] )
{
a1[4] = (_QWORD *)((long long ( *)(_QWORD, _QWORD *, _QWORD))(*a1)[1])(**a1, a1[4], 0LL);
a1[3] = 0LL;
}
a1[2] = (_QWORD *)0x7FFFFFFFFFFFFFFFLL;
*((_DWORD *)a1 + 2) = 0;
return 32;
}
else
{
a1[2] = (_QWORD *)0x8000000000000000LL;
if ( !a1[3] )
return 0;
v3 = 0;
a1[4] = (_QWORD *)((long long ( *)(_QWORD, _QWORD *, _QWORD))(*a1)[1])(**a1, a1[4], 0LL);
a1[3] = 0LL;
}
return v3;
}
| bf_set_ui:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV dword ptr [RDI + 0x8],0x0
TEST RSI,RSI
JZ 0x0018b533
MOV R14,RSI
CMP qword ptr [RBX + 0x18],0x1
JNZ 0x0018b56b
MOV RAX,qword ptr [RBX + 0x20]
JMP 0x0018b58e
LAB_0018b533:
MOV RAX,0x7fffffffffffffff
INC RAX
MOV qword ptr [RBX + 0x10],RAX
CMP qword ptr [RBX + 0x18],0x0
JZ 0x0018b5a8
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RAX]
XOR R14D,R14D
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x18],0x0
JMP 0x0018b5ab
LAB_0018b56b:
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RAX]
MOV EDX,0x8
CALL qword ptr [RAX + 0x8]
TEST RAX,RAX
JZ 0x0018b5b6
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x18],0x1
LAB_0018b58e:
BSR RCX,R14
XOR RCX,0x3f
SHL R14,CL
MOV qword ptr [RAX],R14
MOV EAX,0x40
SUB RAX,RCX
MOV qword ptr [RBX + 0x10],RAX
LAB_0018b5a8:
XOR R14D,R14D
LAB_0018b5ab:
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_0018b5b6:
CMP qword ptr [RBX + 0x18],0x0
JZ 0x0018b5d8
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RAX]
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x18],0x0
LAB_0018b5d8:
MOV RAX,0x7fffffffffffffff
MOV qword ptr [RBX + 0x10],RAX
MOV dword ptr [RBX + 0x8],0x0
MOV R14D,0x20
JMP 0x0018b5ab
|
int8 bf_set_ui(long *param_1,ulong param_2)
{
ulong uVar1;
long *plVar2;
long lVar3;
*(int4 *)(param_1 + 1) = 0;
if (param_2 == 0) {
param_1[2] = -0x8000000000000000;
if (param_1[3] != 0) {
lVar3 = (*(code *)((int8 *)*param_1)[1])(*(int8 *)*param_1,param_1[4],0);
param_1[4] = lVar3;
param_1[3] = 0;
return 0;
}
}
else {
if (param_1[3] == 1) {
plVar2 = (long *)param_1[4];
}
else {
plVar2 = (long *)(*(code *)((int8 *)*param_1)[1])(*(int8 *)*param_1,param_1[4],8);
if (plVar2 == (long *)0x0) {
if (param_1[3] != 0) {
lVar3 = (*(code *)((int8 *)*param_1)[1])(*(int8 *)*param_1,param_1[4],0);
param_1[4] = lVar3;
param_1[3] = 0;
}
param_1[2] = 0x7fffffffffffffff;
*(int4 *)(param_1 + 1) = 0;
return 0x20;
}
param_1[4] = (long)plVar2;
param_1[3] = 1;
}
uVar1 = 0x3f;
if (param_2 != 0) {
for (; param_2 >> uVar1 == 0; uVar1 = uVar1 - 1) {
}
}
*plVar2 = param_2 << ((byte)(uVar1 ^ 0x3f) & 0x3f);
param_1[2] = 0x40 - (uVar1 ^ 0x3f);
}
return 0;
}
| |
38,616 | ma_init_alloc_root | eloqsql/libmariadb/libmariadb/ma_alloc.c | void ma_init_alloc_root(MA_MEM_ROOT *mem_root, size_t block_size, size_t pre_alloc_size)
{
mem_root->free= mem_root->used= mem_root->pre_alloc= 0;
mem_root->min_malloc=32;
mem_root->block_size= (block_size-MALLOC_OVERHEAD-sizeof(MA_USED_MEM)+8);
mem_root->error_handler=0;
mem_root->block_num= 4;
mem_root->first_block_usage= 0;
#if !(defined(HAVE_purify) && defined(EXTRA_DEBUG))
if (pre_alloc_size)
{
if ((mem_root->free = mem_root->pre_alloc=
(MA_USED_MEM*) malloc(pre_alloc_size+ ALIGN_SIZE(sizeof(MA_USED_MEM)))))
{
mem_root->free->size=pre_alloc_size+ALIGN_SIZE(sizeof(MA_USED_MEM));
mem_root->free->left=pre_alloc_size;
mem_root->free->next=0;
}
}
#endif
} | O3 | c | ma_init_alloc_root:
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movq $0x20, 0x18(%rdi)
addq $-0x18, %rsi
movq %rsi, 0x20(%rdi)
movq %rax, 0x30(%rdi)
movq $0x4, 0x28(%rdi)
testq %rdx, %rdx
je 0x1c556
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x18(%rdx), %r15
movq %r15, %rdi
callq 0x135d0
movq %rax, 0x10(%r14)
movq %rax, (%r14)
testq %rax, %rax
je 0x1c54c
movq %r15, 0x10(%rax)
movq %rbx, 0x8(%rax)
movq $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| ma_init_alloc_root:
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
xor eax, eax
mov [rdi+10h], rax
mov qword ptr [rdi+18h], 20h ; ' '
add rsi, 0FFFFFFFFFFFFFFE8h
mov [rdi+20h], rsi
mov [rdi+30h], rax
mov qword ptr [rdi+28h], 4
test rdx, rdx
jz short locret_1C556
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdx
mov r14, rdi
lea r15, [rdx+18h]
mov rdi, r15
call _malloc
mov [r14+10h], rax
mov [r14], rax
test rax, rax
jz short loc_1C54C
mov [rax+10h], r15
mov [rax+8], rbx
mov qword ptr [rax], 0
loc_1C54C:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
locret_1C556:
retn
| _QWORD * ma_init_alloc_root(long long a1, long long a2, long long a3)
{
_QWORD *result; // rax
long long v5; // r15
*(_OWORD *)a1 = 0LL;
result = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
*(_QWORD *)(a1 + 24) = 32LL;
*(_QWORD *)(a1 + 32) = a2 - 24;
*(_QWORD *)(a1 + 48) = 0LL;
*(_QWORD *)(a1 + 40) = 4LL;
if ( a3 )
{
v5 = a3 + 24;
result = (_QWORD *)malloc(a3 + 24);
*(_QWORD *)(a1 + 16) = result;
*(_QWORD *)a1 = result;
if ( result )
{
result[2] = v5;
result[1] = a3;
*result = 0LL;
}
}
return result;
}
| ma_init_alloc_root:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],RAX
MOV qword ptr [RDI + 0x18],0x20
ADD RSI,-0x18
MOV qword ptr [RDI + 0x20],RSI
MOV qword ptr [RDI + 0x30],RAX
MOV qword ptr [RDI + 0x28],0x4
TEST RDX,RDX
JZ 0x0011c556
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RDI
LEA R15,[RDX + 0x18]
MOV RDI,R15
CALL 0x001135d0
MOV qword ptr [R14 + 0x10],RAX
MOV qword ptr [R14],RAX
TEST RAX,RAX
JZ 0x0011c54c
MOV qword ptr [RAX + 0x10],R15
MOV qword ptr [RAX + 0x8],RBX
MOV qword ptr [RAX],0x0
LAB_0011c54c:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
LAB_0011c556:
RET
|
void ma_init_alloc_root(int8 *param_1,long param_2,long param_3)
{
int8 *puVar1;
*param_1 = 0;
param_1[1] = 0;
param_1[2] = 0;
param_1[3] = 0x20;
param_1[4] = param_2 + -0x18;
param_1[6] = 0;
param_1[5] = 4;
if (param_3 != 0) {
puVar1 = (int8 *)malloc(param_3 + 0x18U);
param_1[2] = puVar1;
*param_1 = puVar1;
if (puVar1 != (int8 *)0x0) {
puVar1[2] = param_3 + 0x18U;
puVar1[1] = param_3;
*puVar1 = 0;
}
}
return;
}
| |
38,617 | ggml_compute_forward_sum_f16 | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | static void ggml_compute_forward_sum_f16(
const struct ggml_compute_params * params,
const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
assert(params->ith == 0);
assert(ggml_is_scalar(dst));
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
return;
}
assert(src0->nb[0] == sizeof(ggml_fp16_t));
GGML_TENSOR_LOCALS(int64_t, ne0, src0, ne)
GGML_TENSOR_LOCALS(size_t, nb0, src0, nb)
float sum = 0;
float row_sum = 0;
for (int64_t i03 = 0; i03 < ne03; i03++) {
for (int64_t i02 = 0; i02 < ne02; i02++) {
for (int64_t i01 = 0; i01 < ne01; i01++) {
ggml_vec_sum_f16_ggf(ne00,
&row_sum,
(ggml_fp16_t *) ((char *) src0->data + i01 * nb01 + i02 * nb02 + i03 * nb03));
sum += row_sum;
}
}
}
((ggml_fp16_t *) dst->data)[0] = GGML_FP32_TO_FP16(sum);
} | O0 | c | ggml_compute_forward_sum_f16:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rax
cmpl $0x0, (%rax)
je 0x14d459
movq 0x90(%rsp), %rax
cmpl $0x2, (%rax)
jne 0x14d45e
jmp 0x14d60d
movq 0x88(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x78(%rsp)
movq 0x88(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x88(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x68(%rsp)
movq 0x88(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x60(%rsp)
movq 0x88(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x88(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x88(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x88(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x40(%rsp)
vxorps %xmm0, %xmm0, %xmm0
vmovss %xmm0, 0x3c(%rsp)
vxorps %xmm0, %xmm0, %xmm0
vmovss %xmm0, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x60(%rsp), %rax
jge 0x14d5d7
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x68(%rsp), %rax
jge 0x14d5c2
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x70(%rsp), %rax
jge 0x14d5ad
movq 0x78(%rsp), %rax
movl %eax, %edi
movq 0x88(%rsp), %rax
movq 0x118(%rax), %rdx
movq 0x20(%rsp), %rax
imulq 0x50(%rsp), %rax
addq %rax, %rdx
movq 0x28(%rsp), %rax
imulq 0x48(%rsp), %rax
addq %rax, %rdx
movq 0x30(%rsp), %rax
imulq 0x40(%rsp), %rax
addq %rax, %rdx
leaq 0x38(%rsp), %rsi
callq 0x14d690
vmovss 0x38(%rsp), %xmm0
vaddss 0x3c(%rsp), %xmm0, %xmm0
vmovss %xmm0, 0x3c(%rsp)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x14d535
jmp 0x14d5af
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x14d51c
jmp 0x14d5c4
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x14d503
vmovss 0x3c(%rsp), %xmm0
vmovaps %xmm0, (%rsp)
vmovaps (%rsp), %xmm0
vcvtps2ph $0x0, %xmm0, %xmm0
vmovd %xmm0, %eax
movw %ax, 0x1e(%rsp)
movw 0x1e(%rsp), %cx
movq 0x80(%rsp), %rax
movq 0x118(%rax), %rax
movw %cx, (%rax)
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
| ggml_compute_forward_sum_f16:
sub rsp, 98h
mov [rsp+98h+var_8], rdi
mov [rsp+98h+var_10], rsi
mov [rsp+98h+var_18], rdx
mov rax, [rsp+98h+var_8]
cmp dword ptr [rax], 0
jz short loc_14D459
mov rax, [rsp+98h+var_8]
cmp dword ptr [rax], 2
jnz short loc_14D45E
loc_14D459:
jmp loc_14D60D
loc_14D45E:
mov rax, [rsp+98h+var_10]
mov rax, [rax+10h]
mov [rsp+98h+var_20], rax
mov rax, [rsp+98h+var_10]
mov rax, [rax+18h]
mov [rsp+98h+var_28], rax
mov rax, [rsp+98h+var_10]
mov rax, [rax+20h]
mov [rsp+98h+var_30], rax
mov rax, [rsp+98h+var_10]
mov rax, [rax+28h]
mov [rsp+98h+var_38], rax
mov rax, [rsp+98h+var_10]
mov rax, [rax+30h]
mov [rsp+98h+var_40], rax
mov rax, [rsp+98h+var_10]
mov rax, [rax+38h]
mov [rsp+98h+var_48], rax
mov rax, [rsp+98h+var_10]
mov rax, [rax+40h]
mov [rsp+98h+var_50], rax
mov rax, [rsp+98h+var_10]
mov rax, [rax+48h]
mov [rsp+98h+var_58], rax
vxorps xmm0, xmm0, xmm0
vmovss [rsp+98h+var_5C], xmm0
vxorps xmm0, xmm0, xmm0
vmovss [rsp+98h+var_60], xmm0
mov [rsp+98h+var_68], 0
loc_14D503:
mov rax, [rsp+98h+var_68]
cmp rax, [rsp+98h+var_38]
jge loc_14D5D7
mov [rsp+98h+var_70], 0
loc_14D51C:
mov rax, [rsp+98h+var_70]
cmp rax, [rsp+98h+var_30]
jge loc_14D5C2
mov [rsp+98h+var_78], 0
loc_14D535:
mov rax, [rsp+98h+var_78]
cmp rax, [rsp+98h+var_28]
jge short loc_14D5AD
mov rax, [rsp+98h+var_20]
mov edi, eax
mov rax, [rsp+98h+var_10]
mov rdx, [rax+118h]
mov rax, [rsp+98h+var_78]
imul rax, [rsp+98h+var_48]
add rdx, rax
mov rax, [rsp+98h+var_70]
imul rax, [rsp+98h+var_50]
add rdx, rax
mov rax, [rsp+98h+var_68]
imul rax, [rsp+98h+var_58]
add rdx, rax
lea rsi, [rsp+98h+var_60]
call ggml_vec_sum_f16_ggf
vmovss xmm0, [rsp+98h+var_60]
vaddss xmm0, xmm0, [rsp+98h+var_5C]
vmovss [rsp+98h+var_5C], xmm0
mov rax, [rsp+98h+var_78]
add rax, 1
mov [rsp+98h+var_78], rax
jmp short loc_14D535
loc_14D5AD:
jmp short $+2
loc_14D5AF:
mov rax, [rsp+98h+var_70]
add rax, 1
mov [rsp+98h+var_70], rax
jmp loc_14D51C
loc_14D5C2:
jmp short $+2
loc_14D5C4:
mov rax, [rsp+98h+var_68]
add rax, 1
mov [rsp+98h+var_68], rax
jmp loc_14D503
loc_14D5D7:
vmovss xmm0, [rsp+98h+var_5C]
vmovaps [rsp+98h+var_98], xmm0
vmovaps xmm0, [rsp+98h+var_98]
vcvtps2ph xmm0, xmm0, 0
vmovd eax, xmm0
mov [rsp+98h+var_7A], ax
mov cx, [rsp+98h+var_7A]
mov rax, [rsp+98h+var_18]
mov rax, [rax+118h]
mov [rax], cx
loc_14D60D:
add rsp, 98h
retn
| _WORD * ggml_compute_forward_sum_f16(_DWORD *a1, _QWORD *a2, long long a3, __m128 _XMM0)
{
_WORD *result; // rax
__int16 v13; // cx
long long k; // [rsp+20h] [rbp-78h]
long long j; // [rsp+28h] [rbp-70h]
long long i; // [rsp+30h] [rbp-68h]
int v18; // [rsp+38h] [rbp-60h] BYREF
long long v20; // [rsp+40h] [rbp-58h]
long long v21; // [rsp+48h] [rbp-50h]
long long v22; // [rsp+50h] [rbp-48h]
long long v23; // [rsp+58h] [rbp-40h]
long long v24; // [rsp+60h] [rbp-38h]
long long v25; // [rsp+68h] [rbp-30h]
long long v26; // [rsp+70h] [rbp-28h]
long long v27; // [rsp+78h] [rbp-20h]
long long v28; // [rsp+80h] [rbp-18h]
_QWORD *v29; // [rsp+88h] [rbp-10h]
_DWORD *v30; // [rsp+90h] [rbp-8h]
v30 = a1;
v29 = a2;
v28 = a3;
result = a1;
if ( *a1 )
{
result = v30;
if ( *v30 != 2 )
{
v27 = v29[2];
v26 = v29[3];
v25 = v29[4];
v24 = v29[5];
v23 = v29[6];
v22 = v29[7];
v21 = v29[8];
v20 = v29[9];
__asm
{
vxorps xmm0, xmm0, xmm0
vmovss [rsp+98h+var_5C], xmm0
vxorps xmm0, xmm0, xmm0
vmovss [rsp+98h+var_60], xmm0
}
for ( i = 0LL; i < v24; ++i )
{
for ( j = 0LL; j < v25; ++j )
{
for ( k = 0LL; k < v26; ++k )
{
ggml_vec_sum_f16_ggf((unsigned int)v27, &v18, v20 * i + v21 * j + v22 * k + v29[35]);
__asm
{
vmovss xmm0, [rsp+98h+var_60]
vaddss xmm0, xmm0, [rsp+98h+var_5C]
vmovss [rsp+98h+var_5C], xmm0
}
}
}
}
__asm
{
vmovss xmm0, [rsp+98h+var_5C]
vmovaps [rsp+98h+var_98], xmm0
vmovaps xmm0, [rsp+98h+var_98]
vcvtps2ph xmm0, xmm0, 0
vmovd eax, xmm0
}
v13 = _EAX;
result = *(_WORD **)(v28 + 280);
*result = v13;
}
}
return result;
}
| _M_enable_shared_from_this_with<PhiloxRNG,PhiloxRNG>:
MOV qword ptr [RSP + -0x8],RDI
MOV qword ptr [RSP + -0x10],RSI
RET
|
/* std::enable_if<!__has_esft_base<PhiloxRNG>::value, void>::type std::__shared_ptr<PhiloxRNG,
(__gnu_cxx::_Lock_policy)2>::_M_enable_shared_from_this_with<PhiloxRNG, PhiloxRNG>(PhiloxRNG*) */
void std::__shared_ptr<PhiloxRNG,(__gnu_cxx::_Lock_policy)2>::
_M_enable_shared_from_this_with<PhiloxRNG,PhiloxRNG>(PhiloxRNG *param_1)
{
return;
}
| |
38,618 | lre_is_space | bluesky950520[P]quickjs/libregexp.c | BOOL lre_is_space(int c)
{
int i, n, low, high;
n = (countof(char_range_s) - 1) / 2;
for(i = 0; i < n; i++) {
low = char_range_s[2 * i + 1];
if (c < low)
return FALSE;
high = char_range_s[2 * i + 2];
if (c < high)
return TRUE;
}
return FALSE;
} | O0 | c | lre_is_space:
movl %edi, -0x8(%rsp)
movl $0xa, -0x10(%rsp)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
cmpl -0x10(%rsp), %eax
jge 0xfbbbb
movl -0xc(%rsp), %eax
shll %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x1552f(%rip), %rax # 0x111090
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x14(%rsp)
movl -0x8(%rsp), %eax
cmpl -0x14(%rsp), %eax
jge 0xfbb7d
movl $0x0, -0x4(%rsp)
jmp 0xfbbc3
movl -0xc(%rsp), %eax
shll %eax
addl $0x2, %eax
movslq %eax, %rcx
leaq 0x15500(%rip), %rax # 0x111090
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x18(%rsp)
movl -0x8(%rsp), %eax
cmpl -0x18(%rsp), %eax
jge 0xfbbac
movl $0x1, -0x4(%rsp)
jmp 0xfbbc3
jmp 0xfbbae
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0xfbb44
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
| lre_is_space:
mov [rsp+var_8], edi
mov [rsp+var_10], 0Ah
mov [rsp+var_C], 0
loc_FBB44:
mov eax, [rsp+var_C]
cmp eax, [rsp+var_10]
jge short loc_FBBBB
mov eax, [rsp+var_C]
shl eax, 1
add eax, 1
movsxd rcx, eax
lea rax, char_range_s
movzx eax, word ptr [rax+rcx*2]
mov [rsp+var_14], eax
mov eax, [rsp+var_8]
cmp eax, [rsp+var_14]
jge short loc_FBB7D
mov [rsp+var_4], 0
jmp short loc_FBBC3
loc_FBB7D:
mov eax, [rsp+var_C]
shl eax, 1
add eax, 2
movsxd rcx, eax
lea rax, char_range_s
movzx eax, word ptr [rax+rcx*2]
mov [rsp+var_18], eax
mov eax, [rsp+var_8]
cmp eax, [rsp+var_18]
jge short loc_FBBAC
mov [rsp+var_4], 1
jmp short loc_FBBC3
loc_FBBAC:
jmp short $+2
loc_FBBAE:
mov eax, [rsp+var_C]
add eax, 1
mov [rsp+var_C], eax
jmp short loc_FBB44
loc_FBBBB:
mov [rsp+var_4], 0
loc_FBBC3:
mov eax, [rsp+var_4]
retn
| long long lre_is_space(int a1)
{
int i; // [rsp+Ch] [rbp-Ch]
for ( i = 0; i < 10; ++i )
{
if ( a1 < char_range_s[2 * i + 1] )
return 0;
if ( a1 < char_range_s[2 * i + 2] )
return 1;
}
return 0;
}
| lre_is_space:
MOV dword ptr [RSP + -0x8],EDI
MOV dword ptr [RSP + -0x10],0xa
MOV dword ptr [RSP + -0xc],0x0
LAB_001fbb44:
MOV EAX,dword ptr [RSP + -0xc]
CMP EAX,dword ptr [RSP + -0x10]
JGE 0x001fbbbb
MOV EAX,dword ptr [RSP + -0xc]
SHL EAX,0x1
ADD EAX,0x1
MOVSXD RCX,EAX
LEA RAX,[0x211090]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RSP + -0x14],EAX
MOV EAX,dword ptr [RSP + -0x8]
CMP EAX,dword ptr [RSP + -0x14]
JGE 0x001fbb7d
MOV dword ptr [RSP + -0x4],0x0
JMP 0x001fbbc3
LAB_001fbb7d:
MOV EAX,dword ptr [RSP + -0xc]
SHL EAX,0x1
ADD EAX,0x2
MOVSXD RCX,EAX
LEA RAX,[0x211090]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RSP + -0x18],EAX
MOV EAX,dword ptr [RSP + -0x8]
CMP EAX,dword ptr [RSP + -0x18]
JGE 0x001fbbac
MOV dword ptr [RSP + -0x4],0x1
JMP 0x001fbbc3
LAB_001fbbac:
JMP 0x001fbbae
LAB_001fbbae:
MOV EAX,dword ptr [RSP + -0xc]
ADD EAX,0x1
MOV dword ptr [RSP + -0xc],EAX
JMP 0x001fbb44
LAB_001fbbbb:
MOV dword ptr [RSP + -0x4],0x0
LAB_001fbbc3:
MOV EAX,dword ptr [RSP + -0x4]
RET
|
int4 lre_is_space(int param_1)
{
int local_c;
local_c = 0;
while( true ) {
if (9 < local_c) {
return 0;
}
if (param_1 < (int)(uint)*(ushort *)(char_range_s + (long)(local_c * 2 + 1) * 2)) break;
if (param_1 < (int)(uint)*(ushort *)(char_range_s + (long)(local_c * 2 + 2) * 2)) {
return 1;
}
local_c = local_c + 1;
}
return 0;
}
| |
38,619 | lre_is_space | bluesky950520[P]quickjs/libregexp.c | BOOL lre_is_space(int c)
{
int i, n, low, high;
n = (countof(char_range_s) - 1) / 2;
for(i = 0; i < n; i++) {
low = char_range_s[2 * i + 1];
if (c < low)
return FALSE;
high = char_range_s[2 * i + 2];
if (c < high)
return TRUE;
}
return FALSE;
} | O3 | c | lre_is_space:
movl $0x1, %ecx
leaq 0xe7f4(%rip), %rdx # 0xa4c10
xorl %eax, %eax
movzwl -0x2(%rdx,%rcx,4), %esi
cmpl %edi, %esi
jg 0x96438
movzwl (%rdx,%rcx,4), %esi
cmpl %edi, %esi
ja 0x96439
incq %rcx
cmpq $0xb, %rcx
jne 0x9641e
retq
movl $0x1, %eax
retq
| lre_is_space:
mov ecx, 1
lea rdx, char_range_s
xor eax, eax
loc_9641E:
movzx esi, word ptr [rdx+rcx*4-2]
cmp esi, edi
jg short locret_96438
movzx esi, word ptr [rdx+rcx*4]
cmp esi, edi
ja short loc_96439
inc rcx
cmp rcx, 0Bh
jnz short loc_9641E
locret_96438:
retn
loc_96439:
mov eax, 1
retn
| long long lre_is_space(int a1)
{
long long v1; // rcx
long long result; // rax
v1 = 1LL;
result = 0LL;
while ( char_range_s[2 * v1 - 1] <= a1 )
{
if ( char_range_s[2 * v1] > (unsigned int)a1 )
return 1LL;
if ( ++v1 == 11 )
return result;
}
return result;
}
| lre_is_space:
MOV ECX,0x1
LEA RDX,[0x1a4c10]
XOR EAX,EAX
LAB_0019641e:
MOVZX ESI,word ptr [RDX + RCX*0x4 + -0x2]
CMP ESI,EDI
JG 0x00196438
MOVZX ESI,word ptr [RDX + RCX*0x4]
CMP ESI,EDI
JA 0x00196439
INC RCX
CMP RCX,0xb
JNZ 0x0019641e
LAB_00196438:
RET
LAB_00196439:
MOV EAX,0x1
RET
|
int8 lre_is_space(uint param_1)
{
long lVar1;
lVar1 = 1;
while( true ) {
if ((int)param_1 < (int)(uint)*(ushort *)(&UNK_001a4c0e + lVar1 * 4)) {
return 0;
}
if (param_1 < (ushort)(&char_range_s)[lVar1 * 2]) break;
lVar1 = lVar1 + 1;
if (lVar1 == 0xb) {
return 0;
}
}
return 1;
}
| |
38,620 | psi_mutex_lock | eloqsql/mysys/my_thr_init.c | ATTRIBUTE_COLD int psi_mutex_lock(mysql_mutex_t *that,
const char *file, uint line)
{
PSI_mutex_locker_state state;
PSI_mutex_locker *locker= PSI_MUTEX_CALL(start_mutex_wait)
(&state, that->m_psi, PSI_MUTEX_LOCK, file, line);
# ifdef SAFE_MUTEX
int result= safe_mutex_lock(&that->m_mutex, FALSE, file, line);
# else
int result= pthread_mutex_lock(&that->m_mutex);
# endif
if (locker)
PSI_MUTEX_CALL(end_mutex_wait)(locker, result);
return result;
} | O3 | c | psi_mutex_lock:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %r8d
movq %rsi, %rcx
movq %rdi, %r14
leaq 0x357464(%rip), %r15 # 0x386010
movq (%r15), %rax
movq 0x40(%rdi), %rsi
leaq -0x48(%rbp), %rdi
xorl %edx, %edx
callq *0x190(%rax)
movq %rax, %rbx
movq %r14, %rdi
callq 0x29220
movl %eax, %r14d
testq %rbx, %rbx
je 0x2ebe1
movq (%r15), %rax
movq %rbx, %rdi
movl %r14d, %esi
callq *0x198(%rax)
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| psi_mutex_lock:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 38h
mov r8d, edx
mov rcx, rsi
mov r14, rdi
lea r15, PSI_server
mov rax, [r15]
mov rsi, [rdi+40h]
lea rdi, [rbp+var_48]
xor edx, edx
call qword ptr [rax+190h]
mov rbx, rax
mov rdi, r14
call _pthread_mutex_lock
mov r14d, eax
test rbx, rbx
jz short loc_2EBE1
mov rax, [r15]
mov rdi, rbx
mov esi, r14d
call qword ptr [rax+198h]
loc_2EBE1:
mov eax, r14d
add rsp, 38h
pop rbx
pop r14
pop r15
pop rbp
retn
| long long psi_mutex_lock(long long a1, long long a2, unsigned int a3)
{
long long v3; // rbx
unsigned int v4; // r14d
_BYTE v6[72]; // [rsp+8h] [rbp-48h] BYREF
v3 = ((long long ( *)(_BYTE *, _QWORD, _QWORD, long long, _QWORD))PSI_server[50])(
v6,
*(_QWORD *)(a1 + 64),
0LL,
a2,
a3);
v4 = pthread_mutex_lock(a1);
if ( v3 )
((void ( *)(long long, _QWORD))PSI_server[51])(v3, v4);
return v4;
}
| psi_mutex_lock:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV R8D,EDX
MOV RCX,RSI
MOV R14,RDI
LEA R15,[0x486010]
MOV RAX,qword ptr [R15]
MOV RSI,qword ptr [RDI + 0x40]
LEA RDI,[RBP + -0x48]
XOR EDX,EDX
CALL qword ptr [RAX + 0x190]
MOV RBX,RAX
MOV RDI,R14
CALL 0x00129220
MOV R14D,EAX
TEST RBX,RBX
JZ 0x0012ebe1
MOV RAX,qword ptr [R15]
MOV RDI,RBX
MOV ESI,R14D
CALL qword ptr [RAX + 0x198]
LAB_0012ebe1:
MOV EAX,R14D
ADD RSP,0x38
POP RBX
POP R14
POP R15
POP RBP
RET
|
int psi_mutex_lock(pthread_mutex_t *param_1,int8 param_2,int4 param_3)
{
int iVar1;
long lVar2;
int1 local_50 [48];
lVar2 = (**(code **)(PSI_server + 400))
(local_50,*(int8 *)((long)param_1 + 0x40),0,param_2,param_3);
iVar1 = pthread_mutex_lock(param_1);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x198))(lVar2,iVar1);
}
return iVar1;
}
| |
38,621 | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>(nlohmann::json_abi_v3_11_3::detail::value_t&&, bool) | llama.cpp/common/json.hpp | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
}
// create value
auto value = BasicJsonType(std::forward<Value>(v));
// check callback
const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
// do not handle this value if we just learnt it shall be discarded
if (!keep)
{
return {false, nullptr};
}
if (ref_stack.empty())
{
root = std::move(value);
return {true, & root};
}
// skip this value if we already decided to skip the parent
// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
if (!ref_stack.back())
{
return {false, nullptr};
}
// we now only expect arrays and objects
JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
// array
if (ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
return {true, & (ref_stack.back()->m_data.m_value.array->back())};
}
// object
JSON_ASSERT(ref_stack.back()->is_object());
// check if we should store an element for the current key
JSON_ASSERT(!key_keep_stack.empty());
const bool store_element = key_keep_stack.back();
key_keep_stack.pop_back();
if (!store_element)
{
return {false, nullptr};
}
JSON_ASSERT(object_element);
*object_element = std::move(value);
return {true, object_element};
} | O3 | cpp | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>(nlohmann::json_abi_v3_11_3::detail::value_t&&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq 0x30(%rdi), %rax
movl 0x38(%rdi), %ecx
cmpq %rax, 0x20(%rdi)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0x8c29d
movl %ecx, %ecx
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
leaq -0x1(%rcx), %rdx
addq $0x3e, %rcx
testq %rdx, %rdx
cmovnsq %rdx, %rcx
sarq $0x6, %rcx
leaq (%rax,%rcx,8), %rax
leaq 0x3f(%r15), %rcx
andq %rdx, %rcx
xorl %esi, %esi
cmpq %r15, %rcx
setbe %sil
movq -0x8(%rax,%rsi,8), %rax
btq %rdx, %rax
jae 0x8c130
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x858ca
movq %r14, %rdi
movl $0x1, %esi
callq 0x858ca
testb %bpl, %bpl
jne 0x8c0dd
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
movl %eax, 0xc(%rsp)
movb $0x5, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x8c2be
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq *0x98(%rbx)
testb %al, %al
je 0x8c271
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x8c13a
movq -0x8(%rax), %rax
testq %rax, %rax
je 0x8c271
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x8c194
cmpl $0x2, %ecx
jne 0x8c2c3
movq 0x8(%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0x896e0
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
addq $-0x10, %r14
jmp 0x8c26d
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0x8c28d
leaq 0x10(%rsp), %r14
movups (%r14), %xmm0
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x858ca
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x858ca
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x87a36
movq %r15, %rdi
xorl %esi, %esi
callq 0x858ca
movq %r15, %rdi
callq 0x89fe4
movq (%rbx), %r14
jmp 0x8c26d
movq 0x58(%rbx), %rax
movl 0x60(%rbx), %ecx
cmpq %rax, 0x48(%rbx)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0x8c2d1
movl %ecx, %esi
leaq -0x1(%rsi), %rcx
movq %rsi, %rdx
addq $0x3e, %rdx
testq %rcx, %rcx
cmovnsq %rcx, %rdx
sarq $0x6, %rdx
leaq (%rax,%rdx,8), %rdi
leaq 0x3f(%r15), %rdx
andq %rcx, %rdx
xorl %r8d, %r8d
cmpq %r15, %rdx
setbe %r8b
movl $0x1, %edx
shlq %cl, %rdx
andq -0x8(%rdi,%r8,8), %rdx
subl $0x1, %esi
movl %esi, 0x60(%rbx)
jae 0x8c206
movl $0x3f, 0x60(%rbx)
addq $-0x8, %rax
movq %rax, 0x58(%rbx)
testq %rdx, %rdx
je 0x8c271
cmpq $0x0, 0x70(%rbx)
je 0x8c2f2
leaq 0x10(%rsp), %r14
movups (%r14), %xmm0
leaq 0x20(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x858ca
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x858ca
movq 0x70(%rbx), %rdi
movq %r15, %rsi
callq 0x87a36
movq %r15, %rdi
xorl %esi, %esi
callq 0x858ca
movq %r15, %rdi
callq 0x89fe4
movq 0x70(%rbx), %r14
movb $0x1, %bl
jmp 0x8c276
xorl %ebx, %ebx
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x858ca
movq %r15, %rdi
callq 0x89fe4
movl %ebx, %eax
movq %r14, %rdx
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8d798(%rip), %rdi # 0x119a3c
leaq 0x8d7cc(%rip), %rdx # 0x119a77
leaq 0x8e6f7(%rip), %rcx # 0x11a9a9
movl $0x1c28, %esi # imm = 0x1C28
xorl %eax, %eax
callq 0x20e20
callq 0x21240
leaq 0x8e6f3(%rip), %rcx # 0x11a9bd
movl $0x1c4b, %esi # imm = 0x1C4B
jmp 0x8c2dd
leaq 0x8e723(%rip), %rcx # 0x11a9fb
movl $0x1c57, %esi # imm = 0x1C57
leaq 0x8d758(%rip), %rdi # 0x119a3c
leaq 0x8d78c(%rip), %rdx # 0x119a77
xorl %eax, %eax
callq 0x20e20
leaq 0x8d743(%rip), %rdi # 0x119a3c
leaq 0x8d777(%rip), %rdx # 0x119a77
leaq 0x8e70c(%rip), %rcx # 0x11aa13
movl $0x1c60, %esi # imm = 0x1C60
xorl %eax, %eax
callq 0x20e20
jmp 0x8c315
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x858ca
movq %r14, %rdi
callq 0x89fe4
movq %rbx, %rdi
callq 0x20ad0
nop
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12handle_valueIDnEESt4pairIbPSF_EOT_b:
push rbp
push r15
push r14
push rbx
sub rsp, 48h
mov ebp, edx
mov rax, [rdi+30h]
mov ecx, [rdi+38h]
cmp [rdi+20h], rax
setz dl
test ecx, ecx
setz sil
and sil, dl
cmp sil, 1
jz loc_8C29D
mov ecx, ecx
mov r15, 8000000000000000h
lea rdx, [rcx-1]
add rcx, 3Eh ; '>'
test rdx, rdx
cmovns rcx, rdx
sar rcx, 6
lea rax, [rax+rcx*8]
lea rcx, [r15+3Fh]
and rcx, rdx
xor esi, esi
cmp rcx, r15
setbe sil
mov rax, [rax+rsi*8-8]
bt rax, rdx
jnb loc_8C130
mov rbx, rdi
lea r14, [rsp+68h+var_58]
mov byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
test bpl, bpl
jnz short loc_8C0DD
mov rax, [rbx+10h]
sub rax, [rbx+8]
shr rax, 3
mov [rsp+68h+var_5C], eax
mov [rsp+68h+var_5D], 5
cmp qword ptr [rbx+90h], 0
jz loc_8C2BE
lea rdi, [rbx+80h]
lea rsi, [rsp+68h+var_5C]
lea rdx, [rsp+68h+var_5D]
lea rcx, [rsp+68h+var_58]
call qword ptr [rbx+98h]
test al, al
jz loc_8C271
loc_8C0DD:
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz short loc_8C13A
mov rax, [rax-8]
test rax, rax
jz loc_8C271
movzx ecx, byte ptr [rax]
cmp ecx, 1
jz loc_8C194
cmp ecx, 2
jnz loc_8C2C3
mov rdi, [rax+8]
lea rsi, [rsp+68h+var_58]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<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> &&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov rax, [rax+8]
mov r14, [rax+8]
add r14, 0FFFFFFFFFFFFFFF0h
jmp loc_8C26D
loc_8C130:
xor ebx, ebx
xor r14d, r14d
jmp loc_8C28D
loc_8C13A:
lea r14, [rsp+68h+var_58]
movups xmm0, xmmword ptr [r14]
lea r15, [rsp+68h+var_38]
movaps xmmword ptr [r15], xmm0
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, [rbx]
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r14, [rbx]
jmp loc_8C26D
loc_8C194:
mov rax, [rbx+58h]
mov ecx, [rbx+60h]
cmp [rbx+48h], rax
setz dl
test ecx, ecx
setz sil
and sil, dl
cmp sil, 1
jz loc_8C2D1
mov esi, ecx
lea rcx, [rsi-1]
mov rdx, rsi
add rdx, 3Eh ; '>'
test rcx, rcx
cmovns rdx, rcx
sar rdx, 6
lea rdi, [rax+rdx*8]
lea rdx, [r15+3Fh]
and rdx, rcx
xor r8d, r8d
cmp rdx, r15
setbe r8b
mov edx, 1
shl rdx, cl
and rdx, [rdi+r8*8-8]
sub esi, 1
mov [rbx+60h], esi
jnb short loc_8C206
mov dword ptr [rbx+60h], 3Fh ; '?'
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbx+58h], rax
loc_8C206:
test rdx, rdx
jz short loc_8C271
cmp qword ptr [rbx+70h], 0
jz loc_8C2F2
lea r14, [rsp+68h+var_58]
movups xmm0, xmmword ptr [r14]
lea r15, [rsp+68h+var_48]
movaps xmmword ptr [r15], xmm0
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, [rbx+70h]
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r14, [rbx+70h]
loc_8C26D:
mov bl, 1
jmp short loc_8C276
loc_8C271:
xor ebx, ebx
xor r14d, r14d
loc_8C276:
lea r15, [rsp+68h+var_58]
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_8C28D:
mov eax, ebx
mov rdx, r14
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_8C29D:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeepStackEmpty; "!keep_stack.empty()"
mov esi, 1C28h
xor eax, eax
call _ggml_abort
loc_8C2BE:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
loc_8C2C3:
lea rcx, aRefStackBackIs; "ref_stack.back()->is_array() || ref_sta"...
mov esi, 1C4Bh
jmp short loc_8C2DD
loc_8C2D1:
lea rcx, aKeyKeepStackEm; "!key_keep_stack.empty()"
mov esi, 1C57h
loc_8C2DD:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
xor eax, eax
call _ggml_abort
loc_8C2F2:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aObjectElement; "object_element"
mov esi, 1C60h
xor eax, eax
call _ggml_abort
jmp short $+2
loc_8C315:
mov rbx, rax
lea r14, [rsp+68h+var_58]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::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>>::handle_value<decltype(nullptr)>(
long long a1,
long long a2,
char a3)
{
long long v4; // rax
unsigned int v5; // ecx
signed long long v6; // rdx
long long v7; // rcx
long long v8; // rax
unsigned int v9; // ebx
long long v10; // rax
unsigned __int8 *v11; // rax
int v12; // ecx
long long v13; // rax
unsigned int v14; // ecx
long long v15; // rsi
long long v16; // rcx
long long v17; // rdx
long long v18; // rdx
const char *v20; // rcx
long long v21; // rsi
long long v22; // rax
long long v23; // rbx
char v24; // [rsp+Bh] [rbp-5Dh] BYREF
int v25; // [rsp+Ch] [rbp-5Ch] BYREF
__int128 v26; // [rsp+10h] [rbp-58h] BYREF
__int128 v27; // [rsp+20h] [rbp-48h] BYREF
_OWORD v28[3]; // [rsp+30h] [rbp-38h] BYREF
v4 = *(_QWORD *)(a1 + 48);
v5 = *(_DWORD *)(a1 + 56);
if ( *(_QWORD *)(a1 + 32) == v4 && v5 == 0 )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
7208LL,
"GGML_ASSERT(%s) failed",
"!keep_stack.empty()");
goto LABEL_28;
}
v6 = v5 - 1LL;
v7 = v5 + 62LL;
if ( v6 >= 0 )
v7 = v6;
v8 = *(_QWORD *)(v4 + 8 * (v7 >> 6) + 8LL * ((v6 & 0x800000000000003FLL) <= 0x8000000000000000LL) - 8);
if ( _bittest64(&v8, v6) )
{
v9 = a1;
LOBYTE(v26) = 0;
*((_QWORD *)&v26 + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&v26);
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 *)&v26);
if ( a3 )
{
LABEL_8:
v10 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) == v10 )
{
v28[0] = v26;
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 *)&v26);
LOBYTE(v26) = 0;
*((_QWORD *)&v26 + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v28);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)a1,
(long long)v28);
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 *)v28);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v28);
goto LABEL_23;
}
v11 = *(unsigned __int8 **)(v10 - 8);
if ( v11 )
{
v12 = *v11;
if ( v12 != 1 )
{
if ( v12 == 2 )
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<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>>(
*((_QWORD *)v11 + 1),
(long long)&v26);
LABEL_23:
LOBYTE(v9) = 1;
LABEL_25:
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 *)&v26);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v26);
return v9;
}
v20 = "ref_stack.back()->is_array() || ref_stack.back()->is_object()";
v21 = 7243LL;
goto LABEL_31;
}
v13 = *(_QWORD *)(a1 + 88);
v14 = *(_DWORD *)(a1 + 96);
if ( *(_QWORD *)(a1 + 72) == v13 && v14 == 0 )
{
v20 = "!key_keep_stack.empty()";
v21 = 7255LL;
LABEL_31:
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp", v21, "GGML_ASSERT(%s) failed", v20);
goto LABEL_32;
}
v15 = v14;
v16 = v14 - 1LL;
v17 = v15 + 62;
if ( v16 >= 0 )
v17 = v16;
v18 = *(_QWORD *)(v13 + 8 * (v17 >> 6) + 8LL * ((v16 & 0x800000000000003FLL) <= 0x8000000000000000LL) - 8) & (1LL << v16);
*(_DWORD *)(a1 + 96) = v15 - 1;
if ( !(_DWORD)v15 )
{
*(_DWORD *)(a1 + 96) = 63;
*(_QWORD *)(a1 + 88) = v13 - 8;
}
if ( v18 )
{
if ( *(_QWORD *)(a1 + 112) )
{
v27 = v26;
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 *)&v26);
LOBYTE(v26) = 0;
*((_QWORD *)&v26 + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&v27);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)(a1 + 112),
(long long)&v27);
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 *)&v27);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v27);
goto LABEL_23;
}
LABEL_32:
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
7264LL,
"GGML_ASSERT(%s) failed",
"object_element");
v23 = v22;
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 *)&v26);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v26);
_Unwind_Resume(v23);
}
}
LABEL_24:
v9 = 0;
goto LABEL_25;
}
v25 = (*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) >> 3;
v24 = 5;
if ( *(_QWORD *)(a1 + 144) )
{
if ( !(*(unsigned __int8 ( **)(long long, int *, char *, __int128 *))(a1 + 152))(
a1 + 128,
&v25,
&v24,
&v26) )
goto LABEL_24;
goto LABEL_8;
}
LABEL_28:
std::__throw_bad_function_call();
}
return 0;
}
| handle_value<decltype(nullptr)>:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV EBP,EDX
MOV RAX,qword ptr [RDI + 0x30]
MOV ECX,dword ptr [RDI + 0x38]
CMP qword ptr [RDI + 0x20],RAX
SETZ DL
TEST ECX,ECX
SETZ SIL
AND SIL,DL
CMP SIL,0x1
JZ 0x0018c29d
MOV ECX,ECX
MOV R15,-0x8000000000000000
LEA RDX,[RCX + -0x1]
ADD RCX,0x3e
TEST RDX,RDX
CMOVNS RCX,RDX
SAR RCX,0x6
LEA RAX,[RAX + RCX*0x8]
LEA RCX,[R15 + 0x3f]
AND RCX,RDX
XOR ESI,ESI
CMP RCX,R15
SETBE SIL
MOV RAX,qword ptr [RAX + RSI*0x8 + -0x8]
BT RAX,RDX
JNC 0x0018c130
MOV RBX,RDI
LEA R14,[RSP + 0x10]
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x001858ca
MOV RDI,R14
MOV ESI,0x1
CALL 0x001858ca
TEST BPL,BPL
JNZ 0x0018c0dd
MOV RAX,qword ptr [RBX + 0x10]
SUB RAX,qword ptr [RBX + 0x8]
SHR RAX,0x3
MOV dword ptr [RSP + 0xc],EAX
MOV byte ptr [RSP + 0xb],0x5
CMP qword ptr [RBX + 0x90],0x0
JZ 0x0018c2be
LEA RDI,[RBX + 0x80]
LAB_0018c0c0:
LEA RSI,[RSP + 0xc]
LEA RDX,[RSP + 0xb]
LEA RCX,[RSP + 0x10]
CALL qword ptr [RBX + 0x98]
TEST AL,AL
JZ 0x0018c271
LAB_0018c0dd:
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RBX + 0x8],RAX
JZ 0x0018c13a
MOV RAX,qword ptr [RAX + -0x8]
TEST RAX,RAX
JZ 0x0018c271
MOVZX ECX,byte ptr [RAX]
CMP ECX,0x1
JZ 0x0018c194
CMP ECX,0x2
JNZ 0x0018c2c3
MOV RDI,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x10]
CALL 0x001896e0
LAB_0018c117:
MOV RAX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RAX + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV R14,qword ptr [RAX + 0x8]
ADD R14,-0x10
JMP 0x0018c26d
LAB_0018c130:
XOR EBX,EBX
XOR R14D,R14D
JMP 0x0018c28d
LAB_0018c13a:
LEA R14,[RSP + 0x10]
MOVUPS XMM0,xmmword ptr [R14]
LEA R15,[RSP + 0x30]
MOVAPS xmmword ptr [R15],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x001858ca
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x001858ca
MOV RDI,qword ptr [RBX]
MOV RSI,R15
CALL 0x00187a36
MOV RDI,R15
XOR ESI,ESI
CALL 0x001858ca
MOV RDI,R15
CALL 0x00189fe4
MOV R14,qword ptr [RBX]
JMP 0x0018c26d
LAB_0018c194:
MOV RAX,qword ptr [RBX + 0x58]
MOV ECX,dword ptr [RBX + 0x60]
CMP qword ptr [RBX + 0x48],RAX
SETZ DL
TEST ECX,ECX
SETZ SIL
AND SIL,DL
CMP SIL,0x1
JZ 0x0018c2d1
MOV ESI,ECX
LEA RCX,[RSI + -0x1]
MOV RDX,RSI
ADD RDX,0x3e
TEST RCX,RCX
CMOVNS RDX,RCX
SAR RDX,0x6
LEA RDI,[RAX + RDX*0x8]
LEA RDX,[R15 + 0x3f]
AND RDX,RCX
XOR R8D,R8D
CMP RDX,R15
SETBE R8B
MOV EDX,0x1
SHL RDX,CL
AND RDX,qword ptr [RDI + R8*0x8 + -0x8]
SUB ESI,0x1
MOV dword ptr [RBX + 0x60],ESI
JNC 0x0018c206
MOV dword ptr [RBX + 0x60],0x3f
ADD RAX,-0x8
MOV qword ptr [RBX + 0x58],RAX
LAB_0018c206:
TEST RDX,RDX
JZ 0x0018c271
CMP qword ptr [RBX + 0x70],0x0
JZ 0x0018c2f2
LEA R14,[RSP + 0x10]
MOVUPS XMM0,xmmword ptr [R14]
LEA R15,[RSP + 0x20]
MOVAPS xmmword ptr [R15],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x001858ca
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x001858ca
MOV RDI,qword ptr [RBX + 0x70]
MOV RSI,R15
CALL 0x00187a36
MOV RDI,R15
XOR ESI,ESI
CALL 0x001858ca
MOV RDI,R15
CALL 0x00189fe4
MOV R14,qword ptr [RBX + 0x70]
LAB_0018c26d:
MOV BL,0x1
JMP 0x0018c276
LAB_0018c271:
XOR EBX,EBX
XOR R14D,R14D
LAB_0018c276:
LEA R15,[RSP + 0x10]
MOV RDI,R15
XOR ESI,ESI
CALL 0x001858ca
MOV RDI,R15
CALL 0x00189fe4
LAB_0018c28d:
MOV EAX,EBX
MOV RDX,R14
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0018c29d:
LEA RDI,[0x219a3c]
LEA RDX,[0x219a77]
LEA RCX,[0x21a9a9]
MOV ESI,0x1c28
XOR EAX,EAX
CALL 0x00120e20
LAB_0018c2be:
CALL 0x00121240
LAB_0018c2c3:
LEA RCX,[0x21a9bd]
MOV ESI,0x1c4b
JMP 0x0018c2dd
LAB_0018c2d1:
LEA RCX,[0x21a9fb]
MOV ESI,0x1c57
LAB_0018c2dd:
LEA RDI,[0x219a3c]
LEA RDX,[0x219a77]
XOR EAX,EAX
CALL 0x00120e20
LAB_0018c2f2:
LEA RDI,[0x219a3c]
LEA RDX,[0x219a77]
LEA RCX,[0x21aa13]
MOV ESI,0x1c60
XOR EAX,EAX
CALL 0x00120e20
|
/* std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>*>
nlohmann::json_abi_v3_11_3::detail::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> >::handle_value<decltype(nullptr)>(decltype(nullptr)&&, bool) */
int1 [16] __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>>
::handle_value<decltype(nullptr)>
(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,_func_decltype_nullptr **param_1,bool param_2)
{
uint uVar1;
char cVar2;
ulong uVar3;
char *pcVar4;
ulong uVar5;
int8 uVar6;
bool bVar7;
long lVar8;
int1 auVar9 [16];
int1 local_5d;
int4 local_5c;
basic_json local_58;
int7 uStack_57;
int8 uStack_50;
int8 local_48;
int8 uStack_40;
int8 local_38;
int8 uStack_30;
uVar1 = *(uint *)(this + 0x38);
if (uVar1 == 0 && *(long *)(this + 0x20) == *(long *)(this + 0x30)) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",0x1c28,
"GGML_ASSERT(%s) failed","!keep_stack.empty()");
}
uVar5 = (ulong)uVar1 - 1;
uVar3 = (ulong)uVar1 + 0x3e;
if (-1 < (long)uVar5) {
uVar3 = uVar5;
}
if ((*(ulong *)(*(long *)(this + 0x30) + ((long)uVar3 >> 6) * 8 + -8 +
(ulong)((uVar5 & 0x800000000000003f) < 0x8000000000000001) * 8) >> (uVar5 & 0x3f) &
1) == 0) {
uVar5 = 0;
lVar8 = 0;
goto LAB_0018c28d;
}
local_58 = (basic_json)0x0;
uStack_50 = 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(SUB81(&local_58,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(SUB81(&local_58,0));
if (param_2) {
LAB_0018c0dd:
if (*(long *)(this + 8) == *(long *)(this + 0x10)) {
local_38 = CONCAT71(uStack_57,local_58);
uStack_30 = uStack_50;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_58,0));
local_58 = (basic_json)0x0;
uStack_50 = 0;
bVar7 = SUB81((data *)&local_38,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(bVar7);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)this,(data *)&local_38);
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(bVar7);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_38);
lVar8 = *(long *)this;
}
else {
pcVar4 = *(char **)(*(long *)(this + 0x10) + -8);
if (pcVar4 == (char *)0x0) goto LAB_0018c271;
if (*pcVar4 == '\x01') {
lVar8 = *(long *)(this + 0x58);
uVar1 = *(uint *)(this + 0x60);
if (uVar1 == 0 && *(long *)(this + 0x48) == lVar8) {
pcVar4 = "!key_keep_stack.empty()";
uVar6 = 0x1c57;
goto LAB_0018c2dd;
}
uVar5 = (ulong)uVar1 - 1;
uVar3 = (ulong)uVar1 + 0x3e;
if (-1 < (long)uVar5) {
uVar3 = uVar5;
}
uVar3 = *(ulong *)(lVar8 + ((long)uVar3 >> 6) * 8 + -8 +
(ulong)((uVar5 & 0x800000000000003f) < 0x8000000000000001) * 8);
*(uint *)(this + 0x60) = uVar1 - 1;
if (uVar1 == 0) {
*(int4 *)(this + 0x60) = 0x3f;
*(long *)(this + 0x58) = lVar8 + -8;
}
if ((1L << ((byte)uVar5 & 0x3f) & uVar3) == 0) goto LAB_0018c271;
if (*(long *)(this + 0x70) == 0) {
/* try { // try from 0018c2f2 to 0018c312 has its CatchHandler @ 0018c313 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",0x1c60,
"GGML_ASSERT(%s) failed","object_element");
}
local_48 = CONCAT71(uStack_57,local_58);
uStack_40 = uStack_50;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_58,0));
local_58 = (basic_json)0x0;
uStack_50 = 0;
bVar7 = SUB81((data *)&local_48,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(bVar7);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)(this + 0x70),(data *)&local_48);
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(bVar7);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_48);
lVar8 = *(long *)(this + 0x70);
}
else {
if (*pcVar4 != '\x02') {
pcVar4 = "ref_stack.back()->is_array() || ref_stack.back()->is_object()";
uVar6 = 0x1c4b;
LAB_0018c2dd:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",uVar6,
"GGML_ASSERT(%s) failed",pcVar4);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<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>>
(*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(pcVar4 + 8),&local_58);
lVar8 = *(long *)(*(long *)(*(long *)(*(long *)(this + 0x10) + -8) + 8) + 8) + -0x10;
}
}
uVar5 = CONCAT71((int7)((ulong)this >> 8),1);
}
else {
local_5c = (int4)((ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3);
local_5d = 5;
if (*(long *)(this + 0x90) == 0) {
/* WARNING: Subroutine does not return */
/* try { // try from 0018c2be to 0018c2f1 has its CatchHandler @ 0018c315 */
std::__throw_bad_function_call();
}
/* try { // try from 0018c0c0 to 0018c116 has its CatchHandler @ 0018c315 */
cVar2 = (**(code **)(this + 0x98))(this + 0x80,&local_5c,&local_5d,&local_58);
if (cVar2 != '\0') goto LAB_0018c0dd;
LAB_0018c271:
uVar5 = 0;
lVar8 = 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(SUB81((data *)&local_58,0));
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_58);
LAB_0018c28d:
auVar9._0_8_ = uVar5 & 0xffffffff;
auVar9._8_8_ = lVar8;
return auVar9;
}
| |
38,622 | flush_pagecache_blocks_with_filter | eloqsql/storage/maria/ma_pagecache.c | int flush_pagecache_blocks_with_filter(PAGECACHE *pagecache,
PAGECACHE_FILE *file,
enum flush_type type,
PAGECACHE_FLUSH_FILTER filter,
void *filter_arg)
{
int res;
DBUG_ENTER("flush_pagecache_blocks_with_filter");
DBUG_PRINT("enter", ("pagecache: %p", pagecache));
if (pagecache->disk_blocks <= 0)
DBUG_RETURN(0);
pagecache_pthread_mutex_lock(&pagecache->cache_lock);
inc_counter_for_resize_op(pagecache);
res= flush_pagecache_blocks_int(pagecache, file, type, filter, filter_arg);
dec_counter_for_resize_op(pagecache);
pagecache_pthread_mutex_unlock(&pagecache->cache_lock);
DBUG_RETURN(res);
} | O0 | c | flush_pagecache_blocks_with_filter:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
jmp 0x6618d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jg 0x661a3
jmp 0x6619a
movl $0x0, -0x4(%rbp)
jmp 0x66202
movq -0x10(%rbp), %rdi
addq $0xc8, %rdi
leaq 0xb9b49(%rip), %rsi # 0x11fcfe
movl $0x1471, %edx # imm = 0x1471
callq 0x62e90
movq -0x10(%rbp), %rdi
callq 0x63240
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x66210
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
callq 0x63f70
movq -0x10(%rbp), %rdi
addq $0xc8, %rdi
callq 0x62f00
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| flush_pagecache_blocks_with_filter:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
jmp short $+2
loc_6618D:
mov rax, [rbp+var_10]
cmp qword ptr [rax+40h], 0
jg short loc_661A3
jmp short $+2
loc_6619A:
mov [rbp+var_4], 0
jmp short loc_66202
loc_661A3:
mov rdi, [rbp+var_10]
add rdi, 0C8h
lea rsi, aWorkspaceLlm4b_15; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 1471h
call inline_mysql_mutex_lock_8
mov rdi, [rbp+var_10]
call inc_counter_for_resize_op
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
mov rcx, [rbp+var_28]
mov r8, [rbp+var_30]
call flush_pagecache_blocks_int
mov [rbp+var_34], eax
mov rdi, [rbp+var_10]
call dec_counter_for_resize_op
mov rdi, [rbp+var_10]
add rdi, 0C8h
call inline_mysql_mutex_unlock_8
mov eax, [rbp+var_34]
mov [rbp+var_4], eax
loc_66202:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
| long long flush_pagecache_blocks_with_filter(long long a1, long long a2, unsigned int a3, long long a4, long long a5)
{
unsigned int v6; // [rsp+Ch] [rbp-34h]
if ( *(long long *)(a1 + 64) > 0 )
{
inline_mysql_mutex_lock_8(
a1 + 200,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0x1471u);
inc_counter_for_resize_op(a1);
v6 = flush_pagecache_blocks_int(a1, a2, a3, a4, a5);
dec_counter_for_resize_op(a1);
inline_mysql_mutex_unlock_8(a1 + 200);
return v6;
}
else
{
return 0;
}
}
| flush_pagecache_blocks_with_filter:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
JMP 0x0016618d
LAB_0016618d:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x40],0x0
JG 0x001661a3
JMP 0x0016619a
LAB_0016619a:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00166202
LAB_001661a3:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0xc8
LEA RSI,[0x21fcfe]
MOV EDX,0x1471
CALL 0x00162e90
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00163240
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x30]
CALL 0x00166210
MOV dword ptr [RBP + -0x34],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00163f70
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0xc8
CALL 0x00162f00
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x4],EAX
LAB_00166202:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int4
flush_pagecache_blocks_with_filter
(long param_1,int8 param_2,int4 param_3,int8 param_4,int8 param_5)
{
int4 local_c;
if (*(long *)(param_1 + 0x40) < 1) {
local_c = 0;
}
else {
inline_mysql_mutex_lock
(param_1 + 200,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c"
,0x1471);
inc_counter_for_resize_op(param_1);
local_c = flush_pagecache_blocks_int(param_1,param_2,param_3,param_4,param_5);
dec_counter_for_resize_op(param_1);
inline_mysql_mutex_unlock(param_1 + 200);
}
return local_c;
}
| |
38,623 | aimrt::runtime::core::channel::ChannelRegistry::GetPublishTypeWrapperPtr(std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>) const | aimrt_mujoco_sim/_deps/aimrt-src/src/runtime/core/channel/channel_registry.cc | const PublishTypeWrapper* ChannelRegistry::GetPublishTypeWrapperPtr(
std::string_view msg_type,
std::string_view topic_name,
std::string_view pkg_path,
std::string_view module_name) const {
auto find_itr = publish_type_wrapper_map_.find(
Key{.msg_type = msg_type, .topic_name = topic_name, .pkg_path = pkg_path, .module_name = module_name});
if (find_itr != publish_type_wrapper_map_.end())
return find_itr->second.get();
return nullptr;
} | O0 | cpp | aimrt::runtime::core::channel::ChannelRegistry::GetPublishTypeWrapperPtr(std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>) const:
subq $0x98, %rsp
movq %rcx, (%rsp)
movq %rdx, %rax
movq (%rsp), %rdx
movq %rax, 0x8(%rsp)
movq %rsi, %r9
movq 0x8(%rsp), %rsi
leaq 0xb0(%rsp), %rax
leaq 0xa0(%rsp), %rcx
movq %r9, 0x80(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x70(%rsp)
movq %r8, 0x78(%rsp)
movq %rdi, 0x68(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x10, %rdi
movq 0x80(%rsp), %rdx
movq %rdx, 0x20(%rsp)
movq 0x88(%rsp), %rdx
movq %rdx, 0x28(%rsp)
movq 0x70(%rsp), %rdx
movq %rdx, 0x30(%rsp)
movq 0x78(%rsp), %rdx
movq %rdx, 0x38(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x40(%rsp)
movq 0x8(%rcx), %rcx
movq %rcx, 0x48(%rsp)
movq (%rax), %rcx
movq %rcx, 0x50(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x58(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x12b1f0
movq 0x10(%rsp), %rdi
movq %rax, 0x60(%rsp)
addq $0x10, %rdi
callq 0x12b240
movq %rax, 0x18(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x88f60
xorb $-0x1, %al
testb $0x1, %al
jne 0x12adb5
jmp 0x12add5
leaq 0x60(%rsp), %rdi
callq 0x12b270
movq %rax, %rdi
addq $0x40, %rdi
callq 0xff190
movq %rax, 0x90(%rsp)
jmp 0x12ade1
movq $0x0, 0x90(%rsp)
movq 0x90(%rsp), %rax
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| _ZNK5aimrt7runtime4core7channel15ChannelRegistry24GetPublishTypeWrapperPtrESt17basic_string_viewIcSt11char_traitsIcEES7_S7_S7_:
sub rsp, 98h
mov [rsp+98h+var_98], rcx
mov rax, rdx
mov rdx, [rsp+98h+var_98]
mov [rsp+98h+var_90], rax
mov r9, rsi
mov rsi, [rsp+98h+var_90]
lea rax, [rsp+98h+arg_10]
lea rcx, [rsp+98h+arg_0]
mov [rsp+98h+var_18], r9
mov [rsp+98h+var_10], rsi
mov [rsp+98h+var_28], rdx
mov [rsp+98h+var_20], r8
mov [rsp+98h+var_30], rdi
mov rdi, [rsp+98h+var_30]
mov [rsp+98h+var_88], rdi
add rdi, 10h
mov rdx, [rsp+98h+var_18]
mov [rsp+98h+var_78], rdx
mov rdx, [rsp+98h+var_10]
mov [rsp+98h+var_70], rdx
mov rdx, [rsp+98h+var_28]
mov [rsp+98h+var_68], rdx
mov rdx, [rsp+98h+var_20]
mov [rsp+98h+var_60], rdx
mov rdx, [rcx]
mov [rsp+98h+var_58], rdx
mov rcx, [rcx+8]
mov [rsp+98h+var_50], rcx
mov rcx, [rax]
mov [rsp+98h+var_48], rcx
mov rax, [rax+8]
mov [rsp+98h+var_40], rax
lea rsi, [rsp+98h+var_78]
call _ZNKSt13unordered_mapIN5aimrt7runtime4core7channel15ChannelRegistry3KeyESt10unique_ptrINS3_18PublishTypeWrapperESt14default_deleteIS7_EENS5_4HashESt8equal_toIS5_ESaISt4pairIKS5_SA_EEE4findERSF_; std::unordered_map<aimrt::runtime::core::channel::ChannelRegistry::Key,std::unique_ptr<aimrt::runtime::core::channel::PublishTypeWrapper>,aimrt::runtime::core::channel::ChannelRegistry::Key::Hash,std::equal_to<aimrt::runtime::core::channel::ChannelRegistry::Key>,std::allocator<std::pair<aimrt::runtime::core::channel::ChannelRegistry::Key const,std::unique_ptr<aimrt::runtime::core::channel::PublishTypeWrapper>>>>::find(aimrt::runtime::core::channel::ChannelRegistry::Key const&)
mov rdi, [rsp+98h+var_88]
mov [rsp+98h+var_38], rax
add rdi, 10h
call _ZNKSt13unordered_mapIN5aimrt7runtime4core7channel15ChannelRegistry3KeyESt10unique_ptrINS3_18PublishTypeWrapperESt14default_deleteIS7_EENS5_4HashESt8equal_toIS5_ESaISt4pairIKS5_SA_EEE3endEv; std::unordered_map<aimrt::runtime::core::channel::ChannelRegistry::Key,std::unique_ptr<aimrt::runtime::core::channel::PublishTypeWrapper>,aimrt::runtime::core::channel::ChannelRegistry::Key::Hash,std::equal_to<aimrt::runtime::core::channel::ChannelRegistry::Key>,std::allocator<std::pair<aimrt::runtime::core::channel::ChannelRegistry::Key const,std::unique_ptr<aimrt::runtime::core::channel::PublishTypeWrapper>>>>::end(void)
mov [rsp+98h+var_80], rax
lea rdi, [rsp+98h+var_38]
lea rsi, [rsp+98h+var_80]
call __ZNSt8__detaileqERKNS_19_Node_iterator_baseISt4pairIKN5aimrt7runtime4core7channel15ChannelRegistry3KeyESt10unique_ptrINS5_18PublishTypeWrapperESt14default_deleteISA_EEELb1EEESH_; std::__detail::operator==(std::__detail::_Node_iterator_base<std::pair<aimrt::runtime::core::channel::ChannelRegistry::Key const,std::unique_ptr<aimrt::runtime::core::channel::PublishTypeWrapper>>,true> const&,std::__detail::_Node_iterator_base<std::pair<aimrt::runtime::core::channel::ChannelRegistry::Key const,std::unique_ptr<aimrt::runtime::core::channel::PublishTypeWrapper>>,true> const&)
xor al, 0FFh
test al, 1
jnz short loc_12ADB5
jmp short loc_12ADD5
loc_12ADB5:
lea rdi, [rsp+98h+var_38]
call _ZNKSt8__detail20_Node_const_iteratorISt4pairIKN5aimrt7runtime4core7channel15ChannelRegistry3KeyESt10unique_ptrINS5_18PublishTypeWrapperESt14default_deleteISA_EEELb0ELb1EEptEv; std::__detail::_Node_const_iterator<std::pair<aimrt::runtime::core::channel::ChannelRegistry::Key const,std::unique_ptr<aimrt::runtime::core::channel::PublishTypeWrapper>>,false,true>::operator->(void)
mov rdi, rax
add rdi, 40h ; '@'
call _ZNKSt10unique_ptrIN5aimrt7runtime4core7channel18PublishTypeWrapperESt14default_deleteIS4_EE3getEv; std::unique_ptr<aimrt::runtime::core::channel::PublishTypeWrapper>::get(void)
mov [rsp+98h+var_8], rax
jmp short loc_12ADE1
loc_12ADD5:
mov [rsp+98h+var_8], 0
loc_12ADE1:
mov rax, [rsp+98h+var_8]
add rsp, 98h
retn
| long long aimrt::runtime::core::channel::ChannelRegistry::GetPublishTypeWrapperPtr(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7,
long long a8,
long long a9,
long long a10)
{
long long v11; // [rsp+18h] [rbp-80h] BYREF
_QWORD v12[8]; // [rsp+20h] [rbp-78h] BYREF
_QWORD v13[6]; // [rsp+60h] [rbp-38h] BYREF
v13[4] = a2;
v13[5] = a3;
v13[2] = a4;
v13[3] = a5;
v13[1] = a1;
v12[0] = a2;
v12[1] = a3;
v12[2] = a4;
v12[3] = a5;
v12[4] = a7;
v12[5] = a8;
v12[6] = a9;
v12[7] = a10;
v13[0] = std::unordered_map<aimrt::runtime::core::channel::ChannelRegistry::Key,std::unique_ptr<aimrt::runtime::core::channel::PublishTypeWrapper>,aimrt::runtime::core::channel::ChannelRegistry::Key::Hash,std::equal_to<aimrt::runtime::core::channel::ChannelRegistry::Key>,std::allocator<std::pair<aimrt::runtime::core::channel::ChannelRegistry::Key const,std::unique_ptr<aimrt::runtime::core::channel::PublishTypeWrapper>>>>::find(
a1 + 16,
v12);
v11 = std::unordered_map<aimrt::runtime::core::channel::ChannelRegistry::Key,std::unique_ptr<aimrt::runtime::core::channel::PublishTypeWrapper>,aimrt::runtime::core::channel::ChannelRegistry::Key::Hash,std::equal_to<aimrt::runtime::core::channel::ChannelRegistry::Key>,std::allocator<std::pair<aimrt::runtime::core::channel::ChannelRegistry::Key const,std::unique_ptr<aimrt::runtime::core::channel::PublishTypeWrapper>>>>::end(a1 + 16);
if ( (std::__detail::operator==(v13, &v11) & 1) != 0 )
return 0LL;
std::__detail::_Node_const_iterator<std::pair<aimrt::runtime::core::channel::ChannelRegistry::Key const,std::unique_ptr<aimrt::runtime::core::channel::PublishTypeWrapper>>,false,true>::operator->(v13);
return std::unique_ptr<aimrt::runtime::core::channel::PublishTypeWrapper>::get();
}
| |||
38,624 | aimrt::runtime::core::channel::ChannelRegistry::GetPublishTypeWrapperPtr(std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>) const | aimrt_mujoco_sim/_deps/aimrt-src/src/runtime/core/channel/channel_registry.cc | const PublishTypeWrapper* ChannelRegistry::GetPublishTypeWrapperPtr(
std::string_view msg_type,
std::string_view topic_name,
std::string_view pkg_path,
std::string_view module_name) const {
auto find_itr = publish_type_wrapper_map_.find(
Key{.msg_type = msg_type, .topic_name = topic_name, .pkg_path = pkg_path, .module_name = module_name});
if (find_itr != publish_type_wrapper_map_.end())
return find_itr->second.get();
return nullptr;
} | O3 | cpp | aimrt::runtime::core::channel::ChannelRegistry::GetPublishTypeWrapperPtr(std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>) const:
subq $0x48, %rsp
addq $0x10, %rdi
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %r8, 0x18(%rax)
movaps 0x50(%rsp), %xmm0
movups %xmm0, 0x20(%rax)
movaps 0x60(%rsp), %xmm0
movups %xmm0, 0x30(%rax)
movq %rax, %rsi
callq 0x55166
testq %rax, %rax
je 0x5377d
movq 0x48(%rax), %rax
jmp 0x5377f
xorl %eax, %eax
addq $0x48, %rsp
retq
| _ZNK5aimrt7runtime4core7channel15ChannelRegistry24GetPublishTypeWrapperPtrESt17basic_string_viewIcSt11char_traitsIcEES7_S7_S7_:
sub rsp, 48h
add rdi, 10h
lea rax, [rsp+48h+var_40]
mov [rax], rsi
mov [rax+8], rdx
mov [rax+10h], rcx
mov [rax+18h], r8
movaps xmm0, [rsp+48h+arg_0]
movups xmmword ptr [rax+20h], xmm0
movaps xmm0, [rsp+48h+arg_10]
movups xmmword ptr [rax+30h], xmm0
mov rsi, rax
call _ZNKSt10_HashtableIN5aimrt7runtime4core7channel15ChannelRegistry3KeyESt4pairIKS5_St10unique_ptrINS3_18PublishTypeWrapperESt14default_deleteIS9_EEESaISD_ENSt8__detail10_Select1stESt8equal_toIS5_ENS5_4HashENSF_18_Mod_range_hashingENSF_20_Default_ranged_hashENSF_20_Prime_rehash_policyENSF_17_Hashtable_traitsILb1ELb0ELb1EEEE4findERS7_; std::_Hashtable<aimrt::runtime::core::channel::ChannelRegistry::Key,std::pair<aimrt::runtime::core::channel::ChannelRegistry::Key const,std::unique_ptr<aimrt::runtime::core::channel::PublishTypeWrapper>>,std::allocator<std::pair<aimrt::runtime::core::channel::ChannelRegistry::Key const,std::unique_ptr<aimrt::runtime::core::channel::PublishTypeWrapper>>>,std::__detail::_Select1st,std::equal_to<aimrt::runtime::core::channel::ChannelRegistry::Key>,aimrt::runtime::core::channel::ChannelRegistry::Key::Hash,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(aimrt::runtime::core::channel::ChannelRegistry::Key const&)
test rax, rax
jz short loc_5377D
mov rax, [rax+48h]
jmp short loc_5377F
loc_5377D:
xor eax, eax
loc_5377F:
add rsp, 48h
retn
| long long aimrt::runtime::core::channel::ChannelRegistry::GetPublishTypeWrapperPtr(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__int128 a7,
__int128 a8)
{
long long v8; // rax
_QWORD v10[4]; // [rsp+8h] [rbp-40h] BYREF
__int128 v11; // [rsp+28h] [rbp-20h]
__int128 v12; // [rsp+38h] [rbp-10h]
v10[0] = a2;
v10[1] = a3;
v10[2] = a4;
v10[3] = a5;
v11 = a7;
v12 = a8;
v8 = std::_Hashtable<aimrt::runtime::core::channel::ChannelRegistry::Key,std::pair<aimrt::runtime::core::channel::ChannelRegistry::Key const,std::unique_ptr<aimrt::runtime::core::channel::PublishTypeWrapper>>,std::allocator<std::pair<aimrt::runtime::core::channel::ChannelRegistry::Key const,std::unique_ptr<aimrt::runtime::core::channel::PublishTypeWrapper>>>,std::__detail::_Select1st,std::equal_to<aimrt::runtime::core::channel::ChannelRegistry::Key>,aimrt::runtime::core::channel::ChannelRegistry::Key::Hash,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(
a1 + 16,
v10);
if ( v8 )
return *(_QWORD *)(v8 + 72);
else
return 0LL;
}
| GetPublishTypeWrapperPtr:
SUB RSP,0x48
ADD RDI,0x10
LEA RAX,[RSP + 0x8]
MOV qword ptr [RAX],RSI
MOV qword ptr [RAX + 0x8],RDX
MOV qword ptr [RAX + 0x10],RCX
MOV qword ptr [RAX + 0x18],R8
MOVAPS XMM0,xmmword ptr [RSP + 0x50]
MOVUPS xmmword ptr [RAX + 0x20],XMM0
MOVAPS XMM0,xmmword ptr [RSP + 0x60]
MOVUPS xmmword ptr [RAX + 0x30],XMM0
MOV RSI,RAX
CALL 0x00155166
TEST RAX,RAX
JZ 0x0015377d
MOV RAX,qword ptr [RAX + 0x48]
JMP 0x0015377f
LAB_0015377d:
XOR EAX,EAX
LAB_0015377f:
ADD RSP,0x48
RET
|
/* aimrt::runtime::core::channel::ChannelRegistry::GetPublishTypeWrapperPtr(std::basic_string_view<char,
std::char_traits<char> >, std::basic_string_view<char, std::char_traits<char> >,
std::basic_string_view<char, std::char_traits<char> >, std::basic_string_view<char,
std::char_traits<char> >) const */
int8
aimrt::runtime::core::channel::ChannelRegistry::GetPublishTypeWrapperPtr
(long param_1,int8 param_2,int8 param_3,int8 param_4,int8 param_5,
int8 param_6,int8 param_7,int8 param_8,int8 param_9,
int8 param_10)
{
long lVar1;
int8 uVar2;
int8 local_40;
int8 local_38;
int8 local_30;
int8 local_28;
int8 local_20;
int8 uStack_18;
int8 local_10;
int8 uStack_8;
local_20 = param_7;
uStack_18 = param_8;
local_10 = param_9;
uStack_8 = param_10;
local_40 = param_2;
local_38 = param_3;
local_30 = param_4;
local_28 = param_5;
lVar1 = std::
_Hashtable<aimrt::runtime::core::channel::ChannelRegistry::Key,std::pair<aimrt::runtime::core::channel::ChannelRegistry::Key_const,std::unique_ptr<aimrt::runtime::core::channel::PublishTypeWrapper,std::default_delete<aimrt::runtime::core::channel::PublishTypeWrapper>>>,std::allocator<std::pair<aimrt::runtime::core::channel::ChannelRegistry::Key_const,std::unique_ptr<aimrt::runtime::core::channel::PublishTypeWrapper,std::default_delete<aimrt::runtime::core::channel::PublishTypeWrapper>>>>,std::__detail::_Select1st,std::equal_to<aimrt::runtime::core::channel::ChannelRegistry::Key>,aimrt::runtime::core::channel::ChannelRegistry::Key::Hash,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::find((_Hashtable<aimrt::runtime::core::channel::ChannelRegistry::Key,std::pair<aimrt::runtime::core::channel::ChannelRegistry::Key_const,std::unique_ptr<aimrt::runtime::core::channel::PublishTypeWrapper,std::default_delete<aimrt::runtime::core::channel::PublishTypeWrapper>>>,std::allocator<std::pair<aimrt::runtime::core::channel::ChannelRegistry::Key_const,std::unique_ptr<aimrt::runtime::core::channel::PublishTypeWrapper,std::default_delete<aimrt::runtime::core::channel::PublishTypeWrapper>>>>,std::__detail::_Select1st,std::equal_to<aimrt::runtime::core::channel::ChannelRegistry::Key>,aimrt::runtime::core::channel::ChannelRegistry::Key::Hash,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
*)(param_1 + 0x10),(Key *)&local_40);
if (lVar1 == 0) {
uVar2 = 0;
}
else {
uVar2 = *(int8 *)(lVar1 + 0x48);
}
return uVar2;
}
| |
38,625 | uf_zerofill_skip_zero | eloqsql/storage/myisam/mi_packrec.c | static void uf_zerofill_skip_zero(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
uchar *to, uchar *end)
{
if (get_bit(bit_buff))
bzero((char*) to,(uint) (end-to));
else
{
end-=rec->space_length_bits;
decode_bytes(rec,bit_buff,to,end);
bzero((char*) end,rec->space_length_bits);
}
} | O3 | c | uf_zerofill_skip_zero:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movl 0x4(%rsi), %eax
testl %eax, %eax
je 0x82495
movl (%r12), %ecx
decl %eax
movl %eax, 0x4(%r12)
btl %eax, %ecx
jae 0x824ad
subl %r14d, %ebx
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
jmp 0x824ce
movq %r12, %rdi
callq 0x81cfd
movl $0x1f, 0x4(%r12)
cmpl $0x0, (%r12)
js 0x82488
movl 0x1c(%r15), %eax
subq %rax, %rbx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x825ee
movl 0x1c(%r15), %edx
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x292b0
| uf_zerofill_skip_zero_0:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rcx
mov r14, rdx
mov r12, rsi
mov r15, rdi
mov eax, [rsi+4]
test eax, eax
jz short loc_82495
mov ecx, [r12]
dec eax
mov [r12+4], eax
bt ecx, eax
jnb short loc_824AD
loc_82488:
sub ebx, r14d
mov rdi, r14
xor esi, esi
mov rdx, rbx
jmp short loc_824CE
loc_82495:
mov rdi, r12
call fill_buffer_0
mov dword ptr [r12+4], 1Fh
cmp dword ptr [r12], 0
js short loc_82488
loc_824AD:
mov eax, [r15+1Ch]
sub rbx, rax
mov rdi, r15
mov rsi, r12
mov rdx, r14
mov rcx, rbx
call decode_bytes_0
mov edx, [r15+1Ch]
mov rdi, rbx
xor esi, esi
loc_824CE:
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp _memset
| long long uf_zerofill_skip_zero_0(long long a1, int *a2, long long a3, long long a4)
{
int v6; // eax
int v7; // ecx
unsigned int v8; // eax
long long v10; // rbx
v6 = a2[1];
if ( v6 )
{
v7 = *a2;
v8 = v6 - 1;
a2[1] = v8;
if ( _bittest(&v7, v8) )
return memset(a3, 0LL, (unsigned int)(a4 - a3));
}
else
{
fill_buffer_0((long long)a2);
a2[1] = 31;
if ( *a2 < 0 )
return memset(a3, 0LL, (unsigned int)(a4 - a3));
}
v10 = a4 - *(unsigned int *)(a1 + 28);
decode_bytes_0(a1, a2, a3, v10);
return memset(v10, 0LL, *(unsigned int *)(a1 + 28));
}
| uf_zerofill_skip_zero:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RCX
MOV R14,RDX
MOV R12,RSI
MOV R15,RDI
MOV EAX,dword ptr [RSI + 0x4]
TEST EAX,EAX
JZ 0x00182495
MOV ECX,dword ptr [R12]
DEC EAX
MOV dword ptr [R12 + 0x4],EAX
BT ECX,EAX
JNC 0x001824ad
LAB_00182488:
SUB EBX,R14D
MOV RDI,R14
XOR ESI,ESI
MOV RDX,RBX
JMP 0x001824ce
LAB_00182495:
MOV RDI,R12
CALL 0x00181cfd
MOV dword ptr [R12 + 0x4],0x1f
CMP dword ptr [R12],0x0
JS 0x00182488
LAB_001824ad:
MOV EAX,dword ptr [R15 + 0x1c]
SUB RBX,RAX
MOV RDI,R15
MOV RSI,R12
MOV RDX,R14
MOV RCX,RBX
CALL 0x001825ee
MOV EDX,dword ptr [R15 + 0x1c]
MOV RDI,RBX
XOR ESI,ESI
LAB_001824ce:
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x001292b0
|
void uf_zerofill_skip_zero(long param_1,uint *param_2,void *param_3,long param_4)
{
uint uVar1;
void *__s;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
if (-1 < (int)*param_2) goto LAB_001824ad;
}
else {
uVar1 = param_2[1] - 1;
param_2[1] = uVar1;
if ((*param_2 >> (uVar1 & 0x1f) & 1) == 0) {
LAB_001824ad:
__s = (void *)(param_4 - (ulong)*(uint *)(param_1 + 0x1c));
decode_bytes(param_1,param_2,param_3,__s);
uVar1 = *(uint *)(param_1 + 0x1c);
goto LAB_001824ce;
}
}
uVar1 = (int)param_4 - (int)param_3;
__s = param_3;
LAB_001824ce:
memset(__s,0,(ulong)uVar1);
return;
}
| |
38,626 | warning | bluesky950520[P]quickjs/run-test262.c | void warning(const char *fmt, ...)
{
va_list ap;
fflush(stdout);
fprintf(stderr, "%s: ", CMD_NAME);
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
fputc('\n', stderr);
} | O0 | c | warning:
subq $0xe8, %rsp
testb %al, %al
je 0xebbf
movaps %xmm0, 0x40(%rsp)
movaps %xmm1, 0x50(%rsp)
movaps %xmm2, 0x60(%rsp)
movaps %xmm3, 0x70(%rsp)
movaps %xmm4, 0x80(%rsp)
movaps %xmm5, 0x90(%rsp)
movaps %xmm6, 0xa0(%rsp)
movaps %xmm7, 0xb0(%rsp)
movq %r9, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0xe0(%rsp)
movq 0x12e3d9(%rip), %rax # 0x13cfc0
movq (%rax), %rdi
callq 0xe6e0
movq 0x12e402(%rip), %rax # 0x13cff8
movq %rax, 0x8(%rsp)
movq (%rax), %rdi
leaq 0x1004cb(%rip), %rsi # 0x10f0d0
leaq 0x1004c9(%rip), %rdx # 0x10f0d5
xorl %eax, %eax
callq 0xe5a0
movq 0x8(%rsp), %rax
leaq 0x10(%rsp), %rcx
movq %rcx, 0xd0(%rsp)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0xc8(%rsp)
movl $0x30, 0xc4(%rsp)
movl $0x8, 0xc0(%rsp)
movq (%rax), %rdi
movq 0xe0(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
callq 0xe870
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movl $0xa, %edi
callq 0xe450
addq $0xe8, %rsp
retq
nopl (%rax)
| warning:
sub rsp, 0E8h
test al, al
jz short loc_EBBF
movaps [rsp+0E8h+var_A8], xmm0
movaps [rsp+0E8h+var_98], xmm1
movaps [rsp+0E8h+var_88], xmm2
movaps [rsp+0E8h+var_78], xmm3
movaps [rsp+0E8h+var_68], xmm4
movaps [rsp+0E8h+var_58], xmm5
movaps [rsp+0E8h+var_48], xmm6
movaps [rsp+0E8h+var_38], xmm7
loc_EBBF:
mov [rsp+0E8h+var_B0], r9
mov [rsp+0E8h+var_B8], r8
mov [rsp+0E8h+var_C0], rcx
mov [rsp+0E8h+var_C8], rdx
mov [rsp+0E8h+var_D0], rsi
mov [rsp+0E8h+var_8], rdi
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov [rsp+0E8h+var_E0], rax
mov rdi, [rax]
lea rsi, aS; "%s: "
lea rdx, aRunTest262; "run-test262"
xor eax, eax
call _fprintf
mov rax, [rsp+0E8h+var_E0]
lea rcx, [rsp+0E8h+var_D8]
mov [rsp+0E8h+var_18], rcx
lea rcx, [rsp+0E8h+arg_0]
mov [rsp+0E8h+var_20], rcx
mov [rsp+0E8h+var_24], 30h ; '0'
mov [rsp+0E8h+var_28], 8
mov rdi, [rax]
mov rsi, [rsp+0E8h+var_8]
lea rdx, [rsp+0E8h+var_28]
call _vfprintf
mov rax, [rsp+0E8h+var_E0]
mov rsi, [rax]
mov edi, 0Ah
call _fputc
add rsp, 0E8h
retn
| long long warning(
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-D8h] BYREF
long long v17; // [rsp+18h] [rbp-D0h]
long long v18; // [rsp+20h] [rbp-C8h]
long long v19; // [rsp+28h] [rbp-C0h]
long long v20; // [rsp+30h] [rbp-B8h]
long long v21; // [rsp+38h] [rbp-B0h]
__m128 v22; // [rsp+40h] [rbp-A8h]
__m128 v23; // [rsp+50h] [rbp-98h]
__m128 v24; // [rsp+60h] [rbp-88h]
__m128 v25; // [rsp+70h] [rbp-78h]
__m128 v26; // [rsp+80h] [rbp-68h]
__m128 v27; // [rsp+90h] [rbp-58h]
__m128 v28; // [rsp+A0h] [rbp-48h]
__m128 v29; // [rsp+B0h] [rbp-38h]
_DWORD v30[2]; // [rsp+C0h] [rbp-28h] BYREF
char *v31; // [rsp+C8h] [rbp-20h]
char *v32; // [rsp+D0h] [rbp-18h]
long long v33; // [rsp+E0h] [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;
fflush(stdout);
fprintf(stderr, "%s: ", "run-test262");
v32 = &v16;
v31 = &a15;
v30[1] = 48;
v30[0] = 8;
vfprintf(stderr, a1, v30);
return fputc(10LL, stderr);
}
| warning:
SUB RSP,0xe8
TEST AL,AL
JZ 0x0010ebbf
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVAPS xmmword ptr [RSP + 0x50],XMM1
MOVAPS xmmword ptr [RSP + 0x60],XMM2
MOVAPS xmmword ptr [RSP + 0x70],XMM3
MOVAPS xmmword ptr [RSP + 0x80],XMM4
MOVAPS xmmword ptr [RSP + 0x90],XMM5
MOVAPS xmmword ptr [RSP + 0xa0],XMM6
MOVAPS xmmword ptr [RSP + 0xb0],XMM7
LAB_0010ebbf:
MOV qword ptr [RSP + 0x38],R9
MOV qword ptr [RSP + 0x30],R8
MOV qword ptr [RSP + 0x28],RCX
MOV qword ptr [RSP + 0x20],RDX
MOV qword ptr [RSP + 0x18],RSI
MOV qword ptr [RSP + 0xe0],RDI
MOV RAX,qword ptr [0x0023cfc0]
MOV RDI,qword ptr [RAX]
CALL 0x0010e6e0
MOV RAX,qword ptr [0x0023cff8]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RAX]
LEA RSI,[0x20f0d0]
LEA RDX,[0x20f0d5]
XOR EAX,EAX
CALL 0x0010e5a0
MOV RAX,qword ptr [RSP + 0x8]
LEA RCX,[RSP + 0x10]
MOV qword ptr [RSP + 0xd0],RCX
LEA RCX,[RSP + 0xf0]
MOV qword ptr [RSP + 0xc8],RCX
MOV dword ptr [RSP + 0xc4],0x30
MOV dword ptr [RSP + 0xc0],0x8
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RSP + 0xe0]
LEA RDX,[RSP + 0xc0]
CALL 0x0010e870
MOV RAX,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RAX]
MOV EDI,0xa
CALL 0x0010e450
ADD RSP,0xe8
RET
|
void warning(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_8;
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_d0 = param_10;
local_c8 = param_11;
local_c0 = param_12;
local_b8 = param_13;
local_b0 = param_14;
local_8 = param_9;
fflush(*(FILE **)PTR_stdout_0023cfc0);
puVar1 = PTR_stderr_0023cff8;
fprintf(*(FILE **)PTR_stderr_0023cff8,"%s: ","run-test262");
local_18 = local_d8;
local_20 = &stack0x00000008;
local_24 = 0x30;
local_28 = 8;
vfprintf(*(FILE **)puVar1,local_8,&local_28);
fputc(10,*(FILE **)puVar1);
return;
}
| |
38,627 | cr_union1 | bluesky950520[P]quickjs/libunicode.c | int cr_union1(CharRange *cr, const uint32_t *b_pt, int b_len)
{
CharRange a = *cr;
int ret;
cr->len = 0;
cr->size = 0;
cr->points = NULL;
ret = cr_op(cr, a.points, a.len, b_pt, b_len, CR_OP_UNION);
cr_free(&a);
return ret;
} | O2 | c | cr_union1:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r8d
movq %rsi, %rcx
movl (%rdi), %edx
movq 0x8(%rdi), %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rbx, %rsi
xorl %r9d, %r9d
callq 0x83065
movl %eax, %ebp
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq *%r15
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| cr_union1:
push rbp
push r15
push r14
push rbx
push rax
mov r8d, edx
mov rcx, rsi
mov edx, [rdi]
mov rbx, [rdi+8]
mov r14, [rdi+10h]
mov r15, [rdi+18h]
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov rsi, rbx
xor r9d, r9d
call cr_op
mov ebp, eax
mov rdi, r14
mov rsi, rbx
xor edx, edx
call r15
mov eax, ebp
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long cr_union1(long long a1, long long a2, int a3)
{
int v4; // edx
long long v5; // rbx
long long v6; // r14
void ( *v7)(long long, long long, _QWORD); // r15
unsigned int v8; // ebp
v4 = *(_DWORD *)a1;
v5 = *(_QWORD *)(a1 + 8);
v6 = *(_QWORD *)(a1 + 16);
v7 = *(void ( **)(long long, long long, _QWORD))(a1 + 24);
*(_OWORD *)a1 = 0LL;
v8 = cr_op((const char *)a1, v5, v4, a2, a3, 0);
v7(v6, v5, 0LL);
return v8;
}
| cr_union1:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R8D,EDX
MOV RCX,RSI
MOV EDX,dword ptr [RDI]
MOV RBX,qword ptr [RDI + 0x8]
MOV R14,qword ptr [RDI + 0x10]
MOV R15,qword ptr [RDI + 0x18]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV RSI,RBX
XOR R9D,R9D
CALL 0x00183065
MOV EBP,EAX
MOV RDI,R14
MOV RSI,RBX
XOR EDX,EDX
CALL R15
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 cr_union1(int8 *param_1,int8 param_2,int4 param_3)
{
int8 uVar1;
int8 uVar2;
code *pcVar3;
int4 uVar4;
uVar4 = *(int4 *)param_1;
uVar1 = param_1[1];
uVar2 = param_1[2];
pcVar3 = (code *)param_1[3];
*param_1 = 0;
param_1[1] = 0;
uVar4 = cr_op(param_1,uVar1,uVar4,param_2,param_3,0);
(*pcVar3)(uVar2,uVar1,0);
return uVar4;
}
| |
38,628 | pfs_register_stage_v1 | eloqsql/storage/perfschema/pfs.cc | void pfs_register_stage_v1(const char *category,
PSI_stage_info_v1 **info_array,
int count)
{
char formatted_name[PFS_MAX_INFO_NAME_LENGTH];
size_t prefix_length;
size_t len;
size_t full_length;
PSI_stage_info_v1 *info;
assert(category != NULL);
assert(info_array != NULL);
if (unlikely(build_prefix(&stage_instrument_prefix, category,
formatted_name, &prefix_length)) ||
! pfs_initialized)
{
for (; count>0; count--, info_array++)
(*info_array)->m_key= 0;
return ;
}
for (; count>0; count--, info_array++)
{
info= *info_array;
DBUG_ASSERT(info != NULL);
DBUG_ASSERT(info->m_name != NULL);
len= (int)strlen(info->m_name);
DBUG_ASSERT(len <= 64); // see table_threads.cc near PROCESSLIST_STATE
full_length= prefix_length + len;
if (likely(full_length <= PFS_MAX_INFO_NAME_LENGTH))
{
memcpy(formatted_name + prefix_length, info->m_name, len);
info->m_key= register_stage_class(formatted_name,
(uint)prefix_length,
(uint)full_length,
info->m_flags);
}
else
{
pfs_print_error("register_stage_v1: name too long <%s> <%s>\n",
category, info->m_name);
info->m_key= 0;
}
}
return;
} | O3 | cpp | pfs_register_stage_v1:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq 0x2dbc2c(%rip), %rax # 0x317668
movq (%rax), %rdi
movq 0x8(%rax), %rsi
leaq -0xb0(%rbp), %rcx
leaq -0xd8(%rbp), %r8
movq %r15, %rdx
callq 0x3b3a3
testl %eax, %eax
jne 0x3bb34
leaq 0x352860(%rip), %rax # 0x38e2c8
cmpb $0x1, (%rax)
jne 0x3bb34
movq %r15, -0xc0(%rbp)
testl %ebx, %ebx
jle 0x3bb4e
movq -0xd8(%rbp), %r12
leaq (%r12,%rbp), %rax
addq $-0xb0, %rax
movq %rax, -0xc8(%rbp)
incl %ebx
movq %r12, -0xd0(%rbp)
movq (%r14), %rax
movq %rax, -0xb8(%rbp)
movq 0x8(%rax), %r15
movq %r15, %rdi
callq 0x26150
movslq %eax, %rdx
leaq (%rdx,%r12), %r13
cmpq $0x80, %r13
ja 0x3bb10
movq -0xc8(%rbp), %rdi
movq %r15, %rsi
callq 0x26290
movq -0xb8(%rbp), %r15
movl 0x10(%r15), %ecx
leaq -0xb0(%rbp), %rdi
movl %r12d, %esi
movl %r13d, %edx
callq 0x35c1a
movl %eax, %r13d
movq %r15, %rax
movl %r13d, (%rax)
addq $0x8, %r14
decl %ebx
cmpl $0x1, %ebx
movq -0xd0(%rbp), %r12
jg 0x3baa1
jmp 0x3bb4e
xorl %r13d, %r13d
leaq 0x406be(%rip), %rdi # 0x7c1d8
movq -0xc0(%rbp), %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2cdc5
movq -0xb8(%rbp), %rax
jmp 0x3baf9
testl %ebx, %ebx
jle 0x3bb4e
incl %ebx
movq (%r14), %rax
movl $0x0, (%rax)
addq $0x8, %r14
decl %ebx
cmpl $0x1, %ebx
ja 0x3bb3a
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x3bb6f
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x263a0
| pfs_register_stage_v1:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0B8h
mov ebx, edx
mov r14, rsi
mov r15, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
lea rax, stage_instrument_prefix
mov rdi, [rax]
mov rsi, [rax+8]
lea rcx, [rbp+var_B0]
lea r8, [rbp+var_D8]
mov rdx, r15
call _ZL12build_prefixPK25st_mysql_const_lex_stringPKcPcPm; build_prefix(st_mysql_const_lex_string const*,char const*,char *,ulong *)
test eax, eax
jnz loc_3BB34
lea rax, pfs_initialized
cmp byte ptr [rax], 1
jnz loc_3BB34
mov [rbp+var_C0], r15
test ebx, ebx
jle loc_3BB4E
mov r12, qword ptr [rbp+var_D8]
lea rax, [r12+rbp]
add rax, 0FFFFFFFFFFFFFF50h
mov [rbp+var_C8], rax
inc ebx
mov [rbp+var_D0], r12
loc_3BAA1:
mov rax, [r14]
mov [rbp+var_B8], rax
mov r15, [rax+8]
mov rdi, r15
call _strlen
movsxd rdx, eax
lea r13, [rdx+r12]
cmp r13, 80h
ja short loc_3BB10
mov rdi, [rbp+var_C8]
mov rsi, r15
call _memcpy
mov r15, [rbp+var_B8]
mov ecx, [r15+10h]; int
lea rdi, [rbp+var_B0]; char *
mov esi, r12d; unsigned int
mov edx, r13d; unsigned int
call _Z20register_stage_classPKcjji; register_stage_class(char const*,uint,uint,int)
mov r13d, eax
mov rax, r15
loc_3BAF9:
mov [rax], r13d
add r14, 8
dec ebx
cmp ebx, 1
mov r12, [rbp+var_D0]
jg short loc_3BAA1
jmp short loc_3BB4E
loc_3BB10:
xor r13d, r13d
lea rdi, aRegisterStageV; "register_stage_v1: name too long <%s> <"...
mov rsi, [rbp+var_C0]
mov rdx, r15
xor eax, eax
call _Z15pfs_print_errorPKcz; pfs_print_error(char const*,...)
mov rax, [rbp+var_B8]
jmp short loc_3BAF9
loc_3BB34:
test ebx, ebx
jle short loc_3BB4E
inc ebx
loc_3BB3A:
mov rax, [r14]
mov dword ptr [rax], 0
add r14, 8
dec ebx
cmp ebx, 1
ja short loc_3BB3A
loc_3BB4E:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_3BB6F
add rsp, 0B8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3BB6F:
call ___stack_chk_fail
| unsigned long long pfs_register_stage_v1(long long a1, _DWORD **a2, int a3)
{
long long v5; // r12
int v6; // ebx
long long v7; // r15
long long v8; // rdx
unsigned int v9; // r13d
_DWORD *v10; // r15
int v11; // r13d
_DWORD *v12; // rax
unsigned int v13; // ebx
unsigned int v15[2]; // [rsp+8h] [rbp-D8h] BYREF
long long v16; // [rsp+10h] [rbp-D0h]
char *v17; // [rsp+18h] [rbp-C8h]
long long v18; // [rsp+20h] [rbp-C0h]
_DWORD *v19; // [rsp+28h] [rbp-B8h]
char v20[128]; // [rsp+30h] [rbp-B0h] BYREF
unsigned long long v21; // [rsp+B0h] [rbp-30h]
v21 = __readfsqword(0x28u);
if ( (unsigned int)build_prefix(
(long long)stage_instrument_prefix,
(long long)*(&stage_instrument_prefix + 1),
a1,
(long long)v20,
v15)
|| pfs_initialized[0] != 1 )
{
if ( a3 > 0 )
{
v13 = a3 + 1;
do
{
**a2++ = 0;
--v13;
}
while ( v13 > 1 );
}
}
else
{
v18 = a1;
if ( a3 > 0 )
{
v5 = *(_QWORD *)v15;
v17 = &v20[*(_QWORD *)v15];
v6 = a3 + 1;
v16 = *(_QWORD *)v15;
do
{
v19 = *a2;
v7 = *((_QWORD *)v19 + 1);
v8 = (int)strlen(v7);
v9 = v8 + v5;
if ( (unsigned long long)(v8 + v5) > 0x80 )
{
v11 = 0;
pfs_print_error("register_stage_v1: name too long <%s> <%s>\n");
v12 = v19;
}
else
{
memcpy(v17, v7, v8);
v10 = v19;
v11 = register_stage_class(v20, v5, v9, v19[4]);
v12 = v10;
}
*v12 = v11;
++a2;
--v6;
v5 = v16;
}
while ( v6 > 1 );
}
}
return __readfsqword(0x28u);
}
| pfs_register_stage_v1:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xb8
MOV EBX,EDX
MOV R14,RSI
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[0x417668]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x8]
LEA RCX,[RBP + -0xb0]
LEA R8,[RBP + -0xd8]
MOV RDX,R15
CALL 0x0013b3a3
TEST EAX,EAX
JNZ 0x0013bb34
LEA RAX,[0x48e2c8]
CMP byte ptr [RAX],0x1
JNZ 0x0013bb34
MOV qword ptr [RBP + -0xc0],R15
TEST EBX,EBX
JLE 0x0013bb4e
MOV R12,qword ptr [RBP + -0xd8]
LEA RAX,[R12 + RBP*0x1]
ADD RAX,-0xb0
MOV qword ptr [RBP + -0xc8],RAX
INC EBX
MOV qword ptr [RBP + -0xd0],R12
LAB_0013baa1:
MOV RAX,qword ptr [R14]
MOV qword ptr [RBP + -0xb8],RAX
MOV R15,qword ptr [RAX + 0x8]
MOV RDI,R15
CALL 0x00126150
MOVSXD RDX,EAX
LEA R13,[RDX + R12*0x1]
CMP R13,0x80
JA 0x0013bb10
MOV RDI,qword ptr [RBP + -0xc8]
MOV RSI,R15
CALL 0x00126290
MOV R15,qword ptr [RBP + -0xb8]
MOV ECX,dword ptr [R15 + 0x10]
LEA RDI,[RBP + -0xb0]
MOV ESI,R12D
MOV EDX,R13D
CALL 0x00135c1a
MOV R13D,EAX
MOV RAX,R15
LAB_0013baf9:
MOV dword ptr [RAX],R13D
ADD R14,0x8
DEC EBX
CMP EBX,0x1
MOV R12,qword ptr [RBP + -0xd0]
JG 0x0013baa1
JMP 0x0013bb4e
LAB_0013bb10:
XOR R13D,R13D
LEA RDI,[0x17c1d8]
MOV RSI,qword ptr [RBP + -0xc0]
MOV RDX,R15
XOR EAX,EAX
CALL 0x0012cdc5
MOV RAX,qword ptr [RBP + -0xb8]
JMP 0x0013baf9
LAB_0013bb34:
TEST EBX,EBX
JLE 0x0013bb4e
INC EBX
LAB_0013bb3a:
MOV RAX,qword ptr [R14]
MOV dword ptr [RAX],0x0
ADD R14,0x8
DEC EBX
CMP EBX,0x1
JA 0x0013bb3a
LAB_0013bb4e:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0013bb6f
ADD RSP,0xb8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013bb6f:
CALL 0x001263a0
|
void pfs_register_stage_v1(char *param_1,long *param_2,int param_3)
{
ulong uVar1;
int4 *puVar2;
char *__s;
int iVar3;
int4 uVar4;
size_t sVar5;
uint uVar6;
long in_FS_OFFSET;
long local_e0;
ulong local_b8 [16];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
iVar3 = build_prefix((st_mysql_const_lex_string *)stage_instrument_prefix,DAT_00417670,param_1,
local_b8);
if ((iVar3 == 0) && (pfs_initialized == '\x01')) {
if (0 < param_3) {
param_3 = param_3 + 1;
do {
puVar2 = (int4 *)*param_2;
__s = *(char **)(puVar2 + 2);
sVar5 = strlen(__s);
uVar1 = (int)sVar5 + local_e0;
if (uVar1 < 0x81) {
memcpy((void *)((long)local_b8 + local_e0),__s,(long)(int)sVar5);
uVar4 = register_stage_class((char *)local_b8,(uint)local_e0,(uint)uVar1,puVar2[4]);
}
else {
uVar4 = 0;
pfs_print_error("register_stage_v1: name too long <%s> <%s>\n",param_1,__s);
}
*puVar2 = uVar4;
param_2 = param_2 + 1;
param_3 = param_3 + -1;
} while (1 < param_3);
}
}
else if (0 < param_3) {
uVar6 = param_3 + 1;
do {
*(int4 *)*param_2 = 0;
param_2 = param_2 + 1;
uVar6 = uVar6 - 1;
} while (1 < uVar6);
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
| |
38,629 | common_arg::common_arg(std::initializer_list<char const*> const&, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, void (*)(common_params&, int)) | llama.cpp/common/arg.h | common_arg(
const std::initializer_list<const char *> & args,
const char * value_hint,
const std::string & help,
void (*handler)(common_params & params, int)
) : args(args), value_hint(value_hint), help(help), handler_int(handler) {} | O3 | c | common_arg::common_arg(std::initializer_list<char const*> const&, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, void (*)(common_params&, int)):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsi)
leaq 0x3(%rsp), %rcx
leaq 0x2(%rsp), %r8
movl $0x1, %edx
callq 0x83f90
leaq 0x38(%rbx), %rax
xorl %ecx, %ecx
movq %rcx, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movq %rax, 0x48(%rbx)
movq %rax, 0x50(%rbx)
movq %rcx, 0x58(%rbx)
leaq 0x60(%rbx), %r13
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
leaq 0x1(%rsp), %rcx
movq %r13, %rdi
callq 0x84012
movq %r12, 0x78(%rbx)
leaq 0x90(%rbx), %rdi
leaq 0xa0(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rbx)
movq %rax, 0x90(%rbx)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x2875c
movb $0x0, 0xb0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xb8(%rbx)
movq $0x0, 0xc8(%rbx)
movq %r14, 0xd0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r13), %rdi
testq %rdi, %rdi
je 0x64a3a
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x20180
jmp 0x64a3a
movq %rax, %r14
leaq 0x30(%rbx), %rdi
callq 0x84058
movq %rbx, %rdi
callq 0x84058
movq %r14, %rdi
callq 0x20ae0
nop
| _ZN10common_argC2ERKSt16initializer_listIPKcES2_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPFvR13common_paramsiE:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, r8
mov r15, rcx
mov r12, rdx
mov rbp, rsi
mov rbx, rdi
lea rsi, [rsp+38h+var_34]
mov dword ptr [rsi], 0
lea rcx, [rsp+38h+var_35]
lea r8, [rsp+38h+var_36]
mov edx, 1
call _ZNSt3setI13llama_exampleSt4lessIS0_ESaIS0_EEC2ESt16initializer_listIS0_ERKS2_RKS3_; std::set<llama_example>::set(std::initializer_list<llama_example>,std::less<llama_example> const&,std::allocator<llama_example> const&)
lea rax, [rbx+38h]
xor ecx, ecx
mov [rbx+40h], rcx
xorps xmm0, xmm0
movups xmmword ptr [rbx+30h], xmm0
mov [rbx+48h], rax
mov [rbx+50h], rax
mov [rbx+58h], rcx
lea r13, [rbx+60h]
mov rsi, [rbp+0]
mov rdx, [rbp+8]
lea rcx, [rsp+38h+var_37]
mov rdi, r13
call _ZNSt6vectorIPKcSaIS1_EEC2ESt16initializer_listIS1_ERKS2_; std::vector<char const*>::vector(std::initializer_list<char const*>,std::allocator<char const*> const&)
mov [rbx+78h], r12
lea rdi, [rbx+90h]
lea rax, [rbx+0A0h]
xorps xmm0, xmm0
movups xmmword ptr [rbx+80h], xmm0
mov [rbx+90h], rax
mov rsi, [r15]
mov rdx, [r15+8]
add rdx, rsi
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov byte ptr [rbx+0B0h], 0
xorps xmm0, xmm0
movups xmmword ptr [rbx+0B8h], xmm0
mov qword ptr [rbx+0C8h], 0
mov [rbx+0D0h], r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
mov rdi, [r13+0]; void *
test rdi, rdi
jz short loc_64A3A
mov rsi, [rbx+70h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_64A3A
mov r14, rax
loc_64A3A:
lea rdi, [rbx+30h]
call _ZNSt8_Rb_treeI13llama_exampleS0_St9_IdentityIS0_ESt4lessIS0_ESaIS0_EED2Ev; std::_Rb_tree<llama_example,llama_example,std::_Identity<llama_example>,std::less<llama_example>,std::allocator<llama_example>>::~_Rb_tree()
mov rdi, rbx
call _ZNSt8_Rb_treeI13llama_exampleS0_St9_IdentityIS0_ESt4lessIS0_ESaIS0_EED2Ev; std::_Rb_tree<llama_example,llama_example,std::_Identity<llama_example>,std::less<llama_example>,std::allocator<llama_example>>::~_Rb_tree()
mov rdi, r14
call __Unwind_Resume
| long long common_arg::common_arg(long long a1, _QWORD *a2, long long a3, long long a4, long long a5)
{
int v5; // eax
long long result; // rax
int v10; // [rsp+0h] [rbp-38h] BYREF
_DWORD v11[13]; // [rsp+4h] [rbp-34h] BYREF
v10 = v5;
v11[0] = 0;
std::set<llama_example>::set(a1, v11, 1LL, (char *)&v10 + 3, (char *)&v10 + 2);
*(_QWORD *)(a1 + 64) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_QWORD *)(a1 + 72) = a1 + 56;
*(_QWORD *)(a1 + 80) = a1 + 56;
*(_QWORD *)(a1 + 88) = 0LL;
std::vector<char const*>::vector(a1 + 96, *a2, a2[1], (char *)&v10 + 1);
*(_QWORD *)(a1 + 120) = a3;
*(_OWORD *)(a1 + 128) = 0LL;
*(_QWORD *)(a1 + 144) = a1 + 160;
result = std::string::_M_construct<char *>(a1 + 144, *(_BYTE **)a4, *(_QWORD *)a4 + *(_QWORD *)(a4 + 8));
*(_BYTE *)(a1 + 176) = 0;
*(_OWORD *)(a1 + 184) = 0LL;
*(_QWORD *)(a1 + 200) = 0LL;
*(_QWORD *)(a1 + 208) = a5;
return result;
}
| common_arg:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R8
MOV R15,RCX
MOV R12,RDX
MOV RBP,RSI
MOV RBX,RDI
LEA RSI,[RSP + 0x4]
MOV dword ptr [RSI],0x0
LEA RCX,[RSP + 0x3]
LEA R8,[RSP + 0x2]
MOV EDX,0x1
CALL 0x00183f90
LEA RAX,[RBX + 0x38]
XOR ECX,ECX
MOV qword ptr [RBX + 0x40],RCX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOV qword ptr [RBX + 0x48],RAX
MOV qword ptr [RBX + 0x50],RAX
MOV qword ptr [RBX + 0x58],RCX
LEA R13,[RBX + 0x60]
MOV RSI,qword ptr [RBP]
MOV RDX,qword ptr [RBP + 0x8]
LAB_001649ac:
LEA RCX,[RSP + 0x1]
MOV RDI,R13
CALL 0x00184012
MOV qword ptr [RBX + 0x78],R12
LEA RDI,[RBX + 0x90]
LEA RAX,[RBX + 0xa0]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x80],XMM0
MOV qword ptr [RBX + 0x90],RAX
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
ADD RDX,RSI
LAB_001649e6:
CALL 0x0012875c
LAB_001649eb:
MOV byte ptr [RBX + 0xb0],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0xb8],XMM0
MOV qword ptr [RBX + 0xc8],0x0
MOV qword ptr [RBX + 0xd0],R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* common_arg::common_arg(std::initializer_list<char const*> const&, char const*,
std::__cxx11::string const&, void (*)(common_params&, int)) */
void __thiscall
common_arg::common_arg
(common_arg *this,initializer_list *param_1,char *param_2,string *param_3,
_func_void_common_params_ptr_int *param_4)
{
int4 in_EAX;
int8 in_R9;
std::set<llama_example,std::less<llama_example>,std::allocator<llama_example>>::set
(this,&stack0xffffffffffffffcc,1,&stack0xffffffffffffffcb,&stack0xffffffffffffffca,in_R9
,in_EAX);
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(common_arg **)(this + 0x48) = this + 0x38;
*(common_arg **)(this + 0x50) = this + 0x38;
*(int8 *)(this + 0x58) = 0;
/* try { // try from 001649ac to 001649b8 has its CatchHandler @ 00164a37 */
std::vector<char_const*,std::allocator<char_const*>>::vector
((vector<char_const*,std::allocator<char_const*>> *)(this + 0x60),*(int8 *)param_1
,*(int8 *)(param_1 + 8),&stack0xffffffffffffffc9);
*(char **)(this + 0x78) = param_2;
*(int8 *)(this + 0x80) = 0;
*(int8 *)(this + 0x88) = 0;
*(common_arg **)(this + 0x90) = this + 0xa0;
/* try { // try from 001649e6 to 001649ea has its CatchHandler @ 00164a1d */
std::__cxx11::string::_M_construct<char*>
(this + 0x90,*(long *)param_3,*(long *)(param_3 + 8) + *(long *)param_3);
this[0xb0] = (common_arg)0x0;
*(int8 *)(this + 0xb8) = 0;
*(int8 *)(this + 0xc0) = 0;
*(int8 *)(this + 200) = 0;
*(_func_void_common_params_ptr_int **)(this + 0xd0) = param_4;
return;
}
| |
38,630 | File::MoveWithOverwrite(std::filesystem::__cxx11::path const&, std::filesystem::__cxx11::path const&, std::error_code&) | Dolphin-anty/Source/Core/Common/FileUtil.cpp | static bool MoveWithOverwrite(const std::filesystem::path& src, const std::filesystem::path& dst,
std::error_code& error)
{
fs::rename(src, dst, error);
if (!error)
return true;
// rename failed, try fallbacks
if (!fs::is_directory(src))
{
// src is not a directory (ie, probably a file), try to copy file + delete
if (!fs::copy_file(src, dst, fs::copy_options::overwrite_existing, error))
return false;
if (!fs::remove(src, error))
return false;
return true;
}
// src is a directory, recurse into it and try to move all sub-elements one by one
// this usually happens because the target is a non-empty directory
for (fs::directory_iterator it(src, error); it != fs::directory_iterator(); it.increment(error))
{
if (error)
return false;
if (!MoveWithOverwrite(it->path(), dst / it->path().filename(), error))
return false;
}
if (error)
return false;
// all sub-elements moved, remove top directory
if (!fs::remove(src, error))
return false;
return true;
} | O3 | cpp | File::MoveWithOverwrite(std::filesystem::__cxx11::path const&, std::filesystem::__cxx11::path const&, std::error_code&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x78f0
cmpl $0x0, (%rbx)
je 0x1b5a2
movq %r14, %rdi
callq 0x7270
cmpb $0x2, %al
jne 0x1b5a9
movq %r15, (%rsp)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x70b0
movq 0x8(%r12), %rdi
testq %rdi, %rdi
je 0x1b65e
cmpl $0x0, (%rbx)
je 0x1b5dd
callq 0xe286
jmp 0x1b663
movb $0x1, %al
jmp 0x1b665
movq %r14, %rdi
movq %r15, %rsi
movl $0x2, %edx
movq %rbx, %rcx
callq 0x78b0
testb %al, %al
je 0x1b663
movq %r14, %rdi
movq %rbx, %rsi
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x74e0
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x76f0
movq %rax, %r12
movq %r13, %rdi
callq 0x76f0
leaq 0x18(%rsp), %rbp
movq %rbp, %rdi
movq %rax, %rsi
callq 0x1dc70
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq (%rsp), %rsi
movq %rbp, %rdx
callq 0x1de05
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1b53f
movl %eax, %r12d
movq %r15, %rdi
callq 0x1dbfc
movq %rbp, %rdi
callq 0x1dbfc
testb %r12b, %r12b
je 0x1b681
movq %r13, %rdi
movq %rbx, %rsi
callq 0x7540
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b65e
cmpl $0x0, (%rbx)
je 0x1b5e2
jmp 0x1b598
cmpl $0x0, (%rbx)
je 0x1b674
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x74e0
jmp 0x1b665
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
jne 0x1b598
jmp 0x1b663
| _ZN4FileL17MoveWithOverwriteERKNSt10filesystem7__cxx114pathES4_RSt10error_code:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov rbx, rdx
mov r15, rsi
mov r14, rdi
call __ZNSt10filesystem6renameERKNS_7__cxx114pathES3_RSt10error_code; std::filesystem::rename(std::filesystem::__cxx11::path const&,std::filesystem::__cxx11::path const&,std::error_code &)
cmp dword ptr [rbx], 0
jz short loc_1B5A2
mov rdi, r14; this
call __ZNSt10filesystem6statusERKNS_7__cxx114pathE; std::filesystem::status(std::filesystem::__cxx11::path const&)
cmp al, 2
jnz short loc_1B5A9
mov [rsp+98h+var_98], r15
lea r12, [rsp+98h+var_90]
mov rdi, r12
mov rsi, r14
xor edx, edx
mov rcx, rbx
call __ZNSt10filesystem7__cxx1118directory_iteratorC2ERKNS0_4pathENS_17directory_optionsEPSt10error_code; std::filesystem::__cxx11::directory_iterator::directory_iterator(std::filesystem::__cxx11::path const&,std::filesystem::directory_options,std::error_code *)
mov rdi, [r12+8]
test rdi, rdi
jz loc_1B65E
cmp dword ptr [rbx], 0
jz short loc_1B5DD
loc_1B598:
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
jmp loc_1B663
loc_1B5A2:
mov al, 1
jmp loc_1B665
loc_1B5A9:
mov rdi, r14
mov rsi, r15
mov edx, 2
mov rcx, rbx
call __ZNSt10filesystem9copy_fileERKNS_7__cxx114pathES3_NS_12copy_optionsERSt10error_code; std::filesystem::copy_file(std::filesystem::__cxx11::path const&,std::filesystem::__cxx11::path const&,std::filesystem::copy_options,std::error_code &)
test al, al
jz loc_1B663
mov rdi, r14
mov rsi, rbx
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp __ZNSt10filesystem6removeERKNS_7__cxx114pathERSt10error_code; std::filesystem::remove(std::filesystem::__cxx11::path const&,std::error_code &)
loc_1B5DD:
lea r13, [rsp+98h+var_90]
loc_1B5E2:
mov rdi, r13
call __ZNKSt10filesystem7__cxx1118directory_iteratordeEv; std::filesystem::__cxx11::directory_iterator::operator*(void)
mov r12, rax
mov rdi, r13
call __ZNKSt10filesystem7__cxx1118directory_iteratordeEv; std::filesystem::__cxx11::directory_iterator::operator*(void)
lea rbp, [rsp+98h+var_80]
mov rdi, rbp; this
mov rsi, rax
call _ZNKSt10filesystem7__cxx114path8filenameEv; std::filesystem::__cxx11::path::filename(void)
lea r15, [rsp+98h+var_58]
mov rdi, r15
mov rsi, [rsp+98h+var_98]
mov rdx, rbp
call _ZNSt10filesystem7__cxx11dvERKNS0_4pathES3_; std::filesystem::__cxx11::operator/(std::filesystem::__cxx11::path const&,std::filesystem::__cxx11::path const&)
mov rdi, r12
mov rsi, r15; std::filesystem::__cxx11::path *
mov rdx, rbx
call _ZN4FileL17MoveWithOverwriteERKNSt10filesystem7__cxx114pathES4_RSt10error_code; File::MoveWithOverwrite(std::filesystem::__cxx11::path const&,std::filesystem::__cxx11::path const&,std::error_code &)
mov r12d, eax
mov rdi, r15; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
mov rdi, rbp; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
test r12b, r12b
jz short loc_1B681
mov rdi, r13
mov rsi, rbx
call __ZNSt10filesystem7__cxx1118directory_iterator9incrementERSt10error_code; std::filesystem::__cxx11::directory_iterator::increment(std::error_code &)
mov rdi, [rsp+98h+var_88]
test rdi, rdi
jz short loc_1B65E
cmp dword ptr [rbx], 0
jz short loc_1B5E2
jmp loc_1B598
loc_1B65E:
cmp dword ptr [rbx], 0
jz short loc_1B674
loc_1B663:
xor eax, eax
loc_1B665:
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1B674:
mov rdi, r14
mov rsi, rbx
call __ZNSt10filesystem6removeERKNS_7__cxx114pathERSt10error_code; std::filesystem::remove(std::filesystem::__cxx11::path const&,std::error_code &)
jmp short loc_1B665
loc_1B681:
mov rdi, [rsp+98h+var_88]
test rdi, rdi
jnz loc_1B598
jmp short loc_1B663
| char File::MoveWithOverwrite(std::filesystem *a1, const std::filesystem::__cxx11::path *a2, _DWORD *a3)
{
volatile signed __int32 *v5; // rdi
long long v7; // r12
_BYTE v8[8]; // [rsp+8h] [rbp-90h] BYREF
volatile signed __int32 *v9; // [rsp+10h] [rbp-88h]
_BYTE v10[40]; // [rsp+18h] [rbp-80h] BYREF
_BYTE v11[88]; // [rsp+40h] [rbp-58h] BYREF
std::filesystem::rename(a1, a2, a3);
if ( !*a3 )
return 1;
if ( (unsigned __int8)std::filesystem::status(a1, a2) != 2 )
{
if ( (unsigned __int8)std::filesystem::copy_file(a1, a2, 2LL, a3) )
return std::filesystem::remove(a1, a3);
return 0;
}
std::filesystem::__cxx11::directory_iterator::directory_iterator(v8, a1, 0LL, a3);
v5 = v9;
if ( v9 )
{
if ( *a3 )
goto LABEL_5;
while ( 1 )
{
v7 = std::filesystem::__cxx11::directory_iterator::operator*(v8);
std::filesystem::__cxx11::directory_iterator::operator*(v8);
std::filesystem::__cxx11::path::filename((std::filesystem::__cxx11::path *)v10);
std::filesystem::__cxx11::operator/(v11, a2, v10);
LOBYTE(v7) = File::MoveWithOverwrite(v7, v11, a3);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)v11);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)v10);
if ( !(_BYTE)v7 )
break;
std::filesystem::__cxx11::directory_iterator::increment(v8, a3);
v5 = v9;
if ( !v9 )
goto LABEL_13;
if ( *a3 )
goto LABEL_5;
}
v5 = v9;
if ( v9 )
LABEL_5:
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v5);
return 0;
}
LABEL_13:
if ( *a3 )
return 0;
return std::filesystem::remove(a1, a3);
}
| MoveWithOverwrite:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV RBX,RDX
MOV R15,RSI
MOV R14,RDI
CALL 0x001078f0
CMP dword ptr [RBX],0x0
JZ 0x0011b5a2
MOV RDI,R14
CALL 0x00107270
CMP AL,0x2
JNZ 0x0011b5a9
MOV qword ptr [RSP],R15
LEA R12,[RSP + 0x8]
MOV RDI,R12
MOV RSI,R14
XOR EDX,EDX
MOV RCX,RBX
CALL 0x001070b0
MOV RDI,qword ptr [R12 + 0x8]
TEST RDI,RDI
JZ 0x0011b65e
CMP dword ptr [RBX],0x0
JZ 0x0011b5dd
LAB_0011b598:
CALL 0x0010e286
JMP 0x0011b663
LAB_0011b5a2:
MOV AL,0x1
JMP 0x0011b665
LAB_0011b5a9:
MOV RDI,R14
MOV RSI,R15
MOV EDX,0x2
MOV RCX,RBX
CALL 0x001078b0
TEST AL,AL
JZ 0x0011b663
MOV RDI,R14
MOV RSI,RBX
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001074e0
LAB_0011b5dd:
LEA R13,[RSP + 0x8]
LAB_0011b5e2:
MOV RDI,R13
CALL 0x001076f0
MOV R12,RAX
MOV RDI,R13
CALL 0x001076f0
LEA RBP,[RSP + 0x18]
MOV RDI,RBP
MOV RSI,RAX
CALL 0x0011dc70
LEA R15,[RSP + 0x40]
MOV RDI,R15
MOV RSI,qword ptr [RSP]
MOV RDX,RBP
CALL 0x0011de05
MOV RDI,R12
MOV RSI,R15
MOV RDX,RBX
CALL 0x0011b53f
MOV R12D,EAX
MOV RDI,R15
CALL 0x0011dbfc
MOV RDI,RBP
CALL 0x0011dbfc
TEST R12B,R12B
JZ 0x0011b681
MOV RDI,R13
MOV RSI,RBX
CALL 0x00107540
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x0011b65e
CMP dword ptr [RBX],0x0
JZ 0x0011b5e2
JMP 0x0011b598
LAB_0011b65e:
CMP dword ptr [RBX],0x0
JZ 0x0011b674
LAB_0011b663:
XOR EAX,EAX
LAB_0011b665:
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0011b674:
MOV RDI,R14
MOV RSI,RBX
CALL 0x001074e0
JMP 0x0011b665
LAB_0011b681:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JNZ 0x0011b598
JMP 0x0011b663
|
/* File::MoveWithOverwrite(std::filesystem::__cxx11::path const&, std::filesystem::__cxx11::path
const&, std::error_code&) */
int8 File::MoveWithOverwrite(path *param_1,path *param_2,error_code *param_3)
{
char cVar1;
path *ppVar2;
int8 uVar3;
directory_iterator local_90 [8];
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_88;
path local_80 [40];
__cxx11 local_58 [40];
std::filesystem::rename(param_1,param_2,param_3);
if (*(int *)param_3 == 0) {
uVar3 = 1;
}
else {
cVar1 = std::filesystem::status(param_1);
if (cVar1 == '\x02') {
std::filesystem::__cxx11::directory_iterator::directory_iterator(local_90,param_1,0,param_3);
if (local_88 == (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
LAB_0011b65e:
if (*(int *)param_3 == 0) {
uVar3 = std::filesystem::remove(param_1,param_3);
return uVar3;
}
}
else {
if (*(int *)param_3 == 0) {
do {
ppVar2 = (path *)std::filesystem::__cxx11::directory_iterator::operator*(local_90);
std::filesystem::__cxx11::directory_iterator::operator*(local_90);
std::filesystem::__cxx11::path::filename();
std::filesystem::__cxx11::operator/(local_58,param_2,local_80);
cVar1 = MoveWithOverwrite(ppVar2,(path *)local_58,param_3);
std::filesystem::__cxx11::path::~path((path *)local_58);
std::filesystem::__cxx11::path::~path(local_80);
if (cVar1 == '\0') {
if (local_88 == (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0)
goto LAB_0011b663;
break;
}
std::filesystem::__cxx11::directory_iterator::increment((error_code *)local_90);
if (local_88 == (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) goto LAB_0011b65e;
} while (*(int *)param_3 == 0);
}
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_88);
}
}
else {
cVar1 = std::filesystem::copy_file(param_1,param_2,2,param_3);
if (cVar1 != '\0') {
uVar3 = std::filesystem::remove(param_1,param_3);
return uVar3;
}
}
LAB_0011b663:
uVar3 = 0;
}
return uVar3;
}
| |
38,631 | mi_cmp_dynamic_unique | eloqsql/storage/myisam/mi_dynrec.c | int _mi_cmp_dynamic_unique(MI_INFO *info, MI_UNIQUEDEF *def,
const uchar *record, my_off_t pos)
{
uchar *rec_buff,*old_record;
int error;
DBUG_ENTER("_mi_cmp_dynamic_unique");
if (!(old_record=my_alloca(info->s->base.reclength)))
DBUG_RETURN(1);
/* Don't let the compare destroy blobs that may be in use */
rec_buff=info->rec_buff;
if (info->s->base.blobs)
info->rec_buff=0;
error=_mi_read_dynamic_record(info,pos,old_record);
if (!error)
error=mi_unique_comp(def, record, old_record, def->null_are_equal);
if (info->s->base.blobs)
{
my_free(mi_get_rec_buff_ptr(info, info->rec_buff));
info->rec_buff=rec_buff;
}
my_afree(old_record);
DBUG_RETURN(error);
} | O0 | c | mi_cmp_dynamic_unique:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x140(%rax), %rsi
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0xf4be0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0xacfd9
jmp 0xacfcd
movl $0x1, -0x4(%rbp)
jmp 0xad0be
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x188(%rax)
je 0xad007
movq -0x10(%rbp), %rax
movq $0x0, 0x120(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0xacb90
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jne 0xad03d
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x18(%rbp), %rax
movsbl 0x3(%rax), %ecx
callq 0xc6220
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x188(%rax)
je 0xad0af
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x318(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xad088
movq -0x10(%rbp), %rax
cmpq $0x0, 0x120(%rax)
je 0xad088
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rax
addq $-0x18, %rax
movq %rax, -0x48(%rbp)
jmp 0xad097
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0xf4f60
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x120(%rax)
movq -0x38(%rbp), %rdi
callq 0xf4f60
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _mi_cmp_dynamic_unique:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_10]
mov rax, [rax]
mov rsi, [rax+140h]
xor edi, edi
xor eax, eax
mov edx, eax
call my_malloc
mov [rbp+var_38], rax
cmp rax, 0
jnz short loc_ACFD9
jmp short $+2
loc_ACFCD:
mov [rbp+var_4], 1
jmp loc_AD0BE
loc_ACFD9:
mov rax, [rbp+var_10]
mov rax, [rax+120h]
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov rax, [rax]
cmp dword ptr [rax+188h], 0
jz short loc_AD007
mov rax, [rbp+var_10]
mov qword ptr [rax+120h], 0
loc_AD007:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_38]
call _mi_read_dynamic_record
mov [rbp+var_3C], eax
cmp [rbp+var_3C], 0
jnz short loc_AD03D
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_38]
mov rax, [rbp+var_18]
movsx ecx, byte ptr [rax+3]
call mi_unique_comp
mov [rbp+var_3C], eax
loc_AD03D:
mov rax, [rbp+var_10]
mov rax, [rax]
cmp dword ptr [rax+188h], 0
jz short loc_AD0AF
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+318h]
and rax, 1
cmp rax, 0
jz short loc_AD088
mov rax, [rbp+var_10]
cmp qword ptr [rax+120h], 0
jz short loc_AD088
mov rax, [rbp+var_10]
mov rax, [rax+120h]
add rax, 0FFFFFFFFFFFFFFE8h
mov [rbp+var_48], rax
jmp short loc_AD097
loc_AD088:
mov rax, [rbp+var_10]
mov rax, [rax+120h]
mov [rbp+var_48], rax
loc_AD097:
mov rdi, [rbp+var_48]
call my_free
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax+120h], rcx
loc_AD0AF:
mov rdi, [rbp+var_38]
call my_free
mov eax, [rbp+var_3C]
mov [rbp+var_4], eax
loc_AD0BE:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long mi_cmp_dynamic_unique(char *a1, long long a2, long long a3, const char *a4)
{
unsigned int dynamic_record; // [rsp+14h] [rbp-3Ch]
const char *v6; // [rsp+18h] [rbp-38h]
long long v7; // [rsp+20h] [rbp-30h]
v6 = (const char *)my_malloc(0LL, *(_QWORD *)(*(_QWORD *)a1 + 320LL), 0LL);
if ( v6 )
{
v7 = *((_QWORD *)a1 + 36);
if ( *(_DWORD *)(*(_QWORD *)a1 + 392LL) )
*((_QWORD *)a1 + 36) = 0LL;
dynamic_record = mi_read_dynamic_record(a1, a4, v6);
if ( !dynamic_record )
dynamic_record = mi_unique_comp(a2, a3, v6, (unsigned int)*(char *)(a2 + 3));
if ( *(_DWORD *)(*(_QWORD *)a1 + 392LL) )
{
if ( (*(_QWORD *)(*(_QWORD *)a1 + 792LL) & 1LL) != 0 && *((_QWORD *)a1 + 36) )
my_free(*((_QWORD *)a1 + 36) - 24LL);
else
my_free(*((_QWORD *)a1 + 36));
*((_QWORD *)a1 + 36) = v7;
}
my_free(v6);
return dynamic_record;
}
else
{
return 1;
}
}
| _mi_cmp_dynamic_unique:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x140]
XOR EDI,EDI
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001f4be0
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JNZ 0x001acfd9
JMP 0x001acfcd
LAB_001acfcd:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001ad0be
LAB_001acfd9:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x120]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX + 0x188],0x0
JZ 0x001ad007
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x120],0x0
LAB_001ad007:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x001acb90
MOV dword ptr [RBP + -0x3c],EAX
CMP dword ptr [RBP + -0x3c],0x0
JNZ 0x001ad03d
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x18]
MOVSX ECX,byte ptr [RAX + 0x3]
CALL 0x001c6220
MOV dword ptr [RBP + -0x3c],EAX
LAB_001ad03d:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX + 0x188],0x0
JZ 0x001ad0af
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x318]
AND RAX,0x1
CMP RAX,0x0
JZ 0x001ad088
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x120],0x0
JZ 0x001ad088
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x120]
ADD RAX,-0x18
MOV qword ptr [RBP + -0x48],RAX
JMP 0x001ad097
LAB_001ad088:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x120]
MOV qword ptr [RBP + -0x48],RAX
LAB_001ad097:
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x001f4f60
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x120],RCX
LAB_001ad0af:
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x001f4f60
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x4],EAX
LAB_001ad0be:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int _mi_cmp_dynamic_unique(long *param_1,long param_2,int8 param_3,int8 param_4)
{
long lVar1;
long lVar2;
long local_50;
int local_44;
int local_c;
lVar2 = my_malloc(0,*(int8 *)(*param_1 + 0x140),0);
if (lVar2 == 0) {
local_c = 1;
}
else {
lVar1 = param_1[0x24];
if (*(int *)(*param_1 + 0x188) != 0) {
param_1[0x24] = 0;
}
local_44 = _mi_read_dynamic_record(param_1,param_4,lVar2);
if (local_44 == 0) {
local_44 = mi_unique_comp(param_2,param_3,lVar2,(int)*(char *)(param_2 + 3));
}
if (*(int *)(*param_1 + 0x188) != 0) {
if (((*(ulong *)(*param_1 + 0x318) & 1) == 0) || (param_1[0x24] == 0)) {
local_50 = param_1[0x24];
}
else {
local_50 = param_1[0x24] + -0x18;
}
my_free(local_50);
param_1[0x24] = lVar1;
}
my_free(lVar2);
local_c = local_44;
}
return local_c;
}
| |
38,632 | Gcalc_scan_iterator::get_h() const | eloqsql/sql/gcalc_slicescan.cc | double Gcalc_scan_iterator::get_h() const
{
double cur_y= get_y();
double next_y;
if (state.pi->type == Gcalc_heap::nt_intersection)
{
double x;
state.pi->calc_xy(&x, &next_y);
}
else
next_y= state.pi->next ? state.pi->get_next()->node.shape.y : 0.0;
return next_y - cur_y;
} | O0 | cpp | Gcalc_scan_iterator::get_h() const:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xaaddc0
movq -0x28(%rbp), %rax
movsd %xmm0, -0x10(%rbp)
movq 0x68(%rax), %rax
cmpl $0x1, 0x8(%rax)
jne 0xaae133
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0xaab750
jmp 0xaae16e
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rax
cmpq $0x0, (%rax)
je 0xaae15a
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x984600
movsd 0x30(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0xaae164
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0xaae164
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
| _ZNK19Gcalc_scan_iterator5get_hEv:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]; this
mov [rbp+var_28], rdi
call _ZNK19Gcalc_scan_iterator5get_yEv; Gcalc_scan_iterator::get_y(void)
mov rax, [rbp+var_28]
movsd [rbp+var_10], xmm0
mov rax, [rax+68h]
cmp dword ptr [rax+8], 1
jnz short loc_AAE133
mov rax, [rbp+var_28]
mov rdi, [rax+68h]; this
lea rsi, [rbp+var_20]; double *
lea rdx, [rbp+var_18]; double *
call _ZNK10Gcalc_heap4Info7calc_xyEPdS1_; Gcalc_heap::Info::calc_xy(double *,double *)
jmp short loc_AAE16E
loc_AAE133:
mov rax, [rbp+var_28]
mov rax, [rax+68h]
cmp qword ptr [rax], 0
jz short loc_AAE15A
mov rax, [rbp+var_28]
mov rdi, [rax+68h]; this
call _ZNK10Gcalc_heap4Info8get_nextEv; Gcalc_heap::Info::get_next(void)
movsd xmm0, qword ptr [rax+30h]
movsd [rbp+var_30], xmm0
jmp short loc_AAE164
loc_AAE15A:
xorps xmm0, xmm0
movsd [rbp+var_30], xmm0
jmp short $+2
loc_AAE164:
movsd xmm0, [rbp+var_30]
movsd [rbp+var_18], xmm0
loc_AAE16E:
movsd xmm0, [rbp+var_18]
subsd xmm0, [rbp+var_10]
add rsp, 30h
pop rbp
retn
| double Gcalc_scan_iterator::get_h(Gcalc_heap::Info **this, double a2)
{
double v3; // [rsp+0h] [rbp-30h]
double v4; // [rsp+10h] [rbp-20h] BYREF
double v5; // [rsp+18h] [rbp-18h] BYREF
double y; // [rsp+20h] [rbp-10h]
Gcalc_scan_iterator *v7; // [rsp+28h] [rbp-8h]
v7 = (Gcalc_scan_iterator *)this;
y = Gcalc_scan_iterator::get_y((Gcalc_scan_iterator *)this, a2);
if ( *((_DWORD *)this[13] + 2) == 1 )
{
Gcalc_heap::Info::calc_xy(this[13], &v4, &v5);
}
else
{
if ( *(_QWORD *)this[13] )
v3 = *(double *)(Gcalc_heap::Info::get_next(this[13]) + 48);
else
v3 = 0.0;
v5 = v3;
}
return v5 - y;
}
| ~Item_subselect:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
UD2
|
/* Item_subselect::~Item_subselect() */
void __thiscall Item_subselect::~Item_subselect(Item_subselect *this)
{
code *pcVar1;
/* WARNING: Does not return */
pcVar1 = (code *)invalidInstructionException();
(*pcVar1)();
}
| |
38,633 | my_strndup | eloqsql/mysys/my_malloc.c | char *my_strndup(PSI_memory_key key, const char *from, size_t length, myf my_flags)
{
char *ptr;
DBUG_ENTER("my_strndup");
if ((ptr= (char*) my_malloc(key, length+1, my_flags)))
{
memcpy(ptr, from, length);
ptr[length]= 0;
}
DBUG_RETURN(ptr);
} | O3 | c | my_strndup:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x1(%rdx), %rsi
movq %rcx, %rdx
callq 0xc3acd
movq %rax, %r15
testq %rax, %rax
je 0xc3e1b
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2b0b0
movb $0x0, (%r15,%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
| my_strndup:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdx
mov r14, rsi
lea rsi, [rdx+1]
mov rdx, rcx
call my_malloc
mov r15, rax
test rax, rax
jz short loc_C3E1B
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call _memcpy
mov byte ptr [r15+rbx], 0
loc_C3E1B:
mov rax, r15
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long my_strndup(unsigned int a1, long long a2, long long a3, int a4)
{
long long v5; // rax
long long v6; // r15
v5 = my_malloc(a1, a3 + 1, a4);
v6 = v5;
if ( v5 )
{
memcpy(v5, a2, a3);
*(_BYTE *)(v6 + a3) = 0;
}
return v6;
}
| my_strndup:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
LEA RSI,[RDX + 0x1]
MOV RDX,RCX
CALL 0x001c3acd
MOV R15,RAX
TEST RAX,RAX
JZ 0x001c3e1b
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x0012b0b0
MOV byte ptr [R15 + RBX*0x1],0x0
LAB_001c3e1b:
MOV RAX,R15
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void * my_strndup(int8 param_1,void *param_2,size_t param_3,int8 param_4)
{
void *__dest;
__dest = (void *)my_malloc(param_1,param_3 + 1,param_4);
if (__dest != (void *)0x0) {
memcpy(__dest,param_2,param_3);
*(int1 *)((long)__dest + param_3) = 0;
}
return __dest;
}
| |
38,634 | mi_mmap_pwrite | eloqsql/storage/myisam/mi_dynrec.c | size_t mi_mmap_pwrite(MI_INFO *info, const uchar *Buffer,
size_t Count, my_off_t offset, myf MyFlags)
{
DBUG_PRINT("info", ("mi_write with mmap %d\n", info->dfile));
if (info->s->concurrent_insert)
mysql_rwlock_rdlock(&info->s->mmap_lock);
/*
The following test may fail in the following cases:
- We failed to remap a memory area (fragmented memory?)
- This thread has done some writes, but not yet extended the
memory mapped area.
*/
if (info->s->mmaped_length >= offset + Count)
{
memcpy(info->s->file_map + offset, Buffer, Count);
if (info->s->concurrent_insert)
mysql_rwlock_unlock(&info->s->mmap_lock);
return 0;
}
else
{
info->s->nonmmaped_inserts++;
if (info->s->concurrent_insert)
mysql_rwlock_unlock(&info->s->mmap_lock);
return mysql_file_pwrite(info->dfile, Buffer, Count, offset, MyFlags);
}
} | O3 | c | mi_mmap_pwrite:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
movq (%rdi), %rax
cmpb $0x0, 0x384(%rax)
je 0x76ae5
leaq 0x4e0(%rax), %rdi
cmpq $0x0, 0x570(%rax)
jne 0x76bc9
callq 0xa4358
movq (%r13), %rax
leaq (%r15,%rbx), %rcx
cmpq %rcx, 0x4d0(%rax)
jae 0x76b73
movq %r14, -0x30(%rbp)
incl 0x4d8(%rax)
movq (%r13), %r14
cmpb $0x0, 0x384(%r14)
je 0x76b2d
movq 0x570(%r14), %rdi
addq $0x4e0, %r14 # imm = 0x4E0
testq %rdi, %rdi
jne 0x76c50
movq %r14, %rdi
callq 0xa4486
movl 0x1c0(%r13), %r14d
leaq 0x30f4d5(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x78(%rbp), %rdi
movl %r14d, %esi
movl $0x7, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x76bdf
movl %r14d, %edi
movq %r12, %rsi
movq %rbx, %rdx
movq %r15, %rcx
movq -0x30(%rbp), %r8
callq 0xa078e
movq %rax, %r15
jmp 0x76bb7
addq 0x270(%rax), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x29080
movq (%r13), %rbx
cmpb $0x0, 0x384(%rbx)
je 0x76bb4
movq 0x570(%rbx), %rdi
addq $0x4e0, %rbx # imm = 0x4E0
testq %rdi, %rdi
jne 0x76c65
movq %rbx, %rdi
callq 0xa4486
xorl %r15d, %r15d
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x64e10(%rip), %rsi # 0xdb9e0
movl $0xe3, %edx
callq 0x2ec30
jmp 0x76ae5
movq %rax, %r13
leaq 0x30f427(%rip), %rax # 0x386010
movq (%rax), %rax
leaq 0x64ded(%rip), %rdx # 0xdb9e0
movq %r13, %rdi
movq %rbx, %rsi
movl $0xf8, %ecx
callq *0x210(%rax)
movl %r14d, %edi
movq %r12, %rsi
movq %rbx, %rdx
movq %r15, %rcx
movq -0x30(%rbp), %r14
movq %r14, %r8
callq 0xa078e
movq %rax, %r15
xorl %esi, %esi
testq %rax, %rax
cmovneq %rsi, %rbx
cmpq $-0x1, %rax
cmovneq %rax, %rsi
testb $0x6, %r14b
cmovneq %rbx, %rsi
leaq 0x30f3d1(%rip), %rax # 0x386010
movq (%rax), %rax
movq %r13, %rdi
callq *0x218(%rax)
jmp 0x76bb7
leaq 0x30f3b9(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x168(%rax)
jmp 0x76b25
leaq 0x30f3a4(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x168(%rax)
jmp 0x76bac
| mi_mmap_pwrite:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r14, r8
mov r15, rcx
mov rbx, rdx
mov r12, rsi
mov r13, rdi
mov rax, [rdi]
cmp byte ptr [rax+384h], 0
jz short loc_76AE5
lea rdi, [rax+4E0h]
cmp qword ptr [rax+570h], 0
jnz loc_76BC9
call my_rw_rdlock
loc_76AE5:
mov rax, [r13+0]
lea rcx, [r15+rbx]
cmp [rax+4D0h], rcx
jnb short loc_76B73
mov [rbp+var_30], r14
inc dword ptr [rax+4D8h]
mov r14, [r13+0]
cmp byte ptr [r14+384h], 0
jz short loc_76B2D
mov rdi, [r14+570h]
add r14, 4E0h
test rdi, rdi
jnz loc_76C50
loc_76B25:
mov rdi, r14
call my_rw_unlock
loc_76B2D:
mov r14d, [r13+1C0h]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_78]
mov esi, r14d
mov edx, 7
call qword ptr [rax+158h]
test rax, rax
jnz loc_76BDF
mov edi, r14d
mov rsi, r12
mov rdx, rbx
mov rcx, r15
mov r8, [rbp+var_30]
call my_pwrite
mov r15, rax
jmp short loc_76BB7
loc_76B73:
add r15, [rax+270h]
mov rdi, r15
mov rsi, r12
mov rdx, rbx
call _memcpy
mov rbx, [r13+0]
cmp byte ptr [rbx+384h], 0
jz short loc_76BB4
mov rdi, [rbx+570h]
add rbx, 4E0h
test rdi, rdi
jnz loc_76C65
loc_76BAC:
mov rdi, rbx
call my_rw_unlock
loc_76BB4:
xor r15d, r15d
loc_76BB7:
mov rax, r15
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_76BC9:
lea rsi, aWorkspaceLlm4b_12; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0E3h
call psi_rwlock_rdlock
jmp loc_76AE5
loc_76BDF:
mov r13, rax
lea rax, PSI_server
mov rax, [rax]
lea rdx, aWorkspaceLlm4b_12; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r13
mov rsi, rbx
mov ecx, 0F8h
call qword ptr [rax+210h]
mov edi, r14d
mov rsi, r12
mov rdx, rbx
mov rcx, r15
mov r14, [rbp+var_30]
mov r8, r14
call my_pwrite
mov r15, rax
xor esi, esi
test rax, rax
cmovnz rbx, rsi
cmp rax, 0FFFFFFFFFFFFFFFFh
cmovnz rsi, rax
test r14b, 6
cmovnz rsi, rbx
lea rax, PSI_server
mov rax, [rax]
mov rdi, r13
call qword ptr [rax+218h]
jmp loc_76BB7
loc_76C50:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+168h]
jmp loc_76B25
loc_76C65:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+168h]
jmp loc_76BAC
| long long mi_mmap_pwrite(_DWORD *a1, long long a2, long long a3, long long a4, long long a5)
{
long long v9; // rax
long long v10; // rdi
long long v11; // rax
long long v12; // r14
long long v13; // rdi
long long v14; // r14
unsigned int v15; // r14d
long long v16; // rax
long long v17; // r15
long long v18; // rbx
long long v19; // rdi
long long v20; // rbx
long long v22; // r13
_BYTE v23[72]; // [rsp+8h] [rbp-78h] BYREF
long long v24; // [rsp+50h] [rbp-30h]
v9 = *(_QWORD *)a1;
if ( *(_BYTE *)(*(_QWORD *)a1 + 900LL) )
{
v10 = v9 + 1248;
if ( *(_QWORD *)(v9 + 1392) )
psi_rwlock_rdlock(v10, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c", 0xE3u);
else
my_rw_rdlock(v10);
}
v11 = *(_QWORD *)a1;
if ( *(_QWORD *)(*(_QWORD *)a1 + 1232LL) >= (unsigned long long)(a4 + a3) )
{
memcpy(*(_QWORD *)(v11 + 624) + a4, a2, a3);
v18 = *(_QWORD *)a1;
if ( *(_BYTE *)(*(_QWORD *)a1 + 900LL) )
{
v19 = *(_QWORD *)(v18 + 1392);
v20 = v18 + 1248;
if ( v19 )
PSI_server[45]();
my_rw_unlock(v20);
}
return 0LL;
}
else
{
v24 = a5;
++*(_DWORD *)(v11 + 1240);
v12 = *(_QWORD *)a1;
if ( *(_BYTE *)(*(_QWORD *)a1 + 900LL) )
{
v13 = *(_QWORD *)(v12 + 1392);
v14 = v12 + 1248;
if ( v13 )
PSI_server[45]();
my_rw_unlock(v14);
}
v15 = a1[112];
v16 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v23, v15, 7LL);
if ( v16 )
{
v22 = v16;
((void ( *)(long long, long long, const char *, long long))PSI_server[66])(
v16,
a3,
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c",
248LL);
v17 = my_pwrite(v15, a2, a3, a4, v24);
((void ( *)(long long))PSI_server[67])(v22);
}
else
{
return my_pwrite(v15, a2, a3, a4, v24);
}
}
return v17;
}
| mi_mmap_pwrite:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R14,R8
MOV R15,RCX
MOV RBX,RDX
MOV R12,RSI
MOV R13,RDI
MOV RAX,qword ptr [RDI]
CMP byte ptr [RAX + 0x384],0x0
JZ 0x00176ae5
LEA RDI,[RAX + 0x4e0]
CMP qword ptr [RAX + 0x570],0x0
JNZ 0x00176bc9
CALL 0x001a4358
LAB_00176ae5:
MOV RAX,qword ptr [R13]
LEA RCX,[R15 + RBX*0x1]
CMP qword ptr [RAX + 0x4d0],RCX
JNC 0x00176b73
MOV qword ptr [RBP + -0x30],R14
INC dword ptr [RAX + 0x4d8]
MOV R14,qword ptr [R13]
CMP byte ptr [R14 + 0x384],0x0
JZ 0x00176b2d
MOV RDI,qword ptr [R14 + 0x570]
ADD R14,0x4e0
TEST RDI,RDI
JNZ 0x00176c50
LAB_00176b25:
MOV RDI,R14
CALL 0x001a4486
LAB_00176b2d:
MOV R14D,dword ptr [R13 + 0x1c0]
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x78]
MOV ESI,R14D
MOV EDX,0x7
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00176bdf
MOV EDI,R14D
MOV RSI,R12
MOV RDX,RBX
MOV RCX,R15
MOV R8,qword ptr [RBP + -0x30]
CALL 0x001a078e
MOV R15,RAX
JMP 0x00176bb7
LAB_00176b73:
ADD R15,qword ptr [RAX + 0x270]
MOV RDI,R15
MOV RSI,R12
MOV RDX,RBX
CALL 0x00129080
MOV RBX,qword ptr [R13]
CMP byte ptr [RBX + 0x384],0x0
JZ 0x00176bb4
MOV RDI,qword ptr [RBX + 0x570]
ADD RBX,0x4e0
TEST RDI,RDI
JNZ 0x00176c65
LAB_00176bac:
MOV RDI,RBX
CALL 0x001a4486
LAB_00176bb4:
XOR R15D,R15D
LAB_00176bb7:
MOV RAX,R15
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00176bc9:
LEA RSI,[0x1db9e0]
MOV EDX,0xe3
CALL 0x0012ec30
JMP 0x00176ae5
LAB_00176bdf:
MOV R13,RAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDX,[0x1db9e0]
MOV RDI,R13
MOV RSI,RBX
MOV ECX,0xf8
CALL qword ptr [RAX + 0x210]
MOV EDI,R14D
MOV RSI,R12
MOV RDX,RBX
MOV RCX,R15
MOV R14,qword ptr [RBP + -0x30]
MOV R8,R14
CALL 0x001a078e
MOV R15,RAX
XOR ESI,ESI
TEST RAX,RAX
CMOVNZ RBX,RSI
CMP RAX,-0x1
CMOVNZ RSI,RAX
TEST R14B,0x6
CMOVNZ RSI,RBX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
MOV RDI,R13
CALL qword ptr [RAX + 0x218]
JMP 0x00176bb7
LAB_00176c50:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x168]
JMP 0x00176b25
LAB_00176c65:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x168]
JMP 0x00176bac
|
size_t mi_mmap_pwrite(long *param_1,void *param_2,size_t param_3,long param_4,ulong param_5)
{
int4 uVar1;
ulong uVar2;
long lVar3;
size_t sVar4;
size_t sVar5;
int1 local_80 [72];
ulong local_38;
lVar3 = *param_1;
if (*(char *)(lVar3 + 900) != '\0') {
if (*(long *)(lVar3 + 0x570) == 0) {
my_rw_rdlock();
}
else {
psi_rwlock_rdlock(lVar3 + 0x4e0,
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c",0xe3);
}
}
lVar3 = *param_1;
if (*(ulong *)(lVar3 + 0x4d0) < param_4 + param_3) {
*(int *)(lVar3 + 0x4d8) = *(int *)(lVar3 + 0x4d8) + 1;
lVar3 = *param_1;
local_38 = param_5;
if (*(char *)(lVar3 + 900) != '\0') {
if (*(long *)(lVar3 + 0x570) != 0) {
(**(code **)(PSI_server + 0x168))();
}
my_rw_unlock(lVar3 + 0x4e0);
}
uVar1 = (int4)param_1[0x38];
lVar3 = (**(code **)(PSI_server + 0x158))(local_80,uVar1,7);
if (lVar3 == 0) {
sVar4 = my_pwrite(uVar1,param_2,param_3,param_4,local_38);
}
else {
(**(code **)(PSI_server + 0x210))
(lVar3,param_3,"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c"
,0xf8);
uVar2 = local_38;
sVar4 = my_pwrite(uVar1,param_2,param_3,param_4,local_38);
if (sVar4 != 0) {
param_3 = 0;
}
sVar5 = 0;
if (sVar4 != 0xffffffffffffffff) {
sVar5 = sVar4;
}
if ((uVar2 & 6) != 0) {
sVar5 = param_3;
}
(**(code **)(PSI_server + 0x218))(lVar3,sVar5);
}
}
else {
memcpy((void *)(param_4 + *(long *)(lVar3 + 0x270)),param_2,param_3);
lVar3 = *param_1;
if (*(char *)(lVar3 + 900) != '\0') {
if (*(long *)(lVar3 + 0x570) != 0) {
(**(code **)(PSI_server + 0x168))();
}
my_rw_unlock(lVar3 + 0x4e0);
}
sVar4 = 0;
}
return sVar4;
}
| |
38,635 | pvio_socket_write | eloqsql/libmariadb/plugins/pvio/pvio_socket.c | ssize_t pvio_socket_write(MARIADB_PVIO *pvio, const uchar *buffer, size_t length)
{
ssize_t r;
struct st_pvio_socket *csock;
int timeout;
int send_flags= MSG_DONTWAIT;
#ifdef MSG_NOSIGNAL
send_flags|= MSG_NOSIGNAL;
#endif
if (!pvio || !pvio->data)
return -1;
csock= (struct st_pvio_socket *)pvio->data;
timeout = pvio->timeout[PVIO_WRITE_TIMEOUT];
while ((r = ma_send(csock->socket, (void *)buffer, length,send_flags)) == -1)
{
int err = socket_errno;
if ((err != SOCKET_EAGAIN
#ifdef HAVE_SOCKET_EWOULDBLOCK
&& err != SOCKET_EWOULDBLOCK
#endif
)|| timeout == 0)
return r;
if (pvio_socket_wait_io_or_timeout(pvio, FALSE, timeout) < 1)
return -1;
}
return r;
} | O0 | c | pvio_socket_write:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x40, -0x38(%rbp)
movl -0x38(%rbp), %eax
orl $0x4000, %eax # imm = 0x4000
movl %eax, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5b927
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x5b931
movq $-0x1, -0x8(%rbp)
jmp 0x5b9ad
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x38(%rbp), %ecx
callq 0x5ce80
movq %rax, -0x28(%rbp)
cmpq $-0x1, %rax
jne 0x5b9a5
callq 0x14050
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
cmpl $0xb, -0x3c(%rbp)
jne 0x5b97c
cmpl $0x0, -0x34(%rbp)
jne 0x5b986
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5b9ad
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %edx
xorl %esi, %esi
callq 0x5ba50
cmpl $0x1, %eax
jge 0x5b9a3
movq $-0x1, -0x8(%rbp)
jmp 0x5b9ad
jmp 0x5b946
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| pvio_socket_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_38], 40h ; '@'
mov eax, [rbp+var_38]
or eax, 4000h
mov [rbp+var_38], eax
cmp [rbp+var_10], 0
jz short loc_5B927
mov rax, [rbp+var_10]
cmp qword ptr [rax], 0
jnz short loc_5B931
loc_5B927:
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
jmp short loc_5B9AD
loc_5B931:
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov eax, [rax+2Ch]
mov [rbp+var_34], eax
loc_5B946:
mov rax, [rbp+var_30]
mov edi, [rax]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov ecx, [rbp+var_38]
call ma_send
mov [rbp+var_28], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_5B9A5
call ___errno_location
mov eax, [rax]
mov [rbp+var_3C], eax
cmp [rbp+var_3C], 0Bh
jnz short loc_5B97C
cmp [rbp+var_34], 0
jnz short loc_5B986
loc_5B97C:
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
jmp short loc_5B9AD
loc_5B986:
mov rdi, [rbp+var_10]
mov edx, [rbp+var_34]
xor esi, esi
call pvio_socket_wait_io_or_timeout
cmp eax, 1
jge short loc_5B9A3
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
jmp short loc_5B9AD
loc_5B9A3:
jmp short loc_5B946
loc_5B9A5:
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
loc_5B9AD:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long pvio_socket_write(unsigned int **a1, long long a2, long long a3)
{
long long v3; // rdi
unsigned int v5; // [rsp+Ch] [rbp-34h]
unsigned int *v6; // [rsp+10h] [rbp-30h]
long long v7; // [rsp+18h] [rbp-28h]
if ( !a1 || !*a1 )
return -1LL;
v6 = *a1;
v5 = *((_DWORD *)a1 + 11);
while ( 1 )
{
v3 = *v6;
v7 = ma_send(v3, a2, a3, 16448LL);
if ( v7 != -1 )
break;
if ( *(_DWORD *)__errno_location(v3) != 11 || !v5 )
return -1LL;
if ( (int)pvio_socket_wait_io_or_timeout(a1, 0LL, v5) < 1 )
return -1LL;
}
return v7;
}
| pvio_socket_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 dword ptr [RBP + -0x38],0x40
MOV EAX,dword ptr [RBP + -0x38]
OR EAX,0x4000
MOV dword ptr [RBP + -0x38],EAX
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0015b927
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX],0x0
JNZ 0x0015b931
LAB_0015b927:
MOV qword ptr [RBP + -0x8],-0x1
JMP 0x0015b9ad
LAB_0015b931:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x2c]
MOV dword ptr [RBP + -0x34],EAX
LAB_0015b946:
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 + -0x38]
CALL 0x0015ce80
MOV qword ptr [RBP + -0x28],RAX
CMP RAX,-0x1
JNZ 0x0015b9a5
CALL 0x00114050
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x3c],EAX
CMP dword ptr [RBP + -0x3c],0xb
JNZ 0x0015b97c
CMP dword ptr [RBP + -0x34],0x0
JNZ 0x0015b986
LAB_0015b97c:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0015b9ad
LAB_0015b986:
MOV RDI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x34]
XOR ESI,ESI
CALL 0x0015ba50
CMP EAX,0x1
JGE 0x0015b9a3
MOV qword ptr [RBP + -0x8],-0x1
JMP 0x0015b9ad
LAB_0015b9a3:
JMP 0x0015b946
LAB_0015b9a5:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
LAB_0015b9ad:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
long pvio_socket_write(long *param_1,int8 param_2,int8 param_3)
{
int iVar1;
int4 *puVar2;
int iVar3;
long lVar4;
int *piVar5;
if ((param_1 != (long *)0x0) && (*param_1 != 0)) {
puVar2 = (int4 *)*param_1;
iVar1 = *(int *)((long)param_1 + 0x2c);
do {
lVar4 = ma_send(*puVar2,param_2,param_3,0x4040);
if (lVar4 != -1) {
return lVar4;
}
piVar5 = __errno_location();
if (*piVar5 != 0xb) {
return -1;
}
if (iVar1 == 0) {
return -1;
}
iVar3 = pvio_socket_wait_io_or_timeout(param_1,0,iVar1);
} while (0 < iVar3);
}
return -1;
}
| |
38,636 | pvio_socket_write | eloqsql/libmariadb/plugins/pvio/pvio_socket.c | ssize_t pvio_socket_write(MARIADB_PVIO *pvio, const uchar *buffer, size_t length)
{
ssize_t r;
struct st_pvio_socket *csock;
int timeout;
int send_flags= MSG_DONTWAIT;
#ifdef MSG_NOSIGNAL
send_flags|= MSG_NOSIGNAL;
#endif
if (!pvio || !pvio->data)
return -1;
csock= (struct st_pvio_socket *)pvio->data;
timeout = pvio->timeout[PVIO_WRITE_TIMEOUT];
while ((r = ma_send(csock->socket, (void *)buffer, length,send_flags)) == -1)
{
int err = socket_errno;
if ((err != SOCKET_EAGAIN
#ifdef HAVE_SOCKET_EWOULDBLOCK
&& err != SOCKET_EWOULDBLOCK
#endif
)|| timeout == 0)
return r;
if (pvio_socket_wait_io_or_timeout(pvio, FALSE, timeout) < 1)
return -1;
}
return r;
} | O3 | c | pvio_socket_write:
movq $-0x1, %rax
testq %rdi, %rdi
je 0x40169
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x4015b
movq %rdx, %r14
movq %rsi, %r15
movl 0x2c(%r12), %r13d
movl (%rbx), %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x40cd3
cmpq $-0x1, %rax
jne 0x4015b
callq 0x14060
cmpl $0xb, (%rax)
jne 0x40154
testl %r13d, %r13d
je 0x40154
movq %r12, %rdi
xorl %esi, %esi
movl %r13d, %edx
callq 0x4018c
testl %eax, %eax
jg 0x40121
movq $-0x1, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| pvio_socket_write:
mov rax, 0FFFFFFFFFFFFFFFFh
test rdi, rdi
jz short locret_40169
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12, rdi
mov rbx, [rdi]
test rbx, rbx
jz short loc_4015B
mov r14, rdx
mov r15, rsi
mov r13d, [r12+2Ch]
loc_40121:
mov edi, [rbx]
mov rsi, r15
mov rdx, r14
call ma_send
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_4015B
call ___errno_location
cmp dword ptr [rax], 0Bh
jnz short loc_40154
test r13d, r13d
jz short loc_40154
mov rdi, r12
xor esi, esi
mov edx, r13d
call pvio_socket_wait_io_or_timeout
test eax, eax
jg short loc_40121
loc_40154:
mov rax, 0FFFFFFFFFFFFFFFFh
loc_4015B:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
locret_40169:
retn
| long long pvio_socket_write(unsigned int **a1, long long a2, long long a3)
{
long long result; // rax
unsigned int *v5; // rbx
unsigned int v7; // r13d
long long v8; // rdi
result = -1LL;
if ( a1 )
{
v5 = *a1;
if ( *a1 )
{
v7 = *((_DWORD *)a1 + 11);
while ( 1 )
{
v8 = *v5;
result = ma_send(v8, a2, a3);
if ( result != -1 )
break;
if ( *(_DWORD *)__errno_location(v8) != 11 || !v7 || (int)pvio_socket_wait_io_or_timeout(a1, 0LL, v7) <= 0 )
return -1LL;
}
}
}
return result;
}
| pvio_socket_write:
MOV RAX,-0x1
TEST RDI,RDI
JZ 0x00140169
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12,RDI
MOV RBX,qword ptr [RDI]
TEST RBX,RBX
JZ 0x0014015b
MOV R14,RDX
MOV R15,RSI
MOV R13D,dword ptr [R12 + 0x2c]
LAB_00140121:
MOV EDI,dword ptr [RBX]
MOV RSI,R15
MOV RDX,R14
CALL 0x00140cd3
CMP RAX,-0x1
JNZ 0x0014015b
CALL 0x00114060
CMP dword ptr [RAX],0xb
JNZ 0x00140154
TEST R13D,R13D
JZ 0x00140154
MOV RDI,R12
XOR ESI,ESI
MOV EDX,R13D
CALL 0x0014018c
TEST EAX,EAX
JG 0x00140121
LAB_00140154:
MOV RAX,-0x1
LAB_0014015b:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
LAB_00140169:
RET
|
long pvio_socket_write(int8 *param_1,int8 param_2,int8 param_3)
{
int iVar1;
int4 *puVar2;
int iVar3;
long lVar4;
int *piVar5;
if ((param_1 != (int8 *)0x0) &&
(puVar2 = (int4 *)*param_1, puVar2 != (int4 *)0x0)) {
iVar1 = *(int *)((long)param_1 + 0x2c);
do {
lVar4 = ma_send(*puVar2,param_2,param_3);
if (lVar4 != -1) {
return lVar4;
}
piVar5 = __errno_location();
} while (((*piVar5 == 0xb) && (iVar1 != 0)) &&
(iVar3 = pvio_socket_wait_io_or_timeout(param_1,0,iVar1), 0 < iVar3));
}
return -1;
}
| |
38,637 | minja::Parser::parseExpression(bool) | monkey531[P]llama/common/minja.hpp | std::shared_ptr<Expression> parseExpression(bool allow_if_expr = true) {
auto left = parseLogicalOr();
if (it == end) return left;
if (!allow_if_expr) return left;
static std::regex if_tok(R"(if\b)");
if (consumeToken(if_tok).empty()) {
return left;
}
auto location = get_location();
auto [condition, else_expr] = parseIfExpression();
return std::make_shared<IfExpr>(location, std::move(condition), std::move(left), std::move(else_expr));
} | O1 | cpp | minja::Parser::parseExpression(bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x6aedc
movq 0x20(%r14), %rax
cmpq 0x18(%r14), %rax
je 0x69bfe
testb %bpl, %bpl
je 0x69bfe
leaq 0x863b0(%rip), %rax # 0xeff40
movb (%rax), %al
testb %al, %al
je 0x69cdb
leaq 0x8637f(%rip), %rdx # 0xeff20
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x69d80
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
movq -0x8(%rax), %r15
cmpq %rax, %rdi
je 0x69bd2
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x196b0
testq %r15, %r15
je 0x69bfe
movq (%r14), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x69c37
movq 0x8539c(%rip), %rcx # 0xeef90
cmpb $0x0, (%rcx)
je 0x69c33
incl 0x8(%rax)
jmp 0x69c37
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movaps (%rsp), %xmm0
movq %rax, 0x8(%rsp)
movups %xmm0, (%rbx)
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x69c23
callq 0x42d00
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
lock
incl 0x8(%rax)
movq 0x20(%r14), %rax
subq 0x10(%r14), %rax
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x6b16a
movl $0x60, %edi
callq 0x196a0
movq %rax, %r14
leaq 0x40(%rsp), %r8
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%r14)
leaq 0x83f70(%rip), %rax # 0xedbe8
addq $0x10, %rax
movq %rax, (%r14)
movq %r14, %r15
addq $0x10, %r15
leaq 0x18(%rsp), %rsi
leaq 0x30(%rsp), %r12
movq %rsp, %rcx
movq %r15, %rdi
movq %r12, %rdx
callq 0x7d226
movq %r15, (%rbx)
movq %r14, 0x8(%rbx)
movq 0x18(%r12), %rdi
testq %rdi, %rdi
je 0x69cb4
callq 0x42d00
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x69cc3
callq 0x42d00
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x69c14
callq 0x42d00
jmp 0x69c14
leaq 0x8625e(%rip), %rdi # 0xeff40
callq 0x19c30
testl %eax, %eax
je 0x69b9a
leaq 0x8622a(%rip), %rdi # 0xeff20
leaq 0x53f25(%rip), %rsi # 0xbdc22
movl $0x10, %edx
callq 0x36850
leaq -0x33456(%rip), %rdi # 0x368b8
leaq 0x8620b(%rip), %rsi # 0xeff20
leaq 0x859ac(%rip), %rdx # 0xef6c8
callq 0x195e0
leaq 0x86218(%rip), %rdi # 0xeff40
callq 0x19460
jmp 0x69b9a
movq %rax, %rbx
leaq 0x86204(%rip), %rdi # 0xeff40
callq 0x19450
jmp 0x69d69
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x6b372
jmp 0x69d55
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x69d69
callq 0x42d00
jmp 0x69d69
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x69d78
callq 0x42d00
movq %rbx, %rdi
callq 0x19be0
| _ZN5minja6Parser15parseExpressionEb:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 50h
mov ebp, edx
mov r14, rsi
mov rbx, rdi
mov rdi, rsp; this
call _ZN5minja6Parser14parseLogicalOrEv; minja::Parser::parseLogicalOr(void)
mov rax, [r14+20h]
cmp rax, [r14+18h]
jz short loc_69BFE
test bpl, bpl
jz short loc_69BFE
lea rax, _ZGVZN5minja6Parser15parseExpressionEbE6if_tokB5cxx11; `guard variable for'minja::Parser::parseExpression(bool)::if_tok
mov al, [rax]
test al, al
jz loc_69CDB
loc_69B9A:
lea rdx, _ZZN5minja6Parser15parseExpressionEbE6if_tokB5cxx11; minja::Parser::parseExpression(bool)::if_tok
lea rdi, [rsp+78h+var_48]
mov rsi, r14
mov ecx, 1
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
lea rax, [rsp+78h+var_38]
mov rdi, [rax-10h]; void *
mov r15, [rax-8]
cmp rdi, rax
jz short loc_69BD2
mov rsi, [rsp+78h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_69BD2:
test r15, r15
jz short loc_69BFE
mov rax, [r14]
mov [rsp+78h+var_60], rax
mov rax, [r14+8]
mov [rsp+78h+var_58], rax
test rax, rax
jz short loc_69C37
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_69C33
inc dword ptr [rax+8]
jmp short loc_69C37
loc_69BFE:
xor eax, eax
mov [rbx+8], rax
movaps xmm0, [rsp+78h+var_78]
mov qword ptr [rsp+78h+var_78+8], rax
movups xmmword ptr [rbx], xmm0
mov qword ptr [rsp+78h+var_78], rax
loc_69C14:
mov rdi, qword ptr [rsp+78h+var_78+8]
test rdi, rdi
jz short loc_69C23
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_69C23:
mov rax, rbx
add rsp, 50h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_69C33:
lock inc dword ptr [rax+8]
loc_69C37:
mov rax, [r14+20h]
sub rax, [r14+10h]
mov [rsp+78h+var_50], rax
lea rdi, [rsp+78h+var_48]; this
mov rsi, r14
call _ZN5minja6Parser17parseIfExpressionEv; minja::Parser::parseIfExpression(void)
mov edi, 60h ; '`'; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
lea r8, [rsp+78h+var_38]
mov rax, 100000001h
mov [r14+8], rax
lea rax, _ZTVSt23_Sp_counted_ptr_inplaceIN5minja6IfExprESaIS1_ELN9__gnu_cxx12_Lock_policyE2EE; `vtable for'std::_Sp_counted_ptr_inplace<minja::IfExpr,std::allocator<minja::IfExpr>,(__gnu_cxx::_Lock_policy)2>
add rax, 10h
mov [r14], rax
mov r15, r14
add r15, 10h
lea rsi, [rsp+78h+var_60]
lea r12, [rsp+78h+var_48]
mov rcx, rsp
mov rdi, r15
mov rdx, r12
call _ZN5minja6IfExprC2ERKNS_8LocationEOSt10shared_ptrINS_10ExpressionEES7_S7_; minja::IfExpr::IfExpr(minja::Location const&,std::shared_ptr<minja::Expression> &&,std::shared_ptr<minja::Expression> &,std::shared_ptr<minja::Expression> &)
mov [rbx], r15
mov [rbx+8], r14
mov rdi, [r12+18h]
test rdi, rdi
jz short loc_69CB4
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_69CB4:
mov rdi, [rsp+78h+var_40]
test rdi, rdi
jz short loc_69CC3
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_69CC3:
mov rdi, [rsp+78h+var_58]
test rdi, rdi
jz loc_69C14
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
jmp loc_69C14
loc_69CDB:
lea rdi, _ZGVZN5minja6Parser15parseExpressionEbE6if_tokB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_69B9A
lea rdi, _ZZN5minja6Parser15parseExpressionEbE6if_tokB5cxx11; minja::Parser::parseExpression(bool)::if_tok
lea rsi, aIfB; "if\\b"
mov edx, 10h
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser15parseExpressionEbE6if_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser15parseExpressionEbE6if_tokB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_69B9A
mov rbx, rax
lea rdi, _ZGVZN5minja6Parser15parseExpressionEbE6if_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_69D69
mov rbx, rax
lea rdi, [rsp+arg_28]
call _ZNSt4pairISt10shared_ptrIN5minja10ExpressionEES3_ED2Ev; std::pair<std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>>::~pair()
jmp short loc_69D55
mov rbx, rax
loc_69D55:
mov rdi, [rsp+arg_18]
test rdi, rdi
jz short loc_69D69
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
jmp short loc_69D69
mov rbx, rax
loc_69D69:
mov rdi, [rsp+arg_0]
test rdi, rdi
jz short loc_69D78
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_69D78:
mov rdi, rbx
call __Unwind_Resume
| minja::Parser * minja::Parser::parseExpression(minja::Parser *this, long long *a2, char a3)
{
int v4; // r8d
int v5; // r9d
volatile signed __int32 *v6; // r15
volatile signed __int32 *v7; // rax
__int128 v8; // xmm0
_QWORD *v10; // r14
__int128 v11; // [rsp+0h] [rbp-78h] BYREF
long long v12; // [rsp+18h] [rbp-60h] BYREF
volatile signed __int32 *v13; // [rsp+20h] [rbp-58h]
long long v14; // [rsp+28h] [rbp-50h]
long long *v15; // [rsp+30h] [rbp-48h] BYREF
volatile signed __int32 *v16; // [rsp+38h] [rbp-40h]
long long v17; // [rsp+40h] [rbp-38h] BYREF
volatile signed __int32 *v18; // [rsp+48h] [rbp-30h]
minja::Parser::parseLogicalOr((minja::Parser *)&v11);
if ( a2[4] == a2[3] || !a3 )
goto LABEL_10;
if ( !(_BYTE)`guard variable for'minja::Parser::parseExpression(bool)::if_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseExpression(bool)::if_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseExpression(bool)::if_tok[abi:cxx11],
(long long)"if\\b",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseExpression(bool)::if_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseExpression(bool)::if_tok[abi:cxx11]);
}
minja::Parser::consumeToken(
(unsigned int)&v15,
(_DWORD)a2,
(unsigned int)&minja::Parser::parseExpression(bool)::if_tok[abi:cxx11],
1,
v4,
v5,
v11,
*((long long *)&v11 + 1));
v6 = v16;
if ( v15 != &v17 )
operator delete(v15, v17 + 1);
if ( v6 )
{
v12 = *a2;
v7 = (volatile signed __int32 *)a2[1];
v13 = v7;
if ( v7 )
{
if ( _libc_single_threaded )
++*((_DWORD *)v7 + 2);
else
_InterlockedIncrement(v7 + 2);
}
v14 = a2[4] - a2[2];
minja::Parser::parseIfExpression((minja::Parser *)&v15);
v10 = (_QWORD *)operator new(0x60uLL);
v10[1] = 0x100000001LL;
*v10 = &`vtable for'std::_Sp_counted_ptr_inplace<minja::IfExpr,std::allocator<minja::IfExpr>,(__gnu_cxx::_Lock_policy)2>
+ 2;
minja::IfExpr::IfExpr(v10 + 2, &v12, &v15, &v11, &v17);
*(_QWORD *)this = v10 + 2;
*((_QWORD *)this + 1) = v10;
if ( v18 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v18);
if ( v16 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v16);
if ( v13 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v13);
}
else
{
LABEL_10:
*((_QWORD *)this + 1) = 0LL;
v8 = v11;
*((_QWORD *)&v11 + 1) = 0LL;
*(_OWORD *)this = v8;
*(_QWORD *)&v11 = 0LL;
}
if ( *((_QWORD *)&v11 + 1) )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(*((volatile signed __int32 **)&v11 + 1));
return this;
}
| parseExpression:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x50
MOV EBP,EDX
MOV R14,RSI
MOV RBX,RDI
MOV RDI,RSP
CALL 0x0016aedc
MOV RAX,qword ptr [R14 + 0x20]
CMP RAX,qword ptr [R14 + 0x18]
JZ 0x00169bfe
TEST BPL,BPL
JZ 0x00169bfe
LEA RAX,[0x1eff40]
MOV AL,byte ptr [RAX]
TEST AL,AL
JZ 0x00169cdb
LAB_00169b9a:
LEA RDX,[0x1eff20]
LEA RDI,[RSP + 0x30]
MOV RSI,R14
MOV ECX,0x1
CALL 0x00169d80
LEA RAX,[RSP + 0x40]
MOV RDI,qword ptr [RAX + -0x10]
MOV R15,qword ptr [RAX + -0x8]
CMP RDI,RAX
JZ 0x00169bd2
MOV RSI,qword ptr [RSP + 0x40]
INC RSI
CALL 0x001196b0
LAB_00169bd2:
TEST R15,R15
JZ 0x00169bfe
MOV RAX,qword ptr [R14]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [R14 + 0x8]
MOV qword ptr [RSP + 0x20],RAX
TEST RAX,RAX
JZ 0x00169c37
MOV RCX,qword ptr [0x001eef90]
CMP byte ptr [RCX],0x0
JZ 0x00169c33
INC dword ptr [RAX + 0x8]
JMP 0x00169c37
LAB_00169bfe:
XOR EAX,EAX
MOV qword ptr [RBX + 0x8],RAX
MOVAPS XMM0,xmmword ptr [RSP]
MOV qword ptr [RSP + 0x8],RAX
MOVUPS xmmword ptr [RBX],XMM0
MOV qword ptr [RSP],RAX
LAB_00169c14:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x00169c23
CALL 0x00142d00
LAB_00169c23:
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00169c33:
INC.LOCK dword ptr [RAX + 0x8]
LAB_00169c37:
MOV RAX,qword ptr [R14 + 0x20]
SUB RAX,qword ptr [R14 + 0x10]
MOV qword ptr [RSP + 0x28],RAX
LAB_00169c44:
LEA RDI,[RSP + 0x30]
MOV RSI,R14
CALL 0x0016b16a
LAB_00169c51:
MOV EDI,0x60
CALL 0x001196a0
MOV R14,RAX
LEA R8,[RSP + 0x40]
MOV RAX,0x100000001
MOV qword ptr [R14 + 0x8],RAX
LEA RAX,[0x1edbe8]
ADD RAX,0x10
MOV qword ptr [R14],RAX
MOV R15,R14
ADD R15,0x10
LEA RSI,[RSP + 0x18]
LEA R12,[RSP + 0x30]
MOV RCX,RSP
MOV RDI,R15
MOV RDX,R12
CALL 0x0017d226
MOV qword ptr [RBX],R15
MOV qword ptr [RBX + 0x8],R14
MOV RDI,qword ptr [R12 + 0x18]
TEST RDI,RDI
JZ 0x00169cb4
CALL 0x00142d00
LAB_00169cb4:
MOV RDI,qword ptr [RSP + 0x38]
TEST RDI,RDI
JZ 0x00169cc3
CALL 0x00142d00
LAB_00169cc3:
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x00169c14
CALL 0x00142d00
JMP 0x00169c14
LAB_00169cdb:
LEA RDI,[0x1eff40]
CALL 0x00119c30
TEST EAX,EAX
JZ 0x00169b9a
LAB_00169cef:
LEA RDI,[0x1eff20]
LEA RSI,[0x1bdc22]
MOV EDX,0x10
CALL 0x00136850
LAB_00169d07:
LEA RDI,[0x1368b8]
LEA RSI,[0x1eff20]
LEA RDX,[0x1ef6c8]
CALL 0x001195e0
LEA RDI,[0x1eff40]
CALL 0x00119460
JMP 0x00169b9a
|
/* minja::Parser::parseExpression(bool) */
int8 * minja::Parser::parseExpression(bool param_1)
{
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Var1;
int iVar2;
int8 *puVar3;
char in_DL;
int8 *in_RSI;
int7 in_register_00000039;
int8 *puVar4;
int8 local_78;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Stack_70;
int8 local_60;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_58;
long local_50;
long *local_48;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_40;
long local_38;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_30;
puVar4 = (int8 *)CONCAT71(in_register_00000039,param_1);
parseLogicalOr();
if ((in_RSI[4] != in_RSI[3]) && (in_DL != '\0')) {
if (parseExpression(bool)::if_tok_abi_cxx11_ == '\0') {
iVar2 = __cxa_guard_acquire(&parseExpression(bool)::if_tok_abi_cxx11_);
if (iVar2 != 0) {
/* try { // try from 00169cef to 00169d06 has its CatchHandler @ 00169d32 */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseExpression(bool)::if_tok_abi_cxx11_,&DAT_001bdc22,0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseExpression(bool)::if_tok_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseExpression(bool)::if_tok_abi_cxx11_);
}
}
/* try { // try from 00169b9a to 00169bb2 has its CatchHandler @ 00169d66 */
consumeToken(&local_48);
p_Var1 = local_40;
if (local_48 != &local_38) {
operator_delete(local_48,local_38 + 1);
}
if (p_Var1 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
local_60 = *in_RSI;
local_58 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)in_RSI[1];
if (local_58 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
if (*PTR___libc_single_threaded_001eef90 == '\0') {
LOCK();
*(int *)(local_58 + 8) = *(int *)(local_58 + 8) + 1;
UNLOCK();
}
else {
*(int *)(local_58 + 8) = *(int *)(local_58 + 8) + 1;
}
}
local_50 = in_RSI[4] - in_RSI[2];
/* try { // try from 00169c44 to 00169c50 has its CatchHandler @ 00169d52 */
parseIfExpression();
/* try { // try from 00169c51 to 00169c5a has its CatchHandler @ 00169d43 */
puVar3 = (int8 *)operator_new(0x60);
puVar3[1] = 0x100000001;
*puVar3 = &PTR___Sp_counted_ptr_inplace_001edbf8;
IfExpr::IfExpr((IfExpr *)(puVar3 + 2),(Location *)&local_60,(shared_ptr *)&local_48,
(shared_ptr *)&local_78,(shared_ptr *)&local_38);
*puVar4 = (IfExpr *)(puVar3 + 2);
puVar4[1] = puVar3;
if (local_30 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_30);
}
if (local_40 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_40);
}
if (local_58 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_58);
}
goto LAB_00169c14;
}
}
p_Var1 = p_Stack_70;
puVar4[1] = 0;
p_Stack_70 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0;
*puVar4 = local_78;
puVar4[1] = p_Var1;
local_78 = 0;
LAB_00169c14:
if (p_Stack_70 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Stack_70);
}
return puVar4;
}
| |
38,638 | blst_fp12_in_group | corpus-core[P]colibri-stateless/build_O0/_deps/blst-src/src/pairing.c | int blst_fp12_in_group(const vec384fp12 f)
{
vec384fp12 a, b;
if (vec_is_zero(f, sizeof(vec384fp12)) || !is_cyclotomic(f))
return 0;
frobenius_map_fp12(a, f, 1);
raise_to_z(b, f);
return (int)vec_is_equal(a, b, sizeof(a));
} | O0 | c | blst_fp12_in_group:
pushq %rbp
movq %rsp, %rbp
subq $0x490, %rsp # imm = 0x490
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x240, %esi # imm = 0x240
callq 0xa8cd0
cmpq $0x0, %rax
jne 0xb06a2
movq -0x10(%rbp), %rdi
callq 0xb0710
cmpq $0x0, %rax
jne 0xb06ab
movl $0x0, -0x4(%rbp)
jmp 0xb06fe
leaq -0x250(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0xaf410
leaq -0x490(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb0790
leaq -0x490(%rbp), %rdi
leaq -0x490(%rbp), %rsi
callq 0xaeb20
leaq -0x250(%rbp), %rdi
leaq -0x490(%rbp), %rsi
movl $0x240, %edx # imm = 0x240
callq 0xab4c0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x490, %rsp # imm = 0x490
popq %rbp
retq
nopw (%rax,%rax)
| blst_fp12_in_group:
push rbp
mov rbp, rsp
sub rsp, 490h
mov [rbp+var_10], rdi
mov rdi, [rbp+var_10]
mov esi, 240h
call vec_is_zero
cmp rax, 0
jnz short loc_B06A2
mov rdi, [rbp+var_10]
call is_cyclotomic
cmp rax, 0
jnz short loc_B06AB
loc_B06A2:
mov [rbp+var_4], 0
jmp short loc_B06FE
loc_B06AB:
lea rdi, [rbp+var_250]
mov rsi, [rbp+var_10]
mov edx, 1
call frobenius_map_fp12
lea rdi, [rbp+var_490]
mov rsi, [rbp+var_10]
call raise_to_z_div_by_2
lea rdi, [rbp+var_490]
lea rsi, [rbp+var_490]
call cyclotomic_sqr_fp12
lea rdi, [rbp+var_250]
lea rsi, [rbp+var_490]
mov edx, 240h
call vec_is_equal
mov [rbp+var_4], eax
loc_B06FE:
mov eax, [rbp+var_4]
add rsp, 490h
pop rbp
retn
| long long blst_fp12_in_group(long long a1)
{
_BYTE v2[576]; // [rsp+0h] [rbp-490h] BYREF
_BYTE v3[576]; // [rsp+240h] [rbp-250h] BYREF
long long v4; // [rsp+480h] [rbp-10h]
v4 = a1;
if ( !vec_is_zero(a1, 0x240uLL) && is_cyclotomic(v4) )
{
frobenius_map_fp12((long long)v3, v4, 1LL);
raise_to_z_div_by_2(v2, v4);
cyclotomic_sqr_fp12((long long)v2, (long long)v2);
return (unsigned int)vec_is_equal((long long)v3, (long long)v2, 0x240uLL);
}
else
{
return 0;
}
}
| blst_fp12_in_group:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x490
MOV qword ptr [RBP + -0x10],RDI
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x240
CALL 0x001a8cd0
CMP RAX,0x0
JNZ 0x001b06a2
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001b0710
CMP RAX,0x0
JNZ 0x001b06ab
LAB_001b06a2:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001b06fe
LAB_001b06ab:
LEA RDI,[RBP + -0x250]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,0x1
CALL 0x001af410
LEA RDI,[RBP + -0x490]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x001b0790
LEA RDI,[RBP + -0x490]
LEA RSI,[RBP + -0x490]
CALL 0x001aeb20
LEA RDI,[RBP + -0x250]
LEA RSI,[RBP + -0x490]
MOV EDX,0x240
CALL 0x001ab4c0
MOV dword ptr [RBP + -0x4],EAX
LAB_001b06fe:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x490
POP RBP
RET
|
int4 blst_fp12_in_group(int8 param_1)
{
int4 uVar1;
long lVar2;
int1 local_498 [576];
int1 local_258 [576];
int8 local_18;
local_18 = param_1;
lVar2 = vec_is_zero(param_1,0x240);
if ((lVar2 == 0) && (lVar2 = is_cyclotomic(local_18), lVar2 != 0)) {
frobenius_map_fp12(local_258,local_18,1);
raise_to_z_div_by_2(local_498,local_18);
cyclotomic_sqr_fp12(local_498,local_498);
uVar1 = vec_is_equal(local_258,local_498,0x240);
return uVar1;
}
return 0;
}
| |
38,639 | reinit_queue | eloqsql/mysys/queues.c | int reinit_queue(QUEUE *queue, uint max_elements, uint offset_to_key,
my_bool max_at_top, int (*compare) (void *, uchar *, uchar *),
void *first_cmp_arg, uint offset_to_queue_pos,
uint auto_extent)
{
DBUG_ENTER("reinit_queue");
queue->elements= 0;
queue->compare= compare;
queue->first_cmp_arg= first_cmp_arg;
queue->offset_to_key= offset_to_key;
queue->offset_to_queue_pos= offset_to_queue_pos;
queue->auto_extent= auto_extent;
queue_set_max_at_top(queue, max_at_top);
DBUG_RETURN(resize_queue(queue, max_elements));
} | O3 | c | reinit_queue:
pushq %rbp
movq %rsp, %rbp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %r10d
movl $0x0, 0x10(%rdi)
movq %r8, 0x28(%rdi)
movq %r9, 0x8(%rdi)
movl %edx, 0x18(%rdi)
movl %r10d, 0x1c(%rdi)
movl %eax, 0x20(%rdi)
xorl %eax, %eax
negb %cl
sbbl %eax, %eax
orl $0x1, %eax
movl %eax, 0x24(%rdi)
popq %rbp
jmp 0xa211d
| reinit_queue:
push rbp
mov rbp, rsp
mov eax, [rbp+arg_8]
mov r10d, [rbp+arg_0]
mov dword ptr [rdi+10h], 0
mov [rdi+28h], r8
mov [rdi+8], r9
mov [rdi+18h], edx
mov [rdi+1Ch], r10d
mov [rdi+20h], eax
xor eax, eax
neg cl
sbb eax, eax
or eax, 1
mov [rdi+24h], eax
pop rbp
jmp $+5
| long long reinit_queue(long long a1, long long a2, long long a3, long long a4, long long a5, long long a6, int a7, int a8)
{
*(_DWORD *)(a1 + 16) = 0;
*(_QWORD *)(a1 + 40) = a5;
*(_QWORD *)(a1 + 8) = a6;
*(_DWORD *)(a1 + 24) = a3;
*(_DWORD *)(a1 + 28) = a7;
*(_DWORD *)(a1 + 32) = a8;
LOBYTE(a4) = -(char)a4;
*(_DWORD *)(a1 + 36) = (_BYTE)a4 != 0 ? -1 : 1;
return resize_queue(a1, a2, a3, a4);
}
| reinit_queue:
PUSH RBP
MOV RBP,RSP
MOV EAX,dword ptr [RBP + 0x18]
MOV R10D,dword ptr [RBP + 0x10]
MOV dword ptr [RDI + 0x10],0x0
MOV qword ptr [RDI + 0x28],R8
MOV qword ptr [RDI + 0x8],R9
MOV dword ptr [RDI + 0x18],EDX
MOV dword ptr [RDI + 0x1c],R10D
MOV dword ptr [RDI + 0x20],EAX
XOR EAX,EAX
NEG CL
SBB EAX,EAX
OR EAX,0x1
MOV dword ptr [RDI + 0x24],EAX
POP RBP
JMP 0x001a211d
|
void reinit_queue(long param_1,int8 param_2,int4 param_3,char param_4,int8 param_5
,int8 param_6,int4 param_7,int4 param_8)
{
*(int4 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x28) = param_5;
*(int8 *)(param_1 + 8) = param_6;
*(int4 *)(param_1 + 0x18) = param_3;
*(int4 *)(param_1 + 0x1c) = param_7;
*(int4 *)(param_1 + 0x20) = param_8;
*(uint *)(param_1 + 0x24) = -(uint)(param_4 != '\0') | 1;
resize_queue();
return;
}
| |
38,640 | parse_connection_string | eloqsql/libmariadb/libmariadb/mariadb_lib.c | static int parse_connection_string(MYSQL *mysql, const char *unused __attribute__((unused)),
const char *conn_str, ssize_t len)
{
char *conn_save,
*end, *pos,
*key= NULL, *val= NULL;
my_bool in_curly_brace= 0;
if (len == -1)
len= strlen(conn_str);
/* don't modify original dsn */
conn_save= (char *)malloc(len + 1);
memcpy(conn_save, conn_str, len);
conn_save[len]= 0;
/* start and end */
pos= conn_save;
end= conn_save + len;
while (pos <= end)
{
/* ignore white space, unless it is between curly braces */
if (isspace(*pos) && !in_curly_brace)
{
pos++;
continue;
}
switch (*pos) {
case '{':
if (!key)
goto error;
if (!in_curly_brace)
{
in_curly_brace= 1;
if (pos < end)
{
pos++;
val= pos;
continue;
}
}
break;
case '}':
if (in_curly_brace)
{
if (!key)
goto error;
if (pos < end && *(pos + 1) == '}')
{
memmove(pos, pos + 1, end - pos - 1);
end--;
pos += 2;
continue;
}
if (in_curly_brace)
in_curly_brace= 0;
else
goto error;
*pos++= 0;
continue;
}
break;
case '=':
if (in_curly_brace)
{
pos++;
continue;
}
if (!key)
goto error;
*pos++= 0;
if (pos < end)
val= pos;
continue;
break;
case ';':
if (in_curly_brace)
{
pos++;
continue;
}
if (!key)
goto error;
*pos++= 0;
if (key && strcasecmp(key, "connection") != 0)
_mariadb_set_conf_option(mysql, key, val);
key= val= NULL;
continue;
break;
}
if (!key && *pos)
key= pos;
pos++;
}
if (key && strcasecmp(key, "connection") != 0)
_mariadb_set_conf_option(mysql, key, val);
free(conn_save);
return 0;
error:
my_set_error(mysql, CR_CONNSTR_PARSE_ERROR, SQLSTATE_UNKNOWN, 0, pos - conn_save);
free(conn_save);
return 1;
} | O3 | c | parse_connection_string:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
cmpq $-0x1, %rcx
jne 0x16239
movq %r14, %rdi
callq 0x131c0
movq %rax, %r15
leaq 0x1(%r15), %rdi
callq 0x13600
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x13390
movb $0x0, (%r12,%r15)
testq %r15, %r15
js 0x163f4
movq %rbx, -0x38(%rbp)
addq %r12, %r15
xorl %ebx, %ebx
callq 0x134c0
movq %rax, %r14
xorl %esi, %esi
xorl %r13d, %r13d
movq %r12, -0x30(%rbp)
movq (%r14), %rcx
movsbq (%r12), %rax
testb $0x20, 0x1(%rcx,%rax,2)
sete %cl
testb %bl, %bl
setne %dl
orb %cl, %dl
je 0x1635e
movzbl %al, %eax
cmpl $0x7a, %eax
jg 0x162cf
cmpl $0x3b, %eax
je 0x16308
cmpl $0x3d, %eax
jne 0x163a4
testb %bl, %bl
jne 0x1630c
testq %r13, %r13
je 0x163ff
movb $0x0, (%r12)
incq %r12
cmpq %r15, %r12
cmovbq %r12, %rsi
jmp 0x16361
cmpl $0x7d, %eax
je 0x16316
cmpl $0x7b, %eax
jne 0x163a4
testq %r13, %r13
je 0x163ff
testb %bl, %bl
setne %al
cmpq %r15, %r12
setae %cl
orb %al, %cl
movb $0x1, %bl
jne 0x163b5
incq %r12
movb $0x1, %bl
movq %r12, %rsi
jmp 0x163b8
testb %bl, %bl
je 0x16365
incq %r12
movb $0x1, %bl
jmp 0x163b8
testb %bl, %bl
je 0x163a2
testq %r13, %r13
je 0x163ff
cmpq %r15, %r12
jae 0x16359
cmpb $0x7d, 0x1(%r12)
jne 0x16359
movq %rsi, %rbx
leaq 0x1(%r12), %rsi
movq %r12, %rdx
notq %rdx
addq %r15, %rdx
movq %r12, %rdi
callq 0x13720
movq %rbx, %rsi
decq %r15
addq $0x2, %r12
jmp 0x1630f
movb $0x0, (%r12)
incq %r12
xorl %ebx, %ebx
jmp 0x163b8
testq %r13, %r13
je 0x163ff
movq %rsi, %rbx
movb $0x0, (%r12)
incq %r12
movq %r13, %rdi
leaq 0x1e680(%rip), %rsi # 0x34a03
callq 0x134d0
testl %eax, %eax
je 0x1639b
movq -0x38(%rbp), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x16448
xorl %r13d, %r13d
xorl %esi, %esi
jmp 0x16361
xorl %ebx, %ebx
testq %r13, %r13
jne 0x163b5
testl %eax, %eax
je 0x163b2
movq %r12, %r13
jmp 0x163b5
xorl %r13d, %r13d
incq %r12
cmpq %r15, %r12
jbe 0x1627b
xorl %r14d, %r14d
testq %r13, %r13
je 0x163f9
movq %rsi, %rbx
leaq 0x1e630(%rip), %rsi # 0x34a03
movq %r13, %rdi
callq 0x134d0
testl %eax, %eax
movq -0x30(%rbp), %r12
je 0x1642e
movq -0x38(%rbp), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x16448
jmp 0x1642e
xorl %r14d, %r14d
jmp 0x1642e
movq -0x30(%rbp), %r12
jmp 0x1642e
leaq 0x3262a(%rip), %rax # 0x48a30
movq (%rax), %rdx
movq -0x30(%rbp), %rax
subq %rax, %r12
movq -0x38(%rbp), %rdi
movl $0x1393, %esi # imm = 0x1393
xorl %ecx, %ecx
movq %r12, %r8
movq %rax, %r12
xorl %eax, %eax
callq 0x1577d
movl $0x1, %r14d
movq %r12, %rdi
callq 0x13570
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| parse_connection_string:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15, rcx
mov r14, rdx
mov rbx, rdi
cmp rcx, 0FFFFFFFFFFFFFFFFh
jnz short loc_16239
mov rdi, r14
call _strlen
mov r15, rax
loc_16239:
lea rdi, [r15+1]
call _malloc
mov r12, rax
mov rdi, rax
mov rsi, r14
mov rdx, r15
call _memcpy
mov byte ptr [r12+r15], 0
test r15, r15
js loc_163F4
mov [rbp+var_38], rbx
add r15, r12
xor ebx, ebx
call ___ctype_b_loc
mov r14, rax
xor esi, esi
xor r13d, r13d
mov [rbp+var_30], r12
loc_1627B:
mov rcx, [r14]
movsx rax, byte ptr [r12]
test byte ptr [rcx+rax*2+1], 20h
setz cl
test bl, bl
setnz dl
or dl, cl
jz loc_1635E
movzx eax, al
cmp eax, 7Ah ; 'z'
jg short loc_162CF
cmp eax, 3Bh ; ';'
jz short loc_16308
cmp eax, 3Dh ; '='
jnz loc_163A4
test bl, bl
jnz short loc_1630C
test r13, r13
jz loc_163FF
mov byte ptr [r12], 0
inc r12
cmp r12, r15
cmovb rsi, r12
jmp loc_16361
loc_162CF:
cmp eax, 7Dh ; '}'
jz short loc_16316
cmp eax, 7Bh ; '{'
jnz loc_163A4
test r13, r13
jz loc_163FF
test bl, bl
setnz al
cmp r12, r15
setnb cl
or cl, al
mov bl, 1
jnz loc_163B5
inc r12
mov bl, 1
mov rsi, r12
jmp loc_163B8
loc_16308:
test bl, bl
jz short loc_16365
loc_1630C:
inc r12
loc_1630F:
mov bl, 1
jmp loc_163B8
loc_16316:
test bl, bl
jz loc_163A2
test r13, r13
jz loc_163FF
cmp r12, r15
jnb short loc_16359
cmp byte ptr [r12+1], 7Dh ; '}'
jnz short loc_16359
mov rbx, rsi
lea rsi, [r12+1]
mov rdx, r12
not rdx
add rdx, r15
mov rdi, r12
call _memmove
mov rsi, rbx
dec r15
add r12, 2
jmp short loc_1630F
loc_16359:
mov byte ptr [r12], 0
loc_1635E:
inc r12
loc_16361:
xor ebx, ebx
jmp short loc_163B8
loc_16365:
test r13, r13
jz loc_163FF
mov rbx, rsi
mov byte ptr [r12], 0
inc r12
mov rdi, r13
lea rsi, aConnection; "connection"
call _strcasecmp
test eax, eax
jz short loc_1639B
mov rdi, [rbp+var_38]
mov rsi, r13
mov rdx, rbx
call _mariadb_set_conf_option
loc_1639B:
xor r13d, r13d
xor esi, esi
jmp short loc_16361
loc_163A2:
xor ebx, ebx
loc_163A4:
test r13, r13
jnz short loc_163B5
test eax, eax
jz short loc_163B2
mov r13, r12
jmp short loc_163B5
loc_163B2:
xor r13d, r13d
loc_163B5:
inc r12
loc_163B8:
cmp r12, r15
jbe loc_1627B
xor r14d, r14d
test r13, r13
jz short loc_163F9
mov rbx, rsi
lea rsi, aConnection; "connection"
mov rdi, r13
call _strcasecmp
test eax, eax
mov r12, [rbp+var_30]
jz short loc_1642E
mov rdi, [rbp+var_38]
mov rsi, r13
mov rdx, rbx
call _mariadb_set_conf_option
jmp short loc_1642E
loc_163F4:
xor r14d, r14d
jmp short loc_1642E
loc_163F9:
mov r12, [rbp+var_30]
jmp short loc_1642E
loc_163FF:
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov rax, [rbp+var_30]
sub r12, rax
mov rdi, [rbp+var_38]
mov esi, 1393h
xor ecx, ecx
mov r8, r12
mov r12, rax
xor eax, eax
call my_set_error
mov r14d, 1
loc_1642E:
mov rdi, r12
call _free
mov eax, r14d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long parse_connection_string(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // r15
unsigned long long v6; // r12
unsigned long long v7; // r15
char v8; // bl
_QWORD *v9; // r14
unsigned long long v10; // rsi
unsigned long long v11; // r13
long long v12; // rax
bool v13; // zf
unsigned int v14; // r14d
unsigned long long v15; // r8
unsigned long long v17; // [rsp+10h] [rbp-30h]
v4 = a4;
if ( a4 == -1 )
v4 = strlen(a3);
v6 = malloc(v4 + 1);
memcpy(v6, a3, v4);
*(_BYTE *)(v6 + v4) = 0;
if ( v4 < 0 )
{
v14 = 0;
goto LABEL_47;
}
v7 = v6 + v4;
v8 = 0;
v9 = (_QWORD *)__ctype_b_loc();
v10 = 0LL;
v11 = 0LL;
v17 = v6;
do
{
v12 = *(char *)v6;
if ( (*(_BYTE *)(*v9 + 2 * v12 + 1) & 0x20) != 0 && v8 == 0 )
goto LABEL_28;
if ( (unsigned __int8)v12 > 0x7Au )
{
if ( (unsigned __int8)v12 == 125 )
{
if ( v8 )
{
if ( !v11 )
goto LABEL_46;
if ( v6 < v7 && *(_BYTE *)(v6 + 1) == 125 )
{
memmove(v6, v6 + 1, v7 + ~v6);
--v7;
v6 += 2LL;
goto LABEL_21;
}
*(_BYTE *)v6 = 0;
LABEL_28:
++v6;
LABEL_29:
v8 = 0;
continue;
}
v8 = 0;
}
else if ( (unsigned __int8)v12 == 123 )
{
if ( !v11 )
goto LABEL_46;
v13 = v8 == 0 && v6 < v7;
v8 = 1;
if ( v13 )
{
++v6;
v8 = 1;
v10 = v6;
continue;
}
goto LABEL_39;
}
}
else
{
if ( (unsigned __int8)v12 == 59 )
{
if ( v8 )
{
LABEL_20:
++v6;
LABEL_21:
v8 = 1;
continue;
}
if ( !v11 )
{
LABEL_46:
v15 = v6 - v17;
v6 = v17;
my_set_error(a1, 5011, (long long)SQLSTATE_UNKNOWN, 0LL, v15);
v14 = 1;
goto LABEL_47;
}
*(_BYTE *)v6++ = 0;
if ( (unsigned int)strcasecmp(v11, "connection") )
mariadb_set_conf_option(a1, v11, v10);
v11 = 0LL;
v10 = 0LL;
goto LABEL_29;
}
if ( (unsigned __int8)v12 == 61 )
{
if ( v8 )
goto LABEL_20;
if ( !v11 )
goto LABEL_46;
*(_BYTE *)v6++ = 0;
if ( v6 < v7 )
v10 = v6;
goto LABEL_29;
}
}
if ( !v11 )
{
if ( (_BYTE)v12 )
v11 = v6;
else
v11 = 0LL;
}
LABEL_39:
++v6;
}
while ( v6 <= v7 );
v14 = 0;
if ( v11 )
{
v6 = v17;
if ( (unsigned int)strcasecmp(v11, "connection") )
mariadb_set_conf_option(a1, v11, v10);
}
else
{
v6 = v17;
}
LABEL_47:
free(v6);
return v14;
}
| parse_connection_string:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15,RCX
MOV R14,RDX
MOV RBX,RDI
CMP RCX,-0x1
JNZ 0x00116239
MOV RDI,R14
CALL 0x001131c0
MOV R15,RAX
LAB_00116239:
LEA RDI,[R15 + 0x1]
CALL 0x00113600
MOV R12,RAX
MOV RDI,RAX
MOV RSI,R14
MOV RDX,R15
CALL 0x00113390
MOV byte ptr [R12 + R15*0x1],0x0
TEST R15,R15
JS 0x001163f4
MOV qword ptr [RBP + -0x38],RBX
ADD R15,R12
XOR EBX,EBX
CALL 0x001134c0
MOV R14,RAX
XOR ESI,ESI
XOR R13D,R13D
MOV qword ptr [RBP + -0x30],R12
LAB_0011627b:
MOV RCX,qword ptr [R14]
MOVSX RAX,byte ptr [R12]
TEST byte ptr [RCX + RAX*0x2 + 0x1],0x20
SETZ CL
TEST BL,BL
SETNZ DL
OR DL,CL
JZ 0x0011635e
MOVZX EAX,AL
CMP EAX,0x7a
JG 0x001162cf
CMP EAX,0x3b
JZ 0x00116308
CMP EAX,0x3d
JNZ 0x001163a4
TEST BL,BL
JNZ 0x0011630c
TEST R13,R13
JZ 0x001163ff
MOV byte ptr [R12],0x0
INC R12
CMP R12,R15
CMOVC RSI,R12
JMP 0x00116361
LAB_001162cf:
CMP EAX,0x7d
JZ 0x00116316
CMP EAX,0x7b
JNZ 0x001163a4
TEST R13,R13
JZ 0x001163ff
TEST BL,BL
SETNZ AL
CMP R12,R15
SETNC CL
OR CL,AL
MOV BL,0x1
JNZ 0x001163b5
INC R12
MOV BL,0x1
MOV RSI,R12
JMP 0x001163b8
LAB_00116308:
TEST BL,BL
JZ 0x00116365
LAB_0011630c:
INC R12
LAB_0011630f:
MOV BL,0x1
JMP 0x001163b8
LAB_00116316:
TEST BL,BL
JZ 0x001163a2
TEST R13,R13
JZ 0x001163ff
CMP R12,R15
JNC 0x00116359
CMP byte ptr [R12 + 0x1],0x7d
JNZ 0x00116359
MOV RBX,RSI
LEA RSI,[R12 + 0x1]
MOV RDX,R12
NOT RDX
ADD RDX,R15
MOV RDI,R12
CALL 0x00113720
MOV RSI,RBX
DEC R15
ADD R12,0x2
JMP 0x0011630f
LAB_00116359:
MOV byte ptr [R12],0x0
LAB_0011635e:
INC R12
LAB_00116361:
XOR EBX,EBX
JMP 0x001163b8
LAB_00116365:
TEST R13,R13
JZ 0x001163ff
MOV RBX,RSI
MOV byte ptr [R12],0x0
INC R12
MOV RDI,R13
LEA RSI,[0x134a03]
CALL 0x001134d0
TEST EAX,EAX
JZ 0x0011639b
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,R13
MOV RDX,RBX
CALL 0x00116448
LAB_0011639b:
XOR R13D,R13D
XOR ESI,ESI
JMP 0x00116361
LAB_001163a2:
XOR EBX,EBX
LAB_001163a4:
TEST R13,R13
JNZ 0x001163b5
TEST EAX,EAX
JZ 0x001163b2
MOV R13,R12
JMP 0x001163b5
LAB_001163b2:
XOR R13D,R13D
LAB_001163b5:
INC R12
LAB_001163b8:
CMP R12,R15
JBE 0x0011627b
XOR R14D,R14D
TEST R13,R13
JZ 0x001163f9
MOV RBX,RSI
LEA RSI,[0x134a03]
MOV RDI,R13
CALL 0x001134d0
TEST EAX,EAX
MOV R12,qword ptr [RBP + -0x30]
JZ 0x0011642e
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,R13
MOV RDX,RBX
CALL 0x00116448
JMP 0x0011642e
LAB_001163f4:
XOR R14D,R14D
JMP 0x0011642e
LAB_001163f9:
MOV R12,qword ptr [RBP + -0x30]
JMP 0x0011642e
LAB_001163ff:
LEA RAX,[0x148a30]
MOV RDX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x30]
SUB R12,RAX
MOV RDI,qword ptr [RBP + -0x38]
MOV ESI,0x1393
XOR ECX,ECX
MOV R8,R12
MOV R12,RAX
XOR EAX,EAX
CALL 0x0011577d
MOV R14D,0x1
LAB_0011642e:
MOV RDI,R12
CALL 0x00113570
MOV EAX,R14D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
parse_connection_string(int8 param_1,int8 param_2,char *param_3,size_t param_4)
{
byte bVar1;
bool bVar2;
bool bVar3;
int iVar4;
byte *__dest;
ushort **ppuVar5;
byte *pbVar6;
byte *__dest_00;
byte *__s1;
int8 uVar7;
byte *pbVar8;
if (param_4 == 0xffffffffffffffff) {
param_4 = strlen(param_3);
}
__dest = (byte *)malloc(param_4 + 1);
memcpy(__dest,param_3,param_4);
__dest[param_4] = 0;
if ((long)param_4 < 0) {
uVar7 = 0;
}
else {
pbVar8 = __dest + param_4;
bVar2 = false;
ppuVar5 = __ctype_b_loc();
pbVar6 = (byte *)0x0;
__s1 = (byte *)0x0;
__dest_00 = __dest;
do {
bVar1 = *__dest_00;
if (!bVar2 && (*(byte *)((long)*ppuVar5 + (long)(char)bVar1 * 2 + 1) & 0x20) != 0)
goto LAB_00116361;
if (bVar1 < 0x7b) {
if (bVar1 == 0x3b) {
if (bVar2) {
LAB_0011630c:
__dest_00 = __dest_00 + 1;
LAB_0011630f:
bVar2 = true;
goto LAB_001163b8;
}
if (__s1 == (byte *)0x0) goto LAB_001163ff;
*__dest_00 = 0;
iVar4 = strcasecmp((char *)__s1,"connection");
if (iVar4 != 0) {
_mariadb_set_conf_option(param_1,__s1,pbVar6);
}
__s1 = (byte *)0x0;
pbVar6 = (byte *)0x0;
}
else {
if (bVar1 != 0x3d) goto LAB_001163a4;
if (bVar2) goto LAB_0011630c;
if (__s1 == (byte *)0x0) goto LAB_001163ff;
*__dest_00 = 0;
if (__dest_00 + 1 < pbVar8) {
pbVar6 = __dest_00 + 1;
}
}
LAB_00116361:
bVar2 = false;
__dest_00 = __dest_00 + 1;
}
else {
if (bVar1 == 0x7d) {
if (bVar2) {
if (__s1 == (byte *)0x0) goto LAB_001163ff;
if ((pbVar8 <= __dest_00) || (__dest_00[1] != 0x7d)) {
*__dest_00 = 0;
goto LAB_00116361;
}
memmove(__dest_00,__dest_00 + 1,(size_t)(pbVar8 + ~(ulong)__dest_00));
pbVar8 = pbVar8 + -1;
__dest_00 = __dest_00 + 2;
goto LAB_0011630f;
}
bVar2 = false;
LAB_001163a4:
if ((__s1 == (byte *)0x0) && (__s1 = __dest_00, bVar1 == 0)) {
__s1 = (byte *)0x0;
}
}
else {
if (bVar1 != 0x7b) goto LAB_001163a4;
if (__s1 == (byte *)0x0) {
LAB_001163ff:
my_set_error(param_1,0x1393,SQLSTATE_UNKNOWN,0,(long)__dest_00 - (long)__dest);
uVar7 = 1;
goto LAB_0011642e;
}
bVar3 = !bVar2;
bVar2 = true;
if (__dest_00 < pbVar8 && bVar3) {
pbVar6 = __dest_00 + 1;
bVar2 = true;
__dest_00 = pbVar6;
goto LAB_001163b8;
}
}
__dest_00 = __dest_00 + 1;
}
LAB_001163b8:
} while (__dest_00 <= pbVar8);
uVar7 = 0;
if ((__s1 != (byte *)0x0) && (iVar4 = strcasecmp((char *)__s1,"connection"), iVar4 != 0)) {
_mariadb_set_conf_option(param_1,__s1,pbVar6);
}
}
LAB_0011642e:
free(__dest);
return uVar7;
}
| |
38,641 | my_wc_mb_filename | eloqsql/strings/ctype-utf8.c | static int
my_wc_mb_filename(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int code;
static const char hex[]= "0123456789abcdef";
if (s >= e)
return MY_CS_TOOSMALL;
if (wc < 128 && filename_safe_char[wc])
{
*s= (uchar) wc;
return 1;
}
if (s + 3 > e)
return MY_CS_TOOSMALL3;
*s++= MY_FILENAME_ESCAPE;
if ((wc >= 0x00C0 && wc <= 0x05FF && (code= uni_0C00_05FF[wc - 0x00C0])) ||
(wc >= 0x1E00 && wc <= 0x1FFF && (code= uni_1E00_1FFF[wc - 0x1E00])) ||
(wc >= 0x2160 && wc <= 0x217F && (code= uni_2160_217F[wc - 0x2160])) ||
(wc >= 0x24B0 && wc <= 0x24EF && (code= uni_24B0_24EF[wc - 0x24B0])) ||
(wc >= 0xFF20 && wc <= 0xFF5F && (code= uni_FF20_FF5F[wc - 0xFF20])))
{
*s++= (code / 80) + 0x30;
*s++= (code % 80) + 0x30;
return 3;
}
/* Non letter */
if (s + 4 > e)
return MY_CS_TOOSMALL5;
*s++= hex[(wc >> 12) & 15];
*s++= hex[(wc >> 8) & 15];
*s++= hex[(wc >> 4) & 15];
*s++= hex[(wc) & 15];
return 5;
} | O3 | c | my_wc_mb_filename:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0xcee7e
cmpq $0x7f, %rsi
ja 0xcedde
leaq 0x287f25(%rip), %rax # 0x356cf0
cmpb $0x0, (%rsi,%rax)
je 0xcedde
movb %sil, (%rdx)
movl $0x1, %eax
jmp 0xcee7e
leaq 0x3(%rdx), %rdi
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rcx, %rdi
ja 0xcee7e
movb $0x40, (%rdx)
leaq -0xc0(%rsi), %rax
cmpq $0x53f, %rax # imm = 0x53F
ja 0xcee16
leaq 0x28b487(%rip), %rax # 0x35a290
movzwl -0x180(%rax,%rsi,2), %eax
testw %ax, %ax
jne 0xcee59
movq %rsi, %rax
andq $-0x200, %rax # imm = 0xFE00
cmpq $0x1e00, %rax # imm = 0x1E00
jne 0xcee3b
leaq 0x28af22(%rip), %rax # 0x359d50
movzwl -0x3c00(%rax,%rsi,2), %eax
testw %ax, %ax
jne 0xcee59
movq %rsi, %rax
andq $-0x20, %rax
cmpq $0x2160, %rax # imm = 0x2160
jne 0xcee80
leaq 0x28b2ff(%rip), %rax # 0x35a150
movzwl -0x42c0(%rax,%rsi,2), %eax
movzwl %ax, %ecx
imull $0xcccd, %ecx, %ecx # imm = 0xCCCD
shrl $0x16, %ecx
leal 0x30(%rcx), %esi
movb %sil, 0x1(%rdx)
shll $0x4, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
addb $0x30, %al
movb %al, 0x2(%rdx)
movl $0x3, %eax
popq %rbp
retq
leaq -0x24b0(%rsi), %rax
cmpq $0x3f, %rax
ja 0xceeab
leaq -0x24ea(%rsi), %rax
cmpq $-0x34, %rax
jb 0xceed9
leaq 0x28b2ef(%rip), %rax # 0x35a190
movzwl -0x4960(%rax,%rsi,2), %eax
jmp 0xcee59
leaq -0xff20(%rsi), %rax
cmpq $0x3f, %rax
ja 0xceed9
movabsq $-0x7fffffe07ffffff, %rdi # imm = 0xF8000001F8000001
btq %rax, %rdi
jb 0xceed9
leaq 0x28b341(%rip), %rax # 0x35a210
movzwl -0x1fe40(%rax,%rsi,2), %eax
jmp 0xcee59
leaq 0x5(%rdx), %rdi
movl $0xffffff97, %eax # imm = 0xFFFFFF97
cmpq %rcx, %rdi
ja 0xcee7e
movl %esi, %eax
shrl $0xc, %eax
andl $0xf, %eax
leaq 0x28be1a(%rip), %rcx # 0x35ad10
movb (%rax,%rcx), %al
movb %al, 0x1(%rdx)
movl %esi, %eax
shrl $0x8, %eax
andl $0xf, %eax
movb (%rax,%rcx), %al
movb %al, 0x2(%rdx)
movl %esi, %eax
shrl $0x4, %eax
andl $0xf, %eax
movb (%rax,%rcx), %al
movb %al, 0x3(%rdx)
andl $0xf, %esi
movb (%rsi,%rcx), %al
movb %al, 0x4(%rdx)
movl $0x5, %eax
jmp 0xcee7e
| my_wc_mb_filename:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb loc_CEE7E
cmp rsi, 7Fh
ja short loc_CEDDE
lea rax, filename_safe_char
cmp byte ptr [rsi+rax], 0
jz short loc_CEDDE
mov [rdx], sil
mov eax, 1
jmp loc_CEE7E
loc_CEDDE:
lea rdi, [rdx+3]
mov eax, 0FFFFFF99h
cmp rdi, rcx
ja loc_CEE7E
mov byte ptr [rdx], 40h ; '@'
lea rax, [rsi-0C0h]
cmp rax, 53Fh
ja short loc_CEE16
lea rax, uni_0C00_05FF
movzx eax, word ptr [rax+rsi*2-180h]
test ax, ax
jnz short loc_CEE59
loc_CEE16:
mov rax, rsi
and rax, 0FFFFFFFFFFFFFE00h
cmp rax, 1E00h
jnz short loc_CEE3B
lea rax, uni_1E00_1FFF
movzx eax, word ptr [rax+rsi*2-3C00h]
test ax, ax
jnz short loc_CEE59
loc_CEE3B:
mov rax, rsi
and rax, 0FFFFFFFFFFFFFFE0h
cmp rax, 2160h
jnz short loc_CEE80
lea rax, uni_2160_217F
movzx eax, word ptr [rax+rsi*2-42C0h]
loc_CEE59:
movzx ecx, ax
imul ecx, 0CCCDh
shr ecx, 16h
lea esi, [rcx+30h]
mov [rdx+1], sil
shl ecx, 4
lea ecx, [rcx+rcx*4]
sub eax, ecx
add al, 30h ; '0'
mov [rdx+2], al
mov eax, 3
loc_CEE7E:
pop rbp
retn
loc_CEE80:
lea rax, [rsi-24B0h]
cmp rax, 3Fh ; '?'
ja short loc_CEEAB
lea rax, [rsi-24EAh]
cmp rax, 0FFFFFFFFFFFFFFCCh
jb short loc_CEED9
lea rax, uni_24B0_24EF
movzx eax, word ptr [rax+rsi*2-4960h]
jmp short loc_CEE59
loc_CEEAB:
lea rax, [rsi-0FF20h]
cmp rax, 3Fh ; '?'
ja short loc_CEED9
mov rdi, 0F8000001F8000001h
bt rdi, rax
jb short loc_CEED9
lea rax, uni_FF20_FF5F
movzx eax, word ptr [rax+rsi*2-1FE40h]
jmp short loc_CEE59
loc_CEED9:
lea rdi, [rdx+5]
mov eax, 0FFFFFF97h
cmp rdi, rcx
ja short loc_CEE7E
mov eax, esi
shr eax, 0Ch
and eax, 0Fh
lea rcx, my_wc_mb_filename_hex; "0123456789abcdef"
mov al, [rax+rcx]
mov [rdx+1], al
mov eax, esi
shr eax, 8
and eax, 0Fh
mov al, [rax+rcx]
mov [rdx+2], al
mov eax, esi
shr eax, 4
and eax, 0Fh
mov al, [rax+rcx]
mov [rdx+3], al
and esi, 0Fh
mov al, [rsi+rcx]
mov [rdx+4], al
mov eax, 5
jmp loc_CEE7E
| long long my_wc_mb_filename(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
long long result; // rax
unsigned __int16 v5; // ax
unsigned long long v6; // rdi
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
if ( a2 <= 0x7F && filename_safe_char[a2] )
{
*a3 = a2;
return 1LL;
}
result = 4294967193LL;
if ( (unsigned long long)(a3 + 3) <= a4 )
{
*a3 = 64;
if ( a2 - 192 <= 0x53F )
{
v5 = uni_0C00_05FF[a2 - 192];
if ( v5 )
goto LABEL_12;
}
if ( (a2 & 0xFFFFFFFFFFFFFE00LL) == 0x1E00 )
{
v5 = uni_1E00_1FFF[a2 - 7680];
if ( v5 )
goto LABEL_12;
}
if ( (a2 & 0xFFFFFFFFFFFFFFE0LL) == 0x2160 )
{
v5 = uni_2160_217F[a2 - 8544];
LABEL_12:
a3[1] = v5 / 0x50u + 48;
a3[2] = v5 % 0x50u + 48;
return 3LL;
}
if ( a2 - 9392 > 0x3F )
{
if ( a2 - 65312 <= 0x3F )
{
v6 = 0xF8000001F8000001LL;
if ( !_bittest64((const long long *)&v6, a2 - 65312) )
{
v5 = uni_FF20_FF5F[a2 - 65312];
goto LABEL_12;
}
}
}
else if ( a2 - 9450 >= 0xFFFFFFFFFFFFFFCCLL )
{
v5 = uni_24B0_24EF[a2 - 9392];
goto LABEL_12;
}
result = 4294967191LL;
if ( (unsigned long long)(a3 + 5) <= a4 )
{
a3[1] = my_wc_mb_filename_hex[(unsigned __int16)a2 >> 12];
a3[2] = my_wc_mb_filename_hex[((unsigned int)a2 >> 8) & 0xF];
a3[3] = my_wc_mb_filename_hex[(unsigned __int8)a2 >> 4];
a3[4] = my_wc_mb_filename_hex[a2 & 0xF];
return 5LL;
}
}
}
return result;
}
| my_wc_mb_filename:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001cee7e
CMP RSI,0x7f
JA 0x001cedde
LEA RAX,[0x456cf0]
CMP byte ptr [RSI + RAX*0x1],0x0
JZ 0x001cedde
MOV byte ptr [RDX],SIL
MOV EAX,0x1
JMP 0x001cee7e
LAB_001cedde:
LEA RDI,[RDX + 0x3]
MOV EAX,0xffffff99
CMP RDI,RCX
JA 0x001cee7e
MOV byte ptr [RDX],0x40
LEA RAX,[RSI + -0xc0]
CMP RAX,0x53f
JA 0x001cee16
LEA RAX,[0x45a290]
MOVZX EAX,word ptr [RAX + RSI*0x2 + -0x180]
TEST AX,AX
JNZ 0x001cee59
LAB_001cee16:
MOV RAX,RSI
AND RAX,-0x200
CMP RAX,0x1e00
JNZ 0x001cee3b
LEA RAX,[0x459d50]
MOVZX EAX,word ptr [RAX + RSI*0x2 + -0x3c00]
TEST AX,AX
JNZ 0x001cee59
LAB_001cee3b:
MOV RAX,RSI
AND RAX,-0x20
CMP RAX,0x2160
JNZ 0x001cee80
LEA RAX,[0x45a150]
MOVZX EAX,word ptr [RAX + RSI*0x2 + -0x42c0]
LAB_001cee59:
MOVZX ECX,AX
IMUL ECX,ECX,0xcccd
SHR ECX,0x16
LEA ESI,[RCX + 0x30]
MOV byte ptr [RDX + 0x1],SIL
SHL ECX,0x4
LEA ECX,[RCX + RCX*0x4]
SUB EAX,ECX
ADD AL,0x30
MOV byte ptr [RDX + 0x2],AL
MOV EAX,0x3
LAB_001cee7e:
POP RBP
RET
LAB_001cee80:
LEA RAX,[RSI + -0x24b0]
CMP RAX,0x3f
JA 0x001ceeab
LEA RAX,[RSI + -0x24ea]
CMP RAX,-0x34
JC 0x001ceed9
LEA RAX,[0x45a190]
MOVZX EAX,word ptr [RAX + RSI*0x2 + -0x4960]
JMP 0x001cee59
LAB_001ceeab:
LEA RAX,[RSI + -0xff20]
CMP RAX,0x3f
JA 0x001ceed9
MOV RDI,-0x7fffffe07ffffff
BT RDI,RAX
JC 0x001ceed9
LEA RAX,[0x45a210]
MOVZX EAX,word ptr [RAX + RSI*0x2 + -0x1fe40]
JMP 0x001cee59
LAB_001ceed9:
LEA RDI,[RDX + 0x5]
MOV EAX,0xffffff97
CMP RDI,RCX
JA 0x001cee7e
MOV EAX,ESI
SHR EAX,0xc
AND EAX,0xf
LEA RCX,[0x45ad10]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RDX + 0x1],AL
MOV EAX,ESI
SHR EAX,0x8
AND EAX,0xf
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RDX + 0x2],AL
MOV EAX,ESI
SHR EAX,0x4
AND EAX,0xf
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RDX + 0x3],AL
AND ESI,0xf
MOV AL,byte ptr [RSI + RCX*0x1]
MOV byte ptr [RDX + 0x4],AL
MOV EAX,0x5
JMP 0x001cee7e
|
int8
my_wc_mb_filename(int8 param_1,ulong param_2,int1 *param_3,int1 *param_4)
{
ushort uVar1;
if (param_4 <= param_3) {
return 0xffffff9b;
}
if ((param_2 < 0x80) && (filename_safe_char[param_2] != '\0')) {
*param_3 = (char)param_2;
return 1;
}
if (param_4 < param_3 + 3) {
return 0xffffff99;
}
*param_3 = 0x40;
if (((0x53f < param_2 - 0xc0) ||
(uVar1 = *(ushort *)(uni_1E00_1FFF + param_2 * 2 + 0x3c0), uVar1 == 0)) &&
(((param_2 & 0xfffffffffffffe00) != 0x1e00 ||
(uVar1 = *(ushort *)(unicode_to_jisx0212_eucjp + param_2 * 2 + 0x1f780), uVar1 == 0)))) {
if ((param_2 & 0xffffffffffffffe0) == 0x2160) {
uVar1 = *(ushort *)(unicode_to_jisx0212_eucjp + param_2 * 2 + 0x1f4c0);
}
else if (param_2 - 0x24b0 < 0x40) {
if (param_2 - 0x24ea < 0xffffffffffffffcc) {
LAB_001ceed9:
if (param_4 < param_3 + 5) {
return 0xffffff97;
}
param_3[1] = "0123456789abcdef"[(uint)(param_2 >> 0xc) & 0xf];
param_3[2] = "0123456789abcdef"[(uint)(param_2 >> 8) & 0xf];
param_3[3] = "0123456789abcdef"[(uint)(param_2 >> 4) & 0xf];
param_3[4] = "0123456789abcdef"[(uint)param_2 & 0xf];
return 5;
}
uVar1 = *(ushort *)(unicode_to_jisx0212_eucjp + param_2 * 2 + 0x1ee60);
}
else {
if ((0x3f < param_2 - 0xff20) || ((0xf8000001f8000001U >> (param_2 - 0xff20 & 0x3f) & 1) != 0)
) goto LAB_001ceed9;
uVar1 = *(ushort *)(unicode_to_jisx0212_eucjp + param_2 * 2 + 0x3a00);
}
}
param_3[1] = (char)(uVar1 / 0x50) + '0';
param_3[2] = (char)uVar1 + (char)(uVar1 / 0x50 << 4) * -5 + '0';
return 3;
}
| |
38,642 | inline_mysql_cond_destroy | eloqsql/include/mysql/psi/mysql_thread.h | static inline int inline_mysql_cond_destroy(
mysql_cond_t *that)
{
#ifdef HAVE_PSI_COND_INTERFACE
if (psi_likely(that->m_psi != NULL))
{
PSI_COND_CALL(destroy_cond)(that->m_psi);
that->m_psi= NULL;
}
#endif
return pthread_cond_destroy(&that->m_cond);
} | O0 | c | inline_mysql_cond_destroy:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x5f404
leaq 0x26beb9(%rip), %rax # 0x2cb2a0
movq (%rax), %rax
movq 0x68(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rdi
callq 0x2a280
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| inline_mysql_cond_destroy_2:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
cmp qword ptr [rax+30h], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_5F404
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+68h]
mov rcx, [rbp+var_8]
mov rdi, [rcx+30h]
call rax
mov rax, [rbp+var_8]
mov qword ptr [rax+30h], 0
loc_5F404:
mov rdi, [rbp+var_8]
call _pthread_cond_destroy
add rsp, 10h
pop rbp
retn
| long long inline_mysql_cond_destroy_2(long long a1)
{
if ( *(_QWORD *)(a1 + 48) )
{
((void ( *)(_QWORD))PSI_server[13])(*(_QWORD *)(a1 + 48));
*(_QWORD *)(a1 + 48) = 0LL;
}
return pthread_cond_destroy(a1);
}
| inline_mysql_cond_destroy:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x30],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0015f404
LEA RAX,[0x3cb2a0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x68]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RCX + 0x30]
CALL RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x30],0x0
LAB_0015f404:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0012a280
ADD RSP,0x10
POP RBP
RET
|
void inline_mysql_cond_destroy(pthread_cond_t *param_1)
{
if (param_1[1].__align != 0) {
(**(code **)(PSI_server + 0x68))(param_1[1].__align);
param_1[1].__align = 0;
}
pthread_cond_destroy(param_1);
return;
}
| |
38,643 | nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::erase(__gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>>, __gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>>) | llama.cpp/common/./json.hpp | iterator erase(iterator first, iterator last)
{
if (first == last)
{
return first;
}
const auto elements_affected = std::distance(first, last);
const auto offset = std::distance(Container::begin(), first);
// This is the start situation. We need to delete elements_affected
// elements (3 in this example: e, f, g), and need to return an
// iterator past the last deleted element (h in this example).
// Note that offset is the distance from the start of the vector
// to first. We will need this later.
// [ a, b, c, d, e, f, g, h, i, j ]
// ^ ^
// first last
// Since we cannot move const Keys, we re-construct them in place.
// We start at first and re-construct (viz. copy) the elements from
// the back of the vector. Example for first iteration:
// ,--------.
// v | destroy e and re-construct with h
// [ a, b, c, d, e, f, g, h, i, j ]
// ^ ^
// it it + elements_affected
for (auto it = first; std::next(it, elements_affected) != Container::end(); ++it)
{
it->~value_type(); // destroy but keep allocation
new (&*it) value_type{std::move(*std::next(it, elements_affected))}; // "move" next element to it
}
// [ a, b, c, d, h, i, j, h, i, j ]
// ^ ^
// first last
// remove the unneeded elements at the end of the vector
Container::resize(this->size() - static_cast<size_type>(elements_affected));
// [ a, b, c, d, h, i, j ]
// ^ ^
// first last
// first is now pointing past the last deleted element, but we cannot
// use this iterator, because it may have been invalidated by the
// resize call. Instead, we can return begin() + offset.
return Container::begin() + offset;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::erase(__gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>>, __gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>>):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
cmpq %rdx, %rsi
je 0x344c0
movq %rdx, %r15
movq %rdi, %rbx
movq %rdx, %rax
subq %r14, %rax
sarq $0x4, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
movq %rax, 0x10(%rsp)
movq (%rdi), %rax
movq %rax, 0x8(%rsp)
xorl %ebp, %ebp
leaq (%r15,%rbp), %rax
cmpq 0x8(%rbx), %rax
je 0x3447f
leaq (%r14,%rbp), %r12
addq $0x20, %r12
movq %r12, %rdi
callq 0x3488a
movq -0x20(%r12), %rdi
leaq (%r14,%rbp), %r13
addq $0x10, %r13
cmpq %rdi, %r13
je 0x34447
movq (%r13), %rsi
incq %rsi
callq 0x21180
leaq (%r14,%rbp), %rdi
movq %r13, (%rdi)
movq (%r15,%rbp), %rsi
movq 0x8(%r15,%rbp), %rdx
addq %rsi, %rdx
callq 0x3bb50
movups 0x20(%r15,%rbp), %xmm0
movups %xmm0, (%r12)
movb $0x0, 0x20(%r15,%rbp)
movq $0x0, 0x28(%r15,%rbp)
addq $0x30, %rbp
jmp 0x3440f
movq %r14, %r15
subq 0x8(%rsp), %r15
movq 0x10(%rsp), %rax
leaq (%rax,%rax,2), %rsi
shlq $0x4, %rsi
addq %r14, %rsi
subq (%rbx), %rsi
addq %rbp, %rsi
sarq $0x4, %rsi
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rsi
subq %rax, %rsi
movq %rbx, %rdi
callq 0x344d2
addq (%rbx), %r15
movq %r15, %r14
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEESP_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14, rsi
cmp rsi, rdx
jz loc_344C0
mov r15, rdx
mov rbx, rdi
mov rax, rdx
sub rax, r14
sar rax, 4
mov rcx, 0AAAAAAAAAAAAAAABh
imul rax, rcx
mov [rsp+48h+var_38], rax
mov rax, [rdi]
mov [rsp+48h+var_40], rax
xor ebp, ebp
loc_3440F:
lea rax, [r15+rbp]
cmp rax, [rbx+8]
jz short loc_3447F
lea r12, [r14+rbp]
add r12, 20h ; ' '
mov rdi, r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [r12-20h]; void *
lea r13, [r14+rbp]
add r13, 10h
cmp r13, rdi
jz short loc_34447
mov rsi, [r13+0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_34447:
lea rdi, [r14+rbp]
mov [rdi], r13
mov rsi, [r15+rbp]
mov rdx, [r15+rbp+8]
add rdx, rsi
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
movups xmm0, xmmword ptr [r15+rbp+20h]
movups xmmword ptr [r12], xmm0
mov byte ptr [r15+rbp+20h], 0
mov qword ptr [r15+rbp+28h], 0
add rbp, 30h ; '0'
jmp short loc_3440F
loc_3447F:
mov r15, r14
sub r15, [rsp+48h+var_40]
mov rax, [rsp+48h+var_38]
lea rsi, [rax+rax*2]
shl rsi, 4
add rsi, r14
sub rsi, [rbx]
add rsi, rbp
sar rsi, 4
mov rcx, 0AAAAAAAAAAAAAAABh
imul rsi, rcx
sub rsi, rax
mov rdi, rbx
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE6resizeEm; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::resize(ulong)
add r15, [rbx]
mov r14, r15
loc_344C0:
mov rax, r14
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::erase(
long long *a1,
long long a2,
long long a3)
{
long long v3; // r14
long long i; // rbp
_QWORD *v7; // rdi
_QWORD *v8; // r13
long long v10; // [rsp+8h] [rbp-40h]
unsigned long long v11; // [rsp+10h] [rbp-38h]
v3 = a2;
if ( a2 != a3 )
{
v11 = 0xAAAAAAAAAAAAAAABLL * ((a3 - a2) >> 4);
v10 = *a1;
for ( i = 0LL; a3 + i != a1[1]; i += 48LL )
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(a2 + i + 32);
v7 = *(_QWORD **)(a2 + i);
v8 = (_QWORD *)(a2 + i + 16);
if ( v8 != v7 )
operator delete(v7, *v8 + 1LL);
*(_QWORD *)(a2 + i) = v8;
std::string::_M_construct<char *>(a2 + i, *(_QWORD *)(a3 + i), *(_QWORD *)(a3 + i) + *(_QWORD *)(a3 + i + 8));
*(_OWORD *)(a2 + i + 32) = *(_OWORD *)(a3 + i + 32);
*(_BYTE *)(a3 + i + 32) = 0;
*(_QWORD *)(a3 + i + 40) = 0LL;
}
std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::resize(
a1,
0xAAAAAAAAAAAAAAABLL * ((long long)(i + a2 + 48 * v11 - *a1) >> 4) - v11);
return *a1 + a2 - v10;
}
return v3;
}
| erase:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R14,RSI
CMP RSI,RDX
JZ 0x001344c0
MOV R15,RDX
MOV RBX,RDI
MOV RAX,RDX
SUB RAX,R14
SAR RAX,0x4
MOV RCX,-0x5555555555555555
IMUL RAX,RCX
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RDI]
MOV qword ptr [RSP + 0x8],RAX
XOR EBP,EBP
LAB_0013440f:
LEA RAX,[R15 + RBP*0x1]
CMP RAX,qword ptr [RBX + 0x8]
JZ 0x0013447f
LEA R12,[R14 + RBP*0x1]
ADD R12,0x20
MOV RDI,R12
CALL 0x0013488a
MOV RDI,qword ptr [R12 + -0x20]
LEA R13,[R14 + RBP*0x1]
ADD R13,0x10
CMP R13,RDI
JZ 0x00134447
MOV RSI,qword ptr [R13]
INC RSI
CALL 0x00121180
LAB_00134447:
LEA RDI,[R14 + RBP*0x1]
MOV qword ptr [RDI],R13
MOV RSI,qword ptr [R15 + RBP*0x1]
MOV RDX,qword ptr [R15 + RBP*0x1 + 0x8]
ADD RDX,RSI
CALL 0x0013bb50
MOVUPS XMM0,xmmword ptr [R15 + RBP*0x1 + 0x20]
MOVUPS xmmword ptr [R12],XMM0
MOV byte ptr [R15 + RBP*0x1 + 0x20],0x0
MOV qword ptr [R15 + RBP*0x1 + 0x28],0x0
ADD RBP,0x30
JMP 0x0013440f
LAB_0013447f:
MOV R15,R14
SUB R15,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x10]
LEA RSI,[RAX + RAX*0x2]
SHL RSI,0x4
ADD RSI,R14
SUB RSI,qword ptr [RBX]
ADD RSI,RBP
SAR RSI,0x4
MOV RCX,-0x5555555555555555
IMUL RSI,RCX
SUB RSI,RAX
MOV RDI,RBX
CALL 0x001344d2
ADD R15,qword ptr [RBX]
MOV R14,R15
LAB_001344c0:
MOV RAX,R14
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::string,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > > >::erase(__gnu_cxx::__normal_iterator<std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >*, std::vector<std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >, std::allocator<std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > > > >, __gnu_cxx::__normal_iterator<std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >*, std::vector<std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >, std::allocator<std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > > > >) */
long __thiscall
nlohmann::json_abi_v3_11_3::
ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::erase(ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*this,long param_2,long param_3)
{
int8 *puVar1;
int8 *puVar2;
long lVar3;
int8 uVar4;
long lVar5;
long lVar6;
long *plVar7;
if (param_2 != param_3) {
lVar5 = param_3 - param_2 >> 4;
lVar3 = *(long *)this;
for (lVar6 = 0; param_3 + lVar6 != *(long *)(this + 8); lVar6 = lVar6 + 0x30) {
puVar1 = (int8 *)(param_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>
::data::~data((data *)(puVar1 + 4));
plVar7 = (long *)(param_2 + lVar6 + 0x10);
if (plVar7 != (long *)*puVar1) {
operator_delete((long *)*puVar1,*plVar7 + 1);
}
*(int8 *)(param_2 + lVar6) = plVar7;
std::__cxx11::string::_M_construct<char*>
((int8 *)(param_2 + lVar6),*(long *)(param_3 + lVar6),
*(long *)(param_3 + 8 + lVar6) + *(long *)(param_3 + lVar6));
puVar2 = (int8 *)(param_3 + 0x20 + lVar6);
uVar4 = puVar2[1];
puVar1[4] = *puVar2;
puVar1[5] = uVar4;
*(int1 *)(param_3 + 0x20 + lVar6) = 0;
*(int8 *)(param_3 + 0x28 + lVar6) = 0;
}
std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::resize((vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*)this,(((lVar5 * 0x10 + param_2) - *(long *)this) + lVar6 >> 4) * -0x5555555555555555
+ lVar5 * 0x5555555555555555);
param_2 = (param_2 - lVar3) + *(long *)this;
}
return param_2;
}
| |
38,644 | google::protobuf::DescriptorPool::BuildFile(google::protobuf::FileDescriptorProto const&) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc | const FileDescriptor* DescriptorPool::BuildFile(
const FileDescriptorProto& proto) {
GOOGLE_CHECK(fallback_database_ == nullptr)
<< "Cannot call BuildFile on a DescriptorPool that uses a "
"DescriptorDatabase. You must instead find a way to get your file "
"into the underlying database.";
GOOGLE_CHECK(mutex_ == nullptr); // Implied by the above GOOGLE_CHECK.
tables_->known_bad_symbols_.clear();
tables_->known_bad_files_.clear();
return DescriptorBuilder(this, tables_.get(), nullptr).BuildFile(proto);
} | O0 | cpp | google::protobuf::DescriptorPool::BuildFile(google::protobuf::FileDescriptorProto const&):
subq $0x238, %rsp # imm = 0x238
movq %rdi, 0x230(%rsp)
movq %rsi, 0x228(%rsp)
movq 0x230(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x8(%rax), %rax
movb $0x0, 0x1ef(%rsp)
cmpq $0x0, %rax
jne 0x258dd8
jmp 0x258e49
leaq 0x1a78a9(%rip), %rdx # 0x400688
leaq 0x1f0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movl $0x3, %esi
movl $0x102f, %ecx # imm = 0x102F
callq 0x219560
movq 0x30(%rsp), %rdi
movb $0x1, 0x1ef(%rsp)
leaq 0x1a7de0(%rip), %rsi # 0x400bef
callq 0x218e20
movq %rax, 0x38(%rsp)
jmp 0x258e1b
movq 0x38(%rsp), %rdi
leaq 0x1a7df6(%rip), %rsi # 0x400c1d
callq 0x218e20
movq %rax, 0x28(%rsp)
jmp 0x258e33
movq 0x28(%rsp), %rsi
leaq 0x1db(%rsp), %rdi
callq 0x218fd0
jmp 0x258e47
jmp 0x258e49
testb $0x1, 0x1ef(%rsp)
jne 0x258e55
jmp 0x258e62
leaq 0x1f0(%rsp), %rdi
callq 0x2195a0
movq 0x40(%rsp), %rax
movq (%rax), %rax
movb $0x0, 0x19f(%rsp)
cmpq $0x0, %rax
jne 0x258e7a
jmp 0x258ed3
leaq 0x1a7807(%rip), %rdx # 0x400688
leaq 0x1a0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x3, %esi
movl $0x1033, %ecx # imm = 0x1033
callq 0x219560
movq 0x18(%rsp), %rdi
movb $0x1, 0x19f(%rsp)
leaq 0x1a7e02(%rip), %rsi # 0x400cb3
callq 0x218e20
movq %rax, 0x20(%rsp)
jmp 0x258ebd
movq 0x20(%rsp), %rsi
leaq 0x19e(%rsp), %rdi
callq 0x218fd0
jmp 0x258ed1
jmp 0x258ed3
testb $0x1, 0x19f(%rsp)
jne 0x258edf
jmp 0x258eec
leaq 0x1a0(%rsp), %rdi
callq 0x2195a0
movq 0x40(%rsp), %rdi
addq $0x20, %rdi
movq %rdi, (%rsp)
callq 0x28a320
movq %rax, %rdi
addq $0x50, %rdi
callq 0x8df30
movq (%rsp), %rdi
callq 0x28a320
movq %rax, %rdi
addq $0x18, %rdi
callq 0x8df30
movq (%rsp), %rdi
callq 0x28c900
movq 0x40(%rsp), %rsi
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %ecx
leaq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x2596c0
movq 0x8(%rsp), %rdi
movq 0x228(%rsp), %rsi
callq 0x259000
movq %rax, 0x10(%rsp)
jmp 0x258f5c
leaq 0x48(%rsp), %rdi
callq 0x2598b0
movq 0x10(%rsp), %rax
addq $0x238, %rsp # imm = 0x238
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1e0(%rsp)
movl %eax, 0x1dc(%rsp)
testb $0x1, 0x1ef(%rsp)
jne 0x258f93
jmp 0x258fa0
leaq 0x1f0(%rsp), %rdi
callq 0x2195a0
jmp 0x258fef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1e0(%rsp)
movl %eax, 0x1dc(%rsp)
testb $0x1, 0x19f(%rsp)
jne 0x258fc2
jmp 0x258fcf
leaq 0x1a0(%rsp), %rdi
callq 0x2195a0
jmp 0x258fef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1e0(%rsp)
movl %eax, 0x1dc(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2598b0
movq 0x1e0(%rsp), %rdi
callq 0x21700
nopl (%rax)
| _ZN6google8protobuf14DescriptorPool9BuildFileERKNS0_19FileDescriptorProtoE:
sub rsp, 238h
mov [rsp+238h+var_8], rdi
mov [rsp+238h+var_10], rsi
mov rax, [rsp+238h+var_8]
mov [rsp+238h+var_1F8], rax
mov rax, [rax+8]
mov [rsp+238h+var_49], 0
cmp rax, 0
jnz short loc_258DD8
jmp short loc_258E49
loc_258DD8:
lea rdx, aWorkspaceLlm4b_80; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+238h+var_48]
mov [rsp+238h+var_208], rdi
mov esi, 3
mov ecx, 102Fh
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+238h+var_208]
mov [rsp+238h+var_49], 1
lea rsi, aCheckFailedFal; "CHECK failed: fallback_database_ == nul"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+238h+var_200], rax
jmp short $+2
loc_258E1B:
mov rdi, [rsp+238h+var_200]
lea rsi, aCannotCallBuil; "Cannot call BuildFile on a DescriptorPo"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+238h+var_210], rax
jmp short $+2
loc_258E33:
mov rsi, [rsp+238h+var_210]
lea rdi, [rsp+238h+var_5D]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_258E47:
jmp short $+2
loc_258E49:
test [rsp+238h+var_49], 1
jnz short loc_258E55
jmp short loc_258E62
loc_258E55:
lea rdi, [rsp+238h+var_48]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_258E62:
mov rax, [rsp+238h+var_1F8]
mov rax, [rax]
mov [rsp+238h+var_99], 0
cmp rax, 0
jnz short loc_258E7A
jmp short loc_258ED3
loc_258E7A:
lea rdx, aWorkspaceLlm4b_80; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+238h+var_98]
mov [rsp+238h+var_220], rdi
mov esi, 3
mov ecx, 1033h
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+238h+var_220]
mov [rsp+238h+var_99], 1
lea rsi, aCheckFailedMut; "CHECK failed: mutex_ == nullptr: "
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+238h+var_218], rax
jmp short $+2
loc_258EBD:
mov rsi, [rsp+238h+var_218]
lea rdi, [rsp+238h+var_9A]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_258ED1:
jmp short $+2
loc_258ED3:
test [rsp+238h+var_99], 1
jnz short loc_258EDF
jmp short loc_258EEC
loc_258EDF:
lea rdi, [rsp+238h+var_98]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_258EEC:
mov rdi, [rsp+238h+var_1F8]
add rdi, 20h ; ' '
mov [rsp+238h+var_238], rdi
call _ZNKSt10unique_ptrIN6google8protobuf14DescriptorPool6TablesESt14default_deleteIS3_EEptEv; std::unique_ptr<google::protobuf::DescriptorPool::Tables>::operator->(void)
mov rdi, rax
add rdi, 50h ; 'P'
call _ZNSt13unordered_setINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4hashIS5_ESt8equal_toIS5_ESaIS5_EE5clearEv; std::unordered_set<std::string>::clear(void)
mov rdi, [rsp+238h+var_238]
call _ZNKSt10unique_ptrIN6google8protobuf14DescriptorPool6TablesESt14default_deleteIS3_EEptEv; std::unique_ptr<google::protobuf::DescriptorPool::Tables>::operator->(void)
mov rdi, rax
add rdi, 18h
call _ZNSt13unordered_setINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4hashIS5_ESt8equal_toIS5_ESaIS5_EE5clearEv; std::unordered_set<std::string>::clear(void)
mov rdi, [rsp+238h+var_238]
call _ZNKSt10unique_ptrIN6google8protobuf14DescriptorPool6TablesESt14default_deleteIS3_EE3getEv; std::unique_ptr<google::protobuf::DescriptorPool::Tables>::get(void)
mov rsi, [rsp+238h+var_1F8]; google::protobuf::DescriptorPool *
mov rdx, rax; google::protobuf::DescriptorPool::Tables *
xor eax, eax
mov ecx, eax; google::protobuf::DescriptorPool::ErrorCollector *
lea rdi, [rsp+238h+var_1F0]; this
mov [rsp+238h+var_230], rdi
call _ZN6google8protobuf17DescriptorBuilderC2EPKNS0_14DescriptorPoolEPNS2_6TablesEPNS2_14ErrorCollectorE; google::protobuf::DescriptorBuilder::DescriptorBuilder(google::protobuf::DescriptorPool const*,google::protobuf::DescriptorPool::Tables *,google::protobuf::DescriptorPool::ErrorCollector *)
mov rdi, [rsp+238h+var_230]; this
mov rsi, [rsp+238h+var_10]; google::protobuf::FileDescriptorProto *
call _ZN6google8protobuf17DescriptorBuilder9BuildFileERKNS0_19FileDescriptorProtoE; google::protobuf::DescriptorBuilder::BuildFile(google::protobuf::FileDescriptorProto const&)
mov [rsp+238h+var_228], rax
jmp short $+2
loc_258F5C:
lea rdi, [rsp+238h+var_1F0]; this
call _ZN6google8protobuf17DescriptorBuilderD2Ev; google::protobuf::DescriptorBuilder::~DescriptorBuilder()
mov rax, [rsp+238h+var_228]
add rsp, 238h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_1D8], rcx
mov [rsp+arg_1D4], eax
test [rsp+arg_1E7], 1
jnz short loc_258F93
jmp short loc_258FA0
loc_258F93:
lea rdi, [rsp+arg_1E8]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_258FA0:
jmp short loc_258FEF
mov rcx, rax
mov eax, edx
mov [rsp+arg_1D8], rcx
mov [rsp+arg_1D4], eax
test [rsp+arg_197], 1
jnz short loc_258FC2
jmp short loc_258FCF
loc_258FC2:
lea rdi, [rsp+arg_198]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_258FCF:
jmp short loc_258FEF
mov rcx, rax
mov eax, edx
mov [rsp+arg_1D8], rcx
mov [rsp+arg_1D4], eax
lea rdi, [rsp+arg_40]; this
call _ZN6google8protobuf17DescriptorBuilderD2Ev; google::protobuf::DescriptorBuilder::~DescriptorBuilder()
loc_258FEF:
mov rdi, [rsp+arg_1D8]
call __Unwind_Resume
| long long google::protobuf::DescriptorPool::BuildFile(
google::protobuf::DescriptorPool *this,
const google::protobuf::FileDescriptorProto *a2)
{
long long v2; // rax
long long v3; // rax
long long v4; // rax
long long v5; // rax
google::protobuf::DescriptorPool::Tables *v6; // rax
long long v8; // [rsp+10h] [rbp-228h]
google::protobuf::internal::LogMessage *v9; // [rsp+20h] [rbp-218h]
google::protobuf::internal::LogMessage *v10; // [rsp+28h] [rbp-210h]
long long v11; // [rsp+38h] [rbp-200h]
_BYTE v12[342]; // [rsp+48h] [rbp-1F0h] BYREF
char v13; // [rsp+19Eh] [rbp-9Ah] BYREF
char v14; // [rsp+19Fh] [rbp-99h]
_BYTE v15[59]; // [rsp+1A0h] [rbp-98h] BYREF
_BYTE v16[20]; // [rsp+1DBh] [rbp-5Dh] BYREF
char v17; // [rsp+1EFh] [rbp-49h]
_BYTE v18[56]; // [rsp+1F0h] [rbp-48h] BYREF
google::protobuf::FileDescriptorProto *v19; // [rsp+228h] [rbp-10h]
google::protobuf::DescriptorPool *v20; // [rsp+230h] [rbp-8h]
v20 = this;
v19 = a2;
v2 = *((_QWORD *)this + 1);
v17 = 0;
if ( v2 )
{
google::protobuf::internal::LogMessage::LogMessage(
(long long)v18,
3,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc",
4143);
v17 = 1;
v11 = google::protobuf::internal::LogMessage::operator<<(
(long long)v18,
(long long)"CHECK failed: fallback_database_ == nullptr: ");
v10 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(
v11,
(long long)"Cannot call BuildFile on a DescriptorPool that uses a Des"
"criptorDatabase. You must instead find a way to get your"
" file into the underlying database.");
google::protobuf::internal::LogFinisher::operator=((long long)v16, v10);
}
if ( (v17 & 1) != 0 )
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v18);
v3 = *(_QWORD *)this;
v14 = 0;
if ( v3 )
{
google::protobuf::internal::LogMessage::LogMessage(
(long long)v15,
3,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc",
4147);
v14 = 1;
v9 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(
(long long)v15,
(long long)"CHECK failed: mutex_ == nullptr: ");
google::protobuf::internal::LogFinisher::operator=((long long)&v13, v9);
}
if ( (v14 & 1) != 0 )
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v15);
v4 = std::unique_ptr<google::protobuf::DescriptorPool::Tables>::operator->((char *)this + 32);
std::unordered_set<std::string>::clear((_QWORD *)(v4 + 80));
v5 = std::unique_ptr<google::protobuf::DescriptorPool::Tables>::operator->((char *)this + 32);
std::unordered_set<std::string>::clear((_QWORD *)(v5 + 24));
v6 = (google::protobuf::DescriptorPool::Tables *)std::unique_ptr<google::protobuf::DescriptorPool::Tables>::get((char *)this + 32);
google::protobuf::DescriptorBuilder::DescriptorBuilder((google::protobuf::DescriptorBuilder *)v12, this, v6, 0LL);
v8 = google::protobuf::DescriptorBuilder::BuildFile((google::protobuf::DescriptorBuilder *)v12, v19);
google::protobuf::DescriptorBuilder::~DescriptorBuilder((google::protobuf::DescriptorBuilder *)v12);
return v8;
}
| _M_head:
PUSH RAX
MOV qword ptr [RSP],RDI
MOV RDI,qword ptr [RSP]
CALL 0x00258db0
POP RCX
RET
|
/* std::_Tuple_impl<0ul, google::protobuf::FieldDescriptor const**,
std::default_delete<google::protobuf::FieldDescriptor const* []> >::_M_head(std::_Tuple_impl<0ul,
google::protobuf::FieldDescriptor const**, std::default_delete<google::protobuf::FieldDescriptor
const* []> > const&) */
void std::
_Tuple_impl<0ul,google::protobuf::FieldDescriptor_const**,std::default_delete<google::protobuf::FieldDescriptor_const*[]>>
::_M_head(_Tuple_impl *param_1)
{
_Head_base<0ul,google::protobuf::FieldDescriptor_const**,false>::_M_head((_Head_base *)param_1);
return;
}
| |
38,645 | dynstr_realloc | eloqsql/mysys/string.c | my_bool dynstr_realloc(DYNAMIC_STRING *str, size_t additional_size)
{
DBUG_ENTER("dynstr_realloc");
if (!additional_size) DBUG_RETURN(FALSE);
if (str->length + additional_size > str->max_length)
{
str->max_length=((str->length + additional_size+str->alloc_increment-1)/
str->alloc_increment)*str->alloc_increment;
if (!(str->str=(char*) my_realloc(key_memory_DYNAMIC_STRING, str->str,
str->max_length, MYF(MY_WME))))
DBUG_RETURN(TRUE);
}
DBUG_RETURN(FALSE);
} | O0 | c | dynstr_realloc:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8d902
jmp 0x8d8f9
movb $0x0, -0x1(%rbp)
jmp 0x8d98d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x8d987
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
addq 0x18(%rcx), %rax
subq $0x1, %rax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq 0x18(%rcx)
movq %rax, %rcx
movq -0x10(%rbp), %rax
imulq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
leaq 0x37fb8b(%rip), %rax # 0x40d4e0
movl (%rax), %edi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movl $0x10, %ecx
callq 0x8b0e0
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x8d985
jmp 0x8d97f
movb $0x1, -0x1(%rbp)
jmp 0x8d98d
jmp 0x8d987
jmp 0x8d989
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| dynstr_realloc:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
cmp [rbp+var_18], 0
jnz short loc_8D902
jmp short $+2
loc_8D8F9:
mov [rbp+var_1], 0
jmp loc_8D98D
loc_8D902:
mov rax, [rbp+var_10]
mov rax, [rax+8]
add rax, [rbp+var_18]
mov rcx, [rbp+var_10]
cmp rax, [rcx+10h]
jbe short loc_8D987
mov rax, [rbp+var_10]
mov rax, [rax+8]
add rax, [rbp+var_18]
mov rcx, [rbp+var_10]
add rax, [rcx+18h]
sub rax, 1
mov rcx, [rbp+var_10]
xor edx, edx
div qword ptr [rcx+18h]
mov rcx, rax
mov rax, [rbp+var_10]
imul rcx, [rax+18h]
mov rax, [rbp+var_10]
mov [rax+10h], rcx
lea rax, key_memory_DYNAMIC_STRING
mov edi, [rax]
mov rax, [rbp+var_10]
mov rsi, [rax]
mov rax, [rbp+var_10]
mov rdx, [rax+10h]
mov ecx, 10h
call my_realloc
mov rcx, [rbp+var_10]
mov [rcx], rax
cmp rax, 0
jnz short loc_8D985
jmp short $+2
loc_8D97F:
mov [rbp+var_1], 1
jmp short loc_8D98D
loc_8D985:
jmp short $+2
loc_8D987:
jmp short $+2
loc_8D989:
mov [rbp+var_1], 0
loc_8D98D:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| bool dynstr_realloc(long long *a1, long long a2)
{
long long v2; // rax
char v4; // [rsp+1Fh] [rbp-1h]
if ( a2 )
{
v4 = 0;
if ( a2 + a1[1] > (unsigned long long)a1[2] )
{
a1[2] = a1[3] * ((a1[3] + a2 + a1[1] - 1) / (unsigned long long)a1[3]);
v2 = my_realloc(key_memory_DYNAMIC_STRING, *a1, a1[2], 16);
*a1 = v2;
if ( !v2 )
return 1;
}
}
else
{
return 0;
}
return v4;
}
| dynstr_realloc:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x0018d902
JMP 0x0018d8f9
LAB_0018d8f9:
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0018d98d
LAB_0018d902:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
ADD RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x10]
JBE 0x0018d987
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
ADD RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RCX + 0x18]
SUB RAX,0x1
MOV RCX,qword ptr [RBP + -0x10]
XOR EDX,EDX
DIV qword ptr [RCX + 0x18]
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
IMUL RCX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
LEA RAX,[0x50d4e0]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x10]
MOV ECX,0x10
CALL 0x0018b0e0
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JNZ 0x0018d985
JMP 0x0018d97f
LAB_0018d97f:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0018d98d
LAB_0018d985:
JMP 0x0018d987
LAB_0018d987:
JMP 0x0018d989
LAB_0018d989:
MOV byte ptr [RBP + -0x1],0x0
LAB_0018d98d:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 dynstr_realloc(long *param_1,long param_2)
{
long lVar1;
if ((param_2 != 0) && ((ulong)param_1[2] < (ulong)(param_1[1] + param_2))) {
param_1[2] = (((param_1[1] + param_2 + param_1[3]) - 1U) / (ulong)param_1[3]) * param_1[3];
lVar1 = my_realloc(key_memory_DYNAMIC_STRING,*param_1,param_1[2],0x10);
*param_1 = lVar1;
if (lVar1 == 0) {
return 1;
}
}
return 0;
}
| |
38,646 | inherit_charset_data | eloqsql/mysys/charset.c | static void
inherit_charset_data(struct charset_info_st *cs, CHARSET_INFO *refcs)
{
if (!cs->to_upper)
cs->to_upper= refcs->to_upper;
if (!cs->to_lower)
cs->to_lower= refcs->to_lower;
if (!cs->m_ctype)
cs->m_ctype= refcs->m_ctype;
if (!cs->tab_to_uni)
cs->tab_to_uni= refcs->tab_to_uni;
} | O3 | c | inherit_charset_data:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x50(%rdi)
jne 0x950b8
movq 0x50(%rsi), %rax
movq %rax, 0x50(%rdi)
cmpq $0x0, 0x48(%rdi)
jne 0x950c7
movq 0x48(%rsi), %rax
movq %rax, 0x48(%rdi)
cmpq $0x0, 0x40(%rdi)
jne 0x950d6
movq 0x40(%rsi), %rax
movq %rax, 0x40(%rdi)
cmpq $0x0, 0x68(%rdi)
jne 0x950e5
movq 0x68(%rsi), %rax
movq %rax, 0x68(%rdi)
popq %rbp
retq
nop
| inherit_charset_data:
push rbp
mov rbp, rsp
cmp qword ptr [rdi+50h], 0
jnz short loc_950B8
mov rax, [rsi+50h]
mov [rdi+50h], rax
loc_950B8:
cmp qword ptr [rdi+48h], 0
jnz short loc_950C7
mov rax, [rsi+48h]
mov [rdi+48h], rax
loc_950C7:
cmp qword ptr [rdi+40h], 0
jnz short loc_950D6
mov rax, [rsi+40h]
mov [rdi+40h], rax
loc_950D6:
cmp qword ptr [rdi+68h], 0
jnz short loc_950E5
mov rax, [rsi+68h]
mov [rdi+68h], rax
loc_950E5:
pop rbp
retn
| long long inherit_charset_data(_QWORD *a1, _QWORD *a2)
{
long long result; // rax
if ( !a1[10] )
{
result = a2[10];
a1[10] = result;
}
if ( !a1[9] )
{
result = a2[9];
a1[9] = result;
}
if ( !a1[8] )
{
result = a2[8];
a1[8] = result;
}
if ( !a1[13] )
{
result = a2[13];
a1[13] = result;
}
return result;
}
| inherit_charset_data:
PUSH RBP
MOV RBP,RSP
CMP qword ptr [RDI + 0x50],0x0
JNZ 0x001950b8
MOV RAX,qword ptr [RSI + 0x50]
MOV qword ptr [RDI + 0x50],RAX
LAB_001950b8:
CMP qword ptr [RDI + 0x48],0x0
JNZ 0x001950c7
MOV RAX,qword ptr [RSI + 0x48]
MOV qword ptr [RDI + 0x48],RAX
LAB_001950c7:
CMP qword ptr [RDI + 0x40],0x0
JNZ 0x001950d6
MOV RAX,qword ptr [RSI + 0x40]
MOV qword ptr [RDI + 0x40],RAX
LAB_001950d6:
CMP qword ptr [RDI + 0x68],0x0
JNZ 0x001950e5
MOV RAX,qword ptr [RSI + 0x68]
MOV qword ptr [RDI + 0x68],RAX
LAB_001950e5:
POP RBP
RET
|
void inherit_charset_data(long param_1,long param_2)
{
if (*(long *)(param_1 + 0x50) == 0) {
*(int8 *)(param_1 + 0x50) = *(int8 *)(param_2 + 0x50);
}
if (*(long *)(param_1 + 0x48) == 0) {
*(int8 *)(param_1 + 0x48) = *(int8 *)(param_2 + 0x48);
}
if (*(long *)(param_1 + 0x40) == 0) {
*(int8 *)(param_1 + 0x40) = *(int8 *)(param_2 + 0x40);
}
if (*(long *)(param_1 + 0x68) == 0) {
*(int8 *)(param_1 + 0x68) = *(int8 *)(param_2 + 0x68);
}
return;
}
| |
38,647 | Sp_handler::sp_load_for_information_schema(THD*, TABLE*, st_mysql_const_lex_string const&, st_mysql_const_lex_string const&, st_mysql_const_lex_string const&, st_mysql_const_lex_string const&, unsigned long long, bool*) const | eloqsql/sql/sp.cc | sp_head *
Sp_handler::sp_load_for_information_schema(THD *thd, TABLE *proc_table,
const LEX_CSTRING &db,
const LEX_CSTRING &name,
const LEX_CSTRING ¶ms,
const LEX_CSTRING &returns,
sql_mode_t sql_mode,
bool *free_sp_head) const
{
String defstr;
const AUTHID definer= {{STRING_WITH_LEN("")}, {STRING_WITH_LEN("")}};
sp_head *sp;
sp_cache **spc= get_cache(thd);
sp_name sp_name_obj(&db, &name, true); // This can change "name"
*free_sp_head= 0;
if ((sp= sp_cache_lookup(spc, &sp_name_obj)))
{
return sp;
}
LEX *old_lex= thd->lex, newlex;
Stored_program_creation_ctx *creation_ctx=
Stored_routine_creation_ctx::load_from_db(thd, &sp_name_obj, proc_table);
defstr.set_charset(creation_ctx->get_client_cs());
if (show_create_sp(thd, &defstr,
sp_name_obj.m_db, sp_name_obj.m_name,
params, returns, empty_body_lex_cstring(sql_mode),
Sp_chistics(), definer, DDL_options(), sql_mode))
return 0;
thd->lex= &newlex;
newlex.current_select= NULL;
sp= sp_compile(thd, &defstr, sql_mode, NULL, creation_ctx);
*free_sp_head= 1;
thd->lex->sphead= NULL;
lex_end(thd->lex);
thd->lex= old_lex;
return sp;
} | O0 | cpp | Sp_handler::sp_load_for_information_schema(THD*, TABLE*, st_mysql_const_lex_string const&, st_mysql_const_lex_string const&, st_mysql_const_lex_string const&, st_mysql_const_lex_string const&, unsigned long long, bool*) const:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x1d68, %rsp # imm = 0x1D68
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %fs:0x28, %rax
movq %rax, -0x10(%rbp)
movq %rdi, -0x1be0(%rbp)
movq %rsi, -0x1be8(%rbp)
movq %rdx, -0x1bf0(%rbp)
movq %rcx, -0x1bf8(%rbp)
movq %r8, -0x1c00(%rbp)
movq %r9, -0x1c08(%rbp)
movq -0x1be0(%rbp), %rax
movq %rax, -0x1cc8(%rbp)
leaq -0x1c28(%rbp), %rdi
callq 0x49c930
movq -0x1cc8(%rbp), %rdi
movups 0x943349(%rip), %xmm0 # 0x13b03a0
movaps %xmm0, -0x1c40(%rbp)
movups 0x94332b(%rip), %xmm0 # 0x13b0390
movaps %xmm0, -0x1c50(%rbp)
movq -0x1be8(%rbp), %rsi
movq (%rdi), %rax
movq 0x58(%rax), %rax
callq *%rax
movq %rax, -0x1cc0(%rbp)
jmp 0xa6d085
movq -0x1cc0(%rbp), %rax
movq %rax, -0x1c60(%rbp)
movq -0x1bf8(%rbp), %rsi
movq -0x1c00(%rbp), %rdx
leaq -0x38(%rbp), %rdi
movl $0x1, %ecx
callq 0x5a2440
jmp 0xa6d0b1
movq 0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x1c60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4d41b0
movq %rax, -0x1cd0(%rbp)
jmp 0xa6d0d1
movq -0x1cd0(%rbp), %rax
movq %rax, -0x1c58(%rbp)
cmpq $0x0, %rax
je 0xa6d130
movq -0x1c58(%rbp), %rax
movq %rax, -0x1bd8(%rbp)
movl $0x1, -0x1c70(%rbp)
jmp 0xa6d3d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c68(%rbp)
movl %eax, -0x1c6c(%rbp)
jmp 0xa6d41f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c68(%rbp)
movl %eax, -0x1c6c(%rbp)
jmp 0xa6d416
movq -0x1be8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x1c78(%rbp)
leaq -0x1bd0(%rbp), %rdi
callq 0x587980
jmp 0xa6d150
movq -0x1be8(%rbp), %rdi
movq -0x1bf0(%rbp), %rdx
leaq -0x38(%rbp), %rsi
callq 0xa660b0
movq %rax, -0x1cd8(%rbp)
jmp 0xa6d170
movq -0x1cd8(%rbp), %rax
movq %rax, -0x1c80(%rbp)
movq -0x1c80(%rbp), %rdi
callq 0x4e4590
movq %rax, -0x1ce0(%rbp)
jmp 0xa6d193
movq -0x1ce0(%rbp), %rsi
leaq -0x1c28(%rbp), %rdi
callq 0x49e350
jmp 0xa6d1a8
movq -0x1cc8(%rbp), %rdi
movq -0x1be8(%rbp), %rax
movq %rax, -0x1d18(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x1d10(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x1d08(%rbp)
movq -0x1c08(%rbp), %rax
movq %rax, -0x1d00(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x1cf8(%rbp)
movq 0x18(%rbp), %rsi
movq (%rdi), %rax
movq 0x40(%rax), %rax
callq *%rax
movq %rdx, -0x1cf0(%rbp)
movq %rax, -0x1ce8(%rbp)
jmp 0xa6d209
movq -0x1cf0(%rbp), %rax
movq -0x1ce8(%rbp), %rcx
movq %rcx, -0x1c90(%rbp)
movq %rax, -0x1c88(%rbp)
leaq -0x1cb0(%rbp), %rdi
callq 0x4e2f40
jmp 0xa6d233
leaq -0x1cb8(%rbp), %rdi
callq 0x566340
jmp 0xa6d241
movq -0x1d00(%rbp), %r9
movq -0x1d08(%rbp), %r8
movq -0x1d10(%rbp), %rcx
movq -0x1d18(%rbp), %rsi
movq -0x1cc8(%rbp), %rdi
movq -0x1cf8(%rbp), %r10
movl -0x1cb8(%rbp), %eax
movl %eax, -0x1cb4(%rbp)
movq 0x18(%rbp), %rbx
movl -0x1cb4(%rbp), %r11d
movq (%rdi), %rax
movq 0x98(%rax), %rax
movq %rsp, %rdx
movq %rbx, 0x28(%rdx)
movl %r11d, 0x20(%rdx)
leaq -0x1c50(%rbp), %r11
movq %r11, 0x18(%rdx)
leaq -0x1cb0(%rbp), %r11
movq %r11, 0x10(%rdx)
leaq -0x1c90(%rbp), %r11
movq %r11, 0x8(%rdx)
movq %r10, (%rdx)
leaq -0x1c28(%rbp), %rdx
callq *%rax
movb %al, -0x1d19(%rbp)
jmp 0xa6d2cc
movb -0x1d19(%rbp), %al
testb $0x1, %al
jne 0xa6d2d8
jmp 0xa6d315
movq $0x0, -0x1bd8(%rbp)
movl $0x1, -0x1c70(%rbp)
jmp 0xa6d3c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c68(%rbp)
movl %eax, -0x1c6c(%rbp)
leaq -0x1bd0(%rbp), %rdi
callq 0x4e7440
jmp 0xa6d416
movq -0x1be8(%rbp), %rax
leaq -0x1bd0(%rbp), %rcx
movq %rcx, 0x58(%rax)
movq $0x0, -0xea8(%rbp)
movq -0x1be8(%rbp), %rdi
movq 0x18(%rbp), %rdx
movq -0x1c80(%rbp), %r8
xorl %eax, %eax
movl %eax, %ecx
leaq -0x1c28(%rbp), %rsi
callq 0xa676c0
movq %rax, -0x1d28(%rbp)
jmp 0xa6d35d
movq -0x1d28(%rbp), %rax
movq %rax, -0x1c58(%rbp)
movq 0x20(%rbp), %rax
movb $0x1, (%rax)
movq -0x1be8(%rbp), %rax
movq 0x58(%rax), %rax
movq $0x0, 0x1960(%rax)
movq -0x1be8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x5809e0
jmp 0xa6d39a
movq -0x1c78(%rbp), %rcx
movq -0x1be8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x1c58(%rbp), %rax
movq %rax, -0x1bd8(%rbp)
movl $0x1, -0x1c70(%rbp)
leaq -0x1bd0(%rbp), %rdi
callq 0x4e7440
leaq -0x38(%rbp), %rdi
callq 0xa6d910
leaq -0x1c28(%rbp), %rdi
callq 0x49c9b0
movq -0x1bd8(%rbp), %rax
movq %rax, -0x1d30(%rbp)
movq %fs:0x28, %rax
movq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jne 0xa6d457
movq -0x1d30(%rbp), %rax
addq $0x1d68, %rsp # imm = 0x1D68
popq %rbx
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0xa6d910
leaq -0x1c28(%rbp), %rdi
callq 0x49c9b0
movq -0x1c68(%rbp), %rax
movq %rax, -0x1d38(%rbp)
movq %fs:0x28, %rax
movq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jne 0xa6d457
movq -0x1d38(%rbp), %rdi
callq 0x433ff0
callq 0x433650
nopl (%rax)
| _ZNK10Sp_handler30sp_load_for_information_schemaEP3THDP5TABLERK25st_mysql_const_lex_stringS6_S6_S6_yPb:
push rbp
mov rbp, rsp
push rbx
sub rsp, 1D68h
mov rax, [rbp+arg_10]
mov rax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov rax, fs:28h
mov [rbp+var_10], rax
mov [rbp+var_1BE0], rdi
mov [rbp+var_1BE8], rsi
mov [rbp+var_1BF0], rdx
mov [rbp+var_1BF8], rcx
mov [rbp+var_1C00], r8
mov [rbp+var_1C08], r9
mov rax, [rbp+var_1BE0]
mov [rbp+var_1CC8], rax
lea rdi, [rbp+var_1C28]; this
call _ZN6StringC2Ev; String::String(void)
mov rdi, [rbp+var_1CC8]
movups xmm0, xmmword ptr cs:off_13B03A0
movaps [rbp+var_1C40], xmm0
movups xmm0, xmmword ptr cs:off_13B0390
movaps [rbp+var_1C50], xmm0
mov rsi, [rbp+var_1BE8]
mov rax, [rdi]
mov rax, [rax+58h]
call rax
mov [rbp+var_1CC0], rax
jmp short $+2
loc_A6D085:
mov rax, [rbp+var_1CC0]
mov [rbp+var_1C60], rax
mov rsi, [rbp+var_1BF8]
mov rdx, [rbp+var_1C00]
lea rdi, [rbp+var_38]
mov ecx, 1
call _ZN7sp_nameC2EPK25st_mysql_const_lex_stringS2_b; sp_name::sp_name(st_mysql_const_lex_string const*,st_mysql_const_lex_string const*,bool)
jmp short $+2
loc_A6D0B1:
mov rax, [rbp+arg_10]
mov byte ptr [rax], 0
mov rdi, [rbp+var_1C60]; sp_cache **
lea rsi, [rbp+var_38]; Database_qualified_name *
call _Z15sp_cache_lookupPP8sp_cachePK23Database_qualified_name; sp_cache_lookup(sp_cache **,Database_qualified_name const*)
mov [rbp+var_1CD0], rax
jmp short $+2
loc_A6D0D1:
mov rax, [rbp+var_1CD0]
mov [rbp+var_1C58], rax
cmp rax, 0
jz short loc_A6D130
mov rax, [rbp+var_1C58]
mov [rbp+var_1BD8], rax
mov [rbp+var_1C70], 1
jmp loc_A6D3D0
mov rcx, rax
mov eax, edx
mov [rbp+var_1C68], rcx
mov [rbp+var_1C6C], eax
jmp loc_A6D41F
mov rcx, rax
mov eax, edx
mov [rbp+var_1C68], rcx
mov [rbp+var_1C6C], eax
jmp loc_A6D416
loc_A6D130:
mov rax, [rbp+var_1BE8]
mov rax, [rax+58h]
mov [rbp+var_1C78], rax
lea rdi, [rbp+var_1BD0]; this
call _ZN3LEXC2Ev; LEX::LEX(void)
jmp short $+2
loc_A6D150:
mov rdi, [rbp+var_1BE8]; this
mov rdx, [rbp+var_1BF0]; Database_qualified_name *
lea rsi, [rbp+var_38]; THD *
call _ZN27Stored_routine_creation_ctx12load_from_dbEP3THDPK23Database_qualified_nameP5TABLE; Stored_routine_creation_ctx::load_from_db(THD *,Database_qualified_name const*,TABLE *)
mov [rbp+var_1CD8], rax
jmp short $+2
loc_A6D170:
mov rax, [rbp+var_1CD8]
mov [rbp+var_1C80], rax
mov rdi, [rbp+var_1C80]; this
call _ZN27Default_object_creation_ctx13get_client_csEv; Default_object_creation_ctx::get_client_cs(void)
mov [rbp+var_1CE0], rax
jmp short $+2
loc_A6D193:
mov rsi, [rbp+var_1CE0]; charset_info_st *
lea rdi, [rbp+var_1C28]; this
call _ZN7Charset11set_charsetEPK15charset_info_st; Charset::set_charset(charset_info_st const*)
jmp short $+2
loc_A6D1A8:
mov rdi, [rbp+var_1CC8]
mov rax, [rbp+var_1BE8]
mov [rbp+var_1D18], rax
lea rax, [rbp+var_38]
mov [rbp+var_1D10], rax
lea rax, [rbp+var_28]
mov [rbp+var_1D08], rax
mov rax, [rbp+var_1C08]
mov [rbp+var_1D00], rax
mov rax, [rbp+arg_0]
mov [rbp+var_1CF8], rax
mov rsi, [rbp+arg_8]
mov rax, [rdi]
mov rax, [rax+40h]
call rax
mov [rbp+var_1CF0], rdx
mov [rbp+var_1CE8], rax
jmp short $+2
loc_A6D209:
mov rax, [rbp+var_1CF0]
mov rcx, [rbp+var_1CE8]
mov [rbp+var_1C90], rcx
mov [rbp+var_1C88], rax
lea rdi, [rbp+var_1CB0]; this
call _ZN11Sp_chisticsC2Ev; Sp_chistics::Sp_chistics(void)
jmp short $+2
loc_A6D233:
lea rdi, [rbp+var_1CB8]; this
call _ZN11DDL_optionsC2Ev; DDL_options::DDL_options(void)
jmp short $+2
loc_A6D241:
mov r9, [rbp+var_1D00]
mov r8, [rbp+var_1D08]
mov rcx, [rbp+var_1D10]
mov rsi, [rbp+var_1D18]
mov rdi, [rbp+var_1CC8]
mov r10, [rbp+var_1CF8]
mov eax, [rbp+var_1CB8]
mov [rbp+var_1CB4], eax
mov rbx, [rbp+arg_8]
mov r11d, [rbp+var_1CB4]
mov rax, [rdi]
mov rax, [rax+98h]
mov rdx, rsp
mov [rdx+28h], rbx
mov [rdx+20h], r11d
lea r11, [rbp+var_1C50]
mov [rdx+18h], r11
lea r11, [rbp+var_1CB0]
mov [rdx+10h], r11
lea r11, [rbp+var_1C90]
mov [rdx+8], r11
mov [rdx], r10
lea rdx, [rbp+var_1C28]
call rax
mov [rbp+var_1D19], al
jmp short $+2
loc_A6D2CC:
mov al, [rbp+var_1D19]
test al, 1
jnz short loc_A6D2D8
jmp short loc_A6D315
loc_A6D2D8:
mov [rbp+var_1BD8], 0
mov [rbp+var_1C70], 1
jmp loc_A6D3C4
mov rcx, rax
mov eax, edx
mov [rbp+var_1C68], rcx
mov [rbp+var_1C6C], eax
lea rdi, [rbp+var_1BD0]; this
call _ZN3LEXD2Ev; LEX::~LEX()
jmp loc_A6D416
loc_A6D315:
mov rax, [rbp+var_1BE8]
lea rcx, [rbp+var_1BD0]
mov [rax+58h], rcx
mov [rbp+var_EA8], 0
mov rdi, [rbp+var_1BE8]; THD *
mov rdx, [rbp+arg_8]; unsigned __int64
mov r8, [rbp+var_1C80]; Stored_program_creation_ctx *
xor eax, eax
mov ecx, eax; sp_package *
lea rsi, [rbp+var_1C28]; String *
call _ZL10sp_compileP3THDP6StringyP10sp_packageP27Stored_program_creation_ctx; sp_compile(THD *,String *,ulong long,sp_package *,Stored_program_creation_ctx *)
mov [rbp+var_1D28], rax
jmp short $+2
loc_A6D35D:
mov rax, [rbp+var_1D28]
mov [rbp+var_1C58], rax
mov rax, [rbp+arg_10]
mov byte ptr [rax], 1
mov rax, [rbp+var_1BE8]
mov rax, [rax+58h]
mov qword ptr [rax+1960h], 0
mov rax, [rbp+var_1BE8]
mov rdi, [rax+58h]; LEX *
call _Z7lex_endP3LEX; lex_end(LEX *)
jmp short $+2
loc_A6D39A:
mov rcx, [rbp+var_1C78]
mov rax, [rbp+var_1BE8]
mov [rax+58h], rcx
mov rax, [rbp+var_1C58]
mov [rbp+var_1BD8], rax
mov [rbp+var_1C70], 1
loc_A6D3C4:
lea rdi, [rbp+var_1BD0]; this
call _ZN3LEXD2Ev; LEX::~LEX()
loc_A6D3D0:
lea rdi, [rbp+var_38]; this
call _ZN7sp_nameD2Ev; sp_name::~sp_name()
lea rdi, [rbp+var_1C28]; void *
call _ZN6StringD2Ev; String::~String()
mov rax, [rbp+var_1BD8]
mov [rbp+var_1D30], rax
mov rax, fs:28h
mov rcx, [rbp+var_10]
cmp rax, rcx
jnz short loc_A6D457
mov rax, [rbp+var_1D30]
add rsp, 1D68h
pop rbx
pop rbp
retn
loc_A6D416:
lea rdi, [rbp+var_38]; this
call _ZN7sp_nameD2Ev; sp_name::~sp_name()
loc_A6D41F:
lea rdi, [rbp+var_1C28]; void *
call _ZN6StringD2Ev; String::~String()
mov rax, [rbp+var_1C68]
mov [rbp+var_1D38], rax
mov rax, fs:28h
mov rcx, [rbp+var_10]
cmp rax, rcx
jnz short loc_A6D457
mov rdi, [rbp+var_1D38]
call __Unwind_Resume
loc_A6D457:
call ___stack_chk_fail
| sp_head * Sp_handler::sp_load_for_information_schema(
long long a1,
Stored_routine_creation_ctx *a2,
Database_qualified_name *a3,
_QWORD *a4,
_QWORD *a5,
long long a6,
long long a7,
unsigned long long a8,
_BYTE *a9)
{
TABLE *v9; // rcx
long long v10; // rdx
Stored_routine_creation_ctx *v12; // [rsp+58h] [rbp-1D18h]
long long v13; // [rsp+70h] [rbp-1D00h]
charset_info_st *client_cs; // [rsp+90h] [rbp-1CE0h]
_DWORD v15[2]; // [rsp+B8h] [rbp-1CB8h] BYREF
_BYTE v16[32]; // [rsp+C0h] [rbp-1CB0h] BYREF
_QWORD v17[2]; // [rsp+E0h] [rbp-1C90h] BYREF
Default_object_creation_ctx *v18; // [rsp+F0h] [rbp-1C80h]
long long v19; // [rsp+F8h] [rbp-1C78h]
int v20; // [rsp+100h] [rbp-1C70h]
sp_cache **v21; // [rsp+110h] [rbp-1C60h]
sp_head *v22; // [rsp+118h] [rbp-1C58h]
_OWORD v23[2]; // [rsp+120h] [rbp-1C50h] BYREF
char v24[32]; // [rsp+148h] [rbp-1C28h] BYREF
long long v25; // [rsp+168h] [rbp-1C08h]
_QWORD *v26; // [rsp+170h] [rbp-1C00h]
_QWORD *v27; // [rsp+178h] [rbp-1BF8h]
Database_qualified_name *v28; // [rsp+180h] [rbp-1BF0h]
Stored_routine_creation_ctx *v29; // [rsp+188h] [rbp-1BE8h]
long long v30; // [rsp+190h] [rbp-1BE0h]
sp_head *v31; // [rsp+198h] [rbp-1BD8h]
_BYTE v32[3368]; // [rsp+1A0h] [rbp-1BD0h] BYREF
long long v33; // [rsp+EC8h] [rbp-EA8h]
_QWORD v34[2]; // [rsp+1D38h] [rbp-38h] BYREF
char v35[24]; // [rsp+1D48h] [rbp-28h] BYREF
unsigned long long v36; // [rsp+1D60h] [rbp-10h]
v36 = __readfsqword(0x28u);
v30 = a1;
v29 = a2;
v28 = a3;
v27 = a4;
v26 = a5;
v25 = a6;
String::String((String *)v24);
v23[1] = *(_OWORD *)off_13B03A0;
v23[0] = *(_OWORD *)off_13B0390;
v21 = (sp_cache **)(*(long long ( **)(long long, Stored_routine_creation_ctx *))(*(_QWORD *)a1 + 88LL))(a1, v29);
sp_name::sp_name(v34, v27, v26, 1);
*a9 = 0;
v22 = (sp_head *)sp_cache_lookup(v21, (const Database_qualified_name *)v34);
if ( v22 )
{
v31 = v22;
v20 = 1;
}
else
{
v19 = *((_QWORD *)v29 + 11);
LEX::LEX((LEX *)v32);
v18 = Stored_routine_creation_ctx::load_from_db(v29, (THD *)v34, v28, v9);
client_cs = (charset_info_st *)Default_object_creation_ctx::get_client_cs(v18);
Charset::set_charset((Charset *)v24, client_cs);
v12 = v29;
v13 = v25;
v17[0] = (*(long long ( **)(long long, unsigned long long))(*(_QWORD *)a1 + 64LL))(a1, a8);
v17[1] = v10;
Sp_chistics::Sp_chistics((Sp_chistics *)v16);
DDL_options::DDL_options((DDL_options *)v15);
v15[1] = v15[0];
if ( ((*(long long ( **)(long long, Stored_routine_creation_ctx *, char *, _QWORD *, char *, long long, long long, _QWORD *, _BYTE *, _OWORD *, _DWORD, unsigned long long))(*(_QWORD *)a1 + 152LL))(
a1,
v12,
v24,
v34,
v35,
v13,
a7,
v17,
v16,
v23,
v15[0],
a8) & 1) != 0 )
{
v31 = 0LL;
}
else
{
*((_QWORD *)v29 + 11) = v32;
v33 = 0LL;
v22 = sp_compile(v29, (String *)v24, a8, 0LL, v18);
*a9 = 1;
*(_QWORD *)(*((_QWORD *)v29 + 11) + 6496LL) = 0LL;
lex_end(*((LEX **)v29 + 11));
*((_QWORD *)v29 + 11) = v19;
v31 = v22;
}
v20 = 1;
LEX::~LEX((LEX *)v32);
}
sp_name::~sp_name((sp_name *)v34);
String::~String(v24);
return v31;
}
| ~Item_func_get_user_var:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,-0xc8
POP RBP
JMP 0x00a6cec0
|
/* non-virtual thunk to Item_func_get_user_var::~Item_func_get_user_var() */
void __thiscall Item_func_get_user_var::~Item_func_get_user_var(Item_func_get_user_var *this)
{
~Item_func_get_user_var(this + -200);
return;
}
| |
38,648 | int10_to_str | eloqsql/strings/int2str.c | char *int10_to_str(long int val,char *dst,int radix)
{
char buffer[65];
register char *p;
long int new_val;
unsigned long int uval = (unsigned long int) val;
if (radix < 0) /* -10 */
{
if (val < 0)
{
*dst++ = '-';
/* Avoid integer overflow in (-val) for LONGLONG_MIN (BUG#31799). */
uval = (unsigned long int)0 - uval;
}
}
p = &buffer[sizeof(buffer)-1];
*p = '\0';
new_val= (long) (uval / 10);
*--p = '0'+ (char) (uval - (unsigned long) new_val * 10);
val = new_val;
while (val != 0)
{
new_val=val/10;
*--p = '0' + (char) (val-new_val*10);
val= new_val;
}
while ((*dst++ = *p++) != 0) ;
return dst-1;
} | O3 | c | int10_to_str:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
testl %edx, %edx
setns %al
testq %rdi, %rdi
setns %cl
orb %al, %cl
jne 0x5dba7
movb $0x2d, (%rsi)
incq %rsi
negq %rdi
leaq -0x11(%rbp), %r8
movabsq $-0x3333333333333333, %r9 # imm = 0xCCCCCCCCCCCCCCCD
movq %rdi, %rax
mulq %r9
movq %rdx, %rcx
movb $0x0, 0x1(%r8)
shrq $0x3, %rcx
imull $0xf6, %ecx, %eax
addl %edi, %eax
addb $0x30, %al
movb %al, (%r8)
cmpq $0xa, %rdi
jb 0x5dbfe
movq %rcx, %rax
mulq %r9
shrq $0x3, %rdx
imull $0xf6, %edx, %eax
addl %ecx, %eax
addb $0x30, %al
movb %al, -0x1(%r8)
decq %r8
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0x5dbda
decq %rsi
movb (%r8), %al
incq %r8
movb %al, 0x1(%rsi)
incq %rsi
testb %al, %al
jne 0x5dc01
movq %fs:0x28, %rax
cmpq -0x8(%rbp), %rax
jne 0x5dc29
movq %rsi, %rax
addq $0x50, %rsp
popq %rbp
retq
callq 0x24400
nop
| int10_to_str:
push rbp
mov rbp, rsp
sub rsp, 50h
mov rax, fs:28h
mov [rbp+var_8], rax
test edx, edx
setns al
test rdi, rdi
setns cl
or cl, al
jnz short loc_5DBA7
mov byte ptr [rsi], 2Dh ; '-'
inc rsi
neg rdi
loc_5DBA7:
lea r8, [rbp+var_11]
mov r9, 0CCCCCCCCCCCCCCCDh
mov rax, rdi
mul r9
mov rcx, rdx
mov byte ptr [r8+1], 0
shr rcx, 3
imul eax, ecx, 0F6h
add eax, edi
add al, 30h ; '0'
mov [r8], al
cmp rdi, 0Ah
jb short loc_5DBFE
loc_5DBDA:
mov rax, rcx
mul r9
shr rdx, 3
imul eax, edx, 0F6h
add eax, ecx
add al, 30h ; '0'
mov [r8-1], al
dec r8
cmp rcx, 9
mov rcx, rdx
ja short loc_5DBDA
loc_5DBFE:
dec rsi
loc_5DC01:
mov al, [r8]
inc r8
mov [rsi+1], al
inc rsi
test al, al
jnz short loc_5DC01
mov rax, fs:28h
cmp rax, [rbp+var_8]
jnz short loc_5DC29
mov rax, rsi
add rsp, 50h
pop rbp
retn
loc_5DC29:
call ___stack_chk_fail
| _BYTE * int10_to_str(unsigned long long a1, _BYTE *a2, int a3)
{
char *v3; // r8
unsigned long long v4; // rcx
bool v5; // cc
_BYTE *v6; // rsi
char v7; // al
_BYTE v9[9]; // [rsp+3Fh] [rbp-11h] BYREF
unsigned long long v10; // [rsp+48h] [rbp-8h]
v10 = __readfsqword(0x28u);
if ( a3 < 0 && (a1 & 0x8000000000000000LL) != 0LL )
{
*a2++ = 45;
a1 = -(long long)a1;
}
v3 = v9;
v9[1] = 0;
v4 = a1 / 0xA;
v9[0] = a1 % 0xA + 48;
if ( a1 >= 0xA )
{
do
{
*--v3 = v4 % 0xA + 48;
v5 = v4 <= 9;
v4 /= 0xAuLL;
}
while ( !v5 );
}
v6 = a2 - 1;
do
{
v7 = *v3++;
*++v6 = v7;
}
while ( v7 );
return v6;
}
| int10_to_str:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
TEST EDX,EDX
SETNS AL
TEST RDI,RDI
SETNS CL
OR CL,AL
JNZ 0x0015dba7
MOV byte ptr [RSI],0x2d
INC RSI
NEG RDI
LAB_0015dba7:
LEA R8,[RBP + -0x11]
MOV R9,-0x3333333333333333
MOV RAX,RDI
MUL R9
MOV RCX,RDX
MOV byte ptr [R8 + 0x1],0x0
SHR RCX,0x3
IMUL EAX,ECX,0xf6
ADD EAX,EDI
ADD AL,0x30
MOV byte ptr [R8],AL
CMP RDI,0xa
JC 0x0015dbfe
LAB_0015dbda:
MOV RAX,RCX
MUL R9
SHR RDX,0x3
IMUL EAX,EDX,0xf6
ADD EAX,ECX
ADD AL,0x30
MOV byte ptr [R8 + -0x1],AL
DEC R8
CMP RCX,0x9
MOV RCX,RDX
JA 0x0015dbda
LAB_0015dbfe:
DEC RSI
LAB_0015dc01:
MOV AL,byte ptr [R8]
INC R8
MOV byte ptr [RSI + 0x1],AL
INC RSI
TEST AL,AL
JNZ 0x0015dc01
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x8]
JNZ 0x0015dc29
MOV RAX,RSI
ADD RSP,0x50
POP RBP
RET
LAB_0015dc29:
CALL 0x00124400
|
int1 * int10_to_str(ulong param_1,int1 *param_2,int param_3)
{
char cVar1;
ulong uVar2;
ulong uVar3;
char *pcVar4;
long in_FS_OFFSET;
char local_1a [10];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if ((long)param_1 < 0 && param_3 < 0) {
*param_2 = 0x2d;
param_2 = param_2 + 1;
param_1 = -param_1;
}
pcVar4 = local_1a + 1;
local_1a[2] = 0;
local_1a[1] = (char)(param_1 / 10) * -10 + (char)param_1 + '0';
uVar3 = param_1 / 10;
while (uVar2 = uVar3, 9 < param_1) {
pcVar4[-1] = (char)(uVar2 / 10) * -10 + (char)uVar2 + '0';
pcVar4 = pcVar4 + -1;
uVar3 = uVar2 / 10;
param_1 = uVar2;
}
param_2 = param_2 + -1;
do {
cVar1 = *pcVar4;
pcVar4 = pcVar4 + 1;
param_2[1] = cVar1;
param_2 = param_2 + 1;
} while (cVar1 != '\0');
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_2;
}
| |
38,649 | mi_find_writepos | eloqsql/storage/myisam/mi_dynrec.c | static int _mi_find_writepos(MI_INFO *info,
ulong reclength, /* record length */
my_off_t *filepos, /* Return file pos */
ulong *length) /* length of block at filepos */
{
MI_BLOCK_INFO block_info;
ulong tmp;
DBUG_ENTER("_mi_find_writepos");
if (info->s->state.dellink != HA_OFFSET_ERROR &&
!info->append_insert_at_end)
{
/* Deleted blocks exists; Get last used block */
*filepos=info->s->state.dellink;
block_info.second_read=0;
info->rec_cache.seek_not_done=1;
if (!(_mi_get_block_info(&block_info,info->dfile,info->s->state.dellink) &
BLOCK_DELETED))
{
DBUG_PRINT("error",("Delete link crashed"));
my_errno=HA_ERR_WRONG_IN_RECORD;
DBUG_RETURN(-1);
}
info->s->state.dellink=block_info.next_filepos;
info->state->del--;
info->state->empty-= block_info.block_len;
*length= block_info.block_len;
}
else
{
/* No deleted blocks; Allocate a new block */
*filepos=info->state->data_file_length;
if ((tmp= reclength + 3 + MY_TEST(reclength >= (65520 - 3))) <
info->s->base.min_block_length)
tmp= info->s->base.min_block_length;
else
tmp= ((tmp+MI_DYN_ALIGN_SIZE-1) &
(~ (ulong) (MI_DYN_ALIGN_SIZE-1)));
if (info->state->data_file_length >
(info->s->base.max_data_file_length - tmp))
{
my_errno=HA_ERR_RECORD_FILE_FULL;
DBUG_RETURN(-1);
}
if (tmp > MI_MAX_BLOCK_LENGTH)
tmp=MI_MAX_BLOCK_LENGTH;
*length= tmp;
info->state->data_file_length+= tmp;
info->s->state.split++;
info->update|=HA_STATE_WRITE_AT_END;
}
DBUG_RETURN(0);
} | O3 | c | mi_find_writepos:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rcx, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
movq (%rdi), %rax
movq 0x58(%rax), %rax
cmpq $-0x1, %rax
je 0x7adc6
cmpb $0x0, 0x33a(%r14)
je 0x7ae42
movq 0x8(%r14), %rax
movq 0x28(%rax), %rax
movq %rax, (%rdx)
cmpq $0xffed, %rsi # imm = 0xFFED
sbbq $-0x1, %rsi
leaq 0x3(%rsi), %rax
movq (%r14), %rcx
movq 0x8(%r14), %rdx
movq 0x160(%rcx), %rdi
addq $0x6, %rsi
andq $-0x4, %rsi
cmpq %rdi, %rax
cmovbq %rdi, %rsi
movq 0x110(%rcx), %rax
subq %rsi, %rax
cmpq %rax, 0x28(%rdx)
jbe 0x7ae1a
callq 0xa2a4e
movl $0x87, (%rax)
jmp 0x7ae7d
movl $0xfffffc, %eax # imm = 0xFFFFFC
cmpq %rax, %rsi
cmovbq %rsi, %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rcx
addq %rax, 0x28(%rcx)
movq (%r14), %rax
incq 0x50(%rax)
orb $0x1, 0x1d1(%r14)
jmp 0x7aeaa
movq %rax, (%rdx)
leaq -0x70(%rbp), %rdi
movl $0x0, 0x50(%rdi)
movl $0x1, 0x300(%r14)
movl 0x1c0(%r14), %esi
movq (%r14), %rax
movq 0x58(%rax), %rdx
callq 0x7933f
testb $0x4, %al
jne 0x7ae84
callq 0xa2a4e
movl $0x7f, (%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x7aeac
movq -0x30(%rbp), %rax
movq (%r14), %rcx
movq %rax, 0x58(%rcx)
movq 0x8(%r14), %rax
decq 0x8(%rax)
movq -0x48(%rbp), %rax
movq 0x8(%r14), %rcx
subq %rax, 0x10(%rcx)
movq -0x48(%rbp), %rax
movq %rax, (%rbx)
xorl %eax, %eax
movq %fs:0x28, %rcx
cmpq -0x18(%rbp), %rcx
jne 0x7aec4
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x29270
nopl (%rax)
| _mi_find_writepos:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 60h
mov rbx, rcx
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_18], rax
mov rax, [rdi]
mov rax, [rax+58h]
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_7ADC6
cmp byte ptr [r14+33Ah], 0
jz short loc_7AE42
loc_7ADC6:
mov rax, [r14+8]
mov rax, [rax+28h]
mov [rdx], rax
cmp rsi, 0FFEDh
sbb rsi, 0FFFFFFFFFFFFFFFFh
lea rax, [rsi+3]
mov rcx, [r14]
mov rdx, [r14+8]
mov rdi, [rcx+160h]
add rsi, 6
and rsi, 0FFFFFFFFFFFFFFFCh
cmp rax, rdi
cmovb rsi, rdi
mov rax, [rcx+110h]
sub rax, rsi
cmp [rdx+28h], rax
jbe short loc_7AE1A
call _my_thread_var
mov dword ptr [rax], 87h
jmp short loc_7AE7D
loc_7AE1A:
mov eax, 0FFFFFCh
cmp rsi, rax
cmovb rax, rsi
mov [rbx], rax
mov rcx, [r14+8]
add [rcx+28h], rax
mov rax, [r14]
inc qword ptr [rax+50h]
or byte ptr [r14+1D1h], 1
jmp short loc_7AEAA
loc_7AE42:
mov [rdx], rax
lea rdi, [rbp+var_70]
mov dword ptr [rdi+50h], 0
mov dword ptr [r14+300h], 1
mov esi, [r14+1C0h]
mov rax, [r14]
mov rdx, [rax+58h]
call _mi_get_block_info
test al, 4
jnz short loc_7AE84
call _my_thread_var
mov dword ptr [rax], 7Fh
loc_7AE7D:
mov eax, 0FFFFFFFFh
jmp short loc_7AEAC
loc_7AE84:
mov rax, [rbp+var_30]
mov rcx, [r14]
mov [rcx+58h], rax
mov rax, [r14+8]
dec qword ptr [rax+8]
mov rax, [rbp+var_48]
mov rcx, [r14+8]
sub [rcx+10h], rax
mov rax, [rbp+var_48]
mov [rbx], rax
loc_7AEAA:
xor eax, eax
loc_7AEAC:
mov rcx, fs:28h
cmp rcx, [rbp+var_18]
jnz short loc_7AEC4
add rsp, 60h
pop rbx
pop r14
pop rbp
retn
loc_7AEC4:
call ___stack_chk_fail
| long long mi_find_writepos(_QWORD *a1, unsigned long long a2, _QWORD *a3, long long *a4)
{
long long v6; // rax
unsigned long long v7; // rsi
unsigned long long v8; // rax
long long v9; // rcx
long long v10; // rdx
unsigned long long v11; // rdi
const char *v12; // rsi
long long v13; // rax
unsigned long long v14; // rsi
_BYTE v16[40]; // [rsp+0h] [rbp-70h] BYREF
long long v17; // [rsp+28h] [rbp-48h]
long long v18; // [rsp+40h] [rbp-30h]
int v19; // [rsp+50h] [rbp-20h]
unsigned long long v20; // [rsp+58h] [rbp-18h]
v20 = __readfsqword(0x28u);
v6 = *(_QWORD *)(*a1 + 88LL);
if ( v6 == -1 || *((_BYTE *)a1 + 826) )
{
*a3 = *(_QWORD *)(a1[1] + 40LL);
v7 = a2 - ((a2 < 0xFFED) - 1LL);
v8 = v7 + 3;
v9 = *a1;
v10 = a1[1];
v11 = *(_QWORD *)(*a1 + 352LL);
v12 = (const char *)((v7 + 6) & 0xFFFFFFFFFFFFFFFCLL);
if ( v8 < v11 )
v12 = *(const char **)(*a1 + 352LL);
if ( *(_QWORD *)(v10 + 40) > *(_QWORD *)(v9 + 272) - (_QWORD)v12 )
{
*(_DWORD *)my_thread_var(v11, v12) = 135;
return 0xFFFFFFFFLL;
}
v13 = 16777212LL;
if ( (unsigned long long)v12 < 0xFFFFFC )
v13 = (long long)v12;
*a4 = v13;
*(_QWORD *)(a1[1] + 40LL) += v13;
++*(_QWORD *)(*a1 + 80LL);
*((_BYTE *)a1 + 465) |= 1u;
}
else
{
*a3 = v6;
v19 = 0;
*((_DWORD *)a1 + 192) = 1;
v14 = *((unsigned int *)a1 + 112);
if ( (mi_get_block_info((long long)v16, v14, *(_QWORD *)(*a1 + 88LL)) & 4) == 0 )
{
*(_DWORD *)my_thread_var(v16, (const char *)v14) = 127;
return 0xFFFFFFFFLL;
}
*(_QWORD *)(*a1 + 88LL) = v18;
--*(_QWORD *)(a1[1] + 8LL);
*(_QWORD *)(a1[1] + 16LL) -= v17;
*a4 = v17;
}
return 0LL;
}
| _mi_find_writepos:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x60
MOV RBX,RCX
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x58]
CMP RAX,-0x1
JZ 0x0017adc6
CMP byte ptr [R14 + 0x33a],0x0
JZ 0x0017ae42
LAB_0017adc6:
MOV RAX,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RDX],RAX
CMP RSI,0xffed
SBB RSI,-0x1
LEA RAX,[RSI + 0x3]
MOV RCX,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
MOV RDI,qword ptr [RCX + 0x160]
ADD RSI,0x6
AND RSI,-0x4
CMP RAX,RDI
CMOVC RSI,RDI
MOV RAX,qword ptr [RCX + 0x110]
SUB RAX,RSI
CMP qword ptr [RDX + 0x28],RAX
JBE 0x0017ae1a
CALL 0x001a2a4e
MOV dword ptr [RAX],0x87
JMP 0x0017ae7d
LAB_0017ae1a:
MOV EAX,0xfffffc
CMP RSI,RAX
CMOVC RAX,RSI
MOV qword ptr [RBX],RAX
MOV RCX,qword ptr [R14 + 0x8]
ADD qword ptr [RCX + 0x28],RAX
MOV RAX,qword ptr [R14]
INC qword ptr [RAX + 0x50]
OR byte ptr [R14 + 0x1d1],0x1
JMP 0x0017aeaa
LAB_0017ae42:
MOV qword ptr [RDX],RAX
LEA RDI,[RBP + -0x70]
MOV dword ptr [RDI + 0x50],0x0
MOV dword ptr [R14 + 0x300],0x1
MOV ESI,dword ptr [R14 + 0x1c0]
MOV RAX,qword ptr [R14]
MOV RDX,qword ptr [RAX + 0x58]
CALL 0x0017933f
TEST AL,0x4
JNZ 0x0017ae84
CALL 0x001a2a4e
MOV dword ptr [RAX],0x7f
LAB_0017ae7d:
MOV EAX,0xffffffff
JMP 0x0017aeac
LAB_0017ae84:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [R14]
MOV qword ptr [RCX + 0x58],RAX
MOV RAX,qword ptr [R14 + 0x8]
DEC qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [R14 + 0x8]
SUB qword ptr [RCX + 0x10],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBX],RAX
LAB_0017aeaa:
XOR EAX,EAX
LAB_0017aeac:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x18]
JNZ 0x0017aec4
ADD RSP,0x60
POP RBX
POP R14
POP RBP
RET
LAB_0017aec4:
CALL 0x00129270
|
int8 _mi_find_writepos(long *param_1,ulong param_2,long *param_3,ulong *param_4)
{
int4 *puVar1;
ulong uVar2;
int8 uVar3;
long lVar4;
ulong uVar5;
long in_FS_OFFSET;
int1 local_78 [40];
ulong local_50;
int8 local_38;
int4 local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if ((*(long *)(*param_1 + 0x58) == -1) || (*(char *)((long)param_1 + 0x33a) != '\0')) {
*param_3 = *(long *)(param_1[1] + 0x28);
lVar4 = (param_2 + 1) - (ulong)(param_2 < 0xffed);
uVar2 = *(ulong *)(*param_1 + 0x160);
uVar5 = lVar4 + 6U & 0xfffffffffffffffc;
if (lVar4 + 3U < uVar2) {
uVar5 = uVar2;
}
if (*(ulong *)(param_1[1] + 0x28) <= *(long *)(*param_1 + 0x110) - uVar5) {
uVar2 = 0xfffffc;
if (uVar5 < 0xfffffc) {
uVar2 = uVar5;
}
*param_4 = uVar2;
*(long *)(param_1[1] + 0x28) = *(long *)(param_1[1] + 0x28) + uVar2;
*(long *)(*param_1 + 0x50) = *(long *)(*param_1 + 0x50) + 1;
*(byte *)((long)param_1 + 0x1d1) = *(byte *)((long)param_1 + 0x1d1) | 1;
LAB_0017aeaa:
uVar3 = 0;
goto LAB_0017aeac;
}
puVar1 = (int4 *)_my_thread_var();
*puVar1 = 0x87;
}
else {
*param_3 = *(long *)(*param_1 + 0x58);
local_28 = 0;
*(int4 *)(param_1 + 0x60) = 1;
uVar2 = _mi_get_block_info(local_78,(int)param_1[0x38],*(int8 *)(*param_1 + 0x58));
if ((uVar2 & 4) != 0) {
*(int8 *)(*param_1 + 0x58) = local_38;
*(long *)(param_1[1] + 8) = *(long *)(param_1[1] + 8) + -1;
*(long *)(param_1[1] + 0x10) = *(long *)(param_1[1] + 0x10) - local_50;
*param_4 = local_50;
goto LAB_0017aeaa;
}
puVar1 = (int4 *)_my_thread_var();
*puVar1 = 0x7f;
}
uVar3 = 0xffffffff;
LAB_0017aeac:
if (*(long *)(in_FS_OFFSET + 0x28) == local_20) {
return uVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
38,650 | lunasvg::SVGPointList::parse(std::basic_string_view<char, std::char_traits<char>>) | dmazzella[P]pylunasvg/lunasvg/source/svgproperty.cpp | bool SVGPointList::parse(std::string_view input)
{
m_values.clear();
stripLeadingSpaces(input);
while(!input.empty()) {
Point value;
if(!parseNumber(input, value.x)
|| !skipOptionalSpacesOrComma(input)
|| !parseNumber(input, value.y)) {
return false;
}
m_values.push_back(value);
skipOptionalSpacesOrComma(input);
}
return true;
} | O0 | cpp | lunasvg::SVGPointList::parse(std::basic_string_view<char, std::char_traits<char>>):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x10, %rdi
callq 0x4b8b0
leaq -0x18(%rbp), %rdi
callq 0x33160
leaq -0x18(%rbp), %rdi
callq 0x20620
xorb $-0x1, %al
testb $0x1, %al
jne 0x4a09f
jmp 0x4a101
leaq -0x28(%rbp), %rdi
callq 0x2ef90
leaq -0x28(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x339b0
testb $0x1, %al
jne 0x4a0bb
jmp 0x4a0df
leaq -0x18(%rbp), %rdi
callq 0x33f70
testb $0x1, %al
jne 0x4a0ca
jmp 0x4a0df
leaq -0x28(%rbp), %rsi
addq $0x4, %rsi
leaq -0x18(%rbp), %rdi
callq 0x339b0
testb $0x1, %al
jne 0x4a0e5
movb $0x0, -0x1(%rbp)
jmp 0x4a105
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
leaq -0x28(%rbp), %rsi
callq 0x4b8d0
leaq -0x18(%rbp), %rdi
callq 0x33f70
jmp 0x4a08e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
| _ZN7lunasvg12SVGPointList5parseESt17basic_string_viewIcSt11char_traitsIcEE:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rsi
mov [rbp+var_10], rdx
mov [rbp+var_20], rdi
mov rdi, [rbp+var_20]
mov [rbp+var_30], rdi
add rdi, 10h
call _ZNSt6vectorIN7lunasvg5PointESaIS1_EE5clearEv; std::vector<lunasvg::Point>::clear(void)
lea rdi, [rbp+var_18]
call _ZN7lunasvg18stripLeadingSpacesERSt17basic_string_viewIcSt11char_traitsIcEE; lunasvg::stripLeadingSpaces(std::string_view &)
loc_4A08E:
lea rdi, [rbp+var_18]
call _ZNKSt17basic_string_viewIcSt11char_traitsIcEE5emptyEv; std::string_view::empty(void)
xor al, 0FFh
test al, 1
jnz short loc_4A09F
jmp short loc_4A101
loc_4A09F:
lea rdi, [rbp+var_28]; this
call _ZN7lunasvg5PointC2Ev; lunasvg::Point::Point(void)
lea rsi, [rbp+var_28]
lea rdi, [rbp+var_18]
call _ZN7lunasvg11parseNumberIfEEbRSt17basic_string_viewIcSt11char_traitsIcEERT_; lunasvg::parseNumber<float>(std::string_view &,float &)
test al, 1
jnz short loc_4A0BB
jmp short loc_4A0DF
loc_4A0BB:
lea rdi, [rbp+var_18]
call _ZN7lunasvg25skipOptionalSpacesOrCommaERSt17basic_string_viewIcSt11char_traitsIcEE; lunasvg::skipOptionalSpacesOrComma(std::string_view &)
test al, 1
jnz short loc_4A0CA
jmp short loc_4A0DF
loc_4A0CA:
lea rsi, [rbp+var_28]
add rsi, 4
lea rdi, [rbp+var_18]
call _ZN7lunasvg11parseNumberIfEEbRSt17basic_string_viewIcSt11char_traitsIcEERT_; lunasvg::parseNumber<float>(std::string_view &,float &)
test al, 1
jnz short loc_4A0E5
loc_4A0DF:
mov [rbp+var_1], 0
jmp short loc_4A105
loc_4A0E5:
mov rdi, [rbp+var_30]
add rdi, 10h
lea rsi, [rbp+var_28]
call _ZNSt6vectorIN7lunasvg5PointESaIS1_EE9push_backERKS1_; std::vector<lunasvg::Point>::push_back(lunasvg::Point const&)
lea rdi, [rbp+var_18]
call _ZN7lunasvg25skipOptionalSpacesOrCommaERSt17basic_string_viewIcSt11char_traitsIcEE; lunasvg::skipOptionalSpacesOrComma(std::string_view &)
jmp short loc_4A08E
loc_4A101:
mov [rbp+var_1], 1
loc_4A105:
mov al, [rbp+var_1]
and al, 1
add rsp, 30h
pop rbp
retn
| char lunasvg::SVGPointList::parse(long long a1, long long a2, long long a3)
{
float v4; // [rsp+8h] [rbp-28h] BYREF
float v5; // [rsp+Ch] [rbp-24h] BYREF
long long v6; // [rsp+10h] [rbp-20h]
_QWORD v7[2]; // [rsp+18h] [rbp-18h] BYREF
v7[0] = a2;
v7[1] = a3;
v6 = a1;
std::vector<lunasvg::Point>::clear(a1 + 16);
lunasvg::stripLeadingSpaces(v7, a2);
while ( !std::string_view::empty(v7) )
{
lunasvg::Point::Point((lunasvg::Point *)&v4);
if ( !lunasvg::parseNumber<float>(v7, &v4)
|| (lunasvg::skipOptionalSpacesOrComma((long long)v7) & 1) == 0
|| !lunasvg::parseNumber<float>(v7, &v5) )
{
return 0;
}
std::vector<lunasvg::Point>::push_back(a1 + 16, &v4);
lunasvg::skipOptionalSpacesOrComma((long long)v7);
}
return 1;
}
| parse:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x10],RDX
MOV qword ptr [RBP + -0x20],RDI
MOV RDI,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x30],RDI
ADD RDI,0x10
CALL 0x0014b8b0
LEA RDI,[RBP + -0x18]
CALL 0x00133160
LAB_0014a08e:
LEA RDI,[RBP + -0x18]
CALL 0x00120620
XOR AL,0xff
TEST AL,0x1
JNZ 0x0014a09f
JMP 0x0014a101
LAB_0014a09f:
LEA RDI,[RBP + -0x28]
CALL 0x0012ef90
LEA RSI,[RBP + -0x28]
LEA RDI,[RBP + -0x18]
CALL 0x001339b0
TEST AL,0x1
JNZ 0x0014a0bb
JMP 0x0014a0df
LAB_0014a0bb:
LEA RDI,[RBP + -0x18]
CALL 0x00133f70
TEST AL,0x1
JNZ 0x0014a0ca
JMP 0x0014a0df
LAB_0014a0ca:
LEA RSI,[RBP + -0x28]
ADD RSI,0x4
LEA RDI,[RBP + -0x18]
CALL 0x001339b0
TEST AL,0x1
JNZ 0x0014a0e5
LAB_0014a0df:
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0014a105
LAB_0014a0e5:
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x10
LEA RSI,[RBP + -0x28]
CALL 0x0014b8d0
LEA RDI,[RBP + -0x18]
CALL 0x00133f70
JMP 0x0014a08e
LAB_0014a101:
MOV byte ptr [RBP + -0x1],0x1
LAB_0014a105:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x30
POP RBP
RET
|
/* lunasvg::SVGPointList::parse(std::basic_string_view<char, std::char_traits<char> >) */
int1 lunasvg::SVGPointList::parse(long param_1,int8 param_2,int8 param_3)
{
byte bVar1;
bool bVar2;
Point local_30 [4];
float fStack_2c;
long local_28;
int8 local_20;
int8 local_18;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
std::vector<lunasvg::Point,std::allocator<lunasvg::Point>>::clear
((vector<lunasvg::Point,std::allocator<lunasvg::Point>> *)(param_1 + 0x10));
stripLeadingSpaces((basic_string_view *)&local_20);
while( true ) {
bVar1 = std::basic_string_view<char,std::char_traits<char>>::empty
((basic_string_view<char,std::char_traits<char>> *)&local_20);
if (((bVar1 ^ 0xff) & 1) == 0) {
return 1;
}
Point::Point(local_30);
bVar2 = parseNumber<float>((basic_string_view *)&local_20,(float *)local_30);
if (((!bVar2) ||
(bVar1 = skipOptionalSpacesOrComma((basic_string_view *)&local_20), (bVar1 & 1) == 0)) ||
(bVar2 = parseNumber<float>((basic_string_view *)&local_20,&fStack_2c), !bVar2)) break;
std::vector<lunasvg::Point,std::allocator<lunasvg::Point>>::push_back
((vector<lunasvg::Point,std::allocator<lunasvg::Point>> *)(param_1 + 0x10),local_30);
skipOptionalSpacesOrComma((basic_string_view *)&local_20);
}
return 0;
}
| |
38,651 | lunasvg::SVGPointList::parse(std::basic_string_view<char, std::char_traits<char>>) | dmazzella[P]pylunasvg/lunasvg/source/svgproperty.cpp | bool SVGPointList::parse(std::string_view input)
{
m_values.clear();
stripLeadingSpaces(input);
while(!input.empty()) {
Point value;
if(!parseNumber(input, value.x)
|| !skipOptionalSpacesOrComma(input)
|| !parseNumber(input, value.y)) {
return false;
}
m_values.push_back(value);
skipOptionalSpacesOrComma(input);
}
return true;
} | O1 | cpp | lunasvg::SVGPointList::parse(std::basic_string_view<char, std::char_traits<char>>):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0x1fd1b
movq %rax, 0x18(%rbx)
testq %rsi, %rsi
je 0x1fd75
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
leaq (%rdx,%rsi), %rax
movabsq $0x100002600, %r8 # imm = 0x100002600
xorl %r9d, %r9d
movq %rdx, %r10
movq %rsi, %r11
movzbl (%rdx,%r9), %r14d
cmpq $0x20, %r14
ja 0x1fd6b
btq %r14, %r8
jae 0x1fd6b
incq %r10
decq %r11
incq %r9
movq %r11, %rcx
movq %r10, %rdi
cmpq %r9, %rsi
jne 0x1fd41
xorl %ecx, %ecx
movq %rax, %rdi
movq %rdi, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
sete %bpl
je 0x1fe25
movq %rsp, %rsi
movq $0x0, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x172e2
testb %al, %al
je 0x1fe25
leaq 0x10(%rbx), %r14
leaq 0x4(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %rsp, %r13
movq %r12, %rdi
movl $0x2c, %esi
callq 0x176d5
testb %al, %al
je 0x1fe25
movq %r12, %rdi
movq %r15, %rsi
callq 0x172e2
testb %al, %al
je 0x1fe25
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi
je 0x1fdea
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x18(%rbx)
jmp 0x1fdf5
movq %r14, %rdi
movq %r13, %rdx
callq 0x20bd2
movq %r12, %rdi
movl $0x2c, %esi
callq 0x176d5
cmpq $0x0, 0x8(%rsp)
sete %bpl
je 0x1fe25
movq $0x0, (%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x172e2
testb %al, %al
jne 0x1fdb2
andb $0x1, %bpl
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN7lunasvg12SVGPointList5parseESt17basic_string_viewIcSt11char_traitsIcEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
mov [rsp+48h+var_40], rsi
mov [rsp+48h+var_38], rdx
mov rax, [rdi+10h]
cmp [rdi+18h], rax
jz short loc_1FD1B
mov [rbx+18h], rax
loc_1FD1B:
test rsi, rsi
jz short loc_1FD75
mov rcx, [rsp+48h+var_40]
mov rdi, [rsp+48h+var_38]
lea rax, [rdx+rsi]
mov r8, 100002600h
xor r9d, r9d
mov r10, rdx
mov r11, rsi
loc_1FD41:
movzx r14d, byte ptr [rdx+r9]
cmp r14, 20h ; ' '
ja short loc_1FD6B
bt r8, r14
jnb short loc_1FD6B
inc r10
dec r11
inc r9
mov rcx, r11
mov rdi, r10
cmp rsi, r9
jnz short loc_1FD41
xor ecx, ecx
mov rdi, rax
loc_1FD6B:
mov [rsp+48h+var_38], rdi
mov [rsp+48h+var_40], rcx
loc_1FD75:
cmp [rsp+48h+var_40], 0
setz bpl
jz loc_1FE25
mov rsi, rsp
mov qword ptr [rsi], 0
lea rdi, [rsp+48h+var_40]
call _ZN7lunasvg11parseNumberIfEEbRSt17basic_string_viewIcSt11char_traitsIcEERT_; lunasvg::parseNumber<float>(std::string_view &,float &)
test al, al
jz loc_1FE25
lea r14, [rbx+10h]
lea r15, [rsp+48h+var_44]
lea r12, [rsp+48h+var_40]
mov r13, rsp
loc_1FDB2:
mov rdi, r12
mov esi, 2Ch ; ','
call _ZN7lunasvg29skipOptionalSpacesOrDelimiterERSt17basic_string_viewIcSt11char_traitsIcEEc; lunasvg::skipOptionalSpacesOrDelimiter(std::string_view &,char)
test al, al
jz short loc_1FE25
mov rdi, r12
mov rsi, r15
call _ZN7lunasvg11parseNumberIfEEbRSt17basic_string_viewIcSt11char_traitsIcEERT_; lunasvg::parseNumber<float>(std::string_view &,float &)
test al, al
jz short loc_1FE25
mov rsi, [rbx+18h]
cmp rsi, [rbx+20h]
jz short loc_1FDEA
mov rax, [rsp]
mov [rsi], rax
add qword ptr [rbx+18h], 8
jmp short loc_1FDF5
loc_1FDEA:
mov rdi, r14
mov rdx, r13
call _ZNSt6vectorIN7lunasvg5PointESaIS1_EE17_M_realloc_insertIJRKS1_EEEvN9__gnu_cxx17__normal_iteratorIPS1_S3_EEDpOT_; std::vector<lunasvg::Point>::_M_realloc_insert<lunasvg::Point const&>(__gnu_cxx::__normal_iterator<lunasvg::Point*,std::vector<lunasvg::Point>>,lunasvg::Point const&)
loc_1FDF5:
mov rdi, r12
mov esi, 2Ch ; ','
call _ZN7lunasvg29skipOptionalSpacesOrDelimiterERSt17basic_string_viewIcSt11char_traitsIcEEc; lunasvg::skipOptionalSpacesOrDelimiter(std::string_view &,char)
cmp [rsp+48h+var_40], 0
setz bpl
jz short loc_1FE25
mov qword ptr [rsp], 0
mov rdi, r12
mov rsi, r13
call _ZN7lunasvg11parseNumberIfEEbRSt17basic_string_viewIcSt11char_traitsIcEERT_; lunasvg::parseNumber<float>(std::string_view &,float &)
test al, al
jnz short loc_1FDB2
loc_1FE25:
and bpl, 1
mov eax, ebp
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long lunasvg::SVGPointList::parse(_QWORD *a1, long long a2, long long a3)
{
unsigned int v3; // ebp
long long v5; // rax
long long v6; // rcx
long long v7; // rdi
long long v8; // r8
long long v9; // r9
long long v10; // r10
long long v11; // r11
unsigned long long v12; // r14
_QWORD *v13; // rsi
long long i; // [rsp+0h] [rbp-48h] BYREF
long long v16; // [rsp+8h] [rbp-40h] BYREF
long long v17; // [rsp+10h] [rbp-38h]
v16 = a2;
v17 = a3;
v5 = a1[2];
if ( a1[3] != v5 )
a1[3] = v5;
if ( a2 )
{
v6 = v16;
v7 = v17;
v8 = 0x100002600LL;
v9 = 0LL;
v10 = a3;
v11 = a2;
while ( 1 )
{
v12 = *(unsigned __int8 *)(a3 + v9);
if ( v12 > 0x20 || !_bittest64(&v8, v12) )
break;
++v10;
--v11;
++v9;
v6 = v11;
v7 = v10;
if ( a2 == v9 )
{
v6 = 0LL;
v7 = a3 + a2;
break;
}
}
v17 = v7;
v16 = v6;
}
LOBYTE(v3) = v16 == 0;
if ( v16 )
{
for ( i = 0LL; lunasvg::parseNumber<float>(&v16, (float *)&i); i = 0LL )
{
if ( !lunasvg::skipOptionalSpacesOrDelimiter(&v16, 44) || !lunasvg::parseNumber<float>(&v16, (float *)&i + 1) )
break;
v13 = (_QWORD *)a1[3];
if ( v13 == (_QWORD *)a1[4] )
{
std::vector<lunasvg::Point>::_M_realloc_insert<lunasvg::Point const&>(a1 + 2, v13, &i);
}
else
{
*v13 = i;
a1[3] += 8LL;
}
lunasvg::skipOptionalSpacesOrDelimiter(&v16, 44);
LOBYTE(v3) = v16 == 0;
if ( !v16 )
break;
}
}
LOBYTE(v3) = v3 & 1;
return v3;
}
| parse:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV qword ptr [RSP + 0x8],RSI
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RDI + 0x10]
CMP qword ptr [RDI + 0x18],RAX
JZ 0x0011fd1b
MOV qword ptr [RBX + 0x18],RAX
LAB_0011fd1b:
TEST RSI,RSI
JZ 0x0011fd75
MOV RCX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RSP + 0x10]
LEA RAX,[RDX + RSI*0x1]
MOV R8,0x100002600
XOR R9D,R9D
MOV R10,RDX
MOV R11,RSI
LAB_0011fd41:
MOVZX R14D,byte ptr [RDX + R9*0x1]
CMP R14,0x20
JA 0x0011fd6b
BT R8,R14
JNC 0x0011fd6b
INC R10
DEC R11
INC R9
MOV RCX,R11
MOV RDI,R10
CMP RSI,R9
JNZ 0x0011fd41
XOR ECX,ECX
MOV RDI,RAX
LAB_0011fd6b:
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RCX
LAB_0011fd75:
CMP qword ptr [RSP + 0x8],0x0
SETZ BPL
JZ 0x0011fe25
MOV RSI,RSP
MOV qword ptr [RSI],0x0
LEA RDI,[RSP + 0x8]
CALL 0x001172e2
TEST AL,AL
JZ 0x0011fe25
LEA R14,[RBX + 0x10]
LEA R15,[RSP + 0x4]
LEA R12,[RSP + 0x8]
MOV R13,RSP
LAB_0011fdb2:
MOV RDI,R12
MOV ESI,0x2c
CALL 0x001176d5
TEST AL,AL
JZ 0x0011fe25
MOV RDI,R12
MOV RSI,R15
CALL 0x001172e2
TEST AL,AL
JZ 0x0011fe25
MOV RSI,qword ptr [RBX + 0x18]
CMP RSI,qword ptr [RBX + 0x20]
JZ 0x0011fdea
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSI],RAX
ADD qword ptr [RBX + 0x18],0x8
JMP 0x0011fdf5
LAB_0011fdea:
MOV RDI,R14
MOV RDX,R13
CALL 0x00120bd2
LAB_0011fdf5:
MOV RDI,R12
MOV ESI,0x2c
CALL 0x001176d5
CMP qword ptr [RSP + 0x8],0x0
SETZ BPL
JZ 0x0011fe25
MOV qword ptr [RSP],0x0
MOV RDI,R12
MOV RSI,R13
CALL 0x001172e2
TEST AL,AL
JNZ 0x0011fdb2
LAB_0011fe25:
AND BPL,0x1
MOV EAX,EBP
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* lunasvg::SVGPointList::parse(std::basic_string_view<char, std::char_traits<char> >) */
ulong lunasvg::SVGPointList::parse(long param_1,long param_2,long param_3)
{
int8 *puVar1;
bool bVar2;
char cVar3;
int8 unaff_RBP;
long lVar4;
bool bVar5;
int8 local_48;
long local_40;
long local_38;
if (*(long *)(param_1 + 0x18) != *(long *)(param_1 + 0x10)) {
*(long *)(param_1 + 0x18) = *(long *)(param_1 + 0x10);
}
local_40 = param_2;
local_38 = param_3;
if (param_2 != 0) {
lVar4 = 0;
local_38 = param_3;
do {
if ((0x20 < (ulong)*(byte *)(param_3 + lVar4)) ||
((0x100002600U >> ((ulong)*(byte *)(param_3 + lVar4) & 0x3f) & 1) == 0)) goto LAB_0011fd75;
local_38 = local_38 + 1;
local_40 = local_40 + -1;
lVar4 = lVar4 + 1;
} while (param_2 != lVar4);
local_40 = 0;
local_38 = param_3 + param_2;
}
LAB_0011fd75:
bVar5 = local_40 == 0;
if (!bVar5) {
local_48 = 0;
bVar2 = parseNumber<float>((basic_string_view *)&local_40,(float *)&local_48);
if (bVar2) {
do {
cVar3 = skipOptionalSpacesOrDelimiter((basic_string_view *)&local_40,',');
if ((cVar3 == '\0') ||
(bVar2 = parseNumber<float>((basic_string_view *)&local_40,(float *)((long)&local_48 + 4)
), !bVar2)) break;
puVar1 = *(int8 **)(param_1 + 0x18);
if (puVar1 == *(int8 **)(param_1 + 0x20)) {
std::vector<lunasvg::Point,std::allocator<lunasvg::Point>>::
_M_realloc_insert<lunasvg::Point_const&>
((vector<lunasvg::Point,std::allocator<lunasvg::Point>> *)(param_1 + 0x10),
puVar1,&local_48);
}
else {
*puVar1 = local_48;
*(long *)(param_1 + 0x18) = *(long *)(param_1 + 0x18) + 8;
}
skipOptionalSpacesOrDelimiter((basic_string_view *)&local_40,',');
bVar5 = local_40 == 0;
if (bVar5) break;
local_48 = 0;
bVar2 = parseNumber<float>((basic_string_view *)&local_40,(float *)&local_48);
} while (bVar2);
}
}
return CONCAT71((int7)((ulong)unaff_RBP >> 8),bVar5) & 0xffffffff;
}
| |
38,652 | lunasvg::SVGPointList::parse(std::basic_string_view<char, std::char_traits<char>>) | dmazzella[P]pylunasvg/lunasvg/source/svgproperty.cpp | bool SVGPointList::parse(std::string_view input)
{
m_values.clear();
stripLeadingSpaces(input);
while(!input.empty()) {
Point value;
if(!parseNumber(input, value.x)
|| !skipOptionalSpacesOrComma(input)
|| !parseNumber(input, value.y)) {
return false;
}
m_values.push_back(value);
skipOptionalSpacesOrComma(input);
}
return true;
} | O3 | cpp | lunasvg::SVGPointList::parse(std::basic_string_view<char, std::char_traits<char>>):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0x1fc71
movq %rax, 0x18(%r14)
movb $0x1, %bl
testq %rsi, %rsi
je 0x1fc9d
leaq 0x10(%r14), %r15
movabsq $0x100002600, %rax # imm = 0x100002600
movzbl (%rdx), %ecx
cmpq $0x20, %rcx
ja 0x1fcae
btq %rcx, %rax
jae 0x1fcae
incq %rdx
decq %rsi
jne 0x1fc86
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %r12
movq %rdx, 0x8(%r12)
movq %rsi, (%r12)
leaq 0x4(%rsp), %r13
movq %rsp, %rbp
movq $0x0, (%rsp)
movq %r12, %rdi
movq %rbp, %rsi
callq 0x16bbd
testb %al, %al
je 0x1fd38
movq %r12, %rdi
movl $0x2c, %esi
callq 0x16f85
testb %al, %al
je 0x1fd38
movq %r12, %rdi
movq %r13, %rsi
callq 0x16bbd
testb %al, %al
je 0x1fd38
movq 0x18(%r14), %rsi
cmpq 0x20(%r14), %rsi
je 0x1fd13
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x18(%r14)
jmp 0x1fd1e
movq %r15, %rdi
movq %rbp, %rdx
callq 0x20b22
movq %r12, %rdi
movl $0x2c, %esi
callq 0x16f85
cmpq $0x0, 0x8(%rsp)
jne 0x1fcc4
jmp 0x1fc9d
xorl %ebx, %ebx
jmp 0x1fc9d
nop
| _ZN7lunasvg12SVGPointList5parseESt17basic_string_viewIcSt11char_traitsIcEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14, rdi
mov rax, [rdi+10h]
cmp [rdi+18h], rax
jz short loc_1FC71
mov [r14+18h], rax
loc_1FC71:
mov bl, 1
test rsi, rsi
jz short loc_1FC9D
lea r15, [r14+10h]
mov rax, 100002600h
loc_1FC86:
movzx ecx, byte ptr [rdx]
cmp rcx, 20h ; ' '
ja short loc_1FCAE
bt rax, rcx
jnb short loc_1FCAE
inc rdx
dec rsi
jnz short loc_1FC86
loc_1FC9D:
mov eax, ebx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1FCAE:
lea r12, [rsp+48h+var_40]
mov [r12+8], rdx
mov [r12], rsi
lea r13, [rsp+48h+var_44]
mov rbp, rsp
loc_1FCC4:
mov qword ptr [rsp], 0
mov rdi, r12
mov rsi, rbp
call _ZN7lunasvg11parseNumberIfEEbRSt17basic_string_viewIcSt11char_traitsIcEERT_; lunasvg::parseNumber<float>(std::string_view &,float &)
test al, al
jz short loc_1FD38
mov rdi, r12
mov esi, 2Ch ; ','
call _ZN7lunasvg29skipOptionalSpacesOrDelimiterERSt17basic_string_viewIcSt11char_traitsIcEEc; lunasvg::skipOptionalSpacesOrDelimiter(std::string_view &,char)
test al, al
jz short loc_1FD38
mov rdi, r12
mov rsi, r13
call _ZN7lunasvg11parseNumberIfEEbRSt17basic_string_viewIcSt11char_traitsIcEERT_; lunasvg::parseNumber<float>(std::string_view &,float &)
test al, al
jz short loc_1FD38
mov rsi, [r14+18h]
cmp rsi, [r14+20h]
jz short loc_1FD13
mov rax, [rsp]
mov [rsi], rax
add qword ptr [r14+18h], 8
jmp short loc_1FD1E
loc_1FD13:
mov rdi, r15
mov rdx, rbp
call _ZNSt6vectorIN7lunasvg5PointESaIS1_EE17_M_realloc_insertIJRKS1_EEEvN9__gnu_cxx17__normal_iteratorIPS1_S3_EEDpOT_; std::vector<lunasvg::Point>::_M_realloc_insert<lunasvg::Point const&>(__gnu_cxx::__normal_iterator<lunasvg::Point*,std::vector<lunasvg::Point>>,lunasvg::Point const&)
loc_1FD1E:
mov rdi, r12
mov esi, 2Ch ; ','
call _ZN7lunasvg29skipOptionalSpacesOrDelimiterERSt17basic_string_viewIcSt11char_traitsIcEEc; lunasvg::skipOptionalSpacesOrDelimiter(std::string_view &,char)
cmp [rsp+48h+var_40], 0
jnz short loc_1FCC4
jmp loc_1FC9D
loc_1FD38:
xor ebx, ebx
jmp loc_1FC9D
| long long lunasvg::SVGPointList::parse(_QWORD *a1, long long a2, unsigned __int8 *a3)
{
unsigned int v3; // ebx
long long v4; // rax
long long v5; // rax
unsigned long long v6; // rcx
_QWORD *v8; // rsi
long long v9; // [rsp+0h] [rbp-48h] BYREF
unsigned long long v10[8]; // [rsp+8h] [rbp-40h] BYREF
v4 = a1[2];
if ( a1[3] != v4 )
a1[3] = v4;
LOBYTE(v3) = 1;
if ( a2 )
{
v5 = 0x100002600LL;
while ( 1 )
{
v6 = *a3;
if ( v6 > 0x20 || !_bittest64(&v5, v6) )
break;
++a3;
if ( !--a2 )
return v3;
}
v10[1] = (unsigned long long)a3;
v10[0] = a2;
while ( 1 )
{
v9 = 0LL;
if ( !lunasvg::parseNumber<float>(v10, (float *)&v9)
|| !lunasvg::skipOptionalSpacesOrDelimiter((long long *)v10, 44)
|| !lunasvg::parseNumber<float>(v10, (float *)&v9 + 1) )
{
break;
}
v8 = (_QWORD *)a1[3];
if ( v8 == (_QWORD *)a1[4] )
{
std::vector<lunasvg::Point>::_M_realloc_insert<lunasvg::Point const&>(a1 + 2, v8, &v9);
}
else
{
*v8 = v9;
a1[3] += 8LL;
}
lunasvg::skipOptionalSpacesOrDelimiter((long long *)v10, 44);
if ( !v10[0] )
return v3;
}
return 0;
}
return v3;
}
| parse:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R14,RDI
MOV RAX,qword ptr [RDI + 0x10]
CMP qword ptr [RDI + 0x18],RAX
JZ 0x0011fc71
MOV qword ptr [R14 + 0x18],RAX
LAB_0011fc71:
MOV BL,0x1
TEST RSI,RSI
JZ 0x0011fc9d
LEA R15,[R14 + 0x10]
MOV RAX,0x100002600
LAB_0011fc86:
MOVZX ECX,byte ptr [RDX]
CMP RCX,0x20
JA 0x0011fcae
BT RAX,RCX
JNC 0x0011fcae
INC RDX
DEC RSI
JNZ 0x0011fc86
LAB_0011fc9d:
MOV EAX,EBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0011fcae:
LEA R12,[RSP + 0x8]
MOV qword ptr [R12 + 0x8],RDX
MOV qword ptr [R12],RSI
LEA R13,[RSP + 0x4]
MOV RBP,RSP
LAB_0011fcc4:
MOV qword ptr [RSP],0x0
MOV RDI,R12
MOV RSI,RBP
CALL 0x00116bbd
TEST AL,AL
JZ 0x0011fd38
MOV RDI,R12
MOV ESI,0x2c
CALL 0x00116f85
TEST AL,AL
JZ 0x0011fd38
MOV RDI,R12
MOV RSI,R13
CALL 0x00116bbd
TEST AL,AL
JZ 0x0011fd38
MOV RSI,qword ptr [R14 + 0x18]
CMP RSI,qword ptr [R14 + 0x20]
JZ 0x0011fd13
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSI],RAX
ADD qword ptr [R14 + 0x18],0x8
JMP 0x0011fd1e
LAB_0011fd13:
MOV RDI,R15
MOV RDX,RBP
CALL 0x00120b22
LAB_0011fd1e:
MOV RDI,R12
MOV ESI,0x2c
CALL 0x00116f85
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x0011fcc4
JMP 0x0011fc9d
LAB_0011fd38:
XOR EBX,EBX
JMP 0x0011fc9d
|
/* lunasvg::SVGPointList::parse(std::basic_string_view<char, std::char_traits<char> >) */
ulong lunasvg::SVGPointList::parse(long param_1,long param_2,byte *param_3)
{
int8 *puVar1;
bool bVar2;
char cVar3;
int8 unaff_RBX;
ulong uVar4;
int8 local_48;
long local_40;
byte *local_38;
if (*(long *)(param_1 + 0x18) != *(long *)(param_1 + 0x10)) {
*(long *)(param_1 + 0x18) = *(long *)(param_1 + 0x10);
}
uVar4 = CONCAT71((int7)((ulong)unaff_RBX >> 8),1);
if (param_2 != 0) {
do {
if ((0x20 < (ulong)*param_3) || ((0x100002600U >> ((ulong)*param_3 & 0x3f) & 1) == 0)) {
local_40 = param_2;
local_38 = param_3;
goto LAB_0011fcc4;
}
param_3 = param_3 + 1;
param_2 = param_2 + -1;
} while (param_2 != 0);
}
goto LAB_0011fc9d;
while( true ) {
puVar1 = *(int8 **)(param_1 + 0x18);
if (puVar1 == *(int8 **)(param_1 + 0x20)) {
std::vector<lunasvg::Point,std::allocator<lunasvg::Point>>::
_M_realloc_insert<lunasvg::Point_const&>
((vector<lunasvg::Point,std::allocator<lunasvg::Point>> *)(param_1 + 0x10),puVar1,
&local_48);
}
else {
*puVar1 = local_48;
*(long *)(param_1 + 0x18) = *(long *)(param_1 + 0x18) + 8;
}
skipOptionalSpacesOrDelimiter((basic_string_view *)&local_40,',');
if (local_40 == 0) break;
LAB_0011fcc4:
local_48 = 0;
bVar2 = parseNumber<float>((basic_string_view *)&local_40,(float *)&local_48);
if (((!bVar2) ||
(cVar3 = skipOptionalSpacesOrDelimiter((basic_string_view *)&local_40,','), cVar3 == '\0'))
|| (bVar2 = parseNumber<float>((basic_string_view *)&local_40,(float *)((long)&local_48 + 4))
, !bVar2)) {
uVar4 = 0;
break;
}
}
LAB_0011fc9d:
return uVar4 & 0xffffffff;
}
| |
38,653 | strxnmov | eloqsql/strings/strxnmov.c | char *strxnmov(char *dst, size_t len, const char *src, ...)
{
va_list pvar;
char *end_of_dst=dst+len;
va_start(pvar,src);
while (src != NullS)
{
do
{
if (dst == end_of_dst)
goto end;
}
while ((*dst++ = *src++));
dst--;
src = va_arg(pvar, char *);
}
end:
*dst=0;
va_end(pvar);
return dst;
} | O0 | c | strxnmov:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
testb %al, %al
je 0x75ecb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x75fd7
jmp 0x75f29
movq -0x8(%rbp), %rax
cmpq -0x38(%rbp), %rax
jne 0x75f38
jmp 0x75fd9
jmp 0x75f3a
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %al
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %al, (%rcx)
cmpb $0x0, %al
jne 0x75f29
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x100(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0xf4(%rbp)
cmpl $0x28, %eax
ja 0x75fa7
movq -0x100(%rbp), %rcx
movl -0xf4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x108(%rbp)
jmp 0x75fc4
movq -0x100(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x75f1c
jmp 0x75fd9
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
| strxnmov:
push rbp
mov rbp, rsp
sub rsp, 90h
test al, al
jz short loc_75ECB
movaps [rbp+var_C0], xmm0
movaps [rbp+var_B0], xmm1
movaps [rbp+var_A0], xmm2
movaps [rbp+var_90], xmm3
movaps [rbp+var_80], xmm4
movaps [rbp+var_70], xmm5
movaps [rbp+var_60], xmm6
movaps [rbp+var_50], xmm7
loc_75ECB:
mov [rbp+var_C8], r9
mov [rbp+var_D0], r8
mov [rbp+var_D8], rcx
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
add rax, [rbp+var_10]
mov [rbp+var_38], rax
lea rax, [rbp+var_30]
lea rcx, [rbp+var_F0]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 18h
loc_75F1C:
cmp [rbp+var_18], 0
jz loc_75FD7
jmp short $+2
loc_75F29:
mov rax, [rbp+var_8]
cmp rax, [rbp+var_38]
jnz short loc_75F38
jmp loc_75FD9
loc_75F38:
jmp short $+2
loc_75F3A:
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
mov al, [rax]
mov rcx, [rbp+var_8]
mov rdx, rcx
add rdx, 1
mov [rbp+var_8], rdx
mov [rcx], al
cmp al, 0
jnz short loc_75F29
mov rax, [rbp+var_8]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_8], rax
lea rax, [rbp+var_30]
mov [rbp+var_100], rax
mov eax, [rbp+var_30]
mov [rbp+var_F4], eax
cmp eax, 28h ; '('
ja short loc_75FA7
mov rcx, [rbp+var_100]
mov edx, [rbp+var_F4]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_108], rax
jmp short loc_75FC4
loc_75FA7:
mov rcx, [rbp+var_100]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_108], rax
loc_75FC4:
mov rax, [rbp+var_108]
mov rax, [rax]
mov [rbp+var_18], rax
jmp loc_75F1C
loc_75FD7:
jmp short $+2
loc_75FD9:
mov rax, [rbp+var_8]
mov byte ptr [rax], 0
mov rax, [rbp+var_8]
add rsp, 90h
pop rbp
retn
| _BYTE * strxnmov(
_BYTE *a1,
long long a2,
_BYTE *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)
{
_BYTE *v15; // rax
_BYTE *v16; // rcx
char *v17; // rax
char v19; // [rsp+18h] [rbp-F0h] BYREF
long long v20; // [rsp+30h] [rbp-D8h]
long long v21; // [rsp+38h] [rbp-D0h]
long long v22; // [rsp+40h] [rbp-C8h]
__m128 v23; // [rsp+48h] [rbp-C0h]
__m128 v24; // [rsp+58h] [rbp-B0h]
__m128 v25; // [rsp+68h] [rbp-A0h]
__m128 v26; // [rsp+78h] [rbp-90h]
__m128 v27; // [rsp+88h] [rbp-80h]
__m128 v28; // [rsp+98h] [rbp-70h]
__m128 v29; // [rsp+A8h] [rbp-60h]
__m128 v30; // [rsp+B8h] [rbp-50h]
_BYTE *v31; // [rsp+D0h] [rbp-38h]
int v32; // [rsp+D8h] [rbp-30h]
int v33; // [rsp+DCh] [rbp-2Ch]
char *v34; // [rsp+E0h] [rbp-28h]
char *v35; // [rsp+E8h] [rbp-20h]
_BYTE *v36; // [rsp+F0h] [rbp-18h]
long long v37; // [rsp+F8h] [rbp-10h]
_BYTE *v38; // [rsp+100h] [rbp-8h]
v23 = a7;
v24 = a8;
v25 = a9;
v26 = a10;
v27 = a11;
v28 = a12;
v29 = a13;
v30 = a14;
v22 = a6;
v21 = a5;
v20 = a4;
v38 = a1;
v37 = a2;
v36 = a3;
v31 = &a1[a2];
v35 = &v19;
v34 = &a15;
v33 = 48;
v32 = 24;
LABEL_2:
if ( v36 )
{
while ( v38 != v31 )
{
v15 = v36++;
LOBYTE(v15) = *v15;
v16 = v38++;
*v16 = (_BYTE)v15;
if ( !(_BYTE)v15 )
{
--v38;
if ( (unsigned int)v32 > 0x28 )
{
v17 = v34;
v34 += 8;
}
else
{
v17 = &v35[v32];
v32 += 8;
}
v36 = *(_BYTE **)v17;
goto LABEL_2;
}
}
}
*v38 = 0;
return v38;
}
| strxnmov:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
TEST AL,AL
JZ 0x00175ecb
MOVAPS xmmword ptr [RBP + -0xc0],XMM0
MOVAPS xmmword ptr [RBP + -0xb0],XMM1
MOVAPS xmmword ptr [RBP + -0xa0],XMM2
MOVAPS xmmword ptr [RBP + -0x90],XMM3
MOVAPS xmmword ptr [RBP + -0x80],XMM4
MOVAPS xmmword ptr [RBP + -0x70],XMM5
MOVAPS xmmword ptr [RBP + -0x60],XMM6
MOVAPS xmmword ptr [RBP + -0x50],XMM7
LAB_00175ecb:
MOV qword ptr [RBP + -0xc8],R9
MOV qword ptr [RBP + -0xd0],R8
MOV qword ptr [RBP + -0xd8],RCX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
LEA RAX,[RBP + -0x30]
LEA RCX,[RBP + -0xf0]
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],0x18
LAB_00175f1c:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00175fd7
JMP 0x00175f29
LAB_00175f29:
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x38]
JNZ 0x00175f38
JMP 0x00175fd9
LAB_00175f38:
JMP 0x00175f3a
LAB_00175f3a:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
MOV AL,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x8],RDX
MOV byte ptr [RCX],AL
CMP AL,0x0
JNZ 0x00175f29
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x8],RAX
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x100],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0xf4],EAX
CMP EAX,0x28
JA 0x00175fa7
MOV RCX,qword ptr [RBP + -0x100]
MOV EDX,dword ptr [RBP + -0xf4]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x108],RAX
JMP 0x00175fc4
LAB_00175fa7:
MOV RCX,qword ptr [RBP + -0x100]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x108],RAX
LAB_00175fc4:
MOV RAX,qword ptr [RBP + -0x108]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00175f1c
LAB_00175fd7:
JMP 0x00175fd9
LAB_00175fd9:
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x90
POP RBP
RET
|
/* WARNING: Restarted to delay deadcode elimination for space: stack */
char * strxnmov(char *param_1,long param_2,char *param_3)
{
char cVar1;
char *pcVar2;
int8 *local_110;
int8 local_f8 [24];
uint local_38;
int8 *local_30;
char *local_20;
char *local_10;
local_30 = (int8 *)&stack0x00000008;
local_38 = 0x18;
local_20 = param_3;
local_10 = param_1;
while (pcVar2 = local_10, local_20 != (char *)0x0) {
do {
local_10 = pcVar2;
if (local_10 == param_1 + param_2) goto LAB_00175fd9;
cVar1 = *local_20;
*local_10 = cVar1;
local_20 = local_20 + 1;
pcVar2 = local_10 + 1;
} while (cVar1 != '\0');
if (local_38 < 0x29) {
local_110 = (int8 *)((long)local_f8 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_110 = local_30;
local_30 = local_30 + 1;
}
local_20 = (char *)*local_110;
}
LAB_00175fd9:
*local_10 = '\0';
return local_10;
}
| |
38,654 | strxnmov | eloqsql/strings/strxnmov.c | char *strxnmov(char *dst, size_t len, const char *src, ...)
{
va_list pvar;
char *end_of_dst=dst+len;
va_start(pvar,src);
while (src != NullS)
{
do
{
if (dst == end_of_dst)
goto end;
}
while ((*dst++ = *src++));
dst--;
src = va_arg(pvar, char *);
}
end:
*dst=0;
va_end(pvar);
return dst;
} | O3 | c | strxnmov:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %eax, %r10d
movq %rdi, %rax
leaq -0xd0(%rbp), %rdi
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %r10b, %r10b
je 0x59478
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 %rdi, -0x10(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movabsq $0x3000000018, %rcx # imm = 0x3000000018
movq %rcx, -0x20(%rbp)
testq %rdx, %rdx
je 0x594f1
addq %rax, %rsi
movq -0x10(%rbp), %rcx
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %r8
movq %r8, %r9
cmpq %rsi, %rax
je 0x594ee
movb (%rdx), %r10b
movb %r10b, (%rax)
testb %r10b, %r10b
jne 0x594e6
cmpl $0x28, %edi
ja 0x594ce
movq %r9, %r10
movl %edi, %r9d
addq %rcx, %r9
addl $0x8, %edi
movl %edi, -0x20(%rbp)
jmp 0x594d9
leaq 0x8(%r9), %r8
movq %r8, -0x18(%rbp)
movq %r8, %r10
movq (%r9), %rdx
movq %r10, %r9
testq %rdx, %rdx
jne 0x594a8
jmp 0x594f1
incq %rax
incq %rdx
jmp 0x594a5
movq %rsi, %rax
movb $0x0, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nop
| strxnmov:
push rbp
mov rbp, rsp
sub rsp, 50h
mov r10d, eax
mov rax, rdi
lea rdi, [rbp+var_D0]
mov [rdi+18h], rcx
mov [rdi+20h], r8
mov [rdi+28h], r9
test r10b, r10b
jz short loc_59478
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_59478:
mov [rbp+var_10], rdi
lea rcx, [rbp+arg_0]
mov [rbp+var_18], rcx
mov rcx, 3000000018h
mov [rbp+var_20], rcx
test rdx, rdx
jz short loc_594F1
add rsi, rax
mov rcx, [rbp+var_10]
mov edi, dword ptr [rbp+var_20]
mov r8, [rbp+var_18]
loc_594A5:
mov r9, r8
loc_594A8:
cmp rax, rsi
jz short loc_594EE
mov r10b, [rdx]
mov [rax], r10b
test r10b, r10b
jnz short loc_594E6
cmp edi, 28h ; '('
ja short loc_594CE
mov r10, r9
mov r9d, edi
add r9, rcx
add edi, 8
mov dword ptr [rbp+var_20], edi
jmp short loc_594D9
loc_594CE:
lea r8, [r9+8]
mov [rbp+var_18], r8
mov r10, r8
loc_594D9:
mov rdx, [r9]
mov r9, r10
test rdx, rdx
jnz short loc_594A8
jmp short loc_594F1
loc_594E6:
inc rax
inc rdx
jmp short loc_594A5
loc_594EE:
mov rax, rsi
loc_594F1:
mov byte ptr [rax], 0
add rsp, 50h
pop rbp
retn
| char *strxnmov(char *a1, long long a2, char *a3, ...)
{
char *result; // rax
char *v4; // rsi
char *reg_save_area; // rcx
unsigned int gp_offset; // edi
char *overflow_arg_area; // r8
char *v8; // r9
char v9; // r10
char *v10; // r10
va_list va; // [rsp+B0h] [rbp-20h] BYREF
result = a1;
va_start(va, a3);
if ( a3 )
{
v4 = &a1[a2];
reg_save_area = (char *)va[0].reg_save_area;
gp_offset = va[0].gp_offset;
overflow_arg_area = (char *)va[0].overflow_arg_area;
LABEL_3:
v8 = overflow_arg_area;
while ( result != v4 )
{
v9 = *a3;
*result = *a3;
if ( v9 )
{
++result;
++a3;
goto LABEL_3;
}
if ( gp_offset > 0x28 )
{
overflow_arg_area = v8 + 8;
va[0].overflow_arg_area = v8 + 8;
v10 = v8 + 8;
}
else
{
v10 = v8;
v8 = ®_save_area[gp_offset];
gp_offset += 8;
va[0].gp_offset = gp_offset;
}
a3 = *(char **)v8;
v8 = v10;
if ( !a3 )
goto LABEL_13;
}
result = v4;
}
LABEL_13:
*result = 0;
return result;
}
| strxnmov:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV R10D,EAX
MOV RAX,RDI
LEA RDI,[RBP + -0xd0]
MOV qword ptr [RDI + 0x18],RCX
MOV qword ptr [RDI + 0x20],R8
MOV qword ptr [RDI + 0x28],R9
TEST R10B,R10B
JZ 0x00159478
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_00159478:
MOV qword ptr [RBP + -0x10],RDI
LEA RCX,[RBP + 0x10]
MOV qword ptr [RBP + -0x18],RCX
MOV RCX,0x3000000018
MOV qword ptr [RBP + -0x20],RCX
TEST RDX,RDX
JZ 0x001594f1
ADD RSI,RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x18]
LAB_001594a5:
MOV R9,R8
LAB_001594a8:
CMP RAX,RSI
JZ 0x001594ee
MOV R10B,byte ptr [RDX]
MOV byte ptr [RAX],R10B
TEST R10B,R10B
JNZ 0x001594e6
CMP EDI,0x28
JA 0x001594ce
MOV R10,R9
MOV R9D,EDI
ADD R9,RCX
ADD EDI,0x8
MOV dword ptr [RBP + -0x20],EDI
JMP 0x001594d9
LAB_001594ce:
LEA R8,[R9 + 0x8]
MOV qword ptr [RBP + -0x18],R8
MOV R10,R8
LAB_001594d9:
MOV RDX,qword ptr [R9]
MOV R9,R10
TEST RDX,RDX
JNZ 0x001594a8
JMP 0x001594f1
LAB_001594e6:
INC RAX
INC RDX
JMP 0x001594a5
LAB_001594ee:
MOV RAX,RSI
LAB_001594f1:
MOV byte ptr [RAX],0x0
ADD RSP,0x50
POP RBP
RET
|
void strxnmov(char *param_1,long param_2,char *param_3)
{
char cVar1;
char *pcVar2;
char *pcVar3;
int8 *puVar4;
int8 *puVar5;
ulong uVar6;
int8 *puVar7;
int8 local_d8 [22];
uint local_28;
puVar4 = (int8 *)&stack0x00000008;
pcVar2 = param_1;
if (param_3 != (char *)0x0) {
pcVar3 = param_1 + param_2;
local_28 = 0x18;
puVar5 = puVar4;
do {
while( true ) {
pcVar2 = pcVar3;
if (param_1 == pcVar3) goto LAB_001594f1;
cVar1 = *param_3;
*param_1 = cVar1;
if (cVar1 == '\0') break;
param_1 = param_1 + 1;
param_3 = param_3 + 1;
puVar5 = puVar4;
}
if (local_28 < 0x29) {
uVar6 = (ulong)local_28;
local_28 = local_28 + 8;
puVar7 = (int8 *)((long)local_d8 + uVar6);
}
else {
puVar4 = puVar5 + 1;
puVar7 = puVar5;
puVar5 = puVar4;
}
param_3 = (char *)*puVar7;
pcVar2 = param_1;
} while (param_3 != (char *)0x0);
}
LAB_001594f1:
*pcVar2 = '\0';
return;
}
| |
38,655 | inline_mysql_file_delete | eloqsql/include/mysql/psi/mysql_file.h | static inline int
inline_mysql_file_delete(
#ifdef HAVE_PSI_FILE_INTERFACE
PSI_file_key key, const char *src_file, uint src_line,
#endif
const char *name, myf flags)
{
int result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_name_locker)(&state, key, PSI_FILE_DELETE, name, &locker);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_close_wait)(locker, src_file, src_line);
result= my_delete(name, flags);
PSI_FILE_CALL(end_file_close_wait)(locker, result);
return result;
}
#endif
result= my_delete(name, flags);
return result;
} | O0 | c | inline_mysql_file_delete:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq 0x1f056c(%rip), %rax # 0x2cb2a0
movq (%rax), %rax
movq 0x148(%rax), %rax
movl -0x8(%rbp), %esi
movq -0x20(%rbp), %rcx
leaq -0x80(%rbp), %rdi
movl $0xe, %edx
leaq -0x38(%rbp), %r8
callq *%rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xdadc8
leaq 0x1f0521(%rip), %rax # 0x2cb2a0
movq (%rax), %rax
movq 0x220(%rax), %rax
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq *%rax
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xf0a50
movl %eax, -0x2c(%rbp)
leaq 0x1f04f3(%rip), %rax # 0x2cb2a0
movq (%rax), %rax
movq 0x228(%rax), %rax
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq *%rax
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xdadde
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xf0a50
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| inline_mysql_file_delete_1:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_8], edi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+148h]
mov esi, [rbp+var_8]
mov rcx, [rbp+var_20]
lea rdi, [rbp+var_80]
mov edx, 0Eh
lea r8, [rbp+var_38]
call rax
mov [rbp+var_38], rax
cmp [rbp+var_38], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_DADC8
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+220h]
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
call rax
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_28]
call my_delete
mov [rbp+var_2C], eax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+228h]
mov rdi, [rbp+var_38]
mov esi, [rbp+var_2C]
call rax
mov eax, [rbp+var_2C]
mov [rbp+var_4], eax
jmp short loc_DADDE
loc_DADC8:
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_28]
call my_delete
mov [rbp+var_2C], eax
mov eax, [rbp+var_2C]
mov [rbp+var_4], eax
loc_DADDE:
mov eax, [rbp+var_4]
add rsp, 80h
pop rbp
retn
| long long inline_mysql_file_delete_1(unsigned int a1, long long a2, unsigned int a3, long long a4, long long a5)
{
_BYTE v6[72]; // [rsp+0h] [rbp-80h] BYREF
long long v7; // [rsp+48h] [rbp-38h] BYREF
unsigned int v8; // [rsp+54h] [rbp-2Ch]
long long v9; // [rsp+58h] [rbp-28h]
long long v10; // [rsp+60h] [rbp-20h]
unsigned int v11; // [rsp+6Ch] [rbp-14h]
long long v12; // [rsp+70h] [rbp-10h]
unsigned int v13; // [rsp+78h] [rbp-8h]
v13 = a1;
v12 = a2;
v11 = a3;
v10 = a4;
v9 = a5;
v7 = ((long long ( *)(_BYTE *, _QWORD, long long, long long, long long *))PSI_server[41])(v6, a1, 14LL, a4, &v7);
if ( v7 )
{
((void ( *)(long long, long long, _QWORD))PSI_server[68])(v7, v12, v11);
v8 = my_delete(v10, v9);
((void ( *)(long long, _QWORD))PSI_server[69])(v7, v8);
}
else
{
return (unsigned int)my_delete(v10, v9);
}
return v8;
}
| inline_mysql_file_delete:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV dword ptr [RBP + -0x8],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
LEA RAX,[0x3cb2a0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x148]
MOV ESI,dword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x20]
LEA RDI,[RBP + -0x80]
MOV EDX,0xe
LEA R8,[RBP + -0x38]
CALL RAX
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001dadc8
LEA RAX,[0x3cb2a0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x220]
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
CALL RAX
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x001f0a50
MOV dword ptr [RBP + -0x2c],EAX
LEA RAX,[0x3cb2a0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x228]
MOV RDI,qword ptr [RBP + -0x38]
MOV ESI,dword ptr [RBP + -0x2c]
CALL RAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001dadde
LAB_001dadc8:
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x001f0a50
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x4],EAX
LAB_001dadde:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x80
POP RBP
RET
|
int4
inline_mysql_file_delete
(int4 param_1,int8 param_2,int4 param_3,int8 param_4,
int8 param_5)
{
int1 local_88 [72];
long local_40;
int4 local_34;
int8 local_30;
int8 local_28;
int4 local_1c;
int8 local_18;
int4 local_10;
int4 local_c;
local_30 = param_5;
local_28 = param_4;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
local_40 = (**(code **)(PSI_server + 0x148))(local_88,param_1,0xe,param_4,&local_40);
if (local_40 == 0) {
local_c = my_delete(local_28,local_30);
}
else {
(**(code **)(PSI_server + 0x220))(local_40,local_18,local_1c);
local_34 = my_delete(local_28,local_30);
(**(code **)(PSI_server + 0x228))(local_40,local_34);
local_c = local_34;
}
return local_c;
}
| |
38,656 | pick_seeds | eloqsql/storage/myisam/rt_split.c | static void pick_seeds(SplitStruct *node, int n_entries,
SplitStruct **seed_a, SplitStruct **seed_b, int n_dim)
{
SplitStruct *cur1;
SplitStruct *lim1 = node + (n_entries - 1);
SplitStruct *cur2;
SplitStruct *lim2 = node + n_entries;
double max_d = -DBL_MAX;
double d;
*seed_a = node;
*seed_b = node + 1;
for (cur1 = node; cur1 < lim1; ++cur1)
{
for (cur2=cur1 + 1; cur2 < lim2; ++cur2)
{
d = mbr_join_square(cur1->coords, cur2->coords, n_dim) - cur1->square -
cur2->square;
if (d > max_d)
{
max_d = d;
*seed_a = cur1;
*seed_b = cur2;
}
}
}
} | O0 | c | pick_seeds:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movsd 0x8b37a(%rip), %xmm0 # 0x162258
movsd %xmm0, -0x50(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
addq $0x20, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0xd6fa5
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0xd6f92
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rsi
movl -0x24(%rbp), %edx
callq 0xd7210
movq -0x30(%rbp), %rax
subsd (%rax), %xmm0
movq -0x40(%rbp), %rax
subsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
ucomisd -0x50(%rbp), %xmm0
jbe 0xd6f82
movsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0xd6f84
movq -0x40(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x40(%rbp)
jmp 0xd6f1f
jmp 0xd6f94
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
jmp 0xd6f05
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| pick_seeds_0:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_24], r8d
mov rax, [rbp+var_8]
mov ecx, [rbp+var_C]
sub ecx, 1
movsxd rcx, ecx
shl rcx, 5
add rax, rcx
mov [rbp+var_38], rax
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_C]
shl rcx, 5
add rax, rcx
mov [rbp+var_48], rax
movsd xmm0, cs:qword_162258
movsd [rbp+var_50], xmm0
mov rcx, [rbp+var_8]
mov rax, [rbp+var_18]
mov [rax], rcx
mov rcx, [rbp+var_8]
add rcx, 20h ; ' '
mov rax, [rbp+var_20]
mov [rax], rcx
mov rax, [rbp+var_8]
mov [rbp+var_30], rax
loc_D6F05:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_38]
jnb loc_D6FA5
mov rax, [rbp+var_30]
add rax, 20h ; ' '
mov [rbp+var_40], rax
loc_D6F1F:
mov rax, [rbp+var_40]
cmp rax, [rbp+var_48]
jnb short loc_D6F92
mov rax, [rbp+var_30]
mov rdi, [rax+18h]
mov rax, [rbp+var_40]
mov rsi, [rax+18h]
mov edx, [rbp+var_24]
call mbr_join_square_0
mov rax, [rbp+var_30]
subsd xmm0, qword ptr [rax]
mov rax, [rbp+var_40]
subsd xmm0, qword ptr [rax]
movsd [rbp+var_58], xmm0
movsd xmm0, [rbp+var_58]
ucomisd xmm0, [rbp+var_50]
jbe short loc_D6F82
movsd xmm0, [rbp+var_58]
movsd [rbp+var_50], xmm0
mov rcx, [rbp+var_30]
mov rax, [rbp+var_18]
mov [rax], rcx
mov rcx, [rbp+var_40]
mov rax, [rbp+var_20]
mov [rax], rcx
loc_D6F82:
jmp short $+2
loc_D6F84:
mov rax, [rbp+var_40]
add rax, 20h ; ' '
mov [rbp+var_40], rax
jmp short loc_D6F1F
loc_D6F92:
jmp short $+2
loc_D6F94:
mov rax, [rbp+var_30]
add rax, 20h ; ' '
mov [rbp+var_30], rax
jmp loc_D6F05
loc_D6FA5:
add rsp, 60h
pop rbp
retn
| unsigned long long pick_seeds_0(
unsigned long long a1,
int a2,
unsigned long long *a3,
unsigned long long *a4,
unsigned int a5)
{
unsigned long long result; // rax
double v6; // [rsp+8h] [rbp-58h]
double v7; // [rsp+10h] [rbp-50h]
unsigned long long j; // [rsp+20h] [rbp-40h]
unsigned long long i; // [rsp+30h] [rbp-30h]
v7 = -1.797693134862316e308;
*a3 = a1;
*a4 = a1 + 32;
for ( i = a1; ; i += 32LL )
{
result = i;
if ( i >= 32LL * (a2 - 1) + a1 )
break;
for ( j = i + 32; j < 32LL * a2 + a1; j += 32LL )
{
v6 = mbr_join_square_0(*(_QWORD *)(i + 24), *(_QWORD *)(j + 24), a5) - *(double *)i - *(double *)j;
if ( v6 > v7 )
{
v7 = v6;
*a3 = i;
*a4 = j;
}
}
}
return result;
}
| pick_seeds:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV dword ptr [RBP + -0x24],R8D
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0xc]
SUB ECX,0x1
MOVSXD RCX,ECX
SHL RCX,0x5
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0xc]
SHL RCX,0x5
ADD RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
MOVSD XMM0,qword ptr [0x00262258]
MOVSD qword ptr [RBP + -0x50],XMM0
MOV RCX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x8]
ADD RCX,0x20
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x30],RAX
LAB_001d6f05:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x38]
JNC 0x001d6fa5
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x20
MOV qword ptr [RBP + -0x40],RAX
LAB_001d6f1f:
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x48]
JNC 0x001d6f92
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RAX + 0x18]
MOV EDX,dword ptr [RBP + -0x24]
CALL 0x001d7210
MOV RAX,qword ptr [RBP + -0x30]
SUBSD XMM0,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x40]
SUBSD XMM0,qword ptr [RAX]
MOVSD qword ptr [RBP + -0x58],XMM0
MOVSD XMM0,qword ptr [RBP + -0x58]
UCOMISD XMM0,qword ptr [RBP + -0x50]
JBE 0x001d6f82
MOVSD XMM0,qword ptr [RBP + -0x58]
MOVSD qword ptr [RBP + -0x50],XMM0
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
LAB_001d6f82:
JMP 0x001d6f84
LAB_001d6f84:
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x20
MOV qword ptr [RBP + -0x40],RAX
JMP 0x001d6f1f
LAB_001d6f92:
JMP 0x001d6f94
LAB_001d6f94:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x20
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001d6f05
LAB_001d6fa5:
ADD RSP,0x60
POP RBP
RET
|
void pick_seeds(double *param_1,int param_2,int8 *param_3,int8 *param_4,
int4 param_5)
{
double *pdVar1;
double dVar2;
double local_58;
double *local_48;
double *local_38;
local_58 = DAT_00262258;
*param_3 = param_1;
*param_4 = param_1 + 4;
for (local_38 = param_1; pdVar1 = local_38, local_38 < param_1 + (long)(param_2 + -1) * 4;
local_38 = local_38 + 4) {
while (local_48 = pdVar1 + 4, local_48 < param_1 + (long)param_2 * 4) {
dVar2 = (double)mbr_join_square(local_38[3],pdVar1[7],param_5);
dVar2 = (dVar2 - *local_38) - *local_48;
pdVar1 = local_48;
if (local_58 < dVar2) {
*param_3 = local_38;
*param_4 = local_48;
local_58 = dVar2;
}
}
}
return;
}
| |
38,657 | my_hash_sort_ucs2_bin | eloqsql/strings/ctype-ucs2.c | static void
my_hash_sort_ucs2_bin(CHARSET_INFO *cs,
const uchar *key, size_t len, ulong *nr1, ulong *nr2)
{
size_t lengthsp= my_lengthsp_mb2(cs, (const char *) key, len);
my_hash_sort_ucs2_nopad_bin(cs, key, lengthsp, nr1, nr2);
} | O3 | c | my_hash_sort_ucs2_bin:
movq %rdx, %rax
cmpq $0x2, %rdx
jl 0xc92a9
cmpb $0x20, -0x1(%rsi,%rax)
jne 0xc92a1
leaq -0x2(%rax), %rdx
cmpb $0x0, -0x2(%rsi,%rax)
je 0xc9286
movq (%rcx), %rdx
movq (%r8), %rdi
jmp 0xc92b5
movq (%rcx), %rdx
movq (%r8), %rdi
cmpq $0x1, %rax
jne 0xc92e8
pushq %rbp
movq %rsp, %rbp
addq %rsi, %rax
movl %edx, %r9d
andl $0x3f, %r9d
addq %rdi, %r9
movzbl (%rsi), %r10d
imulq %r9, %r10
movq %rdx, %r9
shlq $0x8, %r9
addq %r10, %r9
xorq %r9, %rdx
addq $0x3, %rdi
incq %rsi
cmpq %rax, %rsi
jb 0xc92bc
popq %rbp
movq %rdx, (%rcx)
movq %rdi, (%r8)
retq
| my_hash_sort_ucs2_bin:
mov rax, rdx
cmp rdx, 2
jl short loc_C92A9
cmp byte ptr [rsi+rax-1], 20h ; ' '
jnz short loc_C92A1
lea rdx, [rax-2]
cmp byte ptr [rsi+rax-2], 0
jz short my_hash_sort_ucs2_bin
loc_C92A1:
mov rdx, [rcx]
mov rdi, [r8]
jmp short loc_C92B5
loc_C92A9:
mov rdx, [rcx]
mov rdi, [r8]
cmp rax, 1
jnz short loc_C92E8
loc_C92B5:
push rbp
mov rbp, rsp
add rax, rsi
loc_C92BC:
mov r9d, edx
and r9d, 3Fh
add r9, rdi
movzx r10d, byte ptr [rsi]
imul r10, r9
mov r9, rdx
shl r9, 8
add r9, r10
xor rdx, r9
add rdi, 3
inc rsi
cmp rsi, rax
jb short loc_C92BC
pop rbp
loc_C92E8:
mov [rcx], rdx
mov [r8], rdi
retn
| unsigned long long my_hash_sort_ucs2_bin(
long long a1,
unsigned long long a2,
long long a3,
long long *a4,
long long *a5)
{
unsigned long long result; // rax
long long v6; // rdx
long long v7; // rdi
while ( 1 )
{
result = a3;
if ( a3 < 2 )
break;
if ( *(_BYTE *)(a2 + a3 - 1) == 32 )
{
a3 -= 2LL;
if ( !*(_BYTE *)(a2 + result - 2) )
continue;
}
v6 = *a4;
v7 = *a5;
goto LABEL_6;
}
v6 = *a4;
v7 = *a5;
if ( result != 1 )
goto LABEL_8;
LABEL_6:
result += a2;
do
{
v6 ^= (v7 + (v6 & 0x3F)) * *(unsigned __int8 *)a2 + (v6 << 8);
v7 += 3LL;
++a2;
}
while ( a2 < result );
LABEL_8:
*a4 = v6;
*a5 = v7;
return result;
}
| my_hash_sort_ucs2_bin:
MOV RAX,RDX
CMP RDX,0x2
JL 0x001c92a9
CMP byte ptr [RSI + RAX*0x1 + -0x1],0x20
JNZ 0x001c92a1
LEA RDX,[RAX + -0x2]
CMP byte ptr [RSI + RAX*0x1 + -0x2],0x0
JZ 0x001c9286
LAB_001c92a1:
MOV RDX,qword ptr [RCX]
MOV RDI,qword ptr [R8]
JMP 0x001c92b5
LAB_001c92a9:
MOV RDX,qword ptr [RCX]
MOV RDI,qword ptr [R8]
CMP RAX,0x1
JNZ 0x001c92e8
LAB_001c92b5:
PUSH RBP
MOV RBP,RSP
ADD RAX,RSI
LAB_001c92bc:
MOV R9D,EDX
AND R9D,0x3f
ADD R9,RDI
MOVZX R10D,byte ptr [RSI]
IMUL R10,R9
MOV R9,RDX
SHL R9,0x8
ADD R9,R10
XOR RDX,R9
ADD RDI,0x3
INC RSI
CMP RSI,RAX
JC 0x001c92bc
POP RBP
LAB_001c92e8:
MOV qword ptr [RCX],RDX
MOV qword ptr [R8],RDI
RET
|
void my_hash_sort_ucs2_bin
(int8 param_1,byte *param_2,long param_3,ulong *param_4,long *param_5)
{
byte *pbVar1;
long lVar2;
ulong uVar3;
long lVar4;
do {
lVar2 = param_3;
if (lVar2 < 2) {
uVar3 = *param_4;
lVar4 = *param_5;
if (lVar2 != 1) goto LAB_001c92e8;
goto LAB_001c92b5;
}
} while ((param_2[lVar2 + -1] == 0x20) && (param_3 = lVar2 + -2, param_2[lVar2 + -2] == 0));
uVar3 = *param_4;
lVar4 = *param_5;
LAB_001c92b5:
pbVar1 = param_2 + lVar2;
do {
uVar3 = uVar3 ^ uVar3 * 0x100 + (ulong)*param_2 * ((ulong)((uint)uVar3 & 0x3f) + lVar4);
lVar4 = lVar4 + 3;
param_2 = param_2 + 1;
} while (param_2 < pbVar1);
LAB_001c92e8:
*param_4 = uVar3;
*param_5 = lVar4;
return;
}
| |
38,658 | maria_ftparser_alloc_param | eloqsql/storage/maria/ma_ft_parser.c | MYSQL_FTPARSER_PARAM* maria_ftparser_alloc_param(MARIA_HA *info)
{
if (!info->ftparser_param)
{
/*
. info->ftparser_param can not be zero after the initialization,
because it always includes built-in fulltext parser. And built-in
parser can be called even if the table has no fulltext indexes and
no varchar/text fields.
ftb_find_relevance... parser (ftb_find_relevance_parse,
ftb_find_relevance_add_word) calls ftb_check_phrase... parser
(ftb_check_phrase_internal, ftb_phrase_add_word). Thus MAX_PARAM_NR=2.
*/
info->ftparser_param= (MYSQL_FTPARSER_PARAM *)
my_malloc(PSI_INSTRUMENT_ME, MAX_PARAM_NR * sizeof(MYSQL_FTPARSER_PARAM) *
info->s->ftkeys, MYF(MY_WME | MY_ZEROFILL));
init_alloc_root(PSI_INSTRUMENT_ME, &info->ft_memroot,
FTPARSER_MEMROOT_ALLOC_SIZE, 0, MYF(0));
}
return info->ftparser_param;
} | O3 | c | maria_ftparser_alloc_param:
movq 0x368(%rdi), %rax
testq %rax, %rax
je 0x6011e
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movl 0x748(%rax), %esi
shlq $0x7, %rsi
movl $0x30, %edx
xorl %edi, %edi
callq 0xa46f9
movq %rax, 0x368(%rbx)
leaq 0x328(%rbx), %rsi
movl $0x10000, %edx # imm = 0x10000
xorl %edi, %edi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x9eac0
movq 0x368(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| maria_ftparser_alloc_param:
mov rax, [rdi+368h]
test rax, rax
jz short loc_6011E
retn
loc_6011E:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
mov rax, [rdi]
mov esi, [rax+748h]
shl rsi, 7
mov edx, 30h ; '0'
xor edi, edi
call my_malloc
mov [rbx+368h], rax
lea rsi, [rbx+328h]
mov edx, 10000h
xor edi, edi
xor ecx, ecx
xor r8d, r8d
call init_alloc_root
mov rax, [rbx+368h]
add rsp, 8
pop rbx
pop rbp
retn
| long long maria_ftparser_alloc_param(_QWORD *a1)
{
long long result; // rax
result = a1[109];
if ( !result )
{
a1[109] = my_malloc(0LL, (unsigned long long)*(unsigned int *)(*a1 + 1864LL) << 7, 48LL);
init_alloc_root(0LL, a1 + 101, 0x10000LL, 0LL, 0LL);
return a1[109];
}
return result;
}
| maria_ftparser_alloc_param:
MOV RAX,qword ptr [RDI + 0x368]
TEST RAX,RAX
JZ 0x0016011e
RET
LAB_0016011e:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RAX,qword ptr [RDI]
MOV ESI,dword ptr [RAX + 0x748]
SHL RSI,0x7
MOV EDX,0x30
XOR EDI,EDI
CALL 0x001a46f9
MOV qword ptr [RBX + 0x368],RAX
LEA RSI,[RBX + 0x328]
MOV EDX,0x10000
XOR EDI,EDI
XOR ECX,ECX
XOR R8D,R8D
CALL 0x0019eac0
MOV RAX,qword ptr [RBX + 0x368]
ADD RSP,0x8
POP RBX
POP RBP
RET
|
long maria_ftparser_alloc_param(long *param_1)
{
long lVar1;
int8 in_R9;
long lVar2;
lVar2 = param_1[0x6d];
if (lVar2 != 0) {
return lVar2;
}
lVar1 = my_malloc(0,(ulong)*(uint *)(*param_1 + 0x748) << 7,0x30);
param_1[0x6d] = lVar1;
init_alloc_root(0,param_1 + 0x65,0x10000,0,0,in_R9,lVar2);
return param_1[0x6d];
}
| |
38,659 | js_object___lookupGetter__ | bluesky950520[P]quickjs/quickjs.c | static JSValue js_object___lookupGetter__(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int setter)
{
JSValue obj, res = JS_EXCEPTION;
JSAtom prop = JS_ATOM_NULL;
JSPropertyDescriptor desc;
int has_prop;
obj = JS_ToObject(ctx, this_val);
if (JS_IsException(obj))
goto exception;
prop = JS_ValueToAtom(ctx, argv[0]);
if (unlikely(prop == JS_ATOM_NULL))
goto exception;
for (;;) {
has_prop = JS_GetOwnPropertyInternal(ctx, &desc, JS_VALUE_GET_OBJ(obj), prop);
if (has_prop < 0)
goto exception;
if (has_prop) {
if (desc.flags & JS_PROP_GETSET)
res = js_dup(setter ? desc.setter : desc.getter);
else
res = JS_UNDEFINED;
js_free_desc(ctx, &desc);
break;
}
obj = JS_GetPrototypeFree(ctx, obj);
if (JS_IsException(obj))
goto exception;
if (JS_IsNull(obj)) {
res = JS_UNDEFINED;
break;
}
/* avoid infinite loop (possible with proxies) */
if (js_poll_interrupts(ctx))
goto exception;
}
exception:
JS_FreeAtom(ctx, prop);
JS_FreeValue(ctx, obj);
return res;
} | O0 | c | js_object___lookupGetter__:
subq $0xf8, %rsp
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xe0(%rsp)
movq %rdi, 0xd0(%rsp)
movl %ecx, 0xcc(%rsp)
movq %r8, 0xc0(%rsp)
movl %r9d, 0xbc(%rsp)
movq 0x4bd63(%rip), %rax # 0x113bb0
movq %rax, 0xe8(%rsp)
movq 0x4bd5c(%rip), %rax # 0x113bb8
movq %rax, 0xf0(%rsp)
movl $0x0, 0xa4(%rsp)
movq 0xd0(%rsp), %rdi
movq 0xd8(%rsp), %rsi
movq 0xe0(%rsp), %rdx
callq 0x3da60
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xa8(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0xc7ecf
jmp 0xc80d1
movq 0xd0(%rsp), %rdi
movq 0xc0(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x374f0
movl %eax, 0xa4(%rsp)
cmpl $0x0, 0xa4(%rsp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xc7f13
jmp 0xc80d1
jmp 0xc7f15
movq 0xd0(%rsp), %rdi
movq 0xa8(%rsp), %rdx
movl 0xa4(%rsp), %ecx
leaq 0x68(%rsp), %rsi
callq 0x364b0
movl %eax, 0x64(%rsp)
cmpl $0x0, 0x64(%rsp)
jge 0xc7f46
jmp 0xc80d1
cmpl $0x0, 0x64(%rsp)
je 0xc8014
movl 0x68(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xc7fd2
cmpl $0x0, 0xbc(%rsp)
je 0xc7f83
movq 0x90(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x38(%rsp)
jmp 0xc7f9d
movq 0x80(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x279c0
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0xf0(%rsp)
jmp 0xc7ffd
movl $0x0, 0x20(%rsp)
movq $0x3, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0xf0(%rsp)
movq 0xd0(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x66cf0
jmp 0xc80cf
movq 0xd0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
movq 0xb0(%rsp), %rdx
callq 0x66550
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xa8(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0xc8071
jmp 0xc80d1
movq 0xa8(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0x34530
cmpl $0x0, %eax
je 0xc80b6
movl $0x0, (%rsp)
movq $0x3, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0xf0(%rsp)
jmp 0xc80cf
movq 0xd0(%rsp), %rdi
callq 0x665b0
cmpl $0x0, %eax
je 0xc80ca
jmp 0xc80d1
jmp 0xc7f15
jmp 0xc80d1
movq 0xd0(%rsp), %rdi
movl 0xa4(%rsp), %esi
callq 0x2f330
movq 0xd0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
movq 0xb0(%rsp), %rdx
callq 0x29f80
movq 0xe8(%rsp), %rax
movq 0xf0(%rsp), %rdx
addq $0xf8, %rsp
retq
nopw (%rax,%rax)
| js_object___lookupGetter__:
sub rsp, 0F8h
mov [rsp+0F8h+var_20], rsi
mov [rsp+0F8h+var_18], rdx
mov [rsp+0F8h+var_28], rdi
mov [rsp+0F8h+var_2C], ecx
mov [rsp+0F8h+var_38], r8
mov [rsp+0F8h+var_3C], r9d
mov rax, cs:qword_113BB0
mov [rsp+0F8h+var_10], rax
mov rax, cs:qword_113BB8
mov [rsp+0F8h+var_8], rax
mov [rsp+0F8h+var_54], 0
mov rdi, [rsp+0F8h+var_28]
mov rsi, [rsp+0F8h+var_20]
mov rdx, [rsp+0F8h+var_18]
call JS_ToObject
mov [rsp+0F8h+var_A8], rax
mov [rsp+0F8h+var_A0], rdx
mov rax, [rsp+0F8h+var_A8]
mov [rsp+0F8h+var_50], rax
mov rax, [rsp+0F8h+var_A0]
mov [rsp+0F8h+var_48], rax
mov rdi, [rsp+0F8h+var_50]
mov rsi, [rsp+0F8h+var_48]
call JS_IsException_1
cmp eax, 0
jz short loc_C7ECF
jmp loc_C80D1
loc_C7ECF:
mov rdi, [rsp+0F8h+var_28]
mov rax, [rsp+0F8h+var_38]
mov rsi, [rax]
mov rdx, [rax+8]
call JS_ValueToAtom
mov [rsp+0F8h+var_54], eax
cmp [rsp+0F8h+var_54], 0
setz al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_C7F13
jmp loc_C80D1
loc_C7F13:
jmp short $+2
loc_C7F15:
mov rdi, [rsp+0F8h+var_28]
mov rdx, [rsp+0F8h+var_50]
mov ecx, [rsp+0F8h+var_54]
lea rsi, [rsp+0F8h+var_90]
call JS_GetOwnPropertyInternal
mov [rsp+0F8h+var_94], eax
cmp [rsp+0F8h+var_94], 0
jge short loc_C7F46
jmp loc_C80D1
loc_C7F46:
cmp [rsp+0F8h+var_94], 0
jz loc_C8014
mov eax, [rsp+0F8h+var_90]
and eax, 10h
cmp eax, 0
jz short loc_C7FD2
cmp [rsp+0F8h+var_3C], 0
jz short loc_C7F83
mov rax, [rsp+0F8h+var_68]
mov [rsp+0F8h+var_C8], rax
mov rax, [rsp+0F8h+var_60]
mov [rsp+0F8h+var_C0], rax
jmp short loc_C7F9D
loc_C7F83:
mov rax, [rsp+0F8h+var_78]
mov [rsp+0F8h+var_C8], rax
mov rax, [rsp+0F8h+var_70]
mov [rsp+0F8h+var_C0], rax
loc_C7F9D:
mov rdi, [rsp+0F8h+var_C8]
mov rsi, [rsp+0F8h+var_C0]
call js_dup
mov [rsp+0F8h+var_B8], rax
mov [rsp+0F8h+var_B0], rdx
mov rax, [rsp+0F8h+var_B8]
mov [rsp+0F8h+var_10], rax
mov rax, [rsp+0F8h+var_B0]
mov [rsp+0F8h+var_8], rax
jmp short loc_C7FFD
loc_C7FD2:
mov dword ptr [rsp+0F8h+var_D8], 0
mov [rsp+0F8h+var_D0], 3
mov rax, [rsp+0F8h+var_D8]
mov [rsp+0F8h+var_10], rax
mov rax, [rsp+0F8h+var_D0]
mov [rsp+0F8h+var_8], rax
loc_C7FFD:
mov rdi, [rsp+0F8h+var_28]
lea rsi, [rsp+0F8h+var_90]
call js_free_desc
jmp loc_C80CF
loc_C8014:
mov rdi, [rsp+0F8h+var_28]
mov rsi, [rsp+0F8h+var_50]
mov rdx, [rsp+0F8h+var_48]
call JS_GetPrototypeFree
mov [rsp+0F8h+var_E8], rax
mov [rsp+0F8h+var_E0], rdx
mov rax, [rsp+0F8h+var_E8]
mov [rsp+0F8h+var_50], rax
mov rax, [rsp+0F8h+var_E0]
mov [rsp+0F8h+var_48], rax
mov rdi, [rsp+0F8h+var_50]
mov rsi, [rsp+0F8h+var_48]
call JS_IsException_1
cmp eax, 0
jz short loc_C8071
jmp short loc_C80D1
loc_C8071:
mov rdi, [rsp+0F8h+var_50]
mov rsi, [rsp+0F8h+var_48]
call JS_IsNull_1
cmp eax, 0
jz short loc_C80B6
mov dword ptr [rsp+0F8h+var_F8], 0
mov [rsp+0F8h+var_F0], 3
mov rax, [rsp+0F8h+var_F8]
mov [rsp+0F8h+var_10], rax
mov rax, [rsp+0F8h+var_F0]
mov [rsp+0F8h+var_8], rax
jmp short loc_C80CF
loc_C80B6:
mov rdi, [rsp+0F8h+var_28]
call js_poll_interrupts
cmp eax, 0
jz short loc_C80CA
jmp short loc_C80D1
loc_C80CA:
jmp loc_C7F15
loc_C80CF:
jmp short $+2
loc_C80D1:
mov rdi, [rsp+0F8h+var_28]
mov esi, [rsp+0F8h+var_54]
call JS_FreeAtom
mov rdi, [rsp+0F8h+var_28]
mov rsi, [rsp+0F8h+var_50]
mov rdx, [rsp+0F8h+var_48]
call JS_FreeValue
mov rax, [rsp+0F8h+var_10]
mov rdx, [rsp+0F8h+var_8]
add rsp, 0F8h
retn
| _DWORD * js_object___lookupGetter__(
long long a1,
_DWORD *a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v14; // rdx
_DWORD *v15; // rax
long long v16; // rdx
long long v17; // rdx
_DWORD *v19; // [rsp+0h] [rbp-F8h]
_DWORD *v20; // [rsp+20h] [rbp-D8h]
int OwnPropertyInternal; // [rsp+64h] [rbp-94h]
long long v22[4]; // [rsp+68h] [rbp-90h] BYREF
long long v23; // [rsp+88h] [rbp-70h]
_DWORD *v24; // [rsp+90h] [rbp-68h]
long long v25; // [rsp+98h] [rbp-60h]
unsigned int v26; // [rsp+A4h] [rbp-54h]
_DWORD *PrototypeFree; // [rsp+A8h] [rbp-50h]
long long v28; // [rsp+B0h] [rbp-48h]
int v29; // [rsp+BCh] [rbp-3Ch]
long long *v30; // [rsp+C0h] [rbp-38h]
int v31; // [rsp+CCh] [rbp-2Ch]
long long v32; // [rsp+D0h] [rbp-28h]
_DWORD *v33; // [rsp+D8h] [rbp-20h]
long long v34; // [rsp+E0h] [rbp-18h]
_DWORD *v35; // [rsp+E8h] [rbp-10h]
long long v36; // [rsp+F0h] [rbp-8h]
v33 = a2;
v34 = a3;
v32 = a1;
v31 = a4;
v30 = (long long *)a5;
v29 = a6;
v35 = 0LL;
v36 = 6LL;
v26 = 0;
PrototypeFree = JS_ToObject(a1, a2, a3, a7, a8, a9, a10, a11, a12, a13, a14, a4, a5, a6);
v28 = v14;
if ( !JS_IsException_1((long long)PrototypeFree, v14) )
{
v26 = JS_ValueToAtom(v32, *v30, v30[1]);
if ( v26 )
{
do
{
OwnPropertyInternal = JS_GetOwnPropertyInternal(v32, (long long)v22, (long long)PrototypeFree, v26);
if ( OwnPropertyInternal < 0 )
break;
if ( OwnPropertyInternal )
{
if ( (v22[0] & 0x10) != 0 )
{
if ( v29 )
v15 = js_dup(v24, v25);
else
v15 = js_dup((_DWORD *)v22[3], v23);
v35 = v15;
v36 = v16;
}
else
{
LODWORD(v20) = 0;
v35 = v20;
v36 = 3LL;
}
js_free_desc(v32, v22);
break;
}
PrototypeFree = JS_GetPrototypeFree(v32, (long long)PrototypeFree, v28);
v28 = v17;
if ( JS_IsException_1((long long)PrototypeFree, v17) )
break;
if ( JS_IsNull_1((long long)PrototypeFree, v28) )
{
LODWORD(v19) = 0;
v35 = v19;
v36 = 3LL;
break;
}
}
while ( !(unsigned int)js_poll_interrupts(v32) );
}
}
JS_FreeAtom(v32, v26);
JS_FreeValue(v32, (long long)PrototypeFree, v28);
return v35;
}
| js_object___lookupGetter__:
SUB RSP,0xf8
MOV qword ptr [RSP + 0xd8],RSI
MOV qword ptr [RSP + 0xe0],RDX
MOV qword ptr [RSP + 0xd0],RDI
MOV dword ptr [RSP + 0xcc],ECX
MOV qword ptr [RSP + 0xc0],R8
MOV dword ptr [RSP + 0xbc],R9D
MOV RAX,qword ptr [0x00213bb0]
MOV qword ptr [RSP + 0xe8],RAX
MOV RAX,qword ptr [0x00213bb8]
MOV qword ptr [RSP + 0xf0],RAX
MOV dword ptr [RSP + 0xa4],0x0
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xd8]
MOV RDX,qword ptr [RSP + 0xe0]
CALL 0x0013da60
MOV qword ptr [RSP + 0x50],RAX
MOV qword ptr [RSP + 0x58],RDX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0xa8],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0xb0],RAX
MOV RDI,qword ptr [RSP + 0xa8]
MOV RSI,qword ptr [RSP + 0xb0]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x001c7ecf
JMP 0x001c80d1
LAB_001c7ecf:
MOV RDI,qword ptr [RSP + 0xd0]
MOV RAX,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x001374f0
MOV dword ptr [RSP + 0xa4],EAX
CMP dword ptr [RSP + 0xa4],0x0
SETZ AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001c7f13
JMP 0x001c80d1
LAB_001c7f13:
JMP 0x001c7f15
LAB_001c7f15:
MOV RDI,qword ptr [RSP + 0xd0]
MOV RDX,qword ptr [RSP + 0xa8]
MOV ECX,dword ptr [RSP + 0xa4]
LEA RSI,[RSP + 0x68]
CALL 0x001364b0
MOV dword ptr [RSP + 0x64],EAX
CMP dword ptr [RSP + 0x64],0x0
JGE 0x001c7f46
JMP 0x001c80d1
LAB_001c7f46:
CMP dword ptr [RSP + 0x64],0x0
JZ 0x001c8014
MOV EAX,dword ptr [RSP + 0x68]
AND EAX,0x10
CMP EAX,0x0
JZ 0x001c7fd2
CMP dword ptr [RSP + 0xbc],0x0
JZ 0x001c7f83
MOV RAX,qword ptr [RSP + 0x90]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x38],RAX
JMP 0x001c7f9d
LAB_001c7f83:
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0x38],RAX
LAB_001c7f9d:
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x38]
CALL 0x001279c0
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0xe8],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0xf0],RAX
JMP 0x001c7ffd
LAB_001c7fd2:
MOV dword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x28],0x3
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0xe8],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0xf0],RAX
LAB_001c7ffd:
MOV RDI,qword ptr [RSP + 0xd0]
LEA RSI,[RSP + 0x68]
CALL 0x00166cf0
JMP 0x001c80cf
LAB_001c8014:
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xa8]
MOV RDX,qword ptr [RSP + 0xb0]
CALL 0x00166550
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],RDX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0xa8],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0xb0],RAX
MOV RDI,qword ptr [RSP + 0xa8]
MOV RSI,qword ptr [RSP + 0xb0]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x001c8071
JMP 0x001c80d1
LAB_001c8071:
MOV RDI,qword ptr [RSP + 0xa8]
MOV RSI,qword ptr [RSP + 0xb0]
CALL 0x00134530
CMP EAX,0x0
JZ 0x001c80b6
MOV dword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x3
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0xe8],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0xf0],RAX
JMP 0x001c80cf
LAB_001c80b6:
MOV RDI,qword ptr [RSP + 0xd0]
CALL 0x001665b0
CMP EAX,0x0
JZ 0x001c80ca
JMP 0x001c80d1
LAB_001c80ca:
JMP 0x001c7f15
LAB_001c80cf:
JMP 0x001c80d1
LAB_001c80d1:
MOV RDI,qword ptr [RSP + 0xd0]
MOV ESI,dword ptr [RSP + 0xa4]
CALL 0x0012f330
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xa8]
MOV RDX,qword ptr [RSP + 0xb0]
CALL 0x00129f80
MOV RAX,qword ptr [RSP + 0xe8]
MOV RDX,qword ptr [RSP + 0xf0]
ADD RSP,0xf8
RET
|
int1 [16]
js_object___lookupGetter__
(int8 param_1,int8 param_2,int8 param_3,int4 param_4,
int8 *param_5,int param_6)
{
int iVar1;
int1 auVar2 [16];
uint uStack_f4;
uint uStack_d4;
int8 local_c8;
int8 local_c0;
uint local_90 [6];
int8 local_78;
int8 local_70;
int8 local_68;
int8 local_60;
int local_54;
int1 local_50 [16];
int local_3c;
int8 *local_38;
int4 local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int1 local_10 [16];
local_10._0_8_ = DAT_00213bb0;
local_10._8_8_ = DAT_00213bb8;
local_54 = 0;
local_3c = param_6;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
local_50 = JS_ToObject(param_1,param_2,param_3);
iVar1 = JS_IsException(local_50._0_8_,local_50._8_8_);
if (iVar1 == 0) {
local_54 = JS_ValueToAtom(local_28,*local_38,local_38[1]);
if (local_54 != 0) {
do {
iVar1 = JS_GetOwnPropertyInternal(local_28,local_90,local_50._0_8_,local_54);
if (iVar1 < 0) break;
if (iVar1 != 0) {
if ((local_90[0] & 0x10) == 0) {
local_10._8_8_ = 3;
local_10._0_8_ = (ulong)uStack_d4 << 0x20;
}
else {
if (local_3c == 0) {
local_c8 = local_78;
local_c0 = local_70;
}
else {
local_c8 = local_68;
local_c0 = local_60;
}
local_10 = js_dup(local_c8,local_c0);
}
js_free_desc(local_28,local_90);
break;
}
auVar2 = JS_GetPrototypeFree(local_28,local_50._0_8_,local_50._8_8_);
local_50 = auVar2;
iVar1 = JS_IsException(auVar2._0_8_,auVar2._8_8_);
if (iVar1 != 0) break;
iVar1 = JS_IsNull(local_50._0_8_,local_50._8_8_);
if (iVar1 != 0) {
local_10._8_8_ = 3;
local_10._0_8_ = (ulong)uStack_f4 << 0x20;
break;
}
iVar1 = js_poll_interrupts(local_28);
} while (iVar1 == 0);
}
}
JS_FreeAtom(local_28,local_54);
JS_FreeValue(local_28,local_50._0_8_,local_50._8_8_);
return local_10;
}
| |
38,660 | my_mutex_init | eloqsql/mysys/thr_mutex.c | void my_mutex_init()
{
/* Initialize mutex attributes */
#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
/*
Set mutex type to "fast" a.k.a "adaptive"
In this case the thread may steal the mutex from some other thread
that is waiting for the same mutex. This will save us some
context switches but may cause a thread to 'starve forever' while
waiting for the mutex (not likely if the code within the mutex is
short).
*/
pthread_mutexattr_init(&my_fast_mutexattr);
pthread_mutexattr_settype(&my_fast_mutexattr,
PTHREAD_MUTEX_ADAPTIVE_NP);
#endif
#ifdef PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
/*
Set mutex type to "errorcheck"
*/
pthread_mutexattr_init(&my_errorcheck_mutexattr);
pthread_mutexattr_settype(&my_errorcheck_mutexattr,
PTHREAD_MUTEX_ERRORCHECK);
#endif
#if defined(SAFE_MUTEX_DEFINED)
safe_mutex_global_init();
#endif
} | O0 | c | my_mutex_init:
pushq %rbp
movq %rsp, %rbp
leaq 0x35e05d(%rip), %rdi # 0x388558
callq 0x24070
leaq 0x35e051(%rip), %rdi # 0x388558
movl $0x3, %esi
callq 0x24440
leaq 0x35e044(%rip), %rdi # 0x38855c
callq 0x24070
leaq 0x35e038(%rip), %rdi # 0x38855c
movl $0x2, %esi
callq 0x24440
popq %rbp
retq
| my_mutex_init:
push rbp
mov rbp, rsp
lea rdi, my_fast_mutexattr
call _pthread_mutexattr_init
lea rdi, my_fast_mutexattr
mov esi, 3
call _pthread_mutexattr_settype
lea rdi, my_errorcheck_mutexattr
call _pthread_mutexattr_init
lea rdi, my_errorcheck_mutexattr
mov esi, 2
call _pthread_mutexattr_settype
pop rbp
retn
| long long my_mutex_init()
{
pthread_mutexattr_init(&my_fast_mutexattr);
pthread_mutexattr_settype(&my_fast_mutexattr, 3LL);
pthread_mutexattr_init(&my_errorcheck_mutexattr);
return pthread_mutexattr_settype(&my_errorcheck_mutexattr, 2LL);
}
| my_mutex_init:
PUSH RBP
MOV RBP,RSP
LEA RDI,[0x488558]
CALL 0x00124070
LEA RDI,[0x488558]
MOV ESI,0x3
CALL 0x00124440
LEA RDI,[0x48855c]
CALL 0x00124070
LEA RDI,[0x48855c]
MOV ESI,0x2
CALL 0x00124440
POP RBP
RET
|
void my_mutex_init(void)
{
pthread_mutexattr_init((pthread_mutexattr_t *)&my_fast_mutexattr);
pthread_mutexattr_settype((pthread_mutexattr_t *)&my_fast_mutexattr,3);
pthread_mutexattr_init((pthread_mutexattr_t *)&my_errorcheck_mutexattr);
pthread_mutexattr_settype((pthread_mutexattr_t *)&my_errorcheck_mutexattr,2);
return;
}
| |
38,661 | 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 0x4ab96
cmpq %rdi, 0x10(%rsi)
jbe 0x4ab96
movslq 0x8(%rdi), %rax
cmpq $0xf, %rax
jg 0x4ab94
movq 0x18(%rsi,%rax,8), %rcx
movq %rcx, (%rdi)
movq %rdi, 0x18(%rsi,%rax,8)
popq %rbp
retq
popq %rbp
jmp 0x36190
| Bfree:
push rbp
mov rbp, rsp
cmp [rsi], rdi
ja short loc_4AB96
cmp [rsi+10h], rdi
jbe short loc_4AB96
movsxd rax, dword ptr [rdi+8]
cmp rax, 0Fh
jg short loc_4AB94
mov rcx, [rsi+rax*8+18h]
mov [rdi], rcx
mov [rsi+rax*8+18h], rdi
loc_4AB94:
pop rbp
retn
loc_4AB96:
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 0x0014ab96
CMP qword ptr [RSI + 0x10],RDI
JBE 0x0014ab96
MOVSXD RAX,dword ptr [RDI + 0x8]
CMP RAX,0xf
JG 0x0014ab94
MOV RCX,qword ptr [RSI + RAX*0x8 + 0x18]
MOV qword ptr [RDI],RCX
MOV qword ptr [RSI + RAX*0x8 + 0x18],RDI
LAB_0014ab94:
POP RBP
RET
LAB_0014ab96:
POP RBP
JMP 0x00136190
|
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;
}
| |
38,662 | js_alloc_string | bluesky950520[P]quickjs/quickjs.c | static JSString *js_alloc_string(JSContext *ctx, int max_len, int is_wide_char)
{
JSString *p;
p = js_alloc_string_rt(ctx->rt, max_len, is_wide_char);
if (unlikely(!p)) {
JS_ThrowOutOfMemory(ctx);
return NULL;
}
return p;
} | O0 | c | js_alloc_string:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
callq 0x63810
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2fab7
movq 0x28(%rsp), %rdi
callq 0x27f00
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq $0x0, 0x30(%rsp)
jmp 0x2fac1
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
| js_alloc_string:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_14], esi
mov [rsp+38h+var_18], edx
mov rax, [rsp+38h+var_10]
mov rdi, [rax+18h]
mov esi, [rsp+38h+var_14]
mov edx, [rsp+38h+var_18]
call js_alloc_string_rt
mov [rsp+38h+var_20], rax
cmp [rsp+38h+var_20], 0
setnz al
xor al, 0FFh
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_2FAB7
mov rdi, [rsp+38h+var_10]
call JS_ThrowOutOfMemory
mov [rsp+38h+var_30], rax
mov [rsp+38h+var_28], rdx
mov [rsp+38h+var_8], 0
jmp short loc_2FAC1
loc_2FAB7:
mov rax, [rsp+38h+var_20]
mov [rsp+38h+var_8], rax
loc_2FAC1:
mov rax, [rsp+38h+var_8]
add rsp, 38h
retn
| long long js_alloc_string(long long a1, unsigned int a2, unsigned int a3)
{
int v3; // edx
long long v4; // rcx
int v5; // r8d
int v6; // r9d
long long v8; // [rsp+18h] [rbp-20h]
v8 = js_alloc_string_rt(*(_QWORD *)(a1 + 24), a2, a3);
if ( v8 )
return v8;
JS_ThrowOutOfMemory(a1, a2, v3, v4, v5, v6);
return 0LL;
}
| js_alloc_string:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV dword ptr [RSP + 0x24],ESI
MOV dword ptr [RSP + 0x20],EDX
MOV RAX,qword ptr [RSP + 0x28]
MOV RDI,qword ptr [RAX + 0x18]
MOV ESI,dword ptr [RSP + 0x24]
MOV EDX,dword ptr [RSP + 0x20]
CALL 0x00163810
MOV qword ptr [RSP + 0x18],RAX
CMP qword ptr [RSP + 0x18],0x0
SETNZ AL
XOR AL,0xff
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0012fab7
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x00127f00
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RSP + 0x30],0x0
JMP 0x0012fac1
LAB_0012fab7:
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x30],RAX
LAB_0012fac1:
MOV RAX,qword ptr [RSP + 0x30]
ADD RSP,0x38
RET
|
long js_alloc_string(long param_1,int4 param_2,int4 param_3)
{
long local_8;
local_8 = js_alloc_string_rt(*(int8 *)(param_1 + 0x18),param_2,param_3);
if (local_8 == 0) {
JS_ThrowOutOfMemory(param_1);
local_8 = 0;
}
return local_8;
}
| |
38,663 | js_alloc_string | bluesky950520[P]quickjs/quickjs.c | static JSString *js_alloc_string(JSContext *ctx, int max_len, int is_wide_char)
{
JSString *p;
p = js_alloc_string_rt(ctx->rt, max_len, is_wide_char);
if (unlikely(!p)) {
JS_ThrowOutOfMemory(ctx);
return NULL;
}
return p;
} | O2 | c | js_alloc_string:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x38615
movq %rax, %r14
testq %rax, %rax
je 0x1e918
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x1ad90
jmp 0x1e90d
| js_alloc_string:
push r14
push rbx
push rax
mov rbx, rdi
mov rdi, [rdi+18h]
call js_alloc_string_rt
mov r14, rax
test rax, rax
jz short loc_1E918
loc_1E90D:
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
loc_1E918:
mov rdi, rbx
call JS_ThrowOutOfMemory
jmp short loc_1E90D
| long long js_alloc_string(long long a1, long long a2, long long a3)
{
int v3; // edx
int v4; // ecx
int v5; // r8d
int v6; // r9d
long long v7; // r14
v7 = js_alloc_string_rt(*(_QWORD *)(a1 + 24), a2, a3);
if ( !v7 )
JS_ThrowOutOfMemory(a1, a2, v3, v4, v5, v6);
return v7;
}
| js_alloc_string:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x18]
CALL 0x00138615
MOV R14,RAX
TEST RAX,RAX
JZ 0x0011e918
LAB_0011e90d:
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_0011e918:
MOV RDI,RBX
CALL 0x0011ad90
JMP 0x0011e90d
|
long js_alloc_string(long param_1)
{
long lVar1;
lVar1 = js_alloc_string_rt(*(int8 *)(param_1 + 0x18));
if (lVar1 == 0) {
JS_ThrowOutOfMemory(param_1);
}
return lVar1;
}
| |
38,664 | list_walk | eloqsql/libmariadb/libmariadb/ma_list.c | int list_walk(LIST *list, list_walk_action action, gptr argument)
{
int error=0;
while (list)
{
if ((error = (*action)(list->data,argument)))
return error;
list= list_rest(list);
}
return 0;
} | O0 | c | list_walk:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7dca2
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x7dc94
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7dca9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x7dc6b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| list_walk:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], 0
loc_7DC6B:
cmp [rbp+var_10], 0
jz short loc_7DCA2
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
mov rdi, [rcx+10h]
mov rsi, [rbp+var_20]
call rax
mov [rbp+var_24], eax
cmp eax, 0
jz short loc_7DC94
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
jmp short loc_7DCA9
loc_7DC94:
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_10], rax
jmp short loc_7DC6B
loc_7DCA2:
mov [rbp+var_4], 0
loc_7DCA9:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long list_walk(long long a1, long long ( *a2)(_QWORD, long long), long long a3)
{
unsigned int v4; // [rsp+Ch] [rbp-24h]
while ( a1 )
{
v4 = a2(*(_QWORD *)(a1 + 16), a3);
if ( v4 )
return v4;
a1 = *(_QWORD *)(a1 + 8);
}
return 0;
}
| list_walk:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],0x0
LAB_0017dc6b:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0017dca2
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RCX + 0x10]
MOV RSI,qword ptr [RBP + -0x20]
CALL RAX
MOV dword ptr [RBP + -0x24],EAX
CMP EAX,0x0
JZ 0x0017dc94
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0017dca9
LAB_0017dc94:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0017dc6b
LAB_0017dca2:
MOV dword ptr [RBP + -0x4],0x0
LAB_0017dca9:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int list_walk(long param_1,code *param_2,int8 param_3)
{
int iVar1;
long local_18;
local_18 = param_1;
while( true ) {
if (local_18 == 0) {
return 0;
}
iVar1 = (*param_2)(*(int8 *)(local_18 + 0x10),param_3);
if (iVar1 != 0) break;
local_18 = *(long *)(local_18 + 8);
}
return iVar1;
}
| |
38,665 | parseParameters(int, char**) | DanielDanyang[P]CSC3050-2025-Spring-Project-4/src/MainMulCache.cpp | bool parseParameters(int argc, char **argv) {
// Read Parameters
if (argc > 1) {
traceFilePath = argv[1];
return true;
} else {
return false;
}
} | O3 | cpp | parseParameters(int, char**):
cmpl $0x2, %edi
jl 0x27f1
movq 0x8(%rsi), %rax
movq %rax, 0x59cf(%rip) # 0x81c0
cmpl $0x2, %edi
setge %al
retq
| _Z15parseParametersiPPc:
cmp edi, 2
jl short loc_27F1
mov rax, [rsi+8]
mov cs:traceFilePath, rax
loc_27F1:
cmp edi, 2
setnl al
retn
| bool parseParameters(int a1, char **a2)
{
if ( a1 >= 2 )
traceFilePath = (long long)a2[1];
return a1 >= 2;
}
| parseParameters:
CMP EDI,0x2
JL 0x001027f1
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [0x001081c0],RAX
LAB_001027f1:
CMP EDI,0x2
SETGE AL
RET
|
/* parseParameters(int, char**) */
bool parseParameters(int param_1,char **param_2)
{
if (1 < param_1) {
traceFilePath = param_2[1];
}
return 1 < param_1;
}
| |
38,666 | trnman_new_trn | eloqsql/storage/maria/trnman.c | TRN *trnman_new_trn(WT_THD *wt)
{
int res;
TRN *trn;
union { TRN *trn; void *v; } tmp;
DBUG_ENTER("trnman_new_trn");
/*
we have a mutex, to do simple things under it - allocate a TRN,
increment trnman_active_transactions, set trn->min_read_from.
Note that all the above is fast. generating short_id may be slow,
as it involves scanning a large array - so it's done outside of the
mutex.
*/
DBUG_PRINT("info", ("mysql_mutex_lock LOCK_trn_list"));
mysql_mutex_lock(&LOCK_trn_list);
/* Allocating a new TRN structure */
tmp.trn= pool;
/*
Popping an unused TRN from the pool
(ABA isn't possible, we're behind a mutex
*/
while (tmp.trn && !my_atomic_casptr((void **)(char*) &pool, &tmp.v,
(void *)tmp.trn->next))
/* no-op */;
/* Nothing in the pool ? Allocate a new one */
if (!(trn= tmp.trn))
{
/*
trn should be completely initialized at create time to allow
one to keep a known state on it.
(Like redo_lns, which is assumed to be 0 at start of row handling
and reset to zero before end of row handling)
*/
trn= (TRN *)my_malloc(PSI_INSTRUMENT_ME, sizeof(TRN), MYF(MY_WME | MY_ZEROFILL));
if (unlikely(!trn))
{
DBUG_PRINT("info", ("mysql_mutex_unlock LOCK_trn_list"));
mysql_mutex_unlock(&LOCK_trn_list);
return 0;
}
trnman_allocated_transactions++;
mysql_mutex_init(key_TRN_state_lock, &trn->state_lock, MY_MUTEX_INIT_FAST);
}
trn->wt= wt;
trn->pins= lf_hash_get_pins(&trid_to_trn);
if (!trn->pins)
{
trnman_free_trn(trn);
mysql_mutex_unlock(&LOCK_trn_list);
return 0;
}
trnman_active_transactions++;
trn->min_read_from= active_list_min.next->trid;
trn->trid= new_trid();
trn->next= &active_list_max;
trn->prev= active_list_max.prev;
active_list_max.prev= trn->prev->next= trn;
trid_min_read_from= active_list_min.next->min_read_from;
DBUG_PRINT("info", ("mysql_mutex_unlock LOCK_trn_list"));
mysql_mutex_unlock(&LOCK_trn_list);
if (unlikely(!trn->min_read_from))
{
/*
We are the only transaction. Set min_read_from so that we can read
our own rows
*/
trn->min_read_from= trn->trid + 1;
}
/* no other transaction can read changes done by this one */
trn->commit_trid= MAX_TRID;
trn->rec_lsn= trn->undo_lsn= trn->first_undo_lsn= 0;
trn->used_tables= 0;
trn->used_instances= 0;
trn->locked_tables= 0;
trn->flags= 0;
/*
only after the following function TRN is considered initialized,
so it must be done the last
*/
mysql_mutex_lock(&trn->state_lock);
trn->short_id= get_short_trid(trn);
mysql_mutex_unlock(&trn->state_lock);
res= lf_hash_insert(&trid_to_trn, trn->pins, &trn);
DBUG_ASSERT(res <= 0);
if (res)
{
trnman_end_trn(trn, 0);
return 0;
}
DBUG_PRINT("exit", ("trn: %p trid: 0x%lu min_read_from: 0x%lu",
trn, (ulong) trn->trid, (ulong) trn->min_read_from));
DBUG_RETURN(trn);
} | O0 | c | trnman_new_trn:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
jmp 0x76f5e
leaq 0xc0a24b(%rip), %rdi # 0xc811b0
leaq 0xe149b(%rip), %rsi # 0x158407
movl $0x128, %edx # imm = 0x128
callq 0x77290
movq 0xc0a15b(%rip), %rax # 0xc810d8
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x32(%rbp)
je 0x76fd3
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
lock
cmpxchgq %rcx, 0xc0a12e(%rip) # 0xc810d8
movq %rax, %rcx
sete %al
movb %al, -0x41(%rbp)
movq %rcx, -0x40(%rbp)
testb $0x1, %al
jne 0x76fc3
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
xorb $-0x1, %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0x76fdc
jmp 0x76fde
jmp 0x76f81
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x77070
xorl %edi, %edi
movl $0xb0, %esi
movl $0x30, %edx
callq 0xf99f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x77044
jmp 0x77029
jmp 0x7702b
leaq 0xc0a17e(%rip), %rdi # 0xc811b0
callq 0x77300
movq $0x0, -0x8(%rbp)
jmp 0x77280
movl 0xc0a086(%rip), %eax # 0xc810d0
addl $0x1, %eax
movl %eax, 0xc0a07d(%rip) # 0xc810d0
leaq 0x407a6a(%rip), %rax # 0x47eac4
movl (%rax), %edi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
leaq 0xc13765(%rip), %rdx # 0xc8a7d0
callq 0x76dd0
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq 0xc0a065(%rip), %rdi # 0xc810e8
addq $0x28, %rdi
callq 0x102c40
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x770c2
movq -0x20(%rbp), %rdi
callq 0x77360
leaq 0xc0a100(%rip), %rdi # 0xc811b0
callq 0x77300
movq $0x0, -0x8(%rbp)
jmp 0x77280
movl 0xc0a000(%rip), %eax # 0xc810c8
addl $0x1, %eax
movl %eax, 0xc09ff7(%rip) # 0xc810c8
movq 0xc09d98(%rip), %rax # 0xc80e70
movq 0x78(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x80(%rax)
callq 0x783a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x20(%rbp), %rax
leaq 0xc09db6(%rip), %rcx # 0xc80eb8
movq %rcx, 0x68(%rax)
movq 0xc09e1b(%rip), %rcx # 0xc80f28
movq -0x20(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x70(%rcx), %rcx
movq %rax, 0x68(%rcx)
movq %rax, 0xc09dfc(%rip) # 0xc80f28
movq 0xc09d3d(%rip), %rax # 0xc80e70
movq 0x80(%rax), %rax
movq %rax, 0x24e3a7(%rip) # 0x2c54e8
jmp 0x77143
leaq 0xc0a066(%rip), %rdi # 0xc811b0
callq 0x77300
movq -0x20(%rbp), %rax
cmpq $0x0, 0x80(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x7718f
movq -0x20(%rbp), %rax
movq 0x78(%rax), %rcx
addq $0x1, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x20(%rbp), %rax
movq $-0x1, 0x88(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0xa0(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x98(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x90(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0xa8(%rax)
movq -0x20(%rbp), %rax
movw $0x0, 0xae(%rax)
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
leaq 0xe11fa(%rip), %rsi # 0x158407
movl $0x173, %edx # imm = 0x173
callq 0x77290
movq -0x20(%rbp), %rdi
callq 0x77410
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, 0xac(%rax)
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x77300
movq -0x20(%rbp), %rax
movq (%rax), %rsi
leaq 0xc09e9f(%rip), %rdi # 0xc810e8
leaq -0x20(%rbp), %rdx
callq 0x103fd0
movl %eax, -0x14(%rbp)
jmp 0x77257
cmpl $0x0, -0x14(%rbp)
je 0x77272
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x774f0
movq $0x0, -0x8(%rbp)
jmp 0x77280
jmp 0x77274
jmp 0x77276
jmp 0x77278
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| trnman_new_trn:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
jmp short $+2
loc_76F5E:
lea rdi, LOCK_trn_list
lea rsi, aWorkspaceLlm4b_15; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 128h
call inline_mysql_mutex_lock_11
mov rax, cs:pool
mov [rbp+var_28], rax
loc_76F81:
xor eax, eax
cmp [rbp+var_28], 0
mov [rbp+var_32], al
jz short loc_76FD3
mov rax, [rbp+var_28]
mov rax, [rax+68h]
mov [rbp+var_30], rax
mov rax, [rbp+var_28]
mov rcx, [rbp+var_30]
lock cmpxchg cs:pool, rcx
mov rcx, rax
setz al
mov [rbp+var_41], al
mov [rbp+var_40], rcx
test al, 1
jnz short loc_76FC3
mov rax, [rbp+var_40]
mov [rbp+var_28], rax
loc_76FC3:
mov al, [rbp+var_41]
and al, 1
mov [rbp+var_31], al
mov al, [rbp+var_31]
xor al, 0FFh
mov [rbp+var_32], al
loc_76FD3:
mov al, [rbp+var_32]
test al, 1
jnz short loc_76FDC
jmp short loc_76FDE
loc_76FDC:
jmp short loc_76F81
loc_76FDE:
mov rax, [rbp+var_28]
mov [rbp+var_20], rax
cmp rax, 0
jnz loc_77070
xor edi, edi
mov esi, 0B0h
mov edx, 30h ; '0'
call my_malloc
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
setnz al
xor al, 0FFh
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_77044
jmp short $+2
loc_77029:
jmp short $+2
loc_7702B:
lea rdi, LOCK_trn_list
call inline_mysql_mutex_unlock_12
mov [rbp+var_8], 0
jmp loc_77280
loc_77044:
mov eax, cs:trnman_allocated_transactions
add eax, 1
mov cs:trnman_allocated_transactions, eax
lea rax, key_TRN_state_lock
mov edi, [rax]
mov rsi, [rbp+var_20]
add rsi, 10h
lea rdx, my_fast_mutexattr
call inline_mysql_mutex_init_3
loc_77070:
mov rcx, [rbp+var_10]
mov rax, [rbp+var_20]
mov [rax+8], rcx
lea rdi, trid_to_trn
add rdi, 28h ; '('
call lf_pinbox_get_pins
mov rcx, rax
mov rax, [rbp+var_20]
mov [rax], rcx
mov rax, [rbp+var_20]
cmp qword ptr [rax], 0
jnz short loc_770C2
mov rdi, [rbp+var_20]
call trnman_free_trn
lea rdi, LOCK_trn_list
call inline_mysql_mutex_unlock_12
mov [rbp+var_8], 0
jmp loc_77280
loc_770C2:
mov eax, cs:trnman_active_transactions
add eax, 1
mov cs:trnman_active_transactions, eax
mov rax, cs:qword_C80E70
mov rcx, [rax+78h]
mov rax, [rbp+var_20]
mov [rax+80h], rcx
call new_trid
mov rcx, rax
mov rax, [rbp+var_20]
mov [rax+78h], rcx
mov rax, [rbp+var_20]
lea rcx, active_list_max
mov [rax+68h], rcx
mov rcx, cs:qword_C80F28
mov rax, [rbp+var_20]
mov [rax+70h], rcx
mov rax, [rbp+var_20]
mov rcx, [rbp+var_20]
mov rcx, [rcx+70h]
mov [rcx+68h], rax
mov cs:qword_C80F28, rax
mov rax, cs:qword_C80E70
mov rax, [rax+80h]
mov cs:trid_min_read_from, rax
jmp short $+2
loc_77143:
lea rdi, LOCK_trn_list
call inline_mysql_mutex_unlock_12
mov rax, [rbp+var_20]
cmp qword ptr [rax+80h], 0
setnz al
xor al, 0FFh
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_7718F
mov rax, [rbp+var_20]
mov rcx, [rax+78h]
add rcx, 1
mov rax, [rbp+var_20]
mov [rax+80h], rcx
loc_7718F:
mov rax, [rbp+var_20]
mov qword ptr [rax+88h], 0FFFFFFFFFFFFFFFFh
mov rax, [rbp+var_20]
mov qword ptr [rax+0A0h], 0
mov rax, [rbp+var_20]
mov qword ptr [rax+98h], 0
mov rax, [rbp+var_20]
mov qword ptr [rax+90h], 0
mov rax, [rbp+var_20]
mov qword ptr [rax+58h], 0
mov rax, [rbp+var_20]
mov qword ptr [rax+60h], 0
mov rax, [rbp+var_20]
mov dword ptr [rax+0A8h], 0
mov rax, [rbp+var_20]
mov word ptr [rax+0AEh], 0
mov rdi, [rbp+var_20]
add rdi, 10h
lea rsi, aWorkspaceLlm4b_15; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 173h
call inline_mysql_mutex_lock_11
mov rdi, [rbp+var_20]
call get_short_trid
mov cx, ax
mov rax, [rbp+var_20]
mov [rax+0ACh], cx
mov rdi, [rbp+var_20]
add rdi, 10h
call inline_mysql_mutex_unlock_12
mov rax, [rbp+var_20]
mov rsi, [rax]
lea rdi, trid_to_trn
lea rdx, [rbp+var_20]
call lf_hash_insert
mov [rbp+var_14], eax
jmp short $+2
loc_77257:
cmp [rbp+var_14], 0
jz short loc_77272
mov rdi, [rbp+var_20]
xor esi, esi
call trnman_end_trn
mov [rbp+var_8], 0
jmp short loc_77280
loc_77272:
jmp short $+2
loc_77274:
jmp short $+2
loc_77276:
jmp short $+2
loc_77278:
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
loc_77280:
mov rax, [rbp+var_8]
add rsp, 50h
pop rbp
retn
| long long trnman_new_trn(long long a1)
{
signed long long v1; // rcx
long long v2; // rax
bool v4; // [rsp+Fh] [rbp-41h]
char v5; // [rsp+1Eh] [rbp-32h]
signed long long v6; // [rsp+28h] [rbp-28h]
long long v7; // [rsp+30h] [rbp-20h] BYREF
long long v9; // [rsp+40h] [rbp-10h]
v9 = a1;
inline_mysql_mutex_lock_11(&LOCK_trn_list, "/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c", 296LL);
v6 = pool;
do
{
v5 = 0;
if ( v6 )
{
v1 = _InterlockedCompareExchange64(&pool, *(_QWORD *)(v6 + 104), v6);
v4 = v6 == v1;
if ( v6 != v1 )
v6 = v1;
v5 = ~v4;
}
}
while ( (v5 & 1) != 0 );
v7 = v6;
if ( !v6 )
{
v7 = my_malloc(0LL, 176LL, 48LL);
if ( !v7 )
{
inline_mysql_mutex_unlock_12(&LOCK_trn_list);
return 0LL;
}
++trnman_allocated_transactions;
inline_mysql_mutex_init_3(key_TRN_state_lock, (_QWORD *)(v7 + 16), (long long)&my_fast_mutexattr);
}
*(_QWORD *)(v7 + 8) = v9;
*(_QWORD *)v7 = lf_pinbox_get_pins((char *)&trid_to_trn + 40);
if ( *(_QWORD *)v7 )
{
++trnman_active_transactions;
*(_QWORD *)(v7 + 128) = *(_QWORD *)(qword_C80E70 + 120);
*(_QWORD *)(v7 + 120) = new_trid();
*(_QWORD *)(v7 + 104) = &active_list_max;
*(_QWORD *)(v7 + 112) = qword_C80F28;
v2 = v7;
*(_QWORD *)(*(_QWORD *)(v7 + 112) + 104LL) = v7;
qword_C80F28 = v2;
trid_min_read_from = *(_QWORD *)(qword_C80E70 + 128);
inline_mysql_mutex_unlock_12(&LOCK_trn_list);
if ( !*(_QWORD *)(v7 + 128) )
*(_QWORD *)(v7 + 128) = *(_QWORD *)(v7 + 120) + 1LL;
*(_QWORD *)(v7 + 136) = -1LL;
*(_QWORD *)(v7 + 160) = 0LL;
*(_QWORD *)(v7 + 152) = 0LL;
*(_QWORD *)(v7 + 144) = 0LL;
*(_QWORD *)(v7 + 88) = 0LL;
*(_QWORD *)(v7 + 96) = 0LL;
*(_DWORD *)(v7 + 168) = 0;
*(_WORD *)(v7 + 174) = 0;
inline_mysql_mutex_lock_11(v7 + 16, "/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c", 371LL);
*(_WORD *)(v7 + 172) = get_short_trid(v7);
inline_mysql_mutex_unlock_12(v7 + 16);
if ( (unsigned int)lf_hash_insert(&trid_to_trn, *(_QWORD *)v7, &v7) )
{
trnman_end_trn(v7, 0LL);
return 0LL;
}
else
{
return v7;
}
}
else
{
trnman_free_trn(v7);
inline_mysql_mutex_unlock_12(&LOCK_trn_list);
return 0LL;
}
}
| trnman_new_trn:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
JMP 0x00176f5e
LAB_00176f5e:
LEA RDI,[0xd811b0]
LEA RSI,[0x258407]
MOV EDX,0x128
CALL 0x00177290
MOV RAX,qword ptr [0x00d810d8]
MOV qword ptr [RBP + -0x28],RAX
LAB_00176f81:
XOR EAX,EAX
CMP qword ptr [RBP + -0x28],0x0
MOV byte ptr [RBP + -0x32],AL
JZ 0x00176fd3
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x68]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
CMPXCHG.LOCK qword ptr [0x00d810d8],RCX
MOV RCX,RAX
SETZ AL
MOV byte ptr [RBP + -0x41],AL
MOV qword ptr [RBP + -0x40],RCX
TEST AL,0x1
JNZ 0x00176fc3
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x28],RAX
LAB_00176fc3:
MOV AL,byte ptr [RBP + -0x41]
AND AL,0x1
MOV byte ptr [RBP + -0x31],AL
MOV AL,byte ptr [RBP + -0x31]
XOR AL,0xff
MOV byte ptr [RBP + -0x32],AL
LAB_00176fd3:
MOV AL,byte ptr [RBP + -0x32]
TEST AL,0x1
JNZ 0x00176fdc
JMP 0x00176fde
LAB_00176fdc:
JMP 0x00176f81
LAB_00176fde:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JNZ 0x00177070
XOR EDI,EDI
MOV ESI,0xb0
MOV EDX,0x30
CALL 0x001f99f0
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
SETNZ AL
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x00177044
JMP 0x00177029
LAB_00177029:
JMP 0x0017702b
LAB_0017702b:
LEA RDI,[0xd811b0]
CALL 0x00177300
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00177280
LAB_00177044:
MOV EAX,dword ptr [0x00d810d0]
ADD EAX,0x1
MOV dword ptr [0x00d810d0],EAX
LEA RAX,[0x57eac4]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x20]
ADD RSI,0x10
LEA RDX,[0xd8a7d0]
CALL 0x00176dd0
LAB_00177070:
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x8],RCX
LEA RDI,[0xd810e8]
ADD RDI,0x28
CALL 0x00202c40
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX],0x0
JNZ 0x001770c2
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00177360
LEA RDI,[0xd811b0]
CALL 0x00177300
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00177280
LAB_001770c2:
MOV EAX,dword ptr [0x00d810c8]
ADD EAX,0x1
MOV dword ptr [0x00d810c8],EAX
MOV RAX,qword ptr [0x00d80e70]
MOV RCX,qword ptr [RAX + 0x78]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x80],RCX
CALL 0x001783a0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x78],RCX
MOV RAX,qword ptr [RBP + -0x20]
LEA RCX,[0xd80eb8]
MOV qword ptr [RAX + 0x68],RCX
MOV RCX,qword ptr [0x00d80f28]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x70],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RCX + 0x70]
MOV qword ptr [RCX + 0x68],RAX
MOV qword ptr [0x00d80f28],RAX
MOV RAX,qword ptr [0x00d80e70]
MOV RAX,qword ptr [RAX + 0x80]
MOV qword ptr [0x003c54e8],RAX
JMP 0x00177143
LAB_00177143:
LEA RDI,[0xd811b0]
CALL 0x00177300
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX + 0x80],0x0
SETNZ AL
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0017718f
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX + 0x78]
ADD RCX,0x1
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x80],RCX
LAB_0017718f:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x88],-0x1
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0xa0],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x98],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x90],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x58],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x60],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0xa8],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV word ptr [RAX + 0xae],0x0
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x10
LEA RSI,[0x258407]
MOV EDX,0x173
CALL 0x00177290
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00177410
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x20]
MOV word ptr [RAX + 0xac],CX
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x10
CALL 0x00177300
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RAX]
LEA RDI,[0xd810e8]
LEA RDX,[RBP + -0x20]
CALL 0x00203fd0
MOV dword ptr [RBP + -0x14],EAX
JMP 0x00177257
LAB_00177257:
CMP dword ptr [RBP + -0x14],0x0
JZ 0x00177272
MOV RDI,qword ptr [RBP + -0x20]
XOR ESI,ESI
CALL 0x001774f0
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00177280
LAB_00177272:
JMP 0x00177274
LAB_00177274:
JMP 0x00177276
LAB_00177276:
JMP 0x00177278
LAB_00177278:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
LAB_00177280:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
long * trnman_new_trn(long param_1)
{
long *plVar1;
int2 uVar2;
long *plVar3;
long lVar4;
bool bVar5;
long *local_30;
long *local_28;
int local_1c;
long local_18;
long *local_10;
local_18 = param_1;
inline_mysql_mutex_lock
(LOCK_trn_list,"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",0x128);
local_30 = pool;
do {
bVar5 = false;
if (local_30 != (long *)0x0) {
LOCK();
bVar5 = local_30 != pool;
plVar3 = local_30;
plVar1 = (long *)local_30[0xd];
if (bVar5) {
plVar3 = pool;
plVar1 = pool;
}
pool = plVar1;
UNLOCK();
if (bVar5) {
local_30 = plVar3;
}
}
} while (bVar5);
local_28 = local_30;
if (local_30 == (long *)0x0) {
local_28 = (long *)my_malloc(0,0xb0,0x30);
if (local_28 == (long *)0x0) {
inline_mysql_mutex_unlock(LOCK_trn_list);
return (long *)0x0;
}
trnman_allocated_transactions = trnman_allocated_transactions + 1;
inline_mysql_mutex_init(key_TRN_state_lock,local_28 + 2,&my_fast_mutexattr);
}
local_28[1] = local_18;
lVar4 = lf_pinbox_get_pins(0xd81110);
*local_28 = lVar4;
if (*local_28 == 0) {
trnman_free_trn(local_28);
inline_mysql_mutex_unlock(LOCK_trn_list);
local_10 = (long *)0x0;
}
else {
trnman_active_transactions = trnman_active_transactions + 1;
local_28[0x10] = *(long *)(active_list_min._104_8_ + 0x78);
lVar4 = new_trid();
local_28[0xf] = lVar4;
local_28[0xd] = (long)active_list_max;
local_28[0xe] = active_list_max._112_8_;
*(long **)(local_28[0xe] + 0x68) = local_28;
active_list_max._112_8_ = local_28;
trid_min_read_from = *(int8 *)(active_list_min._104_8_ + 0x80);
inline_mysql_mutex_unlock(LOCK_trn_list);
if (local_28[0x10] == 0) {
local_28[0x10] = local_28[0xf] + 1;
}
local_28[0x11] = -1;
local_28[0x14] = 0;
local_28[0x13] = 0;
local_28[0x12] = 0;
local_28[0xb] = 0;
local_28[0xc] = 0;
*(int4 *)(local_28 + 0x15) = 0;
*(int2 *)((long)local_28 + 0xae) = 0;
inline_mysql_mutex_lock
(local_28 + 2,"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",0x173)
;
uVar2 = get_short_trid(local_28);
*(int2 *)((long)local_28 + 0xac) = uVar2;
inline_mysql_mutex_unlock(local_28 + 2);
local_1c = lf_hash_insert(trid_to_trn,*local_28,&local_28);
if (local_1c == 0) {
local_10 = local_28;
}
else {
trnman_end_trn(local_28,0);
local_10 = (long *)0x0;
}
}
return local_10;
}
| |
38,667 | my_strnxfrm_8bit_nopad_bin | eloqsql/strings/ctype-bin.c | static size_t
my_strnxfrm_8bit_nopad_bin(CHARSET_INFO *cs,
uchar * dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
set_if_smaller(srclen, dstlen);
set_if_smaller(srclen, nweights);
if (dst != src)
memcpy(dst, src, srclen);
return my_strxfrm_pad_desc_and_reverse_nopad(cs, dst, dst + srclen,
dst + dstlen,(uint)(nweights - srclen),
flags, 0);
} | O3 | c | my_strnxfrm_8bit_nopad_bin:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r13
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movl 0x10(%rbp), %r9d
cmpq %rdx, %r13
cmovaeq %rdx, %r13
movl %ecx, %eax
cmpq %rax, %r13
cmovaeq %rax, %r13
cmpq %r8, %rsi
je 0x345e6
movq %r12, %rdi
movq %r8, %rsi
movq %r13, %rdx
callq 0x24230
movl 0x10(%rbp), %r9d
leaq (%r12,%r13), %rdx
addq %r12, %r14
subl %r13d, %ebx
movl $0x0, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rcx
movl %ebx, %r8d
callq 0x3c906
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_strnxfrm_8bit_nopad_bin:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r13, r9
mov ebx, ecx
mov r14, rdx
mov r12, rsi
mov r15, rdi
mov r9d, [rbp+arg_0]
cmp r13, rdx
cmovnb r13, rdx
mov eax, ecx
cmp r13, rax
cmovnb r13, rax
cmp rsi, r8
jz short loc_345E6
mov rdi, r12
mov rsi, r8
mov rdx, r13
call _memcpy
mov r9d, [rbp+arg_0]
loc_345E6:
lea rdx, [r12+r13]
add r14, r12
sub ebx, r13d
mov [rsp+30h+var_30], 0
mov rdi, r15
mov rsi, r12
mov rcx, r14
mov r8d, ebx
call my_strxfrm_pad_desc_and_reverse_nopad
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_strnxfrm_8bit_nopad_bin(
int a1,
long long a2,
unsigned long long a3,
unsigned int a4,
long long a5,
unsigned long long a6,
int a7)
{
int v9; // r14d
int v10; // r9d
v9 = a3;
v10 = a7;
if ( a6 >= a3 )
a6 = a3;
if ( a6 >= a4 )
a6 = a4;
if ( a2 != a5 )
{
memcpy(a2, a5, a6);
v10 = a7;
}
return my_strxfrm_pad_desc_and_reverse_nopad(a1, a2, (int)a2 + (int)a6, (int)a2 + v9, a4 - (unsigned int)a6, v10, 0);
}
| my_strnxfrm_8bit_nopad_bin:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R13,R9
MOV EBX,ECX
MOV R14,RDX
MOV R12,RSI
MOV R15,RDI
MOV R9D,dword ptr [RBP + 0x10]
CMP R13,RDX
CMOVNC R13,RDX
MOV EAX,ECX
CMP R13,RAX
CMOVNC R13,RAX
CMP RSI,R8
JZ 0x001345e6
MOV RDI,R12
MOV RSI,R8
MOV RDX,R13
CALL 0x00124230
MOV R9D,dword ptr [RBP + 0x10]
LAB_001345e6:
LEA RDX,[R12 + R13*0x1]
ADD R14,R12
SUB EBX,R13D
MOV dword ptr [RSP],0x0
MOV RDI,R15
MOV RSI,R12
MOV RCX,R14
MOV R8D,EBX
CALL 0x0013c906
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void my_strnxfrm_8bit_nopad_bin
(int8 param_1,void *param_2,ulong param_3,uint param_4,void *param_5,
ulong param_6,int4 param_7)
{
int8 in_RAX;
uint uVar1;
uVar1 = (uint)((ulong)in_RAX >> 0x20);
if (param_3 <= param_6) {
param_6 = param_3;
}
if (param_4 <= param_6) {
param_6 = (ulong)param_4;
}
if (param_2 != param_5) {
memcpy(param_2,param_5,param_6);
}
my_strxfrm_pad_desc_and_reverse_nopad
(param_1,param_2,(long)param_2 + param_6,param_3 + (long)param_2,param_4 - (int)param_6,
param_7,(ulong)uVar1 << 0x20);
return;
}
| |
38,668 | my_coll_parser_scan_character_list | eloqsql/strings/ctype-uca.c | static int
my_coll_parser_scan_character_list(MY_COLL_RULE_PARSER *p,
my_wc_t *pwc, size_t limit,
const char *name)
{
if (my_coll_parser_curr(p)->term != MY_COLL_LEXEM_CHAR)
return my_coll_parser_expected_error(p, MY_COLL_LEXEM_CHAR);
if (!my_coll_rule_expand(pwc, limit, my_coll_parser_curr(p)->code))
return my_coll_parser_too_long_error(p, name);
if (!my_coll_parser_scan_term(p, MY_COLL_LEXEM_CHAR))
return 0;
while (my_coll_parser_curr(p)->term == MY_COLL_LEXEM_CHAR)
{
if (!my_coll_rule_expand(pwc, limit, my_coll_parser_curr(p)->code))
return my_coll_parser_too_long_error(p, name);
my_coll_parser_scan(p);
}
return 1;
} | O0 | c | my_coll_parser_scan_character_list:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x51540
cmpl $0x5, (%rax)
je 0x5253c
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0x51e80
movl %eax, -0x4(%rbp)
jmp 0x525fc
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x51540
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movslq 0x24(%rax), %rdx
callq 0x52610
cmpl $0x0, %eax
jne 0x5257d
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x52680
movl %eax, -0x4(%rbp)
jmp 0x525fc
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0x51b10
cmpl $0x0, %eax
jne 0x52599
movl $0x0, -0x4(%rbp)
jmp 0x525fc
jmp 0x5259b
movq -0x10(%rbp), %rdi
callq 0x51540
cmpl $0x5, (%rax)
jne 0x525f5
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x51540
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movslq 0x24(%rax), %rdx
callq 0x52610
cmpl $0x0, %eax
jne 0x525ea
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x52680
movl %eax, -0x4(%rbp)
jmp 0x525fc
movq -0x10(%rbp), %rdi
callq 0x51d20
jmp 0x5259b
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_coll_parser_scan_character_list:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rdi, [rbp+var_10]
call my_coll_parser_curr
cmp dword ptr [rax], 5
jz short loc_5253C
mov rdi, [rbp+var_10]
mov esi, 5
call my_coll_parser_expected_error
mov [rbp+var_4], eax
jmp loc_525FC
loc_5253C:
mov rax, [rbp+var_18]
mov [rbp+var_38], rax
mov rax, [rbp+var_20]
mov [rbp+var_30], rax
mov rdi, [rbp+var_10]
call my_coll_parser_curr
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_30]
movsxd rdx, dword ptr [rax+24h]
call my_coll_rule_expand
cmp eax, 0
jnz short loc_5257D
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
call my_coll_parser_too_long_error
mov [rbp+var_4], eax
jmp short loc_525FC
loc_5257D:
mov rdi, [rbp+var_10]
mov esi, 5
call my_coll_parser_scan_term
cmp eax, 0
jnz short loc_52599
mov [rbp+var_4], 0
jmp short loc_525FC
loc_52599:
jmp short $+2
loc_5259B:
mov rdi, [rbp+var_10]
call my_coll_parser_curr
cmp dword ptr [rax], 5
jnz short loc_525F5
mov rax, [rbp+var_18]
mov [rbp+var_48], rax
mov rax, [rbp+var_20]
mov [rbp+var_40], rax
mov rdi, [rbp+var_10]
call my_coll_parser_curr
mov rdi, [rbp+var_48]
mov rsi, [rbp+var_40]
movsxd rdx, dword ptr [rax+24h]
call my_coll_rule_expand
cmp eax, 0
jnz short loc_525EA
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
call my_coll_parser_too_long_error
mov [rbp+var_4], eax
jmp short loc_525FC
loc_525EA:
mov rdi, [rbp+var_10]
call my_coll_parser_scan
jmp short loc_5259B
loc_525F5:
mov [rbp+var_4], 1
loc_525FC:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long my_coll_parser_scan_character_list(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rax
long long v5; // rax
if ( *(_DWORD *)my_coll_parser_curr(a1) == 5 )
{
v4 = my_coll_parser_curr(a1);
if ( (unsigned int)my_coll_rule_expand(a2, a3, *(int *)(v4 + 36)) )
{
if ( (unsigned int)my_coll_parser_scan_term(a1, 5u) )
{
while ( *(_DWORD *)my_coll_parser_curr(a1) == 5 )
{
v5 = my_coll_parser_curr(a1);
if ( !(unsigned int)my_coll_rule_expand(a2, a3, *(int *)(v5 + 36)) )
return (unsigned int)my_coll_parser_too_long_error(a1, a4);
my_coll_parser_scan(a1);
}
return 1;
}
else
{
return 0;
}
}
else
{
return (unsigned int)my_coll_parser_too_long_error(a1, a4);
}
}
else
{
return (unsigned int)my_coll_parser_expected_error(a1, 5u);
}
}
| my_coll_parser_scan_character_list:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
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 RDI,qword ptr [RBP + -0x10]
CALL 0x00151540
CMP dword ptr [RAX],0x5
JZ 0x0015253c
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x5
CALL 0x00151e80
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001525fc
LAB_0015253c:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00151540
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x30]
MOVSXD RDX,dword ptr [RAX + 0x24]
CALL 0x00152610
CMP EAX,0x0
JNZ 0x0015257d
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x00152680
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001525fc
LAB_0015257d:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x5
CALL 0x00151b10
CMP EAX,0x0
JNZ 0x00152599
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001525fc
LAB_00152599:
JMP 0x0015259b
LAB_0015259b:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00151540
CMP dword ptr [RAX],0x5
JNZ 0x001525f5
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00151540
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x40]
MOVSXD RDX,dword ptr [RAX + 0x24]
CALL 0x00152610
CMP EAX,0x0
JNZ 0x001525ea
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x00152680
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001525fc
LAB_001525ea:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00151d20
JMP 0x0015259b
LAB_001525f5:
MOV dword ptr [RBP + -0x4],0x1
LAB_001525fc:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int4
my_coll_parser_scan_character_list
(int8 param_1,int8 param_2,int8 param_3,int8 param_4)
{
int iVar1;
int4 uVar2;
int *piVar3;
long lVar4;
int4 local_c;
piVar3 = (int *)my_coll_parser_curr(param_1);
if (*piVar3 == 5) {
lVar4 = my_coll_parser_curr(param_1);
iVar1 = my_coll_rule_expand(param_2,param_3,(long)*(int *)(lVar4 + 0x24));
if (iVar1 == 0) {
local_c = my_coll_parser_too_long_error(param_1,param_4);
}
else {
iVar1 = my_coll_parser_scan_term(param_1,5);
if (iVar1 == 0) {
local_c = 0;
}
else {
while (piVar3 = (int *)my_coll_parser_curr(param_1), *piVar3 == 5) {
lVar4 = my_coll_parser_curr(param_1);
iVar1 = my_coll_rule_expand(param_2,param_3,(long)*(int *)(lVar4 + 0x24));
if (iVar1 == 0) {
uVar2 = my_coll_parser_too_long_error(param_1,param_4);
return uVar2;
}
my_coll_parser_scan(param_1);
}
local_c = 1;
}
}
}
else {
local_c = my_coll_parser_expected_error(param_1,5);
}
return local_c;
}
| |
38,669 | my_coll_parser_scan_character_list | eloqsql/strings/ctype-uca.c | static int
my_coll_parser_scan_character_list(MY_COLL_RULE_PARSER *p,
my_wc_t *pwc, size_t limit,
const char *name)
{
if (my_coll_parser_curr(p)->term != MY_COLL_LEXEM_CHAR)
return my_coll_parser_expected_error(p, MY_COLL_LEXEM_CHAR);
if (!my_coll_rule_expand(pwc, limit, my_coll_parser_curr(p)->code))
return my_coll_parser_too_long_error(p, name);
if (!my_coll_parser_scan_term(p, MY_COLL_LEXEM_CHAR))
return 0;
while (my_coll_parser_curr(p)->term == MY_COLL_LEXEM_CHAR)
{
if (!my_coll_rule_expand(pwc, limit, my_coll_parser_curr(p)->code))
return my_coll_parser_too_long_error(p, name);
my_coll_parser_scan(p);
}
return 1;
} | O3 | c | my_coll_parser_scan_character_list:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x5, (%rdi)
jne 0x41d21
movq %rcx, %r14
movq %rdx, %r12
testq %rdx, %rdx
je 0x41d03
movq %rsi, %r13
movslq 0x24(%rbx), %rax
xorl %ecx, %ecx
cmpq $0x0, (%r13,%rcx,8)
je 0x41d5a
incq %rcx
cmpq %rcx, %r12
jne 0x41cf3
addq $0xf8, %rbx
leaq 0x1e221(%rip), %rdx # 0x5ff32
xorl %r15d, %r15d
movl $0x80, %esi
movq %rbx, %rdi
movq %r14, %rcx
jmp 0x41d41
addq $0xf8, %rbx
leaq 0x1e212(%rip), %rdx # 0x5ff41
leaq 0x1e221(%rip), %rcx # 0x5ff57
xorl %r15d, %r15d
movl $0x80, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5b74a
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, (%r13,%rcx,8)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x41a2d
testl %eax, %eax
je 0x41dd0
movl $0x1, %r15d
cmpl $0x5, (%rbx)
jne 0x41d48
leaq 0x28(%rbx), %rdx
movslq 0x24(%rbx), %rax
xorl %ecx, %ecx
cmpq $0x0, (%r13,%rcx,8)
je 0x41d9a
incq %rcx
cmpq %rcx, %r12
jne 0x41d85
jmp 0x41d03
movq %rax, (%r13,%rcx,8)
movq 0x20(%rdx), %rax
movq %rax, 0x20(%rbx)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %rdx, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x417cf
movq -0x30(%rbp), %rdx
cmpl $0x5, (%rbx)
je 0x41d7f
jmp 0x41d48
xorl %r15d, %r15d
jmp 0x41d48
| my_coll_parser_scan_character_list:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
cmp dword ptr [rdi], 5
jnz short loc_41D21
mov r14, rcx
mov r12, rdx
test rdx, rdx
jz short loc_41D03
mov r13, rsi
movsxd rax, dword ptr [rbx+24h]
xor ecx, ecx
loc_41CF3:
cmp qword ptr [r13+rcx*8+0], 0
jz short loc_41D5A
inc rcx
cmp r12, rcx
jnz short loc_41CF3
loc_41D03:
add rbx, 0F8h
lea rdx, aSIsTooLong; "%s is too long"
xor r15d, r15d
mov esi, 80h
mov rdi, rbx
mov rcx, r14
jmp short loc_41D41
loc_41D21:
add rbx, 0F8h
lea rdx, aSExpected; "%s expected"
lea rcx, aCharacter; "Character"
xor r15d, r15d
mov esi, 80h
mov rdi, rbx
loc_41D41:
xor eax, eax
call my_snprintf
loc_41D48:
mov eax, r15d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_41D5A:
mov [r13+rcx*8+0], rax
mov rdi, rbx
mov esi, 5
call my_coll_parser_scan_term
test eax, eax
jz short loc_41DD0
mov r15d, 1
cmp dword ptr [rbx], 5
jnz short loc_41D48
lea rdx, [rbx+28h]
loc_41D7F:
movsxd rax, dword ptr [rbx+24h]
xor ecx, ecx
loc_41D85:
cmp qword ptr [r13+rcx*8+0], 0
jz short loc_41D9A
inc rcx
cmp r12, rcx
jnz short loc_41D85
jmp loc_41D03
loc_41D9A:
mov [r13+rcx*8+0], rax
mov rax, [rdx+20h]
mov [rbx+20h], rax
movups xmm0, xmmword ptr [rdx]
movups xmm1, xmmword ptr [rdx+10h]
movups xmmword ptr [rbx+10h], xmm1
movups xmmword ptr [rbx], xmm0
mov [rbp+var_30], rdx
mov rdi, [rbp+var_30]
call my_coll_lexem_next
mov rdx, [rbp+var_30]
cmp dword ptr [rbx], 5
jz short loc_41D7F
jmp loc_41D48
loc_41DD0:
xor r15d, r15d
jmp loc_41D48
| long long my_coll_parser_scan_character_list(long long a1, long long a2, long long a3, int a4, int a5, int a6)
{
long long v8; // rcx
const char *v9; // rdx
unsigned int v10; // r15d
int v11; // edi
const char *v12; // rcx
long long v14; // rdx
long long v15; // rcx
__int128 v16; // xmm0
long long v17; // [rsp+0h] [rbp-30h]
if ( *(_DWORD *)a1 != 5 )
{
v9 = "%s expected";
v12 = "Character";
v10 = 0;
v11 = a1 + 248;
goto LABEL_8;
}
if ( !a3 )
{
LABEL_6:
v9 = "%s is too long";
v10 = 0;
v11 = a1 + 248;
LODWORD(v12) = a4;
LABEL_8:
my_snprintf(v11, 128, (_DWORD)v9, (_DWORD)v12, a5, a6);
return v10;
}
v8 = 0LL;
while ( *(_QWORD *)(a2 + 8 * v8) )
{
if ( a3 == ++v8 )
goto LABEL_6;
}
*(_QWORD *)(a2 + 8 * v8) = *(int *)(a1 + 36);
if ( (unsigned int)my_coll_parser_scan_term(a1, 5) )
{
v10 = 1;
if ( *(_DWORD *)a1 == 5 )
{
v14 = a1 + 40;
do
{
v15 = 0LL;
while ( *(_QWORD *)(a2 + 8 * v15) )
{
if ( a3 == ++v15 )
goto LABEL_6;
}
*(_QWORD *)(a2 + 8 * v15) = *(int *)(a1 + 36);
*(_QWORD *)(a1 + 32) = *(_QWORD *)(v14 + 32);
v16 = *(_OWORD *)v14;
*(_OWORD *)(a1 + 16) = *(_OWORD *)(v14 + 16);
*(_OWORD *)a1 = v16;
v17 = v14;
my_coll_lexem_next(v14);
v14 = v17;
}
while ( *(_DWORD *)a1 == 5 );
}
}
else
{
return 0;
}
return v10;
}
| my_coll_parser_scan_character_list:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
CMP dword ptr [RDI],0x5
JNZ 0x00141d21
MOV R14,RCX
MOV R12,RDX
TEST RDX,RDX
JZ 0x00141d03
MOV R13,RSI
MOVSXD RAX,dword ptr [RBX + 0x24]
XOR ECX,ECX
LAB_00141cf3:
CMP qword ptr [R13 + RCX*0x8],0x0
JZ 0x00141d5a
INC RCX
CMP R12,RCX
JNZ 0x00141cf3
LAB_00141d03:
ADD RBX,0xf8
LEA RDX,[0x15ff32]
XOR R15D,R15D
MOV ESI,0x80
MOV RDI,RBX
MOV RCX,R14
JMP 0x00141d41
LAB_00141d21:
ADD RBX,0xf8
LEA RDX,[0x15ff41]
LEA RCX,[0x15ff57]
XOR R15D,R15D
MOV ESI,0x80
MOV RDI,RBX
LAB_00141d41:
XOR EAX,EAX
CALL 0x0015b74a
LAB_00141d48:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00141d5a:
MOV qword ptr [R13 + RCX*0x8],RAX
MOV RDI,RBX
MOV ESI,0x5
CALL 0x00141a2d
TEST EAX,EAX
JZ 0x00141dd0
MOV R15D,0x1
CMP dword ptr [RBX],0x5
JNZ 0x00141d48
LEA RDX,[RBX + 0x28]
LAB_00141d7f:
MOVSXD RAX,dword ptr [RBX + 0x24]
XOR ECX,ECX
LAB_00141d85:
CMP qword ptr [R13 + RCX*0x8],0x0
JZ 0x00141d9a
INC RCX
CMP R12,RCX
JNZ 0x00141d85
JMP 0x00141d03
LAB_00141d9a:
MOV qword ptr [R13 + RCX*0x8],RAX
MOV RAX,qword ptr [RDX + 0x20]
MOV qword ptr [RBX + 0x20],RAX
MOVUPS XMM0,xmmword ptr [RDX]
MOVUPS XMM1,xmmword ptr [RDX + 0x10]
MOVUPS xmmword ptr [RBX + 0x10],XMM1
MOVUPS xmmword ptr [RBX],XMM0
MOV qword ptr [RBP + -0x30],RDX
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x001417cf
MOV RDX,qword ptr [RBP + -0x30]
CMP dword ptr [RBX],0x5
JZ 0x00141d7f
JMP 0x00141d48
LAB_00141dd0:
XOR R15D,R15D
JMP 0x00141d48
|
int8 my_coll_parser_scan_character_list(int *param_1,long param_2,long param_3,char *param_4)
{
int iVar1;
long lVar2;
char *pcVar3;
if (*param_1 == 5) {
if (param_3 != 0) {
lVar2 = 0;
do {
if (*(long *)(param_2 + lVar2 * 8) == 0) {
*(long *)(param_2 + lVar2 * 8) = (long)param_1[9];
iVar1 = my_coll_parser_scan_term(param_1,5);
if (iVar1 == 0) {
return 0;
}
if (*param_1 != 5) {
return 1;
}
do {
lVar2 = 0;
while (*(long *)(param_2 + lVar2 * 8) != 0) {
lVar2 = lVar2 + 1;
if (param_3 == lVar2) goto LAB_00141d03;
}
*(long *)(param_2 + lVar2 * 8) = (long)param_1[9];
*(int8 *)(param_1 + 8) = *(int8 *)(param_1 + 0x12);
param_1[4] = param_1[0xe];
param_1[5] = param_1[0xf];
param_1[6] = param_1[0x10];
param_1[7] = param_1[0x11];
*param_1 = param_1[10];
param_1[1] = param_1[0xb];
param_1[2] = param_1[0xc];
param_1[3] = param_1[0xd];
my_coll_lexem_next(param_1 + 10);
if (*param_1 != 5) {
return 1;
}
} while( true );
}
lVar2 = lVar2 + 1;
} while (param_3 != lVar2);
}
LAB_00141d03:
pcVar3 = "%s is too long";
}
else {
pcVar3 = "%s expected";
param_4 = "Character";
}
my_snprintf(param_1 + 0x3e,0x80,pcVar3,param_4);
return 0;
}
| |
38,670 | my_strxfrm_desc_and_reverse | eloqsql/strings/ctype-simple.c | void
my_strxfrm_desc_and_reverse(uchar *str, uchar *strend,
uint flags, uint level)
{
if (flags & (MY_STRXFRM_DESC_LEVEL1 << level))
{
if (flags & (MY_STRXFRM_REVERSE_LEVEL1 << level))
{
for (strend--; str <= strend;)
{
uchar tmp= *str;
*str++= ~*strend;
*strend--= ~tmp;
}
}
else
{
for (; str < strend; str++)
*str= ~*str;
}
}
else if (flags & (MY_STRXFRM_REVERSE_LEVEL1 << level))
{
for (strend--; str < strend;)
{
uchar tmp= *str;
*str++= *strend;
*strend--= tmp;
}
}
} | O3 | c | my_strxfrm_desc_and_reverse:
pushq %rbp
movq %rsp, %rbp
movl %edx, %r8d
shrl %cl, %r8d
movl $0x10000, %eax # imm = 0x10000
shll %cl, %eax
btl $0x8, %r8d
jae 0x4c478
testl %edx, %eax
je 0x4c4ab
decq %rsi
cmpq %rdi, %rsi
jb 0x4c4ba
incq %rdi
movb -0x1(%rdi), %al
movb (%rsi), %cl
notb %cl
movb %cl, -0x1(%rdi)
notb %al
movb %al, (%rsi)
decq %rsi
leaq 0x1(%rdi), %rax
cmpq %rsi, %rdi
movq %rax, %rdi
jbe 0x4c459
jmp 0x4c4ba
testl %edx, %eax
setne %al
decq %rsi
cmpq %rdi, %rsi
seta %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x4c4ba
incq %rdi
movb -0x1(%rdi), %al
movb (%rsi), %cl
movb %cl, -0x1(%rdi)
movb %al, (%rsi)
decq %rsi
leaq 0x1(%rdi), %rax
cmpq %rsi, %rdi
movq %rax, %rdi
jb 0x4c490
jmp 0x4c4ba
cmpq %rsi, %rdi
jae 0x4c4ba
notb (%rdi)
incq %rdi
cmpq %rsi, %rdi
jne 0x4c4b0
popq %rbp
retq
| my_strxfrm_desc_and_reverse:
push rbp
mov rbp, rsp
mov r8d, edx
shr r8d, cl
mov eax, offset stru_10000
shl eax, cl
bt r8d, 8
jnb short loc_4C478
test eax, edx
jz short loc_4C4AB
dec rsi
cmp rsi, rdi
jb short loc_4C4BA
inc rdi
loc_4C459:
mov al, [rdi-1]
mov cl, [rsi]
not cl
mov [rdi-1], cl
not al
mov [rsi], al
dec rsi
lea rax, [rdi+1]
cmp rdi, rsi
mov rdi, rax
jbe short loc_4C459
jmp short loc_4C4BA
loc_4C478:
test eax, edx
setnz al
dec rsi
cmp rsi, rdi
setnbe cl
and cl, al
cmp cl, 1
jnz short loc_4C4BA
inc rdi
loc_4C490:
mov al, [rdi-1]
mov cl, [rsi]
mov [rdi-1], cl
mov [rsi], al
dec rsi
lea rax, [rdi+1]
cmp rdi, rsi
mov rdi, rax
jb short loc_4C490
jmp short loc_4C4BA
loc_4C4AB:
cmp rdi, rsi
jnb short loc_4C4BA
loc_4C4B0:
not byte ptr [rdi]
inc rdi
cmp rdi, rsi
jnz short loc_4C4B0
loc_4C4BA:
pop rbp
retn
| char my_strxfrm_desc_and_reverse(_BYTE *a1, _BYTE *a2, unsigned int a3, char a4)
{
int v4; // eax
_BYTE *v5; // rsi
_BYTE *v6; // rdi
char v7; // al
_BYTE *v9; // rsi
_BYTE *v10; // rdi
char v11; // al
v4 = (_DWORD)&stru_10000 << a4;
if ( ((a3 >> a4) & 0x100) != 0 )
{
if ( (a3 & v4) != 0 )
{
v5 = a2 - 1;
if ( v5 >= a1 )
{
v6 = a1 + 1;
do
{
v7 = *(v6 - 1);
*(v6 - 1) = ~*v5;
*v5-- = ~v7;
LOBYTE(v4) = (_BYTE)v6 + 1;
}
while ( v6++ <= v5 );
}
}
else if ( a1 < a2 )
{
do
{
*a1 = ~*a1;
++a1;
}
while ( a1 != a2 );
}
}
else
{
LOBYTE(v4) = (a3 & v4) != 0;
v9 = a2 - 1;
if ( ((unsigned __int8)v4 & (v9 > a1)) == 1 )
{
v10 = a1 + 1;
do
{
v11 = *(v10 - 1);
*(v10 - 1) = *v9;
*v9-- = v11;
LOBYTE(v4) = (_BYTE)v10 + 1;
}
while ( v10++ < v9 );
}
}
return v4;
}
| my_strxfrm_desc_and_reverse:
PUSH RBP
MOV RBP,RSP
MOV R8D,EDX
SHR R8D,CL
MOV EAX,0x10000
SHL EAX,CL
BT R8D,0x8
JNC 0x0014c478
TEST EAX,EDX
JZ 0x0014c4ab
DEC RSI
CMP RSI,RDI
JC 0x0014c4ba
INC RDI
LAB_0014c459:
MOV AL,byte ptr [RDI + -0x1]
MOV CL,byte ptr [RSI]
NOT CL
MOV byte ptr [RDI + -0x1],CL
NOT AL
MOV byte ptr [RSI],AL
DEC RSI
LEA RAX,[RDI + 0x1]
CMP RDI,RSI
MOV RDI,RAX
JBE 0x0014c459
JMP 0x0014c4ba
LAB_0014c478:
TEST EAX,EDX
SETNZ AL
DEC RSI
CMP RSI,RDI
SETA CL
AND CL,AL
CMP CL,0x1
JNZ 0x0014c4ba
INC RDI
LAB_0014c490:
MOV AL,byte ptr [RDI + -0x1]
MOV CL,byte ptr [RSI]
MOV byte ptr [RDI + -0x1],CL
MOV byte ptr [RSI],AL
DEC RSI
LEA RAX,[RDI + 0x1]
CMP RDI,RSI
MOV RDI,RAX
JC 0x0014c490
JMP 0x0014c4ba
LAB_0014c4ab:
CMP RDI,RSI
JNC 0x0014c4ba
LAB_0014c4b0:
NOT byte ptr [RDI]
INC RDI
CMP RDI,RSI
JNZ 0x0014c4b0
LAB_0014c4ba:
POP RBP
RET
|
void my_strxfrm_desc_and_reverse(byte *param_1,byte *param_2,uint param_3,byte param_4)
{
byte bVar1;
uint uVar2;
byte *pbVar3;
bool bVar4;
uVar2 = 0x10000 << (param_4 & 0x1f);
if (((param_3 >> (param_4 & 0x1f)) >> 8 & 1) == 0) {
param_2 = param_2 + -1;
if (param_1 < param_2 && (uVar2 & param_3) != 0) {
pbVar3 = param_1 + 1;
do {
bVar1 = pbVar3[-1];
pbVar3[-1] = *param_2;
*param_2 = bVar1;
param_2 = param_2 + -1;
bVar4 = pbVar3 < param_2;
pbVar3 = pbVar3 + 1;
} while (bVar4);
}
}
else if ((uVar2 & param_3) == 0) {
if (param_1 < param_2) {
do {
*param_1 = ~*param_1;
param_1 = param_1 + 1;
} while (param_1 != param_2);
}
}
else {
param_2 = param_2 + -1;
if (param_1 <= param_2) {
pbVar3 = param_1 + 1;
do {
bVar1 = pbVar3[-1];
pbVar3[-1] = ~*param_2;
*param_2 = ~bVar1;
param_2 = param_2 + -1;
bVar4 = pbVar3 <= param_2;
pbVar3 = pbVar3 + 1;
} while (bVar4);
}
}
return;
}
| |
38,671 | rw_pr_init | eloqsql/mysys/thr_rwlock.c | int rw_pr_init(rw_pr_lock_t *rwlock)
{
pthread_mutex_init(&rwlock->lock, NULL);
pthread_cond_init(&rwlock->no_active_readers, NULL);
rwlock->active_readers= 0;
rwlock->writers_waiting_readers= 0;
rwlock->active_writer= FALSE;
#ifdef SAFE_MUTEX
rwlock->writer_thread= 0;
#endif
return 0;
} | O3 | c | rw_pr_init:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0x29330
leaq 0x28(%rbx), %rdi
xorl %esi, %esi
callq 0x29380
movq $0x0, 0x58(%rbx)
movb $0x0, 0x60(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| rw_pr_init:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
xor esi, esi
call _pthread_mutex_init
lea rdi, [rbx+28h]
xor esi, esi
call _pthread_cond_init
mov qword ptr [rbx+58h], 0
mov byte ptr [rbx+60h], 0
xor eax, eax
add rsp, 8
pop rbx
pop rbp
retn
| long long rw_pr_init(long long a1, double a2)
{
pthread_mutex_init(a1, 0LL);
pthread_cond_init(a1 + 40, 0LL, a2);
*(_QWORD *)(a1 + 88) = 0LL;
*(_BYTE *)(a1 + 96) = 0;
return 0LL;
}
| rw_pr_init:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
XOR ESI,ESI
CALL 0x00129330
LEA RDI,[RBX + 0x28]
XOR ESI,ESI
CALL 0x00129380
MOV qword ptr [RBX + 0x58],0x0
MOV byte ptr [RBX + 0x60],0x0
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int8 rw_pr_init(pthread_mutex_t *param_1)
{
pthread_mutex_init(param_1,(pthread_mutexattr_t *)0x0);
pthread_cond_init((pthread_cond_t *)(param_1 + 1),(pthread_condattr_t *)0x0);
*(int8 *)((long)param_1 + 0x58) = 0;
*(int1 *)((long)param_1 + 0x60) = 0;
return 0;
}
| |
38,672 | my_copy_fix_mb2_or_mb4 | eloqsql/strings/ctype-ucs2.c | static size_t
my_copy_fix_mb2_or_mb4(CHARSET_INFO *cs,
char *dst, size_t dst_length,
const char *src, size_t src_length,
size_t nchars, MY_STRCOPY_STATUS *status)
{
size_t length2, src_offset= src_length % cs->mbminlen;
my_char_copy_status_t padstatus;
if (!src_offset)
return my_copy_fix_mb(cs, dst, dst_length,
src, src_length, nchars, status);
if ((padstatus= my_copy_incomplete_char(cs, dst, dst_length,
src, src_length, nchars, TRUE)) ==
MY_CHAR_COPY_ERROR)
{
status->m_source_end_pos= status->m_well_formed_error_pos= src;
return 0;
}
length2= my_copy_fix_mb(cs, dst + cs->mbminlen, dst_length - cs->mbminlen,
src + src_offset, src_length - src_offset,
nchars - 1, status);
if (padstatus == MY_CHAR_COPY_FIXED)
status->m_well_formed_error_pos= src;
return cs->mbminlen /* The left-padded character */ + length2;
} | O0 | c | my_copy_fix_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
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 -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x98(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rdx, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0xff0d0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0xe4880
movq %rax, -0x8(%rbp)
jmp 0xff18c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movl $0x1, (%rsp)
callq 0x100980
movl %eax, -0x4c(%rbp)
cmpl $0x1, %eax
jne 0xff119
movq -0x28(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0xff18c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x98(%rax), %eax
addq %rax, %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x98(%rax), %eax
subq %rax, %rdx
movq -0x28(%rbp), %rcx
addq -0x48(%rbp), %rcx
movq -0x30(%rbp), %r8
subq -0x48(%rbp), %r8
movq -0x38(%rbp), %r9
subq $0x1, %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0xe4880
movq %rax, -0x40(%rbp)
cmpl $0x2, -0x4c(%rbp)
jne 0xff17a
movq -0x28(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x98(%rax), %eax
addq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_copy_fix_mb2_or_mb4:
push rbp
mov rbp, rsp
sub rsp, 60h
mov rax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov rax, [rbp+var_30]
mov rcx, [rbp+var_10]
mov ecx, [rcx+98h]
xor edx, edx
div rcx
mov [rbp+var_48], rdx
cmp [rbp+var_48], 0
jnz short loc_FF0D0
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
mov r8, [rbp+var_30]
mov r9, [rbp+var_38]
mov rax, [rbp+arg_0]
mov [rsp+60h+var_60], rax
call my_copy_fix_mb
mov [rbp+var_8], rax
jmp loc_FF18C
loc_FF0D0:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
mov r8, [rbp+var_30]
mov r9, [rbp+var_38]
mov dword ptr [rsp+60h+var_60], 1
call my_copy_incomplete_char
mov [rbp+var_4C], eax
cmp eax, 1
jnz short loc_FF119
mov rcx, [rbp+var_28]
mov rax, [rbp+arg_0]
mov [rax+8], rcx
mov rax, [rbp+arg_0]
mov [rax], rcx
mov [rbp+var_8], 0
jmp short loc_FF18C
loc_FF119:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rax, [rbp+var_10]
mov eax, [rax+98h]
add rsi, rax
mov rdx, [rbp+var_20]
mov rax, [rbp+var_10]
mov eax, [rax+98h]
sub rdx, rax
mov rcx, [rbp+var_28]
add rcx, [rbp+var_48]
mov r8, [rbp+var_30]
sub r8, [rbp+var_48]
mov r9, [rbp+var_38]
sub r9, 1
mov rax, [rbp+arg_0]
mov [rsp+60h+var_60], rax
call my_copy_fix_mb
mov [rbp+var_40], rax
cmp [rbp+var_4C], 2
jnz short loc_FF17A
mov rcx, [rbp+var_28]
mov rax, [rbp+arg_0]
mov [rax+8], rcx
loc_FF17A:
mov rax, [rbp+var_10]
mov eax, [rax+98h]
add rax, [rbp+var_40]
mov [rbp+var_8], rax
loc_FF18C:
mov rax, [rbp+var_8]
add rsp, 60h
pop rbp
retn
| long long my_copy_fix_mb2_or_mb4(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
long long a6,
long long *a7)
{
int v8; // [rsp+14h] [rbp-4Ch]
unsigned long long v9; // [rsp+18h] [rbp-48h]
long long fixed; // [rsp+20h] [rbp-40h]
v9 = a5 % *(unsigned int *)(a1 + 152);
if ( !v9 )
return my_copy_fix_mb(a1, a2, a3, a4, a5, a6, a7);
v8 = my_copy_incomplete_char(a1, a2, a3, a4, a5, a6, 1);
if ( v8 == 1 )
{
a7[1] = a4;
*a7 = a4;
return 0LL;
}
else
{
fixed = my_copy_fix_mb(
a1,
*(unsigned int *)(a1 + 152) + a2,
a3 - *(unsigned int *)(a1 + 152),
v9 + a4,
a5 - v9,
a6 - 1,
a7);
if ( v8 == 2 )
a7[1] = a4;
return fixed + *(unsigned int *)(a1 + 152);
}
}
| my_copy_fix_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x98]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x48],RDX
CMP qword ptr [RBP + -0x48],0x0
JNZ 0x001ff0d0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x30]
MOV R9,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RSP],RAX
CALL 0x001e4880
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001ff18c
LAB_001ff0d0:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x30]
MOV R9,qword ptr [RBP + -0x38]
MOV dword ptr [RSP],0x1
CALL 0x00200980
MOV dword ptr [RBP + -0x4c],EAX
CMP EAX,0x1
JNZ 0x001ff119
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX],RCX
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001ff18c
LAB_001ff119:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x98]
ADD RSI,RAX
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x98]
SUB RDX,RAX
MOV RCX,qword ptr [RBP + -0x28]
ADD RCX,qword ptr [RBP + -0x48]
MOV R8,qword ptr [RBP + -0x30]
SUB R8,qword ptr [RBP + -0x48]
MOV R9,qword ptr [RBP + -0x38]
SUB R9,0x1
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RSP],RAX
CALL 0x001e4880
MOV qword ptr [RBP + -0x40],RAX
CMP dword ptr [RBP + -0x4c],0x2
JNZ 0x001ff17a
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
LAB_001ff17a:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x98]
ADD RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
LAB_001ff18c:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x60
POP RBP
RET
|
long my_copy_fix_mb2_or_mb4
(long param_1,long param_2,long param_3,long param_4,ulong param_5,long param_6,
long *param_7)
{
int iVar1;
ulong uVar2;
long local_10;
uVar2 = param_5 % (ulong)*(uint *)(param_1 + 0x98);
if (uVar2 == 0) {
local_10 = my_copy_fix_mb(param_1,param_2,param_3,param_4,param_5,param_6,param_7);
}
else {
iVar1 = my_copy_incomplete_char(param_1,param_2,param_3,param_4,param_5,param_6,1);
if (iVar1 == 1) {
param_7[1] = param_4;
*param_7 = param_4;
local_10 = 0;
}
else {
local_10 = my_copy_fix_mb(param_1,param_2 + (ulong)*(uint *)(param_1 + 0x98),
param_3 - (ulong)*(uint *)(param_1 + 0x98),param_4 + uVar2,
param_5 - uVar2,param_6 + -1,param_7);
if (iVar1 == 2) {
param_7[1] = param_4;
}
local_10 = (ulong)*(uint *)(param_1 + 0x98) + local_10;
}
}
return local_10;
}
| |
38,673 | my_uca_generate_pages | eloqsql/strings/ctype-uca.c | static my_bool
my_uca_generate_pages(MY_CHARSET_LOADER *loader,
MY_UCA_WEIGHT_LEVEL *dst,
const MY_UCA_WEIGHT_LEVEL *src,
uint npages)
{
uint page;
for (page= 0; page < npages; page++)
{
if (dst->weights[page])
{
/* A page with explicit weights with no special rules */
continue;
}
if (!dst->lengths[page])
{
/*
A page with implicit weights with no special rules.
Keep dst->weights[page]==NULL and dst->lengths[page]==0.
Weights for this page will be generated at run time algorithmically,
using my_uca_scanner_next_implicit().
*/
continue;
}
/* Found a page with some special rules. */
if (my_uca_generate_page(loader, dst, src, page))
return TRUE;
}
return FALSE;
} | O0 | c | my_uca_generate_pages:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x47d18
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x28(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x47cda
jmp 0x47d0d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x28(%rbp), %ecx
cmpb $0x0, (%rax,%rcx)
jne 0x47ced
jmp 0x47d0d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x28(%rbp), %ecx
callq 0x48080
cmpb $0x0, %al
je 0x47d0b
movb $0x1, -0x1(%rbp)
jmp 0x47d1c
jmp 0x47d0d
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x47cbe
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_uca_generate_pages:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_28], 0
loc_47CBE:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_24]
jnb short loc_47D18
mov rax, [rbp+var_18]
mov rax, [rax+10h]
mov ecx, [rbp+var_28]
cmp qword ptr [rax+rcx*8], 0
jz short loc_47CDA
jmp short loc_47D0D
loc_47CDA:
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov ecx, [rbp+var_28]
cmp byte ptr [rax+rcx], 0
jnz short loc_47CED
jmp short loc_47D0D
loc_47CED:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov ecx, [rbp+var_28]
call my_uca_generate_page
cmp al, 0
jz short loc_47D0B
mov [rbp+var_1], 1
jmp short loc_47D1C
loc_47D0B:
jmp short $+2
loc_47D0D:
mov eax, [rbp+var_28]
add eax, 1
mov [rbp+var_28], eax
jmp short loc_47CBE
loc_47D18:
mov [rbp+var_1], 0
loc_47D1C:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char my_uca_generate_pages(long long a1, long long a2, long long a3, unsigned int a4)
{
unsigned int i; // [rsp+8h] [rbp-28h]
for ( i = 0; i < a4; ++i )
{
if ( !*(_QWORD *)(*(_QWORD *)(a2 + 16) + 8LL * i)
&& *(_BYTE *)(*(_QWORD *)(a2 + 8) + i)
&& (unsigned __int8)my_uca_generate_page(a1, a2, a3, i) )
{
return 1;
}
}
return 0;
}
| my_uca_generate_pages:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV dword ptr [RBP + -0x28],0x0
LAB_00147cbe:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x24]
JNC 0x00147d18
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x10]
MOV ECX,dword ptr [RBP + -0x28]
CMP qword ptr [RAX + RCX*0x8],0x0
JZ 0x00147cda
JMP 0x00147d0d
LAB_00147cda:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x28]
CMP byte ptr [RAX + RCX*0x1],0x0
JNZ 0x00147ced
JMP 0x00147d0d
LAB_00147ced:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x28]
CALL 0x00148080
CMP AL,0x0
JZ 0x00147d0b
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00147d1c
LAB_00147d0b:
JMP 0x00147d0d
LAB_00147d0d:
MOV EAX,dword ptr [RBP + -0x28]
ADD EAX,0x1
MOV dword ptr [RBP + -0x28],EAX
JMP 0x00147cbe
LAB_00147d18:
MOV byte ptr [RBP + -0x1],0x0
LAB_00147d1c:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 my_uca_generate_pages(int8 param_1,long param_2,int8 param_3,uint param_4)
{
char cVar1;
uint local_30;
local_30 = 0;
while( true ) {
if (param_4 <= local_30) {
return 0;
}
if (((*(long *)(*(long *)(param_2 + 0x10) + (ulong)local_30 * 8) == 0) &&
(*(char *)(*(long *)(param_2 + 8) + (ulong)local_30) != '\0')) &&
(cVar1 = my_uca_generate_page(param_1,param_2,param_3,local_30), cVar1 != '\0')) break;
local_30 = local_30 + 1;
}
return 1;
}
| |
38,674 | cli::matchable::matchable(cli::matchable const&) | msxemulator/build_O0/_deps/picotool-src/cli.h | matchable() = default; | O0 | c | cli::matchable::matchable(cli::matchable const&):
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x162481(%rip), %rax # 0x1dd8e0
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x10(%rsp)
movq 0x38(%rsp), %rsi
addq $0x8, %rsi
callq 0x7b5d0
movq 0x18(%rsp), %rdi
addq $0x28, %rdi
movq %rdi, 0x20(%rsp)
movq 0x38(%rsp), %rsi
addq $0x28, %rsi
callq 0x7b680
jmp 0x7b497
movq 0x18(%rsp), %rdi
addq $0x48, %rdi
movq %rdi, 0x8(%rsp)
movq 0x38(%rsp), %rsi
addq $0x48, %rsi
callq 0xf2b0
jmp 0x7b4b5
movq 0x18(%rsp), %rdi
addq $0x68, %rdi
movq %rdi, (%rsp)
movq 0x38(%rsp), %rsi
addq $0x68, %rsi
callq 0xf2b0
jmp 0x7b4d2
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rax
movw 0x90(%rax), %cx
movw %cx, 0x90(%rdi)
movq 0x88(%rax), %rax
movq %rax, 0x88(%rdi)
addq $0x98, %rdi
movq 0x38(%rsp), %rsi
addq $0x98, %rsi
callq 0xf2b0
jmp 0x7b512
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x7b572
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x7b568
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x7b55e
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0xfb10
movq 0x8(%rsp), %rdi
callq 0xfb10
movq 0x20(%rsp), %rdi
callq 0x59280
movq 0x10(%rsp), %rdi
callq 0x75a80
movq 0x30(%rsp), %rdi
callq 0xf9e0
nopw %cs:(%rax,%rax)
| _ZN3cli9matchableC2ERKS0_:
sub rsp, 48h
mov [rsp+48h+var_8], rdi
mov [rsp+48h+var_10], rsi
mov rdi, [rsp+48h+var_8]
mov [rsp+48h+var_30], rdi
lea rax, off_1DD8E0
mov [rdi], rax
add rdi, 8
mov [rsp+48h+var_38], rdi
mov rsi, [rsp+48h+var_10]
add rsi, 8
call _ZNSt8functionIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_EEC2ERKS7_; std::function<std::string ()(std::string)>::function(std::function<std::string ()(std::string)> const&)
mov rdi, [rsp+48h+var_30]
add rdi, 28h ; '('
mov [rsp+48h+var_28], rdi
mov rsi, [rsp+48h+var_10]
add rsi, 28h ; '('
call _ZNSt8functionIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEvEEC2ERKS7_; std::function<std::string ()(void)>::function(std::function<std::string ()(void)> const&)
jmp short $+2
loc_7B497:
mov rdi, [rsp+48h+var_30]
add rdi, 48h ; 'H'
mov [rsp+48h+var_40], rdi
mov rsi, [rsp+48h+var_10]
add rsi, 48h ; 'H'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1ERKS4_; std::string::basic_string(std::string const&)
jmp short $+2
loc_7B4B5:
mov rdi, [rsp+48h+var_30]
add rdi, 68h ; 'h'
mov [rsp+48h+var_48], rdi
mov rsi, [rsp+48h+var_10]
add rsi, 68h ; 'h'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1ERKS4_; std::string::basic_string(std::string const&)
jmp short $+2
loc_7B4D2:
mov rdi, [rsp+48h+var_30]
mov rax, [rsp+48h+var_10]
mov cx, [rax+90h]
mov [rdi+90h], cx
mov rax, [rax+88h]
mov [rdi+88h], rax
add rdi, 98h
mov rsi, [rsp+48h+var_10]
add rsi, 98h
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1ERKS4_; std::string::basic_string(std::string const&)
jmp short $+2
loc_7B512:
add rsp, 48h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
jmp short loc_7B572
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
jmp short loc_7B568
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
jmp short loc_7B55E
mov rdi, [rsp+0]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_7B55E:
mov rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_7B568:
mov rdi, [rsp+arg_18]
call _ZNSt8functionIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEvEED2Ev; std::function<std::string ()(void)>::~function()
loc_7B572:
mov rdi, [rsp+arg_8]
call _ZNSt8functionIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_EED2Ev; std::function<std::string ()(std::string)>::~function()
mov rdi, [rsp+arg_28]
call __Unwind_Resume
| long long cli::matchable::matchable(
cli::matchable *this,
const cli::matchable *a2,
int a3,
int a4,
int a5,
int a6)
{
int v6; // edx
int v7; // ecx
int v8; // r8d
int v9; // r9d
*(_QWORD *)this = off_1DD8E0;
std::function<std::string ()(std::string)>::function((_DWORD)this + 8, (_DWORD)a2 + 8, a3, a4, a5, a6);
std::function<std::string ()(void)>::function((_DWORD)this + 40, (_DWORD)a2 + 40, v6, v7, v8, v9);
std::string::basic_string((char *)this + 72, (char *)a2 + 72);
std::string::basic_string((char *)this + 104, (char *)a2 + 104);
*((_WORD *)this + 72) = *((_WORD *)a2 + 72);
*((_QWORD *)this + 17) = *((_QWORD *)a2 + 17);
return std::string::basic_string((char *)this + 152, (char *)a2 + 152);
}
| matchable:
SUB RSP,0x48
MOV qword ptr [RSP + 0x40],RDI
MOV qword ptr [RSP + 0x38],RSI
MOV RDI,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x18],RDI
LEA RAX,[0x2dd8e0]
MOV qword ptr [RDI],RAX
ADD RDI,0x8
MOV qword ptr [RSP + 0x10],RDI
MOV RSI,qword ptr [RSP + 0x38]
ADD RSI,0x8
CALL 0x0017b5d0
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV RSI,qword ptr [RSP + 0x38]
ADD RSI,0x28
LAB_0017b490:
CALL 0x0017b680
JMP 0x0017b497
LAB_0017b497:
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x48
MOV qword ptr [RSP + 0x8],RDI
MOV RSI,qword ptr [RSP + 0x38]
ADD RSI,0x48
LAB_0017b4ae:
CALL 0x0010f2b0
JMP 0x0017b4b5
LAB_0017b4b5:
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x68
MOV qword ptr [RSP],RDI
MOV RSI,qword ptr [RSP + 0x38]
ADD RSI,0x68
LAB_0017b4cb:
CALL 0x0010f2b0
JMP 0x0017b4d2
LAB_0017b4d2:
MOV RDI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x38]
MOV CX,word ptr [RAX + 0x90]
MOV word ptr [RDI + 0x90],CX
MOV RAX,qword ptr [RAX + 0x88]
MOV qword ptr [RDI + 0x88],RAX
ADD RDI,0x98
MOV RSI,qword ptr [RSP + 0x38]
ADD RSI,0x98
LAB_0017b50b:
CALL 0x0010f2b0
LAB_0017b510:
JMP 0x0017b512
LAB_0017b512:
ADD RSP,0x48
RET
|
/* cli::matchable::matchable(cli::matchable const&) */
void __thiscall cli::matchable::matchable(matchable *this,matchable *param_1)
{
*(int ***)this = &PTR__matchable_002dd8e0;
std::function<std::__cxx11::string(std::__cxx11::string)>::function
((function<std::__cxx11::string(std::__cxx11::string)> *)(this + 8),
(function *)(param_1 + 8));
/* try { // try from 0017b490 to 0017b494 has its CatchHandler @ 0017b517 */
std::function<std::__cxx11::string()>::function
((function<std::__cxx11::string()> *)(this + 0x28),(function *)(param_1 + 0x28));
/* try { // try from 0017b4ae to 0017b4b2 has its CatchHandler @ 0017b527 */
std::__cxx11::string::string((string *)(this + 0x48),(string *)(param_1 + 0x48));
/* try { // try from 0017b4cb to 0017b4cf has its CatchHandler @ 0017b537 */
std::__cxx11::string::string((string *)(this + 0x68),(string *)(param_1 + 0x68));
*(int2 *)(this + 0x90) = *(int2 *)(param_1 + 0x90);
*(int8 *)(this + 0x88) = *(int8 *)(param_1 + 0x88);
/* try { // try from 0017b50b to 0017b50f has its CatchHandler @ 0017b547 */
std::__cxx11::string::string((string *)(this + 0x98),(string *)(param_1 + 0x98));
return;
}
| |
38,675 | fs_create_directory_with_parents(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/common.cpp | bool fs_create_directory_with_parents(const std::string & path) {
#ifdef _WIN32
std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
std::wstring wpath = converter.from_bytes(path);
// if the path already exists, check whether it's a directory
const DWORD attributes = GetFileAttributesW(wpath.c_str());
if ((attributes != INVALID_FILE_ATTRIBUTES) && (attributes & FILE_ATTRIBUTE_DIRECTORY)) {
return true;
}
size_t pos_slash = 0;
// process path from front to back, procedurally creating directories
while ((pos_slash = path.find('\\', pos_slash)) != std::string::npos) {
const std::wstring subpath = wpath.substr(0, pos_slash);
const wchar_t * test = subpath.c_str();
const bool success = CreateDirectoryW(test, NULL);
if (!success) {
const DWORD error = GetLastError();
// if the path already exists, ensure that it's a directory
if (error == ERROR_ALREADY_EXISTS) {
const DWORD attributes = GetFileAttributesW(subpath.c_str());
if (attributes == INVALID_FILE_ATTRIBUTES || !(attributes & FILE_ATTRIBUTE_DIRECTORY)) {
return false;
}
} else {
return false;
}
}
pos_slash += 1;
}
return true;
#else
// if the path already exists, check whether it's a directory
struct stat info;
if (stat(path.c_str(), &info) == 0) {
return S_ISDIR(info.st_mode);
}
size_t pos_slash = 1; // skip leading slashes for directory creation
// process path from front to back, procedurally creating directories
while ((pos_slash = path.find('/', pos_slash)) != std::string::npos) {
const std::string subpath = path.substr(0, pos_slash);
struct stat info;
// if the path already exists, ensure that it's a directory
if (stat(subpath.c_str(), &info) == 0) {
if (!S_ISDIR(info.st_mode)) {
return false;
}
} else {
// create parent directories
const int ret = mkdir(subpath.c_str(), 0755);
if (ret != 0) {
return false;
}
}
pos_slash += 1;
}
return true;
#endif // _WIN32
} | O1 | cpp | fs_create_directory_with_parents(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x1b7f0
testl %eax, %eax
je 0x74235
movl $0x1, %r14d
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
movq %rbx, %rdi
movl $0x2f, %esi
movq %r14, %rdx
callq 0x1bb50
movq %rax, %r14
cmpq $-0x1, %rax
sete %al
je 0x74249
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0x1b920
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x1b7f0
testl %eax, %eax
je 0x741f9
movq 0x8(%rsp), %rdi
movl $0x1ed, %esi # imm = 0x1ED
callq 0x1b430
testl %eax, %eax
je 0x7420b
xorl %ebp, %ebp
jmp 0x74211
movl 0x40(%rsp), %eax
movl $0xf000, %ecx # imm = 0xF000
andl %ecx, %eax
cmpl $0x4000, %eax # imm = 0x4000
jne 0x741f5
incq %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x74228
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8d0
testb %bpl, %bpl
jne 0x741a1
xorl %eax, %eax
jmp 0x74249
movl $0xf000, %eax # imm = 0xF000
andl 0xd0(%rsp), %eax
cmpl $0x4000, %eax # imm = 0x4000
sete %al
addq $0x148, %rsp # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _Z32fs_create_directory_with_parentsRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 148h
mov rbx, rdi
mov rdi, [rdi]
lea rsi, [rsp+178h+var_C0]
call _stat
test eax, eax
jz loc_74235
mov r14d, 1
lea r13, [rsp+178h+var_160]
lea r15, [rsp+178h+var_170]
lea r12, [rsp+178h+var_150]
loc_741A1:
mov rdi, rbx
mov esi, 2Fh ; '/'
mov rdx, r14
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEcm; std::string::find(char,ulong)
mov r14, rax
cmp rax, 0FFFFFFFFFFFFFFFFh
setz al
jz loc_74249
mov rdi, r15
mov rsi, rbx
xor edx, edx
mov rcx, r14
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rdi, [rsp+178h+var_170]
mov rsi, r12
call _stat
test eax, eax
jz short loc_741F9
mov rdi, [rsp+178h+var_170]
mov esi, 1EDh
call _mkdir
test eax, eax
jz short loc_7420B
loc_741F5:
xor ebp, ebp
jmp short loc_74211
loc_741F9:
mov eax, [rsp+178h+var_138]
mov ecx, 0F000h
and eax, ecx
cmp eax, 4000h
jnz short loc_741F5
loc_7420B:
inc r14
mov bpl, 1
loc_74211:
mov rdi, [rsp+178h+var_170]; void *
cmp rdi, r13
jz short loc_74228
mov rsi, [rsp+178h+var_160]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_74228:
test bpl, bpl
jnz loc_741A1
xor eax, eax
jmp short loc_74249
loc_74235:
mov eax, 0F000h
and eax, [rsp+178h+var_A8]
cmp eax, 4000h
setz al
loc_74249:
add rsp, 148h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| bool fs_create_directory_with_parents(_QWORD *a1)
{
long long v1; // r14
bool result; // al
char v3; // bp
void *v4; // [rsp+8h] [rbp-170h] BYREF
long long v5; // [rsp+18h] [rbp-160h] BYREF
_BYTE v6[24]; // [rsp+28h] [rbp-150h] BYREF
int v7; // [rsp+40h] [rbp-138h]
_BYTE v8[24]; // [rsp+B8h] [rbp-C0h] BYREF
int v9; // [rsp+D0h] [rbp-A8h]
if ( (unsigned int)stat(*a1, v8) )
{
v1 = 1LL;
while ( 1 )
{
v1 = std::string::find(a1, 47LL, v1);
result = v1 == -1;
if ( v1 == -1 )
return result;
std::string::substr(&v4, a1, 0LL, v1);
if ( (unsigned int)stat(v4, v6) )
{
if ( !(unsigned int)mkdir(v4, 493LL) )
goto LABEL_8;
}
else if ( (v7 & 0xF000) == 0x4000 )
{
LABEL_8:
++v1;
v3 = 1;
goto LABEL_9;
}
v3 = 0;
LABEL_9:
if ( v4 != &v5 )
operator delete(v4, v5 + 1);
if ( !v3 )
return 0;
}
}
return (v9 & 0xF000) == 0x4000;
}
| fs_create_directory_with_parents:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x148
MOV RBX,RDI
MOV RDI,qword ptr [RDI]
LEA RSI,[RSP + 0xb8]
CALL 0x0011b7f0
TEST EAX,EAX
JZ 0x00174235
MOV R14D,0x1
LEA R13,[RSP + 0x18]
LEA R15,[RSP + 0x8]
LEA R12,[RSP + 0x28]
LAB_001741a1:
MOV RDI,RBX
MOV ESI,0x2f
MOV RDX,R14
CALL 0x0011bb50
MOV R14,RAX
CMP RAX,-0x1
SETZ AL
JZ 0x00174249
MOV RDI,R15
MOV RSI,RBX
XOR EDX,EDX
MOV RCX,R14
CALL 0x0011b920
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,R12
CALL 0x0011b7f0
TEST EAX,EAX
JZ 0x001741f9
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,0x1ed
CALL 0x0011b430
TEST EAX,EAX
JZ 0x0017420b
LAB_001741f5:
XOR EBP,EBP
JMP 0x00174211
LAB_001741f9:
MOV EAX,dword ptr [RSP + 0x40]
MOV ECX,0xf000
AND EAX,ECX
CMP EAX,0x4000
JNZ 0x001741f5
LAB_0017420b:
INC R14
MOV BPL,0x1
LAB_00174211:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R13
JZ 0x00174228
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011b8d0
LAB_00174228:
TEST BPL,BPL
JNZ 0x001741a1
XOR EAX,EAX
JMP 0x00174249
LAB_00174235:
MOV EAX,0xf000
AND EAX,dword ptr [RSP + 0xd0]
CMP EAX,0x4000
SETZ AL
LAB_00174249:
ADD RSP,0x148
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* fs_create_directory_with_parents(std::__cxx11::string const&) */
bool fs_create_directory_with_parents(string *param_1)
{
int iVar1;
long lVar2;
bool bVar3;
long *local_170 [2];
long local_160 [2];
stat local_150;
stat local_c0;
iVar1 = stat(*(char **)param_1,&local_c0);
if (iVar1 == 0) {
bVar3 = (local_c0.st_mode & 0xf000) == 0x4000;
}
else {
do {
lVar2 = std::__cxx11::string::find((char)param_1,0x2f);
if (lVar2 == -1) {
return lVar2 == -1;
}
std::__cxx11::string::substr((ulong)local_170,(ulong)param_1);
iVar1 = stat((char *)local_170[0],&local_150);
if (iVar1 == 0) {
if ((local_150.st_mode & 0xf000) != 0x4000) goto LAB_001741f5;
LAB_0017420b:
bVar3 = true;
}
else {
iVar1 = mkdir((char *)local_170[0],0x1ed);
if (iVar1 == 0) goto LAB_0017420b;
LAB_001741f5:
bVar3 = false;
}
if (local_170[0] != local_160) {
operator_delete(local_170[0],local_160[0] + 1);
}
} while (bVar3);
bVar3 = false;
}
return bVar3;
}
| |
38,676 | fs_create_directory_with_parents(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/common.cpp | bool fs_create_directory_with_parents(const std::string & path) {
#ifdef _WIN32
std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
std::wstring wpath = converter.from_bytes(path);
// if the path already exists, check whether it's a directory
const DWORD attributes = GetFileAttributesW(wpath.c_str());
if ((attributes != INVALID_FILE_ATTRIBUTES) && (attributes & FILE_ATTRIBUTE_DIRECTORY)) {
return true;
}
size_t pos_slash = 0;
// process path from front to back, procedurally creating directories
while ((pos_slash = path.find('\\', pos_slash)) != std::string::npos) {
const std::wstring subpath = wpath.substr(0, pos_slash);
const wchar_t * test = subpath.c_str();
const bool success = CreateDirectoryW(test, NULL);
if (!success) {
const DWORD error = GetLastError();
// if the path already exists, ensure that it's a directory
if (error == ERROR_ALREADY_EXISTS) {
const DWORD attributes = GetFileAttributesW(subpath.c_str());
if (attributes == INVALID_FILE_ATTRIBUTES || !(attributes & FILE_ATTRIBUTE_DIRECTORY)) {
return false;
}
} else {
return false;
}
}
pos_slash += 1;
}
return true;
#else
// if the path already exists, check whether it's a directory
struct stat info;
if (stat(path.c_str(), &info) == 0) {
return S_ISDIR(info.st_mode);
}
size_t pos_slash = 1; // skip leading slashes for directory creation
// process path from front to back, procedurally creating directories
while ((pos_slash = path.find('/', pos_slash)) != std::string::npos) {
const std::string subpath = path.substr(0, pos_slash);
struct stat info;
// if the path already exists, ensure that it's a directory
if (stat(subpath.c_str(), &info) == 0) {
if (!S_ISDIR(info.st_mode)) {
return false;
}
} else {
// create parent directories
const int ret = mkdir(subpath.c_str(), 0755);
if (ret != 0) {
return false;
}
}
pos_slash += 1;
}
return true;
#endif // _WIN32
} | O3 | cpp | fs_create_directory_with_parents(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x1a7f0
testl %eax, %eax
je 0x73a6b
movl $0x1, %r14d
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
movq %rbx, %rdi
movl $0x2f, %esi
movq %r14, %rdx
callq 0x1ab50
cmpq $-0x1, %rax
sete %bpl
je 0x73a80
movq %rax, %r14
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x1a920
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x1a7f0
testl %eax, %eax
je 0x73a2c
movq 0x8(%rsp), %rdi
movl $0x1ed, %esi # imm = 0x1ED
callq 0x1a430
testl %eax, %eax
je 0x73a3e
xorl %r13d, %r13d
jmp 0x73a44
movl 0x40(%rsp), %eax
movl $0xf000, %ecx # imm = 0xF000
andl %ecx, %eax
cmpl $0x4000, %eax # imm = 0x4000
jne 0x73a27
incq %r14
movb $0x1, %r13b
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x73a60
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a8d0
testb %r13b, %r13b
jne 0x739d2
jmp 0x73a80
movl $0xf000, %eax # imm = 0xF000
andl 0xd0(%rsp), %eax
cmpl $0x4000, %eax # imm = 0x4000
sete %bpl
movl %ebp, %eax
addq $0x148, %rsp # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _Z32fs_create_directory_with_parentsRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 148h
mov rbx, rdi
mov rdi, [rdi]
lea rsi, [rsp+178h+var_C0]
call _stat
test eax, eax
jz loc_73A6B
mov r14d, 1
lea r15, [rsp+178h+var_170]
lea r12, [rsp+178h+var_150]
loc_739D2:
mov rdi, rbx
mov esi, 2Fh ; '/'
mov rdx, r14
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEcm; std::string::find(char,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
setz bpl
jz loc_73A80
mov r14, rax
mov rdi, r15
mov rsi, rbx
xor edx, edx
mov rcx, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rdi, [rsp+178h+var_170]
mov rsi, r12
call _stat
test eax, eax
jz short loc_73A2C
mov rdi, [rsp+178h+var_170]
mov esi, 1EDh
call _mkdir
test eax, eax
jz short loc_73A3E
loc_73A27:
xor r13d, r13d
jmp short loc_73A44
loc_73A2C:
mov eax, [rsp+178h+var_138]
mov ecx, 0F000h
and eax, ecx
cmp eax, 4000h
jnz short loc_73A27
loc_73A3E:
inc r14
mov r13b, 1
loc_73A44:
mov rdi, [rsp+178h+var_170]; void *
lea rax, [rsp+178h+var_160]
cmp rdi, rax
jz short loc_73A60
mov rsi, [rsp+178h+var_160]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_73A60:
test r13b, r13b
jnz loc_739D2
jmp short loc_73A80
loc_73A6B:
mov eax, 0F000h
and eax, [rsp+178h+var_A8]
cmp eax, 4000h
setz bpl
loc_73A80:
mov eax, ebp
add rsp, 148h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long fs_create_directory_with_parents(_QWORD *a1)
{
unsigned int v1; // ebp
long long v2; // r14
long long v3; // rax
char v4; // r13
void *v6; // [rsp+8h] [rbp-170h] BYREF
long long v7; // [rsp+18h] [rbp-160h] BYREF
_BYTE v8[24]; // [rsp+28h] [rbp-150h] BYREF
int v9; // [rsp+40h] [rbp-138h]
_BYTE v10[24]; // [rsp+B8h] [rbp-C0h] BYREF
int v11; // [rsp+D0h] [rbp-A8h]
if ( (unsigned int)stat(*a1, v10) )
{
v2 = 1LL;
while ( 1 )
{
v3 = std::string::find(a1, 47LL, v2);
LOBYTE(v1) = v3 == -1;
if ( v3 == -1 )
return v1;
v2 = v3;
std::string::substr(&v6, a1, 0LL, v3);
if ( (unsigned int)stat(v6, v8) )
{
if ( !(unsigned int)mkdir(v6, 493LL) )
goto LABEL_8;
}
else if ( (v9 & 0xF000) == 0x4000 )
{
LABEL_8:
++v2;
v4 = 1;
goto LABEL_9;
}
v4 = 0;
LABEL_9:
if ( v6 != &v7 )
operator delete(v6, v7 + 1);
if ( !v4 )
return v1;
}
}
LOBYTE(v1) = (v11 & 0xF000) == 0x4000;
return v1;
}
| fs_create_directory_with_parents:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x148
MOV RBX,RDI
MOV RDI,qword ptr [RDI]
LEA RSI,[RSP + 0xb8]
CALL 0x0011a7f0
TEST EAX,EAX
JZ 0x00173a6b
MOV R14D,0x1
LEA R15,[RSP + 0x8]
LEA R12,[RSP + 0x28]
LAB_001739d2:
MOV RDI,RBX
MOV ESI,0x2f
MOV RDX,R14
CALL 0x0011ab50
CMP RAX,-0x1
SETZ BPL
JZ 0x00173a80
MOV R14,RAX
MOV RDI,R15
MOV RSI,RBX
XOR EDX,EDX
MOV RCX,RAX
CALL 0x0011a920
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,R12
CALL 0x0011a7f0
TEST EAX,EAX
JZ 0x00173a2c
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,0x1ed
CALL 0x0011a430
TEST EAX,EAX
JZ 0x00173a3e
LAB_00173a27:
XOR R13D,R13D
JMP 0x00173a44
LAB_00173a2c:
MOV EAX,dword ptr [RSP + 0x40]
MOV ECX,0xf000
AND EAX,ECX
CMP EAX,0x4000
JNZ 0x00173a27
LAB_00173a3e:
INC R14
MOV R13B,0x1
LAB_00173a44:
MOV RDI,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x00173a60
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011a8d0
LAB_00173a60:
TEST R13B,R13B
JNZ 0x001739d2
JMP 0x00173a80
LAB_00173a6b:
MOV EAX,0xf000
AND EAX,dword ptr [RSP + 0xd0]
CMP EAX,0x4000
SETZ BPL
LAB_00173a80:
MOV EAX,EBP
ADD RSP,0x148
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* fs_create_directory_with_parents(std::__cxx11::string const&) */
ulong fs_create_directory_with_parents(string *param_1)
{
bool bVar1;
int iVar2;
long lVar3;
ulong unaff_RBP;
long *local_170 [2];
long local_160 [2];
stat local_150;
stat local_c0;
iVar2 = stat(*(char **)param_1,&local_c0);
if (iVar2 == 0) {
unaff_RBP = CONCAT71((int7)(unaff_RBP >> 8),(local_c0.st_mode & 0xf000) == 0x4000);
}
else {
do {
lVar3 = std::__cxx11::string::find((char)param_1,0x2f);
unaff_RBP = CONCAT71((int7)(unaff_RBP >> 8),lVar3 == -1);
if (lVar3 == -1) break;
std::__cxx11::string::substr((ulong)local_170,(ulong)param_1);
iVar2 = stat((char *)local_170[0],&local_150);
if (iVar2 == 0) {
if ((local_150.st_mode & 0xf000) != 0x4000) goto LAB_00173a27;
LAB_00173a3e:
bVar1 = true;
}
else {
iVar2 = mkdir((char *)local_170[0],0x1ed);
if (iVar2 == 0) goto LAB_00173a3e;
LAB_00173a27:
bVar1 = false;
}
if (local_170[0] != local_160) {
operator_delete(local_170[0],local_160[0] + 1);
}
} while (bVar1);
}
return unaff_RBP & 0xffffffff;
}
| |
38,677 | ggml_new_object | monkey531[P]llama/ggml/src/ggml.c | static struct ggml_object * ggml_new_object(struct ggml_context * ctx, enum ggml_object_type type, size_t size) {
// always insert objects at the end of the context's memory pool
struct ggml_object * obj_cur = ctx->objects_end;
const size_t cur_offs = obj_cur == NULL ? 0 : obj_cur->offs;
const size_t cur_size = obj_cur == NULL ? 0 : obj_cur->size;
const size_t cur_end = cur_offs + cur_size;
// align to GGML_MEM_ALIGN
size_t size_needed = GGML_PAD(size, GGML_MEM_ALIGN);
char * const mem_buffer = ctx->mem_buffer;
struct ggml_object * const obj_new = (struct ggml_object *)(mem_buffer + cur_end);
if (cur_end + size_needed + GGML_OBJECT_SIZE > ctx->mem_size) {
GGML_LOG_WARN("%s: not enough space in the context's memory pool (needed %zu, available %zu)\n",
__func__, cur_end + size_needed + GGML_OBJECT_SIZE, ctx->mem_size);
#ifndef NDEBUG
GGML_ABORT("not enough space in the context's memory pool");
#endif
return NULL;
}
*obj_new = (struct ggml_object) {
.offs = cur_end + GGML_OBJECT_SIZE,
.size = size_needed,
.next = NULL,
.type = type,
};
GGML_ASSERT_ALIGNED(mem_buffer + obj_new->offs);
if (obj_cur != NULL) {
obj_cur->next = obj_new;
} else {
// this is the first object in this context
ctx->objects_begin = obj_new;
}
ctx->objects_end = obj_new;
//printf("%s: inserted new object at %zu, size = %zu\n", __func__, cur_end, obj_new->size);
return obj_new;
} | O1 | c | ggml_new_object:
pushq %rbx
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x1a012
movq (%rax), %rcx
jmp 0x1a014
xorl %ecx, %ecx
testq %rax, %rax
je 0x1a01f
movq 0x8(%rax), %r9
jmp 0x1a022
xorl %r9d, %r9d
addq %rcx, %r9
addq $0xf, %rdx
andq $-0x10, %rdx
movq (%rdi), %r8
leaq (%rdx,%r9), %rcx
addq $0x20, %rcx
cmpq %r8, %rcx
jbe 0x1a05b
leaq 0x324ef(%rip), %rsi # 0x4c533
leaq 0x32537(%rip), %rdx # 0x4c582
xorl %ebx, %ebx
movl $0x3, %edi
xorl %eax, %eax
callq 0x167f0
jmp 0x1a0a3
movq 0x8(%rdi), %rbx
leaq 0x20(%r9), %rcx
movq %rcx, (%rbx,%r9)
movq %rdx, 0x8(%rbx,%r9)
movq $0x0, 0x10(%rbx,%r9)
movl %esi, 0x18(%rbx,%r9)
movl $0x0, 0x1c(%rbx,%r9)
addl %ebx, %ecx
testb $0xf, %cl
jne 0x1a0a8
addq %r9, %rbx
leaq 0x18(%rdi), %rcx
leaq 0x10(%rax), %rdx
testq %rax, %rax
cmoveq %rcx, %rdx
movq %rbx, (%rdx)
movq %rbx, 0x20(%rdi)
movq %rbx, %rax
popq %rbx
retq
leaq 0x30560(%rip), %rdi # 0x4a60f
leaq 0x305a3(%rip), %rdx # 0x4a659
leaq 0x324d5(%rip), %rcx # 0x4c592
movl $0x604, %esi # imm = 0x604
xorl %eax, %eax
callq 0x17c70
| ggml_new_object:
push rbx
mov rax, [rdi+20h]
test rax, rax
jz short loc_1A012
mov rcx, [rax]
jmp short loc_1A014
loc_1A012:
xor ecx, ecx
loc_1A014:
test rax, rax
jz short loc_1A01F
mov r9, [rax+8]
jmp short loc_1A022
loc_1A01F:
xor r9d, r9d
loc_1A022:
add r9, rcx
add rdx, 0Fh
and rdx, 0FFFFFFFFFFFFFFF0h
mov r8, [rdi]
lea rcx, [rdx+r9]
add rcx, 20h ; ' '
cmp rcx, r8
jbe short loc_1A05B
lea rsi, aSNotEnoughSpac; "%s: not enough space in the context's m"...
lea rdx, aGgmlNewObject; "ggml_new_object"
xor ebx, ebx
mov edi, 3
xor eax, eax
call _ggml_log_internal
jmp short loc_1A0A3
loc_1A05B:
mov rbx, [rdi+8]
lea rcx, [r9+20h]
mov [rbx+r9], rcx
mov [rbx+r9+8], rdx
mov qword ptr [rbx+r9+10h], 0
mov [rbx+r9+18h], esi
mov dword ptr [rbx+r9+1Ch], 0
add ecx, ebx
test cl, 0Fh
jnz short loc_1A0A8
add rbx, r9
lea rcx, [rdi+18h]
lea rdx, [rax+10h]
test rax, rax
cmovz rdx, rcx
mov [rdx], rbx
mov [rdi+20h], rbx
loc_1A0A3:
mov rax, rbx
pop rbx
retn
loc_1A0A8:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aUintptrTMemBuf; "((uintptr_t) (mem_buffer + obj_new->off"...
mov esi, 604h
xor eax, eax
call _ggml_abort
| long long ggml_new_object(
long long *a1,
int a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11)
{
long long *v11; // rax
long long v12; // rcx
long long v13; // r9
long long v14; // r9
unsigned long long v15; // rdx
long long v16; // r8
unsigned long long v17; // rcx
long long v18; // rbx
long long v19; // rbx
long long *v20; // rdx
v11 = (long long *)a1[4];
if ( v11 )
v12 = *v11;
else
v12 = 0LL;
if ( v11 )
v13 = v11[1];
else
v13 = 0LL;
v14 = v12 + v13;
v15 = (a3 + 15) & 0xFFFFFFFFFFFFFFF0LL;
v16 = *a1;
v17 = v15 + v14 + 32;
if ( v17 <= *a1 )
{
v19 = a1[1];
*(_QWORD *)(v19 + v14) = v14 + 32;
*(_QWORD *)(v19 + v14 + 8) = v15;
*(_QWORD *)(v19 + v14 + 16) = 0LL;
*(_DWORD *)(v19 + v14 + 24) = a2;
*(_DWORD *)(v19 + v14 + 28) = 0;
if ( (((_BYTE)v19 + (_BYTE)v14 + 32) & 0xF) != 0 )
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml.c",
1540,
(unsigned int)"GGML_ASSERT(%s) failed",
(unsigned int)"((uintptr_t) (mem_buffer + obj_new->offs))%GGML_MEM_ALIGN == 0",
v16,
v14);
v18 = v14 + v19;
v20 = v11 + 2;
if ( !v11 )
v20 = a1 + 3;
*v20 = v18;
a1[4] = v18;
}
else
{
v18 = 0LL;
ggml_log_internal(
3u,
(long long)"%s: not enough space in the context's memory pool (needed %zu, available %zu)\n",
(long long)"ggml_new_object",
v17,
v16,
v14,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11);
}
return v18;
}
| ggml_new_object:
PUSH RBX
MOV RAX,qword ptr [RDI + 0x20]
TEST RAX,RAX
JZ 0x0011a012
MOV RCX,qword ptr [RAX]
JMP 0x0011a014
LAB_0011a012:
XOR ECX,ECX
LAB_0011a014:
TEST RAX,RAX
JZ 0x0011a01f
MOV R9,qword ptr [RAX + 0x8]
JMP 0x0011a022
LAB_0011a01f:
XOR R9D,R9D
LAB_0011a022:
ADD R9,RCX
ADD RDX,0xf
AND RDX,-0x10
MOV R8,qword ptr [RDI]
LEA RCX,[RDX + R9*0x1]
ADD RCX,0x20
CMP RCX,R8
JBE 0x0011a05b
LEA RSI,[0x14c533]
LEA RDX,[0x14c582]
XOR EBX,EBX
MOV EDI,0x3
XOR EAX,EAX
CALL 0x001167f0
JMP 0x0011a0a3
LAB_0011a05b:
MOV RBX,qword ptr [RDI + 0x8]
LEA RCX,[R9 + 0x20]
MOV qword ptr [RBX + R9*0x1],RCX
MOV qword ptr [RBX + R9*0x1 + 0x8],RDX
MOV qword ptr [RBX + R9*0x1 + 0x10],0x0
MOV dword ptr [RBX + R9*0x1 + 0x18],ESI
MOV dword ptr [RBX + R9*0x1 + 0x1c],0x0
ADD ECX,EBX
TEST CL,0xf
JNZ 0x0011a0a8
ADD RBX,R9
LEA RCX,[RDI + 0x18]
LEA RDX,[RAX + 0x10]
TEST RAX,RAX
CMOVZ RDX,RCX
MOV qword ptr [RDX],RBX
MOV qword ptr [RDI + 0x20],RBX
LAB_0011a0a3:
MOV RAX,RBX
POP RBX
RET
LAB_0011a0a8:
LEA RDI,[0x14a60f]
LEA RDX,[0x14a659]
LEA RCX,[0x14c592]
MOV ESI,0x604
XOR EAX,EAX
CALL 0x00117c70
|
ulong ggml_new_object(ulong *param_1,int4 param_2,long param_3)
{
long *plVar1;
long lVar2;
ulong uVar3;
ulong *puVar4;
ulong uVar5;
long lVar6;
plVar1 = (long *)param_1[4];
if (plVar1 == (long *)0x0) {
lVar2 = 0;
lVar6 = 0;
}
else {
lVar2 = *plVar1;
lVar6 = plVar1[1];
}
lVar6 = lVar6 + lVar2;
uVar3 = param_3 + 0xfU & 0xfffffffffffffff0;
if (*param_1 < uVar3 + lVar6 + 0x20) {
uVar5 = 0;
ggml_log_internal(3,
"%s: not enough space in the context\'s memory pool (needed %zu, available %zu)\n"
,"ggml_new_object");
}
else {
uVar5 = param_1[1];
*(long *)(uVar5 + lVar6) = lVar6 + 0x20;
*(ulong *)(uVar5 + 8 + lVar6) = uVar3;
*(int8 *)(uVar5 + 0x10 + lVar6) = 0;
*(int4 *)(uVar5 + 0x18 + lVar6) = param_2;
*(int4 *)(uVar5 + 0x1c + lVar6) = 0;
if (((int)(lVar6 + 0x20) + (int)uVar5 & 0xfU) != 0) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml.c",0x604,
"GGML_ASSERT(%s) failed",
"((uintptr_t) (mem_buffer + obj_new->offs))%GGML_MEM_ALIGN == 0");
}
uVar5 = uVar5 + lVar6;
puVar4 = (ulong *)(plVar1 + 2);
if (plVar1 == (long *)0x0) {
puVar4 = param_1 + 3;
}
*puVar4 = uVar5;
param_1[4] = uVar5;
}
return uVar5;
}
| |
38,678 | inline_mysql_file_delete | eloqsql/include/mysql/psi/mysql_file.h | static inline int
inline_mysql_file_delete(
#ifdef HAVE_PSI_FILE_INTERFACE
PSI_file_key key, const char *src_file, uint src_line,
#endif
const char *name, myf flags)
{
int result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_name_locker)(&state, key, PSI_FILE_DELETE, name, &locker);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_close_wait)(locker, src_file, src_line);
result= my_delete(name, flags);
PSI_FILE_CALL(end_file_close_wait)(locker, result);
return result;
}
#endif
result= my_delete(name, flags);
return result;
} | O0 | c | inline_mysql_file_delete:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq 0x24a164(%rip), %rax # 0x2c0238
movq (%rax), %rax
movq 0x148(%rax), %rax
movl -0x8(%rbp), %esi
movq -0x20(%rbp), %rcx
leaq -0x80(%rbp), %rdi
movl $0xe, %edx
leaq -0x38(%rbp), %r8
callq *%rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x76168
leaq 0x24a119(%rip), %rax # 0x2c0238
movq (%rax), %rax
movq 0x220(%rax), %rax
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq *%rax
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xef4c0
movl %eax, -0x2c(%rbp)
leaq 0x24a0eb(%rip), %rax # 0x2c0238
movq (%rax), %rax
movq 0x228(%rax), %rax
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq *%rax
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7617e
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xef4c0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| inline_mysql_file_delete_0:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_8], edi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+148h]
mov esi, [rbp+var_8]
mov rcx, [rbp+var_20]
lea rdi, [rbp+var_80]
mov edx, 0Eh
lea r8, [rbp+var_38]
call rax
mov [rbp+var_38], rax
cmp [rbp+var_38], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_76168
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+220h]
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
call rax
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_28]
call my_delete
mov [rbp+var_2C], eax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+228h]
mov rdi, [rbp+var_38]
mov esi, [rbp+var_2C]
call rax
mov eax, [rbp+var_2C]
mov [rbp+var_4], eax
jmp short loc_7617E
loc_76168:
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_28]
call my_delete
mov [rbp+var_2C], eax
mov eax, [rbp+var_2C]
mov [rbp+var_4], eax
loc_7617E:
mov eax, [rbp+var_4]
add rsp, 80h
pop rbp
retn
| long long inline_mysql_file_delete_0(unsigned int a1, long long a2, unsigned int a3, long long a4, long long a5)
{
_BYTE v6[72]; // [rsp+0h] [rbp-80h] BYREF
long long v7; // [rsp+48h] [rbp-38h] BYREF
unsigned int v8; // [rsp+54h] [rbp-2Ch]
long long v9; // [rsp+58h] [rbp-28h]
long long v10; // [rsp+60h] [rbp-20h]
unsigned int v11; // [rsp+6Ch] [rbp-14h]
long long v12; // [rsp+70h] [rbp-10h]
unsigned int v13; // [rsp+78h] [rbp-8h]
v13 = a1;
v12 = a2;
v11 = a3;
v10 = a4;
v9 = a5;
v7 = ((long long ( *)(_BYTE *, _QWORD, long long, long long, long long *))PSI_server[41])(v6, a1, 14LL, a4, &v7);
if ( v7 )
{
((void ( *)(long long, long long, _QWORD))PSI_server[68])(v7, v12, v11);
v8 = my_delete(v10, v9);
((void ( *)(long long, _QWORD))PSI_server[69])(v7, v8);
}
else
{
return (unsigned int)my_delete(v10, v9);
}
return v8;
}
| inline_mysql_file_delete:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV dword ptr [RBP + -0x8],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
LEA RAX,[0x3c0238]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x148]
MOV ESI,dword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x20]
LEA RDI,[RBP + -0x80]
MOV EDX,0xe
LEA R8,[RBP + -0x38]
CALL RAX
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x00176168
LEA RAX,[0x3c0238]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x220]
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
CALL RAX
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x001ef4c0
MOV dword ptr [RBP + -0x2c],EAX
LEA RAX,[0x3c0238]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x228]
MOV RDI,qword ptr [RBP + -0x38]
MOV ESI,dword ptr [RBP + -0x2c]
CALL RAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0017617e
LAB_00176168:
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x001ef4c0
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x4],EAX
LAB_0017617e:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x80
POP RBP
RET
|
int4
inline_mysql_file_delete
(int4 param_1,int8 param_2,int4 param_3,int8 param_4,
int8 param_5)
{
int1 local_88 [72];
long local_40;
int4 local_34;
int8 local_30;
int8 local_28;
int4 local_1c;
int8 local_18;
int4 local_10;
int4 local_c;
local_30 = param_5;
local_28 = param_4;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
local_40 = (**(code **)(PSI_server + 0x148))(local_88,param_1,0xe,param_4,&local_40);
if (local_40 == 0) {
local_c = my_delete(local_28,local_30);
}
else {
(**(code **)(PSI_server + 0x220))(local_40,local_18,local_1c);
local_34 = my_delete(local_28,local_30);
(**(code **)(PSI_server + 0x228))(local_40,local_34);
local_c = local_34;
}
return local_c;
}
| |
38,679 | ftxui::InputOption::Spacious() | Andrewchistyakov[P]flashcards_lyc/build_O2/_deps/ftxui-src/src/ftxui/component/component_options.cpp | InputOption InputOption::Spacious() {
InputOption option;
option.transform = [](InputState state) {
state.element |= borderEmpty;
state.element |= color(Color::White);
if (state.is_placeholder) {
state.element |= dim;
}
if (state.focused) {
state.element |= bgcolor(Color::Black);
}
if (state.hovered) {
state.element |= bgcolor(Color::GrayDark);
}
return state.element;
};
return option;
} | O2 | cpp | ftxui::InputOption::Spacious():
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x2d3be
movups 0x50(%rbx), %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movups 0x60(%rbx), %xmm0
leaq 0x1229(%rip), %rax # 0x2d1cc
movq %rax, 0x60(%rbx)
movaps %xmm0, 0x10(%rdi)
leaq 0x105a(%rip), %rax # 0x2d00c
movq %rax, 0x68(%rbx)
callq 0x13b10
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
| _ZN5ftxui11InputOption8SpaciousEv:
push rbx
sub rsp, 20h
mov rbx, rdi
call _ZN5ftxui11InputOptionC2Ev; ftxui::InputOption::InputOption(void)
movups xmm0, xmmword ptr [rbx+50h]
mov rdi, rsp; this
movaps xmmword ptr [rdi], xmm0
xorps xmm0, xmm0
movups xmmword ptr [rbx+50h], xmm0
movups xmm0, xmmword ptr [rbx+60h]
lea rax, _ZNSt17_Function_handlerIFSt10shared_ptrIN5ftxui4NodeEENS1_10InputStateEEZNS1_11InputOption8SpaciousEvE3$_0E10_M_managerERSt9_Any_dataRKS9_St18_Manager_operation; std::_Function_handler<std::shared_ptr<ftxui::Node> ()(ftxui::InputState),ftxui::InputOption::Spacious(void)::$_0>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rbx+60h], rax
movaps xmmword ptr [rdi+10h], xmm0
lea rax, _ZNSt17_Function_handlerIFSt10shared_ptrIN5ftxui4NodeEENS1_10InputStateEEZNS1_11InputOption8SpaciousEvE3$_0E9_M_invokeERKSt9_Any_dataOS4_; std::_Function_handler<std::shared_ptr<ftxui::Node> ()(ftxui::InputState),ftxui::InputOption::Spacious(void)::$_0>::_M_invoke(std::_Any_data const&,ftxui::InputState&&)
mov [rbx+68h], rax
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
mov rax, rbx
add rsp, 20h
pop rbx
retn
| ftxui::InputOption * ftxui::InputOption::Spacious(ftxui::InputOption *this)
{
__int128 v1; // xmm0
_OWORD v3[2]; // [rsp+0h] [rbp-28h] BYREF
ftxui::InputOption::InputOption(this);
v3[0] = *((_OWORD *)this + 5);
*((_OWORD *)this + 5) = 0LL;
v1 = *((_OWORD *)this + 6);
*((_QWORD *)this + 12) = std::_Function_handler<std::shared_ptr<ftxui::Node> ()(ftxui::InputState),ftxui::InputOption::Spacious(void)::$_0>::_M_manager;
v3[1] = v1;
*((_QWORD *)this + 13) = std::_Function_handler<std::shared_ptr<ftxui::Node> ()(ftxui::InputState),ftxui::InputOption::Spacious(void)::$_0>::_M_invoke;
std::_Function_base::~_Function_base((std::_Function_base *)v3);
return this;
}
| Spacious:
PUSH RBX
SUB RSP,0x20
MOV RBX,RDI
CALL 0x0012d3be
MOVUPS XMM0,xmmword ptr [RBX + 0x50]
MOV RDI,RSP
MOVAPS xmmword ptr [RDI],XMM0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x50],XMM0
MOVUPS XMM0,xmmword ptr [RBX + 0x60]
LEA RAX,[0x12d1cc]
MOV qword ptr [RBX + 0x60],RAX
MOVAPS xmmword ptr [RDI + 0x10],XMM0
LEA RAX,[0x12d00c]
MOV qword ptr [RBX + 0x68],RAX
CALL 0x00113b10
MOV RAX,RBX
ADD RSP,0x20
POP RBX
RET
|
/* ftxui::InputOption::Spacious() */
InputOption * __thiscall ftxui::InputOption::Spacious(InputOption *this)
{
int8 local_28;
int8 uStack_20;
int8 local_18;
int8 uStack_10;
InputOption(this);
local_28 = *(int8 *)(this + 0x50);
uStack_20 = *(int8 *)(this + 0x58);
*(int8 *)(this + 0x50) = 0;
*(int8 *)(this + 0x58) = 0;
local_18 = *(int8 *)(this + 0x60);
uStack_10 = *(int8 *)(this + 0x68);
*(code **)(this + 0x60) =
std::
_Function_handler<std::shared_ptr<ftxui::Node>(ftxui::InputState),ftxui::InputOption::Spacious()::$_0>
::_M_manager;
*(code **)(this + 0x68) =
std::
_Function_handler<std::shared_ptr<ftxui::Node>(ftxui::InputState),ftxui::InputOption::Spacious()::$_0>
::_M_invoke;
std::_Function_base::~_Function_base((_Function_base *)&local_28);
return this;
}
| |
38,680 | my_strnncollsp_latin1_de | eloqsql/strings/ctype-latin1.c | static int my_strnncollsp_latin1_de(CHARSET_INFO *cs __attribute__((unused)),
const uchar *a, size_t a_length,
const uchar *b, size_t b_length)
{
const uchar *a_end= a + a_length, *b_end= b + b_length;
uchar a_char, a_extend= 0, b_char, b_extend= 0;
while ((a < a_end || a_extend) && (b < b_end || b_extend))
{
if (a_extend)
{
a_char=a_extend;
a_extend= 0;
}
else
{
a_extend= combo2map[*a];
a_char= combo1map[*a++];
}
if (b_extend)
{
b_char= b_extend;
b_extend= 0;
}
else
{
b_extend= combo2map[*b];
b_char= combo1map[*b++];
}
if (a_char != b_char)
return (int) a_char - (int) b_char;
}
/* Check if double character last */
if (a_extend)
return 1;
if (b_extend)
return -1;
if (a < a_end)
return my_strnncollsp_padspace_bin(a, a_end - a);
if (b < b_end)
return -my_strnncollsp_padspace_bin(b, b_end - b);
return 0;
} | O3 | c | my_strnncollsp_latin1_de:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
addq %rsi, %rdx
addq %rcx, %r8
xorl %edi, %edi
leaq 0x17143d(%rip), %rax # 0x2256b0
leaq 0x171336(%rip), %r9 # 0x2255b0
xorl %r10d, %r10d
cmpq %rdx, %rsi
jb 0xb4287
testb %dil, %dil
je 0xb42d7
cmpq %r8, %rcx
jb 0xb4291
testb %r10b, %r10b
je 0xb42e3
testb %dil, %dil
je 0xb429d
movl %edi, %r11d
xorl %edi, %edi
jmp 0xb42ac
movzbl (%rsi), %r11d
movb (%r11,%rax), %dil
incq %rsi
movb (%r11,%r9), %r11b
testb %r10b, %r10b
je 0xb42b9
movl %r10d, %ebx
xorl %r10d, %r10d
jmp 0xb42c7
movzbl (%rcx), %ebx
movb (%rbx,%rax), %r10b
incq %rcx
movb (%rbx,%r9), %bl
cmpb %bl, %r11b
je 0xb427d
movzbl %bl, %ecx
movzbl %r11b, %eax
subl %ecx, %eax
jmp 0xb431d
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testb %r10b, %r10b
jne 0xb431d
jmp 0xb4306
movl $0x1, %eax
testb %dil, %dil
jne 0xb431d
cmpq %rdx, %rsi
jae 0xb4306
subq %rsi, %rdx
movq %rsi, %rdi
movq %rdx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xad8f5
xorl %eax, %eax
cmpq %r8, %rcx
jae 0xb431d
subq %rcx, %r8
movq %rcx, %rdi
movq %r8, %rsi
callq 0xad8f5
negl %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| my_strnncollsp_latin1_de:
push rbp
mov rbp, rsp
push rbx
push rax
add rdx, rsi
add r8, rcx
xor edi, edi
lea rax, combo2map
lea r9, combo1map
xor r10d, r10d
loc_B427D:
cmp rsi, rdx
jb short loc_B4287
test dil, dil
jz short loc_B42D7
loc_B4287:
cmp rcx, r8
jb short loc_B4291
test r10b, r10b
jz short loc_B42E3
loc_B4291:
test dil, dil
jz short loc_B429D
mov r11d, edi
xor edi, edi
jmp short loc_B42AC
loc_B429D:
movzx r11d, byte ptr [rsi]
mov dil, [r11+rax]
inc rsi
mov r11b, [r11+r9]
loc_B42AC:
test r10b, r10b
jz short loc_B42B9
mov ebx, r10d
xor r10d, r10d
jmp short loc_B42C7
loc_B42B9:
movzx ebx, byte ptr [rcx]
mov r10b, [rbx+rax]
inc rcx
mov bl, [rbx+r9]
loc_B42C7:
cmp r11b, bl
jz short loc_B427D
movzx ecx, bl
movzx eax, r11b
sub eax, ecx
jmp short loc_B431D
loc_B42D7:
mov eax, 0FFFFFFFFh
test r10b, r10b
jnz short loc_B431D
jmp short loc_B4306
loc_B42E3:
mov eax, 1
test dil, dil
jnz short loc_B431D
cmp rsi, rdx
jnb short loc_B4306
sub rdx, rsi
mov rdi, rsi
mov rsi, rdx
add rsp, 8
pop rbx
pop rbp
jmp my_strnncollsp_padspace_bin
loc_B4306:
xor eax, eax
cmp rcx, r8
jnb short loc_B431D
sub r8, rcx
mov rdi, rcx
mov rsi, r8
call my_strnncollsp_padspace_bin
neg eax
loc_B431D:
add rsp, 8
pop rbx
pop rbp
retn
| long long my_strnncollsp_latin1_de(
long long a1,
unsigned __int8 *a2,
long long a3,
unsigned __int8 *a4,
long long a5)
{
unsigned __int8 *v5; // rdx
unsigned __int8 *v6; // r8
unsigned __int8 v7; // di
unsigned __int8 v8; // r10
unsigned __int8 v9; // r11
long long v10; // r11
unsigned __int8 v11; // bl
long long v12; // rbx
long long result; // rax
v5 = &a2[a3];
v6 = &a4[a5];
v7 = 0;
v8 = 0;
while ( 1 )
{
if ( a2 >= v5 && !v7 )
{
result = 0xFFFFFFFFLL;
if ( v8 )
return result;
goto LABEL_19;
}
if ( a4 >= v6 && !v8 )
break;
if ( v7 )
{
v9 = v7;
v7 = 0;
}
else
{
v10 = *a2;
v7 = combo2map[v10];
++a2;
v9 = combo1map[v10];
}
if ( v8 )
{
v11 = v8;
v8 = 0;
}
else
{
v12 = *a4;
v8 = combo2map[v12];
++a4;
v11 = combo1map[v12];
}
if ( v9 != v11 )
return v9 - (unsigned int)v11;
}
result = 1LL;
if ( v7 )
return result;
if ( a2 < v5 )
return my_strnncollsp_padspace_bin((long long)a2, v5 - a2);
LABEL_19:
result = 0LL;
if ( a4 < v6 )
return (unsigned int)-my_strnncollsp_padspace_bin((long long)a4, v6 - a4);
return result;
}
| my_strnncollsp_latin1_de:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
ADD RDX,RSI
ADD R8,RCX
XOR EDI,EDI
LEA RAX,[0x3256b0]
LEA R9,[0x3255b0]
XOR R10D,R10D
LAB_001b427d:
CMP RSI,RDX
JC 0x001b4287
TEST DIL,DIL
JZ 0x001b42d7
LAB_001b4287:
CMP RCX,R8
JC 0x001b4291
TEST R10B,R10B
JZ 0x001b42e3
LAB_001b4291:
TEST DIL,DIL
JZ 0x001b429d
MOV R11D,EDI
XOR EDI,EDI
JMP 0x001b42ac
LAB_001b429d:
MOVZX R11D,byte ptr [RSI]
MOV DIL,byte ptr [R11 + RAX*0x1]
INC RSI
MOV R11B,byte ptr [R11 + R9*0x1]
LAB_001b42ac:
TEST R10B,R10B
JZ 0x001b42b9
MOV EBX,R10D
XOR R10D,R10D
JMP 0x001b42c7
LAB_001b42b9:
MOVZX EBX,byte ptr [RCX]
MOV R10B,byte ptr [RBX + RAX*0x1]
INC RCX
MOV BL,byte ptr [RBX + R9*0x1]
LAB_001b42c7:
CMP R11B,BL
JZ 0x001b427d
MOVZX ECX,BL
MOVZX EAX,R11B
SUB EAX,ECX
JMP 0x001b431d
LAB_001b42d7:
MOV EAX,0xffffffff
TEST R10B,R10B
JNZ 0x001b431d
JMP 0x001b4306
LAB_001b42e3:
MOV EAX,0x1
TEST DIL,DIL
JNZ 0x001b431d
CMP RSI,RDX
JNC 0x001b4306
SUB RDX,RSI
MOV RDI,RSI
MOV RSI,RDX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x001ad8f5
LAB_001b4306:
XOR EAX,EAX
CMP RCX,R8
JNC 0x001b431d
SUB R8,RCX
MOV RDI,RCX
MOV RSI,R8
CALL 0x001ad8f5
NEG EAX
LAB_001b431d:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
ulong my_strnncollsp_latin1_de
(int8 param_1,byte *param_2,long param_3,byte *param_4,long param_5)
{
int iVar1;
ulong uVar2;
byte *pbVar3;
byte bVar4;
byte bVar5;
byte *pbVar6;
byte bVar7;
byte bVar8;
pbVar3 = param_2 + param_3;
pbVar6 = param_4 + param_5;
bVar5 = 0;
bVar7 = 0;
do {
if ((pbVar3 <= param_2) && (bVar5 == 0)) {
if (bVar7 != 0) {
return 0xffffffff;
}
LAB_001b4306:
if (pbVar6 <= param_4) {
return 0;
}
iVar1 = my_strnncollsp_padspace_bin(param_4,(long)pbVar6 - (long)param_4);
return (ulong)(uint)-iVar1;
}
if ((pbVar6 <= param_4) && (bVar7 == 0)) {
if (bVar5 != 0) {
return 1;
}
if (param_2 < pbVar3) {
uVar2 = my_strnncollsp_padspace_bin(param_2,(long)pbVar3 - (long)param_2);
return uVar2;
}
goto LAB_001b4306;
}
if (bVar5 == 0) {
bVar8 = *param_2;
bVar5 = combo2map[bVar8];
param_2 = param_2 + 1;
bVar8 = combo1map[bVar8];
}
else {
bVar8 = bVar5;
bVar5 = 0;
}
if (bVar7 == 0) {
bVar4 = *param_4;
bVar7 = combo2map[bVar4];
param_4 = param_4 + 1;
bVar4 = combo1map[bVar4];
}
else {
bVar4 = bVar7;
bVar7 = 0;
}
if (bVar8 != bVar4) {
return (ulong)((uint)bVar8 - (uint)bVar4);
}
} while( true );
}
| |
38,681 | ma_lock_key_del | eloqsql/storage/maria/ma_key_recover.c | my_bool _ma_lock_key_del(MARIA_HA *info, my_bool insert_at_end)
{
MARIA_SHARE *share= info->s;
/*
info->key_del_used is 0 initially.
If the caller needs a block (_ma_new()), we look at the free list:
- looks empty? then caller will create a new block at end of file and
remember (through info->key_del_used==2) that it will not change
state.key_del and does not need to wake up waiters as nobody will wait for
it.
- non-empty? then we wait for other users of the state.key_del list to
have finished, then we lock this list (through share->key_del_used==1)
because we need to prevent some other thread to also read state.key_del
and use the same page as ours. We remember through info->key_del_used==1
that we will have to set state.key_del at unlock time and wake up
waiters.
If the caller wants to free a block (_ma_dispose()), "empty" and
"non-empty" are treated as "non-empty" is treated above.
When we are ready to unlock, we copy share->key_del_current into
state.key_del. Unlocking happens when writing the UNDO log record, that
can make a long lock time.
Why we wrote "*looks* empty": because we are looking at state.key_del
which may be slightly old (share->key_del_current may be more recent and
exact): when we want a new page, we tolerate to treat "there was no free
page 1 millisecond ago" as "there is no free page". It's ok to non-pop
(_ma_new(), page will be found later anyway) but it's not ok to non-push
(_ma_dispose(), page would be lost).
When we leave this function, info->key_del_used is always 1 or 2.
*/
if (info->key_del_used != 1)
{
mysql_mutex_lock(&share->key_del_lock);
if (share->state.key_del == HA_OFFSET_ERROR && insert_at_end)
{
mysql_mutex_unlock(&share->key_del_lock);
info->key_del_used= 2; /* insert-with-append */
return 1;
}
while (share->key_del_used)
mysql_cond_wait(&share->key_del_cond, &share->key_del_lock);
info->key_del_used= 1;
share->key_del_used= 1;
share->key_del_current= share->state.key_del;
mysql_mutex_unlock(&share->key_del_lock);
}
return share->key_del_current == HA_OFFSET_ERROR;
} | O0 | c | ma_lock_key_del:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x67e(%rax), %eax
cmpl $0x1, %eax
je 0x728ec
movq -0x20(%rbp), %rdi
addq $0x938, %rdi # imm = 0x938
leaq 0xe0186(%rip), %rsi # 0x1529b9
movl $0x57a, %edx # imm = 0x57A
callq 0x702d0
movq -0x20(%rbp), %rax
cmpq $-0x1, 0x120(%rax)
jne 0x72878
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
je 0x72878
movq -0x20(%rbp), %rdi
addq $0x938, %rdi # imm = 0x938
callq 0x70340
movq -0x10(%rbp), %rax
movb $0x2, 0x67e(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x72903
jmp 0x7287a
movq -0x20(%rbp), %rax
cmpb $0x0, 0x7e9(%rax)
je 0x728b0
movq -0x20(%rbp), %rdi
addq $0x980, %rdi # imm = 0x980
movq -0x20(%rbp), %rsi
addq $0x938, %rsi # imm = 0x938
leaq 0xe0115(%rip), %rdx # 0x1529b9
movl $0x582, %ecx # imm = 0x582
callq 0x72910
jmp 0x7287a
movq -0x10(%rbp), %rax
movb $0x1, 0x67e(%rax)
movq -0x20(%rbp), %rax
movb $0x1, 0x7e9(%rax)
movq -0x20(%rbp), %rax
movq 0x120(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x700(%rax)
movq -0x20(%rbp), %rdi
addq $0x938, %rdi # imm = 0x938
callq 0x70340
movq -0x20(%rbp), %rax
cmpq $-0x1, 0x700(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| _ma_lock_key_del:
push rbp
mov rbp, rsp
sub rsp, 20h
mov al, sil
mov [rbp+var_10], rdi
mov [rbp+var_11], al
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+67Eh]
cmp eax, 1
jz loc_728EC
mov rdi, [rbp+var_20]
add rdi, 938h
lea rsi, aWorkspaceLlm4b_16; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 57Ah
call inline_mysql_mutex_lock_13
mov rax, [rbp+var_20]
cmp qword ptr [rax+120h], 0FFFFFFFFFFFFFFFFh
jnz short loc_72878
movsx eax, [rbp+var_11]
cmp eax, 0
jz short loc_72878
mov rdi, [rbp+var_20]
add rdi, 938h
call inline_mysql_mutex_unlock_13
mov rax, [rbp+var_10]
mov byte ptr [rax+67Eh], 2
mov [rbp+var_1], 1
jmp loc_72903
loc_72878:
jmp short $+2
loc_7287A:
mov rax, [rbp+var_20]
cmp byte ptr [rax+7E9h], 0
jz short loc_728B0
mov rdi, [rbp+var_20]
add rdi, 980h
mov rsi, [rbp+var_20]
add rsi, 938h
lea rdx, aWorkspaceLlm4b_16; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 582h
call inline_mysql_cond_wait_2
jmp short loc_7287A
loc_728B0:
mov rax, [rbp+var_10]
mov byte ptr [rax+67Eh], 1
mov rax, [rbp+var_20]
mov byte ptr [rax+7E9h], 1
mov rax, [rbp+var_20]
mov rcx, [rax+120h]
mov rax, [rbp+var_20]
mov [rax+700h], rcx
mov rdi, [rbp+var_20]
add rdi, 938h
call inline_mysql_mutex_unlock_13
loc_728EC:
mov rax, [rbp+var_20]
cmp qword ptr [rax+700h], 0FFFFFFFFFFFFFFFFh
setz al
and al, 1
movzx eax, al
mov [rbp+var_1], al
loc_72903:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char ma_lock_key_del(long long *a1, char a2)
{
long long v3; // [rsp+0h] [rbp-20h]
v3 = *a1;
if ( *((_BYTE *)a1 + 1662) == 1 )
return *(_QWORD *)(v3 + 1792) == -1LL;
inline_mysql_mutex_lock_13(
v3 + 2360,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_key_recover.c",
0x57Au);
if ( *(_QWORD *)(v3 + 288) != -1LL || !a2 )
{
while ( *(_BYTE *)(v3 + 2025) )
inline_mysql_cond_wait_2(
v3 + 2432,
v3 + 2360,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_key_recover.c",
1410LL);
*((_BYTE *)a1 + 1662) = 1;
*(_BYTE *)(v3 + 2025) = 1;
*(_QWORD *)(v3 + 1792) = *(_QWORD *)(v3 + 288);
inline_mysql_mutex_unlock_13(v3 + 2360);
return *(_QWORD *)(v3 + 1792) == -1LL;
}
inline_mysql_mutex_unlock_13(v3 + 2360);
*((_BYTE *)a1 + 1662) = 2;
return 1;
}
| _ma_lock_key_del:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV AL,SIL
MOV qword ptr [RBP + -0x10],RDI
MOV byte ptr [RBP + -0x11],AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x67e]
CMP EAX,0x1
JZ 0x001728ec
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x938
LEA RSI,[0x2529b9]
MOV EDX,0x57a
CALL 0x001702d0
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX + 0x120],-0x1
JNZ 0x00172878
MOVSX EAX,byte ptr [RBP + -0x11]
CMP EAX,0x0
JZ 0x00172878
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x938
CALL 0x00170340
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x67e],0x2
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00172903
LAB_00172878:
JMP 0x0017287a
LAB_0017287a:
MOV RAX,qword ptr [RBP + -0x20]
CMP byte ptr [RAX + 0x7e9],0x0
JZ 0x001728b0
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x980
MOV RSI,qword ptr [RBP + -0x20]
ADD RSI,0x938
LEA RDX,[0x2529b9]
MOV ECX,0x582
CALL 0x00172910
JMP 0x0017287a
LAB_001728b0:
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x67e],0x1
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x7e9],0x1
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX + 0x120]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x700],RCX
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x938
CALL 0x00170340
LAB_001728ec:
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX + 0x700],-0x1
SETZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x1],AL
LAB_00172903:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
bool _ma_lock_key_del(long *param_1,char param_2)
{
long lVar1;
lVar1 = *param_1;
if (*(char *)((long)param_1 + 0x67e) != '\x01') {
inline_mysql_mutex_lock
(lVar1 + 0x938,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_key_recover.c",0x57a);
if ((*(long *)(lVar1 + 0x120) == -1) && (param_2 != '\0')) {
inline_mysql_mutex_unlock(lVar1 + 0x938);
*(int1 *)((long)param_1 + 0x67e) = 2;
return true;
}
while (*(char *)(lVar1 + 0x7e9) != '\0') {
inline_mysql_cond_wait
(lVar1 + 0x980,lVar1 + 0x938,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_key_recover.c",0x582);
}
*(int1 *)((long)param_1 + 0x67e) = 1;
*(int1 *)(lVar1 + 0x7e9) = 1;
*(int8 *)(lVar1 + 0x700) = *(int8 *)(lVar1 + 0x120);
inline_mysql_mutex_unlock(lVar1 + 0x938);
}
return *(long *)(lVar1 + 0x700) == -1;
}
| |
38,682 | LefDefParser::lefwStartMacroObs() | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp | int
lefwStartMacroObs()
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (lefwState != LEFW_MACRO_START &&
lefwState != LEFW_MACRO)
return LEFW_BAD_ORDER;
if (lefwIsMacroObs)
return LEFW_BAD_ORDER;
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) " OBS\n");
else
fprintf(lefwFile, " OBS\n");
lefwIsMacroObs = 1;
lefwSpacingVal = 0;
lefwWidthVal = 0;
lefwLines++;
return LEFW_OK;
} | O0 | cpp | LefDefParser::lefwStartMacroObs():
pushq %rax
leaq 0xdc28(%rip), %rax # 0x32e00
cmpq $0x0, (%rax)
jne 0x251eb
movl $0x1, 0x4(%rsp)
jmp 0x2529f
leaq 0xde5e(%rip), %rax # 0x33050
cmpl $0x9, (%rax)
je 0x25210
leaq 0xde52(%rip), %rax # 0x33050
cmpl $0x21, (%rax)
je 0x25210
movl $0x2, 0x4(%rsp)
jmp 0x2529f
leaq 0xde81(%rip), %rax # 0x33098
cmpl $0x0, (%rax)
je 0x25226
movl $0x2, 0x4(%rsp)
jmp 0x2529f
cmpl $0x0, 0xdebf(%rip) # 0x330ec
je 0x25249
leaq 0xdbca(%rip), %rax # 0x32e00
movq (%rax), %rdi
leaq 0x6c32(%rip), %rsi # 0x2be72
movb $0x0, %al
callq 0x289b0
jmp 0x25261
leaq 0xdbb0(%rip), %rax # 0x32e00
movq (%rax), %rdi
leaq 0x6c18(%rip), %rsi # 0x2be72
movb $0x0, %al
callq 0x1100
leaq 0xde30(%rip), %rax # 0x33098
movl $0x1, (%rax)
movl $0x0, 0xdea8(%rip) # 0x33120
movl $0x0, 0xdea2(%rip) # 0x33124
leaq 0xddc3(%rip), %rax # 0x3304c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0xddb7(%rip), %rax # 0x3304c
movl %ecx, (%rax)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
| _ZN12LefDefParser17lefwStartMacroObsEv:
push rax
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
cmp qword ptr [rax], 0
jnz short loc_251EB
mov [rsp+8+var_4], 1
jmp loc_2529F
loc_251EB:
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 9
jz short loc_25210
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 21h ; '!'
jz short loc_25210
mov [rsp+8+var_4], 2
jmp loc_2529F
loc_25210:
lea rax, _ZN12LefDefParser14lefwIsMacroObsE; LefDefParser::lefwIsMacroObs
cmp dword ptr [rax], 0
jz short loc_25226
mov [rsp+8+var_4], 2
jmp short loc_2529F
loc_25226:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 0; LefDefParser::lefwWriteEncrypt
jz short loc_25249
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
lea rsi, aObs_0; " OBS\n"
mov al, 0
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_25261
loc_25249:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
lea rsi, aObs_0; " OBS\n"
mov al, 0
call _fprintf
loc_25261:
lea rax, _ZN12LefDefParser14lefwIsMacroObsE; LefDefParser::lefwIsMacroObs
mov dword ptr [rax], 1
mov cs:_ZN12LefDefParserL14lefwSpacingValE, 0; LefDefParser::lefwSpacingVal
mov cs:_ZN12LefDefParserL12lefwWidthValE, 0; LefDefParser::lefwWidthVal
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov [rax], ecx
mov [rsp+8+var_4], 0
loc_2529F:
mov eax, [rsp+8+var_4]
pop rcx
retn
| long long LefDefParser::lefwStartMacroObs(LefDefParser *this, long long a2, int a3, int a4, int a5, int a6)
{
if ( *(_QWORD *)&LefDefParser::lefwFile )
{
if ( LefDefParser::lefwState == 9 || LefDefParser::lefwState == 33 )
{
if ( LefDefParser::lefwIsMacroObs )
{
return 2;
}
else
{
if ( LefDefParser::lefwWriteEncrypt )
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)" OBS\n", a3, a4, a5, a6);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " OBS\n");
LefDefParser::lefwIsMacroObs = 1;
LefDefParser::lefwSpacingVal = 0;
LefDefParser::lefwWidthVal = 0;
++LefDefParser::lefwLines;
return 0;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
| lefwStartMacroObs:
PUSH RAX
LEA RAX,[0x132e00]
CMP qword ptr [RAX],0x0
JNZ 0x001251eb
MOV dword ptr [RSP + 0x4],0x1
JMP 0x0012529f
LAB_001251eb:
LEA RAX,[0x133050]
CMP dword ptr [RAX],0x9
JZ 0x00125210
LEA RAX,[0x133050]
CMP dword ptr [RAX],0x21
JZ 0x00125210
MOV dword ptr [RSP + 0x4],0x2
JMP 0x0012529f
LAB_00125210:
LEA RAX,[0x133098]
CMP dword ptr [RAX],0x0
JZ 0x00125226
MOV dword ptr [RSP + 0x4],0x2
JMP 0x0012529f
LAB_00125226:
CMP dword ptr [0x001330ec],0x0
JZ 0x00125249
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x12be72]
MOV AL,0x0
CALL 0x001289b0
JMP 0x00125261
LAB_00125249:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x12be72]
MOV AL,0x0
CALL 0x00101100
LAB_00125261:
LEA RAX,[0x133098]
MOV dword ptr [RAX],0x1
MOV dword ptr [0x00133120],0x0
MOV dword ptr [0x00133124],0x0
LEA RAX,[0x13304c]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x13304c]
MOV dword ptr [RAX],ECX
MOV dword ptr [RSP + 0x4],0x0
LAB_0012529f:
MOV EAX,dword ptr [RSP + 0x4]
POP RCX
RET
|
/* LefDefParser::lefwStartMacroObs() */
int4 LefDefParser::lefwStartMacroObs(void)
{
int4 local_4;
if (lefwFile == (_IO_FILE *)0x0) {
local_4 = 1;
}
else if ((lefwState == 9) || (lefwState == 0x21)) {
if (lefwIsMacroObs == 0) {
if (lefwWriteEncrypt == 0) {
fprintf(lefwFile," OBS\n");
}
else {
encPrint(lefwFile," OBS\n");
}
lefwIsMacroObs = 1;
lefwSpacingVal = 0;
lefwWidthVal = 0;
lefwLines = lefwLines + 1;
local_4 = 0;
}
else {
local_4 = 2;
}
}
else {
local_4 = 2;
}
return local_4;
}
| |
38,683 | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get_token_string() const | llama.cpp/common/json.hpp | std::string get_token_string() const
{
// escape control characters
std::string result;
for (const auto c : token_string)
{
if (static_cast<unsigned char>(c) <= '\x1F')
{
// escape control characters
std::array<char, 9> cs{{}};
static_cast<void>((std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
result += cs.data();
}
else
{
// add character as is
result.push_back(static_cast<std::string::value_type>(c));
}
}
return result;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get_token_string() const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x38(%rsi), %r13
movq 0x40(%rsi), %rbp
cmpq %rbp, %r13
je 0x76433
leaq 0xa4c2e(%rip), %r14 # 0x11b012
leaq 0x8(%rsp), %r15
movzbl (%r13), %ecx
cmpl $0x1f, %ecx
ja 0x76420
movb $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x9, %esi
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x20880
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20b40
jmp 0x7642b
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x213c0
incq %r13
cmpq %rbp, %r13
jne 0x763e9
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x76447
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x7645e
movq (%r12), %rsi
incq %rsi
callq 0x20180
movq %r14, %rdi
callq 0x20af0
| _ZNK8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE16get_token_stringEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
lea r12, [rdi+10h]
mov [rdi], r12
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov r13, [rsi+38h]
mov rbp, [rsi+40h]
cmp r13, rbp
jz short loc_76433
lea r14, aU4x; "<U+%.4X>"
lea r15, [rsp+48h+var_40]
loc_763E9:
movzx ecx, byte ptr [r13+0]
cmp ecx, 1Fh
ja short loc_76420
mov [rsp+48h+var_38], 0
mov [rsp+48h+var_40], 0
mov esi, 9
mov rdi, r15
mov rdx, r14
xor eax, eax
call _snprintf
mov rdi, rbx
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
jmp short loc_7642B
loc_76420:
movsx esi, cl
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
loc_7642B:
inc r13
cmp r13, rbp
jnz short loc_763E9
loc_76433:
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_76447:
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, r12
jz short loc_7645E
mov rsi, [r12]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7645E:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get_token_string(
long long a1,
long long a2)
{
unsigned __int8 *v2; // r13
unsigned __int8 *i; // rbp
unsigned int v4; // ecx
long long v6; // [rsp+8h] [rbp-40h] BYREF
char v7; // [rsp+10h] [rbp-38h]
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v2 = *(unsigned __int8 **)(a2 + 56);
for ( i = *(unsigned __int8 **)(a2 + 64); v2 != i; ++v2 )
{
v4 = *v2;
if ( v4 > 0x1F )
{
std::string::push_back(a1, (unsigned int)(char)v4);
}
else
{
v7 = 0;
v6 = 0LL;
snprintf(&v6, 9LL, "<U+%.4X>", v4);
std::string::append(a1, &v6);
}
}
return a1;
}
| get_token_string:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
LEA R12,[RDI + 0x10]
MOV qword ptr [RDI],R12
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV R13,qword ptr [RSI + 0x38]
MOV RBP,qword ptr [RSI + 0x40]
CMP R13,RBP
JZ 0x00176433
LEA R14,[0x21b012]
LEA R15,[RSP + 0x8]
LAB_001763e9:
MOVZX ECX,byte ptr [R13]
CMP ECX,0x1f
JA 0x00176420
MOV byte ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x8],0x0
MOV ESI,0x9
MOV RDI,R15
MOV RDX,R14
XOR EAX,EAX
CALL 0x00120880
LAB_00176413:
MOV RDI,RBX
MOV RSI,R15
CALL 0x00120b40
JMP 0x0017642b
LAB_00176420:
MOVSX ESI,CL
MOV RDI,RBX
CALL 0x001213c0
LAB_0017642b:
INC R13
CMP R13,RBP
JNZ 0x001763e9
LAB_00176433:
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>, nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get_token_string()
const */
void nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
::get_token_string(void)
{
byte *pbVar1;
long in_RSI;
long *in_RDI;
byte *pbVar2;
char local_40 [16];
*in_RDI = (long)(in_RDI + 2);
in_RDI[1] = 0;
*(int1 *)(in_RDI + 2) = 0;
pbVar2 = *(byte **)(in_RSI + 0x38);
pbVar1 = *(byte **)(in_RSI + 0x40);
if (pbVar2 != pbVar1) {
do {
if (*pbVar2 < 0x20) {
local_40[8] = 0;
local_40[0] = '\0';
local_40[1] = '\0';
local_40[2] = '\0';
local_40[3] = '\0';
local_40[4] = '\0';
local_40[5] = '\0';
local_40[6] = '\0';
local_40[7] = '\0';
snprintf(local_40,9,"<U+%.4X>");
/* try { // try from 00176413 to 0017641d has its CatchHandler @ 00176447 */
std::__cxx11::string::append((char *)in_RDI);
}
else {
/* try { // try from 00176420 to 0017642a has its CatchHandler @ 00176445 */
std::__cxx11::string::push_back((char)in_RDI);
}
pbVar2 = pbVar2 + 1;
} while (pbVar2 != pbVar1);
}
return;
}
| |
38,684 | evmone::advanced::Instruction const* evmone::advanced::(anonymous namespace)::op<&evmone::TermResult evmone::advanced::instr::impl<(evmone::Opcode)243, &evmone::TermResult evmone::instr::core::return_impl<(evmc_status_code)0>(evmone::StackTop, long, evmone::ExecutionState&)>(evmone::advanced::AdvancedExecutionState&)>(evmone::advanced::Instruction const*, evmone::advanced::AdvancedExecutionState&) | corpus-core[P]colibri-stateless/build_O3/_deps/evmone_external-src/lib/evmone/advanced_instructions.cpp | const Instruction* op(const Instruction* /*instr*/, AdvancedExecutionState& state) noexcept
{
const auto result = InstrFn(state);
state.gas_left = result.gas_left;
return state.exit(result.status);
} | O3 | cpp | evmone::advanced::Instruction const* evmone::advanced::(anonymous namespace)::op<&evmone::TermResult evmone::advanced::instr::impl<(evmone::Opcode)243, &evmone::TermResult evmone::instr::core::return_impl<(evmc_status_code)0>(evmone::StackTop, long, evmone::ExecutionState&)>(evmone::advanced::AdvancedExecutionState&)>(evmone::advanced::Instruction const*, evmone::advanced::AdvancedExecutionState&):
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x220(%rsi), %rax
movq 0x228(%rsi), %r14
movdqu -0x20(%r14), %xmm0
movdqu -0x10(%r14), %xmm1
por %xmm0, %xmm1
ptest %xmm1, %xmm1
je 0x5015c
movq -0x10(%r14), %rcx
orq -0x8(%r14), %rcx
movl $0x3, %ebp
orq -0x18(%r14), %rcx
jne 0x5017b
movq -0x20(%r14), %rcx
movq %rcx, %rdx
shrq $0x20, %rdx
jne 0x5017b
movq 0x10(%r14), %rdx
orq 0x18(%r14), %rdx
orq 0x8(%r14), %rdx
jne 0x5017b
movq (%r14), %rdx
movq %rdx, %rsi
shrq $0x20, %rsi
jne 0x5017b
addq %rcx, %rdx
cmpq 0x10(%rbx), %rdx
jbe 0x50157
leaq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x41c31
testq %rax, %rax
js 0x5017b
movq -0x20(%r14), %rcx
movq %rcx, 0x88(%rbx)
movl $0x2, %ebp
testq %rcx, %rcx
je 0x5017b
movq (%r14), %rcx
movq %rcx, 0x80(%rbx)
movq %rax, 0x220(%rbx)
movl %ebp, 0x78(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
| _ZN6evmone8advanced12_GLOBAL__N_12opIXadL_ZNS0_5instr4implILNS_6OpcodeE253EXadL_ZNS_5instr4core11return_implIL16evmc_status_code2EEENS_10TermResultENS_8StackTopElRNS_14ExecutionStateEEEEESA_RNS0_22AdvancedExecutionStateEEEEEPKNS0_11InstructionESI_SF_:
push rbp
push r14
push rbx
mov rbx, rsi
mov rax, [rsi+220h]
mov r14, [rsi+228h]
movdqu xmm0, xmmword ptr [r14-20h]
movdqu xmm1, xmmword ptr [r14-10h]
por xmm1, xmm0
ptest xmm1, xmm1
jz short loc_5015C
mov rcx, [r14-10h]
or rcx, [r14-8]
mov ebp, 3
or rcx, [r14-18h]
jnz short loc_5017B
mov rcx, [r14-20h]; unsigned __int64
mov rdx, rcx
shr rdx, 20h
jnz short loc_5017B
mov rdx, [r14+10h]
or rdx, [r14+18h]
or rdx, [r14+8]
jnz short loc_5017B
mov rdx, [r14]
mov rsi, rdx
shr rsi, 20h
jnz short loc_5017B
add rdx, rcx; evmone::Memory *
cmp rdx, [rbx+10h]
jbe short loc_50157
lea rsi, [rbx+8]; __int64
mov rdi, rax; this
call _ZN6evmone11grow_memoryElRNS_6MemoryEm; evmone::grow_memory(long,evmone::Memory &,ulong)
loc_50157:
test rax, rax
js short loc_5017B
loc_5015C:
mov rcx, [r14-20h]
mov [rbx+88h], rcx
mov ebp, 2
test rcx, rcx
jz short loc_5017B
mov rcx, [r14]
mov [rbx+80h], rcx
loc_5017B:
mov [rbx+220h], rax
mov [rbx+78h], ebp
xor eax, eax
pop rbx
pop r14
pop rbp
retn
| long long evmone::advanced::`anonymous namespace'::op<&evmone::TermResult evmone::advanced::instr::impl<(evmone::Opcode)253,&evmone::TermResult evmone::instr::core::return_impl<(evmc_status_code)2>>>(
long long a1,
long long a2)
{
char *v2; // rax
const __m128i *v3; // r14
__m128i v4; // xmm1
int v5; // ebp
evmone::Memory *v6; // rdx
long long v7; // rcx
v2 = *(char **)(a2 + 544);
v3 = *(const __m128i **)(a2 + 552);
v4 = _mm_or_si128(_mm_loadu_si128(v3 - 1), _mm_loadu_si128(v3 - 2));
if ( _mm_testz_si128(v4, v4) )
goto LABEL_9;
v5 = 3;
if ( !(v3[-2].m128i_i64[1] | v3[-1].m128i_i64[1] | v3[-1].m128i_i64[0])
&& !HIDWORD(v3[-2].m128i_i64[0])
&& !(v3->m128i_i64[1] | v3[1].m128i_i64[1] | v3[1].m128i_i64[0])
&& !HIDWORD(v3->m128i_i64[0]) )
{
v6 = (evmone::Memory *)(v3[-2].m128i_i64[0] + v3->m128i_i64[0]);
if ( (unsigned long long)v6 > *(_QWORD *)(a2 + 16) )
v2 = evmone::grow_memory((evmone *)v2, (evmone::Memory *)(a2 + 8), v6);
if ( (long long)v2 >= 0 )
{
LABEL_9:
v7 = v3[-2].m128i_i64[0];
*(_QWORD *)(a2 + 136) = v7;
v5 = 2;
if ( v7 )
*(_QWORD *)(a2 + 128) = v3->m128i_i64[0];
}
}
*(_QWORD *)(a2 + 544) = v2;
*(_DWORD *)(a2 + 120) = v5;
return 0LL;
}
| op<&(evmone::TermResult_evmone::advanced::instr::impl<(evmone::Opcode)253,&(evmone::TermResult_evmone::instr::core::return_impl<(evmc_status_code)2>(evmone::StackTop,long,evmone::ExecutionState&))>(evmone::advanced::AdvancedExecutionState&))>:
PUSH RBP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV RAX,qword ptr [RSI + 0x220]
MOV R14,qword ptr [RSI + 0x228]
MOVDQU XMM0,xmmword ptr [R14 + -0x20]
MOVDQU XMM1,xmmword ptr [R14 + -0x10]
POR XMM1,XMM0
PTEST XMM1,XMM1
JZ 0x0015015c
MOV RCX,qword ptr [R14 + -0x10]
OR RCX,qword ptr [R14 + -0x8]
MOV EBP,0x3
OR RCX,qword ptr [R14 + -0x18]
JNZ 0x0015017b
MOV RCX,qword ptr [R14 + -0x20]
MOV RDX,RCX
SHR RDX,0x20
JNZ 0x0015017b
MOV RDX,qword ptr [R14 + 0x10]
OR RDX,qword ptr [R14 + 0x18]
OR RDX,qword ptr [R14 + 0x8]
JNZ 0x0015017b
MOV RDX,qword ptr [R14]
MOV RSI,RDX
SHR RSI,0x20
JNZ 0x0015017b
ADD RDX,RCX
CMP RDX,qword ptr [RBX + 0x10]
JBE 0x00150157
LEA RSI,[RBX + 0x8]
MOV RDI,RAX
CALL 0x00141c31
LAB_00150157:
TEST RAX,RAX
JS 0x0015017b
LAB_0015015c:
MOV RCX,qword ptr [R14 + -0x20]
MOV qword ptr [RBX + 0x88],RCX
MOV EBP,0x2
TEST RCX,RCX
JZ 0x0015017b
MOV RCX,qword ptr [R14]
MOV qword ptr [RBX + 0x80],RCX
LAB_0015017b:
MOV qword ptr [RBX + 0x220],RAX
MOV dword ptr [RBX + 0x78],EBP
XOR EAX,EAX
POP RBX
POP R14
POP RBP
RET
|
/* evmone::advanced::Instruction const* evmone::advanced::(anonymous
namespace)::op<&(evmone::TermResult evmone::advanced::instr::impl<(evmone::Opcode)253,
&(evmone::TermResult evmone::instr::core::return_impl<(evmc_status_code)2>(evmone::StackTop,
long,
evmone::ExecutionState&))>(evmone::advanced::AdvancedExecutionState&))>(evmone::advanced::Instruction
const*, evmone::advanced::AdvancedExecutionState&) */
Instruction *
evmone::advanced::(anonymous_namespace)::
op<&(evmone::TermResult_evmone::advanced::instr::impl<(evmone::Opcode)253,&(evmone::TermResult_evmone::instr::core::return_impl<(evmc_status_code)2>(evmone::StackTop,long,evmone::ExecutionState&))>(evmone::advanced::AdvancedExecutionState&))>
(Instruction *param_1,AdvancedExecutionState *param_2)
{
ulong *puVar1;
long lVar2;
ulong uVar3;
int4 uVar4;
lVar2 = *(long *)(param_2 + 0x220);
puVar1 = *(ulong **)(param_2 + 0x228);
if (*(int1 (*) [16])(puVar1 + -2) != (int1 [16])0x0 ||
*(int1 (*) [16])(puVar1 + -4) != (int1 [16])0x0) {
uVar4 = 3;
if (((((puVar1[-2] != 0 || puVar1[-1] != 0) || puVar1[-3] != 0) || (puVar1[-4] >> 0x20 != 0)) ||
((puVar1[2] != 0 || puVar1[3] != 0) || puVar1[1] != 0)) || (*puVar1 >> 0x20 != 0))
goto LAB_0015017b;
uVar3 = *puVar1 + puVar1[-4];
if (*(ulong *)(param_2 + 0x10) < uVar3) {
lVar2 = grow_memory(lVar2,(Memory *)(param_2 + 8),uVar3);
}
if (lVar2 < 0) goto LAB_0015017b;
}
uVar3 = puVar1[-4];
*(ulong *)(param_2 + 0x88) = uVar3;
uVar4 = 2;
if (uVar3 != 0) {
*(ulong *)(param_2 + 0x80) = *puVar1;
}
LAB_0015017b:
*(long *)(param_2 + 0x220) = lVar2;
*(int4 *)(param_2 + 0x78) = uVar4;
return (Instruction *)0x0;
}
| |
38,685 | testing::internal::(anonymous namespace)::PositiveAndNegativeUnitTestFilter::MatchesTest(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | giladroyz[P]FindPeaks/build_O2/_deps/googletest-src/googletest/src/gtest.cc | bool MatchesTest(const std::string& test_suite_name,
const std::string& test_name) const {
return MatchesName(test_suite_name + "." + test_name);
} | O2 | cpp | testing::internal::(anonymous namespace)::PositiveAndNegativeUnitTestFilter::MatchesTest(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x1f82d(%rip), %rdx # 0x346e1
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x24935
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2496d
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x14ab8
testb %al, %al
je 0x14ef4
addq $0x50, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x14ab8
movl %eax, %ebx
xorb $0x1, %bl
jmp 0x14ef6
xorl %ebx, %ebx
movq %rsp, %rdi
callq 0x8ad8
leaq 0x20(%rsp), %rdi
callq 0x8ad8
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x14f24
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8ad8
leaq 0x20(%rsp), %rdi
callq 0x8ad8
movq %rbx, %rdi
callq 0x89a0
| _ZNK7testing8internal12_GLOBAL__N_133PositiveAndNegativeUnitTestFilter11MatchesTestERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESA_:
push r15
push r14
push rbx
sub rsp, 40h
mov r14, rdx
mov rbx, rdi
lea rdx, asc_346E0+1; "."
lea r15, [rsp+58h+var_38]
mov rdi, r15
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EERKS8_PKS5_; std::operator+<char>(std::string const&,char const*)
mov rdi, rsp
mov rsi, r15
mov rdx, r14
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_RKS8_; std::operator+<char>(std::string&&,std::string const&)
mov rsi, rsp
mov rdi, rbx
call _ZNK7testing8internal12_GLOBAL__N_114UnitTestFilter11MatchesNameERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; testing::internal::`anonymous namespace'::UnitTestFilter::MatchesName(std::string const&)
test al, al
jz short loc_14EF4
add rbx, 50h ; 'P'
mov rsi, rsp
mov rdi, rbx
call _ZNK7testing8internal12_GLOBAL__N_114UnitTestFilter11MatchesNameERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; testing::internal::`anonymous namespace'::UnitTestFilter::MatchesName(std::string const&)
mov ebx, eax
xor bl, 1
jmp short loc_14EF6
loc_14EF4:
xor ebx, ebx
loc_14EF6:
mov rdi, rsp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+58h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov eax, ebx
add rsp, 40h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
jmp short loc_14F24
mov rbx, rax
mov rdi, rsp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_14F24:
lea rdi, [rsp+arg_18]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
| long long testing::internal::`anonymous namespace'::PositiveAndNegativeUnitTestFilter::MatchesTest(
long long *a1,
long long a2,
long long a3)
{
unsigned int v4; // eax
unsigned int v5; // ebx
_BYTE v7[32]; // [rsp+0h] [rbp-58h] BYREF
_BYTE v8[56]; // [rsp+20h] [rbp-38h] BYREF
std::operator+<char>(v8, a2, ".");
std::operator+<char>(v7, v8, a3);
if ( testing::internal::`anonymous namespace'::UnitTestFilter::MatchesName(a1, (long long)v7) )
{
LOBYTE(v4) = testing::internal::`anonymous namespace'::UnitTestFilter::MatchesName(a1 + 10, (long long)v7);
v5 = v4;
LOBYTE(v5) = v4 ^ 1;
}
else
{
v5 = 0;
}
std::string::~string(v7);
std::string::~string(v8);
return v5;
}
| MatchesTest:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RDX
MOV RBX,RDI
LEA RDX,[0x1346e1]
LEA R15,[RSP + 0x20]
MOV RDI,R15
CALL 0x00124935
LAB_00114ec1:
MOV RDI,RSP
MOV RSI,R15
MOV RDX,R14
CALL 0x0012496d
LAB_00114ecf:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x00114ab8
TEST AL,AL
JZ 0x00114ef4
ADD RBX,0x50
MOV RSI,RSP
MOV RDI,RBX
CALL 0x00114ab8
LAB_00114eed:
MOV EBX,EAX
XOR BL,0x1
JMP 0x00114ef6
LAB_00114ef4:
XOR EBX,EBX
LAB_00114ef6:
MOV RDI,RSP
CALL 0x00108ad8
LEA RDI,[RSP + 0x20]
CALL 0x00108ad8
MOV EAX,EBX
ADD RSP,0x40
POP RBX
POP R14
POP R15
RET
|
/* testing::internal::(anonymous
namespace)::PositiveAndNegativeUnitTestFilter::MatchesTest(std::__cxx11::string const&,
std::__cxx11::string const&) const */
uint testing::internal::(anonymous_namespace)::PositiveAndNegativeUnitTestFilter::MatchesTest
(string *param_1,string *param_2)
{
char cVar1;
uint uVar2;
string asStack_58 [32];
string local_38 [32];
std::operator+(local_38,(char *)param_2);
/* try { // try from 00114ec1 to 00114ece has its CatchHandler @ 00114f14 */
std::operator+(asStack_58,local_38);
/* try { // try from 00114ecf to 00114eec has its CatchHandler @ 00114f19 */
cVar1 = UnitTestFilter::MatchesName((UnitTestFilter *)param_1,asStack_58);
if (cVar1 == '\0') {
uVar2 = 0;
}
else {
uVar2 = UnitTestFilter::MatchesName((UnitTestFilter *)(param_1 + 0x50),asStack_58);
uVar2 = uVar2 ^ 1;
}
std::__cxx11::string::~string(asStack_58);
std::__cxx11::string::~string(local_38);
return uVar2;
}
| |
38,686 | my_strnxfrm_8bit_bin | eloqsql/strings/ctype-bin.c | static size_t
my_strnxfrm_8bit_bin(CHARSET_INFO *cs,
uchar * dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
set_if_smaller(srclen, dstlen);
set_if_smaller(srclen, nweights);
if (srclen && dst != src)
memcpy(dst, src, srclen);
return my_strxfrm_pad_desc_and_reverse(cs, dst, dst + srclen, dst + dstlen,
(uint)(nweights - srclen), flags, 0);
} | O0 | c | my_strnxfrm_8bit_bin:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0xeb0d4
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xeb0d6
jmp 0xeb0d8
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpq %rcx, %rax
jbe 0xeb0eb
movl -0x1c(%rbp), %eax
movq %rax, -0x30(%rbp)
jmp 0xeb0ed
cmpq $0x0, -0x30(%rbp)
je 0xeb10f
movq -0x10(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0xeb10f
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x3a0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %eax
subq -0x30(%rbp), %rax
movl %eax, %r8d
movl 0x10(%rbp), %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0xf6e50
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
| my_strnxfrm_8bit_bin:
push rbp
mov rbp, rsp
sub rsp, 40h
mov eax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_30]
cmp rax, [rbp+var_18]
jbe short loc_EB0D4
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
loc_EB0D4:
jmp short $+2
loc_EB0D6:
jmp short $+2
loc_EB0D8:
mov rax, [rbp+var_30]
mov ecx, [rbp+var_1C]
cmp rax, rcx
jbe short loc_EB0EB
mov eax, [rbp+var_1C]
mov [rbp+var_30], rax
loc_EB0EB:
jmp short $+2
loc_EB0ED:
cmp [rbp+var_30], 0
jz short loc_EB10F
mov rax, [rbp+var_10]
cmp rax, [rbp+var_28]
jz short loc_EB10F
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_30]
call _memcpy
loc_EB10F:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_10]
add rdx, [rbp+var_30]
mov rcx, [rbp+var_10]
add rcx, [rbp+var_18]
mov eax, [rbp+var_1C]
sub rax, [rbp+var_30]
mov r8d, eax
mov r9d, [rbp+arg_0]
xor eax, eax
mov [rsp+40h+var_40], 0
call my_strxfrm_pad_desc_and_reverse
add rsp, 40h
pop rbp
retn
| long long my_strnxfrm_8bit_bin(
int a1,
long long a2,
unsigned long long a3,
unsigned int a4,
long long a5,
unsigned long long a6,
int a7)
{
unsigned long long v8; // [rsp+10h] [rbp-30h]
int v10; // [rsp+28h] [rbp-18h]
v10 = a3;
v8 = a6;
if ( a6 > a3 )
v8 = a3;
if ( v8 > a4 )
v8 = a4;
if ( v8 && a2 != a5 )
memcpy(a2, a5, v8);
return my_strxfrm_pad_desc_and_reverse(a1, a2, (int)v8 + (int)a2, v10 + (int)a2, a4 - (unsigned int)v8, a7, 0);
}
| my_strnxfrm_8bit_bin:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x18]
JBE 0x001eb0d4
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
LAB_001eb0d4:
JMP 0x001eb0d6
LAB_001eb0d6:
JMP 0x001eb0d8
LAB_001eb0d8:
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RBP + -0x1c]
CMP RAX,RCX
JBE 0x001eb0eb
MOV EAX,dword ptr [RBP + -0x1c]
MOV qword ptr [RBP + -0x30],RAX
LAB_001eb0eb:
JMP 0x001eb0ed
LAB_001eb0ed:
CMP qword ptr [RBP + -0x30],0x0
JZ 0x001eb10f
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x28]
JZ 0x001eb10f
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x0013a0b0
LAB_001eb10f:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x1c]
SUB RAX,qword ptr [RBP + -0x30]
MOV R8D,EAX
MOV R9D,dword ptr [RBP + 0x10]
XOR EAX,EAX
MOV dword ptr [RSP],0x0
CALL 0x001f6e50
ADD RSP,0x40
POP RBP
RET
|
void my_strnxfrm_8bit_bin
(int8 param_1,void *param_2,ulong param_3,uint param_4,void *param_5,
ulong param_6,int4 param_7)
{
int8 local_38;
local_38 = param_6;
if (param_3 < param_6) {
local_38 = param_3;
}
if (param_4 < local_38) {
local_38 = (ulong)param_4;
}
if ((local_38 != 0) && (param_2 != param_5)) {
memcpy(param_2,param_5,local_38);
}
my_strxfrm_pad_desc_and_reverse
(param_1,param_2,(long)param_2 + local_38,(long)param_2 + param_3,
param_4 - (int)local_38,param_7,0);
return;
}
| |
38,687 | mysql_select_db_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_select_db_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_select_db,
(parms->mysql, parms->db),
parms->mysql,
int,
r_int)
} | O0 | c | mysql_select_db_start_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1dbb0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| mysql_select_db_start_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rax, [rbp+var_10]
mov rsi, [rax+8]
call mysql_select_db
mov [rbp+var_14], eax
mov ecx, [rbp+var_14]
mov rax, [rbp+var_20]
mov [rax+8], ecx
mov rax, [rbp+var_20]
mov dword ptr [rax], 0
add rsp, 20h
pop rbp
retn
| _DWORD * mysql_select_db_start_internal(long long *a1)
{
_DWORD *result; // rax
_DWORD *v2; // [rsp+0h] [rbp-20h]
v2 = *(_DWORD **)(*(_QWORD *)(*a1 + 1152) + 40LL);
v2[2] = mysql_select_db(*a1, a1[1]);
result = v2;
*v2 = 0;
return result;
}
| mysql_select_db_start_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x0011dbb0
MOV dword ptr [RBP + -0x14],EAX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x8],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
ADD RSP,0x20
POP RBP
RET
|
void mysql_select_db_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_select_db(*param_1,param_1[1]);
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
| |
38,688 | list_walk | eloqsql/libmariadb/libmariadb/ma_list.c | int list_walk(LIST *list, list_walk_action action, gptr argument)
{
int error=0;
while (list)
{
if ((error = (*action)(list->data,argument)))
return error;
list= list_rest(list);
}
return 0;
} | O0 | c | list_walk:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x27c42
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x27c34
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x27c49
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x27c0b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| list_walk:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], 0
loc_27C0B:
cmp [rbp+var_10], 0
jz short loc_27C42
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
mov rdi, [rcx+10h]
mov rsi, [rbp+var_20]
call rax
mov [rbp+var_24], eax
cmp eax, 0
jz short loc_27C34
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
jmp short loc_27C49
loc_27C34:
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_10], rax
jmp short loc_27C0B
loc_27C42:
mov [rbp+var_4], 0
loc_27C49:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long list_walk(long long a1, long long ( *a2)(_QWORD, long long), long long a3)
{
unsigned int v4; // [rsp+Ch] [rbp-24h]
while ( a1 )
{
v4 = a2(*(_QWORD *)(a1 + 16), a3);
if ( v4 )
return v4;
a1 = *(_QWORD *)(a1 + 8);
}
return 0;
}
| list_walk:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],0x0
LAB_00127c0b:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00127c42
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RCX + 0x10]
MOV RSI,qword ptr [RBP + -0x20]
CALL RAX
MOV dword ptr [RBP + -0x24],EAX
CMP EAX,0x0
JZ 0x00127c34
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00127c49
LAB_00127c34:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00127c0b
LAB_00127c42:
MOV dword ptr [RBP + -0x4],0x0
LAB_00127c49:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int list_walk(long param_1,code *param_2,int8 param_3)
{
int iVar1;
long local_18;
local_18 = param_1;
while( true ) {
if (local_18 == 0) {
return 0;
}
iVar1 = (*param_2)(*(int8 *)(local_18 + 0x10),param_3);
if (iVar1 != 0) break;
local_18 = *(long *)(local_18 + 8);
}
return iVar1;
}
| |
38,689 | list_walk | eloqsql/libmariadb/libmariadb/ma_list.c | int list_walk(LIST *list, list_walk_action action, gptr argument)
{
int error=0;
while (list)
{
if ((error = (*action)(list->data,argument)))
return error;
list= list_rest(list);
}
return 0;
} | O3 | c | list_walk:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x1fb52
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x10(%r12), %rdi
movq %r14, %rsi
callq *%r15
testl %eax, %eax
jne 0x1fb50
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x1fb35
jmp 0x1fb52
movl %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
| list_walk:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
xor ebx, ebx
test rdi, rdi
jz short loc_1FB52
mov r14, rdx
mov r15, rsi
mov r12, rdi
loc_1FB35:
mov rdi, [r12+10h]
mov rsi, r14
call r15
test eax, eax
jnz short loc_1FB50
mov r12, [r12+8]
test r12, r12
jnz short loc_1FB35
jmp short loc_1FB52
loc_1FB50:
mov ebx, eax
loc_1FB52:
mov eax, ebx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long list_walk(long long a1, long long ( *a2)(_QWORD, long long), long long a3)
{
unsigned int v3; // ebx
long long v5; // r12
unsigned int v6; // eax
v3 = 0;
if ( a1 )
{
v5 = a1;
while ( 1 )
{
v6 = a2(*(_QWORD *)(v5 + 16), a3);
if ( v6 )
break;
v5 = *(_QWORD *)(v5 + 8);
if ( !v5 )
return v3;
}
return v6;
}
return v3;
}
| list_walk:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
XOR EBX,EBX
TEST RDI,RDI
JZ 0x0011fb52
MOV R14,RDX
MOV R15,RSI
MOV R12,RDI
LAB_0011fb35:
MOV RDI,qword ptr [R12 + 0x10]
MOV RSI,R14
CALL R15
TEST EAX,EAX
JNZ 0x0011fb50
MOV R12,qword ptr [R12 + 0x8]
TEST R12,R12
JNZ 0x0011fb35
JMP 0x0011fb52
LAB_0011fb50:
MOV EBX,EAX
LAB_0011fb52:
MOV EAX,EBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int list_walk(long param_1,code *param_2,int8 param_3)
{
int iVar1;
if (param_1 != 0) {
do {
iVar1 = (*param_2)(*(int8 *)(param_1 + 0x10),param_3);
if (iVar1 != 0) {
return iVar1;
}
param_1 = *(long *)(param_1 + 8);
} while (param_1 != 0);
}
return 0;
}
| |
38,690 | blst_p1_compress | corpus-core[P]colibri-stateless/build_O3/_deps/blst-src/src/e1.c | void blst_p1_compress(unsigned char out[48], const POINTonE1 *in)
{
if (vec_is_zero(in->Z, sizeof(in->Z))) {
bytes_zero(out, 48);
out[0] = 0xc0; /* compressed and infinity bits */
} else {
limb_t sign = POINTonE1_Compress_BE(out, in);
out[0] |= (unsigned char)(0x80 | ((sign & 2) << 4));
}
} | O3 | c | blst_p1_compress:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x60(%rsi), %r15
movl $0x30, %esi
movq %r15, %rdi
callq 0x6e900
testq %rax, %rax
je 0x5799b
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x11(%rbx)
movups %xmm0, 0x1(%rbx)
movb $-0x40, %al
jmp 0x579dd
leaq 0x32fa6(%rip), %rsi # 0x8a948
movl $0x30, %edx
movq %r15, %rdi
callq 0x6e940
testq %rax, %rax
jne 0x579c9
leaq -0xa8(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x573d6
movq %r15, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x578dd
shlb $0x4, %al
andb $0x20, %al
orb (%rbx), %al
orb $-0x80, %al
movb %al, (%rbx)
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| blst_p1_compress:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 98h
mov r14, rsi
mov rbx, rdi
lea r15, [rsi+60h]
mov esi, 30h ; '0'
mov rdi, r15
call vec_is_zero_16x
test rax, rax
jz short loc_5799B
xorps xmm0, xmm0
movups xmmword ptr [rbx+20h], xmm0
movups xmmword ptr [rbx+11h], xmm0
movups xmmword ptr [rbx+1], xmm0
mov al, 0C0h
jmp short loc_579DD
loc_5799B:
lea rsi, BLS12_381_Rx
mov edx, 30h ; '0'
mov rdi, r15
call vec_is_equal_16x
test rax, rax
jnz short loc_579C9
lea r15, [rbp+var_A8]
mov rdi, r15
mov rsi, r14
call POINTonE1_from_Jacobian
mov r14, r15
loc_579C9:
mov rdi, rbx
mov rsi, r14
call POINTonE1_affine_Compress_BE
shl al, 4
and al, 20h
or al, [rbx]
or al, 80h
loc_579DD:
mov [rbx], al
add rsp, 98h
pop rbx
pop r14
pop r15
pop rbp
retn
| char blst_p1_compress(long long a1, long long a2)
{
_BYTE *v2; // r14
char result; // al
_BYTE v4[168]; // [rsp+8h] [rbp-A8h] BYREF
v2 = (_BYTE *)a2;
if ( vec_is_zero_16x(a2 + 96, 48LL) )
{
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 17) = 0LL;
*(_OWORD *)(a1 + 1) = 0LL;
result = -64;
}
else
{
if ( !vec_is_equal_16x(a2 + 96, &BLS12_381_Rx, 48LL) )
{
POINTonE1_from_Jacobian((long long)v4, a2);
v2 = v4;
}
result = *(_BYTE *)a1 | (16 * POINTonE1_affine_Compress_BE((_BYTE *)a1, (long long)v2)) & 0x20 | 0x80;
}
*(_BYTE *)a1 = result;
return result;
}
| blst_p1_compress:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x98
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSI + 0x60]
MOV ESI,0x30
MOV RDI,R15
CALL 0x0016e900
TEST RAX,RAX
JZ 0x0015799b
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOVUPS xmmword ptr [RBX + 0x11],XMM0
MOVUPS xmmword ptr [RBX + 0x1],XMM0
MOV AL,0xc0
JMP 0x001579dd
LAB_0015799b:
LEA RSI,[0x18a948]
MOV EDX,0x30
MOV RDI,R15
CALL 0x0016e940
TEST RAX,RAX
JNZ 0x001579c9
LEA R15,[RBP + -0xa8]
MOV RDI,R15
MOV RSI,R14
CALL 0x001573d6
MOV R14,R15
LAB_001579c9:
MOV RDI,RBX
MOV RSI,R14
CALL 0x001578dd
SHL AL,0x4
AND AL,0x20
OR AL,byte ptr [RBX]
OR AL,0x80
LAB_001579dd:
MOV byte ptr [RBX],AL
ADD RSP,0x98
POP RBX
POP R14
POP R15
POP RBP
RET
|
void blst_p1_compress(byte *param_1,int1 *param_2)
{
long lVar1;
byte bVar2;
int1 *puVar3;
int1 local_b0 [144];
lVar1 = vec_is_zero_16x(param_2 + 0x60,0x30);
if (lVar1 == 0) {
lVar1 = vec_is_equal_16x(param_2 + 0x60,&BLS12_381_Rx,0x30);
puVar3 = param_2;
if (lVar1 == 0) {
puVar3 = local_b0;
POINTonE1_from_Jacobian(puVar3,param_2);
}
bVar2 = POINTonE1_affine_Compress_BE(param_1,puVar3);
bVar2 = (bVar2 & 2) << 4 | *param_1 | 0x80;
}
else {
param_1[0x20] = 0;
param_1[0x21] = 0;
param_1[0x22] = 0;
param_1[0x23] = 0;
param_1[0x24] = 0;
param_1[0x25] = 0;
param_1[0x26] = 0;
param_1[0x27] = 0;
param_1[0x28] = 0;
param_1[0x29] = 0;
param_1[0x2a] = 0;
param_1[0x2b] = 0;
param_1[0x2c] = 0;
param_1[0x2d] = 0;
param_1[0x2e] = 0;
param_1[0x2f] = 0;
param_1[0x11] = 0;
param_1[0x12] = 0;
param_1[0x13] = 0;
param_1[0x14] = 0;
param_1[0x15] = 0;
param_1[0x16] = 0;
param_1[0x17] = 0;
param_1[0x18] = 0;
param_1[0x19] = 0;
param_1[0x1a] = 0;
param_1[0x1b] = 0;
param_1[0x1c] = 0;
param_1[0x1d] = 0;
param_1[0x1e] = 0;
param_1[0x1f] = 0;
param_1[0x20] = 0;
param_1[1] = 0;
param_1[2] = 0;
param_1[3] = 0;
param_1[4] = 0;
param_1[5] = 0;
param_1[6] = 0;
param_1[7] = 0;
param_1[8] = 0;
param_1[9] = 0;
param_1[10] = 0;
param_1[0xb] = 0;
param_1[0xc] = 0;
param_1[0xd] = 0;
param_1[0xe] = 0;
param_1[0xf] = 0;
param_1[0x10] = 0;
bVar2 = 0xc0;
}
*param_1 = bVar2;
return;
}
| |
38,691 | mysql_client_plugin_init | eloqsql/build_O3/libmariadb/libmariadb/ma_client_plugin.c | int mysql_client_plugin_init()
{
MYSQL mysql;
struct st_mysql_client_plugin **builtin;
va_list unused;
LINT_INIT_STRUCT(unused);
if (initialized)
return 0;
memset(&mysql, 0, sizeof(mysql)); /* dummy mysql for set_mysql_extended_error */
pthread_mutex_init(&LOCK_load_client_plugin, NULL);
ma_init_alloc_root(&mem_root, 128, 128);
memset(&plugin_list, 0, sizeof(plugin_list));
initialized= 1;
pthread_mutex_lock(&LOCK_load_client_plugin);
for (builtin= mysql_client_builtins; *builtin; builtin++)
add_plugin(&mysql, *builtin, 0, 0, unused);
pthread_mutex_unlock(&LOCK_load_client_plugin);
load_env_plugins(&mysql);
return 0;
} | O3 | c | mysql_client_plugin_init:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x520, %rsp # imm = 0x520
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x540(%rbp)
movq $0x0, -0x530(%rbp)
cmpb $0x0, 0x23bd5(%rip) # 0x4d9d0
jne 0x29f66
leaq -0x520(%rbp), %rdi
movl $0x4f8, %edx # imm = 0x4F8
xorl %esi, %esi
callq 0x13260
leaq 0x23bbd(%rip), %rbx # 0x4d9d8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x136b0
leaq 0x23bd4(%rip), %rdi # 0x4da00
movl $0x80, %esi
movl $0x80, %edx
callq 0x20800
leaq 0x23bfe(%rip), %rax # 0x4da40
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movb $0x1, 0x23b75(%rip) # 0x4d9d0
movq %rbx, %rdi
callq 0x136a0
leaq 0x21b36(%rip), %r15 # 0x4b9a0
movq (%r15), %rsi
testq %rsi, %rsi
je 0x29e9f
addq $0x8, %r15
leaq -0x520(%rbp), %rbx
leaq -0x540(%rbp), %r14
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r8
callq 0x29f8c
movq (%r15), %rsi
addq $0x8, %r15
testq %rsi, %rsi
jne 0x29e84
leaq 0x23b32(%rip), %rdi # 0x4d9d8
callq 0x13330
leaq 0xfb40(%rip), %rdi # 0x399f2
callq 0x13590
testq %rax, %rax
je 0x29f66
xorl %ecx, %ecx
cmpb $0x0, (%rax,%rcx)
je 0x29ed9
incq %rcx
cmpq $0x400, %rcx # imm = 0x400
jne 0x29ec2
jmp 0x29f66
cmpq $0x3ff, %rcx # imm = 0x3FF
ja 0x29f66
movq %rax, %rdi
callq 0x137d0
movq %rax, %rbx
movq %rax, %rdi
movl $0x3b, %esi
callq 0x13180
movq %rbx, %r15
testq %rax, %rax
je 0x29f46
movq %rax, %r14
leaq -0x520(%rbp), %r12
movq %rbx, %r15
movb $0x0, (%r14)
movq %r12, %rdi
movq %r15, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x2a531
movq %r14, %r15
incq %r15
movq %r15, %rdi
movl $0x3b, %esi
callq 0x13180
movq %rax, %r14
testq %rax, %rax
jne 0x29f13
leaq -0x520(%rbp), %rdi
movq %r15, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x2a531
movq %rbx, %rdi
callq 0x13570
movq %fs:0x28, %rax
cmpq -0x28(%rbp), %rax
jne 0x29f87
xorl %eax, %eax
addq $0x520, %rsp # imm = 0x520
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x13500
| mysql_client_plugin_init:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 520h
mov rax, fs:28h
mov [rbp+var_28], rax
xorps xmm0, xmm0
movaps [rbp+var_540], xmm0
mov [rbp+var_530], 0
cmp cs:initialized, 0
jnz loc_29F66
lea rdi, [rbp+var_520]
mov edx, 4F8h
xor esi, esi
call _memset
lea rbx, LOCK_load_client_plugin
mov rdi, rbx
xor esi, esi
call _pthread_mutex_init
lea rdi, mem_root
mov esi, 80h
mov edx, 80h
call ma_init_alloc_root
lea rax, plugin_list
xorps xmm0, xmm0
movaps xmmword ptr [rax+30h], xmm0
movaps xmmword ptr [rax+20h], xmm0
movaps xmmword ptr [rax+10h], xmm0
movaps xmmword ptr [rax], xmm0
mov cs:initialized, 1
mov rdi, rbx
call _pthread_mutex_lock
lea r15, mysql_client_builtins
mov rsi, [r15]
test rsi, rsi
jz short loc_29E9F
add r15, 8
lea rbx, [rbp+var_520]
lea r14, [rbp+var_540]
loc_29E84:
mov rdi, rbx
xor edx, edx
xor ecx, ecx
mov r8, r14
call add_plugin
mov rsi, [r15]
add r15, 8
test rsi, rsi
jnz short loc_29E84
loc_29E9F:
lea rdi, LOCK_load_client_plugin
call _pthread_mutex_unlock
lea rdi, aLibmysqlPlugin; "LIBMYSQL_PLUGINS"
call _getenv
test rax, rax
jz loc_29F66
xor ecx, ecx
loc_29EC2:
cmp byte ptr [rax+rcx], 0
jz short loc_29ED9
inc rcx
cmp rcx, 400h
jnz short loc_29EC2
jmp loc_29F66
loc_29ED9:
cmp rcx, 3FFh
ja loc_29F66
mov rdi, rax
call _strdup
mov rbx, rax
mov rdi, rax
mov esi, 3Bh ; ';'
call _strchr
mov r15, rbx
test rax, rax
jz short loc_29F46
mov r14, rax
lea r12, [rbp+var_520]
mov r15, rbx
loc_29F13:
mov byte ptr [r14], 0
mov rdi, r12
mov rsi, r15
mov edx, 0FFFFFFFFh
xor ecx, ecx
xor eax, eax
call mysql_load_plugin
mov r15, r14
inc r15
mov rdi, r15
mov esi, 3Bh ; ';'
call _strchr
mov r14, rax
test rax, rax
jnz short loc_29F13
loc_29F46:
lea rdi, [rbp+var_520]
mov rsi, r15
mov edx, 0FFFFFFFFh
xor ecx, ecx
xor eax, eax
call mysql_load_plugin
mov rdi, rbx
call _free
loc_29F66:
mov rax, fs:28h
cmp rax, [rbp+var_28]
jnz short loc_29F87
xor eax, eax
add rsp, 520h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_29F87:
call ___stack_chk_fail
| long long mysql_client_plugin_init()
{
void *v0; // rsi
void **v1; // r15
long long v2; // rax
unsigned long long v3; // rcx
long long v4; // rbx
long long v5; // rax
int v6; // r8d
int v7; // r9d
int v8; // r15d
_BYTE *v9; // r14
__int128 v11; // [rsp+0h] [rbp-540h] BYREF
long long v12; // [rsp+10h] [rbp-530h]
_BYTE v13[1272]; // [rsp+20h] [rbp-520h] BYREF
unsigned long long v14; // [rsp+518h] [rbp-28h]
v14 = __readfsqword(0x28u);
v11 = 0LL;
v12 = 0LL;
if ( !initialized )
{
memset(v13, 0LL, sizeof(v13));
pthread_mutex_init(&LOCK_load_client_plugin, 0LL);
ma_init_alloc_root((long long)&mem_root, 128LL, 128LL);
plugin_list[3] = 0LL;
plugin_list[2] = 0LL;
plugin_list[1] = 0LL;
plugin_list[0] = 0LL;
initialized = 1;
pthread_mutex_lock(&LOCK_load_client_plugin);
v0 = mysql_client_builtins;
if ( mysql_client_builtins )
{
v1 = (void **)(&mysql_client_builtins + 1);
do
{
((void ( *)(_BYTE *, void *, _QWORD, _QWORD, __int128 *))add_plugin)(v13, v0, 0LL, 0LL, &v11);
v0 = *v1++;
}
while ( v0 );
}
pthread_mutex_unlock(&LOCK_load_client_plugin);
v2 = getenv("LIBMYSQL_PLUGINS");
if ( v2 )
{
v3 = 0LL;
while ( *(_BYTE *)(v2 + v3) )
{
if ( ++v3 == 1024 )
return 0LL;
}
if ( v3 <= 0x3FF )
{
v4 = strdup(v2);
v5 = strchr(v4, 59LL);
v8 = v4;
if ( v5 )
{
v9 = (_BYTE *)v5;
v8 = v4;
do
{
*v9 = 0;
mysql_load_plugin((unsigned int)v13, v8, -1, 0, v6, v7, v11);
v8 = (_DWORD)v9 + 1;
v9 = (_BYTE *)strchr(v9 + 1, 59LL);
}
while ( v9 );
}
mysql_load_plugin((unsigned int)v13, v8, -1, 0, v6, v7, v11);
free(v4);
}
}
}
return 0LL;
}
| mysql_client_plugin_init:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x520
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x540],XMM0
MOV qword ptr [RBP + -0x530],0x0
CMP byte ptr [0x0014d9d0],0x0
JNZ 0x00129f66
LEA RDI,[RBP + -0x520]
MOV EDX,0x4f8
XOR ESI,ESI
CALL 0x00113260
LEA RBX,[0x14d9d8]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x001136b0
LEA RDI,[0x14da00]
MOV ESI,0x80
MOV EDX,0x80
CALL 0x00120800
LEA RAX,[0x14da40]
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RAX + 0x30],XMM0
MOVAPS xmmword ptr [RAX + 0x20],XMM0
MOVAPS xmmword ptr [RAX + 0x10],XMM0
MOVAPS xmmword ptr [RAX],XMM0
MOV byte ptr [0x0014d9d0],0x1
MOV RDI,RBX
CALL 0x001136a0
LEA R15,[0x14b9a0]
MOV RSI,qword ptr [R15]
TEST RSI,RSI
JZ 0x00129e9f
ADD R15,0x8
LEA RBX,[RBP + -0x520]
LEA R14,[RBP + -0x540]
LAB_00129e84:
MOV RDI,RBX
XOR EDX,EDX
XOR ECX,ECX
MOV R8,R14
CALL 0x00129f8c
MOV RSI,qword ptr [R15]
ADD R15,0x8
TEST RSI,RSI
JNZ 0x00129e84
LAB_00129e9f:
LEA RDI,[0x14d9d8]
CALL 0x00113330
LEA RDI,[0x1399f2]
CALL 0x00113590
TEST RAX,RAX
JZ 0x00129f66
XOR ECX,ECX
LAB_00129ec2:
CMP byte ptr [RAX + RCX*0x1],0x0
JZ 0x00129ed9
INC RCX
CMP RCX,0x400
JNZ 0x00129ec2
JMP 0x00129f66
LAB_00129ed9:
CMP RCX,0x3ff
JA 0x00129f66
MOV RDI,RAX
CALL 0x001137d0
MOV RBX,RAX
MOV RDI,RAX
MOV ESI,0x3b
CALL 0x00113180
MOV R15,RBX
TEST RAX,RAX
JZ 0x00129f46
MOV R14,RAX
LEA R12,[RBP + -0x520]
MOV R15,RBX
LAB_00129f13:
MOV byte ptr [R14],0x0
MOV RDI,R12
MOV RSI,R15
MOV EDX,0xffffffff
XOR ECX,ECX
XOR EAX,EAX
CALL 0x0012a531
MOV R15,R14
INC R15
MOV RDI,R15
MOV ESI,0x3b
CALL 0x00113180
MOV R14,RAX
TEST RAX,RAX
JNZ 0x00129f13
LAB_00129f46:
LEA RDI,[RBP + -0x520]
MOV RSI,R15
MOV EDX,0xffffffff
XOR ECX,ECX
XOR EAX,EAX
CALL 0x0012a531
MOV RDI,RBX
CALL 0x00113570
LAB_00129f66:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x28]
JNZ 0x00129f87
XOR EAX,EAX
ADD RSP,0x520
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00129f87:
CALL 0x00113500
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 mysql_client_plugin_init(void)
{
char *pcVar1;
char *__s;
char *pcVar2;
ulong uVar3;
int *puVar4;
int **ppuVar5;
long in_FS_OFFSET;
int8 local_548;
int8 uStack_540;
int8 local_538;
int1 local_528 [1272];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
local_548 = 0;
uStack_540 = 0;
local_538 = 0;
if (initialized == '\0') {
memset(local_528,0,0x4f8);
pthread_mutex_init((pthread_mutex_t *)LOCK_load_client_plugin,(pthread_mutexattr_t *)0x0);
ma_init_alloc_root(mem_root,0x80,0x80);
_DAT_0014da70 = 0;
uRam000000000014da78 = 0;
_DAT_0014da60 = 0;
uRam000000000014da68 = 0;
_DAT_0014da50 = 0;
uRam000000000014da58 = 0;
plugin_list = 0;
DAT_0014da48 = 0;
initialized = '\x01';
pthread_mutex_lock((pthread_mutex_t *)LOCK_load_client_plugin);
if (mysql_client_builtins != (int *)0x0) {
ppuVar5 = &PTR_mysql_old_password_client_plugin_0014b9a8;
puVar4 = mysql_client_builtins;
do {
add_plugin(local_528,puVar4,0,0,&local_548);
puVar4 = *ppuVar5;
ppuVar5 = ppuVar5 + 1;
} while (puVar4 != (int *)0x0);
}
pthread_mutex_unlock((pthread_mutex_t *)LOCK_load_client_plugin);
pcVar1 = getenv("LIBMYSQL_PLUGINS");
if (pcVar1 != (char *)0x0) {
uVar3 = 0;
do {
if (pcVar1[uVar3] == '\0') {
if (uVar3 < 0x400) {
__s = strdup(pcVar1);
pcVar2 = strchr(__s,0x3b);
pcVar1 = __s;
if (pcVar2 != (char *)0x0) {
do {
*pcVar2 = '\0';
mysql_load_plugin(local_528,pcVar1,0xffffffff,0);
pcVar1 = pcVar2 + 1;
pcVar2 = strchr(pcVar1,0x3b);
} while (pcVar2 != (char *)0x0);
}
mysql_load_plugin(local_528,pcVar1,0xffffffff,0);
free(__s);
}
break;
}
uVar3 = uVar3 + 1;
} while (uVar3 != 0x400);
}
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_30) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return 0;
}
| |
38,692 | my_convert | eloqsql/strings/ctype.c | uint32
my_convert(char *to, uint32 to_length, CHARSET_INFO *to_cs,
const char *from, uint32 from_length,
CHARSET_INFO *from_cs, uint *errors)
{
uint32 length, length2;
/*
If any of the character sets is not ASCII compatible,
immediately switch to slow mb_wc->wc_mb method.
*/
if ((to_cs->state | from_cs->state) & MY_CS_NONASCII)
return my_convert_using_func(to, to_length,
to_cs, to_cs->cset->wc_mb,
from, from_length,
from_cs, from_cs->cset->mb_wc,
errors);
length= length2= MY_MIN(to_length, from_length);
#if defined(__i386__) || defined(__x86_64__)
/*
Special loop for i386, it allows to refer to a
non-aligned memory block as UINT32, which makes
it possible to copy four bytes at once. This
gives about 10% performance improvement comparing
to byte-by-byte loop.
*/
for ( ; length >= 4; length-= 4, from+= 4, to+= 4)
{
if ((*(uint32*)from) & 0x80808080)
break;
*((uint32*) to)= *((const uint32*) from);
}
#endif /* __i386__ */
for (; ; *to++= *from++, length--)
{
if (!length)
{
*errors= 0;
return length2;
}
if (*((unsigned char*) from) > 0x7F) /* A non-ASCII character */
{
uint32 copied_length= length2 - length;
to_length-= copied_length;
from_length-= copied_length;
return copied_length + my_convert_using_func(to, to_length, to_cs,
to_cs->cset->wc_mb,
from, from_length, from_cs,
from_cs->cset->mb_wc,
errors);
}
}
DBUG_ASSERT(FALSE); // Should never get to here
return 0; // Make compiler happy
} | O3 | c | my_convert:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %rax
movl %r8d, %r9d
movq %rcx, %r8
movq 0x10(%rbp), %r10
movl 0xc(%rax), %ecx
orl 0xc(%rdx), %ecx
btl $0xd, %ecx
jb 0x5a0cc
cmpl %r9d, %esi
movl %r9d, %ebx
cmovbl %esi, %ebx
movl %ebx, %ecx
cmpl $0x4, %ebx
jb 0x5a0a5
movl (%r8), %r11d
testl $0x80808080, %r11d # imm = 0x80808080
jne 0x5a0a9
movl %r11d, (%rdi)
addl $-0x4, %ecx
addq $0x4, %r8
addq $0x4, %rdi
cmpl $0x3, %ecx
ja 0x5a086
testl %ecx, %ecx
je 0x5a0c3
movl %ecx, %r14d
xorl %r15d, %r15d
movb (%r8,%r15), %cl
testb %cl, %cl
js 0x5a0f9
movb %cl, (%rdi,%r15)
incq %r15
cmpl %r15d, %r14d
jne 0x5a0af
movl $0x0, (%r10)
jmp 0x5a13e
movl %esi, %esi
movq 0xb8(%rdx), %rcx
movq 0x30(%rcx), %rcx
movl %r9d, %r9d
movq 0xb8(%rax), %r11
subq $0x8, %rsp
pushq %r10
pushq 0x28(%r11)
pushq %rax
callq 0x59f5b
addq $0x28, %rsp
jmp 0x5a144
addl %r14d, %esi
subl %ebx, %esi
subl %r15d, %esi
addl %r14d, %r9d
subl %ebx, %r9d
subl %r15d, %r9d
movq 0xb8(%rdx), %rcx
movq 0x30(%rcx), %rcx
movq 0xb8(%rax), %r11
addq %r15, %rdi
addq %r15, %r8
subq $0x8, %rsp
pushq %r10
pushq 0x28(%r11)
pushq %rax
callq 0x59f5b
addq $0x20, %rsp
subl %r14d, %ebx
addl %r15d, %ebx
addl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| my_convert:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rax, r9
mov r9d, r8d
mov r8, rcx
mov r10, [rbp+arg_0]
mov ecx, [rax+0Ch]
or ecx, [rdx+0Ch]
bt ecx, 0Dh
jb short loc_5A0CC
cmp esi, r9d
mov ebx, r9d
cmovb ebx, esi
mov ecx, ebx
cmp ebx, 4
jb short loc_5A0A5
loc_5A086:
mov r11d, [r8]
test r11d, 80808080h
jnz short loc_5A0A9
mov [rdi], r11d
add ecx, 0FFFFFFFCh
add r8, 4
add rdi, 4
cmp ecx, 3
ja short loc_5A086
loc_5A0A5:
test ecx, ecx
jz short loc_5A0C3
loc_5A0A9:
mov r14d, ecx
xor r15d, r15d
loc_5A0AF:
mov cl, [r8+r15]
test cl, cl
js short loc_5A0F9
mov [rdi+r15], cl
inc r15
cmp r14d, r15d
jnz short loc_5A0AF
loc_5A0C3:
mov dword ptr [r10], 0
jmp short loc_5A13E
loc_5A0CC:
mov esi, esi
mov rcx, [rdx+0B8h]
mov rcx, [rcx+30h]
mov r9d, r9d
mov r11, [rax+0B8h]
sub rsp, 8
push r10
push qword ptr [r11+28h]
push rax
call my_convert_using_func
add rsp, 28h
jmp short loc_5A144
loc_5A0F9:
add esi, r14d
sub esi, ebx
sub esi, r15d
add r9d, r14d
sub r9d, ebx
sub r9d, r15d
mov rcx, [rdx+0B8h]
mov rcx, [rcx+30h]
mov r11, [rax+0B8h]
add rdi, r15
add r8, r15
sub rsp, 8
push r10
push qword ptr [r11+28h]
push rax
call my_convert_using_func
add rsp, 20h
sub ebx, r14d
add ebx, r15d
add ebx, eax
loc_5A13E:
mov eax, ebx
add rsp, 8
loc_5A144:
pop rbx
pop r14
pop r15
pop rbp
retn
| long long my_convert(
_DWORD *a1,
unsigned int a2,
long long a3,
long long a4,
unsigned int a5,
long long a6,
_DWORD *a7)
{
_DWORD *v9; // r8
unsigned int v10; // ebx
unsigned int v11; // ecx
unsigned int v12; // r14d
long long v13; // r15
char v14; // cl
v9 = (_DWORD *)a4;
if ( ((*(_DWORD *)(a3 + 12) | *(_DWORD *)(a6 + 12)) & 0x2000) != 0 )
return my_convert_using_func(
(long long)a1,
a2,
a3,
*(long long ( **)(long long, long long, long long, long long))(*(_QWORD *)(a3 + 184) + 48LL),
a4,
a5,
a6,
*(long long ( **)(long long, long long *, long long, unsigned long long))(*(_QWORD *)(a6 + 184) + 40LL),
a7);
v10 = a5;
if ( a2 < a5 )
v10 = a2;
v11 = v10;
if ( v10 >= 4 )
{
while ( (*v9 & 0x80808080) == 0 )
{
*a1 = *v9;
v11 -= 4;
++v9;
++a1;
if ( v11 <= 3 )
goto LABEL_7;
}
goto LABEL_8;
}
LABEL_7:
if ( v11 )
{
LABEL_8:
v12 = v11;
v13 = 0LL;
do
{
v14 = *((_BYTE *)v9 + v13);
if ( v14 < 0 )
return (unsigned int)my_convert_using_func(
(long long)a1 + v13,
v12 + a2 - v10 - (unsigned int)v13,
a3,
*(long long ( **)(long long, long long, long long, long long))(*(_QWORD *)(a3 + 184)
+ 48LL),
(long long)v9 + v13,
v12 + a5 - v10 - (unsigned int)v13,
a6,
*(long long ( **)(long long, long long *, long long, unsigned long long))(*(_QWORD *)(a6 + 184) + 40LL),
a7)
+ (_DWORD)v13
+ v10
- v12;
*((_BYTE *)a1 + v13++) = v14;
}
while ( v12 != (_DWORD)v13 );
}
*a7 = 0;
return v10;
}
| my_convert:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RAX,R9
MOV R9D,R8D
MOV R8,RCX
MOV R10,qword ptr [RBP + 0x10]
MOV ECX,dword ptr [RAX + 0xc]
OR ECX,dword ptr [RDX + 0xc]
BT ECX,0xd
JC 0x0015a0cc
CMP ESI,R9D
MOV EBX,R9D
CMOVC EBX,ESI
MOV ECX,EBX
CMP EBX,0x4
JC 0x0015a0a5
LAB_0015a086:
MOV R11D,dword ptr [R8]
TEST R11D,0x80808080
JNZ 0x0015a0a9
MOV dword ptr [RDI],R11D
ADD ECX,-0x4
ADD R8,0x4
ADD RDI,0x4
CMP ECX,0x3
JA 0x0015a086
LAB_0015a0a5:
TEST ECX,ECX
JZ 0x0015a0c3
LAB_0015a0a9:
MOV R14D,ECX
XOR R15D,R15D
LAB_0015a0af:
MOV CL,byte ptr [R8 + R15*0x1]
TEST CL,CL
JS 0x0015a0f9
MOV byte ptr [RDI + R15*0x1],CL
INC R15
CMP R14D,R15D
JNZ 0x0015a0af
LAB_0015a0c3:
MOV dword ptr [R10],0x0
JMP 0x0015a13e
LAB_0015a0cc:
MOV ESI,ESI
MOV RCX,qword ptr [RDX + 0xb8]
MOV RCX,qword ptr [RCX + 0x30]
MOV R9D,R9D
MOV R11,qword ptr [RAX + 0xb8]
SUB RSP,0x8
PUSH R10
PUSH qword ptr [R11 + 0x28]
PUSH RAX
CALL 0x00159f5b
ADD RSP,0x28
JMP 0x0015a144
LAB_0015a0f9:
ADD ESI,R14D
SUB ESI,EBX
SUB ESI,R15D
ADD R9D,R14D
SUB R9D,EBX
SUB R9D,R15D
MOV RCX,qword ptr [RDX + 0xb8]
MOV RCX,qword ptr [RCX + 0x30]
MOV R11,qword ptr [RAX + 0xb8]
ADD RDI,R15
ADD R8,R15
SUB RSP,0x8
PUSH R10
PUSH qword ptr [R11 + 0x28]
PUSH RAX
CALL 0x00159f5b
ADD RSP,0x20
SUB EBX,R14D
ADD EBX,R15D
ADD EBX,EAX
LAB_0015a13e:
MOV EAX,EBX
ADD RSP,0x8
LAB_0015a144:
POP RBX
POP R14
POP R15
POP RBP
RET
|
ulong my_convert(uint *param_1,uint param_2,long param_3,uint *param_4,uint param_5,long param_6,
int4 *param_7)
{
int iVar1;
ulong uVar2;
uint uVar3;
uint uVar5;
int iVar6;
long lVar7;
ulong uVar4;
uVar2 = (ulong)param_5;
if (((*(uint *)(param_6 + 0xc) | *(uint *)(param_3 + 0xc)) >> 0xd & 1) == 0) {
if (param_2 < param_5) {
uVar2 = (ulong)param_2;
}
uVar5 = (uint)uVar2;
uVar3 = uVar5;
uVar4 = uVar2;
while (3 < uVar3) {
uVar3 = (uint)uVar4;
if ((*param_4 & 0x80808080) != 0) goto LAB_0015a0a9;
*param_1 = *param_4;
uVar3 = uVar3 - 4;
uVar4 = (ulong)uVar3;
param_4 = param_4 + 1;
param_1 = param_1 + 1;
}
if (uVar3 != 0) {
LAB_0015a0a9:
lVar7 = 0;
do {
if (*(char *)((long)param_4 + lVar7) < '\0') {
iVar6 = (int)lVar7;
iVar1 = my_convert_using_func
((long)param_1 + lVar7,((param_2 + uVar3) - uVar5) - iVar6,param_3,
*(int8 *)(*(long *)(param_3 + 0xb8) + 0x30),(long)param_4 + lVar7
,((param_5 + uVar3) - uVar5) - iVar6,param_6,
*(int8 *)(*(long *)(param_6 + 0xb8) + 0x28),param_7);
return (ulong)((uVar5 - uVar3) + iVar6 + iVar1);
}
*(char *)((long)param_1 + lVar7) = *(char *)((long)param_4 + lVar7);
lVar7 = lVar7 + 1;
} while (uVar3 != (uint)lVar7);
}
*param_7 = 0;
}
else {
uVar2 = my_convert_using_func
(param_1,param_2,param_3,*(int8 *)(*(long *)(param_3 + 0xb8) + 0x30),
param_4,uVar2,param_6,*(int8 *)(*(long *)(param_6 + 0xb8) + 0x28),
param_7);
}
return uVar2;
}
| |
38,693 | JS_GetScriptOrModuleName | bluesky950520[P]quickjs/quickjs.c | JSAtom JS_GetScriptOrModuleName(JSContext *ctx, int n_stack_levels)
{
JSStackFrame *sf;
JSFunctionBytecode *b;
JSObject *p;
/* XXX: currently we just use the filename of the englobing
function. It does not work for eval(). Need to add a
ScriptOrModule info in JSFunctionBytecode */
sf = ctx->rt->current_stack_frame;
if (!sf)
return JS_ATOM_NULL;
while (n_stack_levels-- > 0) {
sf = sf->prev_frame;
if (!sf)
return JS_ATOM_NULL;
}
if (JS_VALUE_GET_TAG(sf->cur_func) != JS_TAG_OBJECT)
return JS_ATOM_NULL;
p = JS_VALUE_GET_OBJ(sf->cur_func);
if (!js_class_has_bytecode(p->class_id))
return JS_ATOM_NULL;
b = p->u.func.function_bytecode;
return JS_DupAtom(ctx, b->filename);
} | O1 | c | JS_GetScriptOrModuleName:
movq 0x18(%rdi), %rcx
movq 0x108(%rcx), %rdx
xorl %eax, %eax
testq %rdx, %rdx
je 0x30268
incl %esi
decl %esi
testl %esi, %esi
jle 0x30269
movq (%rdx), %rdx
testq %rdx, %rdx
jne 0x3025a
retq
cmpl $-0x1, 0x10(%rdx)
jne 0x30268
movq 0x8(%rdx), %rdx
movzwl 0x6(%rdx), %esi
cmpq $0x38, %rsi
ja 0x30268
movabsq $0x110000000012000, %rdi # imm = 0x110000000012000
btq %rsi, %rdi
jae 0x30268
movq 0x30(%rdx), %rax
movslq 0x68(%rax), %rax
cmpq $0xe0, %rax
jl 0x30268
movq 0x68(%rcx), %rcx
movq (%rcx,%rax,8), %rcx
incl (%rcx)
retq
| JS_GetScriptOrModuleName:
mov rcx, [rdi+18h]
mov rdx, [rcx+108h]
xor eax, eax
test rdx, rdx
jz short locret_30268
inc esi
loc_3025A:
dec esi
test esi, esi
jle short loc_30269
mov rdx, [rdx]
test rdx, rdx
jnz short loc_3025A
locret_30268:
retn
loc_30269:
cmp dword ptr [rdx+10h], 0FFFFFFFFh
jnz short locret_30268
mov rdx, [rdx+8]
movzx esi, word ptr [rdx+6]
cmp rsi, 38h ; '8'
ja short locret_30268
mov rdi, 110000000012000h
bt rdi, rsi
jnb short locret_30268
mov rax, [rdx+30h]
movsxd rax, dword ptr [rax+68h]
cmp rax, 0E0h
jl short locret_30268
mov rcx, [rcx+68h]
mov rcx, [rcx+rax*8]
inc dword ptr [rcx]
retn
| long long JS_GetScriptOrModuleName(long long a1, int a2)
{
long long v2; // rcx
long long *v3; // rdx
long long result; // rax
int v5; // esi
long long v6; // rdx
unsigned long long v7; // rsi
long long v8; // rdi
_DWORD *v9; // rcx
v2 = *(_QWORD *)(a1 + 24);
v3 = *(long long **)(v2 + 264);
result = 0LL;
if ( v3 )
{
v5 = a2 + 1;
while ( --v5 > 0 )
{
v3 = (long long *)*v3;
if ( !v3 )
return result;
}
if ( *((_DWORD *)v3 + 4) == -1 )
{
v6 = v3[1];
v7 = *(unsigned __int16 *)(v6 + 6);
if ( v7 <= 0x38 )
{
v8 = 0x110000000012000LL;
if ( _bittest64(&v8, v7) )
{
result = *(int *)(*(_QWORD *)(v6 + 48) + 104LL);
if ( result >= 224 )
{
v9 = *(_DWORD **)(*(_QWORD *)(v2 + 104) + 8 * result);
++*v9;
}
}
}
}
}
return result;
}
| JS_GetScriptOrModuleName:
MOV RCX,qword ptr [RDI + 0x18]
MOV RDX,qword ptr [RCX + 0x108]
XOR EAX,EAX
TEST RDX,RDX
JZ 0x00130268
INC ESI
LAB_0013025a:
DEC ESI
TEST ESI,ESI
JLE 0x00130269
MOV RDX,qword ptr [RDX]
TEST RDX,RDX
JNZ 0x0013025a
LAB_00130268:
RET
LAB_00130269:
CMP dword ptr [RDX + 0x10],-0x1
JNZ 0x00130268
MOV RDX,qword ptr [RDX + 0x8]
MOVZX ESI,word ptr [RDX + 0x6]
CMP RSI,0x38
JA 0x00130268
MOV RDI,0x110000000012000
BT RDI,RSI
JNC 0x00130268
MOV RAX,qword ptr [RDX + 0x30]
MOVSXD RAX,dword ptr [RAX + 0x68]
CMP RAX,0xe0
JL 0x00130268
MOV RCX,qword ptr [RCX + 0x68]
MOV RCX,qword ptr [RCX + RAX*0x8]
INC dword ptr [RCX]
RET
|
long JS_GetScriptOrModuleName(long param_1,int param_2)
{
int *piVar1;
long lVar2;
long *plVar3;
ulong uVar4;
plVar3 = *(long **)(*(long *)(param_1 + 0x18) + 0x108);
if (plVar3 != (long *)0x0) {
param_2 = param_2 + 1;
do {
param_2 = param_2 + -1;
if (param_2 < 1) {
if ((int)plVar3[2] != -1) {
return 0;
}
uVar4 = (ulong)*(ushort *)(plVar3[1] + 6);
if (0x38 < uVar4) {
return 0;
}
if ((0x110000000012000U >> (uVar4 & 0x3f) & 1) == 0) {
return 0;
}
lVar2 = (long)*(int *)(*(long *)(plVar3[1] + 0x30) + 0x68);
if (lVar2 < 0xe0) {
return lVar2;
}
piVar1 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + lVar2 * 8);
*piVar1 = *piVar1 + 1;
return lVar2;
}
plVar3 = (long *)*plVar3;
} while (plVar3 != (long *)0x0);
}
return 0;
}
| |
38,694 | JS_GetScriptOrModuleName | bluesky950520[P]quickjs/quickjs.c | JSAtom JS_GetScriptOrModuleName(JSContext *ctx, int n_stack_levels)
{
JSStackFrame *sf;
JSFunctionBytecode *b;
JSObject *p;
/* XXX: currently we just use the filename of the englobing
function. It does not work for eval(). Need to add a
ScriptOrModule info in JSFunctionBytecode */
sf = ctx->rt->current_stack_frame;
if (!sf)
return JS_ATOM_NULL;
while (n_stack_levels-- > 0) {
sf = sf->prev_frame;
if (!sf)
return JS_ATOM_NULL;
}
if (JS_VALUE_GET_TAG(sf->cur_func) != JS_TAG_OBJECT)
return JS_ATOM_NULL;
p = JS_VALUE_GET_OBJ(sf->cur_func);
if (!js_class_has_bytecode(p->class_id))
return JS_ATOM_NULL;
b = p->u.func.function_bytecode;
return JS_DupAtom(ctx, b->filename);
} | O3 | c | JS_GetScriptOrModuleName:
movq 0x18(%rdi), %rcx
movq 0x108(%rcx), %rdx
xorl %eax, %eax
testq %rdx, %rdx
je 0x31257
incl %esi
decl %esi
testl %esi, %esi
jle 0x31258
movq (%rdx), %rdx
testq %rdx, %rdx
jne 0x31249
retq
cmpl $-0x1, 0x10(%rdx)
jne 0x31257
movq 0x8(%rdx), %rdx
movzwl 0x6(%rdx), %esi
cmpq $0x38, %rsi
ja 0x31257
movabsq $0x110000000012000, %rdi # imm = 0x110000000012000
btq %rsi, %rdi
jae 0x31257
movq 0x30(%rdx), %rax
movslq 0x68(%rax), %rax
cmpq $0xe0, %rax
jl 0x31257
movq 0x68(%rcx), %rcx
movq (%rcx,%rax,8), %rcx
incl (%rcx)
retq
| JS_GetScriptOrModuleName:
mov rcx, [rdi+18h]
mov rdx, [rcx+108h]
xor eax, eax
test rdx, rdx
jz short locret_31257
inc esi
loc_31249:
dec esi
test esi, esi
jle short loc_31258
mov rdx, [rdx]
test rdx, rdx
jnz short loc_31249
locret_31257:
retn
loc_31258:
cmp dword ptr [rdx+10h], 0FFFFFFFFh
jnz short locret_31257
mov rdx, [rdx+8]
movzx esi, word ptr [rdx+6]
cmp rsi, 38h ; '8'
ja short locret_31257
mov rdi, 110000000012000h
bt rdi, rsi
jnb short locret_31257
mov rax, [rdx+30h]
movsxd rax, dword ptr [rax+68h]
cmp rax, 0E0h
jl short locret_31257
mov rcx, [rcx+68h]
mov rcx, [rcx+rax*8]
inc dword ptr [rcx]
retn
| long long JS_GetScriptOrModuleName(long long a1, int a2)
{
long long v2; // rcx
long long *v3; // rdx
long long result; // rax
int v5; // esi
long long v6; // rdx
unsigned long long v7; // rsi
long long v8; // rdi
_DWORD *v9; // rcx
v2 = *(_QWORD *)(a1 + 24);
v3 = *(long long **)(v2 + 264);
result = 0LL;
if ( v3 )
{
v5 = a2 + 1;
while ( --v5 > 0 )
{
v3 = (long long *)*v3;
if ( !v3 )
return result;
}
if ( *((_DWORD *)v3 + 4) == -1 )
{
v6 = v3[1];
v7 = *(unsigned __int16 *)(v6 + 6);
if ( v7 <= 0x38 )
{
v8 = 0x110000000012000LL;
if ( _bittest64(&v8, v7) )
{
result = *(int *)(*(_QWORD *)(v6 + 48) + 104LL);
if ( result >= 224 )
{
v9 = *(_DWORD **)(*(_QWORD *)(v2 + 104) + 8 * result);
++*v9;
}
}
}
}
}
return result;
}
| JS_GetScriptOrModuleName:
MOV RCX,qword ptr [RDI + 0x18]
MOV RDX,qword ptr [RCX + 0x108]
XOR EAX,EAX
TEST RDX,RDX
JZ 0x00131257
INC ESI
LAB_00131249:
DEC ESI
TEST ESI,ESI
JLE 0x00131258
MOV RDX,qword ptr [RDX]
TEST RDX,RDX
JNZ 0x00131249
LAB_00131257:
RET
LAB_00131258:
CMP dword ptr [RDX + 0x10],-0x1
JNZ 0x00131257
MOV RDX,qword ptr [RDX + 0x8]
MOVZX ESI,word ptr [RDX + 0x6]
CMP RSI,0x38
JA 0x00131257
MOV RDI,0x110000000012000
BT RDI,RSI
JNC 0x00131257
MOV RAX,qword ptr [RDX + 0x30]
MOVSXD RAX,dword ptr [RAX + 0x68]
CMP RAX,0xe0
JL 0x00131257
MOV RCX,qword ptr [RCX + 0x68]
MOV RCX,qword ptr [RCX + RAX*0x8]
INC dword ptr [RCX]
RET
|
long JS_GetScriptOrModuleName(long param_1,int param_2)
{
int *piVar1;
long lVar2;
long *plVar3;
ulong uVar4;
plVar3 = *(long **)(*(long *)(param_1 + 0x18) + 0x108);
if (plVar3 != (long *)0x0) {
param_2 = param_2 + 1;
do {
param_2 = param_2 + -1;
if (param_2 < 1) {
if ((int)plVar3[2] != -1) {
return 0;
}
uVar4 = (ulong)*(ushort *)(plVar3[1] + 6);
if (0x38 < uVar4) {
return 0;
}
if ((0x110000000012000U >> (uVar4 & 0x3f) & 1) == 0) {
return 0;
}
lVar2 = (long)*(int *)(*(long *)(plVar3[1] + 0x30) + 0x68);
if (lVar2 < 0xe0) {
return lVar2;
}
piVar1 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + lVar2 * 8);
*piVar1 = *piVar1 + 1;
return lVar2;
}
plVar3 = (long *)*plVar3;
} while (plVar3 != (long *)0x0);
}
return 0;
}
| |
38,695 | translog_free_link | eloqsql/storage/maria/ma_loghandler.c | static void translog_free_link(PAGECACHE_BLOCK_LINK *direct_link)
{
DBUG_ENTER("translog_free_link");
DBUG_PRINT("info", ("Direct link: %p",
direct_link));
if (direct_link)
pagecache_unlock_by_link(log_descriptor.pagecache, direct_link,
PAGECACHE_LOCK_READ_UNLOCK, PAGECACHE_UNPIN,
LSN_IMPOSSIBLE, LSN_IMPOSSIBLE, 0, FALSE);
DBUG_VOID_RETURN;
} | O0 | c | translog_free_link:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x4e57e
cmpq $0x0, -0x8(%rbp)
je 0x4e5b8
movq 0x4297b4(%rip), %rdi # 0x477d40
movq -0x8(%rbp), %rsi
movl $0x5, %edx
movl $0x3, %ecx
xorl %eax, %eax
movl %eax, %r9d
xorl %eax, %eax
movq %r9, %r8
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x58740
jmp 0x4e5ba
jmp 0x4e5bc
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| translog_free_link:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
jmp short $+2
loc_4E57E:
cmp [rbp+var_8], 0
jz short loc_4E5B8
mov rdi, cs:log_descriptor
mov rsi, [rbp+var_8]
mov edx, 5
mov ecx, 3
xor eax, eax
mov r9d, eax
xor eax, eax
mov r8, r9
mov [rsp+20h+var_20], 0
mov [rsp+20h+var_18], 0
call pagecache_unlock_by_link
loc_4E5B8:
jmp short $+2
loc_4E5BA:
jmp short $+2
loc_4E5BC:
add rsp, 20h
pop rbp
retn
| long long translog_free_link(long long a1)
{
long long result; // rax
if ( a1 )
return pagecache_unlock_by_link(log_descriptor[0], a1, 5, 3, 0, 0, 0, 0);
return result;
}
| translog_free_link:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
JMP 0x0014e57e
LAB_0014e57e:
CMP qword ptr [RBP + -0x8],0x0
JZ 0x0014e5b8
MOV RDI,qword ptr [0x00577d40]
MOV RSI,qword ptr [RBP + -0x8]
MOV EDX,0x5
MOV ECX,0x3
XOR EAX,EAX
MOV R9D,EAX
XOR EAX,EAX
MOV R8,R9
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x8],0x0
CALL 0x00158740
LAB_0014e5b8:
JMP 0x0014e5ba
LAB_0014e5ba:
JMP 0x0014e5bc
LAB_0014e5bc:
ADD RSP,0x20
POP RBP
RET
|
void translog_free_link(long param_1)
{
if (param_1 != 0) {
pagecache_unlock_by_link(log_descriptor,param_1,5,3,0,0,0,0);
}
return;
}
| |
38,696 | uint64_to_be | corpus-core[P]colibri-stateless/src/util/bytes.c | void uint64_to_be(uint8_t* data, uint64_t value) {
data[0] = (value >> 56) & 0xFF;
data[1] = (value >> 48) & 0xFF;
data[2] = (value >> 40) & 0xFF;
data[3] = (value >> 32) & 0xFF;
data[4] = (value >> 24) & 0xFF;
data[5] = (value >> 16) & 0xFF;
data[6] = (value >> 8) & 0xFF;
data[7] = value & 0xFF;
} | O3 | c | uint64_to_be:
bswapq %rsi
movq %rsi, (%rdi)
retq
| uint64_to_be:
bswap rsi
mov [rdi], rsi
retn
| void uint64_to_be(_QWORD *a1, unsigned long long a2)
{
*a1 = _byteswap_uint64(a2);
}
| uint64_to_be:
BSWAP RSI
MOV qword ptr [RDI],RSI
RET
|
void uint64_to_be(ulong *param_1,ulong param_2)
{
*param_1 = param_2 >> 0x38 | (param_2 & 0xff000000000000) >> 0x28 |
(param_2 & 0xff0000000000) >> 0x18 | (param_2 & 0xff00000000) >> 8 |
(param_2 & 0xff000000) << 8 | (param_2 & 0xff0000) << 0x18 | (param_2 & 0xff00) << 0x28
| param_2 << 0x38;
return;
}
| |
38,697 | my_casedn_utf32 | eloqsql/strings/ctype-ucs2.c | static size_t
my_casedn_utf32(CHARSET_INFO *cs, const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
int res;
const char *srcend= src + srclen;
char *dstend= dst + dstlen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(srclen <= dstlen);
while ((res= my_utf32_uni(cs, &wc, (uchar*) src, (uchar*) srcend)) > 0)
{
my_tolower_utf32(uni_plane,&wc);
if (res != my_uni_utf32(cs, wc, (uchar*) dst, (uchar*) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
} | O3 | c | my_casedn_utf32:
movq %rdx, %rax
cmpq $0x4, %rdx
jl 0x2aa69
pushq %rbp
movq %rsp, %rbp
pushq %rbx
leaq (%rsi,%rax), %rdx
addq %rcx, %r8
movq 0x78(%rdi), %rdi
addq $0x4, %rcx
movzbl (%rsi), %r9d
shll $0x18, %r9d
movzbl 0x1(%rsi), %r10d
shll $0x10, %r10d
orl %r9d, %r10d
cmpl $0x10ffff, %r10d # imm = 0x10FFFF
ja 0x2aa67
movzbl 0x2(%rsi), %ebx
shll $0x8, %ebx
movzbl 0x3(%rsi), %r9d
orq %r9, %rbx
orq %r10, %rbx
cmpq (%rdi), %rbx
ja 0x2aa30
movq 0x8(%rdi), %r10
movl %ebx, %r11d
shrl $0x8, %r11d
movq (%r10,%r11,8), %r10
testq %r10, %r10
je 0x2aa30
leaq (%r9,%r9,2), %r9
movl 0x4(%r10,%r9,4), %ebx
cmpq %r8, %rcx
ja 0x2aa67
cmpl $0x10ffff, %ebx # imm = 0x10FFFF
ja 0x2aa67
movb $0x0, -0x4(%rcx)
movl %ebx, %r9d
shrl $0x10, %r9d
movb %r9b, -0x3(%rcx)
movb %bh, -0x2(%rcx)
movb %bl, -0x1(%rcx)
leaq 0x8(%rsi), %r9
addq $0x4, %rcx
addq $0x4, %rsi
cmpq %rdx, %r9
jbe 0x2a9df
popq %rbx
popq %rbp
retq
| my_casedn_utf32:
mov rax, rdx
cmp rdx, 4
jl locret_2AA69
push rbp
mov rbp, rsp
push rbx
lea rdx, [rsi+rax]
add r8, rcx
mov rdi, [rdi+78h]
add rcx, 4
loc_2A9DF:
movzx r9d, byte ptr [rsi]
shl r9d, 18h
movzx r10d, byte ptr [rsi+1]
shl r10d, 10h
or r10d, r9d
cmp r10d, offset unk_10FFFF
ja short loc_2AA67
movzx ebx, byte ptr [rsi+2]
shl ebx, 8
movzx r9d, byte ptr [rsi+3]
or rbx, r9
or rbx, r10
cmp rbx, [rdi]
ja short loc_2AA30
mov r10, [rdi+8]
mov r11d, ebx
shr r11d, 8
mov r10, [r10+r11*8]
test r10, r10
jz short loc_2AA30
lea r9, [r9+r9*2]
mov ebx, [r10+r9*4+4]
loc_2AA30:
cmp rcx, r8
ja short loc_2AA67
cmp ebx, offset unk_10FFFF
ja short loc_2AA67
mov byte ptr [rcx-4], 0
mov r9d, ebx
shr r9d, 10h
mov [rcx-3], r9b
mov [rcx-2], bh
mov [rcx-1], bl
lea r9, [rsi+8]
add rcx, 4
add rsi, 4
cmp r9, rdx
jbe loc_2A9DF
loc_2AA67:
pop rbx
pop rbp
locret_2AA69:
retn
| long long my_casedn_utf32(long long a1, unsigned __int8 *a2, long long a3, long long a4, long long a5)
{
long long result; // rax
unsigned __int8 *v6; // rdx
unsigned long long v7; // r8
unsigned long long *v8; // rdi
unsigned long long v9; // rcx
long long v10; // r10
long long v11; // r9
unsigned long long v12; // rbx
long long v13; // r10
unsigned __int8 *v14; // r9
result = a3;
if ( a3 >= 4 )
{
v6 = &a2[a3];
v7 = a4 + a5;
v8 = *(unsigned long long **)(a1 + 120);
v9 = a4 + 4;
do
{
v10 = (*a2 << 24) | (a2[1] << 16);
if ( (unsigned int)v10 > (unsigned int)&unk_10FFFF )
break;
v11 = a2[3];
v12 = v10 | v11 | (a2[2] << 8);
if ( v12 <= *v8 )
{
v13 = *(_QWORD *)(v8[1] + 8LL * ((unsigned int)v12 >> 8));
if ( v13 )
LODWORD(v12) = *(_DWORD *)(v13 + 12 * v11 + 4);
}
if ( v9 > v7 )
break;
if ( (unsigned int)v12 > (unsigned int)&unk_10FFFF )
break;
*(_BYTE *)(v9 - 4) = 0;
*(_BYTE *)(v9 - 3) = BYTE2(v12);
*(_BYTE *)(v9 - 2) = BYTE1(v12);
*(_BYTE *)(v9 - 1) = v12;
v14 = a2 + 8;
v9 += 4LL;
a2 += 4;
}
while ( v14 <= v6 );
}
return result;
}
| my_casedn_utf32:
MOV RAX,RDX
CMP RDX,0x4
JL 0x0012aa69
PUSH RBP
MOV RBP,RSP
PUSH RBX
LEA RDX,[RSI + RAX*0x1]
ADD R8,RCX
MOV RDI,qword ptr [RDI + 0x78]
ADD RCX,0x4
LAB_0012a9df:
MOVZX R9D,byte ptr [RSI]
SHL R9D,0x18
MOVZX R10D,byte ptr [RSI + 0x1]
SHL R10D,0x10
OR R10D,R9D
CMP R10D,0x10ffff
JA 0x0012aa67
MOVZX EBX,byte ptr [RSI + 0x2]
SHL EBX,0x8
MOVZX R9D,byte ptr [RSI + 0x3]
OR RBX,R9
OR RBX,R10
CMP RBX,qword ptr [RDI]
JA 0x0012aa30
MOV R10,qword ptr [RDI + 0x8]
MOV R11D,EBX
SHR R11D,0x8
MOV R10,qword ptr [R10 + R11*0x8]
TEST R10,R10
JZ 0x0012aa30
LEA R9,[R9 + R9*0x2]
MOV EBX,dword ptr [R10 + R9*0x4 + 0x4]
LAB_0012aa30:
CMP RCX,R8
JA 0x0012aa67
CMP EBX,0x10ffff
JA 0x0012aa67
MOV byte ptr [RCX + -0x4],0x0
MOV R9D,EBX
SHR R9D,0x10
MOV byte ptr [RCX + -0x3],R9B
MOV byte ptr [RCX + -0x2],BH
MOV byte ptr [RCX + -0x1],BL
LEA R9,[RSI + 0x8]
ADD RCX,0x4
ADD RSI,0x4
CMP R9,RDX
JBE 0x0012a9df
LAB_0012aa67:
POP RBX
POP RBP
LAB_0012aa69:
RET
|
void my_casedn_utf32(long param_1,byte *param_2,long param_3,long param_4,long param_5)
{
byte *pbVar1;
byte *pbVar2;
ulong *puVar3;
long lVar4;
ulong uVar5;
ulong uVar6;
uint uVar7;
if (3 < param_3) {
pbVar2 = param_2 + param_3;
puVar3 = *(ulong **)(param_1 + 0x78);
uVar5 = param_4 + 4;
while (uVar7 = (uint)param_2[1] << 0x10 | (uint)*param_2 << 0x18, uVar7 < 0x110000) {
uVar6 = (ulong)CONCAT11(param_2[2],param_2[3]) | (ulong)uVar7;
if ((uVar6 <= *puVar3) && (lVar4 = *(long *)(puVar3[1] + (uVar6 >> 8) * 8), lVar4 != 0)) {
uVar6 = (ulong)*(uint *)(lVar4 + 4 + (ulong)param_2[3] * 0xc);
}
if ((ulong)(param_5 + param_4) < uVar5) {
return;
}
if (0x10ffff < (uint)uVar6) {
return;
}
*(int1 *)(uVar5 - 4) = 0;
*(char *)(uVar5 - 3) = (char)(uVar6 >> 0x10);
*(char *)(uVar5 - 2) = (char)(uVar6 >> 8);
*(char *)(uVar5 - 1) = (char)uVar6;
pbVar1 = param_2 + 8;
uVar5 = uVar5 + 4;
param_2 = param_2 + 4;
if (pbVar2 < pbVar1) {
return;
}
}
}
return;
}
| |
38,698 | IsWaveValid | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/raudio.c | bool IsWaveValid(Wave wave)
{
bool result = false;
if ((wave.data != NULL) && // Validate wave data available
(wave.frameCount > 0) && // Validate frame count
(wave.sampleRate > 0) && // Validate sample rate is supported
(wave.sampleSize > 0) && // Validate sample size is supported
(wave.channels > 0)) result = true; // Validate number of channels supported
return result;
} | O0 | c | IsWaveValid:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movb $0x0, -0x1(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x7aaa2
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jbe 0x7aaa2
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jbe 0x7aaa2
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jbe 0x7aaa2
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jbe 0x7aaa2
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
| IsWaveValid:
push rbp
mov rbp, rsp
lea rax, [rbp+arg_0]
mov [rbp+var_10], rax
mov [rbp+var_1], 0
cmp qword ptr [rax+10h], 0
jz short loc_7AAA2
mov rax, [rbp+var_10]
cmp dword ptr [rax], 0
jbe short loc_7AAA2
mov rax, [rbp+var_10]
cmp dword ptr [rax+4], 0
jbe short loc_7AAA2
mov rax, [rbp+var_10]
cmp dword ptr [rax+8], 0
jbe short loc_7AAA2
mov rax, [rbp+var_10]
cmp dword ptr [rax+0Ch], 0
jbe short loc_7AAA2
mov [rbp+var_1], 1
loc_7AAA2:
mov al, [rbp+var_1]
and al, 1
pop rbp
retn
| bool IsWaveValid(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7,
long long a8,
long long a9)
{
bool v10; // [rsp+Fh] [rbp-1h]
v10 = 0;
if ( a9 && (_DWORD)a7 && HIDWORD(a7) && (_DWORD)a8 )
return HIDWORD(a8) != 0;
return v10;
}
| IsWaveValid:
PUSH RBP
MOV RBP,RSP
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x10],RAX
MOV byte ptr [RBP + -0x1],0x0
CMP qword ptr [RAX + 0x10],0x0
JZ 0x0017aaa2
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX],0x0
JBE 0x0017aaa2
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x4],0x0
JBE 0x0017aaa2
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x8],0x0
JBE 0x0017aaa2
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0xc],0x0
JBE 0x0017aaa2
MOV byte ptr [RBP + -0x1],0x1
LAB_0017aaa2:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
POP RBP
RET
|
int8 IsWaveValid(void)
{
int iStack0000000000000008;
int iStack000000000000000c;
int iStack0000000000000010;
int iStack0000000000000014;
long in_stack_00000018;
int1 local_9;
local_9 = 0;
if ((((in_stack_00000018 != 0) && (iStack0000000000000008 != 0)) && (iStack000000000000000c != 0))
&& ((iStack0000000000000010 != 0 && (iStack0000000000000014 != 0)))) {
local_9 = 1;
}
return CONCAT71((int7)((ulong)&stack0x00000008 >> 8),local_9);
}
| |
38,699 | IsWaveValid | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/raudio.c | bool IsWaveValid(Wave wave)
{
bool result = false;
if ((wave.data != NULL) && // Validate wave data available
(wave.frameCount > 0) && // Validate frame count
(wave.sampleRate > 0) && // Validate sample rate is supported
(wave.sampleSize > 0) && // Validate sample size is supported
(wave.channels > 0)) result = true; // Validate number of channels supported
return result;
} | O1 | c | IsWaveValid:
cmpq $0x0, 0x18(%rsp)
setne %al
cmpl $0x0, 0x8(%rsp)
setne %cl
andb %al, %cl
cmpl $0x0, 0xc(%rsp)
setne %al
cmpl $0x0, 0x10(%rsp)
setne %dl
andb %al, %dl
andb %cl, %dl
cmpl $0x0, 0x14(%rsp)
setne %al
andb %dl, %al
retq
| IsWaveValid:
cmp [rsp+arg_10], 0
setnz al
cmp [rsp+arg_0], 0
setnz cl
and cl, al
cmp [rsp+arg_4], 0
setnz al
cmp [rsp+arg_8], 0
setnz dl
and dl, al
and dl, cl
cmp [rsp+arg_C], 0
setnz al
and al, dl
retn
| bool IsWaveValid(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7,
long long a8,
long long a9)
{
return a9 != 0 && (_DWORD)a7 != 0 && HIDWORD(a7) != 0 && (_DWORD)a8 != 0 && HIDWORD(a8) != 0;
}
| IsWaveValid:
CMP qword ptr [RSP + 0x18],0x0
SETNZ AL
CMP dword ptr [RSP + 0x8],0x0
SETNZ CL
AND CL,AL
CMP dword ptr [RSP + 0xc],0x0
SETNZ AL
CMP dword ptr [RSP + 0x10],0x0
SETNZ DL
AND DL,AL
AND DL,CL
CMP dword ptr [RSP + 0x14],0x0
SETNZ AL
AND AL,DL
RET
|
bool IsWaveValid(void)
{
int iStack0000000000000008;
int iStack000000000000000c;
int iStack0000000000000010;
int iStack0000000000000014;
long in_stack_00000018;
return iStack0000000000000014 != 0 &&
((iStack0000000000000010 != 0 && iStack000000000000000c != 0) &&
(iStack0000000000000008 != 0 && in_stack_00000018 != 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.