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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
41,200 | div_by_zz | corpus-core[P]colibri-stateless/build_O3/_deps/blst-src/src/vect.c | static void div_by_zz(limb_t val[])
{
static const limb_t zz[] = { TO_LIMB_T(0x0000000100000000),
TO_LIMB_T(0xac45a4010001a402) };
size_t loop, zz_len = sizeof(zz)/sizeof(zz[0]);
limb_t d_lo, d_hi;
d_lo = zz[zz_len - 2];
d_hi = zz[zz_len - 1];
for (loop = zz_len, zz_len--; loop--;) {
limb_t q = div_3_limbs(val + loop + zz_len, d_lo, d_hi);
(void)quot_rem_128(val + loop, zz, q);
}
/* remainder is in low half of val[], quotient is in high */
} | O3 | c | div_by_zz:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
addq $0x10, %rdi
movq $-0x2, %r13
movabsq $0x100000000, %rbx # imm = 0x100000000
movabsq $-0x53ba5bfefffe5bfe, %r14 # imm = 0xAC45A4010001A402
leaq 0x26644(%rip), %r15 # 0x8d040
leaq -0x8(%rdi), %r12
movq %rbx, %rsi
movq %r14, %rdx
callq 0x77ae0
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x77b40
movq %r12, %rdi
incq %r13
jne 0x669fc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| div_by_zz:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
add rdi, 10h
mov r13, 0FFFFFFFFFFFFFFFEh
mov rbx, 100000000h
mov r14, 0AC45A4010001A402h
lea r15, div_by_zz_zz
loc_669FC:
lea r12, [rdi-8]
mov rsi, rbx
mov rdx, r14
call div_3_limbs
mov rdi, r12
mov rsi, r15
mov rdx, rax
call quot_rem_128
mov rdi, r12
inc r13
jnz short loc_669FC
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long div_by_zz(long long a1)
{
long long v1; // rdi
long long v2; // r13
long long v3; // rax
long long result; // rax
v1 = a1 + 16;
v2 = -2LL;
do
{
v3 = div_3_limbs(v1, 0x100000000LL, 0xAC45A4010001A402LL);
result = quot_rem_128(v1 - 8, &div_by_zz_zz, v3);
v1 -= 8LL;
++v2;
}
while ( v2 );
return result;
}
| div_by_zz:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
ADD RDI,0x10
MOV R13,-0x2
MOV RBX,0x100000000
MOV R14,-0x53ba5bfefffe5bfe
LEA R15,[0x18d040]
LAB_001669fc:
LEA R12,[RDI + -0x8]
MOV RSI,RBX
MOV RDX,R14
CALL 0x00177ae0
MOV RDI,R12
MOV RSI,R15
MOV RDX,RAX
CALL 0x00177b40
MOV RDI,R12
INC R13
JNZ 0x001669fc
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void div_by_zz(long param_1)
{
int8 uVar1;
long lVar2;
long lVar3;
lVar3 = -2;
lVar2 = param_1 + 0x10;
do {
uVar1 = div_3_limbs(lVar2,0x100000000,0xac45a4010001a402);
quot_rem_128(lVar2 + -8,div_by_zz_zz,uVar1);
lVar3 = lVar3 + 1;
lVar2 = lVar2 + -8;
} while (lVar3 != 0);
return;
}
| |
41,201 | js_dynamic_import | bluesky950520[P]quickjs/quickjs.c | static JSValue js_dynamic_import(JSContext *ctx, JSValue specifier)
{
JSAtom basename;
JSValue promise, resolving_funcs[2], basename_val;
JSValue args[4];
basename = JS_GetScriptOrModuleName(ctx, 0);
if (basename == JS_ATOM_NULL)
basename_val = JS_NULL;
else
basename_val = JS_AtomToValue(ctx, basename);
JS_FreeAtom(ctx, basename);
if (JS_IsException(basename_val))
return basename_val;
promise = JS_NewPromiseCapability(ctx, resolving_funcs);
if (JS_IsException(promise)) {
JS_FreeValue(ctx, basename_val);
return promise;
}
args[0] = resolving_funcs[0];
args[1] = resolving_funcs[1];
args[2] = basename_val;
args[3] = specifier;
/* cannot run JS_LoadModuleInternal synchronously because it would
cause an unexpected recursion in js_evaluate_module() */
JS_EnqueueJob(ctx, js_dynamic_import_job, 4, args);
JS_FreeValue(ctx, basename_val);
JS_FreeValue(ctx, resolving_funcs[0]);
JS_FreeValue(ctx, resolving_funcs[1]);
return promise;
} | O0 | c | js_dynamic_import:
subq $0xe8, %rsp
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rdi, 0xc0(%rsp)
movq 0xc0(%rsp), %rdi
xorl %esi, %esi
callq 0x48ea0
movl %eax, 0xbc(%rsp)
cmpl $0x0, 0xbc(%rsp)
jne 0x64de6
movl $0x0, 0x20(%rsp)
movq $0x2, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x78(%rsp)
jmp 0x64e18
movq 0xc0(%rsp), %rdi
movl 0xbc(%rsp), %esi
callq 0x27b70
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0xc0(%rsp), %rdi
movl 0xbc(%rsp), %esi
callq 0x27d80
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x22a00
cmpl $0x0, %eax
je 0x64e5f
movq 0x70(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0xe0(%rsp)
jmp 0x64fdd
movq 0xc0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x491d0
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xa8(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0x22a00
cmpl $0x0, %eax
je 0x64eec
movq 0xc0(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x229d0
movq 0xa8(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0xe0(%rsp)
jmp 0x64fdd
movq 0x80(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0xc0(%rsp), %rdi
leaq 0x30(%rsp), %rcx
leaq 0x7a2e(%rip), %rsi # 0x6c990
movl $0x4, %edx
callq 0x22670
movq 0xc0(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x229d0
movq 0xc0(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0x229d0
movq 0xc0(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
callq 0x229d0
movq 0xa8(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq 0xd8(%rsp), %rax
movq 0xe0(%rsp), %rdx
addq $0xe8, %rsp
retq
nopw %cs:(%rax,%rax)
| js_dynamic_import:
sub rsp, 0E8h
mov [rsp+0E8h+var_20], rsi
mov [rsp+0E8h+var_18], rdx
mov [rsp+0E8h+var_28], rdi
mov rdi, [rsp+0E8h+var_28]
xor esi, esi
call JS_GetScriptOrModuleName
mov [rsp+0E8h+var_2C], eax
cmp [rsp+0E8h+var_2C], 0
jnz short loc_64DE6
mov dword ptr [rsp+0E8h+var_C8], 0
mov [rsp+0E8h+var_C0], 2
mov rax, [rsp+0E8h+var_C8]
mov [rsp+0E8h+var_78], rax
mov rax, [rsp+0E8h+var_C0]
mov [rsp+0E8h+var_70], rax
jmp short loc_64E18
loc_64DE6:
mov rdi, [rsp+0E8h+var_28]
mov esi, [rsp+0E8h+var_2C]
call JS_AtomToValue
mov [rsp+0E8h+var_D8], rax
mov [rsp+0E8h+var_D0], rdx
mov rax, [rsp+0E8h+var_D8]
mov [rsp+0E8h+var_78], rax
mov rax, [rsp+0E8h+var_D0]
mov [rsp+0E8h+var_70], rax
loc_64E18:
mov rdi, [rsp+0E8h+var_28]
mov esi, [rsp+0E8h+var_2C]
call JS_FreeAtom
mov rdi, [rsp+0E8h+var_78]
mov rsi, [rsp+0E8h+var_70]
call JS_IsException_1
cmp eax, 0
jz short loc_64E5F
mov rax, [rsp+0E8h+var_78]
mov [rsp+0E8h+var_10], rax
mov rax, [rsp+0E8h+var_70]
mov [rsp+0E8h+var_8], rax
jmp loc_64FDD
loc_64E5F:
mov rdi, [rsp+0E8h+var_28]
lea rsi, [rsp+0E8h+var_68]
call JS_NewPromiseCapability
mov [rsp+0E8h+var_E8], rax
mov [rsp+0E8h+var_E0], rdx
mov rax, [rsp+0E8h+var_E8]
mov [rsp+0E8h+var_40], rax
mov rax, [rsp+0E8h+var_E0]
mov [rsp+0E8h+var_38], rax
mov rdi, [rsp+0E8h+var_40]
mov rsi, [rsp+0E8h+var_38]
call JS_IsException_1
cmp eax, 0
jz short loc_64EEC
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_78]
mov rdx, [rsp+0E8h+var_70]
call JS_FreeValue
mov rax, [rsp+0E8h+var_40]
mov [rsp+0E8h+var_10], rax
mov rax, [rsp+0E8h+var_38]
mov [rsp+0E8h+var_8], rax
jmp loc_64FDD
loc_64EEC:
mov rax, [rsp+0E8h+var_68]
mov [rsp+0E8h+var_B8], rax
mov rax, [rsp+0E8h+var_60]
mov [rsp+0E8h+var_B0], rax
mov rax, [rsp+0E8h+var_58]
mov [rsp+0E8h+var_A8], rax
mov rax, [rsp+0E8h+var_50]
mov [rsp+0E8h+var_A0], rax
mov rax, [rsp+0E8h+var_78]
mov [rsp+0E8h+var_98], rax
mov rax, [rsp+0E8h+var_70]
mov [rsp+0E8h+var_90], rax
mov rax, [rsp+0E8h+var_20]
mov [rsp+0E8h+var_88], rax
mov rax, [rsp+0E8h+var_18]
mov [rsp+0E8h+var_80], rax
mov rdi, [rsp+0E8h+var_28]
lea rcx, [rsp+0E8h+var_B8]
lea rsi, js_dynamic_import_job
mov edx, 4
call JS_EnqueueJob
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_78]
mov rdx, [rsp+0E8h+var_70]
call JS_FreeValue
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_68]
mov rdx, [rsp+0E8h+var_60]
call JS_FreeValue
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_58]
mov rdx, [rsp+0E8h+var_50]
call JS_FreeValue
mov rax, [rsp+0E8h+var_40]
mov [rsp+0E8h+var_10], rax
mov rax, [rsp+0E8h+var_38]
mov [rsp+0E8h+var_8], rax
loc_64FDD:
mov rax, [rsp+0E8h+var_10]
mov rdx, [rsp+0E8h+var_8]
add rsp, 0E8h
retn
| long long js_dynamic_import(long long a1, long long a2, long long a3)
{
long long v3; // rdx
long long v4; // rdx
long long v6; // [rsp+20h] [rbp-C8h]
_QWORD v7[8]; // [rsp+30h] [rbp-B8h] BYREF
long long v8; // [rsp+70h] [rbp-78h]
long long v9; // [rsp+78h] [rbp-70h]
long long v10; // [rsp+80h] [rbp-68h] BYREF
long long v11; // [rsp+88h] [rbp-60h]
long long v12; // [rsp+90h] [rbp-58h]
long long v13; // [rsp+98h] [rbp-50h]
long long v14; // [rsp+A8h] [rbp-40h]
long long v15; // [rsp+B0h] [rbp-38h]
unsigned int ScriptOrModuleName; // [rsp+BCh] [rbp-2Ch]
long long v17; // [rsp+C0h] [rbp-28h]
long long v18; // [rsp+C8h] [rbp-20h]
long long v19; // [rsp+D0h] [rbp-18h]
long long v20; // [rsp+D8h] [rbp-10h]
long long v21; // [rsp+E0h] [rbp-8h]
v18 = a2;
v19 = a3;
v17 = a1;
ScriptOrModuleName = JS_GetScriptOrModuleName(a1, 0);
if ( ScriptOrModuleName )
{
v8 = JS_AtomToValue(v17, ScriptOrModuleName);
v9 = v3;
}
else
{
LODWORD(v6) = 0;
v8 = v6;
v9 = 2LL;
}
JS_FreeAtom(v17, ScriptOrModuleName);
if ( JS_IsException_1(v8, v9) )
{
v20 = v8;
v21 = v9;
}
else
{
v14 = JS_NewPromiseCapability(v17, (long long)&v10);
v15 = v4;
if ( JS_IsException_1(v14, v4) )
{
JS_FreeValue(v17, v8, v9);
}
else
{
v7[0] = v10;
v7[1] = v11;
v7[2] = v12;
v7[3] = v13;
v7[4] = v8;
v7[5] = v9;
v7[6] = v18;
v7[7] = v19;
JS_EnqueueJob(v17, (long long)js_dynamic_import_job, 4, (long long)v7);
JS_FreeValue(v17, v8, v9);
JS_FreeValue(v17, v10, v11);
JS_FreeValue(v17, v12, v13);
}
v20 = v14;
v21 = v15;
}
return v20;
}
| js_dynamic_import:
SUB RSP,0xe8
MOV qword ptr [RSP + 0xc8],RSI
MOV qword ptr [RSP + 0xd0],RDX
MOV qword ptr [RSP + 0xc0],RDI
MOV RDI,qword ptr [RSP + 0xc0]
XOR ESI,ESI
CALL 0x00148ea0
MOV dword ptr [RSP + 0xbc],EAX
CMP dword ptr [RSP + 0xbc],0x0
JNZ 0x00164de6
MOV dword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x28],0x2
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x70],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x78],RAX
JMP 0x00164e18
LAB_00164de6:
MOV RDI,qword ptr [RSP + 0xc0]
MOV ESI,dword ptr [RSP + 0xbc]
CALL 0x00127b70
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],RDX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x70],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x78],RAX
LAB_00164e18:
MOV RDI,qword ptr [RSP + 0xc0]
MOV ESI,dword ptr [RSP + 0xbc]
CALL 0x00127d80
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x78]
CALL 0x00122a00
CMP EAX,0x0
JZ 0x00164e5f
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0xd8],RAX
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0xe0],RAX
JMP 0x00164fdd
LAB_00164e5f:
MOV RDI,qword ptr [RSP + 0xc0]
LEA RSI,[RSP + 0x80]
CALL 0x001491d0
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0xa8],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0xb0],RAX
MOV RDI,qword ptr [RSP + 0xa8]
MOV RSI,qword ptr [RSP + 0xb0]
CALL 0x00122a00
CMP EAX,0x0
JZ 0x00164eec
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0x70]
MOV RDX,qword ptr [RSP + 0x78]
CALL 0x001229d0
MOV RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xd8],RAX
MOV RAX,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0xe0],RAX
JMP 0x00164fdd
LAB_00164eec:
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [RSP + 0x90]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x48],RAX
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x50],RAX
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0xc8]
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [RSP + 0xd0]
MOV qword ptr [RSP + 0x68],RAX
MOV RDI,qword ptr [RSP + 0xc0]
LEA RCX,[RSP + 0x30]
LEA RSI,[0x16c990]
MOV EDX,0x4
CALL 0x00122670
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0x70]
MOV RDX,qword ptr [RSP + 0x78]
CALL 0x001229d0
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x88]
CALL 0x001229d0
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0x90]
MOV RDX,qword ptr [RSP + 0x98]
CALL 0x001229d0
MOV RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xd8],RAX
MOV RAX,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0xe0],RAX
LAB_00164fdd:
MOV RAX,qword ptr [RSP + 0xd8]
MOV RDX,qword ptr [RSP + 0xe0]
ADD RSP,0xe8
RET
|
int1 [16] js_dynamic_import(int8 param_1,int8 param_2,int8 param_3)
{
int iVar1;
uint uStack_c4;
int8 local_b8;
int8 local_b0;
int8 local_a8;
int8 local_a0;
int1 local_98 [16];
int8 local_88;
int8 local_80;
int1 local_78 [16];
int8 local_68;
int8 local_60;
int8 local_58;
int8 local_50;
int1 local_40 [16];
int local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
local_2c = JS_GetScriptOrModuleName(param_1,0);
if (local_2c == 0) {
local_78._8_8_ = 2;
local_78._0_8_ = (ulong)uStack_c4 << 0x20;
}
else {
local_78 = JS_AtomToValue(local_28,local_2c);
}
JS_FreeAtom(local_28,local_2c);
iVar1 = JS_IsException(local_78._0_8_,local_78._8_8_);
local_40 = local_78;
if (iVar1 == 0) {
local_40 = JS_NewPromiseCapability(local_28,&local_68);
iVar1 = JS_IsException(local_40._0_8_,local_40._8_8_);
if (iVar1 == 0) {
local_b8 = local_68;
local_b0 = local_60;
local_a8 = local_58;
local_a0 = local_50;
local_88 = local_20;
local_80 = local_18;
local_98 = local_78;
JS_EnqueueJob(local_28,js_dynamic_import_job,4,&local_b8);
JS_FreeValue(local_28,local_78._0_8_,local_78._8_8_);
JS_FreeValue(local_28,local_68,local_60);
JS_FreeValue(local_28,local_58,local_50);
}
else {
JS_FreeValue(local_28,local_78._0_8_,local_78._8_8_);
}
}
return local_40;
}
| |
41,202 | my_time_init | eloqsql/mysys/my_getsystime.c | void my_time_init()
{
#ifdef _WIN32
compile_time_assert(sizeof(LARGE_INTEGER) ==
sizeof(query_performance_frequency));
QueryPerformanceFrequency((LARGE_INTEGER *)&query_performance_frequency);
DBUG_ASSERT(query_performance_frequency);
#endif
} | O0 | c | my_time_init:
pushq %rbp
movq %rsp, %rbp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_time_init:
push rbp
mov rbp, rsp
pop rbp
retn
| void my_time_init()
{
;
}
| my_time_init:
PUSH RBP
MOV RBP,RSP
POP RBP
RET
|
void my_time_init(void)
{
return;
}
| |
41,203 | my_time_init | eloqsql/mysys/my_getsystime.c | void my_time_init()
{
#ifdef _WIN32
compile_time_assert(sizeof(LARGE_INTEGER) ==
sizeof(query_performance_frequency));
QueryPerformanceFrequency((LARGE_INTEGER *)&query_performance_frequency);
DBUG_ASSERT(query_performance_frequency);
#endif
} | O3 | c | my_time_init:
pushq %rbp
movq %rsp, %rbp
popq %rbp
retq
| my_time_init:
push rbp
mov rbp, rsp
pop rbp
retn
| void my_time_init()
{
;
}
| my_time_init:
PUSH RBP
MOV RBP,RSP
POP RBP
RET
|
void my_time_init(void)
{
return;
}
| |
41,204 | dequantize_row_q5_0 | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c | void dequantize_row_q5_0(const block_q5_0 * restrict x, float * restrict y, int64_t k) {
static const int qk = QK5_0;
assert(k % qk == 0);
const int nb = k / qk;
for (int i = 0; i < nb; i++) {
const float d = GGML_FP16_TO_FP32(x[i].d);
uint32_t qh;
memcpy(&qh, x[i].qh, sizeof(qh));
for (int j = 0; j < qk/2; ++j) {
const uint8_t xh_0 = ((qh >> (j + 0)) << 4) & 0x10;
const uint8_t xh_1 = ((qh >> (j + 12)) ) & 0x10;
const int32_t x0 = ((x[i].qs[j] & 0x0F) | xh_0) - 16;
const int32_t x1 = ((x[i].qs[j] >> 4) | xh_1) - 16;
y[i*qk + j + 0 ] = x0*d;
y[i*qk + j + qk/2] = x1*d;
}
}
} | O1 | c | dequantize_row_q5_0:
pushq %r15
pushq %r14
pushq %rbx
testb $0x1f, %dl
jne 0x2e6bc
shrq $0x5, %rdx
testl %edx, %edx
jle 0x2e6b6
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
leaq 0x6(%rdi), %r8
addq $0x40, %rsi
xorl %r9d, %r9d
movq 0x3f981(%rip), %r10 # 0x6dfa8
leaq (%r9,%r9,4), %rax
leaq (%r9,%rax,4), %rax
addq %r9, %rax
movzwl (%rdi,%rax), %ecx
movss (%r10,%rcx,4), %xmm0
movl 0x2(%rdi,%rax), %r11d
xorl %eax, %eax
movl %r11d, %ebx
movl %eax, %ecx
shrl %cl, %ebx
shll $0x4, %ebx
leal 0xc(%rax), %ecx
movl %r11d, %r14d
shrl %cl, %r14d
andl $0x10, %ebx
andl $0x10, %r14d
movzbl (%r8,%rax), %ecx
movl %ecx, %r15d
andl $0xf, %r15d
addl %r15d, %ebx
addl $-0x10, %ebx
shrl $0x4, %ecx
addl %r14d, %ecx
addl $-0x10, %ecx
xorps %xmm1, %xmm1
cvtsi2ss %ebx, %xmm1
mulss %xmm0, %xmm1
movss %xmm1, -0x40(%rsi,%rax,4)
xorps %xmm1, %xmm1
cvtsi2ss %ecx, %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rsi,%rax,4)
incq %rax
cmpq $0x10, %rax
jne 0x2e643
incq %r9
addq $0x16, %r8
subq $-0x80, %rsi
cmpq %rdx, %r9
jne 0x2e627
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2d135(%rip), %rdi # 0x5b7f8
leaq 0x2d13a(%rip), %rsi # 0x5b804
leaq 0x2d42e(%rip), %rcx # 0x5baff
movl $0x12b, %edx # imm = 0x12B
callq 0x17b00
| dequantize_row_q5_0:
push r15
push r14
push rbx
test dl, 1Fh
jnz loc_2E6BC
shr rdx, 5
test edx, edx
jle loc_2E6B6
and edx, 7FFFFFFFh
lea r8, [rdi+6]
add rsi, 40h ; '@'
xor r9d, r9d
mov r10, cs:ggml_table_f32_f16_ptr
loc_2E627:
lea rax, [r9+r9*4]
lea rax, [r9+rax*4]
add rax, r9
movzx ecx, word ptr [rdi+rax]
movss xmm0, dword ptr [r10+rcx*4]
mov r11d, [rdi+rax+2]
xor eax, eax
loc_2E643:
mov ebx, r11d
mov ecx, eax
shr ebx, cl
shl ebx, 4
lea ecx, [rax+0Ch]
mov r14d, r11d
shr r14d, cl
and ebx, 10h
and r14d, 10h
movzx ecx, byte ptr [r8+rax]
mov r15d, ecx
and r15d, 0Fh
add ebx, r15d
add ebx, 0FFFFFFF0h
shr ecx, 4
add ecx, r14d
add ecx, 0FFFFFFF0h
xorps xmm1, xmm1
cvtsi2ss xmm1, ebx
mulss xmm1, xmm0
movss dword ptr [rsi+rax*4-40h], xmm1
xorps xmm1, xmm1
cvtsi2ss xmm1, ecx
mulss xmm1, xmm0
movss dword ptr [rsi+rax*4], xmm1
inc rax
cmp rax, 10h
jnz short loc_2E643
inc r9
add r8, 16h
sub rsi, 0FFFFFFFFFFFFFF80h
cmp r9, rdx
jnz loc_2E627
loc_2E6B6:
pop rbx
pop r14
pop r15
retn
loc_2E6BC:
lea rdi, aKQk0; "k % qk == 0"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidDequantize_1; "void dequantize_row_q5_0(const block_q5"...
mov edx, 12Bh
call ___assert_fail
| void dequantize_row_q5_0(long long a1, long long a2, unsigned long long a3)
{
unsigned long long v3; // rdx
long long v4; // rdx
long long v5; // r8
long long v6; // rsi
long long v7; // r9
float v8; // xmm0_4
unsigned int v9; // r11d
long long i; // rax
int v11; // ecx
if ( (a3 & 0x1F) != 0 )
__assert_fail(
"k % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c",
299LL,
"void dequantize_row_q5_0(const block_q5_0 *restrict, float *restrict, int64_t)");
v3 = a3 >> 5;
if ( (int)v3 > 0 )
{
v4 = v3 & 0x7FFFFFFF;
v5 = a1 + 6;
v6 = a2 + 64;
v7 = 0LL;
do
{
v8 = ggml_table_f32_f16[*(unsigned __int16 *)(a1 + 22 * v7)];
v9 = *(_DWORD *)(a1 + 22 * v7 + 2);
for ( i = 0LL; i != 16; ++i )
{
v11 = ((v9 >> (i + 12)) & 0x10) + (*(unsigned __int8 *)(v5 + i) >> 4) - 16;
*(float *)(v6 + 4 * i - 64) = (float)((*(_BYTE *)(v5 + i) & 0xF)
+ ((16 * (unsigned __int8)(v9 >> i)) & 0x10)
- 16)
* v8;
*(float *)(v6 + 4 * i) = (float)v11 * v8;
}
++v7;
v5 += 22LL;
v6 += 128LL;
}
while ( v7 != v4 );
}
}
| dequantize_row_q5_0:
PUSH R15
PUSH R14
PUSH RBX
TEST DL,0x1f
JNZ 0x0012e6bc
SHR RDX,0x5
TEST EDX,EDX
JLE 0x0012e6b6
AND EDX,0x7fffffff
LEA R8,[RDI + 0x6]
ADD RSI,0x40
XOR R9D,R9D
MOV R10,qword ptr [0x0016dfa8]
LAB_0012e627:
LEA RAX,[R9 + R9*0x4]
LEA RAX,[R9 + RAX*0x4]
ADD RAX,R9
MOVZX ECX,word ptr [RDI + RAX*0x1]
MOVSS XMM0,dword ptr [R10 + RCX*0x4]
MOV R11D,dword ptr [RDI + RAX*0x1 + 0x2]
XOR EAX,EAX
LAB_0012e643:
MOV EBX,R11D
MOV ECX,EAX
SHR EBX,CL
SHL EBX,0x4
LEA ECX,[RAX + 0xc]
MOV R14D,R11D
SHR R14D,CL
AND EBX,0x10
AND R14D,0x10
MOVZX ECX,byte ptr [R8 + RAX*0x1]
MOV R15D,ECX
AND R15D,0xf
ADD EBX,R15D
ADD EBX,-0x10
SHR ECX,0x4
ADD ECX,R14D
ADD ECX,-0x10
XORPS XMM1,XMM1
CVTSI2SS XMM1,EBX
MULSS XMM1,XMM0
MOVSS dword ptr [RSI + RAX*0x4 + -0x40],XMM1
XORPS XMM1,XMM1
CVTSI2SS XMM1,ECX
MULSS XMM1,XMM0
MOVSS dword ptr [RSI + RAX*0x4],XMM1
INC RAX
CMP RAX,0x10
JNZ 0x0012e643
INC R9
ADD R8,0x16
SUB RSI,-0x80
CMP R9,RDX
JNZ 0x0012e627
LAB_0012e6b6:
POP RBX
POP R14
POP R15
RET
LAB_0012e6bc:
LEA RDI,[0x15b7f8]
LEA RSI,[0x15b804]
LEA RCX,[0x15baff]
MOV EDX,0x12b
CALL 0x00117b00
|
void dequantize_row_q5_0(long param_1,long param_2,ulong param_3)
{
float fVar1;
byte bVar2;
uint uVar3;
int *puVar4;
long lVar5;
uint uVar6;
long lVar7;
ulong uVar8;
puVar4 = PTR_ggml_table_f32_f16_0016dfa8;
if ((param_3 & 0x1f) == 0) {
uVar6 = (uint)(param_3 >> 5);
if (0 < (int)uVar6) {
lVar7 = param_1 + 6;
param_2 = param_2 + 0x40;
uVar8 = 0;
do {
fVar1 = *(float *)(puVar4 + (ulong)*(ushort *)(param_1 + uVar8 * 0x16) * 4);
uVar3 = *(uint *)(param_1 + 2 + uVar8 * 0x16);
lVar5 = 0;
do {
bVar2 = *(byte *)(lVar7 + lVar5);
*(float *)(param_2 + -0x40 + lVar5 * 4) =
(float)(int)((uVar3 >> ((byte)lVar5 & 0x1f) & 1) * 0x10 + (bVar2 & 0xf) + -0x10) *
fVar1;
*(float *)(param_2 + lVar5 * 4) =
(float)(int)((uint)(bVar2 >> 4) + (uVar3 >> ((byte)lVar5 + 0xc & 0x1f) & 0x10) +
-0x10) * fVar1;
lVar5 = lVar5 + 1;
} while (lVar5 != 0x10);
uVar8 = uVar8 + 1;
lVar7 = lVar7 + 0x16;
param_2 = param_2 + 0x80;
} while (uVar8 != (uVar6 & 0x7fffffff));
}
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("k % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c"
,299,
"void dequantize_row_q5_0(const block_q5_0 *restrict, float *restrict, int64_t)");
}
| |
41,205 | dequantize_row_q5_0 | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c | void dequantize_row_q5_0(const block_q5_0 * restrict x, float * restrict y, int64_t k) {
static const int qk = QK5_0;
assert(k % qk == 0);
const int nb = k / qk;
for (int i = 0; i < nb; i++) {
const float d = GGML_FP16_TO_FP32(x[i].d);
uint32_t qh;
memcpy(&qh, x[i].qh, sizeof(qh));
for (int j = 0; j < qk/2; ++j) {
const uint8_t xh_0 = ((qh >> (j + 0)) << 4) & 0x10;
const uint8_t xh_1 = ((qh >> (j + 12)) ) & 0x10;
const int32_t x0 = ((x[i].qs[j] & 0x0F) | xh_0) - 16;
const int32_t x1 = ((x[i].qs[j] >> 4) | xh_1) - 16;
y[i*qk + j + 0 ] = x0*d;
y[i*qk + j + qk/2] = x1*d;
}
}
} | O3 | c | dequantize_row_q5_0:
pushq %rax
testb $0x1f, %dl
jne 0x2d4ec
shrq $0x5, %rdx
testl %edx, %edx
jle 0x2d4ea
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
leaq 0x6(%rdi), %rax
addq $0x40, %rsi
xorl %ecx, %ecx
movq 0x40c5a(%rip), %r8 # 0x6dfa8
movdqa 0x1ecea(%rip), %xmm1 # 0x4c040
movdqa 0x23bf2(%rip), %xmm2 # 0x50f50
movdqa 0x23c1a(%rip), %xmm3 # 0x50f80
pxor %xmm4, %xmm4
movdqa 0x23bee(%rip), %xmm5 # 0x50f60
movdqa 0x23c16(%rip), %xmm6 # 0x50f90
leaq (%rcx,%rcx,4), %r9
leaq (%rcx,%r9,4), %r9
addq %rcx, %r9
movzwl (%rdi,%r9), %r10d
movd 0x2(%rdi,%r9), %xmm7
pshufd $0x0, %xmm7, %xmm7 # xmm7 = xmm7[0,0,0,0]
movss (%r8,%r10,4), %xmm8
shufps $0x0, %xmm8, %xmm8 # xmm8 = xmm8[0,0,0,0]
xorl %r9d, %r9d
movdqa 0x1ec83(%rip), %xmm10 # 0x4c030
movdqa %xmm10, %xmm9
pshuflw $0xfe, %xmm9, %xmm11 # xmm11 = xmm9[2,3,3,3,4,5,6,7]
movdqa %xmm7, %xmm12
psrld %xmm11, %xmm12
pshuflw $0x54, %xmm9, %xmm13 # xmm13 = xmm9[0,1,1,1,4,5,6,7]
movdqa %xmm7, %xmm11
psrld %xmm13, %xmm11
pshufd $0xee, %xmm9, %xmm13 # xmm13 = xmm9[2,3,2,3]
pshuflw $0xfe, %xmm13, %xmm14 # xmm14 = xmm13[2,3,3,3,4,5,6,7]
movdqa %xmm7, %xmm15
psrld %xmm14, %xmm15
pshuflw $0x54, %xmm13, %xmm13 # xmm13 = xmm13[0,1,1,1,4,5,6,7]
movdqa %xmm7, %xmm14
psrld %xmm13, %xmm14
punpcklqdq %xmm12, %xmm11 # xmm11 = xmm11[0],xmm12[0]
punpckhqdq %xmm15, %xmm14 # xmm14 = xmm14[1],xmm15[1]
movdqa %xmm10, %xmm13
paddd %xmm3, %xmm13
pshuflw $0xfe, %xmm13, %xmm12 # xmm12 = xmm13[2,3,3,3,4,5,6,7]
movdqa %xmm7, %xmm15
psrld %xmm12, %xmm15
pshuflw $0x54, %xmm13, %xmm0 # xmm0 = xmm13[0,1,1,1,4,5,6,7]
movdqa %xmm7, %xmm12
psrld %xmm0, %xmm12
shufps $0xcc, %xmm14, %xmm11 # xmm11 = xmm11[0,3],xmm14[0,3]
pshufd $0xee, %xmm13, %xmm0 # xmm0 = xmm13[2,3,2,3]
pshuflw $0xfe, %xmm0, %xmm13 # xmm13 = xmm0[2,3,3,3,4,5,6,7]
movdqa %xmm7, %xmm14
psrld %xmm13, %xmm14
pshuflw $0x54, %xmm0, %xmm0 # xmm0 = xmm0[0,1,1,1,4,5,6,7]
movdqa %xmm7, %xmm13
psrld %xmm0, %xmm13
pslld $0x4, %xmm11
pand %xmm2, %xmm11
punpcklqdq %xmm15, %xmm12 # xmm12 = xmm12[0],xmm15[0]
punpckhqdq %xmm14, %xmm13 # xmm13 = xmm13[1],xmm14[1]
shufps $0xcc, %xmm13, %xmm12 # xmm12 = xmm12[0,3],xmm13[0,3]
andps %xmm2, %xmm12
movd (%rax,%r9), %xmm0
punpcklbw %xmm4, %xmm0 # xmm0 = xmm0[0],xmm4[0],xmm0[1],xmm4[1],xmm0[2],xmm4[2],xmm0[3],xmm4[3],xmm0[4],xmm4[4],xmm0[5],xmm4[5],xmm0[6],xmm4[6],xmm0[7],xmm4[7]
punpcklwd %xmm4, %xmm0 # xmm0 = xmm0[0],xmm4[0],xmm0[1],xmm4[1],xmm0[2],xmm4[2],xmm0[3],xmm4[3]
movdqa %xmm0, %xmm13
pand %xmm5, %xmm13
por %xmm11, %xmm13
paddd %xmm6, %xmm13
psrld $0x4, %xmm0
por %xmm12, %xmm0
paddd %xmm6, %xmm0
cvtdq2ps %xmm13, %xmm11
mulps %xmm8, %xmm11
movups %xmm11, -0x40(%rsi,%r9,4)
cvtdq2ps %xmm0, %xmm0
mulps %xmm8, %xmm0
movups %xmm0, (%rsi,%r9,4)
addq $0x4, %r9
paddd %xmm1, %xmm9
paddd %xmm1, %xmm10
cmpq $0x10, %r9
jne 0x2d3b2
incq %rcx
addq $0x16, %rax
subq $-0x80, %rsi
cmpq %rdx, %rcx
jne 0x2d37a
popq %rax
retq
leaq 0x2e7f5(%rip), %rdi # 0x5bce8
leaq 0x2e7fa(%rip), %rsi # 0x5bcf4
leaq 0x2eaee(%rip), %rcx # 0x5bfef
movl $0x12b, %edx # imm = 0x12B
callq 0x16b00
| dequantize_row_q5_0:
push rax
test dl, 1Fh
jnz loc_2D4EC
shr rdx, 5
test edx, edx
jle loc_2D4EA
and edx, 7FFFFFFFh
lea rax, [rdi+6]
add rsi, 40h ; '@'
xor ecx, ecx
mov r8, cs:ggml_table_f32_f16_ptr
movdqa xmm1, cs:xmmword_4C040
movdqa xmm2, cs:xmmword_50F50
movdqa xmm3, cs:xmmword_50F80
pxor xmm4, xmm4
movdqa xmm5, cs:xmmword_50F60
movdqa xmm6, cs:xmmword_50F90
loc_2D37A:
lea r9, [rcx+rcx*4]
lea r9, [rcx+r9*4]
add r9, rcx
movzx r10d, word ptr [rdi+r9]
movd xmm7, dword ptr [rdi+r9+2]
pshufd xmm7, xmm7, 0
movss xmm8, dword ptr [r8+r10*4]
shufps xmm8, xmm8, 0
xor r9d, r9d
movdqa xmm10, cs:xmmword_4C030
movdqa xmm9, xmm10
loc_2D3B2:
pshuflw xmm11, xmm9, 0FEh
movdqa xmm12, xmm7
psrld xmm12, xmm11
pshuflw xmm13, xmm9, 54h ; 'T'
movdqa xmm11, xmm7
psrld xmm11, xmm13
pshufd xmm13, xmm9, 0EEh
pshuflw xmm14, xmm13, 0FEh
movdqa xmm15, xmm7
psrld xmm15, xmm14
pshuflw xmm13, xmm13, 54h ; 'T'
movdqa xmm14, xmm7
psrld xmm14, xmm13
punpcklqdq xmm11, xmm12
punpckhqdq xmm14, xmm15
movdqa xmm13, xmm10
paddd xmm13, xmm3
pshuflw xmm12, xmm13, 0FEh
movdqa xmm15, xmm7
psrld xmm15, xmm12
pshuflw xmm0, xmm13, 54h ; 'T'
movdqa xmm12, xmm7
psrld xmm12, xmm0
shufps xmm11, xmm14, 0CCh
pshufd xmm0, xmm13, 0EEh
pshuflw xmm13, xmm0, 0FEh
movdqa xmm14, xmm7
psrld xmm14, xmm13
pshuflw xmm0, xmm0, 54h ; 'T'
movdqa xmm13, xmm7
psrld xmm13, xmm0
pslld xmm11, 4
pand xmm11, xmm2
punpcklqdq xmm12, xmm15
punpckhqdq xmm13, xmm14
shufps xmm12, xmm13, 0CCh
andps xmm12, xmm2
movd xmm0, dword ptr [rax+r9]
punpcklbw xmm0, xmm4
punpcklwd xmm0, xmm4
movdqa xmm13, xmm0
pand xmm13, xmm5
por xmm13, xmm11
paddd xmm13, xmm6
psrld xmm0, 4
por xmm0, xmm12
paddd xmm0, xmm6
cvtdq2ps xmm11, xmm13
mulps xmm11, xmm8
movups xmmword ptr [rsi+r9*4-40h], xmm11
cvtdq2ps xmm0, xmm0
mulps xmm0, xmm8
movups xmmword ptr [rsi+r9*4], xmm0
add r9, 4
paddd xmm9, xmm1
paddd xmm10, xmm1
cmp r9, 10h
jnz loc_2D3B2
inc rcx
add rax, 16h
sub rsi, 0FFFFFFFFFFFFFF80h
cmp rcx, rdx
jnz loc_2D37A
loc_2D4EA:
pop rax
retn
loc_2D4EC:
lea rdi, aKQk0; "k % qk == 0"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidDequantize_1; "void dequantize_row_q5_0(const block_q5"...
mov edx, 12Bh
call ___assert_fail
| void __spoils<rdx,rcx,r8,r9,r10,r11,xmm0,xmm4,xmm5> dequantize_row_q5_0(
long long a1,
long long a2,
unsigned long long a3)
{
unsigned long long v3; // rdx
long long v4; // rdx
long long v5; // rax
long long v6; // rsi
long long v7; // rcx
__m128i si128; // xmm1
__m128 v9; // xmm2
__m128i v10; // xmm3
__m128i v11; // xmm5
__m128i v12; // xmm6
__m128i v13; // xmm7
__m128 v14; // xmm8
long long v15; // r9
__m128i v16; // xmm10
__m128i v17; // xmm9
__m128i v18; // xmm13
__m128 v19; // xmm14
__m128i v20; // xmm13
__m128i v21; // xmm0
__m128i v22; // xmm12
__m128i v23; // xmm0
if ( (a3 & 0x1F) != 0 )
__assert_fail(
"k % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c",
299LL,
"void dequantize_row_q5_0(const block_q5_0 *restrict, float *restrict, int64_t)");
v3 = a3 >> 5;
if ( (int)v3 > 0 )
{
v4 = v3 & 0x7FFFFFFF;
v5 = a1 + 6;
v6 = a2 + 64;
v7 = 0LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_4C040);
v9 = (__m128)_mm_load_si128((const __m128i *)&xmmword_50F50);
v10 = _mm_load_si128((const __m128i *)&xmmword_50F80);
v11 = _mm_load_si128((const __m128i *)&xmmword_50F60);
v12 = _mm_load_si128((const __m128i *)&xmmword_50F90);
do
{
v13 = _mm_shuffle_epi32(_mm_cvtsi32_si128(*(_DWORD *)(a1 + 22 * v7 + 2)), 0);
v14 = _mm_shuffle_ps(
(__m128)LODWORD(ggml_table_f32_f16[*(unsigned __int16 *)(a1 + 22 * v7)]),
(__m128)LODWORD(ggml_table_f32_f16[*(unsigned __int16 *)(a1 + 22 * v7)]),
0);
v15 = 0LL;
v16 = _mm_load_si128((const __m128i *)&xmmword_4C030);
v17 = v16;
do
{
v18 = _mm_shuffle_epi32(v17, 238);
v19 = (__m128)_mm_unpackhi_epi64(
_mm_srl_epi32(v13, _mm_shufflelo_epi16(v18, 84)),
_mm_srl_epi32(v13, _mm_shufflelo_epi16(v18, 254)));
v20 = _mm_add_epi32(v16, v10);
v21 = _mm_shuffle_epi32(v20, 238);
v22 = (__m128i)_mm_and_ps(
_mm_shuffle_ps(
(__m128)_mm_unpacklo_epi64(
_mm_srl_epi32(v13, _mm_shufflelo_epi16(v20, 84)),
_mm_srl_epi32(v13, _mm_shufflelo_epi16(v20, 254))),
(__m128)_mm_unpackhi_epi64(
_mm_srl_epi32(v13, _mm_shufflelo_epi16(v21, 84)),
_mm_srl_epi32(v13, _mm_shufflelo_epi16(v21, 254))),
204),
v9);
v23 = _mm_unpacklo_epi16(
_mm_unpacklo_epi8(_mm_cvtsi32_si128(*(_DWORD *)(v5 + v15)), (__m128i)0LL),
(__m128i)0LL);
*(__m128 *)(v6 + 4 * v15 - 64) = _mm_mul_ps(
_mm_cvtepi32_ps(
_mm_add_epi32(
_mm_or_si128(
_mm_and_si128(v23, v11),
_mm_and_si128(
_mm_slli_epi32(
(__m128i)_mm_shuffle_ps(
(__m128)_mm_unpacklo_epi64(
_mm_srl_epi32(
v13,
_mm_shufflelo_epi16(v17, 84)),
_mm_srl_epi32(
v13,
_mm_shufflelo_epi16(v17, 254))),
v19,
204),
4u),
(__m128i)v9)),
v12)),
v14);
*(__m128 *)(v6 + 4 * v15) = _mm_mul_ps(
_mm_cvtepi32_ps(_mm_add_epi32(_mm_or_si128(_mm_srli_epi32(v23, 4u), v22), v12)),
v14);
v15 += 4LL;
v17 = _mm_add_epi32(v17, si128);
v16 = _mm_add_epi32(v16, si128);
}
while ( v15 != 16 );
++v7;
v5 += 22LL;
v6 += 128LL;
}
while ( v7 != v4 );
}
}
| dequantize_row_q5_0:
PUSH RAX
TEST DL,0x1f
JNZ 0x0012d4ec
SHR RDX,0x5
TEST EDX,EDX
JLE 0x0012d4ea
AND EDX,0x7fffffff
LEA RAX,[RDI + 0x6]
ADD RSI,0x40
XOR ECX,ECX
MOV R8,qword ptr [0x0016dfa8]
MOVDQA XMM1,xmmword ptr [0x0014c040]
MOVDQA XMM2,xmmword ptr [0x00150f50]
MOVDQA XMM3,xmmword ptr [0x00150f80]
PXOR XMM4,XMM4
MOVDQA XMM5,xmmword ptr [0x00150f60]
MOVDQA XMM6,xmmword ptr [0x00150f90]
LAB_0012d37a:
LEA R9,[RCX + RCX*0x4]
LEA R9,[RCX + R9*0x4]
ADD R9,RCX
MOVZX R10D,word ptr [RDI + R9*0x1]
MOVD XMM7,dword ptr [RDI + R9*0x1 + 0x2]
PSHUFD XMM7,XMM7,0x0
MOVSS XMM8,dword ptr [R8 + R10*0x4]
SHUFPS XMM8,XMM8,0x0
XOR R9D,R9D
MOVDQA XMM10,xmmword ptr [0x0014c030]
MOVDQA XMM9,XMM10
LAB_0012d3b2:
PSHUFLW XMM11,XMM9,0xfe
MOVDQA XMM12,XMM7
PSRLD XMM12,XMM11
PSHUFLW XMM13,XMM9,0x54
MOVDQA XMM11,XMM7
PSRLD XMM11,XMM13
PSHUFD XMM13,XMM9,0xee
PSHUFLW XMM14,XMM13,0xfe
MOVDQA XMM15,XMM7
PSRLD XMM15,XMM14
PSHUFLW XMM13,XMM13,0x54
MOVDQA XMM14,XMM7
PSRLD XMM14,XMM13
PUNPCKLQDQ XMM11,XMM12
PUNPCKHQDQ XMM14,XMM15
MOVDQA XMM13,XMM10
PADDD XMM13,XMM3
PSHUFLW XMM12,XMM13,0xfe
MOVDQA XMM15,XMM7
PSRLD XMM15,XMM12
PSHUFLW XMM0,XMM13,0x54
MOVDQA XMM12,XMM7
PSRLD XMM12,XMM0
SHUFPS XMM11,XMM14,0xcc
PSHUFD XMM0,XMM13,0xee
PSHUFLW XMM13,XMM0,0xfe
MOVDQA XMM14,XMM7
PSRLD XMM14,XMM13
PSHUFLW XMM0,XMM0,0x54
MOVDQA XMM13,XMM7
PSRLD XMM13,XMM0
PSLLD XMM11,0x4
PAND XMM11,XMM2
PUNPCKLQDQ XMM12,XMM15
PUNPCKHQDQ XMM13,XMM14
SHUFPS XMM12,XMM13,0xcc
ANDPS XMM12,XMM2
MOVD XMM0,dword ptr [RAX + R9*0x1]
PUNPCKLBW XMM0,XMM4
PUNPCKLWD XMM0,XMM4
MOVDQA XMM13,XMM0
PAND XMM13,XMM5
POR XMM13,XMM11
PADDD XMM13,XMM6
PSRLD XMM0,0x4
POR XMM0,XMM12
PADDD XMM0,XMM6
CVTDQ2PS XMM11,XMM13
MULPS XMM11,XMM8
MOVUPS xmmword ptr [RSI + R9*0x4 + -0x40],XMM11
CVTDQ2PS XMM0,XMM0
MULPS XMM0,XMM8
MOVUPS xmmword ptr [RSI + R9*0x4],XMM0
ADD R9,0x4
PADDD XMM9,XMM1
PADDD XMM10,XMM1
CMP R9,0x10
JNZ 0x0012d3b2
INC RCX
ADD RAX,0x16
SUB RSI,-0x80
CMP RCX,RDX
JNZ 0x0012d37a
LAB_0012d4ea:
POP RAX
RET
LAB_0012d4ec:
LEA RDI,[0x15bce8]
LEA RSI,[0x15bcf4]
LEA RCX,[0x15bfef]
MOV EDX,0x12b
CALL 0x00116b00
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 dequantize_row_q5_0(long param_1,long param_2,ulong param_3)
{
float fVar1;
uint uVar2;
uint uVar3;
int1 auVar4 [13];
uint5 uVar5;
unkbyte9 Var6;
int1 auVar7 [13];
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int1 auVar12 [16];
int1 auVar13 [16];
int iVar14;
int iVar15;
int iVar16;
int iVar17;
int iVar18;
int iVar19;
int iVar20;
int iVar21;
int *puVar22;
int8 in_RAX;
long lVar23;
ulong uVar24;
uint uVar25;
long lVar26;
int1 in_XMM0 [16];
int1 auVar27 [16];
int iVar29;
int iVar30;
int iVar31;
int1 auVar28 [16];
int1 auVar32 [16];
long lVar33;
int1 in_XMM11 [16];
int1 auVar34 [16];
int1 auVar35 [16];
int1 auVar36 [16];
int1 in_XMM13 [16];
int1 auVar37 [16];
int1 auVar38 [16];
int1 auVar39 [16];
int1 auVar40 [16];
int1 in_XMM14 [16];
int1 auVar44 [16];
int iVar41;
int iVar42;
int iVar43;
puVar22 = PTR_ggml_table_f32_f16_0016dfa8;
iVar21 = _UNK_00150f9c;
iVar20 = _UNK_00150f98;
iVar19 = _UNK_00150f94;
iVar18 = _DAT_00150f90;
iVar17 = _UNK_00150f8c;
iVar16 = _UNK_00150f88;
iVar15 = _UNK_00150f84;
iVar14 = _DAT_00150f80;
auVar13 = _DAT_00150f60;
auVar12 = _DAT_00150f50;
iVar11 = _UNK_0014c04c;
iVar10 = _UNK_0014c048;
iVar9 = _UNK_0014c044;
iVar8 = _DAT_0014c040;
if ((param_3 & 0x1f) == 0) {
uVar25 = (uint)(param_3 >> 5);
if (0 < (int)uVar25) {
lVar23 = param_1 + 6;
param_2 = param_2 + 0x40;
uVar24 = 0;
do {
uVar2 = *(uint *)(param_1 + 2 + uVar24 * 0x16);
fVar1 = *(float *)(puVar22 + (ulong)*(ushort *)(param_1 + uVar24 * 0x16) * 4);
lVar26 = 0;
auVar28 = _DAT_0014c030;
auVar32 = _DAT_0014c030;
do {
auVar34 = pshuflw(in_XMM11,auVar28,0xfe);
lVar33 = auVar34._0_8_;
auVar35._0_4_ = uVar2 >> lVar33;
auVar35._4_4_ = uVar2 >> lVar33;
auVar35._8_4_ = uVar2 >> lVar33;
auVar35._12_4_ = uVar2 >> lVar33;
auVar37 = pshuflw(in_XMM13,auVar28,0x54);
iVar29 = auVar28._4_4_;
iVar30 = auVar28._8_4_;
iVar31 = auVar28._12_4_;
auVar34._0_8_ = auVar28._8_8_;
auVar34._8_4_ = iVar30;
auVar34._12_4_ = iVar31;
auVar44 = pshuflw(in_XMM14,auVar34,0xfe);
auVar38 = pshuflw(auVar34,auVar34,0x54);
auVar39._0_4_ = auVar32._0_4_ + iVar14;
iVar41 = auVar32._4_4_;
auVar39._4_4_ = iVar41 + iVar15;
iVar42 = auVar32._8_4_;
iVar43 = auVar32._12_4_;
auVar39._8_4_ = iVar42 + iVar16;
auVar39._12_4_ = iVar43 + iVar17;
auVar36 = pshuflw(auVar35,auVar39,0xfe);
auVar34 = pshuflw(in_XMM0,auVar39,0x54);
auVar27._4_4_ = auVar39._12_4_;
auVar27._0_4_ = auVar39._8_4_;
auVar27._8_4_ = auVar39._8_4_;
auVar27._12_4_ = auVar39._12_4_;
auVar40 = pshuflw(auVar39,auVar27,0xfe);
lVar33 = auVar40._0_8_;
in_XMM14._0_4_ = uVar2 >> lVar33;
in_XMM14._4_4_ = uVar2 >> lVar33;
in_XMM14._8_4_ = uVar2 >> lVar33;
in_XMM14._12_4_ = uVar2 >> lVar33;
auVar27 = pshuflw(auVar27,auVar27,0x54);
auVar40._0_4_ = (uVar2 >> auVar37._0_8_) << 4;
auVar40._4_4_ = auVar35._4_4_ << 4;
auVar40._8_4_ = (uVar2 >> auVar38._0_8_) << 4;
auVar40._12_4_ = (uVar2 >> auVar44._0_8_) << 4;
uVar3 = *(uint *)(lVar23 + lVar26);
auVar4[0xc] = (char)(uVar3 >> 0x18);
auVar4._0_12_ = ZEXT712(0);
uVar5 = CONCAT32(auVar4._10_3_,(ushort)(byte)(uVar3 >> 0x10));
auVar7._5_8_ = 0;
auVar7._0_5_ = uVar5;
Var6 = CONCAT72(SUB137(auVar7 << 0x40,6),(ushort)(byte)(uVar3 >> 8));
auVar37._0_4_ = uVar3 & 0xff;
auVar37._4_9_ = Var6;
auVar37._13_3_ = 0;
auVar37 = auVar37 & auVar13 | auVar40 & auVar12;
in_XMM13._0_4_ = auVar37._0_4_ + iVar18;
in_XMM13._4_4_ = auVar37._4_4_ + iVar19;
in_XMM13._8_4_ = auVar37._8_4_ + iVar20;
in_XMM13._12_4_ = auVar37._12_4_ + iVar21;
in_XMM11._0_4_ = (float)in_XMM13._0_4_ * fVar1;
in_XMM11._4_4_ = (float)in_XMM13._4_4_ * fVar1;
in_XMM11._8_4_ = (float)in_XMM13._8_4_ * fVar1;
in_XMM11._12_4_ = (float)in_XMM13._12_4_ * fVar1;
*(int1 (*) [16])(param_2 + -0x40 + lVar26 * 4) = in_XMM11;
in_XMM0._0_4_ =
(float)(int)((uVar3 >> 4 & 0xf | uVar2 >> auVar34._0_8_ & auVar12._0_4_) + iVar18) *
fVar1;
in_XMM0._4_4_ =
(float)(int)(((uint)Var6 >> 4 | uVar2 >> auVar36._0_8_ & auVar12._4_4_) + iVar19) *
fVar1;
in_XMM0._8_4_ =
(float)(int)(((uint)uVar5 >> 4 | uVar2 >> auVar27._0_8_ & auVar12._8_4_) + iVar20) *
fVar1;
in_XMM0._12_4_ =
(float)(int)(((uint)(uint3)(auVar4._10_3_ >> 0x14) | in_XMM14._12_4_ & auVar12._12_4_
) + iVar21) * fVar1;
*(int1 (*) [16])(param_2 + lVar26 * 4) = in_XMM0;
lVar26 = lVar26 + 4;
auVar28._0_4_ = auVar28._0_4_ + iVar8;
auVar28._4_4_ = iVar29 + iVar9;
auVar28._8_4_ = iVar30 + iVar10;
auVar28._12_4_ = iVar31 + iVar11;
auVar32._0_4_ = auVar32._0_4_ + iVar8;
auVar32._4_4_ = iVar41 + iVar9;
auVar32._8_4_ = iVar42 + iVar10;
auVar32._12_4_ = iVar43 + iVar11;
} while (lVar26 != 0x10);
uVar24 = uVar24 + 1;
lVar23 = lVar23 + 0x16;
param_2 = param_2 + 0x80;
} while (uVar24 != (uVar25 & 0x7fffffff));
}
return in_RAX;
}
/* WARNING: Subroutine does not return */
__assert_fail("k % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c"
,299,
"void dequantize_row_q5_0(const block_q5_0 *restrict, float *restrict, int64_t)");
}
| |
41,206 | google::protobuf::DescriptorBuilder::CrossLinkEnum(google::protobuf::EnumDescriptor*, google::protobuf::EnumDescriptorProto const&) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc | void DescriptorBuilder::CrossLinkEnum(EnumDescriptor* enum_type,
const EnumDescriptorProto& proto) {
if (enum_type->options_ == nullptr) {
enum_type->options_ = &EnumOptions::default_instance();
}
for (int i = 0; i < enum_type->value_count(); i++) {
CrossLinkEnumValue(&enum_type->values_[i], proto.value(i));
}
} | O3 | cpp | google::protobuf::DescriptorBuilder::CrossLinkEnum(google::protobuf::EnumDescriptor*, google::protobuf::EnumDescriptorProto const&):
cmpq $0x0, 0x20(%rsi)
jne 0xd76e6
leaq 0x13a9a6(%rip), %rax # 0x212088
movq %rax, 0x20(%rsi)
movslq 0x4(%rsi), %rax
testq %rax, %rax
jle 0xd7716
movq 0x28(%rsi), %rcx
shlq $0x5, %rax
xorl %edx, %edx
leaq 0x13a9d8(%rip), %rsi # 0x2120d8
cmpq $0x0, 0x18(%rcx,%rdx)
jne 0xd770d
movq %rsi, 0x18(%rcx,%rdx)
addq $0x20, %rdx
cmpq %rdx, %rax
jne 0xd7700
retq
nop
| _ZN6google8protobuf17DescriptorBuilder13CrossLinkEnumEPNS0_14EnumDescriptorERKNS0_19EnumDescriptorProtoE:
cmp qword ptr [rsi+20h], 0
jnz short loc_D76E6
lea rax, _ZN6google8protobuf30_EnumOptions_default_instance_E; google::protobuf::_EnumOptions_default_instance_
mov [rsi+20h], rax
loc_D76E6:
movsxd rax, dword ptr [rsi+4]
test rax, rax
jle short locret_D7716
mov rcx, [rsi+28h]
shl rax, 5
xor edx, edx
lea rsi, _ZN6google8protobuf35_EnumValueOptions_default_instance_E; google::protobuf::_EnumValueOptions_default_instance_
loc_D7700:
cmp qword ptr [rcx+rdx+18h], 0
jnz short loc_D770D
mov [rcx+rdx+18h], rsi
loc_D770D:
add rdx, 20h ; ' '
cmp rax, rdx
jnz short loc_D7700
locret_D7716:
retn
| long long google::protobuf::DescriptorBuilder::CrossLinkEnum(
google::protobuf::DescriptorBuilder *this,
google::protobuf::EnumDescriptor *a2,
const google::protobuf::EnumDescriptorProto *a3)
{
long long result; // rax
long long v4; // rcx
long long v5; // rdx
if ( !*((_QWORD *)a2 + 4) )
*((_QWORD *)a2 + 4) = &google::protobuf::_EnumOptions_default_instance_;
result = *((int *)a2 + 1);
if ( result > 0 )
{
v4 = *((_QWORD *)a2 + 5);
result *= 32LL;
v5 = 0LL;
do
{
if ( !*(_QWORD *)(v4 + v5 + 24) )
*(_QWORD *)(v4 + v5 + 24) = &google::protobuf::_EnumValueOptions_default_instance_;
v5 += 32LL;
}
while ( result != v5 );
}
return result;
}
| CrossLinkEnum:
CMP qword ptr [RSI + 0x20],0x0
JNZ 0x001d76e6
LEA RAX,[0x312088]
MOV qword ptr [RSI + 0x20],RAX
LAB_001d76e6:
MOVSXD RAX,dword ptr [RSI + 0x4]
TEST RAX,RAX
JLE 0x001d7716
MOV RCX,qword ptr [RSI + 0x28]
SHL RAX,0x5
XOR EDX,EDX
LEA RSI,[0x3120d8]
LAB_001d7700:
CMP qword ptr [RCX + RDX*0x1 + 0x18],0x0
JNZ 0x001d770d
MOV qword ptr [RCX + RDX*0x1 + 0x18],RSI
LAB_001d770d:
ADD RDX,0x20
CMP RAX,RDX
JNZ 0x001d7700
LAB_001d7716:
RET
|
/* google::protobuf::DescriptorBuilder::CrossLinkEnum(google::protobuf::EnumDescriptor*,
google::protobuf::EnumDescriptorProto const&) */
void google::protobuf::DescriptorBuilder::CrossLinkEnum
(EnumDescriptor *param_1,EnumDescriptorProto *param_2)
{
int iVar1;
long lVar2;
long lVar3;
if (*(long *)(param_2 + 0x20) == 0) {
*(int1 **)(param_2 + 0x20) = _EnumOptions_default_instance_;
}
iVar1 = *(int *)(param_2 + 4);
if (0 < (long)iVar1) {
lVar2 = *(long *)(param_2 + 0x28);
lVar3 = 0;
do {
if (*(long *)(lVar2 + 0x18 + lVar3) == 0) {
*(int1 **)(lVar2 + 0x18 + lVar3) = _EnumValueOptions_default_instance_;
}
lVar3 = lVar3 + 0x20;
} while ((long)iVar1 * 0x20 != lVar3);
}
return;
}
| |
41,207 | my_hash_sort_utf32_nopad | eloqsql/strings/ctype-ucs2.c | static void
my_hash_sort_utf32_nopad(CHARSET_INFO *cs, const uchar *s, size_t slen,
ulong *nr1, ulong *nr2)
{
my_wc_t wc;
int res;
const uchar *e= s + slen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
register ulong m1= *nr1, m2= *nr2;
while ((res= my_utf32_uni(cs, &wc, (uchar*) s, (uchar*) e)) > 0)
{
my_tosort_utf32(uni_plane, &wc);
MY_HASH_ADD(m1, m2, (uint) (wc >> 24));
MY_HASH_ADD(m1, m2, (uint) (wc >> 16) & 0xFF);
MY_HASH_ADD(m1, m2, (uint) (wc >> 8) & 0xFF);
MY_HASH_ADD(m1, m2, (uint) (wc & 0xFF));
s+= res;
}
*nr1= m1;
*nr2= m2;
} | O0 | c | my_hash_sort_utf32_nopad:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq 0x5dce0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jle 0x62dd7
movq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x62e00
movq -0x50(%rbp), %rax
andq $0x3f, %rax
addq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
shrq $0x18, %rcx
movl %ecx, %ecx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x58(%rbp)
jmp 0x62d03
movq -0x50(%rbp), %rax
andq $0x3f, %rax
addq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
shrq $0x10, %rcx
andl $0xff, %ecx
movl %ecx, %ecx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x58(%rbp)
jmp 0x62d44
movq -0x50(%rbp), %rax
andq $0x3f, %rax
addq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
shrq $0x8, %rcx
andl $0xff, %ecx
movl %ecx, %ecx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x58(%rbp)
jmp 0x62d85
movq -0x50(%rbp), %rax
andq $0x3f, %rax
addq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
andq $0xff, %rcx
movl %ecx, %ecx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x58(%rbp)
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x62c9a
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x58(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_hash_sort_utf32_nopad:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_48], rax
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_50], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_58], rax
loc_62C9A:
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_40]
lea rsi, [rbp+var_30]
call my_utf32_uni
mov [rbp+var_34], eax
cmp eax, 0
jle loc_62DD7
mov rdi, [rbp+var_48]
lea rsi, [rbp+var_30]
call my_tosort_utf32
mov rax, [rbp+var_50]
and rax, 3Fh
add rax, [rbp+var_58]
mov rcx, [rbp+var_30]
shr rcx, 18h
mov ecx, ecx
imul rax, rcx
mov rcx, [rbp+var_50]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
add rax, 3
mov [rbp+var_58], rax
jmp short $+2
loc_62D03:
mov rax, [rbp+var_50]
and rax, 3Fh
add rax, [rbp+var_58]
mov rcx, [rbp+var_30]
shr rcx, 10h
and ecx, 0FFh
mov ecx, ecx
imul rax, rcx
mov rcx, [rbp+var_50]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
add rax, 3
mov [rbp+var_58], rax
jmp short $+2
loc_62D44:
mov rax, [rbp+var_50]
and rax, 3Fh
add rax, [rbp+var_58]
mov rcx, [rbp+var_30]
shr rcx, 8
and ecx, 0FFh
mov ecx, ecx
imul rax, rcx
mov rcx, [rbp+var_50]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
add rax, 3
mov [rbp+var_58], rax
jmp short $+2
loc_62D85:
mov rax, [rbp+var_50]
and rax, 3Fh
add rax, [rbp+var_58]
mov rcx, [rbp+var_30]
and rcx, 0FFh
mov ecx, ecx
imul rax, rcx
mov rcx, [rbp+var_50]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
add rax, 3
mov [rbp+var_58], rax
mov ecx, [rbp+var_34]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
jmp loc_62C9A
loc_62DD7:
mov rcx, [rbp+var_50]
mov rax, [rbp+var_20]
mov [rax], rcx
mov rcx, [rbp+var_58]
mov rax, [rbp+var_28]
mov [rax], rcx
add rsp, 60h
pop rbp
retn
| _QWORD * my_hash_sort_utf32_nopad(long long a1, long long a2, long long a3, long long *a4, _QWORD *a5, long long a6)
{
_QWORD *result; // rax
long long v7; // [rsp+8h] [rbp-58h]
long long v8; // [rsp+8h] [rbp-58h]
long long v9; // [rsp+10h] [rbp-50h]
long long v10; // [rsp+10h] [rbp-50h]
long long v11; // [rsp+10h] [rbp-50h]
long long v12; // [rsp+10h] [rbp-50h]
long long v13; // [rsp+18h] [rbp-48h]
long long v14; // [rsp+20h] [rbp-40h]
int v15; // [rsp+2Ch] [rbp-34h]
unsigned long long v16; // [rsp+30h] [rbp-30h] BYREF
_QWORD *v17; // [rsp+38h] [rbp-28h]
long long *v18; // [rsp+40h] [rbp-20h]
long long v19; // [rsp+48h] [rbp-18h]
long long v20; // [rsp+50h] [rbp-10h]
long long v21; // [rsp+58h] [rbp-8h]
v21 = a1;
v20 = a2;
v19 = a3;
v18 = a4;
v17 = a5;
v14 = a3 + a2;
v13 = *(_QWORD *)(a1 + 120);
v9 = *a4;
v7 = *a5;
while ( 1 )
{
v15 = my_utf32_uni(v21, (long long)&v16, v20, v14, (long long)a5, a6);
if ( v15 <= 0 )
break;
my_tosort_utf32(v13, &v16);
v10 = v9 ^ ((v9 << 8) + (unsigned int)(v16 >> 24) * (v7 + (v9 & 0x3F)));
v8 = v7 + 3;
v11 = v10 ^ ((v10 << 8) + BYTE2(v16) * (v8 + (v10 & 0x3F)));
v8 += 3LL;
v12 = v11 ^ ((v11 << 8) + BYTE1(v16) * (v8 + (v11 & 0x3F)));
v8 += 3LL;
v9 = v12 ^ ((v12 << 8) + (unsigned __int8)v16 * (v8 + (v12 & 0x3F)));
v7 = v8 + 3;
v20 += v15;
}
*v18 = v9;
result = v17;
*v17 = v7;
return result;
}
| my_hash_sort_utf32_nopad:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
LAB_00162c9a:
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x30]
CALL 0x0015dce0
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
JLE 0x00162dd7
MOV RDI,qword ptr [RBP + -0x48]
LEA RSI,[RBP + -0x30]
CALL 0x00162e00
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x30]
SHR RCX,0x18
MOV ECX,ECX
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
JMP 0x00162d03
LAB_00162d03:
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x30]
SHR RCX,0x10
AND ECX,0xff
MOV ECX,ECX
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
JMP 0x00162d44
LAB_00162d44:
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x30]
SHR RCX,0x8
AND ECX,0xff
MOV ECX,ECX
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
JMP 0x00162d85
LAB_00162d85:
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x30]
AND RCX,0xff
MOV ECX,ECX
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00162c9a
LAB_00162dd7:
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
ADD RSP,0x60
POP RBP
RET
|
void my_hash_sort_utf32_nopad(long param_1,long param_2,long param_3,ulong *param_4,long *param_5)
{
int8 uVar1;
int iVar2;
long local_60;
ulong local_58;
ulong local_38;
long *local_30;
ulong *local_28;
long local_20;
long local_18;
long local_10;
uVar1 = *(int8 *)(param_1 + 0x78);
local_58 = *param_4;
local_60 = *param_5;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
iVar2 = my_utf32_uni(local_10,&local_38,local_18,param_2 + param_3);
if (iVar2 < 1) break;
my_tosort_utf32(uVar1,&local_38);
local_58 = ((local_58 & 0x3f) + local_60) * (local_38 >> 0x18 & 0xffffffff) + local_58 * 0x100 ^
local_58;
local_58 = ((local_58 & 0x3f) + local_60 + 3) * (ulong)((uint)(local_38 >> 0x10) & 0xff) +
local_58 * 0x100 ^ local_58;
local_58 = ((local_58 & 0x3f) + local_60 + 6) * (ulong)((uint)(local_38 >> 8) & 0xff) +
local_58 * 0x100 ^ local_58;
local_58 = ((local_58 & 0x3f) + local_60 + 9) * (ulong)((uint)local_38 & 0xff) +
local_58 * 0x100 ^ local_58;
local_60 = local_60 + 0xc;
local_18 = local_18 + iVar2;
}
*local_28 = local_58;
*local_30 = local_60;
return;
}
| |
41,208 | CLI::detail::checkParentSegments(std::vector<CLI::ConfigItem, std::allocator<CLI::ConfigItem>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char) | MikePodsytnik[P]TCRtrie/build_O1/_deps/cli11-src/include/CLI/impl/Config_inl.hpp | CLI11_INLINE void
checkParentSegments(std::vector<ConfigItem> &output, const std::string ¤tSection, char parentSeparator) {
std::string estring;
auto parents = detail::generate_parents(currentSection, estring, parentSeparator);
if(!output.empty() && output.back().name == "--") {
std::size_t msize = (parents.size() > 1U) ? parents.size() : 2;
while(output.back().parents.size() >= msize) {
output.push_back(output.back());
output.back().parents.pop_back();
}
if(parents.size() > 1) {
std::size_t common = 0;
std::size_t mpair = (std::min)(output.back().parents.size(), parents.size() - 1);
for(std::size_t ii = 0; ii < mpair; ++ii) {
if(output.back().parents[ii] != parents[ii]) {
break;
}
++common;
}
if(common == mpair) {
output.pop_back();
} else {
while(output.back().parents.size() > common + 1) {
output.push_back(output.back());
output.back().parents.pop_back();
}
}
for(std::size_t ii = common; ii < parents.size() - 1; ++ii) {
output.emplace_back();
output.back().parents.assign(parents.begin(), parents.begin() + static_cast<std::ptrdiff_t>(ii) + 1);
output.back().name = "++";
}
}
} else if(parents.size() > 1) {
for(std::size_t ii = 0; ii < parents.size() - 1; ++ii) {
output.emplace_back();
output.back().parents.assign(parents.begin(), parents.begin() + static_cast<std::ptrdiff_t>(ii) + 1);
output.back().name = "++";
}
}
// insert a section end which is just an empty items_buffer
output.emplace_back();
output.back().parents = std::move(parents);
output.back().name = "++";
} | O1 | cpp | CLI::detail::checkParentSegments(std::vector<CLI::ConfigItem, std::allocator<CLI::ConfigItem>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %ecx
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq %rsp, %rdi
leaq 0x18(%rsp), %rdx
callq 0x2a4c1
movq 0x8(%rbx), %rdi
cmpq %rdi, (%rbx)
je 0x2a868
addq $-0x38, %rdi
leaq 0xcc6b(%rip), %rsi # 0x374c6
callq 0x7130
testl %eax, %eax
je 0x2a8f8
movq 0x8(%rsp), %rax
subq (%rsp), %rax
cmpq $0x21, %rax
jb 0x2aad6
movq 0x8(%rsp), %rax
subq (%rsp), %rax
cmpq $0x20, %rax
je 0x2aad6
movl $0x20, %r12d
xorl %r13d, %r13d
leaq 0xd063(%rip), %r14 # 0x37901
movq %rbx, %rdi
callq 0x2a46a
movq 0x8(%rbx), %rdi
addq $-0x50, %rdi
movq (%rsp), %rsi
leaq (%rsi,%r12), %rdx
callq 0x2b64e
movq 0x8(%rbx), %rdi
movq -0x30(%rdi), %rdx
addq $-0x38, %rdi
movl $0x2, %r8d
xorl %esi, %esi
movq %r14, %rcx
callq 0x7660
incq %r13
movq 0x8(%rsp), %rax
subq (%rsp), %rax
sarq $0x5, %rax
decq %rax
addq $0x20, %r12
cmpq %rax, %r13
jb 0x2a89e
jmp 0x2aad6
movq 0x8(%rsp), %rax
subq (%rsp), %rax
sarq $0x5, %rax
cmpq $0x3, %rax
movl $0x2, %r12d
cmovaeq %rax, %r12
movq 0x8(%rbx), %rax
leaq -0x50(%rax), %r14
movq -0x50(%rax), %r13
movq -0x48(%rax), %rax
subq %r13, %rax
sarq $0x5, %rax
cmpq %r12, %rax
jb 0x2a964
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2b3a6
movq 0x8(%rbx), %rcx
movq -0x48(%rcx), %rax
leaq -0x20(%rax), %rdx
movq %rdx, -0x48(%rcx)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0x2a913
movq (%rax), %rsi
incq %rsi
callq 0x7430
jmp 0x2a913
movq (%rsp), %rbp
movq 0x8(%rsp), %rsi
subq %rbp, %rsi
sarq $0x5, %rsi
cmpq $0x2, %rsi
jb 0x2aad6
decq %rsi
cmpq %rax, %rsi
cmovaeq %rax, %rsi
testq %rsi, %rsi
je 0x2a9da
movl $0x8, %r15d
xorl %r12d, %r12d
movq %rsi, 0x38(%rsp)
movq (%r13,%r15), %rdx
cmpq (%rbp,%r15), %rdx
jne 0x2a9d3
testq %rdx, %rdx
je 0x2a9c4
movq -0x8(%rbp,%r15), %rsi
movq -0x8(%r13,%r15), %rdi
callq 0x7450
movq 0x38(%rsp), %rsi
testl %eax, %eax
jne 0x2a9d3
incq %r12
addq $0x20, %r15
cmpq %r12, %rsi
jne 0x2a99b
movq %rsi, %r12
leaq 0x28(%rsp), %r15
jmp 0x2a9dd
xorl %r12d, %r12d
cmpq %rsi, %r12
jne 0x2a9f3
movq %r14, 0x8(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2b620
jmp 0x2aa5a
leaq 0x1(%r12), %r14
movq 0x8(%rbx), %rsi
movq -0x48(%rsi), %rax
subq -0x50(%rsi), %rax
sarq $0x5, %rax
cmpq %r14, %rax
jbe 0x2aa5a
addq $-0x50, %rsi
movq %rbx, %rdi
callq 0x2b3a6
movq 0x8(%rbx), %rcx
movq -0x48(%rcx), %rax
leaq -0x20(%rax), %rdx
movq %rdx, -0x48(%rcx)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0x2aa41
movq (%rax), %rsi
incq %rsi
callq 0x7430
movq 0x8(%rbx), %rax
leaq -0x50(%rax), %rsi
movq -0x48(%rax), %rcx
subq -0x50(%rax), %rcx
sarq $0x5, %rcx
cmpq %r14, %rcx
ja 0x2aa11
movq 0x8(%rsp), %rax
subq (%rsp), %rax
sarq $0x5, %rax
decq %rax
cmpq %rax, %r12
jae 0x2aad6
movq %r12, %r13
shlq $0x5, %r13
addq $0x20, %r13
leaq 0xce80(%rip), %r14 # 0x37901
movq %rbx, %rdi
callq 0x2a46a
movq 0x8(%rbx), %rdi
addq $-0x50, %rdi
movq (%rsp), %rsi
leaq (%rsi,%r13), %rdx
callq 0x2b64e
movq 0x8(%rbx), %rdi
movq -0x30(%rdi), %rdx
addq $-0x38, %rdi
movl $0x2, %r8d
xorl %esi, %esi
movq %r14, %rcx
callq 0x7660
incq %r12
movq 0x8(%rsp), %rax
subq (%rsp), %rax
sarq $0x5, %rax
decq %rax
addq $0x20, %r13
cmpq %rax, %r12
jb 0x2aa81
movq %rbx, %rdi
callq 0x2a46a
movq 0x8(%rbx), %rax
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq -0x50(%rax), %rcx
movups -0x48(%rax), %xmm0
movq (%rsp), %rdx
movq %rdx, -0x50(%rax)
movq 0x8(%rsp), %rdx
movq %rdx, -0x48(%rax)
movq 0x10(%rsp), %rdx
movq %rdx, -0x40(%rax)
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
movq %rcx, (%rdi)
movups %xmm0, 0x8(%rdi)
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
callq 0xaf62
movq 0x8(%rbx), %rdi
movq -0x30(%rdi), %rdx
addq $-0x38, %rdi
leaq 0xcdb2(%rip), %rcx # 0x37901
movl $0x2, %r8d
xorl %esi, %esi
callq 0x7660
movq %rsp, %rdi
callq 0xaf62
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x2ab7b
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x7430
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2ab9b
movq %rax, %rbx
jmp 0x2aba6
jmp 0x2ab9b
jmp 0x2ab9b
jmp 0x2ab9b
jmp 0x2ab9b
jmp 0x2ab9b
movq %rax, %rbx
movq %rsp, %rdi
callq 0xaf62
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x2abbd
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x7430
movq %rbx, %rdi
callq 0x7780
| _ZN3CLI6detail19checkParentSegmentsERSt6vectorINS_10ConfigItemESaIS2_EERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEc:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov ecx, edx
mov rbx, rdi
lea r15, [rsp+88h+var_60]
mov [r15-10h], r15
mov qword ptr [r15-8], 0
mov byte ptr [r15], 0
mov rdi, rsp; int
lea rdx, [rsp+88h+var_70]; int
call _ZN3CLI6detail16generate_parentsERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERS6_c; CLI::detail::generate_parents(std::string const&,std::string&,char)
mov rdi, [rbx+8]
cmp [rbx], rdi
jz short loc_2A868
add rdi, 0FFFFFFFFFFFFFFC8h
lea rsi, asc_374C6; "--"
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz loc_2A8F8
loc_2A868:
mov rax, [rsp+88h+var_80]
sub rax, [rsp+88h+var_88]
cmp rax, 21h ; '!'
jb loc_2AAD6
mov rax, [rsp+88h+var_80]
sub rax, [rsp+88h+var_88]
cmp rax, 20h ; ' '
jz loc_2AAD6
mov r12d, 20h ; ' '
xor r13d, r13d
lea r14, asc_37901; "++"
loc_2A89E:
mov rdi, rbx
call _ZNSt6vectorIN3CLI10ConfigItemESaIS1_EE12emplace_backIJEEERS1_DpOT_; std::vector<CLI::ConfigItem>::emplace_back<>()
mov rdi, [rbx+8]
add rdi, 0FFFFFFFFFFFFFFB0h
mov rsi, [rsp+88h+var_88]
lea rdx, [rsi+r12]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE13_M_assign_auxIN9__gnu_cxx17__normal_iteratorIPS5_S7_EEEEvT_SD_St20forward_iterator_tag; std::vector<std::string>::_M_assign_aux<__gnu_cxx::__normal_iterator<std::string*,std::vector<std::string>>>(__gnu_cxx::__normal_iterator<std::string*,std::vector<std::string>>,__gnu_cxx::__normal_iterator<std::string*,std::vector<std::string>>,std::forward_iterator_tag)
mov rdi, [rbx+8]
mov rdx, [rdi-30h]
add rdi, 0FFFFFFFFFFFFFFC8h
mov r8d, 2
xor esi, esi
mov rcx, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
inc r13
mov rax, [rsp+88h+var_80]
sub rax, [rsp+88h+var_88]
sar rax, 5
dec rax
add r12, 20h ; ' '
cmp r13, rax
jb short loc_2A89E
jmp loc_2AAD6
loc_2A8F8:
mov rax, [rsp+88h+var_80]
sub rax, [rsp+88h+var_88]
sar rax, 5
cmp rax, 3
mov r12d, 2
cmovnb r12, rax
loc_2A913:
mov rax, [rbx+8]
lea r14, [rax-50h]
mov r13, [rax-50h]
mov rax, [rax-48h]
sub rax, r13
sar rax, 5
cmp rax, r12
jb short loc_2A964
mov rdi, rbx
mov rsi, r14
call _ZNSt6vectorIN3CLI10ConfigItemESaIS1_EE9push_backERKS1_; std::vector<CLI::ConfigItem>::push_back(CLI::ConfigItem const&)
mov rcx, [rbx+8]
mov rax, [rcx-48h]
lea rdx, [rax-20h]
mov [rcx-48h], rdx
mov rdi, [rax-20h]; void *
add rax, 0FFFFFFFFFFFFFFF0h
cmp rdi, rax
jz short loc_2A913
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_2A913
loc_2A964:
mov rbp, [rsp+88h+var_88]
mov rsi, [rsp+88h+var_80]
sub rsi, rbp
sar rsi, 5
cmp rsi, 2
jb loc_2AAD6
dec rsi
cmp rsi, rax
cmovnb rsi, rax
test rsi, rsi
jz short loc_2A9DA
mov r15d, 8
xor r12d, r12d
mov [rsp+88h+var_50], rsi
loc_2A99B:
mov rdx, [r13+r15+0]
cmp rdx, [rbp+r15+0]
jnz short loc_2A9D3
test rdx, rdx
jz short loc_2A9C4
mov rsi, [rbp+r15-8]
mov rdi, [r13+r15-8]
call _bcmp
mov rsi, [rsp+88h+var_50]
test eax, eax
jnz short loc_2A9D3
loc_2A9C4:
inc r12
add r15, 20h ; ' '
cmp rsi, r12
jnz short loc_2A99B
mov r12, rsi
loc_2A9D3:
lea r15, [rsp+88h+var_60]
jmp short loc_2A9DD
loc_2A9DA:
xor r12d, r12d
loc_2A9DD:
cmp r12, rsi
jnz short loc_2A9F3
mov [rbx+8], r14
mov rdi, rbx
mov rsi, r14
call _ZN9__gnu_cxx13new_allocatorIN3CLI10ConfigItemEE7destroyIS2_EEvPT_; __gnu_cxx::new_allocator<CLI::ConfigItem>::destroy<CLI::ConfigItem>(CLI::ConfigItem *)
jmp short loc_2AA5A
loc_2A9F3:
lea r14, [r12+1]
mov rsi, [rbx+8]
mov rax, [rsi-48h]
sub rax, [rsi-50h]
sar rax, 5
cmp rax, r14
jbe short loc_2AA5A
add rsi, 0FFFFFFFFFFFFFFB0h
loc_2AA11:
mov rdi, rbx
call _ZNSt6vectorIN3CLI10ConfigItemESaIS1_EE9push_backERKS1_; std::vector<CLI::ConfigItem>::push_back(CLI::ConfigItem const&)
mov rcx, [rbx+8]
mov rax, [rcx-48h]
lea rdx, [rax-20h]
mov [rcx-48h], rdx
mov rdi, [rax-20h]; void *
add rax, 0FFFFFFFFFFFFFFF0h
cmp rdi, rax
jz short loc_2AA41
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2AA41:
mov rax, [rbx+8]
lea rsi, [rax-50h]
mov rcx, [rax-48h]
sub rcx, [rax-50h]
sar rcx, 5
cmp rcx, r14
ja short loc_2AA11
loc_2AA5A:
mov rax, [rsp+88h+var_80]
sub rax, [rsp+88h+var_88]
sar rax, 5
dec rax
cmp r12, rax
jnb short loc_2AAD6
mov r13, r12
shl r13, 5
add r13, 20h ; ' '
lea r14, asc_37901; "++"
loc_2AA81:
mov rdi, rbx
call _ZNSt6vectorIN3CLI10ConfigItemESaIS1_EE12emplace_backIJEEERS1_DpOT_; std::vector<CLI::ConfigItem>::emplace_back<>()
mov rdi, [rbx+8]
add rdi, 0FFFFFFFFFFFFFFB0h
mov rsi, [rsp+88h+var_88]
lea rdx, [rsi+r13]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE13_M_assign_auxIN9__gnu_cxx17__normal_iteratorIPS5_S7_EEEEvT_SD_St20forward_iterator_tag; std::vector<std::string>::_M_assign_aux<__gnu_cxx::__normal_iterator<std::string*,std::vector<std::string>>>(__gnu_cxx::__normal_iterator<std::string*,std::vector<std::string>>,__gnu_cxx::__normal_iterator<std::string*,std::vector<std::string>>,std::forward_iterator_tag)
mov rdi, [rbx+8]
mov rdx, [rdi-30h]
add rdi, 0FFFFFFFFFFFFFFC8h
mov r8d, 2
xor esi, esi
mov rcx, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
inc r12
mov rax, [rsp+88h+var_80]
sub rax, [rsp+88h+var_88]
sar rax, 5
dec rax
add r13, 20h ; ' '
cmp r12, rax
jb short loc_2AA81
loc_2AAD6:
mov rdi, rbx
call _ZNSt6vectorIN3CLI10ConfigItemESaIS1_EE12emplace_backIJEEERS1_DpOT_; std::vector<CLI::ConfigItem>::emplace_back<>()
mov rax, [rbx+8]
xorps xmm0, xmm0
lea rdi, [rsp+88h+var_48]
movaps xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov rcx, [rax-50h]
movups xmm0, xmmword ptr [rax-48h]
mov rdx, [rsp+88h+var_88]
mov [rax-50h], rdx
mov rdx, [rsp+88h+var_80]
mov [rax-48h], rdx
mov rdx, [rsp+88h+var_78]
mov [rax-40h], rdx
mov rax, [rdi]
mov rdx, [rdi+8]
mov rsi, [rdi+10h]
mov [rdi], rcx
movups xmmword ptr [rdi+8], xmm0
mov [rsp+88h+var_88], rax
mov [rsp+88h+var_80], rdx
mov [rsp+88h+var_78], rsi
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, [rbx+8]
mov rdx, [rdi-30h]
add rdi, 0FFFFFFFFFFFFFFC8h
lea rcx, asc_37901; "++"
mov r8d, 2
xor esi, esi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
mov rdi, rsp
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, [rsp+88h+var_70]; void *
cmp rdi, r15
jz short loc_2AB7B
mov rsi, [rsp+88h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2AB7B:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_2AB9B
mov rbx, rax
jmp short loc_2ABA6
jmp short loc_2AB9B
jmp short loc_2AB9B
jmp short loc_2AB9B
jmp short loc_2AB9B
jmp short $+2
loc_2AB9B:
mov rbx, rax
mov rdi, rsp
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
loc_2ABA6:
mov rdi, [rsp+arg_10]; void *
cmp rdi, r15
jz short loc_2ABBD
mov rsi, [rsp+arg_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2ABBD:
mov rdi, rbx
call __Unwind_Resume
| void CLI::detail::checkParentSegments(_QWORD *a1, _BYTE **a2, char a3)
{
long long v4; // rdi
long long v5; // r12
unsigned long long v6; // r13
unsigned long long v7; // r12
long long v8; // rax
long long v9; // r14
long long v10; // r13
unsigned long long v11; // rax
long long v12; // rcx
long long v13; // rax
_QWORD *v14; // rdi
_QWORD *v15; // rax
long long v16; // rbp
unsigned long long v17; // rsi
unsigned long long v18; // rsi
long long v19; // r15
unsigned long long v20; // r12
long long v21; // rdx
int v22; // eax
long long v23; // rsi
long long v24; // rsi
long long v25; // rcx
long long v26; // rax
_QWORD *v27; // rdi
_QWORD *v28; // rax
long long v29; // rax
long long v30; // r13
long long v31; // rax
long long v32; // rcx
__int128 v33; // xmm0
__int128 v34; // rax
long long v35; // rsi
__int128 v36; // [rsp+0h] [rbp-88h] BYREF
long long v37; // [rsp+10h] [rbp-78h]
void *v38[2]; // [rsp+18h] [rbp-70h] BYREF
_QWORD v39[2]; // [rsp+28h] [rbp-60h] BYREF
unsigned long long v40; // [rsp+38h] [rbp-50h]
_OWORD v41[4]; // [rsp+40h] [rbp-48h] BYREF
v38[0] = v39;
v38[1] = 0LL;
LOBYTE(v39[0]) = 0;
CLI::detail::generate_parents((long long)&v36, a2, (unsigned __int8 **)v38, a3);
v4 = a1[1];
if ( *a1 != v4 && !(unsigned int)std::string::compare(v4 - 56, "--") )
{
v7 = 2LL;
if ( (unsigned long long)((long long)(*((_QWORD *)&v36 + 1) - v36) >> 5) >= 3 )
v7 = (long long)(*((_QWORD *)&v36 + 1) - v36) >> 5;
while ( 1 )
{
v8 = a1[1];
v9 = v8 - 80;
v10 = *(_QWORD *)(v8 - 80);
v11 = (*(_QWORD *)(v8 - 72) - v10) >> 5;
if ( v11 < v7 )
break;
std::vector<CLI::ConfigItem>::push_back(a1, v9);
v12 = a1[1];
v13 = *(_QWORD *)(v12 - 72);
*(_QWORD *)(v12 - 72) = v13 - 32;
v14 = *(_QWORD **)(v13 - 32);
v15 = (_QWORD *)(v13 - 16);
if ( v14 != v15 )
operator delete(v14, *v15 + 1LL);
}
v16 = v36;
v17 = (long long)(*((_QWORD *)&v36 + 1) - v36) >> 5;
if ( v17 >= 2 )
{
v18 = v17 - 1;
if ( v18 >= v11 )
v18 = v11;
if ( v18 )
{
v19 = 8LL;
v20 = 0LL;
v40 = v18;
while ( 1 )
{
v21 = *(_QWORD *)(v10 + v19);
if ( v21 != *(_QWORD *)(v16 + v19) )
break;
if ( v21 )
{
v22 = bcmp(*(_QWORD *)(v10 + v19 - 8), *(_QWORD *)(v16 + v19 - 8));
v18 = v40;
if ( v22 )
break;
}
++v20;
v19 += 32LL;
if ( v18 == v20 )
{
v20 = v18;
break;
}
}
}
else
{
v20 = 0LL;
}
if ( v20 == v18 )
{
a1[1] = v9;
__gnu_cxx::new_allocator<CLI::ConfigItem>::destroy<CLI::ConfigItem>(a1, v9);
}
else
{
v23 = a1[1];
if ( (long long)(*(_QWORD *)(v23 - 72) - *(_QWORD *)(v23 - 80)) >> 5 > v20 + 1 )
{
v24 = v23 - 80;
do
{
std::vector<CLI::ConfigItem>::push_back(a1, v24);
v25 = a1[1];
v26 = *(_QWORD *)(v25 - 72);
*(_QWORD *)(v25 - 72) = v26 - 32;
v27 = *(_QWORD **)(v26 - 32);
v28 = (_QWORD *)(v26 - 16);
if ( v27 != v28 )
operator delete(v27, *v28 + 1LL);
v29 = a1[1];
v24 = v29 - 80;
}
while ( (long long)(*(_QWORD *)(v29 - 72) - *(_QWORD *)(v29 - 80)) >> 5 > v20 + 1 );
}
}
if ( v20 < ((long long)(*((_QWORD *)&v36 + 1) - v36) >> 5) - 1 )
{
v30 = 32 * v20 + 32;
do
{
std::vector<CLI::ConfigItem>::emplace_back<>((long long)a1);
std::vector<std::string>::_M_assign_aux<__gnu_cxx::__normal_iterator<std::string*,std::vector<std::string>>>(
a1[1] - 80LL,
v36,
v36 + v30);
std::string::_M_replace(a1[1] - 56LL, 0LL, *(_QWORD *)(a1[1] - 48LL), "++", 2LL);
++v20;
v30 += 32LL;
}
while ( v20 < ((long long)(*((_QWORD *)&v36 + 1) - v36) >> 5) - 1 );
}
}
}
else if ( *((_QWORD *)&v36 + 1) - (_QWORD)v36 > 0x20uLL )
{
v5 = 32LL;
v6 = 0LL;
do
{
std::vector<CLI::ConfigItem>::emplace_back<>((long long)a1);
std::vector<std::string>::_M_assign_aux<__gnu_cxx::__normal_iterator<std::string*,std::vector<std::string>>>(
a1[1] - 80LL,
v36,
v36 + v5);
std::string::_M_replace(a1[1] - 56LL, 0LL, *(_QWORD *)(a1[1] - 48LL), "++", 2LL);
++v6;
v5 += 32LL;
}
while ( v6 < ((long long)(*((_QWORD *)&v36 + 1) - v36) >> 5) - 1 );
}
std::vector<CLI::ConfigItem>::emplace_back<>((long long)a1);
v31 = a1[1];
memset(v41, 0, 24);
v32 = *(_QWORD *)(v31 - 80);
v33 = *(_OWORD *)(v31 - 72);
*(_OWORD *)(v31 - 80) = v36;
*(_QWORD *)(v31 - 64) = v37;
v34 = v41[0];
v35 = *(_QWORD *)&v41[1];
*(_QWORD *)&v41[0] = v32;
*(_OWORD *)((char *)v41 + 8) = v33;
v36 = v34;
v37 = v35;
std::vector<std::string>::~vector(v41);
std::string::_M_replace(a1[1] - 56LL, 0LL, *(_QWORD *)(a1[1] - 48LL), "++", 2LL);
std::vector<std::string>::~vector(&v36);
if ( v38[0] != v39 )
operator delete(v38[0], v39[0] + 1LL);
}
| checkParentSegments:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV ECX,EDX
MOV RBX,RDI
LEA R15,[RSP + 0x28]
MOV qword ptr [R15 + -0x10],R15
MOV qword ptr [R15 + -0x8],0x0
MOV byte ptr [R15],0x0
LAB_0012a83a:
MOV RDI,RSP
LEA RDX,[RSP + 0x18]
CALL 0x0012a4c1
MOV RDI,qword ptr [RBX + 0x8]
CMP qword ptr [RBX],RDI
JZ 0x0012a868
ADD RDI,-0x38
LEA RSI,[0x1374c6]
CALL 0x00107130
TEST EAX,EAX
JZ 0x0012a8f8
LAB_0012a868:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr [RSP]
CMP RAX,0x21
JC 0x0012aad6
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr [RSP]
CMP RAX,0x20
JZ 0x0012aad6
MOV R12D,0x20
XOR R13D,R13D
LEA R14,[0x137901]
LAB_0012a89e:
MOV RDI,RBX
CALL 0x0012a46a
MOV RDI,qword ptr [RBX + 0x8]
ADD RDI,-0x50
MOV RSI,qword ptr [RSP]
LEA RDX,[RSI + R12*0x1]
LAB_0012a8b6:
CALL 0x0012b64e
MOV RDI,qword ptr [RBX + 0x8]
MOV RDX,qword ptr [RDI + -0x30]
ADD RDI,-0x38
LAB_0012a8c7:
MOV R8D,0x2
XOR ESI,ESI
MOV RCX,R14
CALL 0x00107660
INC R13
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr [RSP]
SAR RAX,0x5
DEC RAX
ADD R12,0x20
CMP R13,RAX
JC 0x0012a89e
JMP 0x0012aad6
LAB_0012a8f8:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr [RSP]
SAR RAX,0x5
CMP RAX,0x3
MOV R12D,0x2
CMOVNC R12,RAX
LAB_0012a913:
MOV RAX,qword ptr [RBX + 0x8]
LEA R14,[RAX + -0x50]
MOV R13,qword ptr [RAX + -0x50]
MOV RAX,qword ptr [RAX + -0x48]
SUB RAX,R13
SAR RAX,0x5
CMP RAX,R12
JC 0x0012a964
LAB_0012a92f:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0012b3a6
MOV RCX,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RCX + -0x48]
LEA RDX,[RAX + -0x20]
MOV qword ptr [RCX + -0x48],RDX
MOV RDI,qword ptr [RAX + -0x20]
ADD RAX,-0x10
CMP RDI,RAX
JZ 0x0012a913
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x00107430
JMP 0x0012a913
LAB_0012a964:
MOV RBP,qword ptr [RSP]
MOV RSI,qword ptr [RSP + 0x8]
SUB RSI,RBP
SAR RSI,0x5
CMP RSI,0x2
JC 0x0012aad6
DEC RSI
CMP RSI,RAX
CMOVNC RSI,RAX
TEST RSI,RSI
JZ 0x0012a9da
MOV R15D,0x8
XOR R12D,R12D
MOV qword ptr [RSP + 0x38],RSI
LAB_0012a99b:
MOV RDX,qword ptr [R13 + R15*0x1]
CMP RDX,qword ptr [RBP + R15*0x1]
JNZ 0x0012a9d3
TEST RDX,RDX
JZ 0x0012a9c4
MOV RSI,qword ptr [RBP + R15*0x1 + -0x8]
MOV RDI,qword ptr [R13 + R15*0x1 + -0x8]
CALL 0x00107450
MOV RSI,qword ptr [RSP + 0x38]
TEST EAX,EAX
JNZ 0x0012a9d3
LAB_0012a9c4:
INC R12
ADD R15,0x20
CMP RSI,R12
JNZ 0x0012a99b
MOV R12,RSI
LAB_0012a9d3:
LEA R15,[RSP + 0x28]
JMP 0x0012a9dd
LAB_0012a9da:
XOR R12D,R12D
LAB_0012a9dd:
CMP R12,RSI
JNZ 0x0012a9f3
MOV qword ptr [RBX + 0x8],R14
MOV RDI,RBX
MOV RSI,R14
CALL 0x0012b620
JMP 0x0012aa5a
LAB_0012a9f3:
LEA R14,[R12 + 0x1]
MOV RSI,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RSI + -0x48]
SUB RAX,qword ptr [RSI + -0x50]
SAR RAX,0x5
CMP RAX,R14
JBE 0x0012aa5a
ADD RSI,-0x50
LAB_0012aa11:
MOV RDI,RBX
CALL 0x0012b3a6
MOV RCX,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RCX + -0x48]
LEA RDX,[RAX + -0x20]
MOV qword ptr [RCX + -0x48],RDX
MOV RDI,qword ptr [RAX + -0x20]
ADD RAX,-0x10
CMP RDI,RAX
JZ 0x0012aa41
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x00107430
LAB_0012aa41:
MOV RAX,qword ptr [RBX + 0x8]
LEA RSI,[RAX + -0x50]
MOV RCX,qword ptr [RAX + -0x48]
SUB RCX,qword ptr [RAX + -0x50]
SAR RCX,0x5
CMP RCX,R14
JA 0x0012aa11
LAB_0012aa5a:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr [RSP]
SAR RAX,0x5
DEC RAX
CMP R12,RAX
JNC 0x0012aad6
MOV R13,R12
SHL R13,0x5
ADD R13,0x20
LEA R14,[0x137901]
LAB_0012aa81:
MOV RDI,RBX
CALL 0x0012a46a
MOV RDI,qword ptr [RBX + 0x8]
ADD RDI,-0x50
MOV RSI,qword ptr [RSP]
LEA RDX,[RSI + R13*0x1]
LAB_0012aa99:
CALL 0x0012b64e
MOV RDI,qword ptr [RBX + 0x8]
MOV RDX,qword ptr [RDI + -0x30]
ADD RDI,-0x38
LAB_0012aaaa:
MOV R8D,0x2
XOR ESI,ESI
MOV RCX,R14
CALL 0x00107660
INC R12
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr [RSP]
SAR RAX,0x5
DEC RAX
ADD R13,0x20
CMP R12,RAX
JC 0x0012aa81
LAB_0012aad6:
MOV RDI,RBX
CALL 0x0012a46a
MOV RAX,qword ptr [RBX + 0x8]
XORPS XMM0,XMM0
LEA RDI,[RSP + 0x40]
MOVAPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RCX,qword ptr [RAX + -0x50]
MOVUPS XMM0,xmmword ptr [RAX + -0x48]
MOV RDX,qword ptr [RSP]
MOV qword ptr [RAX + -0x50],RDX
MOV RDX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + -0x48],RDX
MOV RDX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + -0x40],RDX
MOV RAX,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
MOV RSI,qword ptr [RDI + 0x10]
MOV qword ptr [RDI],RCX
MOVUPS xmmword ptr [RDI + 0x8],XMM0
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
MOV qword ptr [RSP + 0x10],RSI
CALL 0x0010af62
MOV RDI,qword ptr [RBX + 0x8]
MOV RDX,qword ptr [RDI + -0x30]
ADD RDI,-0x38
LEA RCX,[0x137901]
MOV R8D,0x2
XOR ESI,ESI
CALL 0x00107660
LAB_0012ab5c:
MOV RDI,RSP
CALL 0x0010af62
MOV RDI,qword ptr [RSP + 0x18]
CMP RDI,R15
JZ 0x0012ab7b
MOV RSI,qword ptr [RSP + 0x28]
INC RSI
CALL 0x00107430
LAB_0012ab7b:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* CLI::detail::checkParentSegments(std::vector<CLI::ConfigItem, std::allocator<CLI::ConfigItem> >&,
std::__cxx11::string const&, char) */
void CLI::detail::checkParentSegments(vector *param_1,string *param_2,char param_3)
{
ConfigItem *pCVar1;
size_t __n;
long lVar2;
int iVar3;
ulong uVar4;
long lVar5;
long lVar6;
ulong uVar7;
ulong uVar8;
long local_88;
long local_80;
int8 local_78;
int1 *local_70;
int8 local_68;
int1 local_60;
int7 uStack_5f;
ulong local_50;
int8 local_48;
int8 uStack_40;
int8 local_38;
local_70 = &local_60;
local_68 = 0;
local_60 = 0;
/* try { // try from 0012a83a to 0012a846 has its CatchHandler @ 0012ab8c */
generate_parents((detail *)&local_88,param_2,(string *)&local_70,param_3);
if ((*(long *)param_1 == *(long *)(param_1 + 8)) ||
(iVar3 = std::__cxx11::string::compare((char *)(*(long *)(param_1 + 8) + -0x38)), iVar3 != 0))
{
if ((0x20 < (ulong)(local_80 - local_88)) && (local_80 - local_88 != 0x20)) {
lVar6 = 0x20;
uVar8 = 0;
do {
/* try { // try from 0012a89e to 0012a8a5 has its CatchHandler @ 0012ab9b */
std::vector<CLI::ConfigItem,std::allocator<CLI::ConfigItem>>::emplace_back<>
((vector<CLI::ConfigItem,std::allocator<CLI::ConfigItem>> *)param_1);
/* try { // try from 0012a8b6 to 0012a8ba has its CatchHandler @ 0012ab99 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
_M_assign_aux<__gnu_cxx::__normal_iterator<std::__cxx11::string*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>>
(*(long *)(param_1 + 8) + -0x50,local_88,local_88 + lVar6);
/* try { // try from 0012a8c7 to 0012a8d6 has its CatchHandler @ 0012ab9b */
std::__cxx11::string::_M_replace
(*(long *)(param_1 + 8) - 0x38,0,*(char **)(*(long *)(param_1 + 8) + -0x30),
0x137901);
uVar8 = uVar8 + 1;
lVar6 = lVar6 + 0x20;
} while (uVar8 < (local_80 - local_88 >> 5) - 1U);
}
}
else {
uVar4 = local_80 - local_88 >> 5;
uVar8 = 2;
if (2 < uVar4) {
uVar8 = uVar4;
}
while( true ) {
lVar2 = local_88;
lVar6 = *(long *)(param_1 + 8);
pCVar1 = (ConfigItem *)(lVar6 + -0x50);
lVar5 = *(long *)(lVar6 + -0x50);
uVar4 = *(long *)(lVar6 + -0x48) - lVar5 >> 5;
if (uVar4 < uVar8) break;
/* try { // try from 0012a92f to 0012a939 has its CatchHandler @ 0012ab97 */
std::vector<CLI::ConfigItem,std::allocator<CLI::ConfigItem>>::push_back
((vector<CLI::ConfigItem,std::allocator<CLI::ConfigItem>> *)param_1,pCVar1);
lVar6 = *(long *)(*(long *)(param_1 + 8) + -0x48);
*(long *)(*(long *)(param_1 + 8) + -0x48) = lVar6 + -0x20;
if (*(long **)(lVar6 + -0x20) != (long *)(lVar6 + -0x10)) {
operator_delete(*(long **)(lVar6 + -0x20),*(long *)(lVar6 + -0x10) + 1);
}
}
uVar8 = local_80 - local_88 >> 5;
if (1 < uVar8) {
uVar8 = uVar8 - 1;
if (uVar4 <= uVar8) {
uVar8 = uVar4;
}
if (uVar8 == 0) {
uVar4 = 0;
}
else {
lVar6 = 8;
uVar7 = 0;
local_50 = uVar8;
do {
__n = *(size_t *)(lVar5 + lVar6);
uVar4 = uVar7;
if ((__n != *(size_t *)(lVar2 + lVar6)) ||
((__n != 0 &&
(iVar3 = bcmp(*(void **)(lVar5 + -8 + lVar6),*(void **)(lVar2 + -8 + lVar6),__n),
uVar8 = local_50, iVar3 != 0)))) break;
uVar7 = uVar7 + 1;
lVar6 = lVar6 + 0x20;
uVar4 = uVar8;
} while (uVar8 != uVar7);
}
if (uVar4 == uVar8) {
*(ConfigItem **)(param_1 + 8) = pCVar1;
__gnu_cxx::new_allocator<CLI::ConfigItem>::destroy<CLI::ConfigItem>
((new_allocator<CLI::ConfigItem> *)param_1,pCVar1);
}
else {
lVar6 = *(long *)(param_1 + 8);
lVar5 = *(long *)(lVar6 + -0x48) - *(long *)(lVar6 + -0x50);
while (uVar4 + 1 < (ulong)(lVar5 >> 5)) {
/* try { // try from 0012aa11 to 0012aa18 has its CatchHandler @ 0012ab8a */
std::vector<CLI::ConfigItem,std::allocator<CLI::ConfigItem>>::push_back
((vector<CLI::ConfigItem,std::allocator<CLI::ConfigItem>> *)param_1,
(ConfigItem *)(lVar6 + -0x50));
lVar6 = *(long *)(*(long *)(param_1 + 8) + -0x48);
*(long *)(*(long *)(param_1 + 8) + -0x48) = lVar6 + -0x20;
if (*(long **)(lVar6 + -0x20) != (long *)(lVar6 + -0x10)) {
operator_delete(*(long **)(lVar6 + -0x20),*(long *)(lVar6 + -0x10) + 1);
}
lVar6 = *(long *)(param_1 + 8);
lVar5 = *(long *)(lVar6 + -0x48) - *(long *)(lVar6 + -0x50);
}
}
if (uVar4 < (local_80 - local_88 >> 5) - 1U) {
lVar6 = uVar4 << 5;
do {
/* try { // try from 0012aa81 to 0012aa88 has its CatchHandler @ 0012ab95 */
lVar6 = lVar6 + 0x20;
std::vector<CLI::ConfigItem,std::allocator<CLI::ConfigItem>>::emplace_back<>
((vector<CLI::ConfigItem,std::allocator<CLI::ConfigItem>> *)param_1);
/* try { // try from 0012aa99 to 0012aa9d has its CatchHandler @ 0012ab91 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
_M_assign_aux<__gnu_cxx::__normal_iterator<std::__cxx11::string*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>>
(*(long *)(param_1 + 8) + -0x50,local_88,local_88 + lVar6);
/* try { // try from 0012aaaa to 0012aab9 has its CatchHandler @ 0012ab95 */
std::__cxx11::string::_M_replace
(*(long *)(param_1 + 8) - 0x38,0,*(char **)(*(long *)(param_1 + 8) + -0x30),
0x137901);
uVar4 = uVar4 + 1;
} while (uVar4 < (local_80 - local_88 >> 5) - 1U);
}
}
}
/* try { // try from 0012aad6 to 0012ab5b has its CatchHandler @ 0012ab93 */
std::vector<CLI::ConfigItem,std::allocator<CLI::ConfigItem>>::emplace_back<>
((vector<CLI::ConfigItem,std::allocator<CLI::ConfigItem>> *)param_1);
lVar6 = *(long *)(param_1 + 8);
local_48 = *(int8 *)(lVar6 + -0x50);
uStack_40 = *(int8 *)(lVar6 + -0x48);
local_38 = *(int8 *)(lVar6 + -0x40);
*(long *)(lVar6 + -0x50) = local_88;
*(long *)(lVar6 + -0x48) = local_80;
*(int8 *)(lVar6 + -0x40) = local_78;
local_88 = 0;
local_80 = 0;
local_78 = 0;
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_48);
std::__cxx11::string::_M_replace
(*(long *)(param_1 + 8) - 0x38,0,*(char **)(*(long *)(param_1 + 8) + -0x30),0x137901);
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_88);
if (local_70 != &local_60) {
operator_delete(local_70,CONCAT71(uStack_5f,local_60) + 1);
}
return;
}
| |
41,209 | reaction::ObserverGraph::getActionObserverList(std::shared_ptr<reaction::ObserverDataNode>) | reaction/include/reaction/observerNode.h | std::unordered_map<ActionNodePtr, std::function<void(bool)>> getActionObserverList(DataNodePtr node) {
return m_actionObservers[node];
} | O3 | c | reaction::ObserverGraph::getActionObserverList(std::shared_ptr<reaction::ObserverDataNode>):
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x70(%rsi), %rdi
movq %rdx, %rsi
callq 0xa604
xorl %ecx, %ecx
movq %rcx, (%rbx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, 0x10(%rbx)
movq 0x18(%rax), %rdx
movq %rdx, 0x18(%rbx)
movups 0x20(%rax), %xmm0
movups %xmm0, 0x20(%rbx)
movq %rcx, 0x30(%rbx)
leaq 0x8(%rsp), %rdx
movq %rbx, (%rdx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa7a8
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
| _ZN8reaction13ObserverGraph21getActionObserverListESt10shared_ptrINS_16ObserverDataNodeEE:
push rbx
sub rsp, 10h
mov rbx, rdi
lea rdi, [rsi+70h]
mov rsi, rdx
call _ZNSt8__detail9_Map_baseISt10shared_ptrIN8reaction16ObserverDataNodeEESt4pairIKS4_St13unordered_mapIS1_INS2_18ObserverActionNodeEESt8functionIFvbEESt4hashIS9_ESt8equal_toIS9_ESaIS5_IKS9_SC_EEEESaISL_ENS_10_Select1stESF_IS4_ESD_IS4_ENS_18_Mod_range_hashingENS_20_Default_ranged_hashENS_20_Prime_rehash_policyENS_17_Hashtable_traitsILb0ELb0ELb1EEELb1EEixERS6_; std::__detail::_Map_base<std::shared_ptr<reaction::ObserverDataNode>,std::pair<std::shared_ptr<reaction::ObserverDataNode> const,std::unordered_map<std::shared_ptr<reaction::ObserverActionNode>,std::function<void ()(bool)>>>,std::allocator<std::pair<std::shared_ptr<reaction::ObserverDataNode> const,std::unordered_map<std::shared_ptr<reaction::ObserverActionNode>,std::function<void ()(bool)>>>>,std::__detail::_Select1st,std::equal_to<std::shared_ptr<reaction::ObserverDataNode>>,std::hash<std::shared_ptr<reaction::ObserverDataNode>>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>,true>::operator[](std::shared_ptr<reaction::ObserverDataNode> const&)
xor ecx, ecx
mov [rbx], rcx
mov rdx, [rax+8]
mov [rbx+8], rdx
mov [rbx+10h], rcx
mov rdx, [rax+18h]
mov [rbx+18h], rdx
movups xmm0, xmmword ptr [rax+20h]
movups xmmword ptr [rbx+20h], xmm0
mov [rbx+30h], rcx
lea rdx, [rsp+18h+var_10]
mov [rdx], rbx
mov rdi, rbx
mov rsi, rax
call _ZNSt10_HashtableISt10shared_ptrIN8reaction18ObserverActionNodeEESt4pairIKS3_St8functionIFvbEEESaIS9_ENSt8__detail10_Select1stESt8equal_toIS3_ESt4hashIS3_ENSB_18_Mod_range_hashingENSB_20_Default_ranged_hashENSB_20_Prime_rehash_policyENSB_17_Hashtable_traitsILb0ELb0ELb1EEEE9_M_assignIRKSM_NSB_10_AllocNodeISaINSB_10_Hash_nodeIS9_Lb0EEEEEEEEvOT_RKT0_; std::_Hashtable<std::shared_ptr<reaction::ObserverActionNode>,std::pair<std::shared_ptr<reaction::ObserverActionNode> const,std::function<void ()(bool)>>,std::allocator<std::pair<std::shared_ptr<reaction::ObserverActionNode> const,std::function<void ()(bool)>>>,std::__detail::_Select1st,std::equal_to<std::shared_ptr<reaction::ObserverActionNode>>,std::hash<std::shared_ptr<reaction::ObserverActionNode>>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::_M_assign<std::_Hashtable<std::shared_ptr<reaction::ObserverActionNode>,std::pair<std::shared_ptr<reaction::ObserverActionNode> const,std::function<void ()(bool)>>,std::allocator<std::pair<std::shared_ptr<reaction::ObserverActionNode> const,std::function<void ()(bool)>>>,std::__detail::_Select1st,std::equal_to<std::shared_ptr<reaction::ObserverActionNode>>,std::hash<std::shared_ptr<reaction::ObserverActionNode>>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>> const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::pair<std::shared_ptr<reaction::ObserverActionNode> const,std::function<void ()(bool)>>,false>>>>(std::_Hashtable<std::shared_ptr<reaction::ObserverActionNode>,std::pair<std::shared_ptr<reaction::ObserverActionNode> const,std::function<void ()(bool)>>,std::allocator<std::pair<std::shared_ptr<reaction::ObserverActionNode> const,std::function<void ()(bool)>>>,std::__detail::_Select1st,std::equal_to<std::shared_ptr<reaction::ObserverActionNode>>,std::hash<std::shared_ptr<reaction::ObserverActionNode>>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>> const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::pair<std::shared_ptr<reaction::ObserverActionNode> const,std::function<void ()(bool)>>,false>>> const&)
mov rax, rbx
add rsp, 10h
pop rbx
retn
| long long reaction::ObserverGraph::getActionObserverList(long long a1, int a2, int a3, int a4, int a5, int a6)
{
long long v6; // rax
v6 = std::__detail::_Map_base<std::shared_ptr<reaction::ObserverDataNode>,std::pair<std::shared_ptr<reaction::ObserverDataNode> const,std::unordered_map<std::shared_ptr<reaction::ObserverActionNode>,std::function<void ()(bool)>>>,std::allocator<std::pair<std::shared_ptr<reaction::ObserverDataNode> const,std::unordered_map<std::shared_ptr<reaction::ObserverActionNode>,std::function<void ()(bool)>>>>,std::__detail::_Select1st,std::equal_to<std::shared_ptr<reaction::ObserverDataNode>>,std::hash<std::shared_ptr<reaction::ObserverDataNode>>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>,true>::operator[](
a2 + 112,
a3,
a3,
a4,
a5,
a6);
*(_QWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 8) = *(_QWORD *)(v6 + 8);
*(_QWORD *)(a1 + 16) = 0LL;
*(_QWORD *)(a1 + 24) = *(_QWORD *)(v6 + 24);
*(_OWORD *)(a1 + 32) = *(_OWORD *)(v6 + 32);
*(_QWORD *)(a1 + 48) = 0LL;
std::_Hashtable<std::shared_ptr<reaction::ObserverActionNode>,std::pair<std::shared_ptr<reaction::ObserverActionNode> const,std::function<void ()(bool)>>,std::allocator<std::pair<std::shared_ptr<reaction::ObserverActionNode> const,std::function<void ()(bool)>>>,std::__detail::_Select1st,std::equal_to<std::shared_ptr<reaction::ObserverActionNode>>,std::hash<std::shared_ptr<reaction::ObserverActionNode>>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::_M_assign<std::_Hashtable<std::shared_ptr<reaction::ObserverActionNode>,std::pair<std::shared_ptr<reaction::ObserverActionNode> const,std::function<void ()(bool)>>,std::allocator<std::pair<std::shared_ptr<reaction::ObserverActionNode> const,std::function<void ()(bool)>>>,std::__detail::_Select1st,std::equal_to<std::shared_ptr<reaction::ObserverActionNode>>,std::hash<std::shared_ptr<reaction::ObserverActionNode>>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>> const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::pair<std::shared_ptr<reaction::ObserverActionNode> const,std::function<void ()(bool)>>,false>>>>(
a1,
v6);
return a1;
}
| getActionObserverList:
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
LEA RDI,[RSI + 0x70]
MOV RSI,RDX
CALL 0x0010a604
XOR ECX,ECX
MOV qword ptr [RBX],RCX
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x8],RDX
MOV qword ptr [RBX + 0x10],RCX
MOV RDX,qword ptr [RAX + 0x18]
MOV qword ptr [RBX + 0x18],RDX
MOVUPS XMM0,xmmword ptr [RAX + 0x20]
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOV qword ptr [RBX + 0x30],RCX
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RBX
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0010a7a8
MOV RAX,RBX
ADD RSP,0x10
POP RBX
RET
|
/* reaction::ObserverGraph::getActionObserverList(std::shared_ptr<reaction::ObserverDataNode>) */
_Hashtable<std::shared_ptr<reaction::ObserverActionNode>,std::pair<std::shared_ptr<reaction::ObserverActionNode>const,std::function<void(bool)>>,std::allocator<std::pair<std::shared_ptr<reaction::ObserverActionNode>const,std::function<void(bool)>>>,std::__detail::_Select1st,std::equal_to<std::shared_ptr<reaction::ObserverActionNode>>,std::hash<std::shared_ptr<reaction::ObserverActionNode>>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
* reaction::ObserverGraph::getActionObserverList
(_Hashtable<std::shared_ptr<reaction::ObserverActionNode>,std::pair<std::shared_ptr<reaction::ObserverActionNode>const,std::function<void(bool)>>,std::allocator<std::pair<std::shared_ptr<reaction::ObserverActionNode>const,std::function<void(bool)>>>,std::__detail::_Select1st,std::equal_to<std::shared_ptr<reaction::ObserverActionNode>>,std::hash<std::shared_ptr<reaction::ObserverActionNode>>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
*param_1,long param_2,shared_ptr *param_3)
{
int8 uVar1;
_Hashtable *p_Var2;
_Hashtable<std::shared_ptr<reaction::ObserverActionNode>,std::pair<std::shared_ptr<reaction::ObserverActionNode>const,std::function<void(bool)>>,std::allocator<std::pair<std::shared_ptr<reaction::ObserverActionNode>const,std::function<void(bool)>>>,std::__detail::_Select1st,std::equal_to<std::shared_ptr<reaction::ObserverActionNode>>,std::hash<std::shared_ptr<reaction::ObserverActionNode>>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
*local_10;
p_Var2 = (_Hashtable *)
std::__detail::
_Map_base<std::shared_ptr<reaction::ObserverDataNode>,std::pair<std::shared_ptr<reaction::ObserverDataNode>const,std::unordered_map<std::shared_ptr<reaction::ObserverActionNode>,std::function<void(bool)>,std::hash<std::shared_ptr<reaction::ObserverActionNode>>,std::equal_to<std::shared_ptr<reaction::ObserverActionNode>>,std::allocator<std::pair<std::shared_ptr<reaction::ObserverActionNode>const,std::function<void(bool)>>>>>,std::allocator<std::pair<std::shared_ptr<reaction::ObserverDataNode>const,std::unordered_map<std::shared_ptr<reaction::ObserverActionNode>,std::function<void(bool)>,std::hash<std::shared_ptr<reaction::ObserverActionNode>>,std::equal_to<std::shared_ptr<reaction::ObserverActionNode>>,std::allocator<std::pair<std::shared_ptr<reaction::ObserverActionNode>const,std::function<void(bool)>>>>>>,std::__detail::_Select1st,std::equal_to<std::shared_ptr<reaction::ObserverDataNode>>,std::hash<std::shared_ptr<reaction::ObserverDataNode>>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>,true>
::operator[]((_Map_base<std::shared_ptr<reaction::ObserverDataNode>,std::pair<std::shared_ptr<reaction::ObserverDataNode>const,std::unordered_map<std::shared_ptr<reaction::ObserverActionNode>,std::function<void(bool)>,std::hash<std::shared_ptr<reaction::ObserverActionNode>>,std::equal_to<std::shared_ptr<reaction::ObserverActionNode>>,std::allocator<std::pair<std::shared_ptr<reaction::ObserverActionNode>const,std::function<void(bool)>>>>>,std::allocator<std::pair<std::shared_ptr<reaction::ObserverDataNode>const,std::unordered_map<std::shared_ptr<reaction::ObserverActionNode>,std::function<void(bool)>,std::hash<std::shared_ptr<reaction::ObserverActionNode>>,std::equal_to<std::shared_ptr<reaction::ObserverActionNode>>,std::allocator<std::pair<std::shared_ptr<reaction::ObserverActionNode>const,std::function<void(bool)>>>>>>,std::__detail::_Select1st,std::equal_to<std::shared_ptr<reaction::ObserverDataNode>>,std::hash<std::shared_ptr<reaction::ObserverDataNode>>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>,true>
*)(param_2 + 0x70),param_3);
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = *(int8 *)(p_Var2 + 8);
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x18) = *(int8 *)(p_Var2 + 0x18);
uVar1 = *(int8 *)(p_Var2 + 0x28);
*(int8 *)(param_1 + 0x20) = *(int8 *)(p_Var2 + 0x20);
*(int8 *)(param_1 + 0x28) = uVar1;
*(int8 *)(param_1 + 0x30) = 0;
local_10 = param_1;
std::
_Hashtable<std::shared_ptr<reaction::ObserverActionNode>,std::pair<std::shared_ptr<reaction::ObserverActionNode>const,std::function<void(bool)>>,std::allocator<std::pair<std::shared_ptr<reaction::ObserverActionNode>const,std::function<void(bool)>>>,std::__detail::_Select1st,std::equal_to<std::shared_ptr<reaction::ObserverActionNode>>,std::hash<std::shared_ptr<reaction::ObserverActionNode>>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
::
_M_assign<std::_Hashtable<std::shared_ptr<reaction::ObserverActionNode>,std::pair<std::shared_ptr<reaction::ObserverActionNode>const,std::function<void(bool)>>,std::allocator<std::pair<std::shared_ptr<reaction::ObserverActionNode>const,std::function<void(bool)>>>,std::__detail::_Select1st,std::equal_to<std::shared_ptr<reaction::ObserverActionNode>>,std::hash<std::shared_ptr<reaction::ObserverActionNode>>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::pair<std::shared_ptr<reaction::ObserverActionNode>const,std::function<void(bool)>>,false>>>>
(param_1,p_Var2,(_AllocNode *)&local_10);
return param_1;
}
| |
41,210 | fill_update_undo_parts | eloqsql/storage/maria/ma_blockrec.c | static size_t fill_update_undo_parts(MARIA_HA *info, const uchar *oldrec,
const uchar *newrec,
LEX_CUSTRING *log_parts,
uint *log_parts_count)
{
MARIA_SHARE *share= info->s;
MARIA_COLUMNDEF *column, *end_column;
MARIA_ROW *old_row= &info->cur_row, *new_row= &info->new_row;
uchar *field_data, *start_field_data, *length_str;
uchar *old_field_lengths= old_row->field_lengths;
uchar *new_field_lengths= new_row->field_lengths;
size_t row_length= 0;
uint field_lengths;
LEX_CUSTRING *start_log_parts;
my_bool new_column_is_empty;
DBUG_ENTER("fill_update_undo_parts");
start_log_parts= log_parts;
/*
First log part is for number of fields, field numbers and lengths
The +4 is to reserve place for the number of changed fields.
*/
start_field_data= field_data= info->update_field_data + 4;
log_parts++;
if (memcmp(oldrec, newrec, share->base.null_bytes))
{
/* Store changed null bits */
*field_data++= (uchar) 255; /* Special case */
log_parts->str= oldrec;
log_parts->length= share->base.null_bytes;
row_length= log_parts->length;
log_parts++;
}
/* Handle constant length fields */
for (column= share->columndef,
end_column= column+ share->base.fixed_not_null_fields;
column < end_column;
column++)
{
if (memcmp(oldrec + column->offset, newrec + column->offset,
column->length))
{
field_data= ma_store_length(field_data,
(uint) (column - share->columndef));
log_parts->str= oldrec + column->offset;
log_parts->length= column->length;
row_length+= column->length;
log_parts++;
}
}
/* Handle the rest: NULL fields and CHAR/VARCHAR fields and BLOB's */
for (end_column= share->columndef + share->base.fields;
column < end_column;
column++)
{
const uchar *new_column_pos, *old_column_pos;
size_t new_column_length, old_column_length;
/* First check if old column is null or empty */
if (oldrec[column->null_pos] & column->null_bit)
{
/*
It's safe to skip this one as either the new column is also null
(no change) or the new_column is not null, in which case the null-bit
maps differed and we have already stored the null bitmap.
*/
continue;
}
if (old_row->empty_bits[column->empty_pos] & column->empty_bit)
{
if (new_row->empty_bits[column->empty_pos] & column->empty_bit)
continue; /* Both are empty; skip */
/* Store null length column */
field_data= ma_store_length(field_data,
(uint) (column - share->columndef));
field_data= ma_store_length(field_data, 0);
continue;
}
/*
Remember if the 'new' value is empty (as in this case we must always
log the original value
*/
new_column_is_empty= ((newrec[column->null_pos] & column->null_bit) ||
(new_row->empty_bits[column->empty_pos] &
column->empty_bit));
old_column_pos= oldrec + column->offset;
new_column_pos= newrec + column->offset;
old_column_length= new_column_length= column->length;
switch (column->type) {
case FIELD_CHECK:
case FIELD_NORMAL: /* Fixed length field */
case FIELD_ZERO:
case FIELD_SKIP_PRESPACE: /* Not packed */
case FIELD_SKIP_ZERO: /* Fixed length field */
break;
case FIELD_VARCHAR:
new_column_length--; /* Skip length prefix */
old_column_pos+= column->fill_length;
new_column_pos+= column->fill_length;
/* Fall through */
case FIELD_SKIP_ENDSPACE: /* CHAR */
{
if (new_column_length <= 255)
{
old_column_length= *old_field_lengths++;
if (!new_column_is_empty)
new_column_length= *new_field_lengths++;
}
else
{
old_column_length= uint2korr(old_field_lengths);
old_field_lengths+= 2;
if (!new_column_is_empty)
{
new_column_length= uint2korr(new_field_lengths);
new_field_lengths+= 2;
}
}
break;
}
case FIELD_BLOB:
{
uint size_length= column->length - portable_sizeof_char_ptr;
old_column_length= _ma_calc_blob_length(size_length, old_column_pos);
memcpy((void*) &old_column_pos, oldrec + column->offset + size_length,
sizeof(old_column_pos));
if (!new_column_is_empty)
{
new_column_length= _ma_calc_blob_length(size_length, new_column_pos);
memcpy((void*) &new_column_pos, newrec + column->offset + size_length,
sizeof(old_column_pos));
}
break;
}
default:
DBUG_ASSERT(0);
}
if (new_column_is_empty || new_column_length != old_column_length ||
memcmp(old_column_pos, new_column_pos, new_column_length))
{
field_data= ma_store_length(field_data,
(ulong) (column - share->columndef));
field_data= ma_store_length(field_data, (ulong) old_column_length);
log_parts->str= old_column_pos;
log_parts->length= old_column_length;
row_length+= old_column_length;
log_parts++;
}
}
*log_parts_count= (uint) (log_parts - start_log_parts);
/* Store length of field length data before the field/field_lengths */
field_lengths= (uint) (field_data - start_field_data);
length_str= start_field_data - ma_calc_length_for_store_length(field_lengths);
start_log_parts->str= length_str;
ma_store_length(length_str, field_lengths);
start_log_parts->length= (size_t) (field_data - start_log_parts->str);
row_length+= start_log_parts->length;
DBUG_RETURN(row_length);
} | O3 | c | fill_update_undo_parts:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r8, -0x98(%rbp)
movq %rcx, %rbx
movq %rdx, %rax
movq %rsi, %r14
movq (%rdi), %r13
movq 0xd0(%rdi), %rcx
movq %rcx, -0x48(%rbp)
movq 0x190(%rdi), %rcx
movq %rcx, -0x40(%rbp)
movq %rdi, -0x78(%rbp)
movq 0x3c8(%rdi), %r15
leaq 0x4(%r15), %rcx
movq %rcx, -0x80(%rbp)
movl 0x3fc(%r13), %edx
movq %rsi, %rdi
movq %rax, -0x60(%rbp)
movq %rax, %rsi
callq 0x29560
testl %eax, %eax
movq %rbx, -0xa0(%rbp)
je 0x63704
movb $-0x1, 0x4(%r15)
addq $0x5, %r15
movq %r14, 0x10(%rbx)
movl 0x3fc(%r13), %eax
movq %rax, -0x50(%rbp)
movq %rax, 0x18(%rbx)
leaq 0x20(%rbx), %r12
jmp 0x63714
leaq 0x10(%rbx), %r12
movq $0x0, -0x50(%rbp)
movq -0x80(%rbp), %r15
movq %r14, %r8
movq %r15, -0x30(%rbp)
movq 0x588(%r13), %rbx
movl 0x3cc(%r13), %eax
testq %rax, %rax
movq %r13, -0x58(%rbp)
je 0x637bc
imulq $0x38, %rax, %r14
addq %rbx, %r14
movq %rbx, %r15
movl 0x4(%rbx), %esi
leaq (%r8,%rsi), %rdi
addq -0x60(%rbp), %rsi
movzwl 0x8(%rbx), %edx
movq %r8, %r13
callq 0x29560
testl %eax, %eax
je 0x6379f
movq %r15, %rax
movq -0x58(%rbp), %rcx
subq 0x588(%rcx), %rax
shrq $0x3, %rax
imull $0xb6db6db7, %eax, %esi # imm = 0xB6DB6DB7
movq -0x30(%rbp), %rdi
callq 0x5ed2a
movq %rax, -0x30(%rbp)
movl 0x4(%rbx), %eax
addq %r13, %rax
movq %rax, (%r12)
movzwl 0x8(%rbx), %eax
movq %rax, 0x8(%r12)
movzwl 0x8(%rbx), %eax
addq %rax, -0x50(%rbp)
addq $0x10, %r12
movq %r13, %r8
addq $0x38, %rbx
addq $0x38, %r15
cmpq %r14, %rbx
jb 0x63740
movq -0x58(%rbp), %r13
movq 0x588(%r13), %rax
jmp 0x637bf
movq %rbx, %rax
movl 0x3c8(%r13), %ecx
imulq $0x38, %rcx, %r9
addq %rax, %r9
cmpq %r9, %rbx
movq -0x78(%rbp), %r14
jae 0x639ec
movq %rbx, %r15
movq %r8, -0x70(%rbp)
movq %r9, -0x68(%rbp)
movzwl 0xe(%rbx), %eax
movb 0x12(%rbx), %dl
testb %dl, (%r8,%rax)
je 0x63804
addq $0x38, %rbx
addq $0x38, %r15
cmpq %r9, %rbx
jb 0x637e5
jmp 0x639ec
movq 0xc8(%r14), %rdi
movzwl 0x10(%rbx), %ecx
movb 0x13(%rbx), %sil
testb %sil, (%rdi,%rcx)
je 0x6385b
movq 0x188(%r14), %rax
testb %sil, (%rax,%rcx)
jne 0x637f2
movq %r15, %rax
movq -0x58(%rbp), %rcx
subq 0x588(%rcx), %rax
shrq $0x3, %rax
imull $0xb6db6db7, %eax, %esi # imm = 0xB6DB6DB7
movq -0x30(%rbp), %rdi
callq 0x5ed2a
movq -0x68(%rbp), %r9
movq -0x70(%rbp), %r8
movb $0x0, (%rax)
incq %rax
movq %rax, -0x30(%rbp)
jmp 0x637f2
movq -0x60(%rbp), %rdi
testb %dl, (%rdi,%rax)
je 0x63868
xorl %ecx, %ecx
jmp 0x63876
movq 0x188(%r14), %rax
testb %sil, (%rax,%rcx)
sete %cl
movl (%rbx), %eax
movl 0x4(%rbx), %esi
leaq (%r8,%rsi), %rdx
addq -0x60(%rbp), %rsi
movzwl 0x8(%rbx), %r14d
cmpl $0x1, %eax
je 0x638a8
cmpl $0x4, %eax
je 0x638db
cmpl $0x8, %eax
jne 0x63963
decq %r14
movzwl 0xc(%rbx), %eax
addq %rax, %rdx
addq %rax, %rsi
cmpq $0xff, %r14
ja 0x6393e
movq -0x48(%rbp), %rax
movzbl (%rax), %edi
incq %rax
movq %rax, -0x48(%rbp)
testb %cl, %cl
je 0x63987
movq -0x40(%rbp), %rax
movzbl (%rax), %r14d
incq %rax
jmp 0x6395d
movq %rsi, -0x90(%rbp)
addl $-0x8, %r14d
movl %r14d, %edi
movq %rdx, %rsi
movq %r8, %r13
movl %ecx, -0x34(%rbp)
callq 0x3e2cf
movl 0x4(%rbx), %ecx
addq %r13, %rcx
movq (%r14,%rcx), %r13
cmpb $0x0, -0x34(%rbp)
je 0x639e7
movq %rax, -0x88(%rbp)
movl %r14d, %edi
movq -0x90(%rbp), %rsi
callq 0x3e2cf
movq -0x88(%rbp), %rdi
movl 0x4(%rbx), %ecx
addq -0x60(%rbp), %rcx
movq (%r14,%rcx), %rsi
movl -0x34(%rbp), %ecx
movq %rax, %r14
movq %r13, %rdx
jmp 0x63966
movq -0x48(%rbp), %rax
movzwl (%rax), %edi
addq $0x2, %rax
movq %rax, -0x48(%rbp)
testb %cl, %cl
je 0x63987
movq -0x40(%rbp), %rax
movzwl (%rax), %r14d
addq $0x2, %rax
movq %rax, -0x40(%rbp)
jmp 0x63966
movq %r14, %rdi
cmpq %rdi, %r14
sete %al
andb %al, %cl
cmpb $0x1, %cl
jne 0x63987
movq %rdx, %r13
movq %rdx, %rdi
movq %r14, %rdx
callq 0x29560
testl %eax, %eax
jne 0x6398d
jmp 0x639d6
movq %rdx, %r13
movq %rdi, %r14
movq %r15, %rsi
movq -0x58(%rbp), %rax
subq 0x588(%rax), %rsi
sarq $0x3, %rsi
movabsq $0x6db6db6db6db6db7, %rax # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %rsi
movq -0x30(%rbp), %rdi
callq 0x5ed2a
movq %rax, %rdi
movq %r14, %rsi
callq 0x5ed2a
movq %rax, -0x30(%rbp)
movq %r13, (%r12)
movq %r14, 0x8(%r12)
addq %r14, -0x50(%rbp)
addq $0x10, %r12
movq -0x78(%rbp), %r14
movq -0x70(%rbp), %r8
movq -0x68(%rbp), %r9
jmp 0x637f2
movq %rax, %r14
jmp 0x6398d
movq -0xa0(%rbp), %rbx
subq %rbx, %r12
shrq $0x4, %r12
movq -0x98(%rbp), %rax
movl %r12d, (%rax)
movq -0x30(%rbp), %r14
movl %r14d, %esi
movq -0x80(%rbp), %rdi
subl %edi, %esi
movq $-0x1, %rax
cmpl $0xfb, %esi
jb 0x63a40
xorl %eax, %eax
cmpl $0xffff, %esi # imm = 0xFFFF
ja 0x63a36
cmpl $0x100, %esi # imm = 0x100
adcq $-0x3, %rax
jmp 0x63a40
cmpl $0x1000000, %esi # imm = 0x1000000
adcq $-0x5, %rax
addq %rax, %rdi
movq %rdi, (%rbx)
callq 0x5ed2a
subq (%rbx), %r14
movq %r14, 0x8(%rbx)
addq -0x50(%rbp), %r14
movq %r14, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| fill_update_undo_parts:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov [rbp+var_98], r8
mov rbx, rcx
mov rax, rdx
mov r14, rsi
mov r13, [rdi]
mov rcx, [rdi+0D0h]
mov [rbp+var_48], rcx
mov rcx, [rdi+190h]
mov [rbp+var_40], rcx
mov [rbp+var_78], rdi
mov r15, [rdi+3C8h]
lea rcx, [r15+4]
mov [rbp+var_80], rcx
mov edx, [r13+3FCh]
mov rdi, rsi
mov [rbp+var_60], rax
mov rsi, rax
call _bcmp
test eax, eax
mov [rbp+var_A0], rbx
jz short loc_63704
mov byte ptr [r15+4], 0FFh
add r15, 5
mov [rbx+10h], r14
mov eax, [r13+3FCh]
mov [rbp+var_50], rax
mov [rbx+18h], rax
lea r12, [rbx+20h]
jmp short loc_63714
loc_63704:
lea r12, [rbx+10h]
mov [rbp+var_50], 0
mov r15, [rbp+var_80]
loc_63714:
mov r8, r14
mov [rbp+var_30], r15
mov rbx, [r13+588h]
mov eax, [r13+3CCh]
test rax, rax
mov [rbp+var_58], r13
jz loc_637BC
imul r14, rax, 38h ; '8'
add r14, rbx
mov r15, rbx
loc_63740:
mov esi, [rbx+4]
lea rdi, [r8+rsi]
add rsi, [rbp+var_60]
movzx edx, word ptr [rbx+8]
mov r13, r8
call _bcmp
test eax, eax
jz short loc_6379F
mov rax, r15
mov rcx, [rbp+var_58]
sub rax, [rcx+588h]
shr rax, 3
imul esi, eax, 0B6DB6DB7h
mov rdi, [rbp+var_30]
call ma_store_length
mov [rbp+var_30], rax
mov eax, [rbx+4]
add rax, r13
mov [r12], rax
movzx eax, word ptr [rbx+8]
mov [r12+8], rax
movzx eax, word ptr [rbx+8]
add [rbp+var_50], rax
add r12, 10h
loc_6379F:
mov r8, r13
add rbx, 38h ; '8'
add r15, 38h ; '8'
cmp rbx, r14
jb short loc_63740
mov r13, [rbp+var_58]
mov rax, [r13+588h]
jmp short loc_637BF
loc_637BC:
mov rax, rbx
loc_637BF:
mov ecx, [r13+3C8h]
imul r9, rcx, 38h ; '8'
add r9, rax
cmp rbx, r9
mov r14, [rbp+var_78]
jnb loc_639EC
mov r15, rbx
mov [rbp+var_70], r8
mov [rbp+var_68], r9
loc_637E5:
movzx eax, word ptr [rbx+0Eh]
mov dl, [rbx+12h]
test [r8+rax], dl
jz short loc_63804
loc_637F2:
add rbx, 38h ; '8'
add r15, 38h ; '8'
cmp rbx, r9
jb short loc_637E5
jmp loc_639EC
loc_63804:
mov rdi, [r14+0C8h]
movzx ecx, word ptr [rbx+10h]
mov sil, [rbx+13h]
test [rdi+rcx], sil
jz short loc_6385B
mov rax, [r14+188h]
test [rax+rcx], sil
jnz short loc_637F2
mov rax, r15
mov rcx, [rbp+var_58]
sub rax, [rcx+588h]
shr rax, 3
imul esi, eax, 0B6DB6DB7h
mov rdi, [rbp+var_30]
call ma_store_length
mov r9, [rbp+var_68]
mov r8, [rbp+var_70]
mov byte ptr [rax], 0
inc rax
mov [rbp+var_30], rax
jmp short loc_637F2
loc_6385B:
mov rdi, [rbp+var_60]
test [rdi+rax], dl
jz short loc_63868
xor ecx, ecx
jmp short loc_63876
loc_63868:
mov rax, [r14+188h]
test [rax+rcx], sil
setz cl
loc_63876:
mov eax, [rbx]
mov esi, [rbx+4]
lea rdx, [r8+rsi]
add rsi, [rbp+var_60]
movzx r14d, word ptr [rbx+8]
cmp eax, 1
jz short loc_638A8
cmp eax, 4
jz short loc_638DB
cmp eax, 8
jnz loc_63963
dec r14
movzx eax, word ptr [rbx+0Ch]
add rdx, rax
add rsi, rax
loc_638A8:
cmp r14, 0FFh
ja loc_6393E
mov rax, [rbp+var_48]
movzx edi, byte ptr [rax]
inc rax
mov [rbp+var_48], rax
test cl, cl
jz loc_63987
mov rax, [rbp+var_40]
movzx r14d, byte ptr [rax]
inc rax
jmp loc_6395D
loc_638DB:
mov [rbp+var_90], rsi
add r14d, 0FFFFFFF8h
mov edi, r14d
mov rsi, rdx
mov r13, r8
mov [rbp+var_34], ecx
call _ma_calc_blob_length
mov ecx, [rbx+4]
add rcx, r13
mov r13, [r14+rcx]
cmp byte ptr [rbp+var_34], 0
jz loc_639E7
mov [rbp+var_88], rax
mov edi, r14d
mov rsi, [rbp+var_90]
call _ma_calc_blob_length
mov rdi, [rbp+var_88]
mov ecx, [rbx+4]
add rcx, [rbp+var_60]
mov rsi, [r14+rcx]
mov ecx, [rbp+var_34]
mov r14, rax
mov rdx, r13
jmp short loc_63966
loc_6393E:
mov rax, [rbp+var_48]
movzx edi, word ptr [rax]
add rax, 2
mov [rbp+var_48], rax
test cl, cl
jz short loc_63987
mov rax, [rbp+var_40]
movzx r14d, word ptr [rax]
add rax, 2
loc_6395D:
mov [rbp+var_40], rax
jmp short loc_63966
loc_63963:
mov rdi, r14
loc_63966:
cmp r14, rdi
setz al
and cl, al
cmp cl, 1
jnz short loc_63987
mov r13, rdx
mov rdi, rdx
mov rdx, r14
call _bcmp
test eax, eax
jnz short loc_6398D
jmp short loc_639D6
loc_63987:
mov r13, rdx
mov r14, rdi
loc_6398D:
mov rsi, r15
mov rax, [rbp+var_58]
sub rsi, [rax+588h]
sar rsi, 3
mov rax, 6DB6DB6DB6DB6DB7h
imul rsi, rax
mov rdi, [rbp+var_30]
call ma_store_length
mov rdi, rax
mov rsi, r14
call ma_store_length
mov [rbp+var_30], rax
mov [r12], r13
mov [r12+8], r14
add [rbp+var_50], r14
add r12, 10h
loc_639D6:
mov r14, [rbp+var_78]
mov r8, [rbp+var_70]
mov r9, [rbp+var_68]
jmp loc_637F2
loc_639E7:
mov r14, rax
jmp short loc_6398D
loc_639EC:
mov rbx, [rbp+var_A0]
sub r12, rbx
shr r12, 4
mov rax, [rbp+var_98]
mov [rax], r12d
mov r14, [rbp+var_30]
mov esi, r14d
mov rdi, [rbp+var_80]
sub esi, edi
mov rax, 0FFFFFFFFFFFFFFFFh
cmp esi, 0FBh
jb short loc_63A40
xor eax, eax
cmp esi, 0FFFFh
ja short loc_63A36
cmp esi, 100h
adc rax, 0FFFFFFFFFFFFFFFDh
jmp short loc_63A40
loc_63A36:
cmp esi, 1000000h
adc rax, 0FFFFFFFFFFFFFFFBh
loc_63A40:
add rdi, rax
mov [rbx], rdi
call ma_store_length
sub r14, [rbx]
mov [rbx+8], r14
add r14, [rbp+var_50]
mov rax, r14
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long fill_update_undo_parts(_QWORD *a1, long long a2, long long a3, char *a4, _DWORD *a5)
{
long long v6; // r13
long long v7; // r15
long long v8; // r15
char *v9; // r12
long long v10; // r8
int *v11; // rbx
unsigned long long v12; // r14
long long v13; // r15
long long v14; // r13
long long v15; // rax
long long v16; // rcx
unsigned long long v17; // r9
_QWORD *v18; // r14
int *v19; // r15
long long v20; // rax
unsigned __int8 v21; // dl
long long v22; // rcx
unsigned __int8 v23; // si
_BYTE *v24; // rax
bool v25; // cl
int v26; // eax
long long v27; // rsi
unsigned __int8 *v28; // rdx
unsigned __int8 *v29; // rsi
unsigned long long v30; // r14
long long v31; // rax
unsigned long long v32; // rdi
unsigned __int16 *v33; // rax
long long v34; // r14
long long v35; // r13
unsigned long long v36; // rax
unsigned __int8 *v37; // r13
unsigned long long v38; // rax
long long v39; // rax
unsigned long long v40; // rsi
long long v41; // rax
long long v42; // r14
unsigned long long v46; // [rsp+18h] [rbp-88h]
long long v47; // [rsp+20h] [rbp-80h]
long long v49; // [rsp+30h] [rbp-70h]
unsigned long long v50; // [rsp+38h] [rbp-68h]
long long v52; // [rsp+48h] [rbp-58h]
long long v53; // [rsp+50h] [rbp-50h]
unsigned __int16 *v54; // [rsp+58h] [rbp-48h]
unsigned __int16 *v55; // [rsp+60h] [rbp-40h]
bool v56; // [rsp+6Ch] [rbp-34h]
long long v57; // [rsp+70h] [rbp-30h]
v6 = *a1;
v54 = (unsigned __int16 *)a1[26];
v55 = (unsigned __int16 *)a1[50];
v7 = a1[121];
v47 = v7 + 4;
if ( (unsigned int)bcmp(a2, a3, *(unsigned int *)(*a1 + 1020LL)) )
{
*(_BYTE *)(v7 + 4) = -1;
v8 = v7 + 5;
*((_QWORD *)a4 + 2) = a2;
v53 = *(unsigned int *)(v6 + 1020);
*((_QWORD *)a4 + 3) = v53;
v9 = a4 + 32;
}
else
{
v9 = a4 + 16;
v53 = 0LL;
v8 = v7 + 4;
}
v10 = a2;
v57 = v8;
v11 = *(int **)(v6 + 1416);
v52 = v6;
if ( *(_DWORD *)(v6 + 972) )
{
v12 = (unsigned long long)&v11[14 * *(unsigned int *)(v6 + 972)];
v13 = *(_QWORD *)(v6 + 1416);
do
{
v14 = v10;
if ( (unsigned int)bcmp(v10 + (unsigned int)v11[1], a3 + (unsigned int)v11[1], *((unsigned __int16 *)v11 + 4)) )
{
v57 = ma_store_length(v57, -1227133513 * (unsigned int)((unsigned long long)(v13 - *(_QWORD *)(v52 + 1416)) >> 3));
*(_QWORD *)v9 = v14 + (unsigned int)v11[1];
*((_QWORD *)v9 + 1) = *((unsigned __int16 *)v11 + 4);
v53 += *((unsigned __int16 *)v11 + 4);
v9 += 16;
}
v10 = v14;
v11 += 14;
v13 += 56LL;
}
while ( (unsigned long long)v11 < v12 );
v6 = v52;
v15 = *(_QWORD *)(v52 + 1416);
}
else
{
v15 = *(_QWORD *)(v6 + 1416);
}
v16 = *(unsigned int *)(v6 + 968);
v17 = v15 + 56 * v16;
v18 = a1;
if ( (unsigned long long)v11 < v17 )
{
v19 = v11;
v49 = v10;
v50 = v15 + 56 * v16;
while ( 1 )
{
v20 = *((unsigned __int16 *)v11 + 7);
v21 = *((_BYTE *)v11 + 18);
if ( (v21 & *(_BYTE *)(v10 + v20)) == 0 )
break;
LABEL_14:
v11 += 14;
v19 += 14;
if ( (unsigned long long)v11 >= v17 )
goto LABEL_42;
}
v22 = *((unsigned __int16 *)v11 + 8);
v23 = *((_BYTE *)v11 + 19);
if ( (v23 & *(_BYTE *)(v18[25] + v22)) != 0 )
{
if ( (v23 & *(_BYTE *)(v18[49] + v22)) == 0 )
{
v24 = (_BYTE *)ma_store_length(
v57,
-1227133513 * (unsigned int)(((unsigned long long)v19 - *(_QWORD *)(v52 + 1416)) >> 3));
v17 = v50;
v10 = v49;
*v24 = 0;
v57 = (long long)(v24 + 1);
}
goto LABEL_14;
}
v25 = (v21 & *(_BYTE *)(a3 + v20)) == 0 && (v23 & *(_BYTE *)(v18[49] + v22)) == 0;
v26 = *v11;
v27 = (unsigned int)v11[1];
v28 = (unsigned __int8 *)(v10 + v27);
v29 = (unsigned __int8 *)(a3 + v27);
v30 = *((unsigned __int16 *)v11 + 4);
if ( *v11 != 1 )
{
if ( v26 == 4 )
{
v34 = (unsigned int)(v30 - 8);
v35 = v10;
v56 = v25;
v36 = ma_calc_blob_length(v34, v28);
v37 = *(unsigned __int8 **)(v34 + v35 + (unsigned int)v11[1]);
if ( !v56 )
{
v30 = v36;
goto LABEL_39;
}
v46 = v36;
v38 = ma_calc_blob_length(v34, v29);
v32 = v46;
v29 = *(unsigned __int8 **)(v34 + a3 + (unsigned int)v11[1]);
v25 = v56;
v30 = v38;
v28 = v37;
goto LABEL_35;
}
if ( v26 != 8 )
{
v32 = *((unsigned __int16 *)v11 + 4);
LABEL_35:
if ( v30 == v32 && v25 )
{
v37 = v28;
if ( !(unsigned int)bcmp(v28, v29, v30) )
goto LABEL_40;
goto LABEL_39;
}
goto LABEL_38;
}
--v30;
v31 = *((unsigned __int16 *)v11 + 6);
v28 += v31;
v29 += v31;
}
if ( v30 > 0xFF )
{
v32 = *v54++;
if ( v25 )
{
v30 = *v55;
v33 = v55 + 1;
goto LABEL_33;
}
}
else
{
v32 = *(unsigned __int8 *)v54;
v54 = (unsigned __int16 *)((char *)v54 + 1);
if ( v25 )
{
v30 = *(unsigned __int8 *)v55;
v33 = (unsigned __int16 *)((char *)v55 + 1);
LABEL_33:
v55 = v33;
goto LABEL_35;
}
}
LABEL_38:
v37 = v28;
v30 = v32;
LABEL_39:
v39 = ma_store_length(v57, 0x6DB6DB6DB6DB6DB7LL * (((long long)v19 - *(_QWORD *)(v52 + 1416)) >> 3));
v57 = ma_store_length(v39, v30);
*(_QWORD *)v9 = v37;
*((_QWORD *)v9 + 1) = v30;
v53 += v30;
v9 += 16;
LABEL_40:
v18 = a1;
v10 = v49;
v17 = v50;
goto LABEL_14;
}
LABEL_42:
*a5 = (unsigned long long)(v9 - a4) >> 4;
v40 = (unsigned int)(v57 - v47);
v41 = -1LL;
if ( (unsigned int)v40 >= 0xFB )
{
if ( (unsigned int)v40 > 0xFFFF )
v41 = ((unsigned int)v40 < 0x1000000) - 5LL;
else
v41 = ((unsigned int)v40 < 0x100) - 3LL;
}
*(_QWORD *)a4 = v41 + v47;
ma_store_length(v41 + v47, v40);
v42 = v57 - *(_QWORD *)a4;
*((_QWORD *)a4 + 1) = v42;
return v53 + v42;
}
| fill_update_undo_parts:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RBP + -0x98],R8
MOV RBX,RCX
MOV RAX,RDX
MOV R14,RSI
MOV R13,qword ptr [RDI]
MOV RCX,qword ptr [RDI + 0xd0]
MOV qword ptr [RBP + -0x48],RCX
MOV RCX,qword ptr [RDI + 0x190]
MOV qword ptr [RBP + -0x40],RCX
MOV qword ptr [RBP + -0x78],RDI
MOV R15,qword ptr [RDI + 0x3c8]
LEA RCX,[R15 + 0x4]
MOV qword ptr [RBP + -0x80],RCX
MOV EDX,dword ptr [R13 + 0x3fc]
MOV RDI,RSI
MOV qword ptr [RBP + -0x60],RAX
MOV RSI,RAX
CALL 0x00129560
TEST EAX,EAX
MOV qword ptr [RBP + -0xa0],RBX
JZ 0x00163704
MOV byte ptr [R15 + 0x4],0xff
ADD R15,0x5
MOV qword ptr [RBX + 0x10],R14
MOV EAX,dword ptr [R13 + 0x3fc]
MOV qword ptr [RBP + -0x50],RAX
MOV qword ptr [RBX + 0x18],RAX
LEA R12,[RBX + 0x20]
JMP 0x00163714
LAB_00163704:
LEA R12,[RBX + 0x10]
MOV qword ptr [RBP + -0x50],0x0
MOV R15,qword ptr [RBP + -0x80]
LAB_00163714:
MOV R8,R14
MOV qword ptr [RBP + -0x30],R15
MOV RBX,qword ptr [R13 + 0x588]
MOV EAX,dword ptr [R13 + 0x3cc]
TEST RAX,RAX
MOV qword ptr [RBP + -0x58],R13
JZ 0x001637bc
IMUL R14,RAX,0x38
ADD R14,RBX
MOV R15,RBX
LAB_00163740:
MOV ESI,dword ptr [RBX + 0x4]
LEA RDI,[R8 + RSI*0x1]
ADD RSI,qword ptr [RBP + -0x60]
MOVZX EDX,word ptr [RBX + 0x8]
MOV R13,R8
CALL 0x00129560
TEST EAX,EAX
JZ 0x0016379f
MOV RAX,R15
MOV RCX,qword ptr [RBP + -0x58]
SUB RAX,qword ptr [RCX + 0x588]
SHR RAX,0x3
IMUL ESI,EAX,-0x49249249
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x0015ed2a
MOV qword ptr [RBP + -0x30],RAX
MOV EAX,dword ptr [RBX + 0x4]
ADD RAX,R13
MOV qword ptr [R12],RAX
MOVZX EAX,word ptr [RBX + 0x8]
MOV qword ptr [R12 + 0x8],RAX
MOVZX EAX,word ptr [RBX + 0x8]
ADD qword ptr [RBP + -0x50],RAX
ADD R12,0x10
LAB_0016379f:
MOV R8,R13
ADD RBX,0x38
ADD R15,0x38
CMP RBX,R14
JC 0x00163740
MOV R13,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [R13 + 0x588]
JMP 0x001637bf
LAB_001637bc:
MOV RAX,RBX
LAB_001637bf:
MOV ECX,dword ptr [R13 + 0x3c8]
IMUL R9,RCX,0x38
ADD R9,RAX
CMP RBX,R9
MOV R14,qword ptr [RBP + -0x78]
JNC 0x001639ec
MOV R15,RBX
MOV qword ptr [RBP + -0x70],R8
MOV qword ptr [RBP + -0x68],R9
LAB_001637e5:
MOVZX EAX,word ptr [RBX + 0xe]
MOV DL,byte ptr [RBX + 0x12]
TEST byte ptr [R8 + RAX*0x1],DL
JZ 0x00163804
LAB_001637f2:
ADD RBX,0x38
ADD R15,0x38
CMP RBX,R9
JC 0x001637e5
JMP 0x001639ec
LAB_00163804:
MOV RDI,qword ptr [R14 + 0xc8]
MOVZX ECX,word ptr [RBX + 0x10]
MOV SIL,byte ptr [RBX + 0x13]
TEST byte ptr [RDI + RCX*0x1],SIL
JZ 0x0016385b
MOV RAX,qword ptr [R14 + 0x188]
TEST byte ptr [RAX + RCX*0x1],SIL
JNZ 0x001637f2
MOV RAX,R15
MOV RCX,qword ptr [RBP + -0x58]
SUB RAX,qword ptr [RCX + 0x588]
SHR RAX,0x3
IMUL ESI,EAX,-0x49249249
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x0015ed2a
MOV R9,qword ptr [RBP + -0x68]
MOV R8,qword ptr [RBP + -0x70]
MOV byte ptr [RAX],0x0
INC RAX
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001637f2
LAB_0016385b:
MOV RDI,qword ptr [RBP + -0x60]
TEST byte ptr [RDI + RAX*0x1],DL
JZ 0x00163868
XOR ECX,ECX
JMP 0x00163876
LAB_00163868:
MOV RAX,qword ptr [R14 + 0x188]
TEST byte ptr [RAX + RCX*0x1],SIL
SETZ CL
LAB_00163876:
MOV EAX,dword ptr [RBX]
MOV ESI,dword ptr [RBX + 0x4]
LEA RDX,[R8 + RSI*0x1]
ADD RSI,qword ptr [RBP + -0x60]
MOVZX R14D,word ptr [RBX + 0x8]
CMP EAX,0x1
JZ 0x001638a8
CMP EAX,0x4
JZ 0x001638db
CMP EAX,0x8
JNZ 0x00163963
DEC R14
MOVZX EAX,word ptr [RBX + 0xc]
ADD RDX,RAX
ADD RSI,RAX
LAB_001638a8:
CMP R14,0xff
JA 0x0016393e
MOV RAX,qword ptr [RBP + -0x48]
MOVZX EDI,byte ptr [RAX]
INC RAX
MOV qword ptr [RBP + -0x48],RAX
TEST CL,CL
JZ 0x00163987
MOV RAX,qword ptr [RBP + -0x40]
MOVZX R14D,byte ptr [RAX]
INC RAX
JMP 0x0016395d
LAB_001638db:
MOV qword ptr [RBP + -0x90],RSI
ADD R14D,-0x8
MOV EDI,R14D
MOV RSI,RDX
MOV R13,R8
MOV dword ptr [RBP + -0x34],ECX
CALL 0x0013e2cf
MOV ECX,dword ptr [RBX + 0x4]
ADD RCX,R13
MOV R13,qword ptr [R14 + RCX*0x1]
CMP byte ptr [RBP + -0x34],0x0
JZ 0x001639e7
MOV qword ptr [RBP + -0x88],RAX
MOV EDI,R14D
MOV RSI,qword ptr [RBP + -0x90]
CALL 0x0013e2cf
MOV RDI,qword ptr [RBP + -0x88]
MOV ECX,dword ptr [RBX + 0x4]
ADD RCX,qword ptr [RBP + -0x60]
MOV RSI,qword ptr [R14 + RCX*0x1]
MOV ECX,dword ptr [RBP + -0x34]
MOV R14,RAX
MOV RDX,R13
JMP 0x00163966
LAB_0016393e:
MOV RAX,qword ptr [RBP + -0x48]
MOVZX EDI,word ptr [RAX]
ADD RAX,0x2
MOV qword ptr [RBP + -0x48],RAX
TEST CL,CL
JZ 0x00163987
MOV RAX,qword ptr [RBP + -0x40]
MOVZX R14D,word ptr [RAX]
ADD RAX,0x2
LAB_0016395d:
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00163966
LAB_00163963:
MOV RDI,R14
LAB_00163966:
CMP R14,RDI
SETZ AL
AND CL,AL
CMP CL,0x1
JNZ 0x00163987
MOV R13,RDX
MOV RDI,RDX
MOV RDX,R14
CALL 0x00129560
TEST EAX,EAX
JNZ 0x0016398d
JMP 0x001639d6
LAB_00163987:
MOV R13,RDX
MOV R14,RDI
LAB_0016398d:
MOV RSI,R15
MOV RAX,qword ptr [RBP + -0x58]
SUB RSI,qword ptr [RAX + 0x588]
SAR RSI,0x3
MOV RAX,0x6db6db6db6db6db7
IMUL RSI,RAX
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x0015ed2a
MOV RDI,RAX
MOV RSI,R14
CALL 0x0015ed2a
MOV qword ptr [RBP + -0x30],RAX
MOV qword ptr [R12],R13
MOV qword ptr [R12 + 0x8],R14
ADD qword ptr [RBP + -0x50],R14
ADD R12,0x10
LAB_001639d6:
MOV R14,qword ptr [RBP + -0x78]
MOV R8,qword ptr [RBP + -0x70]
MOV R9,qword ptr [RBP + -0x68]
JMP 0x001637f2
LAB_001639e7:
MOV R14,RAX
JMP 0x0016398d
LAB_001639ec:
MOV RBX,qword ptr [RBP + -0xa0]
SUB R12,RBX
SHR R12,0x4
MOV RAX,qword ptr [RBP + -0x98]
MOV dword ptr [RAX],R12D
MOV R14,qword ptr [RBP + -0x30]
MOV ESI,R14D
MOV RDI,qword ptr [RBP + -0x80]
SUB ESI,EDI
MOV RAX,-0x1
CMP ESI,0xfb
JC 0x00163a40
XOR EAX,EAX
CMP ESI,0xffff
JA 0x00163a36
CMP ESI,0x100
ADC RAX,-0x3
JMP 0x00163a40
LAB_00163a36:
CMP ESI,0x1000000
ADC RAX,-0x5
LAB_00163a40:
ADD RDI,RAX
MOV qword ptr [RBX],RDI
CALL 0x0015ed2a
SUB R14,qword ptr [RBX]
MOV qword ptr [RBX + 0x8],R14
ADD R14,qword ptr [RBP + -0x50]
MOV RAX,R14
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long fill_update_undo_parts
(long *param_1,void *param_2,void *param_3,long *param_4,int4 *param_5)
{
int1 *puVar1;
byte bVar2;
long lVar3;
ushort uVar4;
int iVar5;
int *piVar6;
size_t __n;
int8 uVar7;
long lVar8;
ulong uVar9;
void *__s1;
int *piVar10;
uint uVar11;
void *__s2;
long *plVar12;
uint uVar13;
int *piVar14;
size_t sVar15;
bool bVar16;
ulong local_58;
ushort *local_50;
ushort *local_48;
int1 *local_38;
lVar8 = *param_1;
local_50 = (ushort *)param_1[0x1a];
local_48 = (ushort *)param_1[0x32];
lVar3 = param_1[0x79];
puVar1 = (int1 *)(lVar3 + 4);
iVar5 = bcmp(param_2,param_3,(ulong)*(uint *)(lVar8 + 0x3fc));
if (iVar5 == 0) {
plVar12 = param_4 + 2;
local_58 = 0;
local_38 = puVar1;
}
else {
*(int1 *)(lVar3 + 4) = 0xff;
param_4[2] = (long)param_2;
local_58 = (ulong)*(uint *)(lVar8 + 0x3fc);
param_4[3] = local_58;
plVar12 = param_4 + 4;
local_38 = (int1 *)(lVar3 + 5);
}
piVar6 = *(int **)(lVar8 + 0x588);
piVar10 = piVar6;
if ((ulong)*(uint *)(lVar8 + 0x3cc) != 0) {
piVar14 = piVar6 + (ulong)*(uint *)(lVar8 + 0x3cc) * 0xe;
do {
iVar5 = bcmp((void *)((long)param_2 + (ulong)(uint)piVar10[1]),
(void *)((ulong)(uint)piVar10[1] + (long)param_3),(ulong)*(ushort *)(piVar10 + 2)
);
if (iVar5 != 0) {
local_38 = (int1 *)
ma_store_length(local_38,(int)((ulong)((long)piVar6 - *(long *)(lVar8 + 0x588))
>> 3) * -0x49249249);
*plVar12 = (ulong)(uint)piVar10[1] + (long)param_2;
plVar12[1] = (ulong)*(ushort *)(piVar10 + 2);
local_58 = local_58 + *(ushort *)(piVar10 + 2);
plVar12 = plVar12 + 2;
}
piVar10 = piVar10 + 0xe;
piVar6 = piVar6 + 0xe;
} while (piVar10 < piVar14);
piVar6 = *(int **)(lVar8 + 0x588);
}
uVar11 = *(uint *)(lVar8 + 0x3c8);
piVar14 = piVar10;
do {
if (piVar6 + (ulong)uVar11 * 0xe <= piVar10) {
*param_5 = (int)((ulong)((long)plVar12 - (long)param_4) >> 4);
uVar11 = (int)local_38 - (int)puVar1;
lVar8 = -1;
if (0xfa < uVar11) {
if (uVar11 < 0x10000) {
lVar8 = (ulong)(uVar11 < 0x100) - 3;
}
else {
lVar8 = (ulong)(uVar11 < 0x1000000) - 5;
}
}
*param_4 = (long)(puVar1 + lVar8);
ma_store_length();
param_4[1] = (long)local_38 - *param_4;
return ((long)local_38 - *param_4) + local_58;
}
if ((*(byte *)((long)param_2 + (ulong)*(ushort *)((long)piVar10 + 0xe)) &
*(byte *)((long)piVar10 + 0x12)) == 0) {
uVar9 = (ulong)*(ushort *)(piVar10 + 4);
bVar2 = *(byte *)((long)piVar10 + 0x13);
if ((*(byte *)(param_1[0x19] + uVar9) & bVar2) == 0) {
if ((*(byte *)((long)param_3 + (ulong)*(ushort *)((long)piVar10 + 0xe)) &
*(byte *)((long)piVar10 + 0x12)) == 0) {
bVar16 = (*(byte *)(param_1[0x31] + uVar9) & bVar2) == 0;
}
else {
bVar16 = false;
}
iVar5 = *piVar10;
__s1 = (void *)((long)param_2 + (ulong)(uint)piVar10[1]);
__s2 = (void *)((ulong)(uint)piVar10[1] + (long)param_3);
sVar15 = (size_t)*(ushort *)(piVar10 + 2);
if (iVar5 == 1) {
LAB_001638a8:
if (sVar15 < 0x100) {
sVar15 = (size_t)(byte)*local_50;
local_50 = (ushort *)((long)local_50 + 1);
if (bVar16) {
uVar4 = *local_48;
local_48 = (ushort *)((long)local_48 + 1);
__n = (ulong)(byte)uVar4;
goto LAB_00163966;
}
}
else {
sVar15 = (size_t)*local_50;
local_50 = local_50 + 1;
if (bVar16) {
uVar4 = *local_48;
local_48 = local_48 + 1;
__n = (ulong)uVar4;
goto LAB_00163966;
}
}
}
else {
if (iVar5 == 4) {
uVar13 = *(ushort *)(piVar10 + 2) - 8;
uVar9 = (ulong)uVar13;
sVar15 = _ma_calc_blob_length(uVar9,__s1);
__s1 = *(void **)((long)param_2 + uVar9 + (uint)piVar10[1]);
if (!bVar16) goto LAB_0016398d;
__n = _ma_calc_blob_length(uVar13,__s2);
__s2 = *(void **)((long)param_3 + uVar9 + (uint)piVar10[1]);
}
else {
__n = sVar15;
if (iVar5 == 8) {
sVar15 = sVar15 - 1;
__s1 = (void *)((long)__s1 + (ulong)*(ushort *)(piVar10 + 3));
__s2 = (void *)((long)__s2 + (ulong)*(ushort *)(piVar10 + 3));
goto LAB_001638a8;
}
}
LAB_00163966:
if (((bool)(bVar16 & __n == sVar15)) &&
(iVar5 = bcmp(__s1,__s2,__n), sVar15 = __n, iVar5 == 0)) goto LAB_001637f2;
}
LAB_0016398d:
uVar7 = ma_store_length(local_38,((long)piVar14 - *(long *)(lVar8 + 0x588) >> 3) *
0x6db6db6db6db6db7);
local_38 = (int1 *)ma_store_length(uVar7,sVar15);
*plVar12 = (long)__s1;
plVar12[1] = sVar15;
local_58 = local_58 + sVar15;
plVar12 = plVar12 + 2;
}
else if ((*(byte *)(param_1[0x31] + uVar9) & bVar2) == 0) {
local_38 = (int1 *)
ma_store_length(local_38,(int)((ulong)((long)piVar14 - *(long *)(lVar8 + 0x588))
>> 3) * -0x49249249);
*local_38 = 0;
local_38 = local_38 + 1;
}
}
LAB_001637f2:
piVar10 = piVar10 + 0xe;
piVar14 = piVar14 + 0xe;
} while( true );
}
| |
41,211 | init_default_directories | eloqsql/mysys/my_default.c | static const char **init_default_directories(MEM_ROOT *alloc)
{
const char **dirs;
char *env;
int errors= 0;
DBUG_ENTER("init_default_directories");
dirs= (const char **)alloc_root(alloc, DEFAULT_DIRS_SIZE * sizeof(char *));
if (dirs == NULL)
DBUG_RETURN(NULL);
bzero((char *) dirs, DEFAULT_DIRS_SIZE * sizeof(char *));
#ifdef _WIN32
{
char fname_buffer[FN_REFLEN];
if (GetSystemWindowsDirectory(fname_buffer, sizeof(fname_buffer)))
errors += add_directory(alloc, fname_buffer, dirs);
if (GetWindowsDirectory(fname_buffer, sizeof(fname_buffer)))
errors += add_directory(alloc, fname_buffer, dirs);
errors += add_directory(alloc, "C:/", dirs);
if (my_get_module_parent(fname_buffer, sizeof(fname_buffer)) != NULL)
{
errors += add_directory(alloc, fname_buffer, dirs);
strcat_s(fname_buffer, sizeof(fname_buffer), "/data");
errors += add_directory(alloc, fname_buffer, dirs);
}
}
#else
#if defined(DEFAULT_SYSCONFDIR)
if (DEFAULT_SYSCONFDIR[0])
errors += add_directory(alloc, DEFAULT_SYSCONFDIR, dirs);
#else
errors += add_directory(alloc, "/etc/", dirs);
errors += add_directory(alloc, "/etc/mysql/", dirs);
#endif /* DEFAULT_SYSCONFDIR */
#endif
/*
If value of $MARIADB_HOME environment variable name is NULL, check
for $MYSQL_HOME
*/
if ((env= getenv("MARIADB_HOME")))
errors += add_directory(alloc, env, dirs);
else
{
if ((env= getenv("MYSQL_HOME")))
errors += add_directory(alloc, env, dirs);
}
/* Placeholder for --defaults-extra-file=<path> */
errors += add_directory(alloc, "", dirs);
#if !defined(_WIN32)
errors += add_directory(alloc, "~/", dirs);
#endif
DBUG_RETURN(errors > 0 ? NULL : dirs);
} | O3 | c | init_default_directories:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movl $0x40, %esi
callq 0x5d5af
testq %rax, %rax
je 0x5b5f0
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0x3d2be(%rip), %rsi # 0x9881e
movq %r14, %rdi
movq %rax, %rdx
callq 0x5ba26
movl %eax, %r12d
leaq 0x3d2af(%rip), %rsi # 0x98824
movq %r14, %rdi
movq %rbx, %rdx
callq 0x5ba26
movl %eax, %r15d
addl %r12d, %r15d
leaq 0x3c2b1(%rip), %rdi # 0x9783e
callq 0x367b0
testq %rax, %rax
jne 0x5b5a8
leaq 0x3c2ad(%rip), %rdi # 0x9784b
callq 0x367b0
testq %rax, %rax
je 0x5b5b9
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x5ba26
addl %eax, %r15d
leaq 0x38923(%rip), %rsi # 0x93ee3
movq %r14, %rdi
movq %rbx, %rdx
callq 0x5ba26
movl %eax, %r12d
addl %r15d, %r12d
leaq 0x3d258(%rip), %rsi # 0x98830
movq %r14, %rdi
movq %rbx, %rdx
callq 0x5ba26
movl %eax, %ecx
xorl %eax, %eax
orl %r12d, %ecx
cmoveq %rbx, %rax
jmp 0x5b5f2
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| init_default_directories:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r14, rdi
mov esi, 40h ; '@'
call alloc_root
test rax, rax
jz loc_5B5F0
mov rbx, rax
xorps xmm0, xmm0
movups xmmword ptr [rax+30h], xmm0
movups xmmword ptr [rax+20h], xmm0
movups xmmword ptr [rax+10h], xmm0
movups xmmword ptr [rax], xmm0
lea rsi, aEtc_0; "/etc/"
mov rdi, r14
mov rdx, rax
call add_directory
mov r12d, eax
lea rsi, aEtcMysql_0; "/etc/mysql/"
mov rdi, r14
mov rdx, rbx
call add_directory
mov r15d, eax
add r15d, r12d
lea rdi, aMariadbHome; "MARIADB_HOME"
call _getenv
test rax, rax
jnz short loc_5B5A8
lea rdi, aMysqlHome; "MYSQL_HOME"
call _getenv
test rax, rax
jz short loc_5B5B9
loc_5B5A8:
mov rdi, r14
mov rsi, rax
mov rdx, rbx
call add_directory
add r15d, eax
loc_5B5B9:
lea rsi, aS_0+5; ""
mov rdi, r14
mov rdx, rbx
call add_directory
mov r12d, eax
add r12d, r15d
lea rsi, asc_98830; "~/"
mov rdi, r14
mov rdx, rbx
call add_directory
mov ecx, eax
xor eax, eax
or ecx, r12d
cmovz rax, rbx
jmp short loc_5B5F2
loc_5B5F0:
xor eax, eax
loc_5B5F2:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| _OWORD * init_default_directories(long long a1)
{
_OWORD *v1; // rax
_OWORD *v2; // rbx
int v3; // r12d
int v4; // r15d
long long v5; // rax
int v6; // r12d
int v7; // ecx
_OWORD *result; // rax
v1 = (_OWORD *)alloc_root(a1, 64LL);
if ( !v1 )
return 0LL;
v2 = v1;
v1[3] = 0LL;
v1[2] = 0LL;
v1[1] = 0LL;
*v1 = 0LL;
v3 = add_directory(a1, "/etc/", v1);
v4 = v3 + add_directory(a1, "/etc/mysql/", v2);
v5 = getenv("MARIADB_HOME");
if ( v5 || (v5 = getenv("MYSQL_HOME")) != 0 )
v4 += add_directory(a1, v5, v2);
v6 = v4 + add_directory(a1, "", v2);
v7 = add_directory(a1, "~/", v2);
result = 0LL;
if ( !(v6 | v7) )
return v2;
return result;
}
| init_default_directories:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14,RDI
MOV ESI,0x40
CALL 0x0015d5af
TEST RAX,RAX
JZ 0x0015b5f0
MOV RBX,RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX + 0x30],XMM0
MOVUPS xmmword ptr [RAX + 0x20],XMM0
MOVUPS xmmword ptr [RAX + 0x10],XMM0
MOVUPS xmmword ptr [RAX],XMM0
LEA RSI,[0x19881e]
MOV RDI,R14
MOV RDX,RAX
CALL 0x0015ba26
MOV R12D,EAX
LEA RSI,[0x198824]
MOV RDI,R14
MOV RDX,RBX
CALL 0x0015ba26
MOV R15D,EAX
ADD R15D,R12D
LEA RDI,[0x19783e]
CALL 0x001367b0
TEST RAX,RAX
JNZ 0x0015b5a8
LEA RDI,[0x19784b]
CALL 0x001367b0
TEST RAX,RAX
JZ 0x0015b5b9
LAB_0015b5a8:
MOV RDI,R14
MOV RSI,RAX
MOV RDX,RBX
CALL 0x0015ba26
ADD R15D,EAX
LAB_0015b5b9:
LEA RSI,[0x193ee3]
MOV RDI,R14
MOV RDX,RBX
CALL 0x0015ba26
MOV R12D,EAX
ADD R12D,R15D
LEA RSI,[0x198830]
MOV RDI,R14
MOV RDX,RBX
CALL 0x0015ba26
MOV ECX,EAX
XOR EAX,EAX
OR ECX,R12D
CMOVZ RAX,RBX
JMP 0x0015b5f2
LAB_0015b5f0:
XOR EAX,EAX
LAB_0015b5f2:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int8 * init_default_directories(int8 param_1)
{
int iVar1;
int iVar2;
int iVar3;
int8 *puVar4;
char *pcVar5;
int8 *puVar6;
puVar4 = (int8 *)alloc_root(param_1,0x40);
if (puVar4 == (int8 *)0x0) {
puVar6 = (int8 *)0x0;
}
else {
puVar4[6] = 0;
puVar4[7] = 0;
puVar4[4] = 0;
puVar4[5] = 0;
puVar4[2] = 0;
puVar4[3] = 0;
*puVar4 = 0;
puVar4[1] = 0;
iVar1 = add_directory(param_1,"/etc/",puVar4);
iVar2 = add_directory(param_1,"/etc/mysql/",puVar4);
iVar2 = iVar2 + iVar1;
pcVar5 = getenv("MARIADB_HOME");
if ((pcVar5 != (char *)0x0) || (pcVar5 = getenv("MYSQL_HOME"), pcVar5 != (char *)0x0)) {
iVar1 = add_directory(param_1,pcVar5,puVar4);
iVar2 = iVar2 + iVar1;
}
iVar1 = add_directory(param_1,&DAT_00193ee3,puVar4);
iVar3 = add_directory(param_1,&DAT_00198830,puVar4);
puVar6 = (int8 *)0x0;
if (iVar3 == 0 && iVar1 + iVar2 == 0) {
puVar6 = puVar4;
}
}
return puVar6;
}
| |
41,212 | strlength | eloqsql/mysys/mf_format.c | size_t strlength(const char *str)
{
reg1 const char * pos;
reg2 const char * found;
DBUG_ENTER("strlength");
pos= found= str;
while (*pos)
{
if (*pos != ' ')
{
while (*++pos && *pos != ' ') {};
if (!*pos)
{
found=pos; /* String ends here */
break;
}
}
found=pos;
while (*++pos == ' ') {};
}
DBUG_RETURN((size_t) (found - str));
} | O3 | c | strlength:
pushq %rbp
movq %rsp, %rbp
movb (%rdi), %dl
movq %rdi, %rax
movq %rdi, %rcx
cmpb $0x20, %dl
je 0x94d1d
movzbl %dl, %edx
testl %edx, %edx
je 0x94d36
movzbl 0x1(%rcx), %eax
incq %rcx
testl %eax, %eax
je 0x94d33
cmpl $0x20, %eax
jne 0x94d0d
movq %rcx, %rsi
movb 0x1(%rsi), %dl
incq %rsi
cmpb $0x20, %dl
je 0x94d20
movq %rcx, %rax
movq %rsi, %rcx
jmp 0x94d01
movq %rcx, %rax
subq %rdi, %rax
popq %rbp
retq
nop
| strlength:
push rbp
mov rbp, rsp
mov dl, [rdi]
mov rax, rdi
mov rcx, rdi
loc_94D01:
cmp dl, 20h ; ' '
jz short loc_94D1D
movzx edx, dl
test edx, edx
jz short loc_94D36
loc_94D0D:
movzx eax, byte ptr [rcx+1]
inc rcx
test eax, eax
jz short loc_94D33
cmp eax, 20h ; ' '
jnz short loc_94D0D
loc_94D1D:
mov rsi, rcx
loc_94D20:
mov dl, [rsi+1]
inc rsi
cmp dl, 20h ; ' '
jz short loc_94D20
mov rax, rcx
mov rcx, rsi
jmp short loc_94D01
loc_94D33:
mov rax, rcx
loc_94D36:
sub rax, rdi
pop rbp
retn
| long long strlength(_BYTE *a1)
{
char v1; // dl
_BYTE *v2; // rax
_BYTE *v3; // rcx
int v4; // eax
_BYTE *v5; // rsi
v1 = *a1;
v2 = a1;
v3 = a1;
while ( v1 == 32 )
{
LABEL_6:
v5 = v3;
do
v1 = *++v5;
while ( v1 == 32 );
v2 = v3;
v3 = v5;
}
if ( v1 )
{
while ( 1 )
{
v4 = (unsigned __int8)*++v3;
if ( !v4 )
break;
if ( v4 == 32 )
goto LABEL_6;
}
v2 = v3;
}
return v2 - a1;
}
| strlength:
PUSH RBP
MOV RBP,RSP
MOV DL,byte ptr [RDI]
MOV RAX,RDI
MOV RCX,RDI
LAB_00194d01:
CMP DL,0x20
JZ 0x00194d1d
MOVZX EDX,DL
TEST EDX,EDX
JZ 0x00194d36
LAB_00194d0d:
MOVZX EAX,byte ptr [RCX + 0x1]
INC RCX
TEST EAX,EAX
JZ 0x00194d33
CMP EAX,0x20
JNZ 0x00194d0d
LAB_00194d1d:
MOV RSI,RCX
LAB_00194d20:
MOV DL,byte ptr [RSI + 0x1]
INC RSI
CMP DL,0x20
JZ 0x00194d20
MOV RAX,RCX
MOV RCX,RSI
JMP 0x00194d01
LAB_00194d33:
MOV RAX,RCX
LAB_00194d36:
SUB RAX,RDI
POP RBP
RET
|
long strlength(char *param_1)
{
char *pcVar1;
char *pcVar2;
char *pcVar3;
char cVar4;
char *pcVar5;
cVar4 = *param_1;
pcVar3 = param_1;
pcVar5 = param_1;
do {
pcVar2 = pcVar5;
if (cVar4 != ' ') {
if (cVar4 == '\0') {
LAB_00194d36:
return (long)pcVar3 - (long)param_1;
}
do {
pcVar1 = pcVar5 + 1;
pcVar3 = pcVar5 + 1;
if (*pcVar1 == '\0') goto LAB_00194d36;
pcVar5 = pcVar3;
pcVar2 = pcVar3;
} while (*pcVar1 != ' ');
}
do {
pcVar3 = pcVar2;
cVar4 = pcVar5[1];
pcVar5 = pcVar5 + 1;
pcVar2 = pcVar3;
} while (cVar4 == ' ');
} while( true );
}
| |
41,213 | set_dynamic | eloqsql/mysys/array.c | my_bool set_dynamic(DYNAMIC_ARRAY *array, const void *element, uint idx)
{
if (idx >= array->elements)
{
if (idx >= array->max_element && allocate_dynamic(array, idx))
return TRUE;
bzero((uchar*) (array->buffer+array->elements*array->size_of_element),
(idx - array->elements)*array->size_of_element);
array->elements=idx+1;
}
memcpy(array->buffer+(idx * array->size_of_element),element,
(size_t) array->size_of_element);
return FALSE;
} | O3 | c | set_dynamic:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movl 0x8(%rdi), %eax
cmpl %edx, %eax
ja 0x2c472
cmpl %r14d, 0xc(%r15)
ja 0x2c44f
movq %r15, %rdi
movl %r14d, %esi
callq 0x2c495
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x2c48a
movl 0x8(%r15), %eax
movl 0x14(%r15), %ecx
movl %r14d, %edx
subl %eax, %edx
imull %ecx, %edx
movl %ecx, %edi
imull %eax, %edi
addq (%r15), %rdi
xorl %esi, %esi
callq 0x24170
leal 0x1(%r14), %eax
movl %eax, 0x8(%r15)
movl 0x14(%r15), %edx
imull %edx, %r14d
addq (%r15), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24220
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| set_dynamic:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14d, edx
mov rbx, rsi
mov r15, rdi
mov eax, [rdi+8]
cmp eax, edx
ja short loc_2C472
cmp [r15+0Ch], r14d
ja short loc_2C44F
mov rdi, r15
mov esi, r14d
call allocate_dynamic
mov ecx, eax
mov al, 1
test cl, cl
jnz short loc_2C48A
mov eax, [r15+8]
loc_2C44F:
mov ecx, [r15+14h]
mov edx, r14d
sub edx, eax
imul edx, ecx
mov edi, ecx
imul edi, eax
add rdi, [r15]
xor esi, esi
call _memset
lea eax, [r14+1]
mov [r15+8], eax
loc_2C472:
mov edx, [r15+14h]
imul r14d, edx
add r14, [r15]
mov rdi, r14
mov rsi, rbx
call _memcpy
xor eax, eax
loc_2C48A:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| char set_dynamic(long long a1, long long a2, unsigned int a3)
{
unsigned int v4; // eax
char dynamic; // cl
char result; // al
v4 = *(_DWORD *)(a1 + 8);
if ( v4 <= a3 )
{
if ( *(_DWORD *)(a1 + 12) <= a3 )
{
dynamic = allocate_dynamic(a1, a3);
result = 1;
if ( dynamic )
return result;
v4 = *(_DWORD *)(a1 + 8);
}
memset(*(_QWORD *)a1 + v4 * *(_DWORD *)(a1 + 20), 0LL, *(_DWORD *)(a1 + 20) * (a3 - v4));
*(_DWORD *)(a1 + 8) = a3 + 1;
}
memcpy(*(_QWORD *)a1 + *(_DWORD *)(a1 + 20) * a3, a2, *(unsigned int *)(a1 + 20));
return 0;
}
| set_dynamic:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14D,EDX
MOV RBX,RSI
MOV R15,RDI
MOV EAX,dword ptr [RDI + 0x8]
CMP EAX,EDX
JA 0x0012c472
CMP dword ptr [R15 + 0xc],R14D
JA 0x0012c44f
MOV RDI,R15
MOV ESI,R14D
CALL 0x0012c495
MOV ECX,EAX
MOV AL,0x1
TEST CL,CL
JNZ 0x0012c48a
MOV EAX,dword ptr [R15 + 0x8]
LAB_0012c44f:
MOV ECX,dword ptr [R15 + 0x14]
MOV EDX,R14D
SUB EDX,EAX
IMUL EDX,ECX
MOV EDI,ECX
IMUL EDI,EAX
ADD RDI,qword ptr [R15]
XOR ESI,ESI
CALL 0x00124170
LEA EAX,[R14 + 0x1]
MOV dword ptr [R15 + 0x8],EAX
LAB_0012c472:
MOV EDX,dword ptr [R15 + 0x14]
IMUL R14D,EDX
ADD R14,qword ptr [R15]
MOV RDI,R14
MOV RSI,RBX
CALL 0x00124220
XOR EAX,EAX
LAB_0012c48a:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int8 set_dynamic(long *param_1,void *param_2,uint param_3)
{
char cVar1;
uint uVar2;
uVar2 = *(uint *)(param_1 + 1);
if (uVar2 <= param_3) {
if (*(uint *)((long)param_1 + 0xc) <= param_3) {
cVar1 = allocate_dynamic(param_1);
if (cVar1 != '\0') {
return 1;
}
uVar2 = *(uint *)(param_1 + 1);
}
memset((void *)((ulong)(*(int *)((long)param_1 + 0x14) * uVar2) + *param_1),0,
(ulong)((param_3 - uVar2) * *(int *)((long)param_1 + 0x14)));
*(uint *)(param_1 + 1) = param_3 + 1;
}
memcpy((void *)((ulong)(param_3 * *(uint *)((long)param_1 + 0x14)) + *param_1),param_2,
(ulong)*(uint *)((long)param_1 + 0x14));
return 0;
}
| |
41,214 | free_root | eloqsql/mysys/my_alloc.c | void free_root(MEM_ROOT *root, myf MyFlags)
{
reg1 USED_MEM *next,*old;
DBUG_ENTER("free_root");
DBUG_PRINT("enter",("root: %p flags: %lu", root, MyFlags));
#if !(defined(HAVE_valgrind) && defined(EXTRA_DEBUG))
/*
There is no point in using mark_blocks_free when using valgrind as
it will not reclaim any memory
*/
if (MyFlags & MY_MARK_BLOCKS_FREE)
{
mark_blocks_free(root);
DBUG_VOID_RETURN;
}
#endif
if (!(MyFlags & MY_KEEP_PREALLOC))
root->pre_alloc=0;
for (next=root->used; next ;)
{
old=next; next= next->next ;
if (old != root->pre_alloc)
my_free(old);
}
for (next=root->free ; next ;)
{
old=next; next= next->next;
if (old != root->pre_alloc)
my_free(old);
}
root->used=root->free=0;
if (root->pre_alloc)
{
root->free=root->pre_alloc;
root->free->left=root->pre_alloc->size-ALIGN_SIZE(sizeof(USED_MEM));
TRASH_MEM(root->pre_alloc);
root->free->next=0;
}
root->block_num= 4;
root->first_block_usage= 0;
DBUG_VOID_RETURN;
} | O3 | c | free_root:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testb $0x2, %sil
jne 0x9ef14
testb $0x1, %sil
jne 0x9eead
movq $0x0, 0x10(%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x9eecc
movq (%rdi), %r14
cmpq 0x10(%rbx), %rdi
je 0x9eec4
callq 0xa4926
movq %r14, %rdi
testq %r14, %r14
jne 0x9eeb6
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x9eeea
movq (%rdi), %r14
cmpq 0x10(%rbx), %rdi
je 0x9eee2
callq 0xa4926
movq %r14, %rdi
testq %r14, %r14
jne 0x9eed4
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x9ef5e
movq %rax, (%rbx)
movq 0x10(%rax), %rcx
addq $-0x18, %rcx
movq %rcx, 0x8(%rax)
movq (%rbx), %rax
movq $0x0, (%rax)
jmp 0x9ef5e
movq (%rbx), %rax
movq %rbx, %rcx
testq %rax, %rax
je 0x9ef33
movq %rax, %rcx
movq (%rax), %rax
movq 0x10(%rcx), %rdx
addq $-0x18, %rdx
movq %rdx, 0x8(%rcx)
jmp 0x9ef1a
movq 0x8(%rbx), %rax
movq %rax, (%rcx)
testq %rax, %rax
je 0x9ef56
movq (%rax), %rcx
movq 0x10(%rax), %rdx
addq $-0x18, %rdx
movq %rdx, 0x8(%rax)
movq %rcx, %rax
testq %rcx, %rcx
jne 0x9ef3f
movq $0x0, 0x8(%rbx)
movq $0x4, 0x28(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
| free_root:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
test sil, 2
jnz short loc_9EF14
test sil, 1
jnz short loc_9EEAD
mov qword ptr [rbx+10h], 0
loc_9EEAD:
mov rdi, [rbx+8]
test rdi, rdi
jz short loc_9EECC
loc_9EEB6:
mov r14, [rdi]
cmp rdi, [rbx+10h]
jz short loc_9EEC4
call my_free
loc_9EEC4:
mov rdi, r14
test r14, r14
jnz short loc_9EEB6
loc_9EECC:
mov rdi, [rbx]
test rdi, rdi
jz short loc_9EEEA
loc_9EED4:
mov r14, [rdi]
cmp rdi, [rbx+10h]
jz short loc_9EEE2
call my_free
loc_9EEE2:
mov rdi, r14
test r14, r14
jnz short loc_9EED4
loc_9EEEA:
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
mov rax, [rbx+10h]
test rax, rax
jz short loc_9EF5E
mov [rbx], rax
mov rcx, [rax+10h]
add rcx, 0FFFFFFFFFFFFFFE8h
mov [rax+8], rcx
mov rax, [rbx]
mov qword ptr [rax], 0
jmp short loc_9EF5E
loc_9EF14:
mov rax, [rbx]
mov rcx, rbx
loc_9EF1A:
test rax, rax
jz short loc_9EF33
mov rcx, rax
mov rax, [rax]
mov rdx, [rcx+10h]
add rdx, 0FFFFFFFFFFFFFFE8h
mov [rcx+8], rdx
jmp short loc_9EF1A
loc_9EF33:
mov rax, [rbx+8]
mov [rcx], rax
test rax, rax
jz short loc_9EF56
loc_9EF3F:
mov rcx, [rax]
mov rdx, [rax+10h]
add rdx, 0FFFFFFFFFFFFFFE8h
mov [rax+8], rdx
mov rax, rcx
test rcx, rcx
jnz short loc_9EF3F
loc_9EF56:
mov qword ptr [rbx+8], 0
loc_9EF5E:
mov qword ptr [rbx+28h], 4
pop rbx
pop r14
pop rbp
retn
| _QWORD * free_root(_QWORD *a1, char a2)
{
_QWORD *v3; // rdi
_QWORD *v4; // r14
_QWORD *v5; // rdi
_QWORD *v6; // r14
_QWORD *result; // rax
_QWORD *v8; // rax
_QWORD *v9; // rcx
_QWORD *v10; // rcx
if ( (a2 & 2) != 0 )
{
v8 = (_QWORD *)*a1;
v9 = a1;
while ( v8 )
{
v9 = v8;
v8 = (_QWORD *)*v8;
v9[1] = v9[2] - 24LL;
}
result = (_QWORD *)a1[1];
*v9 = result;
if ( result )
{
do
{
v10 = (_QWORD *)*result;
result[1] = result[2] - 24LL;
result = v10;
}
while ( v10 );
}
a1[1] = 0LL;
}
else
{
if ( (a2 & 1) == 0 )
a1[2] = 0LL;
v3 = (_QWORD *)a1[1];
if ( v3 )
{
do
{
v4 = (_QWORD *)*v3;
if ( v3 != (_QWORD *)a1[2] )
my_free(v3);
v3 = v4;
}
while ( v4 );
}
v5 = (_QWORD *)*a1;
if ( *a1 )
{
do
{
v6 = (_QWORD *)*v5;
if ( v5 != (_QWORD *)a1[2] )
my_free(v5);
v5 = v6;
}
while ( v6 );
}
*(_OWORD *)a1 = 0LL;
result = (_QWORD *)a1[2];
if ( result )
{
*a1 = result;
result[1] = result[2] - 24LL;
result = (_QWORD *)*a1;
*(_QWORD *)*a1 = 0LL;
}
}
a1[5] = 4LL;
return result;
}
| free_root:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
TEST SIL,0x2
JNZ 0x0019ef14
TEST SIL,0x1
JNZ 0x0019eead
MOV qword ptr [RBX + 0x10],0x0
LAB_0019eead:
MOV RDI,qword ptr [RBX + 0x8]
TEST RDI,RDI
JZ 0x0019eecc
LAB_0019eeb6:
MOV R14,qword ptr [RDI]
CMP RDI,qword ptr [RBX + 0x10]
JZ 0x0019eec4
CALL 0x001a4926
LAB_0019eec4:
MOV RDI,R14
TEST R14,R14
JNZ 0x0019eeb6
LAB_0019eecc:
MOV RDI,qword ptr [RBX]
TEST RDI,RDI
JZ 0x0019eeea
LAB_0019eed4:
MOV R14,qword ptr [RDI]
CMP RDI,qword ptr [RBX + 0x10]
JZ 0x0019eee2
CALL 0x001a4926
LAB_0019eee2:
MOV RDI,R14
TEST R14,R14
JNZ 0x0019eed4
LAB_0019eeea:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
MOV RAX,qword ptr [RBX + 0x10]
TEST RAX,RAX
JZ 0x0019ef5e
MOV qword ptr [RBX],RAX
MOV RCX,qword ptr [RAX + 0x10]
ADD RCX,-0x18
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBX]
MOV qword ptr [RAX],0x0
JMP 0x0019ef5e
LAB_0019ef14:
MOV RAX,qword ptr [RBX]
MOV RCX,RBX
LAB_0019ef1a:
TEST RAX,RAX
JZ 0x0019ef33
MOV RCX,RAX
MOV RAX,qword ptr [RAX]
MOV RDX,qword ptr [RCX + 0x10]
ADD RDX,-0x18
MOV qword ptr [RCX + 0x8],RDX
JMP 0x0019ef1a
LAB_0019ef33:
MOV RAX,qword ptr [RBX + 0x8]
MOV qword ptr [RCX],RAX
TEST RAX,RAX
JZ 0x0019ef56
LAB_0019ef3f:
MOV RCX,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x10]
ADD RDX,-0x18
MOV qword ptr [RAX + 0x8],RDX
MOV RAX,RCX
TEST RCX,RCX
JNZ 0x0019ef3f
LAB_0019ef56:
MOV qword ptr [RBX + 0x8],0x0
LAB_0019ef5e:
MOV qword ptr [RBX + 0x28],0x4
POP RBX
POP R14
POP RBP
RET
|
void free_root(long *param_1,byte param_2)
{
int8 *puVar1;
long lVar2;
int8 *puVar3;
long *plVar4;
long *plVar5;
long *plVar6;
bool bVar7;
if ((param_2 & 2) == 0) {
if ((param_2 & 1) == 0) {
param_1[2] = 0;
}
puVar3 = (int8 *)param_1[1];
while (puVar3 != (int8 *)0x0) {
puVar1 = (int8 *)*puVar3;
bVar7 = puVar3 != (int8 *)param_1[2];
puVar3 = puVar1;
if (bVar7) {
my_free();
}
}
puVar3 = (int8 *)*param_1;
while (puVar3 != (int8 *)0x0) {
puVar1 = (int8 *)*puVar3;
bVar7 = puVar3 != (int8 *)param_1[2];
puVar3 = puVar1;
if (bVar7) {
my_free();
}
}
*param_1 = 0;
param_1[1] = 0;
lVar2 = param_1[2];
if (lVar2 != 0) {
*param_1 = lVar2;
*(long *)(lVar2 + 8) = *(long *)(lVar2 + 0x10) + -0x18;
*(int8 *)*param_1 = 0;
}
}
else {
plVar4 = (long *)*param_1;
plVar6 = param_1;
while (plVar5 = plVar4, plVar5 != (long *)0x0) {
plVar5[1] = plVar5[2] + -0x18;
plVar4 = (long *)*plVar5;
plVar6 = plVar5;
}
puVar3 = (int8 *)param_1[1];
*plVar6 = (long)puVar3;
while (puVar3 != (int8 *)0x0) {
puVar3[1] = puVar3[2] + -0x18;
puVar3 = (int8 *)*puVar3;
}
param_1[1] = 0;
}
param_1[5] = 4;
return;
}
| |
41,215 | copy_typelib | eloqsql/mysys/typelib.c | TYPELIB *copy_typelib(MEM_ROOT *root, const TYPELIB *from)
{
TYPELIB *to;
uint i;
if (!from)
return NULL;
if (!(to= (TYPELIB*) alloc_root(root, sizeof(TYPELIB))))
return NULL;
if (!(to->type_names= (const char **)
alloc_root(root, (sizeof(char *) + sizeof(int)) * (from->count + 1))))
return NULL;
to->type_lengths= (unsigned int *)(to->type_names + from->count + 1);
to->count= from->count;
if (from->name)
{
if (!(to->name= strdup_root(root, from->name)))
return NULL;
}
else
to->name= NULL;
for (i= 0; i < from->count; i++)
{
if (!(to->type_names[i]= strmake_root(root, from->type_names[i],
from->type_lengths[i])))
return NULL;
to->type_lengths[i]= from->type_lengths[i];
}
to->type_names[to->count]= NULL;
to->type_lengths[to->count]= 0;
return to;
} | O3 | c | copy_typelib:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x325f7
movq %rsi, %r14
movq %rdi, %r15
movl $0x20, %esi
callq 0x3613f
testq %rax, %rax
je 0x325f7
movq %rax, %rbx
movl (%r14), %eax
incl %eax
shlq $0x2, %rax
leaq (%rax,%rax,2), %rsi
movq %r15, %rdi
callq 0x3613f
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x325f7
movl (%r14), %ecx
leaq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, 0x18(%rbx)
movl (%r14), %eax
movl %eax, (%rbx)
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0x32605
movq %r15, %rdi
callq 0x364da
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0x3260d
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq $0x0, 0x8(%rbx)
cmpl $0x0, (%r14)
je 0x32656
xorl %r12d, %r12d
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
movq (%rax,%r12,8), %rsi
movl (%rcx,%r12,4), %edx
movq %r15, %rdi
callq 0x36501
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
testq %rax, %rax
je 0x325f7
movq 0x18(%r14), %rax
movl (%rax,%r12,4), %eax
movq 0x18(%rbx), %rcx
movl %eax, (%rcx,%r12,4)
incq %r12
movl (%r14), %eax
cmpq %rax, %r12
jb 0x32616
movq 0x10(%rbx), %rax
movl (%rbx), %ecx
movq $0x0, (%rax,%rcx,8)
movq 0x18(%rbx), %rax
movl (%rbx), %ecx
movl $0x0, (%rax,%rcx,4)
jmp 0x325f9
| copy_typelib:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
test rsi, rsi
jz short loc_325F7
mov r14, rsi
mov r15, rdi
mov esi, 20h ; ' '
call alloc_root
test rax, rax
jz short loc_325F7
mov rbx, rax
mov eax, [r14]
inc eax
shl rax, 2
lea rsi, [rax+rax*2]
mov rdi, r15
call alloc_root
mov [rbx+10h], rax
test rax, rax
jz short loc_325F7
mov ecx, [r14]
lea rax, [rax+rcx*8]
add rax, 8
mov [rbx+18h], rax
mov eax, [r14]
mov [rbx], eax
mov rsi, [r14+8]
test rsi, rsi
jz short loc_32605
mov rdi, r15
call strdup_root
mov [rbx+8], rax
test rax, rax
jnz short loc_3260D
loc_325F7:
xor ebx, ebx
loc_325F9:
mov rax, rbx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_32605:
mov qword ptr [rbx+8], 0
loc_3260D:
cmp dword ptr [r14], 0
jz short loc_32656
xor r12d, r12d
loc_32616:
mov rax, [r14+10h]
mov rcx, [r14+18h]
mov rsi, [rax+r12*8]
mov edx, [rcx+r12*4]
mov rdi, r15
call strmake_root
mov rcx, [rbx+10h]
mov [rcx+r12*8], rax
test rax, rax
jz short loc_325F7
mov rax, [r14+18h]
mov eax, [rax+r12*4]
mov rcx, [rbx+18h]
mov [rcx+r12*4], eax
inc r12
mov eax, [r14]
cmp r12, rax
jb short loc_32616
loc_32656:
mov rax, [rbx+10h]
mov ecx, [rbx]
mov qword ptr [rax+rcx*8], 0
mov rax, [rbx+18h]
mov ecx, [rbx]
mov dword ptr [rax+rcx*4], 0
jmp short loc_325F9
| unsigned int * copy_typelib(long long a1, unsigned int *a2)
{
long long v3; // rax
unsigned int *v4; // rbx
long long v5; // rax
long long v6; // rsi
long long v7; // rax
long long v9; // r12
long long v10; // rax
if ( !a2 )
return 0LL;
v3 = alloc_root(a1, 32LL);
if ( !v3 )
return 0LL;
v4 = (unsigned int *)v3;
v5 = alloc_root(a1, 12LL * (*a2 + 1));
*((_QWORD *)v4 + 2) = v5;
if ( !v5 )
return 0LL;
*((_QWORD *)v4 + 3) = v5 + 8LL * *a2 + 8;
*v4 = *a2;
v6 = *((_QWORD *)a2 + 1);
if ( v6 )
{
v7 = strdup_root(a1, v6);
*((_QWORD *)v4 + 1) = v7;
if ( !v7 )
return 0LL;
}
else
{
*((_QWORD *)v4 + 1) = 0LL;
}
if ( !*a2 )
{
LABEL_13:
*(_QWORD *)(*((_QWORD *)v4 + 2) + 8LL * *v4) = 0LL;
*(_DWORD *)(*((_QWORD *)v4 + 3) + 4LL * *v4) = 0;
return v4;
}
v9 = 0LL;
while ( 1 )
{
v10 = strmake_root(a1, *(_QWORD *)(*((_QWORD *)a2 + 2) + 8 * v9), *(unsigned int *)(*((_QWORD *)a2 + 3) + 4 * v9));
*(_QWORD *)(*((_QWORD *)v4 + 2) + 8 * v9) = v10;
if ( !v10 )
return 0LL;
*(_DWORD *)(*((_QWORD *)v4 + 3) + 4 * v9) = *(_DWORD *)(*((_QWORD *)a2 + 3) + 4 * v9);
if ( ++v9 >= (unsigned long long)*a2 )
goto LABEL_13;
}
}
| copy_typelib:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
TEST RSI,RSI
JZ 0x001325f7
MOV R14,RSI
MOV R15,RDI
MOV ESI,0x20
CALL 0x0013613f
TEST RAX,RAX
JZ 0x001325f7
MOV RBX,RAX
MOV EAX,dword ptr [R14]
INC EAX
SHL RAX,0x2
LEA RSI,[RAX + RAX*0x2]
MOV RDI,R15
CALL 0x0013613f
MOV qword ptr [RBX + 0x10],RAX
TEST RAX,RAX
JZ 0x001325f7
MOV ECX,dword ptr [R14]
LEA RAX,[RAX + RCX*0x8]
ADD RAX,0x8
MOV qword ptr [RBX + 0x18],RAX
MOV EAX,dword ptr [R14]
MOV dword ptr [RBX],EAX
MOV RSI,qword ptr [R14 + 0x8]
TEST RSI,RSI
JZ 0x00132605
MOV RDI,R15
CALL 0x001364da
MOV qword ptr [RBX + 0x8],RAX
TEST RAX,RAX
JNZ 0x0013260d
LAB_001325f7:
XOR EBX,EBX
LAB_001325f9:
MOV RAX,RBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00132605:
MOV qword ptr [RBX + 0x8],0x0
LAB_0013260d:
CMP dword ptr [R14],0x0
JZ 0x00132656
XOR R12D,R12D
LAB_00132616:
MOV RAX,qword ptr [R14 + 0x10]
MOV RCX,qword ptr [R14 + 0x18]
MOV RSI,qword ptr [RAX + R12*0x8]
MOV EDX,dword ptr [RCX + R12*0x4]
MOV RDI,R15
CALL 0x00136501
MOV RCX,qword ptr [RBX + 0x10]
MOV qword ptr [RCX + R12*0x8],RAX
TEST RAX,RAX
JZ 0x001325f7
MOV RAX,qword ptr [R14 + 0x18]
MOV EAX,dword ptr [RAX + R12*0x4]
MOV RCX,qword ptr [RBX + 0x18]
MOV dword ptr [RCX + R12*0x4],EAX
INC R12
MOV EAX,dword ptr [R14]
CMP R12,RAX
JC 0x00132616
LAB_00132656:
MOV RAX,qword ptr [RBX + 0x10]
MOV ECX,dword ptr [RBX]
MOV qword ptr [RAX + RCX*0x8],0x0
MOV RAX,qword ptr [RBX + 0x18]
MOV ECX,dword ptr [RBX]
MOV dword ptr [RAX + RCX*0x4],0x0
JMP 0x001325f9
|
uint * copy_typelib(int8 param_1,uint *param_2)
{
uint *puVar1;
long lVar2;
ulong uVar3;
if ((param_2 != (uint *)0x0) && (puVar1 = (uint *)alloc_root(param_1,0x20), puVar1 != (uint *)0x0)
) {
lVar2 = alloc_root(param_1,(ulong)(*param_2 + 1) * 0xc);
*(long *)(puVar1 + 4) = lVar2;
if (lVar2 != 0) {
*(ulong *)(puVar1 + 6) = lVar2 + (ulong)*param_2 * 8 + 8;
*puVar1 = *param_2;
if (*(long *)(param_2 + 2) == 0) {
puVar1[2] = 0;
puVar1[3] = 0;
}
else {
lVar2 = strdup_root(param_1);
*(long *)(puVar1 + 2) = lVar2;
if (lVar2 == 0) {
return (uint *)0x0;
}
}
if (*param_2 != 0) {
uVar3 = 0;
do {
lVar2 = strmake_root(param_1,*(int8 *)(*(long *)(param_2 + 4) + uVar3 * 8),
*(int4 *)(*(long *)(param_2 + 6) + uVar3 * 4));
*(long *)(*(long *)(puVar1 + 4) + uVar3 * 8) = lVar2;
if (lVar2 == 0) {
return (uint *)0x0;
}
*(int4 *)(*(long *)(puVar1 + 6) + uVar3 * 4) =
*(int4 *)(*(long *)(param_2 + 6) + uVar3 * 4);
uVar3 = uVar3 + 1;
} while (uVar3 < *param_2);
}
*(int8 *)(*(long *)(puVar1 + 4) + (ulong)*puVar1 * 8) = 0;
*(int4 *)(*(long *)(puVar1 + 6) + (ulong)*puVar1 * 4) = 0;
return puVar1;
}
}
return (uint *)0x0;
}
| |
41,216 | mysys_namespace::crc32c::crc32c_slow(unsigned int, char const*, unsigned long) | eloqsql/mysys/crc32/crc32c.cc | static uint32_t crc32c_slow(uint32_t crc, const char* buf, size_t size)
{
const uint8_t *p = reinterpret_cast<const uint8_t *>(buf);
const uint8_t *e = p + size;
uint64_t l = crc ^ 0xffffffffu;
// Point x at first 16-byte aligned byte in string. This might be
// just past the end of the string.
const uintptr_t pval = reinterpret_cast<uintptr_t>(p);
const uint8_t* x = reinterpret_cast<const uint8_t*>(ALIGN(pval, 4));
if (x <= e)
// Process bytes until finished or p is 16-byte aligned
while (p != x)
STEP1;
// Process bytes 16 at a time
while ((e-p) >= 16)
{
Slow_CRC32(&l, &p);
Slow_CRC32(&l, &p);
}
// Process bytes 8 at a time
while ((e-p) >= 8)
Slow_CRC32(&l, &p);
// Process the last few bytes
while (p != e)
STEP1;
return static_cast<uint32_t>(l ^ 0xffffffffu);
} | O3 | cpp | mysys_namespace::crc32c::crc32c_slow(unsigned int, char const*, unsigned long):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
movl %edi, %eax
addq %rsi, %rdx
notl %eax
leaq 0xf(%rsi), %rdi
andq $-0x10, %rdi
cmpq %rdi, %rdx
setb %r8b
movq %rdi, %rcx
subq %rsi, %rcx
sete %r9b
orb %r8b, %r9b
je 0xa9567
movq %rsi, %rdi
jmp 0xa9592
leaq 0x38a02(%rip), %r8 # 0xe1f70
movq %rsi, %r9
movzbl %al, %r10d
movzbl (%r9), %r11d
incq %r9
xorl %r10d, %r11d
movl (%r8,%r11,4), %r10d
shrq $0x8, %rax
xorq %r10, %rax
cmpq %rdi, %r9
jne 0xa9571
addq %rcx, %rsi
movq %rdx, %rcx
subq %rdi, %rcx
cmpq $0x10, %rcx
jl 0xa96a2
movq %rdx, %rcx
subq %rsi, %rcx
movl $0xff, %edi
leaq 0x38dbc(%rip), %r8 # 0xe2370
leaq 0x391b5(%rip), %r9 # 0xe2770
movl $0x3fc, %r10d # imm = 0x3FC
leaq 0x395a8(%rip), %r11 # 0xe2b70
leaq 0x389a1(%rip), %rbx # 0xe1f70
xorl (%rsi), %eax
movl %eax, %r15d
andl %edi, %r15d
movl %eax, %r14d
shrl $0x8, %r14d
andl %edi, %r14d
movl (%r9,%r14,4), %r14d
xorl (%r8,%r15,4), %r14d
movl %eax, %r15d
shrl $0xe, %r15d
andl %r10d, %r15d
xorl (%r15,%r11), %r14d
shrl $0x18, %eax
xorl (%rbx,%rax,4), %r14d
xorl 0x4(%rsi), %r14d
movl %r14d, %r15d
andl %edi, %r15d
movl %r14d, %eax
shrl $0x8, %eax
andl %edi, %eax
movl (%r9,%rax,4), %eax
xorl (%r8,%r15,4), %eax
movl %r14d, %r15d
shrl $0xe, %r15d
andl %r10d, %r15d
xorl (%r15,%r11), %eax
shrl $0x18, %r14d
xorl (%rbx,%r14,4), %eax
xorl 0x8(%rsi), %eax
movl %eax, %r15d
andl %edi, %r15d
movl %eax, %r14d
shrl $0x8, %r14d
andl %edi, %r14d
movl (%r9,%r14,4), %r14d
xorl (%r8,%r15,4), %r14d
movl %eax, %r15d
shrl $0xe, %r15d
andl %r10d, %r15d
xorl (%r15,%r11), %r14d
shrl $0x18, %eax
xorl (%rbx,%rax,4), %r14d
xorl 0xc(%rsi), %r14d
addq $0x10, %rsi
movl %r14d, %r15d
andl %edi, %r15d
movl %r14d, %eax
shrl $0x8, %eax
andl %edi, %eax
movl (%r9,%rax,4), %eax
xorl (%r8,%r15,4), %eax
movl %r14d, %r15d
shrl $0xe, %r15d
andl %r10d, %r15d
xorl (%r15,%r11), %eax
shrl $0x18, %r14d
xorl (%rbx,%r14,4), %eax
addq $-0x10, %rcx
cmpq $0xf, %rcx
jg 0xa95cf
movl %eax, %eax
cmpq $0x8, %rcx
jl 0xa9748
movq %rdx, %rcx
subq %rsi, %rcx
movl $0xff, %edi
leaq 0x38cb2(%rip), %r8 # 0xe2370
leaq 0x390ab(%rip), %r9 # 0xe2770
movl $0x3fc, %r10d # imm = 0x3FC
leaq 0x3949e(%rip), %r11 # 0xe2b70
leaq 0x38897(%rip), %rbx # 0xe1f70
xorl (%rsi), %eax
movl %eax, %r15d
andl %edi, %r15d
movl %eax, %r14d
shrl $0x8, %r14d
andl %edi, %r14d
movl (%r9,%r14,4), %r14d
xorl (%r8,%r15,4), %r14d
movl %eax, %r15d
shrl $0xe, %r15d
andl %r10d, %r15d
xorl (%r15,%r11), %r14d
shrl $0x18, %eax
xorl (%rbx,%rax,4), %r14d
xorl 0x4(%rsi), %r14d
addq $0x8, %rsi
movl %r14d, %r15d
andl %edi, %r15d
movl %r14d, %eax
shrl $0x8, %eax
andl %edi, %eax
movl (%r9,%rax,4), %eax
xorl (%r8,%r15,4), %eax
movl %r14d, %r15d
shrl $0xe, %r15d
andl %r10d, %r15d
xorl (%r15,%r11), %eax
shrl $0x18, %r14d
xorl (%rbx,%r14,4), %eax
addq $-0x8, %rcx
cmpq $0x7, %rcx
jg 0xa96d9
movl %eax, %eax
cmpq %rdx, %rsi
je 0xa9771
leaq 0x3881c(%rip), %rcx # 0xe1f70
movzbl %al, %edi
movzbl (%rsi), %r8d
incq %rsi
xorl %edi, %r8d
movl (%rcx,%r8,4), %edi
shrq $0x8, %rax
xorq %rdi, %rax
cmpq %rdx, %rsi
jne 0xa9754
notl %eax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| _ZN15mysys_namespace6crc32cL11crc32c_slowEjPKcm:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
mov eax, edi
add rdx, rsi
not eax
lea rdi, [rsi+0Fh]
and rdi, 0FFFFFFFFFFFFFFF0h
cmp rdx, rdi
setb r8b
mov rcx, rdi
sub rcx, rsi
setz r9b
or r9b, r8b
jz short loc_A9567
mov rdi, rsi
jmp short loc_A9592
loc_A9567:
lea r8, _ZN15mysys_namespace6crc32cL7table0_E; mysys_namespace::crc32c::table0_
mov r9, rsi
loc_A9571:
movzx r10d, al
movzx r11d, byte ptr [r9]
inc r9
xor r11d, r10d
mov r10d, [r8+r11*4]
shr rax, 8
xor rax, r10
cmp r9, rdi
jnz short loc_A9571
add rsi, rcx
loc_A9592:
mov rcx, rdx
sub rcx, rdi
cmp rcx, 10h
jl loc_A96A2
mov rcx, rdx
sub rcx, rsi
mov edi, 0FFh
lea r8, _ZN15mysys_namespace6crc32cL7table3_E; mysys_namespace::crc32c::table3_
lea r9, _ZN15mysys_namespace6crc32cL7table2_E; mysys_namespace::crc32c::table2_
mov r10d, 3FCh
lea r11, _ZN15mysys_namespace6crc32cL7table1_E; mysys_namespace::crc32c::table1_
lea rbx, _ZN15mysys_namespace6crc32cL7table0_E; mysys_namespace::crc32c::table0_
loc_A95CF:
xor eax, [rsi]
mov r15d, eax
and r15d, edi
mov r14d, eax
shr r14d, 8
and r14d, edi
mov r14d, [r9+r14*4]
xor r14d, [r8+r15*4]
mov r15d, eax
shr r15d, 0Eh
and r15d, r10d
xor r14d, [r15+r11]
shr eax, 18h
xor r14d, [rbx+rax*4]
xor r14d, [rsi+4]
mov r15d, r14d
and r15d, edi
mov eax, r14d
shr eax, 8
and eax, edi
mov eax, [r9+rax*4]
xor eax, [r8+r15*4]
mov r15d, r14d
shr r15d, 0Eh
and r15d, r10d
xor eax, [r15+r11]
shr r14d, 18h
xor eax, [rbx+r14*4]
xor eax, [rsi+8]
mov r15d, eax
and r15d, edi
mov r14d, eax
shr r14d, 8
and r14d, edi
mov r14d, [r9+r14*4]
xor r14d, [r8+r15*4]
mov r15d, eax
shr r15d, 0Eh
and r15d, r10d
xor r14d, [r15+r11]
shr eax, 18h
xor r14d, [rbx+rax*4]
xor r14d, [rsi+0Ch]
add rsi, 10h
mov r15d, r14d
and r15d, edi
mov eax, r14d
shr eax, 8
and eax, edi
mov eax, [r9+rax*4]
xor eax, [r8+r15*4]
mov r15d, r14d
shr r15d, 0Eh
and r15d, r10d
xor eax, [r15+r11]
shr r14d, 18h
xor eax, [rbx+r14*4]
add rcx, 0FFFFFFFFFFFFFFF0h
cmp rcx, 0Fh
jg loc_A95CF
mov eax, eax
loc_A96A2:
cmp rcx, 8
jl loc_A9748
mov rcx, rdx
sub rcx, rsi
mov edi, 0FFh
lea r8, _ZN15mysys_namespace6crc32cL7table3_E; mysys_namespace::crc32c::table3_
lea r9, _ZN15mysys_namespace6crc32cL7table2_E; mysys_namespace::crc32c::table2_
mov r10d, 3FCh
lea r11, _ZN15mysys_namespace6crc32cL7table1_E; mysys_namespace::crc32c::table1_
lea rbx, _ZN15mysys_namespace6crc32cL7table0_E; mysys_namespace::crc32c::table0_
loc_A96D9:
xor eax, [rsi]
mov r15d, eax
and r15d, edi
mov r14d, eax
shr r14d, 8
and r14d, edi
mov r14d, [r9+r14*4]
xor r14d, [r8+r15*4]
mov r15d, eax
shr r15d, 0Eh
and r15d, r10d
xor r14d, [r15+r11]
shr eax, 18h
xor r14d, [rbx+rax*4]
xor r14d, [rsi+4]
add rsi, 8
mov r15d, r14d
and r15d, edi
mov eax, r14d
shr eax, 8
and eax, edi
mov eax, [r9+rax*4]
xor eax, [r8+r15*4]
mov r15d, r14d
shr r15d, 0Eh
and r15d, r10d
xor eax, [r15+r11]
shr r14d, 18h
xor eax, [rbx+r14*4]
add rcx, 0FFFFFFFFFFFFFFF8h
cmp rcx, 7
jg short loc_A96D9
mov eax, eax
loc_A9748:
cmp rsi, rdx
jz short loc_A9771
lea rcx, _ZN15mysys_namespace6crc32cL7table0_E; mysys_namespace::crc32c::table0_
loc_A9754:
movzx edi, al
movzx r8d, byte ptr [rsi]
inc rsi
xor r8d, edi
mov edi, [rcx+r8*4]
shr rax, 8
xor rax, rdi
cmp rsi, rdx
jnz short loc_A9754
loc_A9771:
not eax
pop rbx
pop r14
pop r15
pop rbp
retn
| long long mysys_namespace::crc32c::crc32c_slow(
mysys_namespace::crc32c *this,
unsigned long long a2,
const char *a3)
{
const char *v3; // rdx
unsigned long long v4; // rax
unsigned long long v5; // rdi
unsigned __int8 *v6; // r9
int v7; // r11d
long long v8; // rcx
unsigned int v9; // r14d
unsigned int v10; // eax
unsigned int v11; // r14d
long long v12; // rcx
unsigned int v13; // r14d
int v14; // r8d
v3 = &a3[a2];
v4 = (unsigned int)~(_DWORD)this;
v5 = (a2 + 15) & 0xFFFFFFFFFFFFFFF0LL;
if ( (unsigned long long)v3 < v5 || v5 == a2 )
{
v5 = a2;
}
else
{
v6 = (unsigned __int8 *)a2;
do
{
v7 = *v6++;
v4 = mysys_namespace::crc32c::table0_[(unsigned __int8)v4 ^ v7] ^ (v4 >> 8);
}
while ( v6 != (unsigned __int8 *)v5 );
a2 = (a2 + 15) & 0xFFFFFFFFFFFFFFF0LL;
}
v8 = (long long)&v3[-v5];
if ( (long long)&v3[-v5] >= 16 )
{
v8 = (long long)&v3[-a2];
do
{
v9 = *(_DWORD *)(a2 + 4) ^ mysys_namespace::crc32c::table0_[(*(_DWORD *)a2 ^ (unsigned int)v4) >> 24] ^ *(_DWORD *)&mysys_namespace::crc32c::table1_[((*(_DWORD *)a2 ^ (unsigned int)v4) >> 14) & 0x3FC] ^ mysys_namespace::crc32c::table3_[(unsigned __int8)(*(_BYTE *)a2 ^ v4)] ^ mysys_namespace::crc32c::table2_[(unsigned __int8)((unsigned __int16)(*(_WORD *)a2 ^ v4) >> 8)];
v10 = *(_DWORD *)(a2 + 8) ^ mysys_namespace::crc32c::table0_[HIBYTE(v9)] ^ *(_DWORD *)&mysys_namespace::crc32c::table1_[(v9 >> 14) & 0x3FC] ^ mysys_namespace::crc32c::table3_[(unsigned __int8)(*(_BYTE *)(a2 + 4) ^ LOBYTE(mysys_namespace::crc32c::table0_[(*(_DWORD *)a2 ^ (unsigned int)v4) >> 24]) ^ mysys_namespace::crc32c::table1_[((*(_DWORD *)a2 ^ (unsigned int)v4) >> 14) & 0x3FC] ^ LOBYTE(mysys_namespace::crc32c::table3_[(unsigned __int8)(*(_BYTE *)a2 ^ v4)]) ^ LOBYTE(mysys_namespace::crc32c::table2_[(unsigned __int8)((unsigned __int16)(*(_WORD *)a2 ^ v4) >> 8)]))] ^ mysys_namespace::crc32c::table2_[(unsigned __int8)((unsigned __int16)(*(_WORD *)(a2 + 4) ^ LOWORD(mysys_namespace::crc32c::table0_[(*(_DWORD *)a2 ^ (unsigned int)v4) >> 24]) ^ *(_WORD *)&mysys_namespace::crc32c::table1_[((*(_DWORD *)a2 ^ (unsigned int)v4) >> 14) & 0x3FC] ^ LOWORD(mysys_namespace::crc32c::table3_[(unsigned __int8)(*(_BYTE *)a2 ^ v4)]) ^ LOWORD(mysys_namespace::crc32c::table2_[(unsigned __int8)((unsigned __int16)(*(_WORD *)a2 ^ v4) >> 8)])) >> 8)];
v11 = *(_DWORD *)(a2 + 12) ^ mysys_namespace::crc32c::table0_[HIBYTE(v10)] ^ *(_DWORD *)&mysys_namespace::crc32c::table1_[(v10 >> 14) & 0x3FC] ^ mysys_namespace::crc32c::table3_[(unsigned __int8)v10] ^ mysys_namespace::crc32c::table2_[BYTE1(v10)];
a2 += 16LL;
LODWORD(v4) = mysys_namespace::crc32c::table0_[HIBYTE(v11)] ^ *(_DWORD *)&mysys_namespace::crc32c::table1_[(v11 >> 14) & 0x3FC] ^ mysys_namespace::crc32c::table3_[(unsigned __int8)v11] ^ mysys_namespace::crc32c::table2_[BYTE1(v11)];
v8 -= 16LL;
}
while ( v8 > 15 );
v4 = (unsigned int)v4;
}
if ( v8 >= 8 )
{
v12 = (long long)&v3[-a2];
do
{
v13 = *(_DWORD *)(a2 + 4) ^ mysys_namespace::crc32c::table0_[(*(_DWORD *)a2 ^ (unsigned int)v4) >> 24] ^ *(_DWORD *)&mysys_namespace::crc32c::table1_[((*(_DWORD *)a2 ^ (unsigned int)v4) >> 14) & 0x3FC] ^ mysys_namespace::crc32c::table3_[(unsigned __int8)(*(_BYTE *)a2 ^ v4)] ^ mysys_namespace::crc32c::table2_[(unsigned __int8)((unsigned __int16)(*(_WORD *)a2 ^ v4) >> 8)];
a2 += 8LL;
LODWORD(v4) = mysys_namespace::crc32c::table0_[HIBYTE(v13)] ^ *(_DWORD *)&mysys_namespace::crc32c::table1_[(v13 >> 14) & 0x3FC] ^ mysys_namespace::crc32c::table3_[(unsigned __int8)v13] ^ mysys_namespace::crc32c::table2_[BYTE1(v13)];
v12 -= 8LL;
}
while ( v12 > 7 );
v4 = (unsigned int)v4;
}
for ( ; (const char *)a2 != v3; v4 = mysys_namespace::crc32c::table0_[(unsigned __int8)v4 ^ v14] ^ (v4 >> 8) )
v14 = *(unsigned __int8 *)a2++;
return (unsigned int)~(_DWORD)v4;
}
| crc32c_slow:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
MOV EAX,EDI
ADD RDX,RSI
NOT EAX
LEA RDI,[RSI + 0xf]
AND RDI,-0x10
CMP RDX,RDI
SETC R8B
MOV RCX,RDI
SUB RCX,RSI
SETZ R9B
OR R9B,R8B
JZ 0x001a9567
MOV RDI,RSI
JMP 0x001a9592
LAB_001a9567:
LEA R8,[0x1e1f70]
MOV R9,RSI
LAB_001a9571:
MOVZX R10D,AL
MOVZX R11D,byte ptr [R9]
INC R9
XOR R11D,R10D
MOV R10D,dword ptr [R8 + R11*0x4]
SHR RAX,0x8
XOR RAX,R10
CMP R9,RDI
JNZ 0x001a9571
ADD RSI,RCX
LAB_001a9592:
MOV RCX,RDX
SUB RCX,RDI
CMP RCX,0x10
JL 0x001a96a2
MOV RCX,RDX
SUB RCX,RSI
MOV EDI,0xff
LEA R8,[0x1e2370]
LEA R9,[0x1e2770]
MOV R10D,0x3fc
LEA R11,[0x1e2b70]
LEA RBX,[0x1e1f70]
LAB_001a95cf:
XOR EAX,dword ptr [RSI]
MOV R15D,EAX
AND R15D,EDI
MOV R14D,EAX
SHR R14D,0x8
AND R14D,EDI
MOV R14D,dword ptr [R9 + R14*0x4]
XOR R14D,dword ptr [R8 + R15*0x4]
MOV R15D,EAX
SHR R15D,0xe
AND R15D,R10D
XOR R14D,dword ptr [R15 + R11*0x1]
SHR EAX,0x18
XOR R14D,dword ptr [RBX + RAX*0x4]
XOR R14D,dword ptr [RSI + 0x4]
MOV R15D,R14D
AND R15D,EDI
MOV EAX,R14D
SHR EAX,0x8
AND EAX,EDI
MOV EAX,dword ptr [R9 + RAX*0x4]
XOR EAX,dword ptr [R8 + R15*0x4]
MOV R15D,R14D
SHR R15D,0xe
AND R15D,R10D
XOR EAX,dword ptr [R15 + R11*0x1]
SHR R14D,0x18
XOR EAX,dword ptr [RBX + R14*0x4]
XOR EAX,dword ptr [RSI + 0x8]
MOV R15D,EAX
AND R15D,EDI
MOV R14D,EAX
SHR R14D,0x8
AND R14D,EDI
MOV R14D,dword ptr [R9 + R14*0x4]
XOR R14D,dword ptr [R8 + R15*0x4]
MOV R15D,EAX
SHR R15D,0xe
AND R15D,R10D
XOR R14D,dword ptr [R15 + R11*0x1]
SHR EAX,0x18
XOR R14D,dword ptr [RBX + RAX*0x4]
XOR R14D,dword ptr [RSI + 0xc]
ADD RSI,0x10
MOV R15D,R14D
AND R15D,EDI
MOV EAX,R14D
SHR EAX,0x8
AND EAX,EDI
MOV EAX,dword ptr [R9 + RAX*0x4]
XOR EAX,dword ptr [R8 + R15*0x4]
MOV R15D,R14D
SHR R15D,0xe
AND R15D,R10D
XOR EAX,dword ptr [R15 + R11*0x1]
SHR R14D,0x18
XOR EAX,dword ptr [RBX + R14*0x4]
ADD RCX,-0x10
CMP RCX,0xf
JG 0x001a95cf
MOV EAX,EAX
LAB_001a96a2:
CMP RCX,0x8
JL 0x001a9748
MOV RCX,RDX
SUB RCX,RSI
MOV EDI,0xff
LEA R8,[0x1e2370]
LEA R9,[0x1e2770]
MOV R10D,0x3fc
LEA R11,[0x1e2b70]
LEA RBX,[0x1e1f70]
LAB_001a96d9:
XOR EAX,dword ptr [RSI]
MOV R15D,EAX
AND R15D,EDI
MOV R14D,EAX
SHR R14D,0x8
AND R14D,EDI
MOV R14D,dword ptr [R9 + R14*0x4]
XOR R14D,dword ptr [R8 + R15*0x4]
MOV R15D,EAX
SHR R15D,0xe
AND R15D,R10D
XOR R14D,dword ptr [R15 + R11*0x1]
SHR EAX,0x18
XOR R14D,dword ptr [RBX + RAX*0x4]
XOR R14D,dword ptr [RSI + 0x4]
ADD RSI,0x8
MOV R15D,R14D
AND R15D,EDI
MOV EAX,R14D
SHR EAX,0x8
AND EAX,EDI
MOV EAX,dword ptr [R9 + RAX*0x4]
XOR EAX,dword ptr [R8 + R15*0x4]
MOV R15D,R14D
SHR R15D,0xe
AND R15D,R10D
XOR EAX,dword ptr [R15 + R11*0x1]
SHR R14D,0x18
XOR EAX,dword ptr [RBX + R14*0x4]
ADD RCX,-0x8
CMP RCX,0x7
JG 0x001a96d9
MOV EAX,EAX
LAB_001a9748:
CMP RSI,RDX
JZ 0x001a9771
LEA RCX,[0x1e1f70]
LAB_001a9754:
MOVZX EDI,AL
MOVZX R8D,byte ptr [RSI]
INC RSI
XOR R8D,EDI
MOV EDI,dword ptr [RCX + R8*0x4]
SHR RAX,0x8
XOR RAX,RDI
CMP RSI,RDX
JNZ 0x001a9754
LAB_001a9771:
NOT EAX
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* mysys_namespace::crc32c::crc32c_slow(unsigned int, char const*, unsigned long) */
uint __thiscall
mysys_namespace::crc32c::crc32c_slow(crc32c *this,uint param_1,char *param_2,ulong param_3)
{
uint uVar1;
ulong uVar2;
long lVar3;
uint *puVar4;
int4 in_register_00000034;
uint *puVar5;
uint *puVar6;
uint *puVar7;
uint *puVar8;
puVar5 = (uint *)CONCAT44(in_register_00000034,param_1);
puVar4 = (uint *)(param_2 + (long)puVar5);
uVar2 = (ulong)~(uint)this;
puVar6 = (uint *)((ulong)((long)puVar5 + 0xfU) & 0xfffffffffffffff0);
puVar7 = puVar5;
if ((long)puVar6 - (long)puVar5 != 0 && puVar6 <= puVar4) {
do {
puVar8 = (uint *)((long)puVar7 + 1);
uVar2 = uVar2 >> 8 ^
(ulong)*(uint *)(table0_ + (ulong)((uint)(byte)*puVar7 ^ (uint)uVar2 & 0xff) * 4);
puVar7 = puVar8;
} while (puVar8 != puVar6);
puVar5 = (uint *)((long)puVar5 + ((long)puVar6 - (long)puVar5));
puVar7 = puVar6;
}
lVar3 = (long)puVar4 - (long)puVar7;
if (0xf < lVar3) {
lVar3 = (long)puVar4 - (long)puVar5;
do {
uVar1 = (uint)uVar2 ^ *puVar5;
uVar1 = *(uint *)(table2_ + (ulong)(uVar1 >> 8 & 0xff) * 4) ^
*(uint *)(table3_ + (ulong)(uVar1 & 0xff) * 4) ^
*(uint *)(table1_ + (uVar1 >> 0xe & 0x3fc)) ^
*(uint *)(table0_ + (ulong)(uVar1 >> 0x18) * 4) ^ puVar5[1];
uVar1 = *(uint *)(table2_ + (ulong)(uVar1 >> 8 & 0xff) * 4) ^
*(uint *)(table3_ + (ulong)(uVar1 & 0xff) * 4) ^
*(uint *)(table1_ + (uVar1 >> 0xe & 0x3fc)) ^
*(uint *)(table0_ + (ulong)(uVar1 >> 0x18) * 4) ^ puVar5[2];
uVar1 = *(uint *)(table2_ + (ulong)(uVar1 >> 8 & 0xff) * 4) ^
*(uint *)(table3_ + (ulong)(uVar1 & 0xff) * 4) ^
*(uint *)(table1_ + (uVar1 >> 0xe & 0x3fc)) ^
*(uint *)(table0_ + (ulong)(uVar1 >> 0x18) * 4) ^ puVar5[3];
puVar5 = puVar5 + 4;
uVar1 = *(uint *)(table2_ + (ulong)(uVar1 >> 8 & 0xff) * 4) ^
*(uint *)(table3_ + (ulong)(uVar1 & 0xff) * 4) ^
*(uint *)(table1_ + (uVar1 >> 0xe & 0x3fc)) ^
*(uint *)(table0_ + (ulong)(uVar1 >> 0x18) * 4);
uVar2 = (ulong)uVar1;
lVar3 = lVar3 + -0x10;
} while (0xf < lVar3);
uVar2 = (ulong)uVar1;
}
if (7 < lVar3) {
lVar3 = (long)puVar4 - (long)puVar5;
do {
uVar1 = (uint)uVar2 ^ *puVar5;
uVar1 = *(uint *)(table2_ + (ulong)(uVar1 >> 8 & 0xff) * 4) ^
*(uint *)(table3_ + (ulong)(uVar1 & 0xff) * 4) ^
*(uint *)(table1_ + (uVar1 >> 0xe & 0x3fc)) ^
*(uint *)(table0_ + (ulong)(uVar1 >> 0x18) * 4) ^ puVar5[1];
puVar5 = puVar5 + 2;
uVar1 = *(uint *)(table2_ + (ulong)(uVar1 >> 8 & 0xff) * 4) ^
*(uint *)(table3_ + (ulong)(uVar1 & 0xff) * 4) ^
*(uint *)(table1_ + (uVar1 >> 0xe & 0x3fc)) ^
*(uint *)(table0_ + (ulong)(uVar1 >> 0x18) * 4);
uVar2 = (ulong)uVar1;
lVar3 = lVar3 + -8;
} while (7 < lVar3);
uVar2 = (ulong)uVar1;
}
for (; puVar5 != puVar4; puVar5 = (uint *)((long)puVar5 + 1)) {
uVar2 = uVar2 >> 8 ^
(ulong)*(uint *)(table0_ + (ulong)((uint)(byte)*puVar5 ^ (uint)uVar2 & 0xff) * 4);
}
return ~(uint)uVar2;
}
| |
41,217 | my_copy_8bit | eloqsql/strings/ctype-simple.c | size_t
my_copy_8bit(CHARSET_INFO *cs __attribute__((unused)),
char *dst, size_t dst_length,
const char *src, size_t src_length,
size_t nchars, MY_STRCOPY_STATUS *status)
{
set_if_smaller(src_length, dst_length);
set_if_smaller(src_length, nchars);
if (src_length)
memmove(dst, src, src_length);
status->m_source_end_pos= src + src_length;
status->m_well_formed_error_pos= NULL;
return src_length;
} | O3 | c | my_copy_8bit:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq 0x10(%rbp), %r15
cmpq %rdx, %r8
cmovbq %r8, %rbx
cmpq %r9, %rbx
cmovaeq %r9, %rbx
testq %rbx, %rbx
je 0x58cf5
movq %rsi, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x265c0
addq %rbx, %r14
movq %r14, (%r15)
movq $0x0, 0x8(%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| my_copy_8bit:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rcx
mov rbx, rdx
mov r15, [rbp+arg_0]
cmp r8, rdx
cmovb rbx, r8
cmp rbx, r9
cmovnb rbx, r9
test rbx, rbx
jz short loc_58CF5
mov rdi, rsi
mov rsi, r14
mov rdx, rbx
call _memmove
loc_58CF5:
add r14, rbx
mov [r15], r14
mov qword ptr [r15+8], 0
mov rax, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| unsigned long long my_copy_8bit(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
unsigned long long a6,
_QWORD *a7)
{
unsigned long long v8; // rbx
v8 = a3;
if ( a5 < a3 )
v8 = a5;
if ( v8 >= a6 )
v8 = a6;
if ( v8 )
memmove(a2, a4, v8);
*a7 = v8 + a4;
a7[1] = 0LL;
return v8;
}
| my_copy_8bit:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RCX
MOV RBX,RDX
MOV R15,qword ptr [RBP + 0x10]
CMP R8,RDX
CMOVC RBX,R8
CMP RBX,R9
CMOVNC RBX,R9
TEST RBX,RBX
JZ 0x00158cf5
MOV RDI,RSI
MOV RSI,R14
MOV RDX,RBX
CALL 0x001265c0
LAB_00158cf5:
ADD R14,RBX
MOV qword ptr [R15],R14
MOV qword ptr [R15 + 0x8],0x0
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
size_t my_copy_8bit(int8 param_1,void *param_2,ulong param_3,void *param_4,ulong param_5,
ulong param_6,long *param_7)
{
if (param_5 < param_3) {
param_3 = param_5;
}
if (param_6 <= param_3) {
param_3 = param_6;
}
if (param_3 != 0) {
memmove(param_2,param_4,param_3);
}
*param_7 = (long)param_4 + param_3;
param_7[1] = 0;
return param_3;
}
| |
41,218 | google::protobuf::internal::DecodeTwoBytes(char const**) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/parse_context.h | inline uint32_t DecodeTwoBytes(const char** ptr) {
uint32_t value = UnalignedLoad<uint16_t>(*ptr);
// Sign extend the low byte continuation bit
uint32_t x = static_cast<int8_t>(value);
value &= x; // Mask out the high byte iff no continuation
// This add is an amazing operation, it cancels the low byte continuation bit
// from y transferring it to the carry. Simultaneously it also shifts the 7
// LSB left by one tightly against high byte varint bits. Hence value now
// contains the unpacked value shifted left by 1.
value += x;
// Use the carry to update the ptr appropriately.
*ptr += value < x ? 2 : 1;
return value;
} | O0 | c | google::protobuf::internal::DecodeTwoBytes(char const**):
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x203820
movzwl %ax, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movsbl %al, %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
andl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x8(%rsp), %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %ecx
movl 0x8(%rsp), %esi
movl $0x1, %edx
movl $0x2, %eax
cmpl %esi, %ecx
cmovbl %eax, %edx
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, (%rax)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| _ZN6google8protobuf8internal14DecodeTwoBytesEPPKc:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov rax, [rsp+18h+var_8]
mov rdi, [rax]
call _ZN6google8protobuf8internal13UnalignedLoadItEET_PKc; google::protobuf::internal::UnalignedLoad<ushort>(char const*)
movzx eax, ax
mov [rsp+18h+var_C], eax
mov eax, [rsp+18h+var_C]
movsx eax, al
mov [rsp+18h+var_10], eax
mov eax, [rsp+18h+var_10]
and eax, [rsp+18h+var_C]
mov [rsp+18h+var_C], eax
mov eax, [rsp+18h+var_10]
add eax, [rsp+18h+var_C]
mov [rsp+18h+var_C], eax
mov ecx, [rsp+18h+var_C]
mov esi, [rsp+18h+var_10]
mov edx, 1
mov eax, 2
cmp ecx, esi
cmovb edx, eax
mov rax, [rsp+18h+var_8]
mov rcx, [rax]
movsxd rdx, edx
add rcx, rdx
mov [rax], rcx
mov eax, [rsp+18h+var_C]
add rsp, 18h
retn
| long long google::protobuf::internal::DecodeTwoBytes(google::protobuf::internal *this, const char **a2)
{
unsigned __int16 v2; // ax
int v3; // edx
unsigned int v5; // [rsp+Ch] [rbp-Ch]
v2 = google::protobuf::internal::UnalignedLoad<unsigned short>(*(_QWORD *)this, a2);
v5 = (v2 & (char)v2) + (char)v2;
v3 = 1;
if ( v5 < (char)v2 )
v3 = 2;
*(_QWORD *)this += v3;
return v5;
}
| NativeHandle:
MOV qword ptr [RSP + -0x8],RDI
MOV RAX,qword ptr [RSP + -0x8]
MOV RAX,qword ptr [RAX]
RET
|
/* aimrt::channel::ContextRef::NativeHandle() const */
int8 __thiscall aimrt::channel::ContextRef::NativeHandle(ContextRef *this)
{
return *(int8 *)this;
}
| |
41,219 | httplib::ThreadPool::ThreadPool(unsigned long) | nickolajgrishuk[P]metricz-cpp/build_O3/_deps/httplib-src/httplib.h | explicit ThreadPool(size_t n) : shutdown_(false) {
while (n) {
threads_.emplace_back(worker(*this));
n--;
}
} | O3 | c | httplib::ThreadPool::ThreadPool(unsigned long):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x345bc(%rip), %rax # 0x3f468
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
xorl %r13d, %r13d
movq %r13, 0x18(%rdi)
leaq 0x20(%rdi), %r14
movq %r14, 0x28(%rdi)
movq %r14, 0x20(%rdi)
movq %r13, 0x30(%rdi)
movb $0x0, 0x38(%rdi)
leaq 0x40(%rdi), %r12
movq %r12, %rdi
callq 0x8790
movq %r13, 0x90(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%r15)
movups %xmm0, 0x70(%r15)
testq %rbx, %rbx
je 0xaf14
leaq 0x8(%r15), %r13
movq %rsp, %rbp
movq %r15, (%rsp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0xaf46
decq %rbx
jne 0xaf00
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0x89d0
movq %r14, %rdi
callq 0xb542
movq %r13, %rdi
callq 0xaf72
movq %rbx, %rdi
callq 0x8980
| _ZN7httplib10ThreadPoolC2Em:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
mov r15, rdi
lea rax, off_3F468
mov [rdi], rax
xorps xmm0, xmm0
movups xmmword ptr [rdi+8], xmm0
xor r13d, r13d
mov [rdi+18h], r13
lea r14, [rdi+20h]
mov [rdi+28h], r14
mov [rdi+20h], r14
mov [rdi+30h], r13
mov byte ptr [rdi+38h], 0
lea r12, [rdi+40h]
mov rdi, r12; this
call __ZNSt18condition_variableC1Ev; std::condition_variable::condition_variable(void)
mov [r15+90h], r13
xorps xmm0, xmm0
movups xmmword ptr [r15+80h], xmm0
movups xmmword ptr [r15+70h], xmm0
test rbx, rbx
jz short loc_AF14
lea r13, [r15+8]
mov rbp, rsp
loc_AF00:
mov [rsp+38h+var_38], r15
mov rdi, r13
mov rsi, rbp
call _ZNSt6vectorISt6threadSaIS0_EE12emplace_backIJN7httplib10ThreadPool6workerEEEEvDpOT_; std::vector<std::thread>::emplace_back<httplib::ThreadPool::worker>(httplib::ThreadPool::worker &&)
dec rbx
jnz short loc_AF00
loc_AF14:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, r12; this
call __ZNSt18condition_variableD1Ev; std::condition_variable::~condition_variable()
mov rdi, r14
call _ZNSt7__cxx1110_List_baseISt8functionIFvvEESaIS3_EE8_M_clearEv; std::_List_base<std::function<void ()(void)>>::_M_clear(void)
mov rdi, r13
call _ZNSt6vectorISt6threadSaIS0_EED2Ev; std::vector<std::thread>::~vector()
mov rdi, rbx
call __Unwind_Resume
| long long httplib::ThreadPool::ThreadPool(httplib::ThreadPool *this, long long a2)
{
httplib::ThreadPool *v2; // rax
long long v3; // rbx
long long result; // rax
httplib::ThreadPool *v5; // [rsp+0h] [rbp-38h] BYREF
v5 = v2;
v3 = a2;
*(_QWORD *)this = off_3F468;
*(_OWORD *)((char *)this + 8) = 0LL;
*((_QWORD *)this + 3) = 0LL;
*((_QWORD *)this + 5) = (char *)this + 32;
*((_QWORD *)this + 4) = (char *)this + 32;
*((_QWORD *)this + 6) = 0LL;
*((_BYTE *)this + 56) = 0;
result = std::condition_variable::condition_variable((httplib::ThreadPool *)((char *)this + 64));
*((_QWORD *)this + 18) = 0LL;
*((_OWORD *)this + 8) = 0LL;
for ( *((_OWORD *)this + 7) = 0LL; v3; --v3 )
{
v5 = this;
result = std::vector<std::thread>::emplace_back<httplib::ThreadPool::worker>((char *)this + 8, &v5);
}
return result;
}
| ThreadPool:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R15,RDI
LEA RAX,[0x13f468]
MOV qword ptr [RDI],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x8],XMM0
XOR R13D,R13D
MOV qword ptr [RDI + 0x18],R13
LEA R14,[RDI + 0x20]
MOV qword ptr [RDI + 0x28],R14
MOV qword ptr [RDI + 0x20],R14
MOV qword ptr [RDI + 0x30],R13
MOV byte ptr [RDI + 0x38],0x0
LEA R12,[RDI + 0x40]
MOV RDI,R12
CALL 0x00108790
MOV qword ptr [R15 + 0x90],R13
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R15 + 0x80],XMM0
MOVUPS xmmword ptr [R15 + 0x70],XMM0
TEST RBX,RBX
JZ 0x0010af14
LEA R13,[R15 + 0x8]
MOV RBP,RSP
LAB_0010af00:
MOV qword ptr [RSP],R15
LAB_0010af04:
MOV RDI,R13
MOV RSI,RBP
CALL 0x0010af46
LAB_0010af0f:
DEC RBX
JNZ 0x0010af00
LAB_0010af14:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* httplib::ThreadPool::ThreadPool(unsigned long) */
void __thiscall httplib::ThreadPool::ThreadPool(ThreadPool *this,ulong param_1)
{
ThreadPool *local_38;
*(int ***)this = &PTR__ThreadPool_0013f468;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(ThreadPool **)(this + 0x28) = this + 0x20;
*(ThreadPool **)(this + 0x20) = this + 0x20;
*(int8 *)(this + 0x30) = 0;
this[0x38] = (ThreadPool)0x0;
std::condition_variable::condition_variable((condition_variable *)(this + 0x40));
*(int8 *)(this + 0x90) = 0;
*(int8 *)(this + 0x80) = 0;
*(int8 *)(this + 0x88) = 0;
*(int8 *)(this + 0x70) = 0;
*(int8 *)(this + 0x78) = 0;
if (param_1 != 0) {
do {
local_38 = this;
/* try { // try from 0010af04 to 0010af0e has its CatchHandler @ 0010af23 */
std::vector<std::thread,std::allocator<std::thread>>::
emplace_back<httplib::ThreadPool::worker>
((vector<std::thread,std::allocator<std::thread>> *)(this + 8),(worker *)&local_38);
param_1 = param_1 - 1;
} while (param_1 != 0);
}
return;
}
| |
41,220 | ma_mark_file_changed_now | eloqsql/storage/maria/ma_locking.c | int _ma_mark_file_changed_now(register MARIA_SHARE *share)
{
uchar buff[3];
int error= 1;
DBUG_ENTER("_ma_mark_file_changed_now");
if (_MA_ALREADY_MARKED_FILE_CHANGED)
DBUG_RETURN(0);
mysql_mutex_lock(&share->intern_lock); /* recheck under mutex */
if (! _MA_ALREADY_MARKED_FILE_CHANGED)
{
share->state.changed|=(STATE_CHANGED | STATE_NOT_ANALYZED |
STATE_NOT_OPTIMIZED_KEYS);
if (!share->global_changed)
{
share->changed= share->global_changed= 1;
share->state.open_count++;
}
/*
Temp tables don't need an open_count as they are removed on crash.
In theory transactional tables are fixed by log-based recovery, so don't
need an open_count either, but if recovery has failed and logs have been
removed (by maria-force-start-after-recovery-failures), we still need to
detect dubious tables.
If we didn't maintain open_count on disk for a table, after a crash
we wouldn't know if it was closed at crash time (thus does not need a
check) or not. So we would have to check all tables: overkill.
*/
if (!share->temporary)
{
CRASH_IF_S3_TABLE(share);
mi_int2store(buff,share->state.open_count);
buff[2]=1; /* Mark that it's changed */
if (my_pwrite(share->kfile.file, buff, sizeof(buff),
sizeof(share->state.header) +
MARIA_FILE_OPEN_COUNT_OFFSET,
MYF(MY_NABP)))
goto err;
}
/* Set uuid of file if not yet set (zerofilled file) */
if (share->base.born_transactional &&
!(share->state.org_changed & STATE_NOT_MOVABLE))
{
CRASH_IF_S3_TABLE(share);
/* Lock table to current installation */
if (_ma_set_uuid(share, 0) ||
(share->state.create_rename_lsn == LSN_NEEDS_NEW_STATE_LSNS &&
_ma_update_state_lsns_sub(share, LSN_IMPOSSIBLE,
trnman_get_min_trid(),
TRUE, TRUE)))
goto err;
share->state.changed|= STATE_NOT_MOVABLE;
share->state.org_changed|= STATE_NOT_MOVABLE;
}
}
error= 0;
err:
mysql_mutex_unlock(&share->intern_lock);
DBUG_RETURN(error);
#undef _MA_ALREADY_MARKED_FILE_CHANGED
} | O0 | c | ma_mark_file_changed_now:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x170(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x48e63
movq -0x10(%rbp), %rax
movsbl 0x7df(%rax), %eax
cmpl $0x0, %eax
je 0x48e63
jmp 0x48e57
movl $0x0, -0x4(%rbp)
jmp 0x49014
movq -0x10(%rbp), %rdi
addq $0x8f0, %rdi # imm = 0x8F0
leaq 0x109475(%rip), %rsi # 0x1522ea
movl $0x1ad, %edx # imm = 0x1AD
callq 0x48a90
movq -0x10(%rbp), %rax
movl 0x170(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x48ea5
movq -0x10(%rbp), %rax
movsbl 0x7df(%rax), %eax
cmpl $0x0, %eax
jne 0x48ff7
movq -0x10(%rbp), %rax
movl 0x170(%rax), %ecx
orl $0x19, %ecx
movl %ecx, 0x170(%rax)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x7df(%rax)
jne 0x48eee
movq -0x10(%rbp), %rax
movb $0x1, 0x7df(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x7de(%rax)
movq -0x10(%rbp), %rax
movl 0x16c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x16c(%rax)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x7d9(%rax)
jne 0x48f4f
jmp 0x48efd
jmp 0x48eff
movq -0x10(%rbp), %rax
movl 0x16c(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movb %al, -0x12(%rbp)
movl -0x1c(%rbp), %eax
shrl $0x8, %eax
movb %al, -0x13(%rbp)
movb $0x1, -0x11(%rbp)
movq -0x10(%rbp), %rax
movl 0x760(%rax), %edi
leaq -0x13(%rbp), %rsi
movl $0x3, %edx
movl $0x18, %ecx
movl $0x4, %r8d
callq 0xf4850
cmpq $0x0, %rax
je 0x48f4d
jmp 0x48ffe
jmp 0x48f4f
movq -0x10(%rbp), %rax
movsbl 0x44c(%rax), %eax
cmpl $0x0, %eax
je 0x48ff5
movq -0x10(%rbp), %rax
movl 0x174(%rax), %eax
andl $0x100, %eax # imm = 0x100
cmpl $0x0, %eax
jne 0x48ff5
jmp 0x48f79
jmp 0x48f7b
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x49020
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x48fc7
movq -0x10(%rbp), %rax
cmpq $0x2, 0x178(%rax)
jne 0x48fc9
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x79d40
movq -0x28(%rbp), %rdi
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %r8d
movl %r8d, %ecx
callq 0x75990
cmpl $0x0, %eax
je 0x48fc9
jmp 0x48ffe
movq -0x10(%rbp), %rax
movl 0x170(%rax), %ecx
orl $0x100, %ecx # imm = 0x100
movl %ecx, 0x170(%rax)
movq -0x10(%rbp), %rax
movl 0x174(%rax), %ecx
orl $0x100, %ecx # imm = 0x100
movl %ecx, 0x174(%rax)
jmp 0x48ff7
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8f0, %rdi # imm = 0x8F0
callq 0x48c30
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| _ma_mark_file_changed_now:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], 1
mov rax, [rbp+var_10]
mov eax, [rax+170h]
and eax, 1
cmp eax, 0
jz short loc_48E63
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax+7DFh]
cmp eax, 0
jz short loc_48E63
jmp short $+2
loc_48E57:
mov [rbp+var_4], 0
jmp loc_49014
loc_48E63:
mov rdi, [rbp+var_10]
add rdi, 8F0h
lea rsi, aWorkspaceLlm4b_6; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 1ADh
call inline_mysql_mutex_lock_5
mov rax, [rbp+var_10]
mov eax, [rax+170h]
and eax, 1
cmp eax, 0
jz short loc_48EA5
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax+7DFh]
cmp eax, 0
jnz loc_48FF7
loc_48EA5:
mov rax, [rbp+var_10]
mov ecx, [rax+170h]
or ecx, 19h
mov [rax+170h], ecx
mov rax, [rbp+var_10]
cmp byte ptr [rax+7DFh], 0
jnz short loc_48EEE
mov rax, [rbp+var_10]
mov byte ptr [rax+7DFh], 1
mov rax, [rbp+var_10]
mov byte ptr [rax+7DEh], 1
mov rax, [rbp+var_10]
mov ecx, [rax+16Ch]
add ecx, 1
mov [rax+16Ch], ecx
loc_48EEE:
mov rax, [rbp+var_10]
cmp byte ptr [rax+7D9h], 0
jnz short loc_48F4F
jmp short $+2
loc_48EFD:
jmp short $+2
loc_48EFF:
mov rax, [rbp+var_10]
mov eax, [rax+16Ch]
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
mov [rbp+var_12], al
mov eax, [rbp+var_1C]
shr eax, 8
mov [rbp+var_13], al
mov [rbp+var_11], 1
mov rax, [rbp+var_10]
mov edi, [rax+760h]
lea rsi, [rbp+var_13]
mov edx, 3
mov ecx, 18h
mov r8d, 4
call my_pwrite
cmp rax, 0
jz short loc_48F4D
jmp loc_48FFE
loc_48F4D:
jmp short $+2
loc_48F4F:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax+44Ch]
cmp eax, 0
jz loc_48FF5
mov rax, [rbp+var_10]
mov eax, [rax+174h]
and eax, 100h
cmp eax, 0
jnz short loc_48FF5
jmp short $+2
loc_48F79:
jmp short $+2
loc_48F7B:
mov rdi, [rbp+var_10]
xor esi, esi
call _ma_set_uuid
movsx eax, al
cmp eax, 0
jnz short loc_48FC7
mov rax, [rbp+var_10]
cmp qword ptr [rax+178h], 2
jnz short loc_48FC9
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
call trnman_get_min_trid
mov rdi, [rbp+var_28]
mov rdx, rax
xor eax, eax
mov esi, eax
mov r8d, 1
mov ecx, r8d
call _ma_update_state_lsns_sub
cmp eax, 0
jz short loc_48FC9
loc_48FC7:
jmp short loc_48FFE
loc_48FC9:
mov rax, [rbp+var_10]
mov ecx, [rax+170h]
or ecx, 100h
mov [rax+170h], ecx
mov rax, [rbp+var_10]
mov ecx, [rax+174h]
or ecx, 100h
mov [rax+174h], ecx
loc_48FF5:
jmp short $+2
loc_48FF7:
mov [rbp+var_18], 0
loc_48FFE:
mov rdi, [rbp+var_10]
add rdi, 8F0h
call inline_mysql_mutex_unlock_5
mov eax, [rbp+var_18]
mov [rbp+var_4], eax
loc_49014:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long ma_mark_file_changed_now(long long a1)
{
__int16 v1; // kr00_2
long long min_trid; // rax
long long v4; // [rsp+8h] [rbp-28h]
unsigned int v5; // [rsp+18h] [rbp-18h]
_BYTE v6[3]; // [rsp+1Dh] [rbp-13h] BYREF
long long v7; // [rsp+20h] [rbp-10h]
v7 = a1;
v5 = 1;
if ( (*(_DWORD *)(a1 + 368) & 1) == 0 || !*(_BYTE *)(v7 + 2015) )
{
inline_mysql_mutex_lock_5(
v7 + 2288,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_locking.c",
0x1ADu);
if ( (*(_DWORD *)(v7 + 368) & 1) == 0 || !*(_BYTE *)(v7 + 2015) )
{
*(_DWORD *)(v7 + 368) |= 0x19u;
if ( !*(_BYTE *)(v7 + 2015) )
{
*(_BYTE *)(v7 + 2015) = 1;
*(_BYTE *)(v7 + 2014) = 1;
++*(_DWORD *)(v7 + 364);
}
if ( !*(_BYTE *)(v7 + 2009) )
{
v1 = *(_DWORD *)(v7 + 364);
v6[0] = HIBYTE(v1);
v6[1] = v1;
v6[2] = 1;
if ( my_pwrite(*(unsigned int *)(v7 + 1888), v6, 3LL, 24LL, 4LL) )
goto LABEL_18;
}
if ( *(_BYTE *)(v7 + 1100) && (*(_DWORD *)(v7 + 372) & 0x100) == 0 )
{
if ( (unsigned __int8)ma_set_uuid(v7, 0LL) )
goto LABEL_18;
if ( *(_QWORD *)(v7 + 376) == 2LL )
{
v4 = v7;
min_trid = trnman_get_min_trid();
if ( (unsigned int)ma_update_state_lsns_sub(v4, 0LL, min_trid, 1LL) )
goto LABEL_18;
}
*(_DWORD *)(v7 + 368) |= 0x100u;
*(_DWORD *)(v7 + 372) |= 0x100u;
}
}
v5 = 0;
LABEL_18:
inline_mysql_mutex_unlock_5(v7 + 2288);
return v5;
}
return 0;
}
| _ma_mark_file_changed_now:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x18],0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x170]
AND EAX,0x1
CMP EAX,0x0
JZ 0x00148e63
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX + 0x7df]
CMP EAX,0x0
JZ 0x00148e63
JMP 0x00148e57
LAB_00148e57:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00149014
LAB_00148e63:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x8f0
LEA RSI,[0x2522ea]
MOV EDX,0x1ad
CALL 0x00148a90
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x170]
AND EAX,0x1
CMP EAX,0x0
JZ 0x00148ea5
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX + 0x7df]
CMP EAX,0x0
JNZ 0x00148ff7
LAB_00148ea5:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x170]
OR ECX,0x19
MOV dword ptr [RAX + 0x170],ECX
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX + 0x7df],0x0
JNZ 0x00148eee
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x7df],0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x7de],0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x16c]
ADD ECX,0x1
MOV dword ptr [RAX + 0x16c],ECX
LAB_00148eee:
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX + 0x7d9],0x0
JNZ 0x00148f4f
JMP 0x00148efd
LAB_00148efd:
JMP 0x00148eff
LAB_00148eff:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x16c]
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV byte ptr [RBP + -0x12],AL
MOV EAX,dword ptr [RBP + -0x1c]
SHR EAX,0x8
MOV byte ptr [RBP + -0x13],AL
MOV byte ptr [RBP + -0x11],0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RAX + 0x760]
LEA RSI,[RBP + -0x13]
MOV EDX,0x3
MOV ECX,0x18
MOV R8D,0x4
CALL 0x001f4850
CMP RAX,0x0
JZ 0x00148f4d
JMP 0x00148ffe
LAB_00148f4d:
JMP 0x00148f4f
LAB_00148f4f:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX + 0x44c]
CMP EAX,0x0
JZ 0x00148ff5
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x174]
AND EAX,0x100
CMP EAX,0x0
JNZ 0x00148ff5
JMP 0x00148f79
LAB_00148f79:
JMP 0x00148f7b
LAB_00148f7b:
MOV RDI,qword ptr [RBP + -0x10]
XOR ESI,ESI
CALL 0x00149020
MOVSX EAX,AL
CMP EAX,0x0
JNZ 0x00148fc7
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x178],0x2
JNZ 0x00148fc9
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
CALL 0x00179d40
MOV RDI,qword ptr [RBP + -0x28]
MOV RDX,RAX
XOR EAX,EAX
MOV ESI,EAX
MOV R8D,0x1
MOV ECX,R8D
CALL 0x00175990
CMP EAX,0x0
JZ 0x00148fc9
LAB_00148fc7:
JMP 0x00148ffe
LAB_00148fc9:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x170]
OR ECX,0x100
MOV dword ptr [RAX + 0x170],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x174]
OR ECX,0x100
MOV dword ptr [RAX + 0x174],ECX
LAB_00148ff5:
JMP 0x00148ff7
LAB_00148ff7:
MOV dword ptr [RBP + -0x18],0x0
LAB_00148ffe:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x8f0
CALL 0x00148c30
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x4],EAX
LAB_00149014:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 _ma_mark_file_changed_now(long param_1)
{
char cVar1;
int iVar2;
long lVar3;
int8 uVar4;
int4 local_20;
int1 local_1b;
int1 local_1a;
int1 local_19;
long local_18;
local_20 = 1;
if (((*(uint *)(param_1 + 0x170) & 1) != 0) && (*(char *)(param_1 + 0x7df) != '\0')) {
return 0;
}
local_18 = param_1;
inline_mysql_mutex_lock
(param_1 + 0x8f0,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_locking.c",
0x1ad);
if (((*(uint *)(local_18 + 0x170) & 1) == 0) || (*(char *)(local_18 + 0x7df) == '\0')) {
*(uint *)(local_18 + 0x170) = *(uint *)(local_18 + 0x170) | 0x19;
if (*(char *)(local_18 + 0x7df) == '\0') {
*(int1 *)(local_18 + 0x7df) = 1;
*(int1 *)(local_18 + 0x7de) = 1;
*(int *)(local_18 + 0x16c) = *(int *)(local_18 + 0x16c) + 1;
}
if (*(char *)(local_18 + 0x7d9) == '\0') {
local_1a = (int1)*(int4 *)(local_18 + 0x16c);
local_1b = (int1)((uint)*(int4 *)(local_18 + 0x16c) >> 8);
local_19 = 1;
lVar3 = my_pwrite(*(int4 *)(local_18 + 0x760),&local_1b,3,0x18,4);
if (lVar3 != 0) goto LAB_00148ffe;
}
if ((*(char *)(local_18 + 0x44c) != '\0') && ((*(uint *)(local_18 + 0x174) & 0x100) == 0)) {
cVar1 = _ma_set_uuid(local_18,0);
lVar3 = local_18;
if (cVar1 != '\0') goto LAB_00148ffe;
if (*(long *)(local_18 + 0x178) == 2) {
uVar4 = trnman_get_min_trid();
iVar2 = _ma_update_state_lsns_sub(lVar3,0,uVar4,1);
if (iVar2 != 0) goto LAB_00148ffe;
}
*(uint *)(local_18 + 0x170) = *(uint *)(local_18 + 0x170) | 0x100;
*(uint *)(local_18 + 0x174) = *(uint *)(local_18 + 0x174) | 0x100;
}
}
local_20 = 0;
LAB_00148ffe:
inline_mysql_mutex_unlock(local_18 + 0x8f0);
return local_20;
}
| |
41,221 | unpack_dirname | eloqsql/mysys/mf_pack.c | size_t unpack_dirname(char * to, const char *from)
{
size_t length, h_length;
char buff[FN_REFLEN+1+4],*suffix,*tilde_expansion;
DBUG_ENTER("unpack_dirname");
length= normalize_dirname(buff, from);
if (buff[0] == FN_HOMELIB)
{
suffix=buff+1; tilde_expansion=expand_tilde(&suffix);
if (tilde_expansion)
{
length-= (size_t) (suffix-buff)-1;
if (length+(h_length= strlen(tilde_expansion)) <= FN_REFLEN)
{
if ((h_length > 0) && (tilde_expansion[h_length-1] == FN_LIBCHAR))
h_length--;
if (buff+h_length < suffix)
bmove(buff+h_length,suffix,length);
else
bmove_upp((uchar*) buff+h_length+length, (uchar*) suffix+length, length);
bmove(buff,tilde_expansion,h_length);
}
}
}
#ifdef USE_SYMDIR
if (my_use_symdir)
symdirget(buff);
#endif
DBUG_RETURN(system_filename(to,buff)); /* Fix for open */
} | O0 | c | unpack_dirname:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp # imm = 0x250
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x218(%rbp)
movq %rsi, -0x220(%rbp)
leaq -0x210(%rbp), %rdi
movq -0x220(%rbp), %rsi
callq 0xe9260
movq %rax, -0x228(%rbp)
movsbl -0x210(%rbp), %eax
cmpl $0x7e, %eax
jne 0xe9511
leaq -0x210(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x238(%rbp)
leaq -0x238(%rbp), %rdi
callq 0xe9560
movq %rax, -0x240(%rbp)
cmpq $0x0, -0x240(%rbp)
je 0xe950f
movq -0x238(%rbp), %rcx
leaq -0x210(%rbp), %rax
subq %rax, %rcx
subq $0x1, %rcx
movq -0x228(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x228(%rbp)
movq -0x228(%rbp), %rax
movq %rax, -0x248(%rbp)
movq -0x240(%rbp), %rdi
callq 0x2a350
movq %rax, %rcx
movq -0x248(%rbp), %rax
movq %rcx, -0x230(%rbp)
addq %rcx, %rax
cmpq $0x200, %rax # imm = 0x200
ja 0xe950d
cmpq $0x0, -0x230(%rbp)
jbe 0xe948a
movq -0x240(%rbp), %rax
movq -0x230(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0xe948a
movq -0x230(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x230(%rbp)
leaq -0x210(%rbp), %rax
addq -0x230(%rbp), %rax
cmpq -0x238(%rbp), %rax
jae 0xe94c4
leaq -0x210(%rbp), %rdi
addq -0x230(%rbp), %rdi
movq -0x238(%rbp), %rsi
movq -0x228(%rbp), %rdx
callq 0x2a130
jmp 0xe94f3
leaq -0x210(%rbp), %rdi
addq -0x230(%rbp), %rdi
addq -0x228(%rbp), %rdi
movq -0x238(%rbp), %rsi
addq -0x228(%rbp), %rsi
movq -0x228(%rbp), %rdx
callq 0x10ae90
leaq -0x210(%rbp), %rdi
movq -0x240(%rbp), %rsi
movq -0x230(%rbp), %rdx
callq 0x2a130
jmp 0xe950f
jmp 0xe9511
jmp 0xe9513
movq -0x218(%rbp), %rdi
leaq -0x210(%rbp), %rsi
callq 0xe9620
movq %rax, -0x250(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xe954f
movq -0x250(%rbp), %rax
addq $0x250, %rsp # imm = 0x250
popq %rbp
retq
callq 0x2a270
nopw %cs:(%rax,%rax)
| unpack_dirname:
push rbp
mov rbp, rsp
sub rsp, 250h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_218], rdi
mov [rbp+var_220], rsi
lea rdi, [rbp+var_210]
mov rsi, [rbp+var_220]
call normalize_dirname
mov [rbp+var_228], rax
movsx eax, [rbp+var_210]
cmp eax, 7Eh ; '~'
jnz loc_E9511
lea rax, [rbp+var_210]
add rax, 1
mov [rbp+var_238], rax
lea rdi, [rbp+var_238]
call expand_tilde
mov [rbp+var_240], rax
cmp [rbp+var_240], 0
jz loc_E950F
mov rcx, [rbp+var_238]
lea rax, [rbp+var_210]
sub rcx, rax
sub rcx, 1
mov rax, [rbp+var_228]
sub rax, rcx
mov [rbp+var_228], rax
mov rax, [rbp+var_228]
mov [rbp+var_248], rax
mov rdi, [rbp+var_240]
call _strlen
mov rcx, rax
mov rax, [rbp+var_248]
mov [rbp+var_230], rcx
add rax, rcx
cmp rax, 200h
ja loc_E950D
cmp [rbp+var_230], 0
jbe short loc_E948A
mov rax, [rbp+var_240]
mov rcx, [rbp+var_230]
sub rcx, 1
movsx eax, byte ptr [rax+rcx]
cmp eax, 2Fh ; '/'
jnz short loc_E948A
mov rax, [rbp+var_230]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_230], rax
loc_E948A:
lea rax, [rbp+var_210]
add rax, [rbp+var_230]
cmp rax, [rbp+var_238]
jnb short loc_E94C4
lea rdi, [rbp+var_210]
add rdi, [rbp+var_230]
mov rsi, [rbp+var_238]
mov rdx, [rbp+var_228]
call _memmove
jmp short loc_E94F3
loc_E94C4:
lea rdi, [rbp+var_210]
add rdi, [rbp+var_230]
add rdi, [rbp+var_228]
mov rsi, [rbp+var_238]
add rsi, [rbp+var_228]
mov rdx, [rbp+var_228]
call bmove_upp
loc_E94F3:
lea rdi, [rbp+var_210]
mov rsi, [rbp+var_240]
mov rdx, [rbp+var_230]
call _memmove
loc_E950D:
jmp short $+2
loc_E950F:
jmp short $+2
loc_E9511:
jmp short $+2
loc_E9513:
mov rdi, [rbp+var_218]
lea rsi, [rbp+var_210]
call system_filename
mov [rbp+var_250], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_E954F
mov rax, [rbp+var_250]
add rsp, 250h
pop rbp
retn
loc_E954F:
call ___stack_chk_fail
| long long unpack_dirname(long long a1, _BYTE *a2)
{
long long v3; // [rsp+8h] [rbp-248h]
long long v4; // [rsp+10h] [rbp-240h]
_BYTE *v5; // [rsp+18h] [rbp-238h] BYREF
long long v6; // [rsp+20h] [rbp-230h]
long long v7; // [rsp+28h] [rbp-228h]
_BYTE *v8; // [rsp+30h] [rbp-220h]
long long v9; // [rsp+38h] [rbp-218h]
char v10; // [rsp+40h] [rbp-210h] BYREF
_BYTE v11[527]; // [rsp+41h] [rbp-20Fh] BYREF
*(_QWORD *)&v11[519] = __readfsqword(0x28u);
v9 = a1;
v8 = a2;
v7 = normalize_dirname((long long)&v10, a2);
if ( v10 == 126 )
{
v5 = v11;
v4 = expand_tilde(&v5);
if ( v4 )
{
v7 -= v5 - &v10 - 1;
v3 = v7;
v6 = strlen(v4);
if ( (unsigned long long)(v6 + v3) <= 0x200 )
{
if ( v6 && *(_BYTE *)(v4 + v6 - 1) == 47 )
--v6;
if ( &v11[v6 - 1] >= v5 )
bmove_upp(&v11[v6 - 1 + v7], &v5[v7], v7);
else
memmove(&v11[v6 - 1], v5, v7);
memmove(&v10, v4, v6);
}
}
}
return system_filename(v9, &v10);
}
| unpack_dirname:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x250
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x218],RDI
MOV qword ptr [RBP + -0x220],RSI
LEA RDI,[RBP + -0x210]
MOV RSI,qword ptr [RBP + -0x220]
CALL 0x001e9260
MOV qword ptr [RBP + -0x228],RAX
MOVSX EAX,byte ptr [RBP + -0x210]
CMP EAX,0x7e
JNZ 0x001e9511
LEA RAX,[RBP + -0x210]
ADD RAX,0x1
MOV qword ptr [RBP + -0x238],RAX
LEA RDI,[RBP + -0x238]
CALL 0x001e9560
MOV qword ptr [RBP + -0x240],RAX
CMP qword ptr [RBP + -0x240],0x0
JZ 0x001e950f
MOV RCX,qword ptr [RBP + -0x238]
LEA RAX,[RBP + -0x210]
SUB RCX,RAX
SUB RCX,0x1
MOV RAX,qword ptr [RBP + -0x228]
SUB RAX,RCX
MOV qword ptr [RBP + -0x228],RAX
MOV RAX,qword ptr [RBP + -0x228]
MOV qword ptr [RBP + -0x248],RAX
MOV RDI,qword ptr [RBP + -0x240]
CALL 0x0012a350
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x248]
MOV qword ptr [RBP + -0x230],RCX
ADD RAX,RCX
CMP RAX,0x200
JA 0x001e950d
CMP qword ptr [RBP + -0x230],0x0
JBE 0x001e948a
MOV RAX,qword ptr [RBP + -0x240]
MOV RCX,qword ptr [RBP + -0x230]
SUB RCX,0x1
MOVSX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x2f
JNZ 0x001e948a
MOV RAX,qword ptr [RBP + -0x230]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x230],RAX
LAB_001e948a:
LEA RAX,[RBP + -0x210]
ADD RAX,qword ptr [RBP + -0x230]
CMP RAX,qword ptr [RBP + -0x238]
JNC 0x001e94c4
LEA RDI,[RBP + -0x210]
ADD RDI,qword ptr [RBP + -0x230]
MOV RSI,qword ptr [RBP + -0x238]
MOV RDX,qword ptr [RBP + -0x228]
CALL 0x0012a130
JMP 0x001e94f3
LAB_001e94c4:
LEA RDI,[RBP + -0x210]
ADD RDI,qword ptr [RBP + -0x230]
ADD RDI,qword ptr [RBP + -0x228]
MOV RSI,qword ptr [RBP + -0x238]
ADD RSI,qword ptr [RBP + -0x228]
MOV RDX,qword ptr [RBP + -0x228]
CALL 0x0020ae90
LAB_001e94f3:
LEA RDI,[RBP + -0x210]
MOV RSI,qword ptr [RBP + -0x240]
MOV RDX,qword ptr [RBP + -0x230]
CALL 0x0012a130
LAB_001e950d:
JMP 0x001e950f
LAB_001e950f:
JMP 0x001e9511
LAB_001e9511:
JMP 0x001e9513
LAB_001e9513:
MOV RDI,qword ptr [RBP + -0x218]
LEA RSI,[RBP + -0x210]
CALL 0x001e9620
MOV qword ptr [RBP + -0x250],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001e954f
MOV RAX,qword ptr [RBP + -0x250]
ADD RSP,0x250
POP RBP
RET
LAB_001e954f:
CALL 0x0012a270
|
int8 unpack_dirname(int8 param_1,int8 param_2)
{
char *__s;
size_t sVar1;
int8 uVar2;
long in_FS_OFFSET;
char *local_240;
size_t local_238;
size_t local_230;
int8 local_228;
int8 local_220;
char local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_228 = param_2;
local_220 = param_1;
local_230 = normalize_dirname(local_218,param_2);
if (local_218[0] == '~') {
local_240 = local_218 + 1;
__s = (char *)expand_tilde(&local_240);
if (__s != (char *)0x0) {
sVar1 = local_230 - (long)(local_240 + (-1 - (long)local_218));
local_230 = sVar1;
local_238 = strlen(__s);
if (sVar1 + local_238 < 0x201) {
if ((local_238 != 0) && (__s[local_238 - 1] == '/')) {
local_238 = local_238 - 1;
}
if (local_218 + local_238 < local_240) {
memmove(local_218 + local_238,local_240,local_230);
}
else {
bmove_upp(local_218 + local_230 + local_238,local_240 + local_230,local_230);
}
memmove(local_218,__s,local_238);
}
}
}
uVar2 = system_filename(local_220,local_218);
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar2;
}
| |
41,222 | nglog::tools::Demangle(char const*, char*, unsigned long) | ng-log[P]ng-log/src/demangle.cc | bool Demangle(const char* mangled, char* out, size_t out_size) {
#if defined(NGLOG_OS_WINDOWS)
# if defined(HAVE_DBGHELP)
// When built with incremental linking, the Windows debugger
// library provides a more complicated `Symbol->Name` with the
// Incremental Linking Table offset, which looks like
// `@ILT+1105(?func@Foo@@SAXH@Z)`. However, the demangler expects
// only the mangled symbol, `?func@Foo@@SAXH@Z`. Fortunately, the
// mangled symbol is guaranteed not to have parentheses,
// so we search for `(` and extract up to `)`.
//
// Since we may be in a signal handler here, we cannot use `std::string`.
char buffer[1024]; // Big enough for a sane symbol.
const char* lparen = strchr(mangled, '(');
if (lparen) {
// Extract the string `(?...)`
const char* rparen = strchr(lparen, ')');
size_t length = static_cast<size_t>(rparen - lparen) - 1;
strncpy(buffer, lparen + 1, length);
buffer[length] = '\0';
mangled = buffer;
} // Else the symbol wasn't inside a set of parentheses
// We use the ANSI version to ensure the string type is always `char *`.
return UnDecorateSymbolName(mangled, out, out_size, UNDNAME_COMPLETE);
# else
(void)mangled;
(void)out;
(void)out_size;
return false;
# endif
#elif defined(HAVE___CXA_DEMANGLE)
int status = -1;
std::size_t n = 0;
std::unique_ptr<char, decltype(&std::free)> unmangled{
abi::__cxa_demangle(mangled, nullptr, &n, &status), &std::free};
if (!unmangled) {
return false;
}
std::copy_n(unmangled.get(), std::min(n, out_size), out);
return status == 0;
#else
State state;
InitState(&state, mangled, out, out_size);
return ParseTopLevelMangledName(&state) && !state.overflowed;
#endif
} | O2 | cpp | nglog::tools::Demangle(char const*, char*, unsigned long):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0xc(%rsp), %rcx
orl $-0x1, (%rcx)
leaq 0x10(%rsp), %rdx
andq $0x0, (%rdx)
xorl %r12d, %r12d
xorl %esi, %esi
callq 0x74a0
testq %rax, %rax
je 0x901c
movq %rax, %r15
movq 0x10(%rsp), %rax
cmpq %rbx, %rax
cmovbq %rax, %rbx
testq %rbx, %rbx
je 0x900b
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x7950
cmpl $0x0, 0xc(%rsp)
sete %r12b
movq %r15, %rdi
callq 0x76d0
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| _ZN5nglog5tools8DemangleEPKcPcm:
push r15
push r14
push r12
push rbx
sub rsp, 18h
mov rbx, rdx
mov r14, rsi
lea rcx, [rsp+38h+status]; lpstatus
or dword ptr [rcx], 0FFFFFFFFh
lea rdx, [rsp+38h+outlen]; lpoutlen
and qword ptr [rdx], 0
xor r12d, r12d
xor esi, esi; lpout
call ___cxa_demangle
test rax, rax
jz short loc_901C
mov r15, rax
mov rax, [rsp+38h+outlen]
cmp rax, rbx
cmovb rbx, rax
test rbx, rbx
jz short loc_900B
mov rdi, r14
mov rsi, r15
mov rdx, rbx
call _memmove
loc_900B:
cmp [rsp+38h+status], 0
setz r12b
mov rdi, r15
call _free
loc_901C:
mov eax, r12d
add rsp, 18h
pop rbx
pop r12
pop r14
pop r15
retn
| long long nglog::tools::Demangle(nglog::tools *this, const char *a2, char *a3)
{
unsigned int v4; // r12d
char *v5; // rax
char *v6; // r15
int status; // [rsp+Ch] [rbp-2Ch] BYREF
size_t outlen[5]; // [rsp+10h] [rbp-28h] BYREF
status = -1;
outlen[0] = 0LL;
v4 = 0;
v5 = __cxa_demangle((const char *)this, 0LL, outlen, &status);
if ( v5 )
{
v6 = v5;
if ( outlen[0] < (unsigned long long)a3 )
a3 = (char *)outlen[0];
if ( a3 )
memmove(a2, v5, a3);
LOBYTE(v4) = status == 0;
free(v6);
}
return v4;
}
| Demangle:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDX
MOV R14,RSI
LEA RCX,[RSP + 0xc]
OR dword ptr [RCX],0xffffffff
LEA RDX,[RSP + 0x10]
AND qword ptr [RDX],0x0
XOR R12D,R12D
XOR ESI,ESI
CALL 0x001074a0
TEST RAX,RAX
JZ 0x0010901c
MOV R15,RAX
MOV RAX,qword ptr [RSP + 0x10]
CMP RAX,RBX
CMOVC RBX,RAX
TEST RBX,RBX
JZ 0x0010900b
MOV RDI,R14
MOV RSI,R15
MOV RDX,RBX
CALL 0x00107950
LAB_0010900b:
CMP dword ptr [RSP + 0xc],0x0
SETZ R12B
MOV RDI,R15
CALL 0x001076d0
LAB_0010901c:
MOV EAX,R12D
ADD RSP,0x18
POP RBX
POP R12
POP R14
POP R15
RET
|
/* nglog::tools::Demangle(char const*, char*, unsigned long) */
int8 nglog::tools::Demangle(char *param_1,char *param_2,ulong param_3)
{
void *__src;
__src = (void *)__cxa_demangle(param_1,0);
if (__src != (void *)0x0) {
if (param_3 != 0) {
param_3 = 0;
}
if (param_3 != 0) {
memmove(param_2,__src,param_3);
}
free(__src);
}
return 0;
}
| |
41,223 | ftxui::borderDashed(std::shared_ptr<ftxui::Node>) | Andrewchistyakov[P]flashcards_lyc/build_O2/_deps/ftxui-src/src/ftxui/dom/border.cpp | Element borderDashed(Element child) {
return std::make_shared<Border>(unpack(std::move(child)), DASHED);
} | O2 | cpp | ftxui::borderDashed(std::shared_ptr<ftxui::Node>):
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x28(%rsp), %rbx
movups (%rsi), %xmm0
andq $0x0, 0x8(%rsi)
movaps %xmm0, -0x8(%rbx)
andq $0x0, (%rsi)
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1d99c
leaq 0x4(%rsp), %rdx
movl $0x1, (%rdx)
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1c48a
leaq 0x38(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%r14)
andq $0x0, -0x8(%rdi)
callq 0x13452
leaq 0x8(%rsp), %rdi
callq 0x13b2c
movq %rbx, %rdi
callq 0x13452
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x13b2c
jmp 0x1c6ee
movq %rax, %r14
movq %rbx, %rdi
callq 0x13452
movq %r14, %rdi
callq 0xc7f0
| _ZN5ftxui12borderDashedESt10shared_ptrINS_4NodeEE:
push r14
push rbx
sub rsp, 48h
mov r14, rdi
lea rbx, [rsp+58h+var_30]
movups xmm0, xmmword ptr [rsi]
and qword ptr [rsi+8], 0
movaps xmmword ptr [rbx-8], xmm0
and qword ptr [rsi], 0
lea rdi, [rsp+58h+var_50]
lea rsi, [rsp+58h+var_38]
call _ZN5ftxui6unpackIJSt10shared_ptrINS_4NodeEEEEESt6vectorIS3_SaIS3_EEDpT_; ftxui::unpack<std::shared_ptr<ftxui::Node>>(std::shared_ptr<ftxui::Node>)
lea rdx, [rsp+58h+var_54]
mov dword ptr [rdx], 1
lea rdi, [rsp+58h+var_28]
lea rsi, [rsp+58h+var_50]
call _ZSt11make_sharedIN5ftxui12_GLOBAL__N_16BorderEJSt6vectorISt10shared_ptrINS0_4NodeEESaIS6_EENS0_11BorderStyleEEES4_IT_EDpOT0_; std::make_shared<ftxui::`anonymous namespace'::Border,std::vector<std::shared_ptr<ftxui::Node>>,ftxui::BorderStyle>(std::vector<std::shared_ptr<ftxui::Node>>,ftxui::BorderStyle &&)
lea rdi, [rsp+58h+var_20]
movaps xmm0, xmmword ptr [rdi-8]
and qword ptr [rdi], 0
movups xmmword ptr [r14], xmm0
and qword ptr [rdi-8], 0
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+58h+var_50]
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
mov rdi, rbx
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rax, r14
add rsp, 48h
pop rbx
pop r14
retn
mov r14, rax
lea rdi, [rsp+arg_0]
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
jmp short loc_1C6EE
mov r14, rax
loc_1C6EE:
mov rdi, rbx
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, r14
call __Unwind_Resume
| _OWORD * ftxui::borderDashed(_OWORD *a1, __int128 *a2)
{
__int128 v2; // xmm0
__int128 v3; // xmm0
unsigned int v5; // [rsp+4h] [rbp-54h] BYREF
__int128 v6; // [rsp+8h] [rbp-50h] BYREF
__int128 v7; // [rsp+20h] [rbp-38h] BYREF
_OWORD v8[2]; // [rsp+30h] [rbp-28h] BYREF
v2 = *a2;
*((_QWORD *)a2 + 1) = 0LL;
v7 = v2;
*(_QWORD *)a2 = 0LL;
ftxui::unpack<std::shared_ptr<ftxui::Node>>(&v6, &v7);
v5 = 1;
std::make_shared<ftxui::`anonymous namespace'::Border,std::vector<std::shared_ptr<ftxui::Node>>,ftxui::BorderStyle>(
v8,
&v6,
&v5);
v3 = v8[0];
*((_QWORD *)&v8[0] + 1) = 0LL;
*a1 = v3;
*(_QWORD *)&v8[0] = 0LL;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((_QWORD *)v8 + 1);
std::vector<std::shared_ptr<ftxui::Node>>::~vector(&v6);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((_QWORD *)&v7 + 1);
return a1;
}
| borderDashed:
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV R14,RDI
LEA RBX,[RSP + 0x28]
MOVUPS XMM0,xmmword ptr [RSI]
AND qword ptr [RSI + 0x8],0x0
MOVAPS xmmword ptr [RBX + -0x8],XMM0
AND qword ptr [RSI],0x0
LAB_0011c67b:
LEA RDI,[RSP + 0x8]
LEA RSI,[RSP + 0x20]
CALL 0x0011d99c
LEA RDX,[RSP + 0x4]
MOV dword ptr [RDX],0x1
LAB_0011c695:
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x8]
CALL 0x0011c48a
LAB_0011c6a4:
LEA RDI,[RSP + 0x38]
MOVAPS XMM0,xmmword ptr [RDI + -0x8]
AND qword ptr [RDI],0x0
MOVUPS xmmword ptr [R14],XMM0
AND qword ptr [RDI + -0x8],0x0
CALL 0x00113452
LEA RDI,[RSP + 0x8]
CALL 0x00113b2c
MOV RDI,RBX
CALL 0x00113452
MOV RAX,R14
ADD RSP,0x48
POP RBX
POP R14
RET
|
/* ftxui::borderDashed(std::shared_ptr<ftxui::Node>) */
ftxui * __thiscall ftxui::borderDashed(ftxui *this,int8 *param_2)
{
int8 uVar1;
ftxui local_50 [24];
int4 local_38;
int4 uStack_34;
int4 uStack_30;
int4 uStack_2c;
int8 local_28;
int8 auStack_20 [2];
local_38 = *(int4 *)param_2;
uStack_34 = *(int4 *)((long)param_2 + 4);
uStack_30 = *(int4 *)(param_2 + 1);
uStack_2c = *(int4 *)((long)param_2 + 0xc);
param_2[1] = 0;
*param_2 = 0;
/* try { // try from 0011c67b to 0011c689 has its CatchHandler @ 0011c6eb */
unpack<std::shared_ptr<ftxui::Node>>(local_50,&local_38);
/* try { // try from 0011c695 to 0011c6a3 has its CatchHandler @ 0011c6dc */
std::
make_shared<ftxui::(anonymous_namespace)::Border,std::vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>,ftxui::BorderStyle>
((vector *)&local_28,(BorderStyle *)local_50);
uVar1 = auStack_20[0];
auStack_20[0] = 0;
*(int8 *)this = local_28;
*(int8 *)(this + 8) = uVar1;
local_28 = 0;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)auStack_20);
std::vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>::~vector
((vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>> *)
local_50);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&uStack_30);
return this;
}
| |
41,224 | intx::div_result<intx::uint<256u>, intx::uint<256u>> intx::sdivrem<256u>(intx::uint<256u> const&, intx::uint<256u> const&) | corpus-core[P]colibri-stateless/build_O0/_deps/intx-src/include/intx/intx.hpp | inline constexpr div_result<uint<N>> sdivrem(const uint<N>& u, const uint<N>& v) noexcept
{
const auto sign_mask = uint<N>{1} << (sizeof(u) * 8 - 1);
auto u_is_neg = (u & sign_mask) != 0;
auto v_is_neg = (v & sign_mask) != 0;
auto u_abs = u_is_neg ? -u : u;
auto v_abs = v_is_neg ? -v : v;
auto q_is_neg = u_is_neg ^ v_is_neg;
auto res = udivrem(u_abs, v_abs);
return {q_is_neg ? -res.quot : res.quot, u_is_neg ? -res.rem : res.rem};
} | O0 | cpp | intx::div_result<intx::uint<256u>, intx::uint<256u>> intx::sdivrem<256u>(intx::uint<256u> const&, intx::uint<256u> const&):
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x140(%rbp)
movq %rdi, -0x138(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
leaq -0x50(%rbp), %rdi
movl $0x1, %esi
callq 0x61cc0
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0xff, %edx
callq 0x64ac0
movq -0x8(%rbp), %rsi
leaq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x64db0
movl $0x0, -0x7c(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x7c(%rbp), %rsi
callq 0x61c20
andb $0x1, %al
movb %al, -0x51(%rbp)
movq -0x10(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x64db0
movl $0x0, -0xa4(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0xa4(%rbp), %rsi
callq 0x61c20
andb $0x1, %al
movb %al, -0x7d(%rbp)
testb $0x1, -0x51(%rbp)
je 0x64949
movq -0x8(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
callq 0x64e40
jmp 0x64978
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0xc8(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0xc0(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0xb8(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0xb0(%rbp)
testb $0x1, -0x7d(%rbp)
je 0x64990
movq -0x10(%rbp), %rsi
leaq -0xe8(%rbp), %rdi
callq 0x64e40
jmp 0x649bf
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0xe8(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0xe0(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0xd8(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0xd0(%rbp)
movb -0x51(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb -0x7d(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
xorl %ecx, %eax
movl %eax, -0xec(%rbp)
leaq -0x130(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
leaq -0xe8(%rbp), %rdx
callq 0x61db0
cmpl $0x0, -0xec(%rbp)
je 0x64a10
movq -0x140(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0x64e40
jmp 0x64a42
movq -0x140(%rbp), %rax
movq -0x130(%rbp), %rcx
movq %rcx, (%rax)
movq -0x128(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x120(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x118(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x140(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x148(%rbp)
testb $0x1, -0x51(%rbp)
je 0x64a73
movq -0x148(%rbp), %rdi
leaq -0x130(%rbp), %rsi
addq $0x20, %rsi
callq 0x64e40
jmp 0x64aa5
movq -0x148(%rbp), %rax
movq -0x110(%rbp), %rcx
movq %rcx, (%rax)
movq -0x108(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0xf8(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x138(%rbp), %rax
addq $0x150, %rsp # imm = 0x150
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| _ZN4intx7sdivremILj256EEENS_10div_resultINS_4uintIXT_EEES3_EERKS3_S6_:
push rbp
mov rbp, rsp
sub rsp, 150h
mov [rbp+var_140], rdi
mov [rbp+var_138], rdi
mov [rbp+var_8], rsi
mov [rbp+var_10], rdx
lea rdi, [rbp+var_50]
mov esi, 1
call _ZN4intx4uintILj256EEC2IJiEvEEDpT_; intx::uint<256u>::uint<int,void>(int)
lea rdi, [rbp+var_30]
lea rsi, [rbp+var_50]
mov edx, 0FFh
call _ZN4intxlsERKNS_4uintILj256EEEm; intx::operator<<(intx::uint<256u> const&,ulong)
mov rsi, [rbp+var_8]
lea rdi, [rbp+var_78]
lea rdx, [rbp+var_30]
call _ZN4intxanERKNS_4uintILj256EEES3_; intx::operator&(intx::uint<256u> const&,intx::uint<256u> const&)
mov [rbp+var_7C], 0
lea rdi, [rbp+var_78]
lea rsi, [rbp+var_7C]
call _ZN4intxneILj256EivEEbRKNS_4uintIXT_EEERKT0_; intx::operator!=<256u,int,void>(intx::uint<256u> const&,int const&)
and al, 1
mov [rbp+var_51], al
mov rsi, [rbp+var_10]
lea rdi, [rbp+var_A0]
lea rdx, [rbp+var_30]
call _ZN4intxanERKNS_4uintILj256EEES3_; intx::operator&(intx::uint<256u> const&,intx::uint<256u> const&)
mov [rbp+var_A4], 0
lea rdi, [rbp+var_A0]
lea rsi, [rbp+var_A4]
call _ZN4intxneILj256EivEEbRKNS_4uintIXT_EEERKT0_; intx::operator!=<256u,int,void>(intx::uint<256u> const&,int const&)
and al, 1
mov [rbp+var_7D], al
test [rbp+var_51], 1
jz short loc_64949
mov rsi, [rbp+var_8]
lea rdi, [rbp+var_C8]
call _ZNK4intx4uintILj256EEngEv; intx::uint<256u>::operator-(void)
jmp short loc_64978
loc_64949:
mov rax, [rbp+var_8]
mov rcx, [rax]
mov [rbp+var_C8], rcx
mov rcx, [rax+8]
mov [rbp+var_C0], rcx
mov rcx, [rax+10h]
mov [rbp+var_B8], rcx
mov rax, [rax+18h]
mov [rbp+var_B0], rax
loc_64978:
test [rbp+var_7D], 1
jz short loc_64990
mov rsi, [rbp+var_10]
lea rdi, [rbp+var_E8]
call _ZNK4intx4uintILj256EEngEv; intx::uint<256u>::operator-(void)
jmp short loc_649BF
loc_64990:
mov rax, [rbp+var_10]
mov rcx, [rax]
mov [rbp+var_E8], rcx
mov rcx, [rax+8]
mov [rbp+var_E0], rcx
mov rcx, [rax+10h]
mov [rbp+var_D8], rcx
mov rax, [rax+18h]
mov [rbp+var_D0], rax
loc_649BF:
mov al, [rbp+var_51]
and al, 1
movzx eax, al
mov cl, [rbp+var_7D]
and cl, 1
movzx ecx, cl
xor eax, ecx
mov [rbp+var_EC], eax
lea rdi, [rbp+var_130]
lea rsi, [rbp+var_C8]
lea rdx, [rbp+var_E8]
call _ZN4intx7udivremILj256ELj256EEENS_10div_resultINS_4uintIXT_EEENS2_IXT0_EEEEERKS3_RKS4_; intx::udivrem<256u,256u>(intx::uint<256u> const&,intx::uint<256u> const&)
cmp [rbp+var_EC], 0
jz short loc_64A10
mov rdi, [rbp+var_140]
lea rsi, [rbp+var_130]
call _ZNK4intx4uintILj256EEngEv; intx::uint<256u>::operator-(void)
jmp short loc_64A42
loc_64A10:
mov rax, [rbp+var_140]
mov rcx, [rbp+var_130]
mov [rax], rcx
mov rcx, [rbp+var_128]
mov [rax+8], rcx
mov rcx, [rbp+var_120]
mov [rax+10h], rcx
mov rcx, [rbp+var_118]
mov [rax+18h], rcx
loc_64A42:
mov rax, [rbp+var_140]
add rax, 20h ; ' '
mov [rbp+var_148], rax
test [rbp+var_51], 1
jz short loc_64A73
mov rdi, [rbp+var_148]
lea rsi, [rbp+var_130]
add rsi, 20h ; ' '
call _ZNK4intx4uintILj256EEngEv; intx::uint<256u>::operator-(void)
jmp short loc_64AA5
loc_64A73:
mov rax, [rbp+var_148]
mov rcx, [rbp+var_110]
mov [rax], rcx
mov rcx, [rbp+var_108]
mov [rax+8], rcx
mov rcx, [rbp+var_100]
mov [rax+10h], rcx
mov rcx, [rbp+var_F8]
mov [rax+18h], rcx
loc_64AA5:
mov rax, [rbp+var_138]
add rsp, 150h
pop rbp
retn
| _QWORD * intx::sdivrem<256u>(_QWORD *a1, _QWORD *a2, _QWORD *a3)
{
_QWORD *v4; // [rsp+8h] [rbp-148h]
_QWORD v5[4]; // [rsp+20h] [rbp-130h] BYREF
_QWORD v6[4]; // [rsp+40h] [rbp-110h] BYREF
int v7; // [rsp+64h] [rbp-ECh]
_QWORD v8[4]; // [rsp+68h] [rbp-E8h] BYREF
_QWORD v9[4]; // [rsp+88h] [rbp-C8h] BYREF
unsigned int v10; // [rsp+ACh] [rbp-A4h] BYREF
_BYTE v11[35]; // [rsp+B0h] [rbp-A0h] BYREF
char v12; // [rsp+D3h] [rbp-7Dh]
unsigned int v13; // [rsp+D4h] [rbp-7Ch] BYREF
_BYTE v14[39]; // [rsp+D8h] [rbp-78h] BYREF
char v15; // [rsp+FFh] [rbp-51h]
_QWORD v16[4]; // [rsp+100h] [rbp-50h] BYREF
_BYTE v17[32]; // [rsp+120h] [rbp-30h] BYREF
_QWORD *v18; // [rsp+140h] [rbp-10h]
_QWORD *v19; // [rsp+148h] [rbp-8h]
v19 = a2;
v18 = a3;
intx::uint<256u>::uint<int,void>(v16, 1);
intx::operator<<(v17, v16, 255LL);
intx::operator&(v14, v19, v17);
v13 = 0;
v15 = intx::operator!=<256u,int,void>((long long)v14, &v13) & 1;
intx::operator&(v11, v18, v17);
v10 = 0;
v12 = intx::operator!=<256u,int,void>((long long)v11, &v10) & 1;
if ( (v15 & 1) != 0 )
{
intx::uint<256u>::operator-(v9, v19);
}
else
{
v9[0] = *v19;
v9[1] = v19[1];
v9[2] = v19[2];
v9[3] = v19[3];
}
if ( (v12 & 1) != 0 )
{
intx::uint<256u>::operator-(v8, v18);
}
else
{
v8[0] = *v18;
v8[1] = v18[1];
v8[2] = v18[2];
v8[3] = v18[3];
}
v7 = v12 & 1 ^ v15 & 1;
intx::udivrem<256u,256u>(v5, (unsigned long long)v9, v8);
if ( v7 )
{
intx::uint<256u>::operator-(a1, v5);
}
else
{
*a1 = v5[0];
a1[1] = v5[1];
a1[2] = v5[2];
a1[3] = v5[3];
}
v4 = a1 + 4;
if ( (v15 & 1) != 0 )
{
intx::uint<256u>::operator-(v4, v6);
}
else
{
*v4 = v6[0];
a1[5] = v6[1];
a1[6] = v6[2];
a1[7] = v6[3];
}
return a1;
}
| sdivrem<256u>:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x150
MOV qword ptr [RBP + -0x140],RDI
MOV qword ptr [RBP + -0x138],RDI
MOV qword ptr [RBP + -0x8],RSI
MOV qword ptr [RBP + -0x10],RDX
LEA RDI,[RBP + -0x50]
MOV ESI,0x1
CALL 0x00161cc0
LEA RDI,[RBP + -0x30]
LEA RSI,[RBP + -0x50]
MOV EDX,0xff
CALL 0x00164ac0
MOV RSI,qword ptr [RBP + -0x8]
LEA RDI,[RBP + -0x78]
LEA RDX,[RBP + -0x30]
CALL 0x00164db0
MOV dword ptr [RBP + -0x7c],0x0
LEA RDI,[RBP + -0x78]
LEA RSI,[RBP + -0x7c]
CALL 0x00161c20
AND AL,0x1
MOV byte ptr [RBP + -0x51],AL
MOV RSI,qword ptr [RBP + -0x10]
LEA RDI,[RBP + -0xa0]
LEA RDX,[RBP + -0x30]
CALL 0x00164db0
MOV dword ptr [RBP + -0xa4],0x0
LEA RDI,[RBP + -0xa0]
LEA RSI,[RBP + -0xa4]
CALL 0x00161c20
AND AL,0x1
MOV byte ptr [RBP + -0x7d],AL
TEST byte ptr [RBP + -0x51],0x1
JZ 0x00164949
MOV RSI,qword ptr [RBP + -0x8]
LEA RDI,[RBP + -0xc8]
CALL 0x00164e40
JMP 0x00164978
LAB_00164949:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBP + -0xc8],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0xc0],RCX
MOV RCX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0xb8],RCX
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0xb0],RAX
LAB_00164978:
TEST byte ptr [RBP + -0x7d],0x1
JZ 0x00164990
MOV RSI,qword ptr [RBP + -0x10]
LEA RDI,[RBP + -0xe8]
CALL 0x00164e40
JMP 0x001649bf
LAB_00164990:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBP + -0xe8],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0xe0],RCX
MOV RCX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0xd8],RCX
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0xd0],RAX
LAB_001649bf:
MOV AL,byte ptr [RBP + -0x51]
AND AL,0x1
MOVZX EAX,AL
MOV CL,byte ptr [RBP + -0x7d]
AND CL,0x1
MOVZX ECX,CL
XOR EAX,ECX
MOV dword ptr [RBP + -0xec],EAX
LEA RDI,[RBP + -0x130]
LEA RSI,[RBP + -0xc8]
LEA RDX,[RBP + -0xe8]
CALL 0x00161db0
CMP dword ptr [RBP + -0xec],0x0
JZ 0x00164a10
MOV RDI,qword ptr [RBP + -0x140]
LEA RSI,[RBP + -0x130]
CALL 0x00164e40
JMP 0x00164a42
LAB_00164a10:
MOV RAX,qword ptr [RBP + -0x140]
MOV RCX,qword ptr [RBP + -0x130]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x128]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x120]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x118]
MOV qword ptr [RAX + 0x18],RCX
LAB_00164a42:
MOV RAX,qword ptr [RBP + -0x140]
ADD RAX,0x20
MOV qword ptr [RBP + -0x148],RAX
TEST byte ptr [RBP + -0x51],0x1
JZ 0x00164a73
MOV RDI,qword ptr [RBP + -0x148]
LEA RSI,[RBP + -0x130]
ADD RSI,0x20
CALL 0x00164e40
JMP 0x00164aa5
LAB_00164a73:
MOV RAX,qword ptr [RBP + -0x148]
MOV RCX,qword ptr [RBP + -0x110]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x108]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x100]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0xf8]
MOV qword ptr [RAX + 0x18],RCX
LAB_00164aa5:
MOV RAX,qword ptr [RBP + -0x138]
ADD RSP,0x150
POP RBP
RET
|
/* intx::div_result<intx::uint<256u>, intx::uint<256u> > intx::sdivrem<256u>(intx::uint<256u>
const&, intx::uint<256u> const&) */
intx * __thiscall intx::sdivrem<256u>(intx *this,uint *param_1,uint *param_2)
{
int8 local_138;
int8 local_130;
int8 local_128;
int8 local_120;
int8 local_118;
int8 local_110;
int8 local_108;
int8 local_100;
uint local_f4;
int8 local_f0;
int8 local_e8;
int8 local_e0;
int8 local_d8;
int8 local_d0;
int8 local_c8;
int8 local_c0;
int8 local_b8;
int local_ac;
intx local_a8 [35];
byte local_85;
int local_84;
intx local_80 [39];
byte local_59;
uint<256u> local_58 [32];
intx local_38 [32];
uint *local_18;
uint *local_10;
local_18 = param_2;
local_10 = param_1;
uint<256u>::uint<int,void>(local_58,1);
operator<<(local_38,(uint *)local_58,0xff);
operator&(local_80,local_10,(uint *)local_38);
local_84 = 0;
local_59 = operator!=((uint *)local_80,&local_84);
operator&(local_a8,local_18,(uint *)local_38);
local_ac = 0;
local_85 = operator!=((uint *)local_a8,&local_ac);
if ((local_59 & 1) == 0) {
local_d0 = *(int8 *)local_10;
local_c8 = *(int8 *)(local_10 + 8);
local_c0 = *(int8 *)(local_10 + 0x10);
local_b8 = *(int8 *)(local_10 + 0x18);
}
else {
uint<256u>::operator-((uint<256u> *)&local_d0);
}
if ((local_85 & 1) == 0) {
local_f0 = *(int8 *)local_18;
local_e8 = *(int8 *)(local_18 + 8);
local_e0 = *(int8 *)(local_18 + 0x10);
local_d8 = *(int8 *)(local_18 + 0x18);
}
else {
uint<256u>::operator-((uint<256u> *)&local_f0);
}
local_f4 = (uint)(local_59 & 1 ^ local_85 & 1);
udivrem<256u,256u>((intx *)&local_138,(uint *)&local_d0,(uint *)&local_f0);
if (local_f4 == 0) {
*(int8 *)this = local_138;
*(int8 *)(this + 8) = local_130;
*(int8 *)(this + 0x10) = local_128;
*(int8 *)(this + 0x18) = local_120;
}
else {
uint<256u>::operator-((uint<256u> *)this);
}
if ((local_59 & 1) == 0) {
*(int8 *)(this + 0x20) = local_118;
*(int8 *)(this + 0x28) = local_110;
*(int8 *)(this + 0x30) = local_108;
*(int8 *)(this + 0x38) = local_100;
}
else {
uint<256u>::operator-((uint<256u> *)(this + 0x20));
}
return this;
}
| |
41,225 | parse_cpu_mask(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool (&) [512]) | monkey531[P]llama/common/common.cpp | bool parse_cpu_mask(const std::string & mask, bool (&boolmask)[GGML_MAX_N_THREADS]) {
// Discard potential 0x prefix
size_t start_i = 0;
if (mask.length() >= 2 && mask.substr(0, 2) == "0x") {
start_i = 2;
}
size_t num_digits = mask.length() - start_i;
if (num_digits > 128) num_digits = 128;
size_t end_i = num_digits + start_i;
for (size_t i = start_i, n = (num_digits*4 - 1); i < end_i; i++, n-=4) {
char c = mask.at(i);
int8_t id = c;
if ((c >= '0' && c <= '9')) {
id -= '0';
} else if (c >= 'a' && c <= 'f') {
id -= 'a' - 10;
} else if (c >= 'A' && c <= 'F') {
id -= 'A' - 10;
} else {
LOG_ERR("Invalid hex character '%c' at position %d\n", c, int32_t(i));
return false;
}
boolmask[ n ] = boolmask[ n ] || ((id & 8) != 0);
boolmask[n - 1] = boolmask[n - 1] || ((id & 4) != 0);
boolmask[n - 2] = boolmask[n - 2] || ((id & 2) != 0);
boolmask[n - 3] = boolmask[n - 3] || ((id & 1) != 0);
}
return true;
} | O2 | cpp | parse_cpu_mask(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool (&) [512]):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq $0x2, %rax
jb 0x506a7
leaq 0x8(%rsp), %r14
pushq $0x2
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x21720
leaq 0x49c4b(%rip), %rsi # 0x9a2d3
movq %r14, %rdi
callq 0x3afd1
movl %eax, %ebp
movq %r14, %rdi
callq 0x21dc8
movzbl %bpl, %r14d
addl %r14d, %r14d
movq 0x8(%rbx), %rax
jmp 0x506aa
xorl %r14d, %r14d
subq %r14, %rax
movl $0x80, %ecx
cmpq %rcx, %rax
cmovaeq %rcx, %rax
leaq (%rax,%r14), %r12
movl %eax, %eax
leaq (%r15,%rax,4), %r13
addq $-0x4, %r13
cmpq %r12, %r14
jae 0x5077f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21810
movsbl (%rax), %r15d
leal -0x30(%r15), %eax
cmpb $0xa, %al
jb 0x50704
leal -0x61(%r15), %eax
cmpb $0x5, %al
ja 0x506f5
addb $-0x57, %r15b
jmp 0x50701
leal -0x41(%r15), %eax
cmpb $0x5, %al
ja 0x50754
addb $-0x37, %r15b
movl %r15d, %eax
movzbl %al, %eax
movd (%r13), %xmm0
punpcklbw %xmm0, %xmm0 # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
punpcklwd %xmm0, %xmm0 # xmm0 = xmm0[0,0,1,1,2,2,3,3]
movd %eax, %xmm1
pshufd $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
movdqa 0x4b49a(%rip), %xmm2 # 0x9bbc0
pand %xmm2, %xmm1
pcmpeqd %xmm2, %xmm1
por %xmm0, %xmm1
pand 0x4b496(%rip), %xmm1 # 0x9bbd0
packuswb %xmm1, %xmm1
packuswb %xmm1, %xmm1
movd %xmm1, (%r13)
incq %r14
addq $-0x4, %r13
jmp 0x506c7
leaq 0x8cab5(%rip), %rax # 0xdd210
cmpl $0x0, (%rax)
js 0x5077f
callq 0x837e2
leaq 0x4b706(%rip), %rdx # 0x9be72
pushq $0x4
popq %rsi
movq %rax, %rdi
movl %r15d, %ecx
movl %r14d, %r8d
xorl %eax, %eax
callq 0x8387a
cmpq %r12, %r14
setae %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _Z14parse_cpu_maskRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA512_b:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r15, rsi
mov rbx, rdi
mov rax, [rdi+8]
cmp rax, 2
jb short loc_506A7
lea r14, [rsp+58h+var_50]
push 2
pop rcx
mov rdi, r14
mov rsi, rbx
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
lea rsi, aIncompleteUtf8+24h; "0x"
mov rdi, r14
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
mov ebp, eax
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
movzx r14d, bpl
add r14d, r14d
mov rax, [rbx+8]
jmp short loc_506AA
loc_506A7:
xor r14d, r14d
loc_506AA:
sub rax, r14
mov ecx, 80h
cmp rax, rcx
cmovnb rax, rcx
lea r12, [rax+r14]
mov eax, eax
lea r13, [r15+rax*4]
add r13, 0FFFFFFFFFFFFFFFCh
loc_506C7:
cmp r14, r12
jnb loc_5077F
mov rdi, rbx
mov rsi, r14
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE2atEm; std::string::at(ulong)
movsx r15d, byte ptr [rax]
lea eax, [r15-30h]
cmp al, 0Ah
jb short loc_50704
lea eax, [r15-61h]
cmp al, 5
ja short loc_506F5
add r15b, 0A9h
jmp short loc_50701
loc_506F5:
lea eax, [r15-41h]
cmp al, 5
ja short loc_50754
add r15b, 0C9h
loc_50701:
mov eax, r15d
loc_50704:
movzx eax, al
movd xmm0, dword ptr [r13+0]
punpcklbw xmm0, xmm0
punpcklwd xmm0, xmm0
movd xmm1, eax
pshufd xmm1, xmm1, 0
movdqa xmm2, cs:xmmword_9BBC0
pand xmm1, xmm2
pcmpeqd xmm1, xmm2
por xmm1, xmm0
pand xmm1, cs:xmmword_9BBD0
packuswb xmm1, xmm1
packuswb xmm1, xmm1
movd dword ptr [r13+0], xmm1
inc r14
add r13, 0FFFFFFFFFFFFFFFCh
jmp loc_506C7
loc_50754:
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_5077F
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aInvalidHexChar; "Invalid hex character '%c' at position "...
push 4
pop rsi
mov rdi, rax
mov ecx, r15d
mov r8d, r14d
xor eax, eax
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_5077F:
cmp r14, r12
setnb al
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| bool parse_cpu_mask(long long a1, long long a2)
{
unsigned long long v2; // rax
bool v3; // bp
unsigned long long v4; // r14
unsigned long long v5; // rax
unsigned long long v6; // r12
unsigned int *v7; // r13
int v8; // r15d
unsigned __int8 v9; // al
unsigned __int8 v10; // r15
__m128i v11; // xmm0
__m128i v12; // xmm0
__m128i si128; // xmm2
__m128i v14; // xmm1
__m128i v15; // xmm1
int v16; // eax
int v17; // r9d
_BYTE v19[80]; // [rsp+8h] [rbp-50h] BYREF
v2 = *(_QWORD *)(a1 + 8);
if ( v2 < 2 )
{
v4 = 0LL;
}
else
{
std::string::substr(v19, a1, 0LL, 2LL);
v3 = std::operator==<char>((long long)v19);
std::string::~string(v19);
v4 = 2 * (unsigned int)v3;
v2 = *(_QWORD *)(a1 + 8);
}
v5 = v2 - v4;
if ( v5 >= 0x80 )
v5 = 128LL;
v6 = v5 + v4;
v7 = (unsigned int *)(a2 + 4LL * (unsigned int)v5 - 4);
while ( v4 < v6 )
{
v8 = *(char *)std::string::at(a1, v4);
v9 = v8 - 48;
if ( (unsigned __int8)(v8 - 48) >= 0xAu )
{
if ( (unsigned __int8)(v8 - 97) > 5u )
{
if ( (unsigned __int8)(v8 - 65) > 5u )
{
if ( common_log_verbosity_thold >= 0 )
{
v16 = common_log_main();
common_log_add(v16, 4, (unsigned int)"Invalid hex character '%c' at position %d\n", v8, v4, v17);
}
return v4 >= v6;
}
v10 = v8 - 55;
}
else
{
v10 = v8 - 87;
}
v9 = v10;
}
v11 = _mm_cvtsi32_si128(*v7);
v12 = _mm_unpacklo_epi8(v11, v11);
si128 = _mm_load_si128((const __m128i *)&xmmword_9BBC0);
v14 = _mm_and_si128(
_mm_or_si128(
_mm_cmpeq_epi32(_mm_and_si128(_mm_shuffle_epi32(_mm_cvtsi32_si128(v9), 0), si128), si128),
_mm_unpacklo_epi16(v12, v12)),
(__m128i)xmmword_9BBD0);
v15 = _mm_packus_epi16(v14, v14);
*v7 = _mm_cvtsi128_si32(_mm_packus_epi16(v15, v15));
++v4;
--v7;
}
return v4 >= v6;
}
| parse_cpu_mask:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x8]
CMP RAX,0x2
JC 0x001506a7
LEA R14,[RSP + 0x8]
PUSH 0x2
POP RCX
MOV RDI,R14
MOV RSI,RBX
XOR EDX,EDX
CALL 0x00121720
LEA RSI,[0x19a2d3]
MOV RDI,R14
CALL 0x0013afd1
MOV EBP,EAX
MOV RDI,R14
CALL 0x00121dc8
MOVZX R14D,BPL
ADD R14D,R14D
MOV RAX,qword ptr [RBX + 0x8]
JMP 0x001506aa
LAB_001506a7:
XOR R14D,R14D
LAB_001506aa:
SUB RAX,R14
MOV ECX,0x80
CMP RAX,RCX
CMOVNC RAX,RCX
LEA R12,[RAX + R14*0x1]
MOV EAX,EAX
LEA R13,[R15 + RAX*0x4]
ADD R13,-0x4
LAB_001506c7:
CMP R14,R12
JNC 0x0015077f
MOV RDI,RBX
MOV RSI,R14
CALL 0x00121810
MOVSX R15D,byte ptr [RAX]
LEA EAX,[R15 + -0x30]
CMP AL,0xa
JC 0x00150704
LEA EAX,[R15 + -0x61]
CMP AL,0x5
JA 0x001506f5
ADD R15B,0xa9
JMP 0x00150701
LAB_001506f5:
LEA EAX,[R15 + -0x41]
CMP AL,0x5
JA 0x00150754
ADD R15B,0xc9
LAB_00150701:
MOV EAX,R15D
LAB_00150704:
MOVZX EAX,AL
MOVD XMM0,dword ptr [R13]
PUNPCKLBW XMM0,XMM0
PUNPCKLWD XMM0,XMM0
MOVD XMM1,EAX
PSHUFD XMM1,XMM1,0x0
MOVDQA XMM2,xmmword ptr [0x0019bbc0]
PAND XMM1,XMM2
PCMPEQD XMM1,XMM2
POR XMM1,XMM0
PAND XMM1,xmmword ptr [0x0019bbd0]
PACKUSWB XMM1,XMM1
PACKUSWB XMM1,XMM1
MOVD dword ptr [R13],XMM1
INC R14
ADD R13,-0x4
JMP 0x001506c7
LAB_00150754:
LEA RAX,[0x1dd210]
CMP dword ptr [RAX],0x0
JS 0x0015077f
CALL 0x001837e2
LEA RDX,[0x19be72]
PUSH 0x4
POP RSI
MOV RDI,RAX
MOV ECX,R15D
MOV R8D,R14D
XOR EAX,EAX
CALL 0x0018387a
LAB_0015077f:
CMP R14,R12
SETNC AL
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* parse_cpu_mask(std::__cxx11::string const&, bool (&) [512]) */
bool parse_cpu_mask(string *param_1,bool *param_2)
{
ulong uVar1;
char cVar2;
char cVar3;
short sVar6;
short sVar7;
short sVar8;
bool bVar9;
ulong uVar10;
char *pcVar11;
int8 uVar12;
bool *pbVar13;
ulong uVar14;
byte bVar15;
int1 uVar19;
int1 auVar16 [16];
short sVar21;
int1 auVar24 [16];
int1 auVar25 [16];
int1 auVar26 [16];
string local_50 [32];
char cVar4;
char cVar5;
int1 auVar17 [16];
int1 auVar18 [16];
int2 uVar20;
int4 uVar22;
int6 uVar23;
uVar10 = *(ulong *)(param_1 + 8);
if (uVar10 < 2) {
uVar14 = 0;
}
else {
std::__cxx11::string::substr((ulong)local_50,(ulong)param_1);
bVar9 = std::operator==(local_50,"0x");
std::__cxx11::string::~string(local_50);
uVar14 = (ulong)((uint)bVar9 * 2);
uVar10 = *(ulong *)(param_1 + 8);
}
uVar10 = uVar10 - uVar14;
if (0x7f < uVar10) {
uVar10 = 0x80;
}
uVar1 = uVar10 + uVar14;
pbVar13 = param_2 + (uVar10 & 0xffffffff) * 4;
do {
pbVar13 = pbVar13 + -4;
if (uVar1 <= uVar14) {
LAB_0015077f:
return uVar1 <= uVar14;
}
pcVar11 = (char *)std::__cxx11::string::at((ulong)param_1);
cVar2 = *pcVar11;
bVar15 = cVar2 - 0x30;
if (9 < bVar15) {
if ((byte)(cVar2 + 0x9fU) < 6) {
bVar15 = cVar2 + 0xa9;
}
else {
if (5 < (byte)(cVar2 + 0xbfU)) {
if (-1 < common_log_verbosity_thold) {
uVar12 = common_log_main();
common_log_add(uVar12,4,"Invalid hex character \'%c\' at position %d\n",(int)cVar2,
uVar14 & 0xffffffff);
}
goto LAB_0015077f;
}
bVar15 = cVar2 - 0x37;
}
}
uVar22 = *(int4 *)pbVar13;
uVar19 = (int1)((uint)uVar22 >> 0x18);
uVar20 = CONCAT11(uVar19,uVar19);
uVar19 = (int1)((uint)uVar22 >> 0x10);
uVar12 = CONCAT35(CONCAT21(uVar20,uVar19),CONCAT14(uVar19,uVar22));
uVar19 = (int1)((uint)uVar22 >> 8);
uVar23 = CONCAT51(CONCAT41((int)((ulong)uVar12 >> 0x20),uVar19),uVar19);
auVar26._0_2_ = CONCAT11((char)uVar22,(char)uVar22);
uVar10 = CONCAT62(uVar23,auVar26._0_2_);
auVar18._8_4_ = 0;
auVar18._0_8_ = uVar10;
auVar18._12_2_ = uVar20;
auVar18._14_2_ = uVar20;
uVar20 = (int2)((ulong)uVar12 >> 0x20);
auVar17._12_4_ = auVar18._12_4_;
auVar17._8_2_ = 0;
auVar17._0_8_ = uVar10;
auVar17._10_2_ = uVar20;
auVar16._10_6_ = auVar17._10_6_;
auVar16._8_2_ = uVar20;
auVar16._0_8_ = uVar10;
uVar20 = (int2)uVar23;
auVar26._8_8_ = auVar16._8_8_;
auVar26._6_2_ = uVar20;
auVar26._4_2_ = uVar20;
auVar26._2_2_ = auVar26._0_2_;
auVar24._1_3_ = 0;
auVar24[0] = bVar15;
auVar24[4] = bVar15;
auVar24._5_3_ = 0;
auVar24[8] = bVar15;
auVar24._9_3_ = 0;
auVar24[0xc] = bVar15;
auVar24._13_3_ = 0;
auVar24 = auVar24 & _DAT_0019bbc0;
auVar25._0_4_ = -(uint)(auVar24._0_4_ == SUB164(_DAT_0019bbc0,0));
auVar25._4_4_ = -(uint)(auVar24._4_4_ == SUB164(_DAT_0019bbc0,4));
auVar25._8_4_ = -(uint)(auVar24._8_4_ == SUB164(_DAT_0019bbc0,8));
auVar25._12_4_ = -(uint)(auVar24._12_4_ == SUB164(_DAT_0019bbc0,0xc));
auVar26 = (auVar25 | auVar26) & _DAT_0019bbd0;
sVar6 = auVar26._0_2_;
cVar2 = (0 < sVar6) * (sVar6 < 0x100) * auVar26[0] - (0xff < sVar6);
sVar6 = auVar26._2_2_;
sVar21 = CONCAT11((0 < sVar6) * (sVar6 < 0x100) * auVar26[2] - (0xff < sVar6),cVar2);
sVar6 = auVar26._4_2_;
cVar3 = (0 < sVar6) * (sVar6 < 0x100) * auVar26[4] - (0xff < sVar6);
sVar6 = auVar26._6_2_;
uVar22 = CONCAT13((0 < sVar6) * (sVar6 < 0x100) * auVar26[6] - (0xff < sVar6),
CONCAT12(cVar3,sVar21));
sVar6 = auVar26._8_2_;
cVar4 = (0 < sVar6) * (sVar6 < 0x100) * auVar26[8] - (0xff < sVar6);
sVar6 = auVar26._10_2_;
uVar23 = CONCAT15((0 < sVar6) * (sVar6 < 0x100) * auVar26[10] - (0xff < sVar6),
CONCAT14(cVar4,uVar22));
sVar6 = auVar26._12_2_;
cVar5 = (0 < sVar6) * (sVar6 < 0x100) * auVar26[0xc] - (0xff < sVar6);
sVar8 = auVar26._14_2_;
sVar6 = (short)((uint)uVar22 >> 0x10);
sVar7 = (short)((uint6)uVar23 >> 0x20);
sVar8 = (short)(CONCAT17((0 < sVar8) * (sVar8 < 0x100) * auVar26[0xe] - (0xff < sVar8),
CONCAT16(cVar5,uVar23)) >> 0x30);
*(uint *)pbVar13 =
CONCAT13((0 < sVar8) * (sVar8 < 0x100) * cVar5 - (0xff < sVar8),
CONCAT12((0 < sVar7) * (sVar7 < 0x100) * cVar4 - (0xff < sVar7),
CONCAT11((0 < sVar6) * (sVar6 < 0x100) * cVar3 - (0xff < sVar6),
(0 < sVar21) * (sVar21 < 0x100) * cVar2 - (0xff < sVar21))));
uVar14 = uVar14 + 1;
} while( true );
}
| |
41,226 | ftxui::(anonymous namespace)::Reset[abi:cxx11](std::vector<ftxui::(anonymous namespace)::DECMode, std::allocator<ftxui::(anonymous namespace)::DECMode>> const&) | Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/component/screen_interactive.cpp | std::string Reset(const std::vector<DECMode>& parameters) {
return CSI + "?" + Serialize(parameters) + "l";
} | O1 | cpp | ftxui::(anonymous namespace)::Reset[abi:cxx11](std::vector<ftxui::(anonymous namespace)::DECMode, std::allocator<ftxui::(anonymous namespace)::DECMode>> const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x2a7f3(%rip), %rsi # 0x5b2a0
movq 0x2a7f4(%rip), %rdx # 0x5b2a8
addq %rsi, %rdx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x11e4e
leaq 0xf3ae(%rip), %rsi # 0x3fe79
movq %r15, %rdi
callq 0xb7f0
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x307e6
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x50(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r12, %rcx
je 0x30b02
movq 0x38(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x30b21
leaq 0x58(%rsp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x30b1c
movq 0x58(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x30b32
movq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0xb110
jmp 0x30b40
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb470
leaq 0x18(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x30b64
movq %rsi, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x30b6a
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0xf2e2(%rip), %rsi # 0x3fe70
leaq 0x8(%rsp), %rdi
callq 0xb7f0
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x30bba
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x30bc0
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x30bf2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb400
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x30c0d
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xb400
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x30c24
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb400
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x30c56
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb400
jmp 0x30c56
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x30c78
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xb400
jmp 0x30c78
jmp 0x30c75
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x30c8f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb400
movq %rbx, %rdi
callq 0xb780
nop
| _ZN5ftxui12_GLOBAL__N_15ResetB5cxx11ERKSt6vectorINS0_7DECModeESaIS2_EE:
push r15
push r14
push r12
push rbx
sub rsp, 68h
mov r14, rsi
mov rbx, rdi
lea r12, [rsp+88h+var_50]
mov [r12-10h], r12
mov rsi, cs:_ZN5ftxui12_GLOBAL__N_13CSIB5cxx11E; ftxui::`anonymous namespace'::CSI
mov rdx, cs:qword_5B2A8
add rdx, rsi
lea r15, [rsp+88h+var_60]
mov rdi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rsi, asc_3FE79; "?"
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rdi, [rsp+88h+var_40]; int
mov rsi, r14; int
call _ZN5ftxui12_GLOBAL__N_19SerializeB5cxx11ERKSt6vectorINS0_7DECModeESaIS2_EE; ftxui::`anonymous namespace'::Serialize(std::vector<ftxui::`anonymous namespace'::DECMode> const&)
mov rcx, [rsp+88h+var_60]
mov r8, [rsp+88h+var_58]
mov rdx, [rsp+88h+var_38]
lea rax, [rdx+r8]
mov esi, 0Fh
cmp rcx, r12
jz short loc_30B02
mov rsi, [rsp+88h+var_50]
loc_30B02:
cmp rax, rsi
jbe short loc_30B21
lea rdi, [rsp+88h+var_30]
mov esi, 0Fh
cmp [rdi-10h], rdi
jz short loc_30B1C
mov rsi, [rsp+88h+var_30]
loc_30B1C:
cmp rax, rsi
jbe short loc_30B32
loc_30B21:
mov rsi, qword ptr [rsp+88h+var_40]
lea rdi, [rsp+88h+var_60]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
jmp short loc_30B40
loc_30B32:
lea rdi, [rsp+88h+var_40]
xor esi, esi
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
loc_30B40:
lea rdx, [rsp+88h+var_70]
mov [rdx-10h], rdx
mov rsi, [rax]
lea rcx, [rax+10h]
cmp rsi, rcx
jz short loc_30B64
mov [rsp+88h+var_80], rsi
mov rdx, [rcx]
mov [rsp+88h+var_70], rdx
jmp short loc_30B6A
loc_30B64:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rdx], xmm0
loc_30B6A:
mov rdx, rax
add rdx, 8
mov rsi, [rax+8]
mov [rsp+88h+var_78], rsi
mov [rax], rcx
mov qword ptr [rdx], 0
mov byte ptr [rcx], 0
lea rsi, a25l+5; "l"
lea rdi, [rsp+88h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rdx, [rbx+10h]
mov [rbx], rdx
mov rsi, [rax]
mov rcx, rax
add rcx, 10h
cmp rsi, rcx
jz short loc_30BBA
mov [rbx], rsi
mov rdx, [rcx]
mov [rbx+10h], rdx
jmp short loc_30BC0
loc_30BBA:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rdx], xmm0
loc_30BC0:
mov rdx, [rax+8]
mov [rbx+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
lea rax, [rsp+88h+var_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_30BF2
mov rsi, [rsp+88h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_30BF2:
lea rax, [rsp+88h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_30C0D
mov rsi, [rsp+88h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_30C0D:
mov rdi, [rsp+88h+var_60]; void *
cmp rdi, r12
jz short loc_30C24
mov rsi, [rsp+88h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_30C24:
mov rax, rbx
add rsp, 68h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_30C56
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_30C56
mov rbx, rax
loc_30C56:
lea rax, [rsp+arg_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_30C78
mov rsi, [rsp+arg_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_30C78
jmp short $+2
loc_30C75:
mov rbx, rax
loc_30C78:
mov rdi, [rsp+arg_20]; void *
cmp rdi, r12
jz short loc_30C8F
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_30C8F:
mov rdi, rbx
call __Unwind_Resume
| long long ftxui::`anonymous namespace'::Reset[abi:cxx11](long long a1, int **a2)
{
char *v2; // rax
unsigned long long v3; // rsi
unsigned long long v4; // rsi
void **v5; // rax
__int128 *v6; // rcx
long long v7; // rax
_OWORD *v8; // rcx
void *v10[2]; // [rsp+8h] [rbp-80h] BYREF
__int128 v11; // [rsp+18h] [rbp-70h] BYREF
void *v12[2]; // [rsp+28h] [rbp-60h] BYREF
_QWORD v13[2]; // [rsp+38h] [rbp-50h] BYREF
int v14[2]; // [rsp+48h] [rbp-40h] BYREF
long long v15; // [rsp+50h] [rbp-38h]
_QWORD v16[6]; // [rsp+58h] [rbp-30h] BYREF
v12[0] = v13;
std::string::_M_construct<char *>(
v12,
(_BYTE *)ftxui::`anonymous namespace'::CSI[abi:cxx11],
ftxui::`anonymous namespace'::CSI[abi:cxx11] + qword_5B2A8);
std::string::append(v12, "?");
ftxui::`anonymous namespace'::Serialize[abi:cxx11]((long long)v14, a2);
v2 = (char *)v12[1] + v15;
v3 = 15LL;
if ( v12[0] != v13 )
v3 = v13[0];
if ( (unsigned long long)v2 <= v3 )
goto LABEL_7;
v4 = 15LL;
if ( *(_QWORD **)v14 != v16 )
v4 = v16[0];
if ( (unsigned long long)v2 <= v4 )
v5 = (void **)std::string::replace(v14, 0LL, 0LL);
else
LABEL_7:
v5 = (void **)std::string::_M_append(v12, *(_QWORD *)v14, v15);
v10[0] = &v11;
v6 = (__int128 *)(v5 + 2);
if ( *v5 == v5 + 2 )
{
v11 = *v6;
}
else
{
v10[0] = *v5;
*(_QWORD *)&v11 = *(_QWORD *)v6;
}
v10[1] = v5[1];
*v5 = v6;
v5[1] = 0LL;
*(_BYTE *)v6 = 0;
v7 = std::string::append(v10, "l");
*(_QWORD *)a1 = a1 + 16;
v8 = (_OWORD *)(v7 + 16);
if ( *(_QWORD *)v7 == v7 + 16 )
{
*(_OWORD *)(a1 + 16) = *v8;
}
else
{
*(_QWORD *)a1 = *(_QWORD *)v7;
*(_QWORD *)(a1 + 16) = *(_QWORD *)v8;
}
*(_QWORD *)(a1 + 8) = *(_QWORD *)(v7 + 8);
*(_QWORD *)v7 = v8;
*(_QWORD *)(v7 + 8) = 0LL;
*(_BYTE *)(v7 + 16) = 0;
if ( v10[0] != &v11 )
operator delete(v10[0], v11 + 1);
if ( *(_QWORD **)v14 != v16 )
operator delete(*(void **)v14, v16[0] + 1LL);
if ( v12[0] != v13 )
operator delete(v12[0], v13[0] + 1LL);
return a1;
}
| Reset[abi:cxx11]:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R14,RSI
MOV RBX,RDI
LEA R12,[RSP + 0x38]
MOV qword ptr [R12 + -0x10],R12
MOV RSI,qword ptr [0x0015b2a0]
MOV RDX,qword ptr [0x0015b2a8]
ADD RDX,RSI
LEA R15,[RSP + 0x28]
MOV RDI,R15
CALL 0x00111e4e
LAB_00130ac4:
LEA RSI,[0x13fe79]
MOV RDI,R15
CALL 0x0010b7f0
LAB_00130ad3:
LEA RDI,[RSP + 0x48]
MOV RSI,R14
CALL 0x001307e6
MOV RCX,qword ptr [RSP + 0x28]
MOV R8,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x50]
LEA RAX,[RDX + R8*0x1]
MOV ESI,0xf
CMP RCX,R12
JZ 0x00130b02
MOV RSI,qword ptr [RSP + 0x38]
LAB_00130b02:
CMP RAX,RSI
JBE 0x00130b21
LEA RDI,[RSP + 0x58]
MOV ESI,0xf
CMP qword ptr [RDI + -0x10],RDI
JZ 0x00130b1c
MOV RSI,qword ptr [RSP + 0x58]
LAB_00130b1c:
CMP RAX,RSI
JBE 0x00130b32
LAB_00130b21:
MOV RSI,qword ptr [RSP + 0x48]
LAB_00130b26:
LEA RDI,[RSP + 0x28]
CALL 0x0010b110
JMP 0x00130b40
LAB_00130b32:
LEA RDI,[RSP + 0x48]
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0010b470
LAB_00130b40:
LEA RDX,[RSP + 0x18]
MOV qword ptr [RDX + -0x10],RDX
MOV RSI,qword ptr [RAX]
LEA RCX,[RAX + 0x10]
CMP RSI,RCX
JZ 0x00130b64
MOV qword ptr [RSP + 0x8],RSI
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x18],RDX
JMP 0x00130b6a
LAB_00130b64:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RDX],XMM0
LAB_00130b6a:
MOV RDX,RAX
ADD RDX,0x8
MOV RSI,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RAX],RCX
MOV qword ptr [RDX],0x0
MOV byte ptr [RCX],0x0
LAB_00130b87:
LEA RSI,[0x13fe70]
LEA RDI,[RSP + 0x8]
CALL 0x0010b7f0
LAB_00130b98:
LEA RDX,[RBX + 0x10]
MOV qword ptr [RBX],RDX
MOV RSI,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RSI,RCX
JZ 0x00130bba
MOV qword ptr [RBX],RSI
MOV RDX,qword ptr [RCX]
MOV qword ptr [RBX + 0x10],RDX
JMP 0x00130bc0
LAB_00130bba:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RDX],XMM0
LAB_00130bc0:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00130bf2
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0010b400
LAB_00130bf2:
LEA RAX,[RSP + 0x58]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00130c0d
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x0010b400
LAB_00130c0d:
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R12
JZ 0x00130c24
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0010b400
LAB_00130c24:
MOV RAX,RBX
ADD RSP,0x68
POP RBX
POP R12
POP R14
POP R15
RET
|
/* ftxui::(anonymous namespace)::Reset[abi:cxx11](std::vector<ftxui::(anonymous namespace)::DECMode,
std::allocator<ftxui::(anonymous namespace)::DECMode> > const&) */
_anonymous_namespace_ * __thiscall
ftxui::(anonymous_namespace)::Reset_abi_cxx11_(_anonymous_namespace_ *this,vector *param_1)
{
long lVar1;
int8 *puVar2;
long *plVar3;
long *plVar4;
ulong uVar5;
long *local_80;
int8 local_78;
long local_70;
int8 uStack_68;
ulong *local_60;
long local_58;
ulong local_50 [2];
ulong *local_40;
long local_38;
ulong local_30 [2];
local_60 = local_50;
std::__cxx11::string::_M_construct<char*>(&local_60,CSI_abi_cxx11_,DAT_0015b2a8 + CSI_abi_cxx11_);
/* try { // try from 00130ac4 to 00130ad2 has its CatchHandler @ 00130c75 */
std::__cxx11::string::append((char *)&local_60);
/* try { // try from 00130ad3 to 00130adf has its CatchHandler @ 00130c73 */
Serialize_abi_cxx11_((_anonymous_namespace_ *)&local_40,param_1);
uVar5 = 0xf;
if (local_60 != local_50) {
uVar5 = local_50[0];
}
if (uVar5 < (ulong)(local_38 + local_58)) {
uVar5 = 0xf;
if (local_40 != local_30) {
uVar5 = local_30[0];
}
if ((ulong)(local_38 + local_58) <= uVar5) {
puVar2 = (int8 *)
std::__cxx11::string::replace((ulong)&local_40,0,(char *)0x0,(ulong)local_60);
goto LAB_00130b40;
}
}
/* try { // try from 00130b26 to 00130b3f has its CatchHandler @ 00130c53 */
puVar2 = (int8 *)std::__cxx11::string::_M_append((char *)&local_60,(ulong)local_40);
LAB_00130b40:
local_80 = &local_70;
plVar3 = puVar2 + 2;
if ((long *)*puVar2 == plVar3) {
local_70 = *plVar3;
uStack_68 = puVar2[3];
}
else {
local_70 = *plVar3;
local_80 = (long *)*puVar2;
}
local_78 = puVar2[1];
*puVar2 = plVar3;
puVar2[1] = 0;
*(int1 *)plVar3 = 0;
/* try { // try from 00130b87 to 00130b97 has its CatchHandler @ 00130c33 */
plVar3 = (long *)std::__cxx11::string::append((char *)&local_80);
*(_anonymous_namespace_ **)this = this + 0x10;
plVar4 = plVar3 + 2;
if ((long *)*plVar3 == plVar4) {
lVar1 = plVar3[3];
*(long *)(this + 0x10) = *plVar4;
*(long *)(this + 0x18) = lVar1;
}
else {
*(long **)this = (long *)*plVar3;
*(long *)(this + 0x10) = *plVar4;
}
*(long *)(this + 8) = plVar3[1];
*plVar3 = (long)plVar4;
plVar3[1] = 0;
*(int1 *)(plVar3 + 2) = 0;
if (local_80 != &local_70) {
operator_delete(local_80,local_70 + 1);
}
if (local_40 != local_30) {
operator_delete(local_40,local_30[0] + 1);
}
if (local_60 != local_50) {
operator_delete(local_60,local_50[0] + 1);
}
return this;
}
| |
41,227 | stbi_info_from_file | monkey531[P]llama/examples/llava/../../common/stb_image.h | STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)
{
int r;
stbi__context s;
long pos = ftell(f);
stbi__start_file(&s, f);
r = stbi__info_main(&s,x,y,comp);
fseek(f,pos,SEEK_SET);
return r;
} | O2 | c | stbi_info_from_file:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x28050
movq %rax, %r13
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x2e07b
movq %rbp, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2f692
movl %eax, %ebx
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x2a1a0
movl %ebx, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| stbi_info_from_file:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0E8h
mov rbx, rcx
mov r14, rdx
mov r15, rsi
mov r12, rdi
call _ftell
mov r13, rax
lea rbp, [rsp+118h+var_110]
mov rdi, rbp
mov rsi, r12
call _ZL16stbi__start_fileP13stbi__contextP8_IO_FILE; stbi__start_file(stbi__context *,_IO_FILE *)
mov rdi, rbp
mov rsi, r15
mov rdx, r14
mov rcx, rbx
call _ZL15stbi__info_mainP13stbi__contextPiS1_S1_; stbi__info_main(stbi__context *,int *,int *,int *)
mov ebx, eax
mov rdi, r12
mov rsi, r13
xor edx, edx
call _fseek
mov eax, ebx
add rsp, 0E8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long stbi_info_from_file(long long a1, long long a2, long long a3, long long a4)
{
long long v6; // r13
_BYTE v8[272]; // [rsp+8h] [rbp-110h] BYREF
v6 = ftell(a1);
stbi__start_file((long long)v8, a1);
LODWORD(a4) = stbi__info_main(v8, a2, a3, a4);
fseek(a1, v6, 0LL);
return (unsigned int)a4;
}
| stbi_info_from_file:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xe8
MOV RBX,RCX
MOV R14,RDX
MOV R15,RSI
MOV R12,RDI
CALL 0x00128050
MOV R13,RAX
LEA RBP,[RSP + 0x8]
MOV RDI,RBP
MOV RSI,R12
CALL 0x0012e07b
MOV RDI,RBP
MOV RSI,R15
MOV RDX,R14
MOV RCX,RBX
CALL 0x0012f692
MOV EBX,EAX
MOV RDI,R12
MOV RSI,R13
XOR EDX,EDX
CALL 0x0012a1a0
MOV EAX,EBX
ADD RSP,0xe8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int4 stbi_info_from_file(FILE *param_1,int *param_2,int *param_3,int *param_4)
{
int4 uVar1;
long __off;
stbi__context local_110 [224];
__off = ftell(param_1);
stbi__start_file(local_110,param_1);
uVar1 = stbi__info_main(local_110,param_2,param_3,param_4);
fseek(param_1,__off,0);
return uVar1;
}
| |
41,228 | evmone::ExecutionState::ExecutionState() | corpus-core[P]colibri-stateless/build_O2/_deps/evmone_external-src/lib/evmone/execution_state.hpp | ExecutionState() noexcept = default; | O2 | cpp | evmone::ExecutionState::ExecutionState():
pushq %rbx
movq %rdi, %rbx
andq $0x0, (%rdi)
addq $0x8, %rdi
callq 0x2f9de
andq $0x0, 0x20(%rbx)
leaq 0x79851(%rip), %rax # 0xa91c0
movq %rax, 0x28(%rbx)
leaq 0x58(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
andl $0x0, 0x40(%rbx)
movq %rax, 0x48(%rbx)
andq $0x0, 0x50(%rbx)
xorl %eax, %eax
movb %al, 0x58(%rbx)
movb %al, 0xb0(%rbx)
leaq 0xb8(%rbx), %rdi
movb %al, 0x1f0(%rbx)
movups %xmm0, 0x68(%rbx)
andl $0x0, 0x78(%rbx)
movups %xmm0, 0x80(%rbx)
movl $0x100, %edx # imm = 0x100
xorl %esi, %esi
callq 0x221a0
xorps %xmm0, %xmm0
movups %xmm0, 0x1f8(%rbx)
movups %xmm0, 0x208(%rbx)
callq 0x2fa2c
movq %rax, 0x218(%rbx)
popq %rbx
retq
nop
| _ZN6evmone14ExecutionStateC2Ev:
push rbx
mov rbx, rdi
and qword ptr [rdi], 0
add rdi, 8; this
call _ZN6evmone6MemoryC2Ev; evmone::Memory::Memory(void)
and qword ptr [rbx+20h], 0
lea rax, off_A91C0
mov [rbx+28h], rax
lea rax, [rbx+58h]
xorps xmm0, xmm0
movups xmmword ptr [rbx+30h], xmm0
and dword ptr [rbx+40h], 0
mov [rbx+48h], rax
and qword ptr [rbx+50h], 0
xor eax, eax
mov [rbx+58h], al
mov [rbx+0B0h], al
lea rdi, [rbx+0B8h]; this
mov [rbx+1F0h], al
movups xmmword ptr [rbx+68h], xmm0
and dword ptr [rbx+78h], 0
movups xmmword ptr [rbx+80h], xmm0
mov edx, 100h
xor esi, esi
call _memset
xorps xmm0, xmm0
movups xmmword ptr [rbx+1F8h], xmm0
movups xmmword ptr [rbx+208h], xmm0
call _ZN6evmone10StackSpace8allocateEv; evmone::StackSpace::allocate(void)
mov [rbx+218h], rax
pop rbx
retn
| long long evmone::ExecutionState::ExecutionState(evmone::ExecutionState *this)
{
long long result; // rax
*(_QWORD *)this = 0LL;
evmone::Memory::Memory((evmone::ExecutionState *)((char *)this + 8));
*((_QWORD *)this + 4) = 0LL;
*((_QWORD *)this + 5) = off_A91C0;
*((_OWORD *)this + 3) = 0LL;
*((_DWORD *)this + 16) = 0;
*((_QWORD *)this + 9) = (char *)this + 88;
*((_QWORD *)this + 10) = 0LL;
*((_BYTE *)this + 88) = 0;
*((_BYTE *)this + 176) = 0;
*((_BYTE *)this + 496) = 0;
*(_OWORD *)((char *)this + 104) = 0LL;
*((_DWORD *)this + 30) = 0;
*((_OWORD *)this + 8) = 0LL;
memset((char *)this + 184, 0LL, 256LL);
*(_OWORD *)((char *)this + 504) = 0LL;
*(_OWORD *)((char *)this + 520) = 0LL;
result = evmone::StackSpace::allocate((evmone::ExecutionState *)((char *)this + 184));
*((_QWORD *)this + 67) = result;
return result;
}
| ExecutionState:
PUSH RBX
MOV RBX,RDI
AND qword ptr [RDI],0x0
ADD RDI,0x8
CALL 0x0012f9de
AND qword ptr [RBX + 0x20],0x0
LEA RAX,[0x1a91c0]
MOV qword ptr [RBX + 0x28],RAX
LEA RAX,[RBX + 0x58]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
AND dword ptr [RBX + 0x40],0x0
MOV qword ptr [RBX + 0x48],RAX
AND qword ptr [RBX + 0x50],0x0
XOR EAX,EAX
MOV byte ptr [RBX + 0x58],AL
MOV byte ptr [RBX + 0xb0],AL
LEA RDI,[RBX + 0xb8]
MOV byte ptr [RBX + 0x1f0],AL
MOVUPS xmmword ptr [RBX + 0x68],XMM0
AND dword ptr [RBX + 0x78],0x0
MOVUPS xmmword ptr [RBX + 0x80],XMM0
MOV EDX,0x100
XOR ESI,ESI
CALL 0x001221a0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x1f8],XMM0
MOVUPS xmmword ptr [RBX + 0x208],XMM0
CALL 0x0012fa2c
MOV qword ptr [RBX + 0x218],RAX
POP RBX
RET
|
/* evmone::ExecutionState::ExecutionState() */
void __thiscall evmone::ExecutionState::ExecutionState(ExecutionState *this)
{
int8 uVar1;
*(int8 *)this = 0;
Memory::Memory((Memory *)(this + 8));
*(int8 *)(this + 0x20) = 0;
*(int ***)(this + 0x28) = &PTR__HostInterface_001a91c0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int4 *)(this + 0x40) = 0;
*(ExecutionState **)(this + 0x48) = this + 0x58;
*(int8 *)(this + 0x50) = 0;
this[0x58] = (ExecutionState)0x0;
this[0xb0] = (ExecutionState)0x0;
this[0x1f0] = (ExecutionState)0x0;
*(int8 *)(this + 0x68) = 0;
*(int8 *)(this + 0x70) = 0;
*(int4 *)(this + 0x78) = 0;
*(int8 *)(this + 0x80) = 0;
*(int8 *)(this + 0x88) = 0;
memset(this + 0xb8,0,0x100);
*(int8 *)(this + 0x1f8) = 0;
*(int8 *)(this + 0x200) = 0;
*(int8 *)(this + 0x208) = 0;
*(int8 *)(this + 0x210) = 0;
uVar1 = StackSpace::allocate();
*(int8 *)(this + 0x218) = uVar1;
return;
}
| |
41,229 | my_sync_dir | eloqsql/mysys/my_sync.c | int my_sync_dir(const char *dir_name __attribute__((unused)),
myf my_flags __attribute__((unused)))
{
#ifdef NEED_EXPLICIT_SYNC_DIR
static const char cur_dir_name[]= {FN_CURLIB, 0};
File dir_fd;
int res= 0;
const char *correct_dir_name;
DBUG_ENTER("my_sync_dir");
DBUG_PRINT("my",("Dir: '%s' my_flags: %lu", dir_name, my_flags));
/* Sometimes the path does not contain an explicit directory */
correct_dir_name= (dir_name[0] == 0) ? cur_dir_name : dir_name;
/*
Syncing a dir may give EINVAL on tmpfs on Linux, which is ok.
EIO on the other hand is very important. Hence MY_IGNORE_BADFD.
*/
if ((dir_fd= my_open(correct_dir_name, O_RDONLY, MYF(my_flags))) >= 0)
{
if (my_sync(dir_fd, MYF(my_flags | MY_IGNORE_BADFD)))
res= 2;
if (my_close(dir_fd, MYF(my_flags)))
res= 3;
}
else
res= 1;
DBUG_RETURN(res);
#else
return 0;
#endif
} | O3 | c | my_sync_dir:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, (%rdi)
movq %rsi, %rbx
leaq 0x4085c(%rip), %rax # 0xe1e48
cmoveq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0xa03e0
testl %eax, %eax
js 0xa1633
movl %eax, %r14d
movq %rbx, %rsi
orq $0x20, %rsi
movl %eax, %edi
callq 0xa14a4
xorl %r15d, %r15d
testl %eax, %eax
setne %r15b
addl %r15d, %r15d
movl %r14d, %edi
movq %rbx, %rsi
callq 0xa0585
testl %eax, %eax
movl $0x3, %eax
cmovel %r15d, %eax
jmp 0xa1638
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| my_sync_dir:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
cmp byte ptr [rdi], 0
mov rbx, rsi
lea rax, my_sync_dir_cur_dir_name
cmovz rdi, rax
xor esi, esi
mov rdx, rbx
call my_open
test eax, eax
js short loc_A1633
mov r14d, eax
mov rsi, rbx
or rsi, 20h
mov edi, eax
call my_sync
xor r15d, r15d
test eax, eax
setnz r15b
add r15d, r15d
mov edi, r14d
mov rsi, rbx
call my_close
test eax, eax
mov eax, 3
cmovz eax, r15d
jmp short loc_A1638
loc_A1633:
mov eax, 1
loc_A1638:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long my_sync_dir(_BYTE *a1, long long a2)
{
int v2; // eax
unsigned int v3; // r14d
unsigned int v4; // r15d
bool v5; // zf
long long result; // rax
if ( !*a1 )
a1 = &my_sync_dir_cur_dir_name;
v2 = my_open((long long)a1, 0, a2);
if ( v2 < 0 )
return 1LL;
v3 = v2;
v4 = 2 * ((unsigned int)my_sync((unsigned int)v2, (const char *)(a2 | 0x20)) != 0);
v5 = (unsigned int)my_close(v3, (const char *)a2) == 0;
result = 3LL;
if ( v5 )
return v4;
return result;
}
| my_sync_dir:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
CMP byte ptr [RDI],0x0
MOV RBX,RSI
LEA RAX,[0x1e1e48]
CMOVZ RDI,RAX
XOR ESI,ESI
MOV RDX,RBX
CALL 0x001a03e0
TEST EAX,EAX
JS 0x001a1633
MOV R14D,EAX
MOV RSI,RBX
OR RSI,0x20
MOV EDI,EAX
CALL 0x001a14a4
XOR R15D,R15D
TEST EAX,EAX
SETNZ R15B
ADD R15D,R15D
MOV EDI,R14D
MOV RSI,RBX
CALL 0x001a0585
TEST EAX,EAX
MOV EAX,0x3
CMOVZ EAX,R15D
JMP 0x001a1638
LAB_001a1633:
MOV EAX,0x1
LAB_001a1638:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
char my_sync_dir(char *param_1,ulong param_2)
{
char cVar1;
int iVar2;
int iVar3;
if (*param_1 == '\0') {
param_1 = ".";
}
iVar2 = my_open(param_1,0,param_2);
if (iVar2 < 0) {
cVar1 = '\x01';
}
else {
iVar3 = my_sync(iVar2,param_2 | 0x20);
iVar2 = my_close(iVar2,param_2);
cVar1 = '\x03';
if (iVar2 == 0) {
cVar1 = (iVar3 != 0) * '\x02';
}
}
return cVar1;
}
| |
41,230 | PVG_FT_Angle_Diff | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-ft-math.c | PVG_FT_Angle PVG_FT_Angle_Diff( PVG_FT_Angle angle1, PVG_FT_Angle angle2 )
{
PVG_FT_Angle delta = angle2 - angle1;
while ( delta <= -PVG_FT_ANGLE_PI )
delta += PVG_FT_ANGLE_2PI;
while ( delta > PVG_FT_ANGLE_PI )
delta -= PVG_FT_ANGLE_2PI;
return delta;
} | O0 | c | PVG_FT_Angle_Diff:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
subq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $-0xb40000, -0x18(%rbp) # imm = 0xFF4C0000
jg 0x8b5e2
movq -0x18(%rbp), %rax
addq $0x1680000, %rax # imm = 0x1680000
movq %rax, -0x18(%rbp)
jmp 0x8b5c8
jmp 0x8b5e4
cmpq $0xb40000, -0x18(%rbp) # imm = 0xB40000
jle 0x8b5fe
movq -0x18(%rbp), %rax
subq $0x1680000, %rax # imm = 0x1680000
movq %rax, -0x18(%rbp)
jmp 0x8b5e4
movq -0x18(%rbp), %rax
popq %rbp
retq
| PVG_FT_Angle_Diff:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
sub rax, [rbp+var_8]
mov [rbp+var_18], rax
loc_8B5C8:
cmp [rbp+var_18], 0FFFFFFFFFF4C0000h
jg short loc_8B5E2
mov rax, [rbp+var_18]
add rax, 1680000h
mov [rbp+var_18], rax
jmp short loc_8B5C8
loc_8B5E2:
jmp short $+2
loc_8B5E4:
cmp [rbp+var_18], 0B40000h
jle short loc_8B5FE
mov rax, [rbp+var_18]
sub rax, 1680000h
mov [rbp+var_18], rax
jmp short loc_8B5E4
loc_8B5FE:
mov rax, [rbp+var_18]
pop rbp
retn
| long long PVG_FT_Angle_Diff(long long a1, long long a2)
{
long long i; // [rsp+0h] [rbp-18h]
for ( i = a2 - a1; i <= -11796480; i += 23592960LL )
;
while ( i > 11796480 )
i -= 23592960LL;
return i;
}
| PVG_FT_Angle_Diff:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
SUB RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
LAB_0018b5c8:
CMP qword ptr [RBP + -0x18],-0xb40000
JG 0x0018b5e2
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1680000
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0018b5c8
LAB_0018b5e2:
JMP 0x0018b5e4
LAB_0018b5e4:
CMP qword ptr [RBP + -0x18],0xb40000
JLE 0x0018b5fe
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,0x1680000
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0018b5e4
LAB_0018b5fe:
MOV RAX,qword ptr [RBP + -0x18]
POP RBP
RET
|
long PVG_FT_Angle_Diff(long param_1,long param_2)
{
int8 local_20;
for (local_20 = param_2 - param_1; local_20 < -0xb3ffff; local_20 = local_20 + 0x1680000) {
}
for (; 0xb40000 < local_20; local_20 = local_20 + -0x1680000) {
}
return local_20;
}
| |
41,231 | thr_print_lock | eloqsql/mysys/thr_lock.c | static void thr_print_lock(const char* name,struct st_lock_list *list)
{
THR_LOCK_DATA *data,**prev;
uint count=0;
if (list->data)
{
printf("%-10s: ",name);
prev= &list->data;
for (data=list->data; data && count++ < MAX_LOCKS ; data=data->next)
{
printf("%p (%lu:%d); ", data, (ulong) data->owner->thread_id,
(int) data->type);
if (data->prev != prev)
printf("\nWarning: prev didn't point at previous lock\n");
prev= &data->next;
}
puts("");
if (prev != list->last)
printf("Warning: last didn't point at last lock\n");
}
} | O0 | c | thr_print_lock:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xf9bec
movq -0x8(%rbp), %rsi
leaq 0x5abfd(%rip), %rdi # 0x15471d
movb $0x0, %al
callq 0x2a050
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x25(%rbp)
je 0xf9b5c
movl -0x24(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x24(%rbp)
cmpl $0x3e8, %eax # imm = 0x3E8
setb %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0xf9b65
jmp 0xf9bc2
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rax
movl 0x40(%rax), %ecx
leaq 0x5aba3(%rip), %rdi # 0x154725
movb $0x0, %al
callq 0x2a050
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x20(%rbp), %rax
je 0xf9ba5
leaq 0x5ab95(%rip), %rdi # 0x154733
movb $0x0, %al
callq 0x2a050
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xf9b3a
leaq 0x5e0e4(%rip), %rdi # 0x157cad
callq 0x2a790
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0xf9bea
leaq 0x5ab7e(%rip), %rdi # 0x154761
movb $0x0, %al
callq 0x2a050
jmp 0xf9bec
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| thr_print_lock:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_24], 0
mov rax, [rbp+var_10]
cmp qword ptr [rax], 0
jz loc_F9BEC
mov rsi, [rbp+var_8]
lea rdi, a10s; "%-10s: "
mov al, 0
call _printf
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_18], rax
loc_F9B3A:
xor eax, eax
cmp [rbp+var_18], 0
mov [rbp+var_25], al
jz short loc_F9B5C
mov eax, [rbp+var_24]
mov ecx, eax
add ecx, 1
mov [rbp+var_24], ecx
cmp eax, 3E8h
setb al
mov [rbp+var_25], al
loc_F9B5C:
mov al, [rbp+var_25]
test al, 1
jnz short loc_F9B65
jmp short loc_F9BC2
loc_F9B65:
mov rsi, [rbp+var_18]
mov rax, [rbp+var_18]
mov rax, [rax]
mov rdx, [rax+8]
mov rax, [rbp+var_18]
mov ecx, [rax+40h]
lea rdi, aPLuD; "%p (%lu:%d); "
mov al, 0
call _printf
mov rax, [rbp+var_18]
mov rax, [rax+10h]
cmp rax, [rbp+var_20]
jz short loc_F9BA5
lea rdi, aWarningPrevDid; "\nWarning: prev didn't point at previou"...
mov al, 0
call _printf
loc_F9BA5:
mov rax, [rbp+var_18]
add rax, 8
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rbp+var_18], rax
jmp loc_F9B3A
loc_F9BC2:
lea rdi, asc_157CA9+4; ""
call _puts
mov rax, [rbp+var_20]
mov rcx, [rbp+var_10]
cmp rax, [rcx+8]
jz short loc_F9BEA
lea rdi, aWarningLastDid; "Warning: last didn't point at last lock"...
mov al, 0
call _printf
loc_F9BEA:
jmp short $+2
loc_F9BEC:
add rsp, 30h
pop rbp
retn
| long long thr_print_lock(const char *a1, _QWORD *a2)
{
long long result; // rax
unsigned int v3; // eax
bool v4; // [rsp+Bh] [rbp-25h]
unsigned int v5; // [rsp+Ch] [rbp-24h]
_QWORD *v6; // [rsp+10h] [rbp-20h]
long long i; // [rsp+18h] [rbp-18h]
v5 = 0;
result = (long long)a2;
if ( *a2 )
{
printf("%-10s: ", a1);
v6 = a2;
for ( i = *a2; ; i = *(_QWORD *)(i + 8) )
{
v4 = 0;
if ( i )
{
v3 = v5++;
v4 = v3 < 0x3E8;
}
if ( !v4 )
break;
printf("%p (%lu:%d); ", (const void *)i, *(_QWORD *)(*(_QWORD *)i + 8LL), *(_DWORD *)(i + 64));
if ( *(_QWORD **)(i + 16) != v6 )
printf("\nWarning: prev didn't point at previous lock\n");
v6 = (_QWORD *)(i + 8);
}
puts("");
result = (long long)v6;
if ( v6 != (_QWORD *)a2[1] )
return printf("Warning: last didn't point at last lock\n");
}
return result;
}
| thr_print_lock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x24],0x0
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX],0x0
JZ 0x001f9bec
MOV RSI,qword ptr [RBP + -0x8]
LEA RDI,[0x25471d]
MOV AL,0x0
CALL 0x0012a050
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
LAB_001f9b3a:
XOR EAX,EAX
CMP qword ptr [RBP + -0x18],0x0
MOV byte ptr [RBP + -0x25],AL
JZ 0x001f9b5c
MOV EAX,dword ptr [RBP + -0x24]
MOV ECX,EAX
ADD ECX,0x1
MOV dword ptr [RBP + -0x24],ECX
CMP EAX,0x3e8
SETC AL
MOV byte ptr [RBP + -0x25],AL
LAB_001f9b5c:
MOV AL,byte ptr [RBP + -0x25]
TEST AL,0x1
JNZ 0x001f9b65
JMP 0x001f9bc2
LAB_001f9b65:
MOV RSI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX + 0x40]
LEA RDI,[0x254725]
MOV AL,0x0
CALL 0x0012a050
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x10]
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x001f9ba5
LEA RDI,[0x254733]
MOV AL,0x0
CALL 0x0012a050
LAB_001f9ba5:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x8
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001f9b3a
LAB_001f9bc2:
LEA RDI,[0x257cad]
CALL 0x0012a790
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x8]
JZ 0x001f9bea
LEA RDI,[0x254761]
MOV AL,0x0
CALL 0x0012a050
LAB_001f9bea:
JMP 0x001f9bec
LAB_001f9bec:
ADD RSP,0x30
POP RBP
RET
|
void thr_print_lock(int8 param_1,long *param_2)
{
uint uVar1;
uint local_2c;
long *local_28;
long *local_20;
local_2c = 0;
if (*param_2 != 0) {
printf("%-10s: ",param_1);
local_20 = (long *)*param_2;
local_28 = param_2;
while( true ) {
uVar1 = local_2c;
if (local_20 != (long *)0x0) {
local_2c = local_2c + 1;
}
if (local_20 == (long *)0x0 || 999 < uVar1) break;
printf("%p (%lu:%d); ",local_20,*(int8 *)(*local_20 + 8),(ulong)*(uint *)(local_20 + 8))
;
if ((long *)local_20[2] != local_28) {
printf("\nWarning: prev didn\'t point at previous lock\n");
}
local_28 = local_20 + 1;
local_20 = (long *)local_20[1];
}
puts("");
if (local_28 != (long *)param_2[1]) {
printf("Warning: last didn\'t point at last lock\n");
}
}
return;
}
| |
41,232 | my_coll_rule_parse | eloqsql/strings/ctype-uca.c | static int
my_coll_rule_parse(MY_COLL_RULES *rules,
const char *str, const char *str_end)
{
MY_COLL_RULE_PARSER p;
my_coll_parser_init(&p, rules, str, str_end);
if (!my_coll_parser_exec(&p))
{
my_coll_lexem_print_error(my_coll_parser_curr(&p),
rules->loader->error,
sizeof(rules->loader->error) - 1,
p.errstr);
return 1;
}
return 0;
} | O0 | c | my_coll_rule_parse:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x190(%rbp)
movq %rsi, -0x198(%rbp)
movq %rdx, -0x1a0(%rbp)
movq -0x190(%rbp), %rsi
movq -0x198(%rbp), %rdx
movq -0x1a0(%rbp), %rcx
leaq -0x180(%rbp), %rdi
callq 0x9e370
leaq -0x180(%rbp), %rdi
callq 0x9e420
cmpl $0x0, %eax
jne 0x9e01d
leaq -0x180(%rbp), %rdi
callq 0x9e5a0
movq %rax, %rdi
movq -0x190(%rbp), %rax
movq 0x28(%rax), %rsi
leaq -0x180(%rbp), %rcx
addq $0xf8, %rcx
movl $0x7f, %edx
callq 0x9e490
movl $0x1, -0x184(%rbp)
jmp 0x9e027
movl $0x0, -0x184(%rbp)
movl -0x184(%rbp), %eax
movl %eax, -0x1a4(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x9e054
movl -0x1a4(%rbp), %eax
addq $0x1b0, %rsp # imm = 0x1B0
popq %rbp
retq
callq 0x362a0
nopl (%rax)
| my_coll_rule_parse:
push rbp
mov rbp, rsp
sub rsp, 1B0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_190], rdi
mov [rbp+var_198], rsi
mov [rbp+var_1A0], rdx
mov rsi, [rbp+var_190]
mov rdx, [rbp+var_198]
mov rcx, [rbp+var_1A0]
lea rdi, [rbp+var_180]
call my_coll_parser_init
lea rdi, [rbp+var_180]
call my_coll_parser_exec
cmp eax, 0
jnz short loc_9E01D
lea rdi, [rbp+var_180]
call my_coll_parser_curr
mov rdi, rax
mov rax, [rbp+var_190]
mov rsi, [rax+28h]
lea rcx, [rbp+var_180]
add rcx, 0F8h
mov edx, 7Fh
call my_coll_lexem_print_error
mov [rbp+var_184], 1
jmp short loc_9E027
loc_9E01D:
mov [rbp+var_184], 0
loc_9E027:
mov eax, [rbp+var_184]
mov [rbp+var_1A4], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_9E054
mov eax, [rbp+var_1A4]
add rsp, 1B0h
pop rbp
retn
loc_9E054:
call ___stack_chk_fail
| long long my_coll_rule_parse(long long a1, long long a2, long long a3)
{
long long v3; // rax
_BYTE v6[248]; // [rsp+30h] [rbp-180h] BYREF
_QWORD v7[17]; // [rsp+128h] [rbp-88h] BYREF
v7[16] = __readfsqword(0x28u);
my_coll_parser_init(v6, a1, a2, a3);
if ( (unsigned int)my_coll_parser_exec(v6) )
{
return 0;
}
else
{
v3 = my_coll_parser_curr(v6);
my_coll_lexem_print_error(v3, *(_QWORD *)(a1 + 40), 127LL, v7);
return 1;
}
}
| my_coll_rule_parse:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1b0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x190],RDI
MOV qword ptr [RBP + -0x198],RSI
MOV qword ptr [RBP + -0x1a0],RDX
MOV RSI,qword ptr [RBP + -0x190]
MOV RDX,qword ptr [RBP + -0x198]
MOV RCX,qword ptr [RBP + -0x1a0]
LEA RDI,[RBP + -0x180]
CALL 0x0019e370
LEA RDI,[RBP + -0x180]
CALL 0x0019e420
CMP EAX,0x0
JNZ 0x0019e01d
LEA RDI,[RBP + -0x180]
CALL 0x0019e5a0
MOV RDI,RAX
MOV RAX,qword ptr [RBP + -0x190]
MOV RSI,qword ptr [RAX + 0x28]
LEA RCX,[RBP + -0x180]
ADD RCX,0xf8
MOV EDX,0x7f
CALL 0x0019e490
MOV dword ptr [RBP + -0x184],0x1
JMP 0x0019e027
LAB_0019e01d:
MOV dword ptr [RBP + -0x184],0x0
LAB_0019e027:
MOV EAX,dword ptr [RBP + -0x184]
MOV dword ptr [RBP + -0x1a4],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0019e054
MOV EAX,dword ptr [RBP + -0x1a4]
ADD RSP,0x1b0
POP RBP
RET
LAB_0019e054:
CALL 0x001362a0
|
bool my_coll_rule_parse(long param_1,int8 param_2,int8 param_3)
{
int iVar1;
int8 uVar2;
long in_FS_OFFSET;
int1 local_188 [248];
int1 auStack_90 [128];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
my_coll_parser_init(local_188,param_1,param_2,param_3);
iVar1 = my_coll_parser_exec(local_188);
if (iVar1 == 0) {
uVar2 = my_coll_parser_curr(local_188);
my_coll_lexem_print_error(uVar2,*(int8 *)(param_1 + 0x28),0x7f,auStack_90);
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar1 == 0;
}
| |
41,233 | auth_old_password | eloqsql/libmariadb/plugins/auth/old_password.c | static int auth_old_password(MYSQL_PLUGIN_VIO *vio, MYSQL *mysql)
{
uchar *pkt;
int pkt_len;
if (((MCPVIO_EXT *)vio)->mysql_change_user)
{
/*
in mysql_change_user() the client sends the first packet.
we use the old scramble.
*/
pkt= (uchar*)mysql->scramble_buff;
}
else
{
/* read the scramble */
if ((pkt_len= vio->read_packet(vio, &pkt)) < 0)
return CR_ERROR;
if (pkt_len != SCRAMBLE_LENGTH_323 + 1 &&
pkt_len != SCRAMBLE_LENGTH + 1)
return CR_SERVER_HANDSHAKE_ERR;
/* save it in MYSQL */
memmove(mysql->scramble_buff, pkt, pkt_len - 1);
mysql->scramble_buff[pkt_len - 1] = 0;
}
if (mysql && mysql->passwd[0])
{
char scrambled[SCRAMBLE_LENGTH_323 + 1];
ma_scramble_323(scrambled, (char*)pkt, mysql->passwd);
if (vio->write_packet(vio, (uchar*)scrambled, SCRAMBLE_LENGTH_323 + 1))
return CR_ERROR;
}
else
if (vio->write_packet(vio, 0, 0)) /* no password */
return CR_ERROR;
return CR_OK;
} | O3 | c | auth_old_password:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
cmpb $0x0, 0x48(%rdi)
je 0x2e98e
leaq 0x48e(%r14), %rax
movq %rax, -0x40(%rbp)
testq %r14, %r14
jne 0x2e9ce
jmp 0x2ea01
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq *(%rbx)
testl %eax, %eax
js 0x2e9fc
movl %eax, %r12d
cmpl $0x15, %eax
je 0x2e9af
movl $0x7dc, %r15d # imm = 0x7DC
cmpl $0x9, %r12d
jne 0x2ea18
leaq 0x48e(%r14), %rdi
movq -0x40(%rbp), %rsi
decl %r12d
movq %r12, %rdx
callq 0x13720
movb $0x0, 0x48e(%r14,%r12)
movq 0x2c0(%r14), %rdx
cmpb $0x0, (%rdx)
je 0x2ea01
movq -0x40(%rbp), %rsi
leaq -0x31(%rbp), %r14
movq %r14, %rdi
callq 0x329ba
movq %rbx, %rdi
movq %r14, %rsi
movl $0x9, %edx
callq *0x8(%rbx)
testl %eax, %eax
je 0x2ea12
xorl %r15d, %r15d
jmp 0x2ea18
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq *0x8(%rbx)
testl %eax, %eax
jne 0x2ea18
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
movq %fs:0x28, %rax
cmpq -0x28(%rbp), %rax
jne 0x2ea37
movl %r15d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x13500
| auth_old_password:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 20h
mov r14, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_28], rax
cmp byte ptr [rdi+48h], 0
jz short loc_2E98E
lea rax, [r14+48Eh]
mov [rbp+var_40], rax
test r14, r14
jnz short loc_2E9CE
jmp short loc_2EA01
loc_2E98E:
lea rsi, [rbp+var_40]
mov rdi, rbx
call qword ptr [rbx]
test eax, eax
js short loc_2E9FC
mov r12d, eax
cmp eax, 15h
jz short loc_2E9AF
mov r15d, 7DCh
cmp r12d, 9
jnz short loc_2EA18
loc_2E9AF:
lea rdi, [r14+48Eh]
mov rsi, [rbp+var_40]
dec r12d
mov rdx, r12
call _memmove
mov byte ptr [r14+r12+48Eh], 0
loc_2E9CE:
mov rdx, [r14+2C0h]
cmp byte ptr [rdx], 0
jz short loc_2EA01
mov rsi, [rbp+var_40]
lea r14, [rbp+var_31]
mov rdi, r14
call ma_scramble_323
mov rdi, rbx
mov rsi, r14
mov edx, 9
call qword ptr [rbx+8]
test eax, eax
jz short loc_2EA12
loc_2E9FC:
xor r15d, r15d
jmp short loc_2EA18
loc_2EA01:
xor r15d, r15d
mov rdi, rbx
xor esi, esi
xor edx, edx
call qword ptr [rbx+8]
test eax, eax
jnz short loc_2EA18
loc_2EA12:
mov r15d, 0FFFFFFFFh
loc_2EA18:
mov rax, fs:28h
cmp rax, [rbp+var_28]
jnz short loc_2EA37
mov eax, r15d
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_2EA37:
call ___stack_chk_fail
| long long auth_old_password(long long a1, long long a2)
{
int v2; // eax
unsigned int v3; // r15d
unsigned int v4; // r12d
long long v6; // [rsp+0h] [rbp-40h] BYREF
_BYTE v7[9]; // [rsp+Fh] [rbp-31h] BYREF
unsigned long long v8; // [rsp+18h] [rbp-28h]
v8 = __readfsqword(0x28u);
if ( !*(_BYTE *)(a1 + 72) )
{
v2 = (*(long long ( **)(long long, long long *))a1)(a1, &v6);
if ( v2 < 0 )
return 0;
if ( v2 != 21 )
{
v3 = 2012;
if ( v2 != 9 )
return v3;
}
v4 = v2 - 1;
memmove(a2 + 1166, v6, (unsigned int)(v2 - 1));
*(_BYTE *)(a2 + v4 + 1166) = 0;
LABEL_8:
if ( !**(_BYTE **)(a2 + 704) )
goto LABEL_11;
ma_scramble_323(v7, v6);
if ( !(*(unsigned int ( **)(long long, _BYTE *, long long))(a1 + 8))(a1, v7, 9LL) )
return (unsigned int)-1;
return 0;
}
v6 = a2 + 1166;
if ( a2 )
goto LABEL_8;
LABEL_11:
v3 = 0;
if ( !(*(unsigned int ( **)(long long, _QWORD, _QWORD))(a1 + 8))(a1, 0LL, 0LL) )
return (unsigned int)-1;
return v3;
}
| auth_old_password:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
CMP byte ptr [RDI + 0x48],0x0
JZ 0x0012e98e
LEA RAX,[R14 + 0x48e]
MOV qword ptr [RBP + -0x40],RAX
TEST R14,R14
JNZ 0x0012e9ce
JMP 0x0012ea01
LAB_0012e98e:
LEA RSI,[RBP + -0x40]
MOV RDI,RBX
CALL qword ptr [RBX]
TEST EAX,EAX
JS 0x0012e9fc
MOV R12D,EAX
CMP EAX,0x15
JZ 0x0012e9af
MOV R15D,0x7dc
CMP R12D,0x9
JNZ 0x0012ea18
LAB_0012e9af:
LEA RDI,[R14 + 0x48e]
MOV RSI,qword ptr [RBP + -0x40]
DEC R12D
MOV RDX,R12
CALL 0x00113720
MOV byte ptr [R14 + R12*0x1 + 0x48e],0x0
LAB_0012e9ce:
MOV RDX,qword ptr [R14 + 0x2c0]
CMP byte ptr [RDX],0x0
JZ 0x0012ea01
MOV RSI,qword ptr [RBP + -0x40]
LEA R14,[RBP + -0x31]
MOV RDI,R14
CALL 0x001329ba
MOV RDI,RBX
MOV RSI,R14
MOV EDX,0x9
CALL qword ptr [RBX + 0x8]
TEST EAX,EAX
JZ 0x0012ea12
LAB_0012e9fc:
XOR R15D,R15D
JMP 0x0012ea18
LAB_0012ea01:
XOR R15D,R15D
MOV RDI,RBX
XOR ESI,ESI
XOR EDX,EDX
CALL qword ptr [RBX + 0x8]
TEST EAX,EAX
JNZ 0x0012ea18
LAB_0012ea12:
MOV R15D,0xffffffff
LAB_0012ea18:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x28]
JNZ 0x0012ea37
MOV EAX,R15D
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0012ea37:
CALL 0x00113500
|
int8 auth_old_password(int8 *param_1,long param_2)
{
int iVar1;
int8 uVar2;
long in_FS_OFFSET;
void *local_48;
int1 local_39 [9];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if (*(char *)(param_1 + 9) == '\0') {
iVar1 = (*(code *)*param_1)(param_1,&local_48);
if (-1 < iVar1) {
if ((iVar1 != 0x15) && (uVar2 = 0x7dc, iVar1 != 9)) goto LAB_0012ea18;
memmove((void *)(param_2 + 0x48e),local_48,(ulong)(iVar1 - 1));
*(int1 *)(param_2 + 0x48e + (ulong)(iVar1 - 1)) = 0;
goto LAB_0012e9ce;
}
LAB_0012e9fc:
uVar2 = 0;
goto LAB_0012ea18;
}
local_48 = (void *)(param_2 + 0x48e);
if (param_2 == 0) {
LAB_0012ea01:
uVar2 = 0;
iVar1 = (*(code *)param_1[1])(param_1,0,0);
if (iVar1 != 0) goto LAB_0012ea18;
}
else {
LAB_0012e9ce:
if (**(char **)(param_2 + 0x2c0) == '\0') goto LAB_0012ea01;
ma_scramble_323(local_39,local_48);
iVar1 = (*(code *)param_1[1])(param_1,local_39,9);
if (iVar1 != 0) goto LAB_0012e9fc;
}
uVar2 = 0xffffffff;
LAB_0012ea18:
if (*(long *)(in_FS_OFFSET + 0x28) != local_30) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar2;
}
| |
41,234 | inline_mysql_file_stat | eloqsql/include/mysql/psi/mysql_file.h | static inline MY_STAT *
inline_mysql_file_stat(
#ifdef HAVE_PSI_FILE_INTERFACE
PSI_file_key key, const char *src_file, uint src_line,
#endif
const char *path, MY_STAT *stat_area, myf flags)
{
MY_STAT *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_STAT, path, &locker);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_open_wait)(locker, src_file, src_line);
result= my_stat(path, stat_area, flags);
PSI_FILE_CALL(end_file_open_wait)(locker, result);
return result;
}
#endif
result= my_stat(path, stat_area, flags);
return result;
} | O0 | c | inline_mysql_file_stat:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
leaq 0x28b410(%rip), %rax # 0x2c0238
movq (%rax), %rax
movq 0x148(%rax), %rax
movl -0xc(%rbp), %esi
movq -0x28(%rbp), %rcx
leaq -0x90(%rbp), %rdi
movl $0xb, %edx
leaq -0x48(%rbp), %r8
callq *%rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%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 0x34ec7
leaq 0x28b3c2(%rip), %rax # 0x2c0238
movq (%rax), %rax
movq 0x1f0(%rax), %rax
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq *%rax
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0xf33a0
movq %rax, -0x40(%rbp)
leaq 0x28b38f(%rip), %rax # 0x2c0238
movq (%rax), %rax
movq 0x1f8(%rax), %rax
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq *%rax
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x34ee4
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0xf33a0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| inline_mysql_file_stat:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_C], edi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+148h]
mov esi, [rbp+var_C]
mov rcx, [rbp+var_28]
lea rdi, [rbp+var_90]
mov edx, 0Bh
lea r8, [rbp+var_48]
call rax
mov [rbp+var_48], rax
cmp [rbp+var_48], 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_34EC7
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1F0h]
mov rdi, [rbp+var_48]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
call rax
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_38]
call my_stat
mov [rbp+var_40], rax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1F8h]
mov rdi, [rbp+var_48]
mov rsi, [rbp+var_40]
call rax
mov rax, [rbp+var_40]
mov [rbp+var_8], rax
jmp short loc_34EE4
loc_34EC7:
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_38]
call my_stat
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov [rbp+var_8], rax
loc_34EE4:
mov rax, [rbp+var_8]
add rsp, 90h
pop rbp
retn
| long long inline_mysql_file_stat(
unsigned int a1,
long long a2,
unsigned int a3,
long long a4,
long long a5,
long long a6)
{
_BYTE v7[72]; // [rsp+0h] [rbp-90h] BYREF
long long v8; // [rsp+48h] [rbp-48h] BYREF
long long v9; // [rsp+50h] [rbp-40h]
long long v10; // [rsp+58h] [rbp-38h]
long long v11; // [rsp+60h] [rbp-30h]
long long v12; // [rsp+68h] [rbp-28h]
unsigned int v13; // [rsp+74h] [rbp-1Ch]
long long v14; // [rsp+78h] [rbp-18h]
unsigned int v15; // [rsp+84h] [rbp-Ch]
v15 = a1;
v14 = a2;
v13 = a3;
v12 = a4;
v11 = a5;
v10 = a6;
v8 = ((long long ( *)(_BYTE *, _QWORD, long long, long long, long long *))PSI_server[41])(v7, a1, 11LL, a4, &v8);
if ( !v8 )
return my_stat(v12, v11, v10);
((void ( *)(long long, long long, _QWORD))PSI_server[62])(v8, v14, v13);
v9 = my_stat(v12, v11, v10);
((void ( *)(long long, long long))PSI_server[63])(v8, v9);
return v9;
}
| inline_mysql_file_stat:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV dword ptr [RBP + -0xc],EDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
LEA RAX,[0x3c0238]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x148]
MOV ESI,dword ptr [RBP + -0xc]
MOV RCX,qword ptr [RBP + -0x28]
LEA RDI,[RBP + -0x90]
MOV EDX,0xb
LEA R8,[RBP + -0x48]
CALL RAX
MOV qword ptr [RBP + -0x48],RAX
CMP qword ptr [RBP + -0x48],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 0x00134ec7
LEA RAX,[0x3c0238]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1f0]
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
CALL RAX
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x001f33a0
MOV qword ptr [RBP + -0x40],RAX
LEA RAX,[0x3c0238]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1f8]
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x40]
CALL RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00134ee4
LAB_00134ec7:
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x001f33a0
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
LAB_00134ee4:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x90
POP RBP
RET
|
int8
inline_mysql_file_stat
(int4 param_1,int8 param_2,int4 param_3,int8 param_4,
int8 param_5,int8 param_6)
{
int1 local_98 [72];
long local_50;
int8 local_48;
int8 local_40;
int8 local_38;
int8 local_30;
int4 local_24;
int8 local_20;
int4 local_14;
int8 local_10;
local_40 = param_6;
local_38 = param_5;
local_30 = param_4;
local_24 = param_3;
local_20 = param_2;
local_14 = param_1;
local_50 = (**(code **)(PSI_server + 0x148))(local_98,param_1,0xb,param_4,&local_50);
if (local_50 == 0) {
local_10 = my_stat(local_30,local_38,local_40);
}
else {
(**(code **)(PSI_server + 0x1f0))(local_50,local_20,local_24);
local_48 = my_stat(local_30,local_38,local_40);
(**(code **)(PSI_server + 0x1f8))(local_50,local_48);
local_10 = local_48;
}
return local_10;
}
| |
41,235 | b2d | eloqsql/strings/dtoa.c | static double b2d(Bigint *a, int *e)
{
ULong *xa, *xa0, w, y, z;
int k;
U d;
#define d0 word0(&d)
#define d1 word1(&d)
xa0= a->p.x;
xa= xa0 + a->wds;
y= *--xa;
k= hi0bits(y);
*e= 32 - k;
if (k < Ebits)
{
d0= Exp_1 | y >> (Ebits - k);
w= xa > xa0 ? *--xa : 0;
d1= y << ((32-Ebits) + k) | w >> (Ebits - k);
goto ret_d;
}
z= xa > xa0 ? *--xa : 0;
if (k-= Ebits)
{
d0= Exp_1 | y << k | z >> (32 - k);
y= xa > xa0 ? *--xa : 0;
d1= z << k | y >> (32 - k);
}
else
{
d0= Exp_1 | y;
d1= z;
}
ret_d:
#undef d0
#undef d1
return dval(&d);
} | O0 | c | b2d:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x14(%rcx), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, -0x18(%rbp)
movl -0x4(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %edi
callq 0x790b0
movl %eax, -0x30(%rbp)
movl $0x20, %ecx
subl -0x30(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
cmpl $0xb, -0x30(%rbp)
jge 0x7924d
movl -0x28(%rbp), %eax
movl $0xb, %ecx
subl -0x30(%rbp), %ecx
shrl %cl, %eax
orl $0x3ff00000, %eax # imm = 0x3FF00000
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x7921c
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, -0x18(%rbp)
movl -0x4(%rax), %eax
movl %eax, -0x3c(%rbp)
jmp 0x79223
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0x79223
movl -0x3c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
movl -0x30(%rbp), %ecx
addl $0x15, %ecx
shll %cl, %eax
movl -0x24(%rbp), %edx
movl $0xb, %ecx
subl -0x30(%rbp), %ecx
shrl %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, -0x38(%rbp)
jmp 0x79309
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x7926e
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, -0x18(%rbp)
movl -0x4(%rax), %eax
movl %eax, -0x40(%rbp)
jmp 0x79275
xorl %eax, %eax
movl %eax, -0x40(%rbp)
jmp 0x79275
movl -0x40(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
subl $0xb, %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, %eax
je 0x792f6
movl -0x28(%rbp), %eax
movl -0x30(%rbp), %ecx
shll %cl, %eax
orl $0x3ff00000, %eax # imm = 0x3FF00000
movl -0x2c(%rbp), %edx
movl $0x20, %ecx
subl -0x30(%rbp), %ecx
shrl %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x792cb
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, -0x18(%rbp)
movl -0x4(%rax), %eax
movl %eax, -0x44(%rbp)
jmp 0x792d2
xorl %eax, %eax
movl %eax, -0x44(%rbp)
jmp 0x792d2
movl -0x44(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
movl -0x30(%rbp), %ecx
shll %cl, %eax
movl -0x28(%rbp), %edx
movl $0x20, %ecx
subl -0x30(%rbp), %ecx
shrl %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, -0x38(%rbp)
jmp 0x79307
movl -0x28(%rbp), %eax
orl $0x3ff00000, %eax # imm = 0x3FF00000
movl %eax, -0x34(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x79309
movsd -0x38(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| b2d:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_8]
movsxd rcx, dword ptr [rcx+14h]
shl rcx, 2
add rax, rcx
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_18], rcx
mov eax, [rax-4]
mov [rbp+var_28], eax
mov edi, [rbp+var_28]
call hi0bits
mov [rbp+var_30], eax
mov ecx, 20h ; ' '
sub ecx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax], ecx
cmp [rbp+var_30], 0Bh
jge short loc_7924D
mov eax, [rbp+var_28]
mov ecx, 0Bh
sub ecx, [rbp+var_30]
shr eax, cl
or eax, 3FF00000h
mov dword ptr [rbp+var_38+4], eax
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jbe short loc_7921C
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_18], rcx
mov eax, [rax-4]
mov [rbp+var_3C], eax
jmp short loc_79223
loc_7921C:
xor eax, eax
mov [rbp+var_3C], eax
jmp short $+2
loc_79223:
mov eax, [rbp+var_3C]
mov [rbp+var_24], eax
mov eax, [rbp+var_28]
mov ecx, [rbp+var_30]
add ecx, 15h
shl eax, cl
mov edx, [rbp+var_24]
mov ecx, 0Bh
sub ecx, [rbp+var_30]
shr edx, cl
mov ecx, edx
or eax, ecx
mov dword ptr [rbp+var_38], eax
jmp loc_79309
loc_7924D:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jbe short loc_7926E
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_18], rcx
mov eax, [rax-4]
mov [rbp+var_40], eax
jmp short loc_79275
loc_7926E:
xor eax, eax
mov [rbp+var_40], eax
jmp short $+2
loc_79275:
mov eax, [rbp+var_40]
mov [rbp+var_2C], eax
mov eax, [rbp+var_30]
sub eax, 0Bh
mov [rbp+var_30], eax
cmp eax, 0
jz short loc_792F6
mov eax, [rbp+var_28]
mov ecx, [rbp+var_30]
shl eax, cl
or eax, 3FF00000h
mov edx, [rbp+var_2C]
mov ecx, 20h ; ' '
sub ecx, [rbp+var_30]
shr edx, cl
mov ecx, edx
or eax, ecx
mov dword ptr [rbp+var_38+4], eax
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jbe short loc_792CB
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_18], rcx
mov eax, [rax-4]
mov [rbp+var_44], eax
jmp short loc_792D2
loc_792CB:
xor eax, eax
mov [rbp+var_44], eax
jmp short $+2
loc_792D2:
mov eax, [rbp+var_44]
mov [rbp+var_28], eax
mov eax, [rbp+var_2C]
mov ecx, [rbp+var_30]
shl eax, cl
mov edx, [rbp+var_28]
mov ecx, 20h ; ' '
sub ecx, [rbp+var_30]
shr edx, cl
mov ecx, edx
or eax, ecx
mov dword ptr [rbp+var_38], eax
jmp short loc_79307
loc_792F6:
mov eax, [rbp+var_28]
or eax, 3FF00000h
mov dword ptr [rbp+var_38+4], eax
mov eax, [rbp+var_2C]
mov dword ptr [rbp+var_38], eax
loc_79307:
jmp short $+2
loc_79309:
movsd xmm0, [rbp+var_38]
add rsp, 50h
pop rbp
retn
| double b2d(long long a1, _DWORD *a2)
{
int *v2; // rax
unsigned int v4; // [rsp+Ch] [rbp-44h]
unsigned int v5; // [rsp+10h] [rbp-40h]
unsigned int v6; // [rsp+14h] [rbp-3Ch]
long long v7; // [rsp+18h] [rbp-38h]
int v8; // [rsp+20h] [rbp-30h]
int v9; // [rsp+20h] [rbp-30h]
long long v10; // [rsp+24h] [rbp-2Ch]
unsigned long long v11; // [rsp+30h] [rbp-20h]
int *v12; // [rsp+38h] [rbp-18h]
v11 = *(_QWORD *)a1;
v12 = (int *)(4LL * *(int *)(a1 + 20) + *(_QWORD *)a1 - 4);
HIDWORD(v10) = *v12;
v8 = hi0bits(*v12);
*a2 = 32 - v8;
if ( v8 >= 11 )
{
if ( (unsigned long long)v12 <= v11 )
{
v5 = 0;
}
else
{
v2 = v12--;
v5 = *(v2 - 1);
}
LODWORD(v10) = v5;
v9 = v8 - 11;
if ( v9 )
{
HIDWORD(v7) = (v5 >> (32 - v9)) | (HIDWORD(v10) << v9) | 0x3FF00000;
if ( (unsigned long long)v12 <= v11 )
v4 = 0;
else
v4 = *(v12 - 1);
LODWORD(v7) = (v4 >> (32 - v9)) | (v5 << v9);
}
else
{
v7 = v10 | 0x3FF0000000000000LL;
}
}
else
{
HIDWORD(v7) = (HIDWORD(v10) >> (11 - v8)) | 0x3FF00000;
if ( (unsigned long long)v12 <= v11 )
v6 = 0;
else
v6 = *(v12 - 1);
LODWORD(v7) = (v6 >> (11 - v8)) | (HIDWORD(v10) << (v8 + 21));
}
return *(double *)&v7;
}
| b2d:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RCX + 0x14]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,-0x4
MOV qword ptr [RBP + -0x18],RCX
MOV EAX,dword ptr [RAX + -0x4]
MOV dword ptr [RBP + -0x28],EAX
MOV EDI,dword ptr [RBP + -0x28]
CALL 0x001790b0
MOV dword ptr [RBP + -0x30],EAX
MOV ECX,0x20
SUB ECX,dword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
CMP dword ptr [RBP + -0x30],0xb
JGE 0x0017924d
MOV EAX,dword ptr [RBP + -0x28]
MOV ECX,0xb
SUB ECX,dword ptr [RBP + -0x30]
SHR EAX,CL
OR EAX,0x3ff00000
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x0017921c
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,-0x4
MOV qword ptr [RBP + -0x18],RCX
MOV EAX,dword ptr [RAX + -0x4]
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x00179223
LAB_0017921c:
XOR EAX,EAX
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x00179223
LAB_00179223:
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x28]
MOV ECX,dword ptr [RBP + -0x30]
ADD ECX,0x15
SHL EAX,CL
MOV EDX,dword ptr [RBP + -0x24]
MOV ECX,0xb
SUB ECX,dword ptr [RBP + -0x30]
SHR EDX,CL
MOV ECX,EDX
OR EAX,ECX
MOV dword ptr [RBP + -0x38],EAX
JMP 0x00179309
LAB_0017924d:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x0017926e
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,-0x4
MOV qword ptr [RBP + -0x18],RCX
MOV EAX,dword ptr [RAX + -0x4]
MOV dword ptr [RBP + -0x40],EAX
JMP 0x00179275
LAB_0017926e:
XOR EAX,EAX
MOV dword ptr [RBP + -0x40],EAX
JMP 0x00179275
LAB_00179275:
MOV EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x30]
SUB EAX,0xb
MOV dword ptr [RBP + -0x30],EAX
CMP EAX,0x0
JZ 0x001792f6
MOV EAX,dword ptr [RBP + -0x28]
MOV ECX,dword ptr [RBP + -0x30]
SHL EAX,CL
OR EAX,0x3ff00000
MOV EDX,dword ptr [RBP + -0x2c]
MOV ECX,0x20
SUB ECX,dword ptr [RBP + -0x30]
SHR EDX,CL
MOV ECX,EDX
OR EAX,ECX
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x001792cb
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,-0x4
MOV qword ptr [RBP + -0x18],RCX
MOV EAX,dword ptr [RAX + -0x4]
MOV dword ptr [RBP + -0x44],EAX
JMP 0x001792d2
LAB_001792cb:
XOR EAX,EAX
MOV dword ptr [RBP + -0x44],EAX
JMP 0x001792d2
LAB_001792d2:
MOV EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RBP + -0x28],EAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV ECX,dword ptr [RBP + -0x30]
SHL EAX,CL
MOV EDX,dword ptr [RBP + -0x28]
MOV ECX,0x20
SUB ECX,dword ptr [RBP + -0x30]
SHR EDX,CL
MOV ECX,EDX
OR EAX,ECX
MOV dword ptr [RBP + -0x38],EAX
JMP 0x00179307
LAB_001792f6:
MOV EAX,dword ptr [RBP + -0x28]
OR EAX,0x3ff00000
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x38],EAX
LAB_00179307:
JMP 0x00179309
LAB_00179309:
MOVSD XMM0,qword ptr [RBP + -0x38]
ADD RSP,0x50
POP RBP
RET
|
int8 b2d(ulong *param_1,int *param_2)
{
uint uVar1;
ulong uVar2;
char cVar3;
int iVar4;
long lVar5;
byte bVar6;
int4 local_4c;
int4 local_48;
int4 local_44;
int4 local_40;
int4 uStack_3c;
int8 local_20;
uVar2 = *param_1;
lVar5 = uVar2 + (long)*(int *)((long)param_1 + 0x14) * 4;
local_20 = lVar5 - 4;
uVar1 = *(uint *)(lVar5 + -4);
iVar4 = hi0bits(uVar1);
*param_2 = 0x20 - iVar4;
if (iVar4 < 0xb) {
cVar3 = (char)iVar4;
uStack_3c = uVar1 >> (0xbU - cVar3 & 0x1f) | 0x3ff00000;
if (uVar2 < local_20) {
local_44 = *(uint *)(lVar5 + -8);
}
else {
local_44 = 0;
}
local_40 = uVar1 << (cVar3 + 0x15U & 0x1f) | local_44 >> (0xbU - cVar3 & 0x1f);
}
else {
if (uVar2 < local_20) {
local_20 = lVar5 - 8;
local_48 = *(uint *)(lVar5 + -8);
}
else {
local_48 = 0;
}
if (iVar4 + -0xb == 0) {
uStack_3c = uVar1 | 0x3ff00000;
local_40 = local_48;
}
else {
bVar6 = (byte)(iVar4 + -0xb);
uStack_3c = uVar1 << (bVar6 & 0x1f) | 0x3ff00000 | local_48 >> (0x20 - bVar6 & 0x1f);
if (uVar2 < local_20) {
local_4c = *(uint *)(local_20 - 4);
}
else {
local_4c = 0;
}
local_40 = local_48 << (bVar6 & 0x1f) | local_4c >> (0x20 - bVar6 & 0x1f);
}
}
return CONCAT44(uStack_3c,local_40);
}
| |
41,236 | google::protobuf::FloatValue::ByteSizeLong() const | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/wrappers.pb.cc | size_t FloatValue::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.protobuf.FloatValue)
size_t total_size = 0;
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
// float value = 1;
static_assert(sizeof(uint32_t) == sizeof(float), "Code assumes uint32_t and float are the same size.");
float tmp_value = this->_internal_value();
uint32_t raw_value;
memcpy(&raw_value, &tmp_value, sizeof(tmp_value));
if (raw_value != 0) {
total_size += 1 + 4;
}
return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
} | O0 | cpp | google::protobuf::FloatValue::ByteSizeLong() const:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movq $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
callq 0x212cf0
movss %xmm0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x20c8ab
movq 0x18(%rsp), %rax
addq $0x5, %rax
movq %rax, 0x18(%rsp)
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rdi, %rdx
addq $0x10, %rdx
addq $0x4, %rdx
callq 0x1dbd10
addq $0x28, %rsp
retq
nopl (%rax)
| _ZNK6google8protobuf10FloatValue12ByteSizeLongEv:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov rdi, [rsp+28h+var_8]; this
mov [rsp+28h+var_28], rdi
mov [rsp+28h+var_10], 0
mov [rsp+28h+var_14], 0
call _ZNK6google8protobuf10FloatValue15_internal_valueEv; google::protobuf::FloatValue::_internal_value(void)
movss [rsp+28h+var_18], xmm0
mov eax, [rsp+28h+var_18]
mov [rsp+28h+var_1C], eax
cmp [rsp+28h+var_1C], 0
jz short loc_20C8AB
mov rax, [rsp+28h+var_10]
add rax, 5
mov [rsp+28h+var_10], rax
loc_20C8AB:
mov rdi, [rsp+28h+var_28]; this
mov rsi, [rsp+28h+var_10]; unsigned __int64
mov rdx, rdi
add rdx, 10h
add rdx, 4; google::protobuf::internal::CachedSize *
call _ZNK6google8protobuf7Message29MaybeComputeUnknownFieldsSizeEmPNS0_8internal10CachedSizeE; google::protobuf::Message::MaybeComputeUnknownFieldsSize(ulong,google::protobuf::internal::CachedSize *)
add rsp, 28h
retn
| google::protobuf::internal * google::protobuf::FloatValue::ByteSizeLong(
google::protobuf::FloatValue *this,
float a2)
{
const google::protobuf::UnknownFieldSet *v3; // [rsp+18h] [rbp-10h]
v3 = 0LL;
google::protobuf::FloatValue::_internal_value(this);
if ( a2 != 0.0 )
v3 = (const google::protobuf::UnknownFieldSet *)&byte_5;
return google::protobuf::Message::MaybeComputeUnknownFieldsSize(
this,
v3,
(google::protobuf::FloatValue *)((char *)this + 20));
}
| |||
41,237 | google::protobuf::FloatValue::ByteSizeLong() const | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/wrappers.pb.cc | size_t FloatValue::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.protobuf.FloatValue)
size_t total_size = 0;
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
// float value = 1;
static_assert(sizeof(uint32_t) == sizeof(float), "Code assumes uint32_t and float are the same size.");
float tmp_value = this->_internal_value();
uint32_t raw_value;
memcpy(&raw_value, &tmp_value, sizeof(tmp_value));
if (raw_value != 0) {
total_size += 1 + 4;
}
return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
} | O3 | cpp | google::protobuf::FloatValue::ByteSizeLong() const:
pushq %rbx
testq %rdi, %rdi
je 0xb2898
movq %rdi, %rbx
leaq 0x1593f8(%rip), %rdx # 0x20bc80
movl $0x20, %esi
callq 0x78440
movq %rbx, 0x8(%rax)
jmp 0xb28aa
movl $0x20, %edi
callq 0x2d270
movq $0x0, 0x8(%rax)
leaq 0x15911f(%rip), %rcx # 0x20b9d0
movq %rcx, (%rax)
movl $0x0, 0x18(%rax)
leaq 0x1623c6(%rip), %rcx # 0x214c88
movq %rcx, 0x10(%rax)
popq %rbx
retq
| _ZN6google8protobuf5Arena18CreateMaybeMessageINS0_11StringValueEJEEEPT_PS1_DpOT0_:
push rbx
test rdi, rdi
jz short loc_B2898
mov rbx, rdi
lea rdx, _ZTIN6google8protobuf11StringValueE; type_info *
mov esi, 20h ; ' '; unsigned __int64
call _ZN6google8protobuf5Arena23AllocateAlignedWithHookEmPKSt9type_info; google::protobuf::Arena::AllocateAlignedWithHook(ulong,std::type_info const*)
mov [rax+8], rbx
jmp short loc_B28AA
loc_B2898:
mov edi, 20h ; ' '; unsigned __int64
call __Znwm; operator new(ulong)
mov qword ptr [rax+8], 0
loc_B28AA:
lea rcx, off_20B9D0
mov [rax], rcx
mov dword ptr [rax+18h], 0
lea rcx, _ZN6google8protobuf8internal26fixed_address_empty_stringB5cxx11E; google::protobuf::internal::fixed_address_empty_string
mov [rax+10h], rcx
pop rbx
retn
| long long google::protobuf::Arena::CreateMaybeMessage<google::protobuf::StringValue>(
google::protobuf::Arena *a1)
{
long long result; // rax
if ( a1 )
{
result = google::protobuf::Arena::AllocateAlignedWithHook(
a1,
0x20uLL,
(const type_info *)&`typeinfo for'google::protobuf::StringValue);
*(_QWORD *)(result + 8) = a1;
}
else
{
result = operator new(0x20uLL);
*(_QWORD *)(result + 8) = 0LL;
}
*(_QWORD *)result = off_20B9D0;
*(_DWORD *)(result + 24) = 0;
*(_QWORD *)(result + 16) = google::protobuf::internal::fixed_address_empty_string[abi:cxx11];
return result;
}
| CreateMaybeMessage<google::protobuf::StringValue>:
PUSH RBX
TEST RDI,RDI
JZ 0x001b2898
MOV RBX,RDI
LEA RDX,[0x30bc80]
MOV ESI,0x20
CALL 0x00178440
MOV qword ptr [RAX + 0x8],RBX
JMP 0x001b28aa
LAB_001b2898:
MOV EDI,0x20
CALL 0x0012d270
MOV qword ptr [RAX + 0x8],0x0
LAB_001b28aa:
LEA RCX,[0x30b9d0]
MOV qword ptr [RAX],RCX
MOV dword ptr [RAX + 0x18],0x0
LEA RCX,[0x314c88]
MOV qword ptr [RAX + 0x10],RCX
POP RBX
RET
|
/* google::protobuf::StringValue*
google::protobuf::Arena::CreateMaybeMessage<google::protobuf::StringValue>(google::protobuf::Arena*)
*/
StringValue *
google::protobuf::Arena::CreateMaybeMessage<google::protobuf::StringValue>(Arena *param_1)
{
StringValue *pSVar1;
if (param_1 == (Arena *)0x0) {
pSVar1 = (StringValue *)operator_new(0x20);
*(int8 *)(pSVar1 + 8) = 0;
}
else {
pSVar1 = (StringValue *)AllocateAlignedWithHook((ulong)param_1,(type_info *)0x20);
*(Arena **)(pSVar1 + 8) = param_1;
}
*(int ***)pSVar1 = &PTR__StringValue_0030b9d0;
*(int4 *)(pSVar1 + 0x18) = 0;
*(int8 **)(pSVar1 + 0x10) = &internal::fixed_address_empty_string_abi_cxx11_;
return pSVar1;
}
| |
41,238 | TRP_ROR_INTERSECT::trace_basic_info(PARAM*, Json_writer_object*) const | eloqsql/sql/opt_range.cc | void TRP_ROR_INTERSECT::trace_basic_info(PARAM *param,
Json_writer_object *trace_object) const
{
THD *thd= param->thd;
DBUG_ASSERT(trace_object->trace_started());
trace_object->add("type", "index_roworder_intersect");
trace_object->add("rows", records);
trace_object->add("cost", read_cost);
trace_object->add("covering", is_covering);
trace_object->add("clustered_pk_scan", cpk_scan != NULL);
Json_writer_array smth_trace(thd, "intersect_of");
for (ROR_SCAN_INFO **cur_scan= first_scan; cur_scan != last_scan;
cur_scan++)
{
const KEY &cur_key= param->table->key_info[(*cur_scan)->keynr];
const KEY_PART_INFO *key_part= cur_key.key_part;
Json_writer_object trace_isect_idx(thd);
trace_isect_idx.add("type", "range_scan");
trace_isect_idx.add("index", cur_key.name);
trace_isect_idx.add("rows", (*cur_scan)->records);
Json_writer_array trace_range(thd, "ranges");
trace_ranges(&trace_range, param, (*cur_scan)->idx,
(*cur_scan)->sel_arg, key_part);
}
} | O0 | cpp | TRP_ROR_INTERSECT::trace_basic_info(PARAM*, Json_writer_object*) const:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x70(%rbp)
movq %rsi, -0x78(%rbp)
movq %rdx, -0x80(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x88(%rbp)
jmp 0x8b616f
movq -0x80(%rbp), %rdi
leaq 0xbdcb52(%rip), %rsi # 0x1492ccc
leaq 0xb5f843(%rip), %rdx # 0x14159c4
callq 0x8ca5d0
movq -0xb8(%rbp), %rax
movq -0x80(%rbp), %rdi
movq 0x10(%rax), %rdx
leaq 0xb96e23(%rip), %rsi # 0x144cfbf
callq 0x8ca690
movq -0xb8(%rbp), %rax
movq -0x80(%rbp), %rdi
movsd 0x8(%rax), %xmm0
leaq 0xb5faf9(%rip), %rsi # 0x1415cb1
callq 0x8ca920
movq -0xb8(%rbp), %rax
movq -0x80(%rbp), %rdi
movb 0x38(%rax), %al
leaq 0xb5fb60(%rip), %rsi # 0x1415d32
andb $0x1, %al
movzbl %al, %edx
callq 0x8ca8c0
movq -0xb8(%rbp), %rax
movq -0x80(%rbp), %rdi
cmpq $0x0, 0x30(%rax)
setne %al
movzbl %al, %edx
andl $0x1, %edx
leaq 0xb5f8a3(%rip), %rsi # 0x1415a9f
callq 0x8ca8c0
movq -0x88(%rbp), %rsi
leaq -0x28(%rbp), %rdi
leaq 0xb5f554(%rip), %rdx # 0x1415767
callq 0x8ca6f0
movq -0xb8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x90(%rbp)
movq -0xb8(%rbp), %rcx
movq -0x90(%rbp), %rax
cmpq 0x28(%rcx), %rax
je 0x8b63a4
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xa8(%rax), %rax
movq -0x90(%rbp), %rcx
movq (%rcx), %rcx
movl 0x4(%rcx), %ecx
leaq (%rcx,%rcx,2), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0xa0(%rbp)
movq -0x88(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
leaq -0x48(%rbp), %rdi
callq 0x8ca7c0
jmp 0x8b6298
leaq 0xbdca2d(%rip), %rsi # 0x1492ccc
leaq 0xb7d906(%rip), %rdx # 0x1433bac
leaq -0x48(%rbp), %rdi
callq 0x8ca5d0
jmp 0x8b62b1
movq -0x98(%rbp), %rdx
addq $0x40, %rdx
leaq 0xbc340a(%rip), %rsi # 0x14796cd
leaq -0x48(%rbp), %rdi
callq 0x8ca630
jmp 0x8b62ce
movq -0x90(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdx
leaq 0xb96cdc(%rip), %rsi # 0x144cfbf
leaq -0x48(%rbp), %rdi
callq 0x8ca690
jmp 0x8b62ee
movq -0x88(%rbp), %rsi
leaq 0xb5f741(%rip), %rdx # 0x1415a3d
leaq -0x68(%rbp), %rdi
callq 0x8ca6f0
jmp 0x8b6307
movq -0x78(%rbp), %rsi
movq -0x90(%rbp), %rax
movq (%rax), %rax
movl (%rax), %edx
movq 0x18(%rax), %rcx
movq -0xa0(%rbp), %r8
leaq -0x68(%rbp), %rdi
callq 0x8aaec0
jmp 0x8b632d
leaq -0x68(%rbp), %rdi
callq 0x8ca740
leaq -0x48(%rbp), %rdi
callq 0x8ca810
movq -0x90(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x90(%rbp)
jmp 0x8b622a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x8b63c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x8b6399
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x8ca740
leaq -0x48(%rbp), %rdi
callq 0x8ca810
jmp 0x8b63c8
leaq -0x28(%rbp), %rdi
callq 0x8ca740
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x8b63fd
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x8ca740
movq -0xa8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x8b63fd
movq -0xc0(%rbp), %rdi
callq 0x775a20
callq 0x7754c0
nopw %cs:(%rax,%rax)
| _ZNK17TRP_ROR_INTERSECT16trace_basic_infoEP5PARAMP18Json_writer_object:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_70], rdi
mov [rbp+var_78], rsi
mov [rbp+var_80], rdx
mov rax, [rbp+var_70]
mov [rbp+var_B8], rax
mov rax, [rbp+var_78]
mov rax, [rax]
mov [rbp+var_88], rax
jmp short $+2
loc_8B616F:
mov rdi, [rbp+var_80]; this
lea rsi, aFieldColMtypeT+15h; char *
lea rdx, aIndexRoworderI; "index_roworder_intersect"
call _ZN18Json_writer_object3addEPKcS1_; Json_writer_object::add(char const*,char const*)
mov rax, [rbp+var_B8]
mov rdi, [rbp+var_80]; this
mov rdx, [rax+10h]; unsigned __int64
lea rsi, aMovedLldMispla+15h; char *
call _ZN18Json_writer_object3addEPKcy; Json_writer_object::add(char const*,ulong long)
mov rax, [rbp+var_B8]
mov rdi, [rbp+var_80]; this
movsd xmm0, qword ptr [rax+8]; double
lea rsi, aDoesNotReduceC_0+10h; char *
call _ZN18Json_writer_object3addEPKcd; Json_writer_object::add(char const*,double)
mov rax, [rbp+var_B8]
mov rdi, [rbp+var_80]; this
mov al, [rax+38h]
lea rsi, aRoworderIsCove+0Ch; char *
and al, 1
movzx edx, al; bool
call _ZN18Json_writer_object3addEPKcb; Json_writer_object::add(char const*,bool)
mov rax, [rbp+var_B8]
mov rdi, [rbp+var_80]; this
cmp qword ptr [rax+30h], 0
setnz al
movzx edx, al
and edx, 1; bool
lea rsi, aCostOfMappingR+1Dh; char *
call _ZN18Json_writer_object3addEPKcb; Json_writer_object::add(char const*,bool)
mov rsi, [rbp+var_88]; THD *
lea rdi, [rbp+var_28]; this
lea rdx, aIndexSortInter_0+0Bh; char *
call _ZN17Json_writer_arrayC2EP3THDPKc; Json_writer_array::Json_writer_array(THD *,char const*)
mov rax, [rbp+var_B8]
mov rax, [rax+20h]
mov [rbp+var_90], rax
loc_8B622A:
mov rcx, [rbp+var_B8]
mov rax, [rbp+var_90]
cmp rax, [rcx+28h]
jz loc_8B63A4
mov rax, [rbp+var_78]
mov rax, [rax+8]
mov rax, [rax+0A8h]
mov rcx, [rbp+var_90]
mov rcx, [rcx]
mov ecx, [rcx+4]
lea rcx, [rcx+rcx*2]
shl rcx, 6
add rax, rcx
mov [rbp+var_98], rax
mov rax, [rbp+var_98]
mov rax, [rax+68h]
mov [rbp+var_A0], rax
mov rsi, [rbp+var_88]; THD *
xor eax, eax
mov edx, eax; char *
lea rdi, [rbp+var_48]; this
call _ZN18Json_writer_objectC2EP3THDPKc; Json_writer_object::Json_writer_object(THD *,char const*)
jmp short $+2
loc_8B6298:
lea rsi, aFieldColMtypeT+15h; char *
lea rdx, aNotNullRangeSc+9; char *
lea rdi, [rbp+var_48]; this
call _ZN18Json_writer_object3addEPKcS1_; Json_writer_object::add(char const*,char const*)
jmp short $+2
loc_8B62B1:
mov rdx, [rbp+var_98]
add rdx, 40h ; '@'
lea rsi, aBlockIndexInde+10h; "index"
lea rdi, [rbp+var_48]
call _ZN18Json_writer_object3addEPKcRK25st_mysql_const_lex_string; Json_writer_object::add(char const*,st_mysql_const_lex_string const&)
jmp short $+2
loc_8B62CE:
mov rax, [rbp+var_90]
mov rax, [rax]
mov rdx, [rax+10h]; unsigned __int64
lea rsi, aMovedLldMispla+15h; char *
lea rdi, [rbp+var_48]; this
call _ZN18Json_writer_object3addEPKcy; Json_writer_object::add(char const*,ulong long)
jmp short $+2
loc_8B62EE:
mov rsi, [rbp+var_88]; THD *
lea rdx, aCostOfReadingR+10h; char *
lea rdi, [rbp+var_68]; this
call _ZN17Json_writer_arrayC2EP3THDPKc; Json_writer_array::Json_writer_array(THD *,char const*)
jmp short $+2
loc_8B6307:
mov rsi, [rbp+var_78]
mov rax, [rbp+var_90]
mov rax, [rax]
mov edx, [rax]
mov rcx, [rax+18h]
mov r8, [rbp+var_A0]
lea rdi, [rbp+var_68]
call _ZL12trace_rangesP17Json_writer_arrayP5PARAMjP7SEL_ARGPK16st_key_part_info; trace_ranges(Json_writer_array *,PARAM *,uint,SEL_ARG *,st_key_part_info const*)
jmp short $+2
loc_8B632D:
lea rdi, [rbp+var_68]; this
call _ZN17Json_writer_arrayD2Ev; Json_writer_array::~Json_writer_array()
lea rdi, [rbp+var_48]; this
call _ZN18Json_writer_objectD2Ev; Json_writer_object::~Json_writer_object()
mov rax, [rbp+var_90]
add rax, 8
mov [rbp+var_90], rax
jmp loc_8B622A
mov rcx, rax
mov eax, edx
mov [rbp+var_A8], rcx
mov [rbp+var_AC], eax
jmp short loc_8B63C8
mov rcx, rax
mov eax, edx
mov [rbp+var_A8], rcx
mov [rbp+var_AC], eax
jmp short loc_8B6399
mov rcx, rax
mov eax, edx
mov [rbp+var_A8], rcx
mov [rbp+var_AC], eax
lea rdi, [rbp+var_68]; this
call _ZN17Json_writer_arrayD2Ev; Json_writer_array::~Json_writer_array()
loc_8B6399:
lea rdi, [rbp+var_48]; this
call _ZN18Json_writer_objectD2Ev; Json_writer_object::~Json_writer_object()
jmp short loc_8B63C8
loc_8B63A4:
lea rdi, [rbp+var_28]; this
call _ZN17Json_writer_arrayD2Ev; Json_writer_array::~Json_writer_array()
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_8B63FD
add rsp, 0C0h
pop rbp
retn
loc_8B63C8:
lea rdi, [rbp+var_28]; this
call _ZN17Json_writer_arrayD2Ev; Json_writer_array::~Json_writer_array()
mov rax, [rbp+var_A8]
mov [rbp+var_C0], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_8B63FD
mov rdi, [rbp+var_C0]
call __Unwind_Resume
loc_8B63FD:
call ___stack_chk_fail
| unsigned long long TRP_ROR_INTERSECT::trace_basic_info(
TRP_ROR_INTERSECT *this,
THD **a2,
Json_writer_object *a3)
{
long long v4; // [rsp+20h] [rbp-A0h]
long long v5; // [rsp+28h] [rbp-98h]
unsigned int **i; // [rsp+30h] [rbp-90h]
THD *v7; // [rsp+38h] [rbp-88h]
_BYTE v9[32]; // [rsp+58h] [rbp-68h] BYREF
_BYTE v10[32]; // [rsp+78h] [rbp-48h] BYREF
_BYTE v11[32]; // [rsp+98h] [rbp-28h] BYREF
unsigned long long v12; // [rsp+B8h] [rbp-8h]
v12 = __readfsqword(0x28u);
v7 = *a2;
Json_writer_object::add(a3, "type", "index_roworder_intersect");
Json_writer_object::add(a3, "rows", *((_QWORD *)this + 2));
Json_writer_object::add(a3, "cost", *((double *)this + 1));
Json_writer_object::add(a3, "covering", *((_BYTE *)this + 56) & 1);
Json_writer_object::add(a3, "clustered_pk_scan", *((_QWORD *)this + 6) != 0LL);
Json_writer_array::Json_writer_array((Json_writer_array *)v11, v7, "intersect_of");
for ( i = (unsigned int **)*((_QWORD *)this + 4); i != *((unsigned int ***)this + 5); ++i )
{
v5 = 192LL * (*i)[1] + *((_QWORD *)a2[1] + 21);
v4 = *(_QWORD *)(v5 + 104);
Json_writer_object::Json_writer_object((Json_writer_object *)v10, v7, 0LL);
Json_writer_object::add((Json_writer_object *)v10, "type", "range_scan");
Json_writer_object::add(v10, "index", v5 + 64);
Json_writer_object::add((Json_writer_object *)v10, "rows", *((_QWORD *)*i + 2));
Json_writer_array::Json_writer_array((Json_writer_array *)v9, v7, "ranges");
trace_ranges((Json_writer_array *)v9, (long long)a2, **i, *((_QWORD *)*i + 3), v4);
Json_writer_array::~Json_writer_array((Json_writer_array *)v9);
Json_writer_object::~Json_writer_object((Json_writer_object *)v10);
}
Json_writer_array::~Json_writer_array((Json_writer_array *)v11);
return __readfsqword(0x28u);
}
| __cxx_global_var_init:
PUSH RBP
MOV RBP,RSP
LEA RDI,[0x1e7bb10]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x008fd530
POP RBP
RET
|
void __cxx_global_var_init(void)
{
date_conv_mode_t::date_conv_mode_t((date_conv_mode_t *)&TIME_CONV_NONE,0);
return;
}
| |
41,239 | js_string_iterator_next | bluesky950520[P]quickjs/quickjs.c | static JSValue js_string_iterator_next(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv,
BOOL *pdone, int magic)
{
JSArrayIteratorData *it;
uint32_t idx, c, start;
JSString *p;
it = JS_GetOpaque2(ctx, this_val, JS_CLASS_STRING_ITERATOR);
if (!it) {
*pdone = FALSE;
return JS_EXCEPTION;
}
if (JS_IsUndefined(it->obj))
goto done;
p = JS_VALUE_GET_STRING(it->obj);
idx = it->idx;
if (idx >= p->len) {
JS_FreeValue(ctx, it->obj);
it->obj = JS_UNDEFINED;
done:
*pdone = TRUE;
return JS_UNDEFINED;
}
start = idx;
c = string_getc(p, (int *)&idx);
it->idx = idx;
*pdone = FALSE;
if (c <= 0xffff) {
return js_new_string_char(ctx, c);
} else {
return js_new_string16_len(ctx, p->u.str16 + start, 2);
}
} | O2 | c | js_string_iterator_next:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %rdi, %rbx
pushq $0x2d
popq %rcx
callq 0x2068b
testq %rax, %rax
je 0x68d8f
movq %rax, %r15
movq 0x8(%rax), %rdx
cmpl $0x3, %edx
je 0x68dae
movq (%r15), %r12
movl 0x14(%r15), %r13d
movl %r13d, 0x4(%rsp)
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
andl 0x4(%r12), %eax
cmpl %eax, %r13d
jae 0x68d97
movabsq $-0x100000000, %rbp # imm = 0xFFFFFFFF00000000
leaq 0x4(%rsp), %rsi
movq %r12, %rdi
callq 0x40eac
leaq 0x4(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x14(%r15)
andl $0x0, (%r14)
cmpl $0xffff, %eax # imm = 0xFFFF
ja 0x68dd0
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x35320
jmp 0x68de3
andl $0x0, (%r14)
pushq $0x6
jmp 0x68db7
movq %rbx, %rdi
movq %r12, %rsi
callq 0x174a2
andl $0x0, (%r15)
movq $0x3, 0x8(%r15)
movl $0x1, (%r14)
pushq $0x3
popq %rdx
xorl %eax, %eax
xorl %ebp, %ebp
movl %eax, %eax
orq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq (%r12,%r13,2), %rsi
addq $0x18, %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x35477
andq %rax, %rbp
jmp 0x68dbc
| js_string_iterator_next:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, r9
mov rbx, rdi
push 2Dh ; '-'
pop rcx
call JS_GetOpaque2
test rax, rax
jz short loc_68D8F
mov r15, rax
mov rdx, [rax+8]
cmp edx, 3
jz short loc_68DAE
mov r12, [r15]
mov r13d, [r15+14h]
mov [rsp+38h+var_34], r13d
mov eax, 7FFFFFFFh
and eax, [r12+4]
cmp r13d, eax
jnb short loc_68D97
mov rbp, 0FFFFFFFF00000000h
lea rsi, [rsp+38h+var_34]
mov rdi, r12
call string_getc
lea rcx, [rsp+38h+var_34]
mov ecx, [rcx]
mov [r15+14h], ecx
and dword ptr [r14], 0
cmp eax, 0FFFFh
ja short loc_68DD0
movzx esi, ax
mov rdi, rbx
call js_new_string_char
jmp short loc_68DE3
loc_68D8F:
and dword ptr [r14], 0
push 6
jmp short loc_68DB7
loc_68D97:
mov rdi, rbx
mov rsi, r12
call JS_FreeValue
and dword ptr [r15], 0
mov qword ptr [r15+8], 3
loc_68DAE:
mov dword ptr [r14], 1
push 3
loc_68DB7:
pop rdx
xor eax, eax
xor ebp, ebp
loc_68DBC:
mov eax, eax
or rax, rbp
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_68DD0:
lea rsi, [r12+r13*2]
add rsi, 18h
push 2
pop rdx
mov rdi, rbx
call js_new_string16_len
loc_68DE3:
and rbp, rax
jmp short loc_68DBC
| unsigned long long js_string_iterator_next(long long a1, long long a2, int a3, long long a4, long long a5, _DWORD *a6)
{
long long v6; // rax
long long Opaque2; // rax
long long v9; // r15
long long v10; // rdx
long long v11; // r12
long long v12; // r13
unsigned int v13; // eax
long long v14; // rax
unsigned long long v15; // rbp
int v17[13]; // [rsp+0h] [rbp-34h] BYREF
v17[0] = HIDWORD(v6);
Opaque2 = JS_GetOpaque2(a1, a2, a3, 0x2Du);
if ( !Opaque2 )
{
*a6 = 0;
LABEL_9:
LODWORD(v14) = 0;
v15 = 0LL;
return v15 | (unsigned int)v14;
}
v9 = Opaque2;
v10 = *(_QWORD *)(Opaque2 + 8);
if ( (_DWORD)v10 == 3 )
{
LABEL_8:
*a6 = 1;
goto LABEL_9;
}
v11 = *(_QWORD *)Opaque2;
v12 = *(unsigned int *)(Opaque2 + 20);
v17[0] = v12;
if ( (unsigned int)v12 >= (*(_DWORD *)(v11 + 4) & 0x7FFFFFFFu) )
{
JS_FreeValue(a1, v11, v10);
*(_DWORD *)v9 = 0;
*(_QWORD *)(v9 + 8) = 3LL;
goto LABEL_8;
}
v13 = string_getc(v11, v17);
*(_DWORD *)(v9 + 20) = v17[0];
*a6 = 0;
if ( v13 > 0xFFFF )
v14 = js_new_string16_len(a1, v11 + 2 * v12 + 24, 2u);
else
v14 = js_new_string_char(a1, v13);
v15 = v14 & 0xFFFFFFFF00000000LL;
return v15 | (unsigned int)v14;
}
| js_string_iterator_next:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R9
MOV RBX,RDI
PUSH 0x2d
POP RCX
CALL 0x0012068b
TEST RAX,RAX
JZ 0x00168d8f
MOV R15,RAX
MOV RDX,qword ptr [RAX + 0x8]
CMP EDX,0x3
JZ 0x00168dae
MOV R12,qword ptr [R15]
MOV R13D,dword ptr [R15 + 0x14]
MOV dword ptr [RSP + 0x4],R13D
MOV EAX,0x7fffffff
AND EAX,dword ptr [R12 + 0x4]
CMP R13D,EAX
JNC 0x00168d97
MOV RBP,-0x100000000
LEA RSI,[RSP + 0x4]
MOV RDI,R12
CALL 0x00140eac
LEA RCX,[RSP + 0x4]
MOV ECX,dword ptr [RCX]
MOV dword ptr [R15 + 0x14],ECX
AND dword ptr [R14],0x0
CMP EAX,0xffff
JA 0x00168dd0
MOVZX ESI,AX
MOV RDI,RBX
CALL 0x00135320
JMP 0x00168de3
LAB_00168d8f:
AND dword ptr [R14],0x0
PUSH 0x6
JMP 0x00168db7
LAB_00168d97:
MOV RDI,RBX
MOV RSI,R12
CALL 0x001174a2
AND dword ptr [R15],0x0
MOV qword ptr [R15 + 0x8],0x3
LAB_00168dae:
MOV dword ptr [R14],0x1
PUSH 0x3
LAB_00168db7:
POP RDX
XOR EAX,EAX
XOR EBP,EBP
LAB_00168dbc:
MOV EAX,EAX
OR RAX,RBP
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00168dd0:
LEA RSI,[R12 + R13*0x2]
ADD RSI,0x18
PUSH 0x2
POP RDX
MOV RDI,RBX
CALL 0x00135477
LAB_00168de3:
AND RBP,RAX
JMP 0x00168dbc
|
ulong js_string_iterator_next(int8 param_1)
{
long lVar1;
uint uVar2;
long *plVar3;
ulong uVar4;
ulong uVar5;
int4 *in_R9;
uint local_34;
plVar3 = (long *)JS_GetOpaque2();
if (plVar3 == (long *)0x0) {
*in_R9 = 0;
}
else {
if ((int)plVar3[1] != 3) {
lVar1 = *plVar3;
local_34 = *(uint *)((long)plVar3 + 0x14);
uVar4 = (ulong)local_34;
if (local_34 < (*(uint *)(lVar1 + 4) & 0x7fffffff)) {
uVar2 = string_getc(lVar1,&local_34);
*(uint *)((long)plVar3 + 0x14) = local_34;
*in_R9 = 0;
if (uVar2 < 0x10000) {
uVar4 = js_new_string_char(param_1,uVar2 & 0xffff);
}
else {
uVar4 = js_new_string16_len(param_1,lVar1 + uVar4 * 2 + 0x18,2);
}
uVar5 = uVar4 & 0xffffffff00000000;
goto LAB_00168dbc;
}
JS_FreeValue(param_1,lVar1);
*(int4 *)plVar3 = 0;
plVar3[1] = 3;
}
*in_R9 = 1;
}
uVar4 = 0;
uVar5 = 0;
LAB_00168dbc:
return uVar4 & 0xffffffff | uVar5;
}
| |
41,240 | js_string_iterator_next | bluesky950520[P]quickjs/quickjs.c | static JSValue js_string_iterator_next(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv,
BOOL *pdone, int magic)
{
JSArrayIteratorData *it;
uint32_t idx, c, start;
JSString *p;
it = JS_GetOpaque2(ctx, this_val, JS_CLASS_STRING_ITERATOR);
if (!it) {
*pdone = FALSE;
return JS_EXCEPTION;
}
if (JS_IsUndefined(it->obj))
goto done;
p = JS_VALUE_GET_STRING(it->obj);
idx = it->idx;
if (idx >= p->len) {
JS_FreeValue(ctx, it->obj);
it->obj = JS_UNDEFINED;
done:
*pdone = TRUE;
return JS_UNDEFINED;
}
start = idx;
c = string_getc(p, (int *)&idx);
it->idx = idx;
*pdone = FALSE;
if (c <= 0xffff) {
return js_new_string_char(ctx, c);
} else {
return js_new_string16_len(ctx, p->u.str16 + start, 2);
}
} | O3 | c | js_string_iterator_next:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %rdi, %r14
cmpl $-0x1, %edx
jne 0x7f9cf
cmpw $0x2d, 0x6(%rsi)
jne 0x7f9cf
movq 0x30(%rsi), %rbp
testq %rbp, %rbp
je 0x7f9cf
movq 0x8(%rbp), %rdx
cmpl $0x3, %edx
je 0x7fa2e
movq (%rbp), %r15
movl 0x14(%rbp), %r12d
movl %r12d, 0x4(%rsp)
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
andl 0x4(%r15), %eax
cmpl %eax, %r12d
jae 0x7fa00
movabsq $-0x100000000, %r13 # imm = 0xFFFFFFFF00000000
leaq 0x4(%rsp), %rsi
movq %r15, %rdi
callq 0x4d7fe
leaq 0x4(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x14(%rbp)
movl $0x0, (%rbx)
cmpl $0xffff, %eax # imm = 0xFFFF
ja 0x7fa3b
movzwl %ax, %esi
movq %r14, %rdi
callq 0x3df42
jmp 0x7fa6a
movq %r14, %rdi
movl $0x2d, %esi
callq 0x270bb
movl $0x0, (%rbx)
movl $0x6, %edx
xorl %eax, %eax
xorl %r13d, %r13d
movl %eax, %eax
orq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $-0x9, %edx
jb 0x7fa1f
movq 0x18(%r14), %rdi
movl (%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r15)
cmpl $0x1, %eax
jg 0x7fa1f
movq %r15, %rsi
callq 0x20d90
movl $0x0, (%rbp)
movq $0x3, 0x8(%rbp)
movl $0x1, (%rbx)
movl $0x3, %edx
jmp 0x7f9e7
movq %r14, %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x20686
testq %rax, %rax
je 0x7fa63
movl 0x18(%r15,%r12,2), %ecx
movl %ecx, 0x18(%rax)
movq $-0x7, %rdx
jmp 0x7fa6a
movl $0x6, %edx
xorl %eax, %eax
andq %rax, %r13
jmp 0x7f9ec
| js_string_iterator_next:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, r9
mov r14, rdi
cmp edx, 0FFFFFFFFh
jnz short loc_7F9CF
cmp word ptr [rsi+6], 2Dh ; '-'
jnz short loc_7F9CF
mov rbp, [rsi+30h]
test rbp, rbp
jz short loc_7F9CF
mov rdx, [rbp+8]
cmp edx, 3
jz loc_7FA2E
mov r15, [rbp+0]
mov r12d, [rbp+14h]
mov [rsp+38h+var_34], r12d
mov eax, 7FFFFFFFh
and eax, [r15+4]
cmp r12d, eax
jnb short loc_7FA00
mov r13, 0FFFFFFFF00000000h
lea rsi, [rsp+38h+var_34]
mov rdi, r15
call string_getc
lea rcx, [rsp+38h+var_34]
mov ecx, [rcx]
mov [rbp+14h], ecx
mov dword ptr [rbx], 0
cmp eax, 0FFFFh
ja short loc_7FA3B
movzx esi, ax
mov rdi, r14
call js_new_string_char
jmp loc_7FA6A
loc_7F9CF:
mov rdi, r14
mov esi, 2Dh ; '-'
call JS_ThrowTypeErrorInvalidClass
mov dword ptr [rbx], 0
mov edx, 6
loc_7F9E7:
xor eax, eax
xor r13d, r13d
loc_7F9EC:
mov eax, eax
or rax, r13
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7FA00:
cmp edx, 0FFFFFFF7h
jb short loc_7FA1F
mov rdi, [r14+18h]
mov eax, [r15]
lea ecx, [rax-1]
mov [r15], ecx
cmp eax, 1
jg short loc_7FA1F
mov rsi, r15
call js_free_value_rt
loc_7FA1F:
mov dword ptr [rbp+0], 0
mov qword ptr [rbp+8], 3
loc_7FA2E:
mov dword ptr [rbx], 1
mov edx, 3
jmp short loc_7F9E7
loc_7FA3B:
mov rdi, r14
mov esi, 2
mov edx, 1
call js_alloc_string
test rax, rax
jz short loc_7FA63
mov ecx, [r15+r12*2+18h]
mov [rax+18h], ecx
mov rdx, 0FFFFFFFFFFFFFFF9h
jmp short loc_7FA6A
loc_7FA63:
mov edx, 6
xor eax, eax
loc_7FA6A:
and r13, rax
jmp loc_7F9EC
| unsigned long long js_string_iterator_next(
long long a1,
long long a2,
int a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11,
long long a12,
long long a13,
_DWORD *a14)
{
long long v14; // rax
long long v16; // rbp
long long v17; // rdx
long long v18; // r15
long long v19; // r12
unsigned int v20; // eax
long long v21; // rax
unsigned long long v22; // r13
long long v24; // rdi
int v25; // eax
long long v26; // rcx
int v27[13]; // [rsp+0h] [rbp-34h] BYREF
v27[0] = HIDWORD(v14);
if ( a3 != -1 || *(_WORD *)(a2 + 6) != 45 || (v16 = *(_QWORD *)(a2 + 48)) == 0 )
{
JS_ThrowTypeErrorInvalidClass(a1, 45, a4, a5, a6, a7, a8, a9, a10, a11);
*a14 = 0;
LABEL_9:
LODWORD(v21) = 0;
v22 = 0LL;
return v22 | (unsigned int)v21;
}
v17 = *(_QWORD *)(v16 + 8);
if ( (_DWORD)v17 == 3 )
{
LABEL_15:
*a14 = 1;
goto LABEL_9;
}
v18 = *(_QWORD *)v16;
v19 = *(unsigned int *)(v16 + 20);
v27[0] = v19;
if ( (unsigned int)v19 >= (*(_DWORD *)(v18 + 4) & 0x7FFFFFFFu) )
{
if ( (unsigned int)v17 >= 0xFFFFFFF7 )
{
v24 = *(_QWORD *)(a1 + 24);
v25 = *(_DWORD *)v18;
v26 = (unsigned int)(*(_DWORD *)v18 - 1);
*(_DWORD *)v18 = v26;
if ( v25 <= 1 )
js_free_value_rt(v24, (_QWORD *)v18, v17, v26, a13, (long long)a14);
}
*(_DWORD *)v16 = 0;
*(_QWORD *)(v16 + 8) = 3LL;
goto LABEL_15;
}
v20 = string_getc(v18, v27);
*(_DWORD *)(v16 + 20) = v27[0];
*a14 = 0;
if ( v20 > 0xFFFF )
{
v21 = js_alloc_string(a1, 2LL, 1u);
if ( v21 )
*(_DWORD *)(v21 + 24) = *(_DWORD *)(v18 + 2 * v19 + 24);
else
v21 = 0LL;
}
else
{
v21 = js_new_string_char(a1, (unsigned __int16)v20);
}
v22 = v21 & 0xFFFFFFFF00000000LL;
return v22 | (unsigned int)v21;
}
| js_string_iterator_next:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,R9
MOV R14,RDI
CMP EDX,-0x1
JNZ 0x0017f9cf
CMP word ptr [RSI + 0x6],0x2d
JNZ 0x0017f9cf
MOV RBP,qword ptr [RSI + 0x30]
TEST RBP,RBP
JZ 0x0017f9cf
MOV RDX,qword ptr [RBP + 0x8]
CMP EDX,0x3
JZ 0x0017fa2e
MOV R15,qword ptr [RBP]
MOV R12D,dword ptr [RBP + 0x14]
MOV dword ptr [RSP + 0x4],R12D
MOV EAX,0x7fffffff
AND EAX,dword ptr [R15 + 0x4]
CMP R12D,EAX
JNC 0x0017fa00
MOV R13,-0x100000000
LEA RSI,[RSP + 0x4]
MOV RDI,R15
CALL 0x0014d7fe
LEA RCX,[RSP + 0x4]
MOV ECX,dword ptr [RCX]
MOV dword ptr [RBP + 0x14],ECX
MOV dword ptr [RBX],0x0
CMP EAX,0xffff
JA 0x0017fa3b
MOVZX ESI,AX
MOV RDI,R14
CALL 0x0013df42
JMP 0x0017fa6a
LAB_0017f9cf:
MOV RDI,R14
MOV ESI,0x2d
CALL 0x001270bb
MOV dword ptr [RBX],0x0
MOV EDX,0x6
LAB_0017f9e7:
XOR EAX,EAX
XOR R13D,R13D
LAB_0017f9ec:
MOV EAX,EAX
OR RAX,R13
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017fa00:
CMP EDX,-0x9
JC 0x0017fa1f
MOV RDI,qword ptr [R14 + 0x18]
MOV EAX,dword ptr [R15]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R15],ECX
CMP EAX,0x1
JG 0x0017fa1f
MOV RSI,R15
CALL 0x00120d90
LAB_0017fa1f:
MOV dword ptr [RBP],0x0
MOV qword ptr [RBP + 0x8],0x3
LAB_0017fa2e:
MOV dword ptr [RBX],0x1
MOV EDX,0x3
JMP 0x0017f9e7
LAB_0017fa3b:
MOV RDI,R14
MOV ESI,0x2
MOV EDX,0x1
CALL 0x00120686
TEST RAX,RAX
JZ 0x0017fa63
MOV ECX,dword ptr [R15 + R12*0x2 + 0x18]
MOV dword ptr [RAX + 0x18],ECX
MOV RDX,-0x7
JMP 0x0017fa6a
LAB_0017fa63:
MOV EDX,0x6
XOR EAX,EAX
LAB_0017fa6a:
AND R13,RAX
JMP 0x0017f9ec
|
ulong js_string_iterator_next
(long param_1,long param_2,int param_3,int8 param_4,int8 param_5,
int4 *param_6)
{
int iVar1;
int8 *puVar2;
int *piVar3;
int8 uVar4;
uint uVar5;
ulong uVar6;
ulong uVar7;
uint local_34;
if (((param_3 == -1) && (*(short *)(param_2 + 6) == 0x2d)) &&
(puVar2 = *(int8 **)(param_2 + 0x30), puVar2 != (int8 *)0x0)) {
if ((uint)puVar2[1] != 3) {
piVar3 = (int *)*puVar2;
local_34 = *(uint *)((long)puVar2 + 0x14);
uVar7 = (ulong)local_34;
if (local_34 < (piVar3[1] & 0x7fffffffU)) {
uVar5 = string_getc(piVar3,&local_34);
*(uint *)((long)puVar2 + 0x14) = local_34;
*param_6 = 0;
if (uVar5 < 0x10000) {
uVar6 = js_new_string_char(param_1,uVar5 & 0xffff);
}
else {
uVar6 = js_alloc_string(param_1,2,1);
if (uVar6 == 0) {
uVar6 = 0;
}
else {
*(int4 *)(uVar6 + 0x18) = *(int4 *)((long)piVar3 + uVar7 * 2 + 0x18);
}
}
uVar7 = uVar6 & 0xffffffff00000000;
goto LAB_0017f9ec;
}
if (0xfffffff6 < (uint)puVar2[1]) {
uVar4 = *(int8 *)(param_1 + 0x18);
iVar1 = *piVar3;
*piVar3 = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(uVar4,piVar3);
}
}
*(int4 *)puVar2 = 0;
puVar2[1] = 3;
}
*param_6 = 1;
}
else {
JS_ThrowTypeErrorInvalidClass(param_1,0x2d);
*param_6 = 0;
}
uVar6 = 0;
uVar7 = 0;
LAB_0017f9ec:
return uVar6 & 0xffffffff | uVar7;
}
| |
41,241 | wait_for_readers | eloqsql/storage/maria/ma_pagecache.c | static inline void wait_for_readers(PAGECACHE *pagecache
__attribute__((unused)),
PAGECACHE_BLOCK_LINK *block
__attribute__((unused)))
{
struct st_my_thread_var *thread= my_thread_var;
DBUG_ASSERT(block->condvar == NULL);
while (block->hash_link->requests)
{
DBUG_ENTER("wait_for_readers");
DBUG_PRINT("wait",
("suspend thread: %s %ld block: %u",
thread->name, (ulong) thread->id,
PCBLOCK_NUMBER(pagecache, block)));
block->condvar= &thread->suspend;
pagecache_pthread_cond_wait(&thread->suspend, &pagecache->cache_lock);
block->condvar= NULL;
DBUG_VOID_RETURN;
}
} | O3 | c | wait_for_readers:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa8ec2
movq 0x20(%rbx), %rcx
cmpl $0x0, 0x68(%rcx)
je 0x73427
movq %rax, %rcx
addq $0x8, %rax
movq %rax, 0x28(%rbx)
addq $0xc8, %r14
cmpq $0x0, 0x38(%rcx)
jne 0x7342c
movq %rax, %rdi
movq %r14, %rsi
callq 0x2a410
movq $0x0, 0x28(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6f7e4(%rip), %rdx # 0xe2c17
movq %rax, %rdi
movq %r14, %rsi
movl $0x64d, %ecx # imm = 0x64D
callq 0x30240
jmp 0x7341f
| wait_for_readers:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
call _my_thread_var
mov rcx, [rbx+20h]
cmp dword ptr [rcx+68h], 0
jz short loc_73427
mov rcx, rax
add rax, 8
mov [rbx+28h], rax
add r14, 0C8h
cmp qword ptr [rcx+38h], 0
jnz short loc_7342C
mov rdi, rax
mov rsi, r14
call _pthread_cond_wait
loc_7341F:
mov qword ptr [rbx+28h], 0
loc_73427:
pop rbx
pop r14
pop rbp
retn
loc_7342C:
lea rdx, aWorkspaceLlm4b_38; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rax
mov rsi, r14
mov ecx, 64Dh
call psi_cond_wait
jmp short loc_7341F
| long long wait_for_readers(long long a1, long long a2)
{
long long result; // rax
long long v3; // rcx
long long v4; // rax
long long v5; // r14
result = my_thread_var(a1);
if ( *(_DWORD *)(*(_QWORD *)(a2 + 32) + 104LL) )
{
v3 = result;
v4 = result + 8;
*(_QWORD *)(a2 + 40) = v4;
v5 = a1 + 200;
if ( *(_QWORD *)(v3 + 56) )
result = psi_cond_wait(
v4,
v5,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0x64Du);
else
result = pthread_cond_wait(v4, v5);
*(_QWORD *)(a2 + 40) = 0LL;
}
return result;
}
| wait_for_readers:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
CALL 0x001a8ec2
MOV RCX,qword ptr [RBX + 0x20]
CMP dword ptr [RCX + 0x68],0x0
JZ 0x00173427
MOV RCX,RAX
ADD RAX,0x8
MOV qword ptr [RBX + 0x28],RAX
ADD R14,0xc8
CMP qword ptr [RCX + 0x38],0x0
JNZ 0x0017342c
MOV RDI,RAX
MOV RSI,R14
CALL 0x0012a410
LAB_0017341f:
MOV qword ptr [RBX + 0x28],0x0
LAB_00173427:
POP RBX
POP R14
POP RBP
RET
LAB_0017342c:
LEA RDX,[0x1e2c17]
MOV RDI,RAX
MOV RSI,R14
MOV ECX,0x64d
CALL 0x00130240
JMP 0x0017341f
|
void wait_for_readers(long param_1,long param_2)
{
long lVar1;
pthread_cond_t *__cond;
lVar1 = _my_thread_var();
if (*(int *)(*(long *)(param_2 + 0x20) + 0x68) != 0) {
__cond = (pthread_cond_t *)(lVar1 + 8);
*(pthread_cond_t **)(param_2 + 0x28) = __cond;
if (*(long *)(lVar1 + 0x38) == 0) {
pthread_cond_wait(__cond,(pthread_mutex_t *)(param_1 + 200));
}
else {
psi_cond_wait(__cond,(pthread_mutex_t *)(param_1 + 200),
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",0x64d);
}
*(int8 *)(param_2 + 0x28) = 0;
}
return;
}
| |
41,242 | ring_buffer<int>::rat(unsigned long) const | monkey531[P]llama/common/sampling.cpp | const T & rat(size_t i) const {
if (i >= sz) {
throw std::runtime_error("ring buffer: index out of bounds");
}
return data[(first + sz - i - 1) % capacity];
} | O2 | cpp | ring_buffer<int>::rat(unsigned long) const:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
cmpq %rsi, %rax
jbe 0x9a83c
notq %rsi
addq %rsi, %rax
addq 0x10(%rdi), %rax
xorl %edx, %edx
divq (%rdi)
leaq (,%rdx,4), %rax
addq 0x20(%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x23470
movq %rax, %rbx
leaq 0x20297(%rip), %rsi # 0xbaae5
movq %rax, %rdi
callq 0x23330
movq 0x6478b(%rip), %rsi # 0xfefe8
movq 0x646e4(%rip), %rdx # 0xfef48
movq %rbx, %rdi
callq 0x23fb0
movq %rax, %r14
movq %rbx, %rdi
callq 0x23690
movq %r14, %rdi
callq 0x24030
nop
| _ZNK11ring_bufferIiE3ratEm:
push r14
push rbx
push rax
mov rax, [rdi+8]
cmp rax, rsi
jbe short loc_9A83C
not rsi
add rax, rsi
add rax, [rdi+10h]
xor edx, edx
div qword ptr [rdi]
lea rax, ds:0[rdx*4]
add rax, [rdi+20h]
add rsp, 8
pop rbx
pop r14
retn
loc_9A83C:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aRingBufferInde; "ring buffer: index out of bounds"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
mov rdi, r14
call __Unwind_Resume
| long long ring_buffer<int>::rat(_QWORD *a1, unsigned long long a2)
{
unsigned long long v2; // rax
std::runtime_error *exception; // rbx
v2 = a1[1];
if ( v2 <= a2 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "ring buffer: index out of bounds");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return a1[4] + 4 * ((a1[2] + ~a2 + v2) % *a1);
}
| rat:
PUSH R14
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RDI + 0x8]
CMP RAX,RSI
JBE 0x0019a83c
NOT RSI
ADD RAX,RSI
ADD RAX,qword ptr [RDI + 0x10]
XOR EDX,EDX
DIV qword ptr [RDI]
LEA RAX,[RDX*0x4]
ADD RAX,qword ptr [RDI + 0x20]
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_0019a83c:
PUSH 0x10
POP RDI
CALL 0x00123470
MOV RBX,RAX
LAB_0019a847:
LEA RSI,[0x1baae5]
MOV RDI,RAX
CALL 0x00123330
LAB_0019a856:
MOV RSI,qword ptr [0x001fefe8]
MOV RDX,qword ptr [0x001fef48]
MOV RDI,RBX
CALL 0x00123fb0
|
/* ring_buffer<int>::rat(unsigned long) const */
long __thiscall ring_buffer<int>::rat(ring_buffer<int> *this,ulong param_1)
{
runtime_error *this_00;
if (param_1 < *(ulong *)(this + 8)) {
return ((*(ulong *)(this + 8) + ~param_1 + *(long *)(this + 0x10)) % *(ulong *)this) * 4 +
*(long *)(this + 0x20);
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0019a847 to 0019a855 has its CatchHandler @ 0019a86c */
std::runtime_error::runtime_error(this_00,"ring buffer: index out of bounds");
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_001fefe8,PTR__runtime_error_001fef48);
}
| |
41,243 | ma_bitmap_create_missing | eloqsql/storage/maria/ma_bitmap.c | static my_bool _ma_bitmap_create_missing(MARIA_HA *info,
MARIA_FILE_BITMAP *bitmap,
pgcache_page_no_t page)
{
MARIA_SHARE *share= info->s;
uint block_size= bitmap->block_size;
pgcache_page_no_t from, to;
my_off_t data_file_length= share->state.state.data_file_length;
DBUG_ENTER("_ma_bitmap_create_missing");
DBUG_PRINT("enter", ("page: %lld", (longlong) page));
/* First (in offset order) bitmap page to create */
if (data_file_length < block_size)
goto err; /* corrupted, should have first bitmap page */
if (page * block_size >= share->base.max_data_file_length)
{
my_errno= HA_ERR_RECORD_FILE_FULL;
goto err;
}
from= (data_file_length / block_size - 1) / bitmap->pages_covered + 1;
from*= bitmap->pages_covered;
/*
page>=from because:
(page + 1) * bs > dfl, and page == k * pc so:
(k * pc + 1) * bs > dfl; k * pc + 1 > dfl / bs; k * pc > dfl / bs - 1
k > (dfl / bs - 1) / pc; k >= (dfl / bs - 1) / pc + 1
k * pc >= ((dfl / bs - 1) / pc + 1) * pc == from.
*/
DBUG_ASSERT(page >= from);
if (share->now_transactional)
{
LSN lsn;
uchar log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE * 2];
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 1];
page_store(log_data + FILEID_STORE_SIZE, from);
page_store(log_data + FILEID_STORE_SIZE + PAGE_STORE_SIZE, page);
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= sizeof(log_data);
/*
We don't use info->trn so that this REDO is always executed even though
the UNDO does not reach disk due to crash. This is also consistent with
the fact that the new bitmap pages are not pinned.
*/
if (translog_write_record(&lsn, LOGREC_REDO_BITMAP_NEW_PAGE,
&dummy_transaction_object, info,
(translog_size_t)sizeof(log_data),
TRANSLOG_INTERNAL_PARTS + 1, log_array,
log_data, NULL))
goto err;
/*
No need to flush the log: the bitmap pages we are going to create will
flush it when they go to disk.
*/
}
/*
Last bitmap page. It has special creation: will go to the page cache
only later as we are going to modify it very soon.
*/
bzero(bitmap->map, bitmap->block_size);
bitmap->used_size= bitmap->full_head_size= bitmap->full_tail_size= 0;
bitmap->changed=1;
#ifndef DBUG_OFF
/*
Make a copy of the page to be able to print out bitmap changes during
debugging
*/
memcpy(bitmap->map + bitmap->block_size, bitmap->map, bitmap->block_size);
#endif
/* Last bitmap page to create before 'page' */
DBUG_ASSERT(page >= bitmap->pages_covered);
to= page - bitmap->pages_covered;
/*
In run-time situations, from>=to is always false, i.e. we always create
one bitmap at a time ('page').
*/
if ((from <= to) &&
_ma_bitmap_create_missing_into_pagecache(share, bitmap, from, to,
bitmap->map))
goto err;
share->state.state.data_file_length= (page + 1) * bitmap->block_size;
DBUG_RETURN(FALSE);
err:
DBUG_RETURN(TRUE);
} | O0 | c | ma_bitmap_create_missing:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movl 0x134(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x58(%rbp)
jmp 0x64f5a
movq -0x58(%rbp), %rax
movl -0x3c(%rbp), %ecx
cmpq %rcx, %rax
jae 0x64f6b
jmp 0x65159
movq -0x30(%rbp), %rax
movl -0x3c(%rbp), %ecx
imulq %rcx, %rax
movq -0x38(%rbp), %rcx
cmpq 0x368(%rcx), %rax
jb 0x64f93
callq 0xfdd30
movl $0x87, (%rax)
jmp 0x65159
movq -0x58(%rbp), %rax
movl -0x3c(%rbp), %ecx
xorl %edx, %edx
divq %rcx
subq $0x1, %rax
movq -0x28(%rbp), %rcx
xorl %edx, %edx
divq 0x138(%rcx)
addq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq 0x138(%rax), %rax
imulq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x64fce
movq -0x38(%rbp), %rax
cmpb $0x0, 0x7e7(%rax)
je 0x650ab
jmp 0x64fe1
leaq -0x14(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x98(%rbp)
movq -0x48(%rbp), %rax
movl %eax, %ecx
movq -0x98(%rbp), %rax
movl %ecx, (%rax)
movq -0x48(%rbp), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0x98(%rbp), %rax
movb %cl, 0x4(%rax)
jmp 0x65015
leaq -0x14(%rbp), %rax
addq $0x2, %rax
addq $0x5, %rax
movq %rax, -0xa0(%rbp)
movq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0xa0(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0xa0(%rbp), %rax
movb %cl, 0x4(%rax)
leaq -0x14(%rbp), %rax
movq %rax, -0x70(%rbp)
movq $0xc, -0x68(%rbp)
movq -0x20(%rbp), %rcx
leaq -0x90(%rbp), %r10
leaq -0x14(%rbp), %rax
leaq -0x60(%rbp), %rdi
movl $0x28, %esi
leaq 0x41dcf6(%rip), %rdx # 0x482d70
movl $0xc, %r8d
movl $0x3, %r9d
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0x90c10
cmpb $0x0, %al
je 0x650a9
jmp 0x65159
jmp 0x650ab
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rax
movl 0x134(%rax), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x29280
movq -0x28(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x28(%rbp), %rax
movb $0x1, 0x20(%rax)
jmp 0x650f1
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
subq 0x138(%rcx), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x50(%rbp), %rax
ja 0x65135
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %r8
callq 0x63bb0
movsbl %al, %eax
cmpl $0x0, %eax
je 0x65135
jmp 0x65159
movq -0x30(%rbp), %rcx
addq $0x1, %rcx
movq -0x28(%rbp), %rax
movl 0x134(%rax), %eax
imulq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x40(%rax)
movb $0x0, -0x15(%rbp)
jmp 0x6515f
jmp 0x6515b
movb $0x1, -0x15(%rbp)
movb -0x15(%rbp), %al
movb %al, -0xa1(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x65189
movb -0xa1(%rbp), %al
addq $0xc0, %rsp
popq %rbp
retq
callq 0x29230
nop
| _ma_bitmap_create_missing:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_20], rdi
mov [rbp+var_28], rsi
mov [rbp+var_30], rdx
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
mov eax, [rax+134h]
mov [rbp+var_3C], eax
mov rax, [rbp+var_38]
mov rax, [rax+40h]
mov [rbp+var_58], rax
jmp short $+2
loc_64F5A:
mov rax, [rbp+var_58]
mov ecx, [rbp+var_3C]
cmp rax, rcx
jnb short loc_64F6B
jmp loc_65159
loc_64F6B:
mov rax, [rbp+var_30]
mov ecx, [rbp+var_3C]
imul rax, rcx
mov rcx, [rbp+var_38]
cmp rax, [rcx+368h]
jb short loc_64F93
call _my_thread_var
mov dword ptr [rax], 87h
jmp loc_65159
loc_64F93:
mov rax, [rbp+var_58]
mov ecx, [rbp+var_3C]
xor edx, edx
div rcx
sub rax, 1
mov rcx, [rbp+var_28]
xor edx, edx
div qword ptr [rcx+138h]
add rax, 1
mov [rbp+var_48], rax
mov rax, [rbp+var_28]
mov rax, [rax+138h]
imul rax, [rbp+var_48]
mov [rbp+var_48], rax
jmp short $+2
loc_64FCE:
mov rax, [rbp+var_38]
cmp byte ptr [rax+7E7h], 0
jz loc_650AB
jmp short $+2
loc_64FE1:
lea rax, [rbp+var_14]
add rax, 2
mov [rbp+var_98], rax
mov rax, [rbp+var_48]
mov ecx, eax
mov rax, [rbp+var_98]
mov [rax], ecx
mov rax, [rbp+var_48]
shr rax, 20h
mov cl, al
mov rax, [rbp+var_98]
mov [rax+4], cl
jmp short $+2
loc_65015:
lea rax, [rbp+var_14]
add rax, 2
add rax, 5
mov [rbp+var_A0], rax
mov rax, [rbp+var_30]
mov ecx, eax
mov rax, [rbp+var_A0]
mov [rax], ecx
mov rax, [rbp+var_30]
shr rax, 20h
mov cl, al
mov rax, [rbp+var_A0]
mov [rax+4], cl
lea rax, [rbp+var_14]
mov [rbp+var_70], rax
mov [rbp+var_68], 0Ch
mov rcx, [rbp+var_20]
lea r10, [rbp+var_90]
lea rax, [rbp+var_14]
lea rdi, [rbp+var_60]
mov esi, 28h ; '('
lea rdx, dummy_transaction_object
mov r8d, 0Ch
mov r9d, 3
xor r11d, r11d
mov [rsp+0C0h+var_C0], r10
mov [rsp+0C0h+var_B8], rax
mov [rsp+0C0h+var_B0], 0
call translog_write_record
cmp al, 0
jz short loc_650A9
jmp loc_65159
loc_650A9:
jmp short $+2
loc_650AB:
mov rax, [rbp+var_28]
mov rdi, [rax+8]
mov rax, [rbp+var_28]
mov eax, [rax+134h]
mov edx, eax
xor esi, esi
call _memset
mov rax, [rbp+var_28]
mov dword ptr [rax+2Ch], 0
mov rax, [rbp+var_28]
mov dword ptr [rax+28h], 0
mov rax, [rbp+var_28]
mov dword ptr [rax+24h], 0
mov rax, [rbp+var_28]
mov byte ptr [rax+20h], 1
jmp short $+2
loc_650F1:
mov rax, [rbp+var_30]
mov rcx, [rbp+var_28]
sub rax, [rcx+138h]
mov [rbp+var_50], rax
mov rax, [rbp+var_48]
cmp rax, [rbp+var_50]
ja short loc_65135
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_48]
mov rcx, [rbp+var_50]
mov rax, [rbp+var_28]
mov r8, [rax+8]
call _ma_bitmap_create_missing_into_pagecache
movsx eax, al
cmp eax, 0
jz short loc_65135
jmp short loc_65159
loc_65135:
mov rcx, [rbp+var_30]
add rcx, 1
mov rax, [rbp+var_28]
mov eax, [rax+134h]
imul rcx, rax
mov rax, [rbp+var_38]
mov [rax+40h], rcx
mov [rbp+var_15], 0
jmp short loc_6515F
loc_65159:
jmp short $+2
loc_6515B:
mov [rbp+var_15], 1
loc_6515F:
mov al, [rbp+var_15]
mov [rbp+var_A1], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_65189
mov al, [rbp+var_A1]
add rsp, 0C0h
pop rbp
retn
loc_65189:
call ___stack_chk_fail
| char ma_bitmap_create_missing(long long *a1, long long a2, long long a3)
{
_BYTE v4[32]; // [rsp+30h] [rbp-90h] BYREF
_BYTE *v5; // [rsp+50h] [rbp-70h]
long long v6; // [rsp+58h] [rbp-68h]
char v7; // [rsp+60h] [rbp-60h] BYREF
unsigned long long v8; // [rsp+68h] [rbp-58h]
unsigned long long v9; // [rsp+70h] [rbp-50h]
unsigned long long v10; // [rsp+78h] [rbp-48h]
unsigned int v11; // [rsp+84h] [rbp-3Ch]
long long v12; // [rsp+88h] [rbp-38h]
long long v13; // [rsp+90h] [rbp-30h]
long long v14; // [rsp+98h] [rbp-28h]
long long *v15; // [rsp+A0h] [rbp-20h]
_BYTE v17[2]; // [rsp+ACh] [rbp-14h] BYREF
int v18; // [rsp+AEh] [rbp-12h]
char v19; // [rsp+B2h] [rbp-Eh]
int v20; // [rsp+B3h] [rbp-Dh]
char v21; // [rsp+B7h] [rbp-9h]
unsigned long long v22; // [rsp+B8h] [rbp-8h]
v22 = __readfsqword(0x28u);
v15 = a1;
v14 = a2;
v13 = a3;
v12 = *a1;
v11 = *(_DWORD *)(a2 + 308);
v8 = *(_QWORD *)(v12 + 64);
if ( v8 < v11 )
return 1;
if ( (unsigned long long)v11 * v13 >= *(_QWORD *)(v12 + 872) )
{
*(_DWORD *)my_thread_var(a1, (const char *)a2) = 135;
return 1;
}
v10 = ((v8 / v11 - 1) / *(_QWORD *)(v14 + 312) + 1) * *(_QWORD *)(v14 + 312);
if ( *(_BYTE *)(v12 + 2023) )
{
v18 = v10;
v19 = BYTE4(v10);
v20 = v13;
v21 = BYTE4(v13);
v5 = v17;
v6 = 12LL;
if ( (unsigned __int8)translog_write_record(
(unsigned int)&v7,
40,
(unsigned int)&dummy_transaction_object,
(_DWORD)v15,
12,
3,
(long long)v4,
(long long)v17,
0LL) )
return 1;
}
memset(*(_QWORD *)(v14 + 8), 0LL, *(unsigned int *)(v14 + 308));
*(_DWORD *)(v14 + 44) = 0;
*(_DWORD *)(v14 + 40) = 0;
*(_DWORD *)(v14 + 36) = 0;
*(_BYTE *)(v14 + 32) = 1;
v9 = v13 - *(_QWORD *)(v14 + 312);
if ( v10 <= v9 )
{
if ( ma_bitmap_create_missing_into_pagecache(v12, v14, v10, v9, *(_QWORD *)(v14 + 8)) )
return 1;
}
*(_QWORD *)(v12 + 64) = *(unsigned int *)(v14 + 308) * (v13 + 1);
return 0;
}
| _ma_bitmap_create_missing:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x20],RDI
MOV qword ptr [RBP + -0x28],RSI
MOV qword ptr [RBP + -0x30],RDX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX + 0x134]
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x40]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x00164f5a
LAB_00164f5a:
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RBP + -0x3c]
CMP RAX,RCX
JNC 0x00164f6b
JMP 0x00165159
LAB_00164f6b:
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RBP + -0x3c]
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RCX + 0x368]
JC 0x00164f93
CALL 0x001fdd30
MOV dword ptr [RAX],0x87
JMP 0x00165159
LAB_00164f93:
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RBP + -0x3c]
XOR EDX,EDX
DIV RCX
SUB RAX,0x1
MOV RCX,qword ptr [RBP + -0x28]
XOR EDX,EDX
DIV qword ptr [RCX + 0x138]
ADD RAX,0x1
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x138]
IMUL RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x00164fce
LAB_00164fce:
MOV RAX,qword ptr [RBP + -0x38]
CMP byte ptr [RAX + 0x7e7],0x0
JZ 0x001650ab
JMP 0x00164fe1
LAB_00164fe1:
LEA RAX,[RBP + -0x14]
ADD RAX,0x2
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x98]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x48]
SHR RAX,0x20
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x98]
MOV byte ptr [RAX + 0x4],CL
JMP 0x00165015
LAB_00165015:
LEA RAX,[RBP + -0x14]
ADD RAX,0x2
ADD RAX,0x5
MOV qword ptr [RBP + -0xa0],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0xa0]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x30]
SHR RAX,0x20
MOV CL,AL
MOV RAX,qword ptr [RBP + -0xa0]
MOV byte ptr [RAX + 0x4],CL
LEA RAX,[RBP + -0x14]
MOV qword ptr [RBP + -0x70],RAX
MOV qword ptr [RBP + -0x68],0xc
MOV RCX,qword ptr [RBP + -0x20]
LEA R10,[RBP + -0x90]
LEA RAX,[RBP + -0x14]
LEA RDI,[RBP + -0x60]
MOV ESI,0x28
LEA RDX,[0x582d70]
MOV R8D,0xc
MOV R9D,0x3
XOR R11D,R11D
MOV qword ptr [RSP],R10
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],0x0
CALL 0x00190c10
CMP AL,0x0
JZ 0x001650a9
JMP 0x00165159
LAB_001650a9:
JMP 0x001650ab
LAB_001650ab:
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX + 0x134]
MOV EDX,EAX
XOR ESI,ESI
CALL 0x00129280
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x2c],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x28],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x24],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x20],0x1
JMP 0x001650f1
LAB_001650f1:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,qword ptr [RCX + 0x138]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x48]
CMP RAX,qword ptr [RBP + -0x50]
JA 0x00165135
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RAX + 0x8]
CALL 0x00163bb0
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x00165135
JMP 0x00165159
LAB_00165135:
MOV RCX,qword ptr [RBP + -0x30]
ADD RCX,0x1
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX + 0x134]
IMUL RCX,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x40],RCX
MOV byte ptr [RBP + -0x15],0x0
JMP 0x0016515f
LAB_00165159:
JMP 0x0016515b
LAB_0016515b:
MOV byte ptr [RBP + -0x15],0x1
LAB_0016515f:
MOV AL,byte ptr [RBP + -0x15]
MOV byte ptr [RBP + -0xa1],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00165189
MOV AL,byte ptr [RBP + -0xa1]
ADD RSP,0xc0
POP RBP
RET
LAB_00165189:
CALL 0x00129230
|
int8 _ma_bitmap_create_missing(long *param_1,long param_2,long param_3)
{
char cVar1;
int4 *puVar2;
long in_FS_OFFSET;
int1 local_98 [32];
int1 *local_78;
int8 local_70;
int1 local_68 [8];
ulong local_60;
ulong local_58;
ulong local_50;
uint local_44;
long local_40;
long local_38;
long local_30;
long *local_28;
int1 local_1d;
int1 local_1c [2];
int4 local_1a;
int1 local_16;
int4 local_15;
int1 local_11;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_40 = *param_1;
local_44 = *(uint *)(param_2 + 0x134);
local_60 = *(ulong *)(local_40 + 0x40);
local_38 = param_3;
local_30 = param_2;
local_28 = param_1;
if (local_44 <= local_60) {
if (param_3 * (ulong)local_44 < *(ulong *)(local_40 + 0x368)) {
local_50 = *(long *)(param_2 + 0x138) *
((local_60 / local_44 - 1) / *(ulong *)(param_2 + 0x138) + 1);
if (*(char *)(local_40 + 0x7e7) != '\0') {
local_1a = (int4)local_50;
local_16 = (int1)(local_50 >> 0x20);
local_15 = (int4)param_3;
local_11 = (int1)((ulong)param_3 >> 0x20);
local_78 = local_1c;
local_70 = 0xc;
cVar1 = translog_write_record
(local_68,0x28,dummy_transaction_object,param_1,0xc,3,local_98,local_1c,0)
;
if (cVar1 != '\0') goto LAB_00165159;
}
memset(*(void **)(local_30 + 8),0,(ulong)*(uint *)(local_30 + 0x134));
*(int4 *)(local_30 + 0x2c) = 0;
*(int4 *)(local_30 + 0x28) = 0;
*(int4 *)(local_30 + 0x24) = 0;
*(int1 *)(local_30 + 0x20) = 1;
local_58 = local_38 - *(long *)(local_30 + 0x138);
if ((local_58 < local_50) ||
(cVar1 = _ma_bitmap_create_missing_into_pagecache
(local_40,local_30,local_50,local_58,*(int8 *)(local_30 + 8)),
cVar1 == '\0')) {
*(ulong *)(local_40 + 0x40) = (local_38 + 1) * (ulong)*(uint *)(local_30 + 0x134);
local_1d = 0;
goto LAB_0016515f;
}
}
else {
puVar2 = (int4 *)_my_thread_var();
*puVar2 = 0x87;
}
}
LAB_00165159:
local_1d = 1;
LAB_0016515f:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),local_1d);
}
| |
41,244 | mysql_stmt_close_start | eloqsql/libmariadb/libmariadb/mariadb_async.c | int STDCALL
mysql_stmt_close_start(my_bool *ret, MYSQL_STMT *stmt)
{
MK_ASYNC_START_BODY(
mysql_stmt_close,
stmt->mysql,
{
WIN_SET_NONBLOCKING(stmt->mysql)
parms.stmt= stmt;
},
TRUE,
r_my_bool,
/* If stmt->mysql==NULL then we will not block so can call directly. */
if (!stmt->mysql)
{
*ret= mysql_stmt_close(stmt);
return 0;
})
} | O0 | c | mysql_stmt_close_start:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x41718
movq -0x18(%rbp), %rdi
callq 0x2d7b0
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x41826
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movb $0x1, 0x14(%rax)
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
leaq 0xe2(%rip), %rsi # 0x41830
leaq -0x30(%rbp), %rdx
callq 0x43410
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movb $0x0, 0x15(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0x14(%rax)
cmpl $0x0, -0x1c(%rbp)
jle 0x41786
movq -0x28(%rbp), %rax
movb $0x1, 0x15(%rax)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x41826
cmpl $0x0, -0x1c(%rbp)
jge 0x41812
jmp 0x41792
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x23a76(%rip), %rax # 0x65230
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13210
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movb $0x0, 0x29c(%rax)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
addq $0x97, %rdi
leaq 0x23a54(%rip), %rax # 0x65240
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13210
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movb $0x0, 0x296(%rax)
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
jmp 0x4181f
movq -0x28(%rbp), %rax
movb 0x8(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
| mysql_stmt_close_start:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_18]
cmp qword ptr [rax+38h], 0
jnz short loc_41718
mov rdi, [rbp+var_18]
call mysql_stmt_close
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
mov [rbp+var_4], 0
jmp loc_41826
loc_41718:
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
mov rax, [rbp+var_28]
mov byte ptr [rax+14h], 1
mov rdi, [rbp+var_28]
add rdi, 38h ; '8'
lea rsi, mysql_stmt_close_start_internal
lea rdx, [rbp+var_30]
call my_context_spawn
mov [rbp+var_1C], eax
mov rax, [rbp+var_28]
mov byte ptr [rax+15h], 0
mov rax, [rbp+var_28]
mov byte ptr [rax+14h], 0
cmp [rbp+var_1C], 0
jle short loc_41786
mov rax, [rbp+var_28]
mov byte ptr [rax+15h], 1
mov rax, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_4], eax
jmp loc_41826
loc_41786:
cmp [rbp+var_1C], 0
jge loc_41812
jmp short $+2
loc_41792:
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov dword ptr [rax+90h], 7D8h
mov rax, [rbp+var_18]
mov rdi, [rax+38h]
add rdi, 297h
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov byte ptr [rax+29Ch], 0
mov rax, [rbp+var_18]
mov rdi, [rax+38h]
add rdi, 97h
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov byte ptr [rax+296h], 0
mov rax, [rbp+var_10]
mov byte ptr [rax], 1
jmp short loc_4181F
loc_41812:
mov rax, [rbp+var_28]
mov cl, [rax+8]
mov rax, [rbp+var_10]
mov [rax], cl
loc_4181F:
mov [rbp+var_4], 0
loc_41826:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long mysql_stmt_close_start(char *a1, long long a2)
{
long long v3; // [rsp+0h] [rbp-30h] BYREF
_BYTE *v4; // [rsp+8h] [rbp-28h]
int v5; // [rsp+14h] [rbp-1Ch]
long long v6; // [rsp+18h] [rbp-18h]
char *v7; // [rsp+20h] [rbp-10h]
v7 = a1;
v6 = a2;
if ( *(_QWORD *)(a2 + 56) )
{
v4 = *(_BYTE **)(*(_QWORD *)(*(_QWORD *)(v6 + 56) + 1152LL) + 40LL);
v3 = v6;
v4[20] = 1;
v5 = my_context_spawn(v4 + 56, mysql_stmt_close_start_internal, &v3);
v4[21] = 0;
v4[20] = 0;
if ( v5 <= 0 )
{
if ( v5 >= 0 )
{
*v7 = v4[8];
}
else
{
*(_DWORD *)(*(_QWORD *)(v6 + 56) + 144LL) = 2008;
strncpy(*(_QWORD *)(v6 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(*(_QWORD *)(v6 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(v6 + 56) + 151LL, client_errors[8], 511LL);
*(_BYTE *)(*(_QWORD *)(v6 + 56) + 662LL) = 0;
*v7 = 1;
}
return 0;
}
else
{
v4[21] = 1;
return *(unsigned int *)v4;
}
}
else
{
*v7 = mysql_stmt_close(v6);
return 0;
}
}
| mysql_stmt_close_start:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x38],0x0
JNZ 0x00141718
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0012d7b0
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00141826
LAB_00141718:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x14],0x1
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x38
LEA RSI,[0x141830]
LEA RDX,[RBP + -0x30]
CALL 0x00143410
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x15],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x14],0x0
CMP dword ptr [RBP + -0x1c],0x0
JLE 0x00141786
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x15],0x1
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00141826
LAB_00141786:
CMP dword ptr [RBP + -0x1c],0x0
JGE 0x00141812
JMP 0x00141792
LAB_00141792:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV dword ptr [RAX + 0x90],0x7d8
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x38]
ADD RDI,0x297
LEA RAX,[0x165230]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV byte ptr [RAX + 0x29c],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x38]
ADD RDI,0x97
LEA RAX,[0x165240]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV byte ptr [RAX + 0x296],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],0x1
JMP 0x0014181f
LAB_00141812:
MOV RAX,qword ptr [RBP + -0x28]
MOV CL,byte ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
LAB_0014181f:
MOV dword ptr [RBP + -0x4],0x0
LAB_00141826:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 mysql_stmt_close_start(int1 *param_1,long param_2)
{
int1 uVar1;
long local_38;
int4 *local_30;
int local_24;
long local_20;
int1 *local_18;
int4 local_c;
local_20 = param_2;
local_18 = param_1;
if (*(long *)(param_2 + 0x38) == 0) {
uVar1 = mysql_stmt_close(param_2);
*local_18 = uVar1;
local_c = 0;
}
else {
local_30 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x38) + 0x480) + 0x28);
*(int1 *)(local_30 + 5) = 1;
local_38 = param_2;
local_24 = my_context_spawn(local_30 + 0xe,mysql_stmt_close_start_internal,&local_38);
*(int1 *)((long)local_30 + 0x15) = 0;
*(int1 *)(local_30 + 5) = 0;
if (local_24 < 1) {
if (local_24 < 0) {
*(int4 *)(*(long *)(local_20 + 0x38) + 0x90) = 0x7d8;
strncpy((char *)(*(long *)(local_20 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(*(long *)(local_20 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(local_20 + 0x38) + 0x97),PTR_s_Client_run_out_of_memory_00165280,
0x1ff);
*(int1 *)(*(long *)(local_20 + 0x38) + 0x296) = 0;
*local_18 = 1;
}
else {
*local_18 = *(int1 *)(local_30 + 2);
}
local_c = 0;
}
else {
*(int1 *)((long)local_30 + 0x15) = 1;
local_c = *local_30;
}
}
return local_c;
}
| |
41,245 | OpenSubdiv::v3_6_0::Vtr::internal::(anonymous namespace)::DynamicRelation::DynamicRelation(std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, int) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/vtr/level.cpp | inline
DynamicRelation::DynamicRelation(IndexVector& countAndOffsets, IndexVector& indices, int membersPerComp) :
_compCount(0),
_memberCountPerComp(membersPerComp),
_countsAndOffsets(countAndOffsets),
_regIndices(indices) {
_compCount = (int) _countsAndOffsets.size() / 2;
for (int i = 0; i < _compCount; ++i) {
_countsAndOffsets[2*i] = 0;
_countsAndOffsets[2*i+1] = i * _memberCountPerComp;
}
_regIndices.resize(_compCount * _memberCountPerComp);
} | O2 | cpp | OpenSubdiv::v3_6_0::Vtr::internal::(anonymous namespace)::DynamicRelation::DynamicRelation(std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, int):
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r8
movq %rdi, %rbx
movl %ecx, 0x4(%rdi)
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
leaq 0x20(%rdi), %rax
andl $0x0, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movq %rax, 0x38(%rdi)
andq $0x0, 0x40(%rdi)
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
subq %rcx, %rax
shrq $0x2, %rax
pushq $0x2
popq %rsi
cltd
idivl %esi
movl %eax, (%rdi)
xorl %edx, %edx
cltq
cmpq %rax, %rdx
jge 0x5d3f1
andl $0x0, (%rcx,%rdx,8)
movl 0x4(%rbx), %eax
imull %edx, %eax
movl %eax, 0x4(%rcx,%rdx,8)
incq %rdx
movl (%rbx), %eax
jmp 0x5d3d5
movslq 0x4(%rbx), %rsi
imulq %rax, %rsi
movq %r8, %rdi
callq 0x514b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x52320
movq %r14, %rdi
callq 0x55300
| _ZN10OpenSubdiv6v3_6_03Vtr8internal12_GLOBAL__N_115DynamicRelationC2ERSt6vectorIiSaIiEES8_i:
push r14
push rbx
push rax
mov r8, rdx
mov rbx, rdi
mov [rdi+4], ecx
mov [rdi+8], rsi
mov [rdi+10h], rdx
lea rax, [rdi+20h]
and dword ptr [rdi+20h], 0
and qword ptr [rdi+28h], 0
mov [rdi+30h], rax
mov [rdi+38h], rax
and qword ptr [rdi+40h], 0
mov rcx, [rsi]
mov rax, [rsi+8]
sub rax, rcx
shr rax, 2
push 2
pop rsi
cdq
idiv esi
mov [rdi], eax
xor edx, edx
loc_5D3D5:
cdqe
cmp rdx, rax
jge short loc_5D3F1
and dword ptr [rcx+rdx*8], 0
mov eax, [rbx+4]
imul eax, edx
mov [rcx+rdx*8+4], eax
inc rdx
mov eax, [rbx]
jmp short loc_5D3D5
loc_5D3F1:
movsxd rsi, dword ptr [rbx+4]
imul rsi, rax
mov rdi, r8
call __ZNSt6vectorIiSaIiEE6resizeEm; std::vector<int>::resize(ulong)
add rsp, 8
pop rbx
pop r14
retn
mov r14, rax
add rbx, 18h
mov rdi, rbx
call __ZNSt8_Rb_treeIiSt4pairIKiSt6vectorIiSaIiEEESt10_Select1stIS5_ESt4lessIiESaIS5_EED2Ev; std::_Rb_tree<int,std::pair<int const,std::vector<int>>,std::_Select1st<std::pair<int const,std::vector<int>>>,std::less<int>,std::allocator<std::pair<int const,std::vector<int>>>>::~_Rb_tree()
mov rdi, r14
call __Unwind_Resume
| long long OpenSubdiv::v3_6_0::Vtr::internal::`anonymous namespace'::DynamicRelation::DynamicRelation(
long long a1,
long long *a2,
long long a3,
int a4)
{
long long v5; // rcx
int v6; // eax
long long i; // rdx
*(_DWORD *)(a1 + 4) = a4;
*(_QWORD *)(a1 + 8) = a2;
*(_QWORD *)(a1 + 16) = a3;
*(_DWORD *)(a1 + 32) = 0;
*(_QWORD *)(a1 + 40) = 0LL;
*(_QWORD *)(a1 + 48) = a1 + 32;
*(_QWORD *)(a1 + 56) = a1 + 32;
*(_QWORD *)(a1 + 64) = 0LL;
v5 = *a2;
v6 = (int)((unsigned long long)(a2[1] - *a2) >> 2) / 2;
*(_DWORD *)a1 = v6;
for ( i = 0LL; i < v6; ++i )
{
*(_DWORD *)(v5 + 8 * i) = 0;
*(_DWORD *)(v5 + 8 * i + 4) = i * *(_DWORD *)(a1 + 4);
v6 = *(_DWORD *)a1;
}
return std::vector<int>::resize(a3, v6 * (long long)*(int *)(a1 + 4));
}
| DynamicRelation:
PUSH R14
PUSH RBX
PUSH RAX
MOV R8,RDX
MOV RBX,RDI
MOV dword ptr [RDI + 0x4],ECX
MOV qword ptr [RDI + 0x8],RSI
MOV qword ptr [RDI + 0x10],RDX
LEA RAX,[RDI + 0x20]
AND dword ptr [RDI + 0x20],0x0
AND qword ptr [RDI + 0x28],0x0
MOV qword ptr [RDI + 0x30],RAX
MOV qword ptr [RDI + 0x38],RAX
AND qword ptr [RDI + 0x40],0x0
MOV RCX,qword ptr [RSI]
MOV RAX,qword ptr [RSI + 0x8]
SUB RAX,RCX
SHR RAX,0x2
PUSH 0x2
POP RSI
CDQ
IDIV ESI
MOV dword ptr [RDI],EAX
XOR EDX,EDX
LAB_0015d3d5:
CDQE
CMP RDX,RAX
JGE 0x0015d3f1
AND dword ptr [RCX + RDX*0x8],0x0
MOV EAX,dword ptr [RBX + 0x4]
IMUL EAX,EDX
MOV dword ptr [RCX + RDX*0x8 + 0x4],EAX
INC RDX
MOV EAX,dword ptr [RBX]
JMP 0x0015d3d5
LAB_0015d3f1:
MOVSXD RSI,dword ptr [RBX + 0x4]
IMUL RSI,RAX
LAB_0015d3f9:
MOV RDI,R8
CALL 0x001514b0
LAB_0015d401:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* OpenSubdiv::v3_6_0::Vtr::internal::(anonymous
namespace)::DynamicRelation::DynamicRelation(std::vector<int, std::allocator<int> >&,
std::vector<int, std::allocator<int> >&, int) */
void __thiscall
OpenSubdiv::v3_6_0::Vtr::internal::(anonymous_namespace)::DynamicRelation::DynamicRelation
(DynamicRelation *this,vector *param_1,vector *param_2,int param_3)
{
long lVar1;
ulong uVar2;
ulong uVar3;
long lVar4;
*(int *)(this + 4) = param_3;
*(vector **)(this + 8) = param_1;
*(vector **)(this + 0x10) = param_2;
*(int4 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(DynamicRelation **)(this + 0x30) = this + 0x20;
*(DynamicRelation **)(this + 0x38) = this + 0x20;
*(int8 *)(this + 0x40) = 0;
lVar1 = *(long *)param_1;
uVar2 = (ulong)(*(long *)(param_1 + 8) - lVar1) >> 2;
uVar2 = (long)((ulong)(uint)((int)uVar2 >> 0x1f) << 0x20 | uVar2 & 0xffffffff) / 2;
uVar3 = uVar2 & 0xffffffff;
*(int *)this = (int)uVar2;
for (lVar4 = 0; lVar4 < (int)uVar3; lVar4 = lVar4 + 1) {
*(int4 *)(lVar1 + lVar4 * 8) = 0;
*(int *)(lVar1 + 4 + lVar4 * 8) = *(int *)(this + 4) * (int)lVar4;
uVar3 = (ulong)*(uint *)this;
}
/* try { // try from 0015d3f9 to 0015d400 has its CatchHandler @ 0015d409 */
std::vector<int,std::allocator<int>>::resize
((vector<int,std::allocator<int>> *)param_2,(long)*(int *)(this + 4) * (long)(int)uVar3)
;
return;
}
| |
41,246 | inline_mysql_file_pwrite | eloqsql/include/mysql/psi/mysql_file.h | static inline size_t
inline_mysql_file_pwrite(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, const uchar *buffer, size_t count, my_off_t offset, myf flags)
{
size_t result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
size_t bytes_written;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_WRITE);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, count, src_file, src_line);
result= my_pwrite(file, buffer, count, offset, flags);
if (flags & (MY_NABP | MY_FNABP))
bytes_written= (result == 0) ? count : 0;
else
bytes_written= (result != MY_FILE_ERROR) ? result : 0;
PSI_FILE_CALL(end_file_wait)(locker, bytes_written);
return result;
}
#endif
result= my_pwrite(file, buffer, count, offset, flags);
return result;
} | O0 | c | inline_mysql_file_pwrite:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq 0x1dd64c(%rip), %rax # 0x2c1018
movq (%rax), %rax
movq 0x158(%rax), %rax
movl -0x18(%rbp), %esi
leaq -0x88(%rbp), %rdi
movl $0x7, %edx
callq *%rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%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 0xe3adf
leaq 0x1dd602(%rip), %rax # 0x2c1018
movq (%rax), %rax
movq 0x210(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq *%rax
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0xf6120
movq %rax, -0x38(%rbp)
movq 0x10(%rbp), %rax
andq $0x6, %rax
cmpq $0x0, %rax
je 0xe3a8a
cmpq $0x0, -0x38(%rbp)
jne 0xe3a6f
movq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0xe3a7a
xorl %eax, %eax
movq %rax, -0x98(%rbp)
jmp 0xe3a7a
movq -0x98(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0xe3ab7
cmpq $-0x1, -0x38(%rbp)
je 0xe3a9e
movq -0x38(%rbp), %rax
movq %rax, -0xa0(%rbp)
jmp 0xe3aa9
xorl %eax, %eax
movq %rax, -0xa0(%rbp)
jmp 0xe3aa9
movq -0xa0(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq 0x1dd55a(%rip), %rax # 0x2c1018
movq (%rax), %rax
movq 0x218(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq *%rax
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe3b03
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0xf6120
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
| inline_mysql_file_pwrite_3:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov rax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+158h]
mov esi, [rbp+var_18]
lea rdi, [rbp+var_88]
mov edx, 7
call rax
mov [rbp+var_40], rax
cmp [rbp+var_40], 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 loc_E3ADF
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+210h]
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_10]
mov ecx, [rbp+var_14]
call rax
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
mov r8, [rbp+arg_0]
call my_pwrite
mov [rbp+var_38], rax
mov rax, [rbp+arg_0]
and rax, 6
cmp rax, 0
jz short loc_E3A8A
cmp [rbp+var_38], 0
jnz short loc_E3A6F
mov rax, [rbp+var_28]
mov [rbp+var_98], rax
jmp short loc_E3A7A
loc_E3A6F:
xor eax, eax
mov [rbp+var_98], rax
jmp short $+2
loc_E3A7A:
mov rax, [rbp+var_98]
mov [rbp+var_90], rax
jmp short loc_E3AB7
loc_E3A8A:
cmp [rbp+var_38], 0FFFFFFFFFFFFFFFFh
jz short loc_E3A9E
mov rax, [rbp+var_38]
mov [rbp+var_A0], rax
jmp short loc_E3AA9
loc_E3A9E:
xor eax, eax
mov [rbp+var_A0], rax
jmp short $+2
loc_E3AA9:
mov rax, [rbp+var_A0]
mov [rbp+var_90], rax
loc_E3AB7:
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+218h]
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_90]
call rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
jmp short loc_E3B03
loc_E3ADF:
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
mov r8, [rbp+arg_0]
call my_pwrite
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
loc_E3B03:
mov rax, [rbp+var_8]
add rsp, 0A0h
pop rbp
retn
| long long inline_mysql_file_pwrite_3(
long long a1,
unsigned int a2,
unsigned int a3,
long long a4,
long long a5,
long long a6,
long long a7)
{
long long v8; // [rsp+0h] [rbp-A0h]
long long v9; // [rsp+8h] [rbp-98h]
_BYTE v10[72]; // [rsp+18h] [rbp-88h] BYREF
long long v11; // [rsp+60h] [rbp-40h]
long long v12; // [rsp+68h] [rbp-38h]
long long v13; // [rsp+70h] [rbp-30h]
long long v14; // [rsp+78h] [rbp-28h]
long long v15; // [rsp+80h] [rbp-20h]
unsigned int v16; // [rsp+88h] [rbp-18h]
unsigned int v17; // [rsp+8Ch] [rbp-14h]
long long v18; // [rsp+90h] [rbp-10h]
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
v14 = a5;
v13 = a6;
v11 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v10, a3, 7LL);
if ( v11 )
{
((void ( *)(long long, long long, long long, _QWORD))PSI_server[66])(v11, v14, v18, v17);
v12 = my_pwrite(v16, v15, v14, v13, a7);
if ( (a7 & 6) != 0 )
{
if ( v12 )
v9 = 0LL;
else
v9 = v14;
((void ( *)(long long, long long))PSI_server[67])(v11, v9);
}
else
{
if ( v12 == -1 )
v8 = 0LL;
else
v8 = v12;
((void ( *)(long long, long long))PSI_server[67])(v11, v8);
}
return v12;
}
else
{
return my_pwrite(v16, v15, v14, v13, a7);
}
}
| inline_mysql_file_pwrite:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
LEA RAX,[0x3c1018]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x158]
MOV ESI,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x88]
MOV EDX,0x7
CALL RAX
MOV qword ptr [RBP + -0x40],RAX
CMP qword ptr [RBP + -0x40],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001e3adf
LEA RAX,[0x3c1018]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x210]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x14]
CALL RAX
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + 0x10]
CALL 0x001f6120
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + 0x10]
AND RAX,0x6
CMP RAX,0x0
JZ 0x001e3a8a
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x001e3a6f
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x98],RAX
JMP 0x001e3a7a
LAB_001e3a6f:
XOR EAX,EAX
MOV qword ptr [RBP + -0x98],RAX
JMP 0x001e3a7a
LAB_001e3a7a:
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x90],RAX
JMP 0x001e3ab7
LAB_001e3a8a:
CMP qword ptr [RBP + -0x38],-0x1
JZ 0x001e3a9e
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x001e3aa9
LAB_001e3a9e:
XOR EAX,EAX
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x001e3aa9
LAB_001e3aa9:
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0x90],RAX
LAB_001e3ab7:
LEA RAX,[0x3c1018]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x90]
CALL RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001e3b03
LAB_001e3adf:
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + 0x10]
CALL 0x001f6120
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
LAB_001e3b03:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0xa0
POP RBP
RET
|
long inline_mysql_file_pwrite
(int8 param_1,int4 param_2,int4 param_3,int8 param_4,
long param_5,int8 param_6,ulong param_7)
{
long local_a8;
long local_a0;
long local_98;
int1 local_90 [72];
long local_48;
long local_40;
int8 local_38;
long local_30;
int8 local_28;
int4 local_20;
int4 local_1c;
int8 local_18;
long local_10;
local_38 = param_6;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
local_48 = (**(code **)(PSI_server + 0x158))(local_90,param_3,7);
if (local_48 == 0) {
local_10 = my_pwrite(local_20,local_28,local_30,local_38,param_7);
}
else {
(**(code **)(PSI_server + 0x210))(local_48,local_30,local_18,local_1c);
local_40 = my_pwrite(local_20,local_28,local_30,local_38,param_7);
if ((param_7 & 6) == 0) {
local_a8 = local_40;
if (local_40 == -1) {
local_a8 = 0;
}
local_98 = local_a8;
}
else {
if (local_40 == 0) {
local_a0 = local_30;
}
else {
local_a0 = 0;
}
local_98 = local_a0;
}
(**(code **)(PSI_server + 0x218))(local_48,local_98);
local_10 = local_40;
}
return local_10;
}
| |
41,247 | my_wildcmp_8bit_impl | eloqsql/strings/ctype-simple.c | static
int my_wildcmp_8bit_impl(CHARSET_INFO *cs,
const char *str,const char *str_end,
const char *wildstr,const char *wildend,
int escape, int w_one, int w_many, int recurse_level)
{
int result= -1; /* Not found, using wildcards */
if (my_string_stack_guard && my_string_stack_guard(recurse_level))
return 1;
while (wildstr != wildend)
{
while (*wildstr != w_many && *wildstr != w_one)
{
if (*wildstr == escape && wildstr+1 != wildend)
wildstr++;
if (str == str_end || likeconv(cs,*wildstr++) != likeconv(cs,*str++))
return(1); /* No match */
if (wildstr == wildend)
return(str != str_end); /* Match if both are at end */
result=1; /* Found an anchor char */
}
if (*wildstr == w_one)
{
do
{
if (str == str_end) /* Skip one char if possible */
return(result);
INC_PTR(cs,str,str_end);
} while (++wildstr < wildend && *wildstr == w_one);
if (wildstr == wildend)
break;
}
if (*wildstr == w_many)
{ /* Found w_many */
uchar cmp;
wildstr++;
/* Remove any '%' and '_' from the wild search string */
for (; wildstr != wildend ; wildstr++)
{
if (*wildstr == w_many)
continue;
if (*wildstr == w_one)
{
if (str == str_end)
return(-1);
INC_PTR(cs,str,str_end);
continue;
}
break; /* Not a wild character */
}
if (wildstr == wildend)
return(0); /* Ok if w_many is last */
if (str == str_end)
return(-1);
if ((cmp= *wildstr) == escape && wildstr+1 != wildend)
cmp= *++wildstr;
INC_PTR(cs,wildstr,wildend); /* This is compared trough cmp */
cmp=likeconv(cs,cmp);
do
{
/*
Find the next character in the subject string equal to 'cmp', then
check recursively my_wildcmp_8bit_impl() for the pattern remainder.
*/
while (str != str_end && (uchar) likeconv(cs,*str) != cmp)
str++;
if (str++ == str_end)
return(-1); /* 'cmp' was not found in the subject string */
{
int tmp=my_wildcmp_8bit_impl(cs,str,str_end,
wildstr,wildend,escape,w_one,
w_many, recurse_level+1);
if (tmp <= 0)
return(tmp);
}
/*
The recursion call did not match. But it returned 1, which means
the pattern remainder has some non-special characters.
Continue, there is a chance that we'll find another 'cmp'
at a different position in the subject string.
*/
} while (str != str_end);
return(-1);
}
}
return(str != str_end ? 1 : 0);
} | O3 | c | my_wildcmp_8bit_impl:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r14
movl 0x20(%rbp), %r10d
leaq 0xb532ed(%rip), %rax # 0xc0bba8
movq (%rax), %rax
testq %rax, %rax
je 0xb88ee
movq %rbx, -0x30(%rbp)
movq %rdi, %rbx
movl %r10d, %edi
movl %r9d, %r15d
callq *%rax
movl 0x20(%rbp), %r10d
movq %rbx, %rdi
movq -0x30(%rbp), %rbx
movl %r15d, %r9d
movl $0x1, %r15d
testl %eax, %eax
jne 0xb8a14
movl 0x18(%rbp), %r11d
movl 0x10(%rbp), %r8d
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
cmpq %r12, %r13
je 0xb8a0a
movb (%r13), %al
movsbl %al, %ecx
cmpl %r11d, %ecx
sete %sil
cmpl %r8d, %ecx
sete %dl
orb %dl, %sil
je 0xb896b
testb %dl, %dl
je 0xb8961
incq %r13
movq %r13, %rax
cmpq %rbx, %r14
je 0xb8a14
movq %r14, %rcx
movq %rax, %r13
cmpq %r12, %rax
jae 0xb894e
leaq 0x1(%rcx), %r14
movsbl (%r13), %edx
leaq 0x1(%r13), %rax
cmpl %r8d, %edx
je 0xb8928
incq %rcx
cmpq %r12, %r13
je 0xb8a07
movb (%r13), %al
movq %rcx, %r14
movsbl %al, %eax
cmpl %r11d, %eax
jne 0xb88fc
jmp 0xb89cc
movl $0x1, %r15d
cmpq %rbx, %r14
je 0xb8a14
leaq 0x1(%r13), %rax
cmpq %r12, %rax
cmoveq %r13, %rax
cmpl %r9d, %ecx
cmoveq %rax, %r13
movq 0x58(%rdi), %rax
movzbl (%r13), %ecx
movb (%rax,%rcx), %cl
movzbl (%r14), %edx
cmpb (%rax,%rdx), %cl
jne 0xb8a14
incq %r14
incq %r13
cmpq %r12, %r13
je 0xb8a0a
movb (%r13), %al
movsbl %al, %ecx
cmpl %r8d, %ecx
sete %dl
cmpl %r11d, %ecx
je 0xb891e
cmpl %r8d, %ecx
jne 0xb896b
jmp 0xb891e
leaq 0x1(%r13), %rax
xorl %r15d, %r15d
cmpq %r12, %rax
je 0xb8a14
addq $0x2, %r13
movb -0x1(%r13), %al
movsbl %al, %ecx
cmpl %r11d, %ecx
je 0xb89f9
cmpl %r8d, %ecx
jne 0xb8a26
cmpq %rbx, %r14
je 0xb8ad1
incq %r14
leaq 0x1(%r13), %rax
cmpq %r12, %r13
movq %rax, %r13
jne 0xb89dc
jmp 0xb8a14
movq %rcx, %r14
xorl %r15d, %r15d
cmpq %rbx, %r14
setne %r15b
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
cmpq %rbx, %r14
je 0xb8a14
movzbl %al, %ecx
leaq -0x1(%r13), %rdx
cmpl %r9d, %ecx
jne 0xb8a49
cmpq %r12, %r13
je 0xb8a49
movb (%r13), %al
movq %r13, %rdx
incq %rdx
movq 0x58(%rdi), %rcx
movzbl %al, %eax
movb (%rcx,%rax), %r13b
incl %r10d
cmpq %rbx, %r14
je 0xb8a14
movq 0x58(%rdi), %rax
movzbl (%r14), %ecx
cmpb %r13b, (%rax,%rcx)
je 0xb8a77
incq %r14
cmpq %rbx, %r14
jne 0xb8a63
jmp 0xb8a14
incq %r14
subq $0x8, %rsp
movq %rdi, -0x48(%rbp)
movq %r14, %rsi
movq %rdx, %rcx
movq %rbx, %rdx
movq %rcx, -0x38(%rbp)
movq %r8, %rax
movq %r12, %r8
movl %r9d, -0x30(%rbp)
movq %r10, -0x40(%rbp)
pushq %r10
pushq %r11
pushq %rax
callq 0xb8893
addq $0x20, %rsp
testl %eax, %eax
jle 0xb8adc
cmpq %rbx, %r14
movl -0x30(%rbp), %r9d
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %r10
movl 0x18(%rbp), %r11d
movl 0x10(%rbp), %r8d
movq -0x38(%rbp), %rdx
jne 0xb8a5a
jmp 0xb8a14
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
jmp 0xb8a14
movl %eax, %r15d
jmp 0xb8a14
| my_wildcmp_8bit_impl:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r12, r8
mov r13, rcx
mov rbx, rdx
mov r14, rsi
mov r10d, [rbp+arg_10]
lea rax, my_string_stack_guard
mov rax, [rax]
test rax, rax
jz short loc_B88EE
mov [rbp+var_30], rbx
mov rbx, rdi
mov edi, r10d
mov r15d, r9d
call rax
mov r10d, [rbp+arg_10]
mov rdi, rbx
mov rbx, [rbp+var_30]
mov r9d, r15d
mov r15d, 1
test eax, eax
jnz loc_B8A14
loc_B88EE:
mov r11d, [rbp+arg_8]
mov r8d, [rbp+arg_0]
mov r15d, 0FFFFFFFFh
loc_B88FC:
cmp r13, r12
jz loc_B8A0A
mov al, [r13+0]
movsx ecx, al
cmp ecx, r11d
setz sil
cmp ecx, r8d
setz dl
or sil, dl
jz short loc_B896B
loc_B891E:
test dl, dl
jz short loc_B8961
inc r13
mov rax, r13
loc_B8928:
cmp r14, rbx
jz loc_B8A14
mov rcx, r14
mov r13, rax
cmp rax, r12
jnb short loc_B894E
lea r14, [rcx+1]
movsx edx, byte ptr [r13+0]
lea rax, [r13+1]
cmp edx, r8d
jz short loc_B8928
loc_B894E:
inc rcx
cmp r13, r12
jz loc_B8A07
mov al, [r13+0]
mov r14, rcx
loc_B8961:
movsx eax, al
cmp eax, r11d
jnz short loc_B88FC
jmp short loc_B89CC
loc_B896B:
mov r15d, 1
cmp r14, rbx
jz loc_B8A14
lea rax, [r13+1]
cmp rax, r12
cmovz rax, r13
cmp ecx, r9d
cmovz r13, rax
mov rax, [rdi+58h]
movzx ecx, byte ptr [r13+0]
mov cl, [rax+rcx]
movzx edx, byte ptr [r14]
cmp cl, [rax+rdx]
jnz short loc_B8A14
inc r14
inc r13
cmp r13, r12
jz short loc_B8A0A
mov al, [r13+0]
movsx ecx, al
cmp ecx, r8d
setz dl
cmp ecx, r11d
jz loc_B891E
cmp ecx, r8d
jnz short loc_B896B
jmp loc_B891E
loc_B89CC:
lea rax, [r13+1]
xor r15d, r15d
cmp rax, r12
jz short loc_B8A14
add r13, 2
loc_B89DC:
mov al, [r13-1]
movsx ecx, al
cmp ecx, r11d
jz short loc_B89F9
cmp ecx, r8d
jnz short loc_B8A26
cmp r14, rbx
jz loc_B8AD1
inc r14
loc_B89F9:
lea rax, [r13+1]
cmp r13, r12
mov r13, rax
jnz short loc_B89DC
jmp short loc_B8A14
loc_B8A07:
mov r14, rcx
loc_B8A0A:
xor r15d, r15d
cmp r14, rbx
setnz r15b
loc_B8A14:
mov eax, r15d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_B8A26:
mov r15d, 0FFFFFFFFh
cmp r14, rbx
jz short loc_B8A14
movzx ecx, al
lea rdx, [r13-1]
cmp ecx, r9d
jnz short loc_B8A49
cmp r13, r12
jz short loc_B8A49
mov al, [r13+0]
mov rdx, r13
loc_B8A49:
inc rdx
mov rcx, [rdi+58h]
movzx eax, al
mov r13b, [rcx+rax]
inc r10d
loc_B8A5A:
cmp r14, rbx
jz short loc_B8A14
mov rax, [rdi+58h]
loc_B8A63:
movzx ecx, byte ptr [r14]
cmp [rax+rcx], r13b
jz short loc_B8A77
inc r14
cmp r14, rbx
jnz short loc_B8A63
jmp short loc_B8A14
loc_B8A77:
inc r14
sub rsp, 8
mov [rbp+var_48], rdi
mov rsi, r14
mov rcx, rdx
mov rdx, rbx
mov [rbp+var_38], rcx
mov rax, r8
mov r8, r12
mov dword ptr [rbp+var_30], r9d
mov [rbp+var_40], r10
push r10
push r11
push rax
call my_wildcmp_8bit_impl
add rsp, 20h
test eax, eax
jle short loc_B8ADC
cmp r14, rbx
mov r9d, dword ptr [rbp+var_30]
mov rdi, [rbp+var_48]
mov r10, [rbp+var_40]
mov r11d, [rbp+arg_8]
mov r8d, [rbp+arg_0]
mov rdx, [rbp+var_38]
jnz short loc_B8A5A
jmp loc_B8A14
loc_B8AD1:
mov r15d, 0FFFFFFFFh
jmp loc_B8A14
loc_B8ADC:
mov r15d, eax
jmp loc_B8A14
| long long my_wildcmp_8bit_impl(
long long a1,
unsigned __int8 *a2,
unsigned __int8 *a3,
char *a4,
char *a5,
int a6,
int a7,
int a8,
unsigned int a9)
{
unsigned __int8 *v11; // rbx
unsigned int v13; // r10d
int v14; // r15d
int v15; // eax
unsigned int v16; // r15d
int v17; // r11d
int v18; // r8d
signed __int8 v19; // al
int v20; // ecx
bool v21; // dl
char *v22; // rax
unsigned __int8 *v23; // rcx
int v24; // edx
unsigned __int8 *v25; // rcx
char *v26; // rax
char *v27; // r13
unsigned __int8 v28; // al
char *v31; // rdx
_BYTE *v32; // rdx
char v33; // r13
long long v34; // r10
int v35; // eax
long long v36; // [rsp+10h] [rbp-40h]
_BYTE *v37; // [rsp+18h] [rbp-38h]
int v39; // [rsp+20h] [rbp-30h]
v11 = a3;
v13 = a9;
if ( my_string_stack_guard )
{
v14 = a6;
v15 = my_string_stack_guard(a9);
v13 = a9;
v11 = a3;
a6 = v14;
v16 = 1;
if ( v15 )
return v16;
}
v17 = a8;
v18 = a7;
v16 = -1;
do
{
if ( a4 == a5 )
return a2 != v11;
v19 = *a4;
v20 = *a4;
v21 = v20 == a7;
if ( v20 != a7 && v20 != a8 )
{
do
{
v16 = 1;
if ( a2 == v11 )
return v16;
v26 = a4 + 1;
if ( a4 + 1 == a5 )
v26 = a4;
if ( v20 == a6 )
a4 = v26;
if ( *(_BYTE *)(*(_QWORD *)(a1 + 88) + (unsigned __int8)*a4) != *(_BYTE *)(*(_QWORD *)(a1 + 88) + *a2) )
return v16;
++a2;
if ( ++a4 == a5 )
return a2 != v11;
v19 = *a4;
v20 = *a4;
v21 = v20 == a7;
}
while ( v20 != a8 && v20 != a7 );
}
if ( v21 )
{
v22 = a4 + 1;
do
{
if ( a2 == v11 )
return v16;
v23 = a2;
a4 = v22;
if ( v22 >= a5 )
break;
++a2;
v24 = *v22++;
}
while ( v24 == a7 );
v25 = v23 + 1;
if ( a4 == a5 )
{
a2 = v25;
return a2 != v11;
}
v19 = *a4;
a2 = v25;
}
}
while ( v19 != a8 );
v16 = 0;
if ( a4 + 1 == a5 )
return v16;
v27 = a4 + 2;
while ( 1 )
{
v28 = *(v27 - 1);
if ( (char)v28 == a8 )
goto LABEL_31;
if ( (char)v28 != a7 )
break;
if ( a2 == v11 )
return (unsigned int)-1;
++a2;
LABEL_31:
if ( v27++ == a5 )
return v16;
}
v16 = -1;
if ( a2 != v11 )
{
v31 = v27 - 1;
if ( v28 == a6 && v27 != a5 )
{
v28 = *v27;
v31 = v27;
}
v32 = v31 + 1;
v33 = *(_BYTE *)(*(_QWORD *)(a1 + 88) + v28);
v34 = v13 + 1;
while ( a2 != v11 )
{
while ( *(_BYTE *)(*(_QWORD *)(a1 + 88) + *a2) != v33 )
{
if ( ++a2 == v11 )
return v16;
}
++a2;
v37 = v32;
v39 = a6;
v36 = v34;
v35 = my_wildcmp_8bit_impl(a1, (_DWORD)a2, (_DWORD)v11, (_DWORD)v32, (_DWORD)a5, a6, v18, v17, v34);
if ( v35 <= 0 )
return (unsigned int)v35;
a6 = v39;
v34 = v36;
v17 = a8;
v18 = a7;
v32 = v37;
if ( a2 == v11 )
return v16;
}
}
return v16;
}
| my_wildcmp_8bit_impl:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R12,R8
MOV R13,RCX
MOV RBX,RDX
MOV R14,RSI
MOV R10D,dword ptr [RBP + 0x20]
LEA RAX,[0xd0bba8]
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x001b88ee
MOV qword ptr [RBP + -0x30],RBX
MOV RBX,RDI
MOV EDI,R10D
MOV R15D,R9D
CALL RAX
MOV R10D,dword ptr [RBP + 0x20]
MOV RDI,RBX
MOV RBX,qword ptr [RBP + -0x30]
MOV R9D,R15D
MOV R15D,0x1
TEST EAX,EAX
JNZ 0x001b8a14
LAB_001b88ee:
MOV R11D,dword ptr [RBP + 0x18]
MOV R8D,dword ptr [RBP + 0x10]
MOV R15D,0xffffffff
LAB_001b88fc:
CMP R13,R12
JZ 0x001b8a0a
MOV AL,byte ptr [R13]
MOVSX ECX,AL
CMP ECX,R11D
SETZ SIL
CMP ECX,R8D
SETZ DL
OR SIL,DL
JZ 0x001b896b
LAB_001b891e:
TEST DL,DL
JZ 0x001b8961
INC R13
MOV RAX,R13
LAB_001b8928:
CMP R14,RBX
JZ 0x001b8a14
MOV RCX,R14
MOV R13,RAX
CMP RAX,R12
JNC 0x001b894e
LEA R14,[RCX + 0x1]
MOVSX EDX,byte ptr [R13]
LEA RAX,[R13 + 0x1]
CMP EDX,R8D
JZ 0x001b8928
LAB_001b894e:
INC RCX
CMP R13,R12
JZ 0x001b8a07
MOV AL,byte ptr [R13]
MOV R14,RCX
LAB_001b8961:
MOVSX EAX,AL
CMP EAX,R11D
JNZ 0x001b88fc
JMP 0x001b89cc
LAB_001b896b:
MOV R15D,0x1
CMP R14,RBX
JZ 0x001b8a14
LEA RAX,[R13 + 0x1]
CMP RAX,R12
CMOVZ RAX,R13
CMP ECX,R9D
CMOVZ R13,RAX
MOV RAX,qword ptr [RDI + 0x58]
MOVZX ECX,byte ptr [R13]
MOV CL,byte ptr [RAX + RCX*0x1]
MOVZX EDX,byte ptr [R14]
CMP CL,byte ptr [RAX + RDX*0x1]
JNZ 0x001b8a14
INC R14
INC R13
CMP R13,R12
JZ 0x001b8a0a
MOV AL,byte ptr [R13]
MOVSX ECX,AL
CMP ECX,R8D
SETZ DL
CMP ECX,R11D
JZ 0x001b891e
CMP ECX,R8D
JNZ 0x001b896b
JMP 0x001b891e
LAB_001b89cc:
LEA RAX,[R13 + 0x1]
XOR R15D,R15D
CMP RAX,R12
JZ 0x001b8a14
ADD R13,0x2
LAB_001b89dc:
MOV AL,byte ptr [R13 + -0x1]
MOVSX ECX,AL
CMP ECX,R11D
JZ 0x001b89f9
CMP ECX,R8D
JNZ 0x001b8a26
CMP R14,RBX
JZ 0x001b8ad1
INC R14
LAB_001b89f9:
LEA RAX,[R13 + 0x1]
CMP R13,R12
MOV R13,RAX
JNZ 0x001b89dc
JMP 0x001b8a14
LAB_001b8a07:
MOV R14,RCX
LAB_001b8a0a:
XOR R15D,R15D
CMP R14,RBX
SETNZ R15B
LAB_001b8a14:
MOV EAX,R15D
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001b8a26:
MOV R15D,0xffffffff
CMP R14,RBX
JZ 0x001b8a14
MOVZX ECX,AL
LEA RDX,[R13 + -0x1]
CMP ECX,R9D
JNZ 0x001b8a49
CMP R13,R12
JZ 0x001b8a49
MOV AL,byte ptr [R13]
MOV RDX,R13
LAB_001b8a49:
INC RDX
MOV RCX,qword ptr [RDI + 0x58]
MOVZX EAX,AL
MOV R13B,byte ptr [RCX + RAX*0x1]
INC R10D
LAB_001b8a5a:
CMP R14,RBX
JZ 0x001b8a14
MOV RAX,qword ptr [RDI + 0x58]
LAB_001b8a63:
MOVZX ECX,byte ptr [R14]
CMP byte ptr [RAX + RCX*0x1],R13B
JZ 0x001b8a77
INC R14
CMP R14,RBX
JNZ 0x001b8a63
JMP 0x001b8a14
LAB_001b8a77:
INC R14
SUB RSP,0x8
MOV qword ptr [RBP + -0x48],RDI
MOV RSI,R14
MOV RCX,RDX
MOV RDX,RBX
MOV qword ptr [RBP + -0x38],RCX
MOV RAX,R8
MOV R8,R12
MOV dword ptr [RBP + -0x30],R9D
MOV qword ptr [RBP + -0x40],R10
PUSH R10
PUSH R11
PUSH RAX
CALL 0x001b8893
ADD RSP,0x20
TEST EAX,EAX
JLE 0x001b8adc
CMP R14,RBX
MOV R9D,dword ptr [RBP + -0x30]
MOV RDI,qword ptr [RBP + -0x48]
MOV R10,qword ptr [RBP + -0x40]
MOV R11D,dword ptr [RBP + 0x18]
MOV R8D,dword ptr [RBP + 0x10]
MOV RDX,qword ptr [RBP + -0x38]
JNZ 0x001b8a5a
JMP 0x001b8a14
LAB_001b8ad1:
MOV R15D,0xffffffff
JMP 0x001b8a14
LAB_001b8adc:
MOV R15D,EAX
JMP 0x001b8a14
|
uint my_wildcmp_8bit_impl
(long param_1,byte *param_2,byte *param_3,byte *param_4,byte *param_5,ulong param_6,
uint param_7,uint param_8,int param_9)
{
char cVar1;
byte bVar2;
int iVar3;
uint uVar4;
byte *pbVar5;
uint uVar6;
byte *pbVar7;
bool bVar8;
if (my_string_stack_guard != (code *)0x0) {
param_6 = param_6 & 0xffffffff;
iVar3 = (*my_string_stack_guard)(param_9);
if (iVar3 != 0) {
return 1;
}
}
uVar4 = 0xffffffff;
while (param_4 != param_5) {
bVar2 = *param_4;
uVar6 = (uint)(char)bVar2;
bVar8 = uVar6 == param_7;
if (uVar6 != param_8 && !bVar8) {
do {
uVar4 = 1;
if (param_2 == param_3) {
return 1;
}
pbVar5 = param_4 + 1;
if (param_4 + 1 == param_5) {
pbVar5 = param_4;
}
if (uVar6 == (uint)param_6) {
param_4 = pbVar5;
}
if (*(char *)(*(long *)(param_1 + 0x58) + (ulong)*param_4) !=
*(char *)(*(long *)(param_1 + 0x58) + (ulong)*param_2)) {
return 1;
}
param_2 = param_2 + 1;
param_4 = param_4 + 1;
if (param_4 == param_5) goto LAB_001b8a0a;
bVar2 = *param_4;
uVar6 = (uint)(char)bVar2;
bVar8 = uVar6 == param_7;
} while ((uVar6 != param_8) && (uVar6 != param_7));
}
if (bVar8) {
do {
pbVar5 = param_2;
param_4 = param_4 + 1;
if (pbVar5 == param_3) {
return uVar4;
}
} while ((param_4 < param_5) && (param_2 = pbVar5 + 1, (int)(char)*param_4 == param_7));
param_2 = pbVar5 + 1;
if (param_4 == param_5) break;
bVar2 = *param_4;
}
if ((int)(char)bVar2 == param_8) {
if (param_4 + 1 != param_5) {
pbVar5 = param_4 + 2;
do {
bVar2 = pbVar5[-1];
if ((int)(char)bVar2 != param_8) {
if ((int)(char)bVar2 != param_7) {
if (param_2 == param_3) {
return 0xffffffff;
}
pbVar7 = pbVar5 + -1;
if (((uint)bVar2 == (uint)param_6) && (pbVar5 != param_5)) {
bVar2 = *pbVar5;
pbVar7 = pbVar5;
}
cVar1 = *(char *)(*(long *)(param_1 + 0x58) + (ulong)bVar2);
while( true ) {
if (param_2 == param_3) {
return 0xffffffff;
}
while (*(char *)(*(long *)(param_1 + 0x58) + (ulong)*param_2) != cVar1) {
param_2 = param_2 + 1;
if (param_2 == param_3) {
return 0xffffffff;
}
}
param_2 = param_2 + 1;
uVar4 = my_wildcmp_8bit_impl
(param_1,param_2,param_3,pbVar7 + 1,param_5,param_6,param_7,
param_8,param_9 + 1);
if ((int)uVar4 < 1) break;
param_6 = param_6 & 0xffffffff;
if (param_2 == param_3) {
return 0xffffffff;
}
}
return uVar4;
}
if (param_2 == param_3) {
return 0xffffffff;
}
param_2 = param_2 + 1;
}
bVar8 = pbVar5 != param_5;
pbVar5 = pbVar5 + 1;
} while (bVar8);
}
return 0;
}
}
LAB_001b8a0a:
return (uint)(param_2 != param_3);
}
| |
41,248 | fmt::v10::detail::parse_align(char) | AlayaLite/build_O0/_deps/spdlog-src/include/spdlog/fmt/bundled/core.h | FMT_CONSTEXPR inline auto parse_align(char c) -> align_t {
switch (c) {
case '<':
return align::left;
case '>':
return align::right;
case '^':
return align::center;
}
return align::none;
} | O0 | c | fmt::v10::detail::parse_align(char):
movb %dil, %al
movb %al, -0x2(%rsp)
movsbl -0x2(%rsp), %eax
movl %eax, -0x8(%rsp)
subl $0x3c, %eax
je 0xab7cd
jmp 0xab7b7
movl -0x8(%rsp), %eax
subl $0x3e, %eax
je 0xab7d4
jmp 0xab7c2
movl -0x8(%rsp), %eax
subl $0x5e, %eax
je 0xab7db
jmp 0xab7e2
movb $0x1, -0x1(%rsp)
jmp 0xab7e7
movb $0x2, -0x1(%rsp)
jmp 0xab7e7
movb $0x3, -0x1(%rsp)
jmp 0xab7e7
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
nopl (%rax)
| _ZN3fmt3v106detail11parse_alignEc:
mov al, dil
mov [rsp+var_2], al
movsx eax, [rsp+var_2]
mov [rsp+var_8], eax
sub eax, 3Ch ; '<'
jz short loc_AB7CD
jmp short $+2
loc_AB7B7:
mov eax, [rsp+var_8]
sub eax, 3Eh ; '>'
jz short loc_AB7D4
jmp short $+2
loc_AB7C2:
mov eax, [rsp+var_8]
sub eax, 5Eh ; '^'
jz short loc_AB7DB
jmp short loc_AB7E2
loc_AB7CD:
mov [rsp+var_1], 1
jmp short loc_AB7E7
loc_AB7D4:
mov [rsp+var_1], 2
jmp short loc_AB7E7
loc_AB7DB:
mov [rsp+var_1], 3
jmp short loc_AB7E7
loc_AB7E2:
mov [rsp+var_1], 0
loc_AB7E7:
mov al, [rsp+var_1]
retn
| char fmt::v10::detail::parse_align(fmt::v10::detail *this)
{
switch ( (char)this )
{
case '<':
return 1;
case '>':
return 2;
case '^':
return 3;
}
return 0;
}
| parse_align:
MOV AL,DIL
MOV byte ptr [RSP + -0x2],AL
MOVSX EAX,byte ptr [RSP + -0x2]
MOV dword ptr [RSP + -0x8],EAX
SUB EAX,0x3c
JZ 0x001ab7cd
JMP 0x001ab7b7
LAB_001ab7b7:
MOV EAX,dword ptr [RSP + -0x8]
SUB EAX,0x3e
JZ 0x001ab7d4
JMP 0x001ab7c2
LAB_001ab7c2:
MOV EAX,dword ptr [RSP + -0x8]
SUB EAX,0x5e
JZ 0x001ab7db
JMP 0x001ab7e2
LAB_001ab7cd:
MOV byte ptr [RSP + -0x1],0x1
JMP 0x001ab7e7
LAB_001ab7d4:
MOV byte ptr [RSP + -0x1],0x2
JMP 0x001ab7e7
LAB_001ab7db:
MOV byte ptr [RSP + -0x1],0x3
JMP 0x001ab7e7
LAB_001ab7e2:
MOV byte ptr [RSP + -0x1],0x0
LAB_001ab7e7:
MOV AL,byte ptr [RSP + -0x1]
RET
|
/* fmt::v10::detail::parse_align(char) */
int8 fmt::v10::detail::parse_align(char param_1)
{
int iVar1;
ulong uVar2;
int1 local_1;
iVar1 = (int)param_1;
uVar2 = (ulong)(iVar1 - 0x3cU);
if (iVar1 - 0x3cU == 0) {
local_1 = 1;
}
else {
uVar2 = (ulong)(iVar1 - 0x3eU);
if (iVar1 - 0x3eU == 0) {
local_1 = 2;
}
else {
uVar2 = (ulong)(iVar1 - 0x5eU);
if (iVar1 - 0x5eU == 0) {
local_1 = 3;
}
else {
local_1 = 0;
}
}
}
return CONCAT71((int7)(uVar2 >> 8),local_1);
}
| |
41,249 | bfdec_print_str | bluesky950520[P]quickjs/libbf.c | void bfdec_print_str(const char *str, const bfdec_t *a)
{
slimb_t i;
printf("%s=", str);
if (a->expn == BF_EXP_NAN) {
printf("NaN");
} else {
if (a->sign)
putchar('-');
if (a->expn == BF_EXP_ZERO) {
putchar('0');
} else if (a->expn == BF_EXP_INF) {
printf("Inf");
} else {
printf("0.");
for(i = a->len - 1; i >= 0; i--)
printf("%0*" PRIu_LIMB, LIMB_DIGITS, a->tab[i]);
printf("e%" PRId_LIMB, a->expn);
}
}
printf("\n");
} | O0 | c | bfdec_print_str:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rsi
leaq 0x1eec4(%rip), %rdi # 0x110a4e
movb $0x0, %al
callq 0xe280
movq 0x8(%rsp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, 0x10(%rax)
jne 0xf1bb9
leaq 0x1c3ae(%rip), %rdi # 0x10df5b
movb $0x0, %al
callq 0xe280
jmp 0xf1c8a
movq 0x8(%rsp), %rax
cmpl $0x0, 0x8(%rax)
je 0xf1bce
movl $0x2d, %edi
callq 0xe080
movq 0x8(%rsp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmpq %rcx, 0x10(%rax)
jne 0xf1bf2
movl $0x30, %edi
callq 0xe080
jmp 0xf1c88
movq 0x8(%rsp), %rax
movabsq $0x7ffffffffffffffe, %rcx # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rcx, 0x10(%rax)
jne 0xf1c17
leaq 0x1ee44(%rip), %rdi # 0x110a52
movb $0x0, %al
callq 0xe280
jmp 0xf1c86
leaq 0x1ee3a(%rip), %rdi # 0x110a58
movb $0x0, %al
callq 0xe280
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
subq $0x1, %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jl 0xf1c6f
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x1ee0b(%rip), %rdi # 0x110a60
movl $0x13, %esi
movb $0x0, %al
callq 0xe280
movq (%rsp), %rax
addq $-0x1, %rax
movq %rax, (%rsp)
jmp 0xf1c36
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
leaq 0x1ede7(%rip), %rdi # 0x110a66
movb $0x0, %al
callq 0xe280
jmp 0xf1c88
jmp 0xf1c8a
leaq 0x1a62f(%rip), %rdi # 0x10c2c0
movb $0x0, %al
callq 0xe280
addq $0x18, %rsp
retq
nopl (%rax)
| bfdec_print_str:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov [rsp+18h+var_10], rsi
mov rsi, [rsp+18h+var_8]
lea rdi, aS_2; "%s="
mov al, 0
call _printf
mov rax, [rsp+18h+var_10]
mov rcx, 7FFFFFFFFFFFFFFFh
cmp [rax+10h], rcx
jnz short loc_F1BB9
lea rdi, aDateValueIsNan+0Eh; "NaN"
mov al, 0
call _printf
jmp loc_F1C8A
loc_F1BB9:
mov rax, [rsp+18h+var_10]
cmp dword ptr [rax+8], 0
jz short loc_F1BCE
mov edi, 2Dh ; '-'
call _putchar
loc_F1BCE:
mov rax, [rsp+18h+var_10]
mov rcx, 8000000000000000h
cmp [rax+10h], rcx
jnz short loc_F1BF2
mov edi, 30h ; '0'
call _putchar
jmp loc_F1C88
loc_F1BF2:
mov rax, [rsp+18h+var_10]
mov rcx, 7FFFFFFFFFFFFFFEh
cmp [rax+10h], rcx
jnz short loc_F1C17
lea rdi, aInf; "Inf"
mov al, 0
call _printf
jmp short loc_F1C86
loc_F1C17:
lea rdi, a0x0+2; "0."
mov al, 0
call _printf
mov rax, [rsp+18h+var_10]
mov rax, [rax+18h]
sub rax, 1
mov [rsp+18h+var_18], rax
loc_F1C36:
cmp [rsp+18h+var_18], 0
jl short loc_F1C6F
mov rax, [rsp+18h+var_10]
mov rax, [rax+20h]
mov rcx, [rsp+18h+var_18]
mov rdx, [rax+rcx*8]
lea rdi, a0Lu; "%0*lu"
mov esi, 13h
mov al, 0
call _printf
mov rax, [rsp+18h+var_18]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rsp+18h+var_18], rax
jmp short loc_F1C36
loc_F1C6F:
mov rax, [rsp+18h+var_10]
mov rsi, [rax+10h]
lea rdi, aELd; "e%ld"
mov al, 0
call _printf
loc_F1C86:
jmp short $+2
loc_F1C88:
jmp short $+2
loc_F1C8A:
lea rdi, aQuickjsNgMemor+4Ch; "\n"
mov al, 0
call _printf
add rsp, 18h
retn
| long long bfdec_print_str(const char *a1, long long a2)
{
long long i; // [rsp+0h] [rbp-18h]
printf("%s=", a1);
if ( *(_QWORD *)(a2 + 16) == 0x7FFFFFFFFFFFFFFFLL )
{
printf("NaN");
}
else
{
if ( *(_DWORD *)(a2 + 8) )
putchar(45LL);
if ( *(_QWORD *)(a2 + 16) == 0x8000000000000000LL )
{
putchar(48LL);
}
else if ( *(_QWORD *)(a2 + 16) == 0x7FFFFFFFFFFFFFFELL )
{
printf("Inf");
}
else
{
printf("0.");
for ( i = *(_QWORD *)(a2 + 24) - 1LL; i >= 0; --i )
printf("%0*lu", 19, *(_QWORD *)(*(_QWORD *)(a2 + 32) + 8 * i));
printf("e%ld", *(_QWORD *)(a2 + 16));
}
}
return printf("\n");
}
| bfdec_print_str:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV RSI,qword ptr [RSP + 0x10]
LEA RDI,[0x210a4e]
MOV AL,0x0
CALL 0x0010e280
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,0x7fffffffffffffff
CMP qword ptr [RAX + 0x10],RCX
JNZ 0x001f1bb9
LEA RDI,[0x20df5b]
MOV AL,0x0
CALL 0x0010e280
JMP 0x001f1c8a
LAB_001f1bb9:
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RAX + 0x8],0x0
JZ 0x001f1bce
MOV EDI,0x2d
CALL 0x0010e080
LAB_001f1bce:
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,-0x8000000000000000
CMP qword ptr [RAX + 0x10],RCX
JNZ 0x001f1bf2
MOV EDI,0x30
CALL 0x0010e080
JMP 0x001f1c88
LAB_001f1bf2:
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,0x7ffffffffffffffe
CMP qword ptr [RAX + 0x10],RCX
JNZ 0x001f1c17
LEA RDI,[0x210a52]
MOV AL,0x0
CALL 0x0010e280
JMP 0x001f1c86
LAB_001f1c17:
LEA RDI,[0x210a58]
MOV AL,0x0
CALL 0x0010e280
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x18]
SUB RAX,0x1
MOV qword ptr [RSP],RAX
LAB_001f1c36:
CMP qword ptr [RSP],0x0
JL 0x001f1c6f
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RSP]
MOV RDX,qword ptr [RAX + RCX*0x8]
LEA RDI,[0x210a60]
MOV ESI,0x13
MOV AL,0x0
CALL 0x0010e280
MOV RAX,qword ptr [RSP]
ADD RAX,-0x1
MOV qword ptr [RSP],RAX
JMP 0x001f1c36
LAB_001f1c6f:
MOV RAX,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RAX + 0x10]
LEA RDI,[0x210a66]
MOV AL,0x0
CALL 0x0010e280
LAB_001f1c86:
JMP 0x001f1c88
LAB_001f1c88:
JMP 0x001f1c8a
LAB_001f1c8a:
LEA RDI,[0x20c2c0]
MOV AL,0x0
CALL 0x0010e280
ADD RSP,0x18
RET
|
void bfdec_print_str(int8 param_1,long param_2)
{
long local_18;
printf("%s=",param_1);
if (*(long *)(param_2 + 0x10) == 0x7fffffffffffffff) {
printf("NaN");
}
else {
if (*(int *)(param_2 + 8) != 0) {
putchar(0x2d);
}
if (*(long *)(param_2 + 0x10) == -0x8000000000000000) {
putchar(0x30);
}
else if (*(long *)(param_2 + 0x10) == 0x7ffffffffffffffe) {
printf("Inf");
}
else {
printf("0.");
local_18 = *(long *)(param_2 + 0x18);
while (local_18 = local_18 + -1, -1 < local_18) {
printf("%0*lu",0x13,*(int8 *)(*(long *)(param_2 + 0x20) + local_18 * 8));
}
printf("e%ld",*(int8 *)(param_2 + 0x10));
}
}
printf("\n");
return;
}
| |
41,250 | bfdec_print_str | bluesky950520[P]quickjs/libbf.c | void bfdec_print_str(const char *str, const bfdec_t *a)
{
slimb_t i;
printf("%s=", str);
if (a->expn == BF_EXP_NAN) {
printf("NaN");
} else {
if (a->sign)
putchar('-');
if (a->expn == BF_EXP_ZERO) {
putchar('0');
} else if (a->expn == BF_EXP_INF) {
printf("Inf");
} else {
printf("0.");
for(i = a->len - 1; i >= 0; i--)
printf("%0*" PRIu_LIMB, LIMB_DIGITS, a->tab[i]);
printf("e%" PRId_LIMB, a->expn);
}
}
printf("\n");
} | O1 | c | bfdec_print_str:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x14319(%rip), %rdi # 0xa1a3e
xorl %eax, %eax
callq 0xe280
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, 0x10(%rbx)
jne 0x8d745
leaq 0x1181c(%rip), %rdi # 0x9ef5f
jmp 0x8d780
cmpl $0x0, 0x8(%rbx)
je 0x8d755
movl $0x2d, %edi
callq 0xe080
movq 0x10(%rbx), %rax
movabsq $0x7ffffffffffffffe, %rcx # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rcx, %rax
je 0x8d779
negq %rax
jno 0x8d796
movl $0x30, %edi
callq 0xe080
jmp 0x8d787
leaq 0x142c2(%rip), %rdi # 0xa1a42
xorl %eax, %eax
callq 0xe280
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0xe080
leaq 0x142ab(%rip), %rdi # 0xa1a48
xorl %eax, %eax
callq 0xe280
movq 0x18(%rbx), %r15
movq %r15, %rax
decq %rax
js 0x8d7d7
leaq 0x14299(%rip), %r14 # 0xa1a50
movq 0x20(%rbx), %rax
movq -0x8(%rax,%r15,8), %rdx
movq %r14, %rdi
movl $0x13, %esi
xorl %eax, %eax
callq 0xe280
decq %r15
testq %r15, %r15
jg 0x8d7b7
movq 0x10(%rbx), %rsi
leaq 0x14274(%rip), %rdi # 0xa1a56
xorl %eax, %eax
callq 0xe280
jmp 0x8d787
| bfdec_print_str:
push r15
push r14
push rbx
mov rbx, rsi
mov rsi, rdi
lea rdi, aS_2; "%s="
xor eax, eax
call _printf
mov rax, 7FFFFFFFFFFFFFFFh
cmp [rbx+10h], rax
jnz short loc_8D745
lea rdi, aDateValueIsNan+0Eh; "NaN"
jmp short loc_8D780
loc_8D745:
cmp dword ptr [rbx+8], 0
jz short loc_8D755
mov edi, 2Dh ; '-'
call _putchar
loc_8D755:
mov rax, [rbx+10h]
mov rcx, 7FFFFFFFFFFFFFFEh
cmp rax, rcx
jz short loc_8D779
neg rax
jno short loc_8D796
mov edi, 30h ; '0'
call _putchar
jmp short loc_8D787
loc_8D779:
lea rdi, aInf; "Inf"
loc_8D780:
xor eax, eax
call _printf
loc_8D787:
mov edi, 0Ah
pop rbx
pop r14
pop r15
jmp _putchar
loc_8D796:
lea rdi, a0x0+2; "0."
xor eax, eax
call _printf
mov r15, [rbx+18h]
mov rax, r15
dec rax
js short loc_8D7D7
lea r14, a0Lu; "%0*lu"
loc_8D7B7:
mov rax, [rbx+20h]
mov rdx, [rax+r15*8-8]
mov rdi, r14
mov esi, 13h
xor eax, eax
call _printf
dec r15
test r15, r15
jg short loc_8D7B7
loc_8D7D7:
mov rsi, [rbx+10h]
lea rdi, aELd; "e%ld"
xor eax, eax
call _printf
jmp short loc_8D787
| long long bfdec_print_str(const char *a1, long long a2)
{
long long v2; // rax
long long v4; // r15
printf("%s=", a1);
if ( *(_QWORD *)(a2 + 16) == 0x7FFFFFFFFFFFFFFFLL )
{
printf("NaN");
}
else
{
if ( *(_DWORD *)(a2 + 8) )
putchar(45LL);
v2 = *(_QWORD *)(a2 + 16);
if ( v2 == 0x7FFFFFFFFFFFFFFELL )
{
printf("Inf");
}
else if ( __OFSUB__(-v2, 1LL) )
{
putchar(48LL);
}
else
{
printf("0.");
v4 = *(_QWORD *)(a2 + 24);
if ( v4 - 1 >= 0 )
{
do
printf("%0*lu", 19, *(_QWORD *)(*(_QWORD *)(a2 + 32) + 8 * v4-- - 8));
while ( v4 > 0 );
}
printf("e%ld", *(_QWORD *)(a2 + 16));
}
}
return putchar(10LL);
}
| bfdec_print_str:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV RSI,RDI
LEA RDI,[0x1a1a3e]
XOR EAX,EAX
CALL 0x0010e280
MOV RAX,0x7fffffffffffffff
CMP qword ptr [RBX + 0x10],RAX
JNZ 0x0018d745
LEA RDI,[0x19ef5f]
JMP 0x0018d780
LAB_0018d745:
CMP dword ptr [RBX + 0x8],0x0
JZ 0x0018d755
MOV EDI,0x2d
CALL 0x0010e080
LAB_0018d755:
MOV RAX,qword ptr [RBX + 0x10]
MOV RCX,0x7ffffffffffffffe
CMP RAX,RCX
JZ 0x0018d779
NEG RAX
JNO 0x0018d796
MOV EDI,0x30
CALL 0x0010e080
JMP 0x0018d787
LAB_0018d779:
LEA RDI,[0x1a1a42]
LAB_0018d780:
XOR EAX,EAX
CALL 0x0010e280
LAB_0018d787:
MOV EDI,0xa
POP RBX
POP R14
POP R15
JMP 0x0010e080
LAB_0018d796:
LEA RDI,[0x1a1a48]
XOR EAX,EAX
CALL 0x0010e280
MOV R15,qword ptr [RBX + 0x18]
MOV RAX,R15
DEC RAX
JS 0x0018d7d7
LEA R14,[0x1a1a50]
LAB_0018d7b7:
MOV RAX,qword ptr [RBX + 0x20]
MOV RDX,qword ptr [RAX + R15*0x8 + -0x8]
MOV RDI,R14
MOV ESI,0x13
XOR EAX,EAX
CALL 0x0010e280
DEC R15
TEST R15,R15
JG 0x0018d7b7
LAB_0018d7d7:
MOV RSI,qword ptr [RBX + 0x10]
LEA RDI,[0x1a1a56]
XOR EAX,EAX
CALL 0x0010e280
JMP 0x0018d787
|
/* WARNING: Removing unreachable block (ram,0x0018d76d) */
void bfdec_print_str(int8 param_1,long param_2)
{
char *__format;
long lVar1;
printf("%s=",param_1);
if (*(long *)(param_2 + 0x10) == 0x7fffffffffffffff) {
__format = "NaN";
}
else {
if (*(int *)(param_2 + 8) != 0) {
putchar(0x2d);
}
if (*(long *)(param_2 + 0x10) != 0x7ffffffffffffffe) {
printf("0.");
lVar1 = *(long *)(param_2 + 0x18);
if (-1 < lVar1 + -1) {
do {
printf("%0*lu",0x13,*(int8 *)(*(long *)(param_2 + 0x20) + -8 + lVar1 * 8));
lVar1 = lVar1 + -1;
} while (0 < lVar1);
}
printf("e%ld",*(int8 *)(param_2 + 0x10));
goto LAB_0018d787;
}
__format = "Inf";
}
printf(__format);
LAB_0018d787:
putchar(10);
return;
}
| |
41,251 | bfdec_print_str | bluesky950520[P]quickjs/libbf.c | void bfdec_print_str(const char *str, const bfdec_t *a)
{
slimb_t i;
printf("%s=", str);
if (a->expn == BF_EXP_NAN) {
printf("NaN");
} else {
if (a->sign)
putchar('-');
if (a->expn == BF_EXP_ZERO) {
putchar('0');
} else if (a->expn == BF_EXP_INF) {
printf("Inf");
} else {
printf("0.");
for(i = a->len - 1; i >= 0; i--)
printf("%0*" PRIu_LIMB, LIMB_DIGITS, a->tab[i]);
printf("e%" PRId_LIMB, a->expn);
}
}
printf("\n");
} | O3 | c | bfdec_print_str:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x14845(%rip), %rdi # 0xa49ee
xorl %eax, %eax
callq 0xe280
movq 0x10(%rbx), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, %rax
jne 0x901cc
leaq 0x11d4f(%rip), %rdi # 0xa1f19
jmp 0x90207
cmpl $0x0, 0x8(%rbx)
je 0x901e0
movl $0x2d, %edi
callq 0xe080
movq 0x10(%rbx), %rax
movabsq $0x7ffffffffffffffe, %rcx # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rcx, %rax
je 0x90200
negq %rax
jno 0x9021d
movl $0x30, %edi
callq 0xe080
jmp 0x9020e
leaq 0x147eb(%rip), %rdi # 0xa49f2
xorl %eax, %eax
callq 0xe280
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0xe080
leaq 0x147d4(%rip), %rdi # 0xa49f8
xorl %eax, %eax
callq 0xe280
movq 0x18(%rbx), %r15
movq %r15, %rax
decq %rax
js 0x9025b
leaq 0x147c2(%rip), %r14 # 0xa4a00
movq 0x20(%rbx), %rax
movq -0x8(%rax,%r15,8), %rdx
movq %r14, %rdi
movl $0x13, %esi
xorl %eax, %eax
callq 0xe280
decq %r15
jne 0x9023e
movq 0x10(%rbx), %rsi
leaq 0x147a0(%rip), %rdi # 0xa4a06
xorl %eax, %eax
callq 0xe280
jmp 0x9020e
| bfdec_print_str:
push r15
push r14
push rbx
mov rbx, rsi
mov rsi, rdi
lea rdi, aS_2; "%s="
xor eax, eax
call _printf
mov rax, [rbx+10h]
mov rcx, 7FFFFFFFFFFFFFFFh
cmp rax, rcx
jnz short loc_901CC
lea rdi, aDateValueIsNan+0Eh; "NaN"
jmp short loc_90207
loc_901CC:
cmp dword ptr [rbx+8], 0
jz short loc_901E0
mov edi, 2Dh ; '-'
call _putchar
mov rax, [rbx+10h]
loc_901E0:
mov rcx, 7FFFFFFFFFFFFFFEh
cmp rax, rcx
jz short loc_90200
neg rax
jno short loc_9021D
mov edi, 30h ; '0'
call _putchar
jmp short loc_9020E
loc_90200:
lea rdi, aInf; "Inf"
loc_90207:
xor eax, eax
call _printf
loc_9020E:
mov edi, 0Ah
pop rbx
pop r14
pop r15
jmp _putchar
loc_9021D:
lea rdi, a0x0+2; "0."
xor eax, eax
call _printf
mov r15, [rbx+18h]
mov rax, r15
dec rax
js short loc_9025B
lea r14, a0Lu; "%0*lu"
loc_9023E:
mov rax, [rbx+20h]
mov rdx, [rax+r15*8-8]
mov rdi, r14
mov esi, 13h
xor eax, eax
call _printf
dec r15
jnz short loc_9023E
loc_9025B:
mov rsi, [rbx+10h]
lea rdi, aELd; "e%ld"
xor eax, eax
call _printf
jmp short loc_9020E
| long long bfdec_print_str(const char *a1, long long a2)
{
long long v2; // rax
long long v4; // r15
printf("%s=", a1);
v2 = *(_QWORD *)(a2 + 16);
if ( v2 == 0x7FFFFFFFFFFFFFFFLL )
{
printf("NaN");
}
else
{
if ( *(_DWORD *)(a2 + 8) )
{
putchar(45LL);
v2 = *(_QWORD *)(a2 + 16);
}
if ( v2 == 0x7FFFFFFFFFFFFFFELL )
{
printf("Inf");
}
else if ( __OFSUB__(-v2, 1LL) )
{
putchar(48LL);
}
else
{
printf("0.");
v4 = *(_QWORD *)(a2 + 24);
if ( v4 - 1 >= 0 )
{
do
printf("%0*lu", 19, *(_QWORD *)(*(_QWORD *)(a2 + 32) + 8 * v4-- - 8));
while ( v4 );
}
printf("e%ld", *(_QWORD *)(a2 + 16));
}
}
return putchar(10LL);
}
| bfdec_print_str:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV RSI,RDI
LEA RDI,[0x1a49ee]
XOR EAX,EAX
CALL 0x0010e280
MOV RAX,qword ptr [RBX + 0x10]
MOV RCX,0x7fffffffffffffff
CMP RAX,RCX
JNZ 0x001901cc
LEA RDI,[0x1a1f19]
JMP 0x00190207
LAB_001901cc:
CMP dword ptr [RBX + 0x8],0x0
JZ 0x001901e0
MOV EDI,0x2d
CALL 0x0010e080
MOV RAX,qword ptr [RBX + 0x10]
LAB_001901e0:
MOV RCX,0x7ffffffffffffffe
CMP RAX,RCX
JZ 0x00190200
NEG RAX
JNO 0x0019021d
MOV EDI,0x30
CALL 0x0010e080
JMP 0x0019020e
LAB_00190200:
LEA RDI,[0x1a49f2]
LAB_00190207:
XOR EAX,EAX
CALL 0x0010e280
LAB_0019020e:
MOV EDI,0xa
POP RBX
POP R14
POP R15
JMP 0x0010e080
LAB_0019021d:
LEA RDI,[0x1a49f8]
XOR EAX,EAX
CALL 0x0010e280
MOV R15,qword ptr [RBX + 0x18]
MOV RAX,R15
DEC RAX
JS 0x0019025b
LEA R14,[0x1a4a00]
LAB_0019023e:
MOV RAX,qword ptr [RBX + 0x20]
MOV RDX,qword ptr [RAX + R15*0x8 + -0x8]
MOV RDI,R14
MOV ESI,0x13
XOR EAX,EAX
CALL 0x0010e280
DEC R15
JNZ 0x0019023e
LAB_0019025b:
MOV RSI,qword ptr [RBX + 0x10]
LEA RDI,[0x1a4a06]
XOR EAX,EAX
CALL 0x0010e280
JMP 0x0019020e
|
/* WARNING: Removing unreachable block (ram,0x001901f4) */
void bfdec_print_str(int8 param_1,long param_2)
{
char *__format;
long lVar1;
printf("%s=",param_1);
lVar1 = *(long *)(param_2 + 0x10);
if (lVar1 == 0x7fffffffffffffff) {
__format = "NaN";
}
else {
if (*(int *)(param_2 + 8) != 0) {
putchar(0x2d);
lVar1 = *(long *)(param_2 + 0x10);
}
if (lVar1 != 0x7ffffffffffffffe) {
printf("0.");
lVar1 = *(long *)(param_2 + 0x18);
if (-1 < lVar1 + -1) {
do {
printf("%0*lu",0x13,*(int8 *)(*(long *)(param_2 + 0x20) + -8 + lVar1 * 8));
lVar1 = lVar1 + -1;
} while (lVar1 != 0);
}
printf("e%ld",*(int8 *)(param_2 + 0x10));
goto LAB_0019020e;
}
__format = "Inf";
}
printf(__format);
LAB_0019020e:
putchar(10);
return;
}
| |
41,252 | ha_find_null | eloqsql/mysys/my_compare.c | HA_KEYSEG *ha_find_null(HA_KEYSEG *keyseg, const uchar *a)
{
for (; (enum ha_base_keytype) keyseg->type != HA_KEYTYPE_END; keyseg++)
{
const uchar *end;
if (keyseg->null_bit)
{
if (!*a++)
return keyseg;
}
end= a+ keyseg->length;
switch ((enum ha_base_keytype) keyseg->type) {
case HA_KEYTYPE_TEXT:
case HA_KEYTYPE_BINARY:
case HA_KEYTYPE_BIT:
if (keyseg->flag & HA_SPACE_PACK)
{
int a_length;
get_key_length(a_length, a);
a += a_length;
break;
}
else
a= end;
break;
case HA_KEYTYPE_VARTEXT1:
case HA_KEYTYPE_VARTEXT2:
case HA_KEYTYPE_VARBINARY1:
case HA_KEYTYPE_VARBINARY2:
{
int a_length;
get_key_length(a_length, a);
a+= a_length;
break;
}
case HA_KEYTYPE_NUM:
if (keyseg->flag & HA_SPACE_PACK)
{
int alength= *a++;
end= a+alength;
}
a= end;
break;
case HA_KEYTYPE_INT8:
case HA_KEYTYPE_SHORT_INT:
case HA_KEYTYPE_USHORT_INT:
case HA_KEYTYPE_LONG_INT:
case HA_KEYTYPE_ULONG_INT:
case HA_KEYTYPE_INT24:
case HA_KEYTYPE_UINT24:
#ifdef HAVE_LONG_LONG
case HA_KEYTYPE_LONGLONG:
case HA_KEYTYPE_ULONGLONG:
#endif
case HA_KEYTYPE_FLOAT:
case HA_KEYTYPE_DOUBLE:
a= end;
break;
case HA_KEYTYPE_END: /* purecov: inspected */
/* keep compiler happy */
DBUG_ASSERT(0);
break;
}
}
return keyseg;
} | O0 | c | ha_find_null:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x18(%rax), %eax
cmpl $0x0, %eax
je 0xf2732
movq -0x10(%rbp), %rax
cmpb $0x0, 0x19(%rax)
je 0xf25aa
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpb $0x0, (%rax)
jne 0xf25a8
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf273a
jmp 0xf25aa
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movzwl 0x14(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x18(%rax), %eax
movq %rax, -0x38(%rbp)
subq $0x13, %rax
ja 0xf271f
movq -0x38(%rbp), %rax
leaq 0x67252(%rip), %rcx # 0x159830
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movzwl 0x12(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xf265f
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
je 0xf261c
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movzbl (%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0xf2649
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
movzwl %ax, %eax
movq -0x18(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x18(%rbp)
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0xf271f
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xf271f
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
je 0xf2691
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movzbl (%rax), %eax
movl %eax, -0x28(%rbp)
jmp 0xf26be
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
movzwl %ax, %eax
movq -0x18(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x18(%rbp)
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0xf271f
movq -0x10(%rbp), %rax
movzwl 0x12(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xf2705
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xf271f
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xf271f
jmp 0xf271b
jmp 0xf271d
jmp 0xf271f
jmp 0xf2721
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
jmp 0xf256c
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
| ha_find_null:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
loc_F256C:
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+18h]
cmp eax, 0
jz loc_F2732
mov rax, [rbp+var_10]
cmp byte ptr [rax+19h], 0
jz short loc_F25AA
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
cmp byte ptr [rax], 0
jnz short loc_F25A8
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
jmp loc_F273A
loc_F25A8:
jmp short $+2
loc_F25AA:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
movzx ecx, word ptr [rcx+14h]
add rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+18h]
mov [rbp+var_38], rax
sub rax, 13h; switch 20 cases
ja def_F25E5; jumptable 00000000000F25E5 default case
mov rax, [rbp+var_38]
lea rcx, jpt_F25E5
movsxd rax, ds:(jpt_F25E5 - 159830h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_F25E7:
mov rax, [rbp+var_10]; jumptable 00000000000F25E5 cases 1,2,19
movzx eax, word ptr [rax+12h]
and eax, 1
cmp eax, 0
jz short loc_F265F
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
cmp eax, 0FFh
jz short loc_F261C
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
movzx eax, byte ptr [rax]
mov [rbp+var_24], eax
jmp short loc_F2649
loc_F261C:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+2]
movzx eax, ax
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+1]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
mov [rbp+var_24], eax
mov rax, [rbp+var_18]
add rax, 3
mov [rbp+var_18], rax
loc_F2649:
mov ecx, [rbp+var_24]
mov rax, [rbp+var_18]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_18], rax
jmp def_F25E5; jumptable 00000000000F25E5 default case
loc_F265F:
mov rax, [rbp+var_20]
mov [rbp+var_18], rax
jmp def_F25E5; jumptable 00000000000F25E5 default case
loc_F266C:
mov rax, [rbp+var_18]; jumptable 00000000000F25E5 cases 15-18
movzx eax, byte ptr [rax]
cmp eax, 0FFh
jz short loc_F2691
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
movzx eax, byte ptr [rax]
mov [rbp+var_28], eax
jmp short loc_F26BE
loc_F2691:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+2]
movzx eax, ax
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+1]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
mov [rbp+var_28], eax
mov rax, [rbp+var_18]
add rax, 3
mov [rbp+var_18], rax
loc_F26BE:
mov ecx, [rbp+var_28]
mov rax, [rbp+var_18]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_18], rax
jmp short def_F25E5; jumptable 00000000000F25E5 default case
loc_F26D1:
mov rax, [rbp+var_10]; jumptable 00000000000F25E5 case 7
movzx eax, word ptr [rax+12h]
and eax, 1
cmp eax, 0
jz short loc_F2705
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
movzx eax, byte ptr [rax]
mov [rbp+var_2C], eax
mov rax, [rbp+var_18]
movsxd rcx, [rbp+var_2C]
add rax, rcx
mov [rbp+var_20], rax
loc_F2705:
mov rax, [rbp+var_20]
mov [rbp+var_18], rax
jmp short def_F25E5; jumptable 00000000000F25E5 default case
loc_F270F:
mov rax, [rbp+var_20]; jumptable 00000000000F25E5 cases 3-6,8-14
mov [rbp+var_18], rax
jmp short def_F25E5; jumptable 00000000000F25E5 default case
loc_F2719:
jmp short $+2; jumptable 00000000000F25E5 case 0
loc_F271B:
jmp short $+2
loc_F271D:
jmp short $+2; jumptable 00000000000F25E5 default case
def_F25E5:
jmp short $+2; jumptable 00000000000F25E5 default case
loc_F2721:
mov rax, [rbp+var_10]
add rax, 20h ; ' '
mov [rbp+var_10], rax
jmp loc_F256C
loc_F2732:
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
loc_F273A:
mov rax, [rbp+var_8]
pop rbp
retn
| long long ha_find_null(long long a1, unsigned __int8 *a2)
{
unsigned __int8 *v2; // rax
unsigned __int8 *v3; // rax
unsigned __int8 *v4; // rax
int v6; // [rsp+10h] [rbp-28h]
int v7; // [rsp+14h] [rbp-24h]
long long v8; // [rsp+18h] [rbp-20h]
unsigned __int8 *v10; // [rsp+20h] [rbp-18h]
unsigned __int8 *v11; // [rsp+20h] [rbp-18h]
while ( *(_BYTE *)(a1 + 24) )
{
if ( *(_BYTE *)(a1 + 25) )
{
v2 = a2++;
if ( !*v2 )
return a1;
}
v8 = (long long)&a2[*(unsigned __int16 *)(a1 + 20)];
switch ( *(_BYTE *)(a1 + 24) )
{
case 1:
case 2:
case 0x13:
if ( (*(_WORD *)(a1 + 18) & 1) != 0 )
{
if ( *a2 == 255 )
{
v7 = _byteswap_ushort(*(_WORD *)(a2 + 1));
v10 = a2 + 3;
}
else
{
v3 = a2;
v10 = a2 + 1;
v7 = *v3;
}
a2 = &v10[v7];
}
else
{
a2 += *(unsigned __int16 *)(a1 + 20);
}
break;
case 3:
case 4:
case 5:
case 6:
case 8:
case 9:
case 0xA:
case 0xB:
case 0xC:
case 0xD:
case 0xE:
a2 += *(unsigned __int16 *)(a1 + 20);
break;
case 7:
if ( (*(_WORD *)(a1 + 18) & 1) != 0 )
v8 = (long long)&a2[*a2 + 1];
a2 = (unsigned __int8 *)v8;
break;
case 0xF:
case 0x10:
case 0x11:
case 0x12:
if ( *a2 == 255 )
{
v6 = _byteswap_ushort(*(_WORD *)(a2 + 1));
v11 = a2 + 3;
}
else
{
v4 = a2;
v11 = a2 + 1;
v6 = *v4;
}
a2 = &v11[v6];
break;
default:
break;
}
a1 += 32LL;
}
return a1;
}
| ha_find_null:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
LAB_001f256c:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x18]
CMP EAX,0x0
JZ 0x001f2732
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX + 0x19],0x0
JZ 0x001f25aa
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
CMP byte ptr [RAX],0x0
JNZ 0x001f25a8
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001f273a
LAB_001f25a8:
JMP 0x001f25aa
LAB_001f25aa:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,word ptr [RCX + 0x14]
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x38],RAX
SUB RAX,0x13
JA 0x001f271f
MOV RAX,qword ptr [RBP + -0x38]
LEA RCX,[0x259830]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,word ptr [RAX + 0x12]
AND EAX,0x1
CMP EAX,0x0
JZ 0x001f265f
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xff
JZ 0x001f261c
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x24],EAX
JMP 0x001f2649
LAB_001f261c:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x2]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x1]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x3
MOV qword ptr [RBP + -0x18],RAX
LAB_001f2649:
MOV ECX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001f271f
LAB_001f265f:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001f271f
caseD_f:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xff
JZ 0x001f2691
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x28],EAX
JMP 0x001f26be
LAB_001f2691:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x2]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x1]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
MOV dword ptr [RBP + -0x28],EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x3
MOV qword ptr [RBP + -0x18],RAX
LAB_001f26be:
MOV ECX,dword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001f271f
caseD_7:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,word ptr [RAX + 0x12]
AND EAX,0x1
CMP EAX,0x0
JZ 0x001f2705
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,dword ptr [RBP + -0x2c]
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
LAB_001f2705:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001f271f
caseD_3:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001f271f
caseD_0:
JMP 0x001f271b
LAB_001f271b:
JMP 0x001f271d
LAB_001f271d:
JMP 0x001f271f
default:
JMP 0x001f2721
LAB_001f2721:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x20
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001f256c
LAB_001f2732:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
LAB_001f273a:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
long ha_find_null(long param_1,byte *param_2)
{
byte bVar1;
byte *pbVar2;
uint local_30;
uint local_2c;
byte *local_28;
byte *local_20;
long local_18;
local_20 = param_2;
local_18 = param_1;
while ((*(char *)(local_18 + 0x18) != '\0' &&
((*(char *)(local_18 + 0x19) == '\0' ||
(bVar1 = *local_20, local_20 = local_20 + 1, bVar1 != 0))))) {
local_28 = local_20 + *(ushort *)(local_18 + 0x14);
pbVar2 = local_20;
switch(*(int1 *)(local_18 + 0x18)) {
case 0:
break;
case 1:
case 2:
case 0x13:
pbVar2 = local_28;
if ((*(ushort *)(local_18 + 0x12) & 1) != 0) {
if (*local_20 == 0xff) {
local_2c = (uint)CONCAT11(local_20[1],local_20[2]);
local_20 = local_20 + 3;
}
else {
local_2c = (uint)*local_20;
local_20 = local_20 + 1;
}
pbVar2 = local_20 + (int)local_2c;
}
break;
case 3:
case 4:
case 5:
case 6:
case 8:
case 9:
case 10:
case 0xb:
case 0xc:
case 0xd:
case 0xe:
pbVar2 = local_28;
break;
case 7:
if ((*(ushort *)(local_18 + 0x12) & 1) != 0) {
local_28 = local_20 + (long)(int)(uint)*local_20 + 1;
}
local_20 = local_28;
pbVar2 = local_20;
break;
case 0xf:
case 0x10:
case 0x11:
case 0x12:
if (*local_20 == 0xff) {
local_30 = (uint)CONCAT11(local_20[1],local_20[2]);
local_20 = local_20 + 3;
}
else {
local_30 = (uint)*local_20;
local_20 = local_20 + 1;
}
pbVar2 = local_20 + (int)local_30;
}
local_20 = pbVar2;
local_18 = local_18 + 0x20;
}
return local_18;
}
| |
41,253 | test_xjoin | eloqsql/tests/mysql_client_test.c | static void test_xjoin()
{
MYSQL_STMT *stmt;
int rc, i;
const char *query=
"select t.id, p1.value, n1.value, p2.value, n2.value from t3 t LEFT JOIN t1 p1 ON (p1.id=t.param1_id) LEFT JOIN t2 p2 ON (p2.id=t.param2_id) LEFT JOIN t4 n1 ON (n1.id=p1.name_id) LEFT JOIN t4 n2 ON (n2.id=p2.name_id) where t.id=1";
myheader("test_xjoin");
rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1, t2, t3, t4");
myquery(rc);
rc= mysql_query(mysql, "create table t3 (id int(8), param1_id int(8), param2_id int(8)) ENGINE=InnoDB DEFAULT CHARSET=utf8");
myquery(rc);
rc= mysql_query(mysql, "create table t1 ( id int(8), name_id int(8), value varchar(10)) ENGINE=InnoDB DEFAULT CHARSET=utf8");
myquery(rc);
rc= mysql_query(mysql, "create table t2 (id int(8), name_id int(8), value varchar(10)) ENGINE=InnoDB DEFAULT CHARSET=utf8;");
myquery(rc);
rc= mysql_query(mysql, "create table t4(id int(8), value varchar(10)) ENGINE=InnoDB DEFAULT CHARSET=utf8");
myquery(rc);
rc= mysql_query(mysql, "insert into t3 values (1, 1, 1), (2, 2, null)");
myquery(rc);
rc= mysql_query(mysql, "insert into t1 values (1, 1, 'aaa'), (2, null, 'bbb')");
myquery(rc);
rc= mysql_query(mysql, "insert into t2 values (1, 2, 'ccc')");
myquery(rc);
rc= mysql_query(mysql, "insert into t4 values (1, 'Name1'), (2, null)");
myquery(rc);
stmt= mysql_simple_prepare(mysql, query);
check_stmt(stmt);
for (i= 0; i < 3; i++)
{
rc= mysql_stmt_execute(stmt);
check_execute(stmt, rc);
rc= my_process_stmt_result(stmt);
DIE_UNLESS(rc == 1);
}
mysql_stmt_close(stmt);
rc= mysql_query(mysql, "DROP TABLE t1, t2, t3, t4");
myquery(rc);
} | O3 | c | test_xjoin:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpb $0x1, 0x3bcbe7(%rip) # 0x41a4c1
jg 0x5d955
movq 0x3426dd(%rip), %rbx # 0x39ffc0
movq (%rbx), %rdi
leaq 0x81bd7(%rip), %rdx # 0xdf4c4
movl $0x1, %esi
xorl %eax, %eax
callq 0x39240
movq (%rbx), %rdi
movl 0x3bce0a(%rip), %ecx # 0x41a70c
leal 0x1(%rcx), %eax
movl %eax, 0x3bce01(%rip) # 0x41a70c
movl 0x3bcdf6(%rip), %r8d # 0x41a708
movl 0x3bcbd3(%rip), %r9d # 0x41a4ec
leaq 0x8249d(%rip), %rax # 0xdfdbd
movq %rax, (%rsp)
leaq 0x82ea1(%rip), %rdx # 0xe07cc
movl $0x1, %esi
xorl %eax, %eax
callq 0x39240
movq (%rbx), %rdi
leaq 0x81bbb(%rip), %rdx # 0xdf4fc
movl $0x1, %esi
xorl %eax, %eax
callq 0x39240
movq (%rbx), %rdi
callq 0x394b0
movq 0x3bcb6c(%rip), %rdi # 0x41a4c8
leaq 0x8c589(%rip), %rsi # 0xe9eec
callq 0x3b116
testl %eax, %eax
jne 0x5daef
movq 0x3bcb51(%rip), %rdi # 0x41a4c8
leaq 0x8ca86(%rip), %rsi # 0xea404
callq 0x3b116
testl %eax, %eax
jne 0x5db0e
movq 0x3bcb36(%rip), %rdi # 0x41a4c8
leaq 0x8cace(%rip), %rsi # 0xea467
callq 0x3b116
testl %eax, %eax
jne 0x5db2d
movq 0x3bcb1b(%rip), %rdi # 0x41a4c8
leaq 0x8cb16(%rip), %rsi # 0xea4ca
callq 0x3b116
testl %eax, %eax
jne 0x5db4c
movq 0x3bcb00(%rip), %rdi # 0x41a4c8
leaq 0x8cb5e(%rip), %rsi # 0xea52d
callq 0x3b116
testl %eax, %eax
jne 0x5db6b
movq 0x3bcae5(%rip), %rdi # 0x41a4c8
leaq 0x8cb94(%rip), %rsi # 0xea57e
callq 0x3b116
testl %eax, %eax
jne 0x5db8a
movq 0x3bcaca(%rip), %rdi # 0x41a4c8
leaq 0x8cba7(%rip), %rsi # 0xea5ac
callq 0x3b116
testl %eax, %eax
jne 0x5dba9
movq 0x3bcaaf(%rip), %rdi # 0x41a4c8
leaq 0x8cbc2(%rip), %rsi # 0xea5e2
callq 0x3b116
testl %eax, %eax
jne 0x5dbc8
movq 0x3bca94(%rip), %rdi # 0x41a4c8
leaq 0x8cbcb(%rip), %rsi # 0xea606
callq 0x3b116
testl %eax, %eax
jne 0x5dbe7
movq 0x3bca79(%rip), %rdi # 0x41a4c8
leaq 0x8c8c9(%rip), %rsi # 0xea31f
callq 0x3ba15
testq %rax, %rax
je 0x5dc06
movq %rax, %rbx
movl $0x3, %r14d
movq %rbx, %rdi
callq 0x3b510
testl %eax, %eax
jne 0x5dacf
movq %rbx, %rdi
callq 0x3bc81
cmpl $0x1, %eax
jne 0x5dab7
decl %r14d
jne 0x5da6d
movq %rbx, %rdi
callq 0x3b639
movq 0x3bca2e(%rip), %rdi # 0x41a4c8
leaq 0x8cb93(%rip), %rsi # 0xea634
callq 0x3b116
testl %eax, %eax
jne 0x5dc25
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x812ee(%rip), %rdi # 0xdedac
leaq 0x83565(%rip), %rdx # 0xe102a
movl $0x27de, %esi # imm = 0x27DE
callq 0x3bb30
movq %rbx, %rdi
callq 0x3bbbe
leaq 0x812ce(%rip), %rdi # 0xdedac
leaq 0x8ce82(%rip), %rdx # 0xea967
movl $0x27dc, %esi # imm = 0x27DC
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x812af(%rip), %rdi # 0xdedac
leaq 0x975bb(%rip), %rdx # 0xf50bf
movl $0x27bc, %esi # imm = 0x27BC
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x81290(%rip), %rdi # 0xdedac
leaq 0x9759c(%rip), %rdx # 0xf50bf
movl $0x27bf, %esi # imm = 0x27BF
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x81271(%rip), %rdi # 0xdedac
leaq 0x9757d(%rip), %rdx # 0xf50bf
movl $0x27c2, %esi # imm = 0x27C2
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x81252(%rip), %rdi # 0xdedac
leaq 0x9755e(%rip), %rdx # 0xf50bf
movl $0x27c5, %esi # imm = 0x27C5
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x81233(%rip), %rdi # 0xdedac
leaq 0x9753f(%rip), %rdx # 0xf50bf
movl $0x27c8, %esi # imm = 0x27C8
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x81214(%rip), %rdi # 0xdedac
leaq 0x97520(%rip), %rdx # 0xf50bf
movl $0x27cb, %esi # imm = 0x27CB
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x811f5(%rip), %rdi # 0xdedac
leaq 0x97501(%rip), %rdx # 0xf50bf
movl $0x27ce, %esi # imm = 0x27CE
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x811d6(%rip), %rdi # 0xdedac
leaq 0x974e2(%rip), %rdx # 0xf50bf
movl $0x27d1, %esi # imm = 0x27D1
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x811b7(%rip), %rdi # 0xdedac
leaq 0x974c3(%rip), %rdx # 0xf50bf
movl $0x27d4, %esi # imm = 0x27D4
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x81198(%rip), %rdi # 0xdedac
leaq 0x80eef(%rip), %rdx # 0xdeb0a
movl $0x27d7, %esi # imm = 0x27D7
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x81179(%rip), %rdi # 0xdedac
leaq 0x97485(%rip), %rdx # 0xf50bf
movl $0x27e3, %esi # imm = 0x27E3
callq 0x3bb30
| test_xjoin:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 10h
cmp cs:opt_silent, 1
jg short loc_5D955
mov rbx, cs:stdout_ptr
mov rdi, [rbx]
lea rdx, asc_DF4C4; "\n\n###################################"...
mov esi, 1
xor eax, eax
call ___fprintf_chk
mov rdi, [rbx]
mov ecx, cs:test_count
lea eax, [rcx+1]
mov cs:test_count, eax
mov r8d, cs:iter_count
mov r9d, cs:opt_count
lea rax, aTestXjoin; "test_xjoin"
mov [rsp+20h+var_20], rax
lea rdx, aUOfUUS; "%u of (%u/%u): %s"
mov esi, 1
xor eax, eax
call ___fprintf_chk
mov rdi, [rbx]
lea rdx, asc_DF4FC; " \n###################################"...
mov esi, 1
xor eax, eax
call ___fprintf_chk
mov rdi, [rbx]
call _fflush
loc_5D955:
mov rdi, cs:mysql
lea rsi, aDropTableIfExi_65; "DROP TABLE IF EXISTS t1, t2, t3, t4"
call wrap_mysql_query
test eax, eax
jnz loc_5DAEF
mov rdi, cs:mysql
lea rsi, aCreateTableT3I; "create table t3 (id int(8), param1_id i"...
call wrap_mysql_query
test eax, eax
jnz loc_5DB0E
mov rdi, cs:mysql
lea rsi, aCreateTableT1I_6; "create table t1 ( id int(8), name_id in"...
call wrap_mysql_query
test eax, eax
jnz loc_5DB2D
mov rdi, cs:mysql
lea rsi, aCreateTableT2I_0; "create table t2 (id int(8), name_id int"...
call wrap_mysql_query
test eax, eax
jnz loc_5DB4C
mov rdi, cs:mysql
lea rsi, aCreateTableT4I; "create table t4(id int(8), value varcha"...
call wrap_mysql_query
test eax, eax
jnz loc_5DB6B
mov rdi, cs:mysql
lea rsi, aInsertIntoT3Va_0; "insert into t3 values (1, 1, 1), (2, 2,"...
call wrap_mysql_query
test eax, eax
jnz loc_5DB8A
mov rdi, cs:mysql
lea rsi, aInsertIntoT1Va_15; "insert into t1 values (1, 1, 'aaa'), (2"...
call wrap_mysql_query
test eax, eax
jnz loc_5DBA9
mov rdi, cs:mysql
lea rsi, aInsertIntoT2Va_4; "insert into t2 values (1, 2, 'ccc')"
call wrap_mysql_query
test eax, eax
jnz loc_5DBC8
mov rdi, cs:mysql
lea rsi, aInsertIntoT4Va; "insert into t4 values (1, 'Name1'), (2,"...
call wrap_mysql_query
test eax, eax
jnz loc_5DBE7
mov rdi, cs:mysql
lea rsi, aSelectTIdP1Val; "select t.id, p1.value, n1.value, p2.val"...
call mysql_simple_prepare
test rax, rax
jz loc_5DC06
mov rbx, rax
mov r14d, 3
loc_5DA6D:
mov rdi, rbx
call wrap_mysql_stmt_execute
test eax, eax
jnz short loc_5DACF
mov rdi, rbx
call my_process_stmt_result
cmp eax, 1
jnz short loc_5DAB7
dec r14d
jnz short loc_5DA6D
mov rdi, rbx
call wrap_mysql_stmt_close
mov rdi, cs:mysql
lea rsi, aDropTableT1T2T_0; "DROP TABLE t1, t2, t3, t4"
call wrap_mysql_query
test eax, eax
jnz loc_5DC25
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
loc_5DAB7:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aRc1; "rc == 1"
mov esi, 27DEh
call die
loc_5DACF:
mov rdi, rbx
call print_st_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aRcMysqlDataTru+1Eh; "rc == 0"
mov esi, 27DCh
call die
loc_5DAEF:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 27BCh
call die
loc_5DB0E:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 27BFh
call die
loc_5DB2D:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 27C2h
call die
loc_5DB4C:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 27C5h
call die
loc_5DB6B:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 27C8h
call die
loc_5DB8A:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 27CBh
call die
loc_5DBA9:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 27CEh
call die
loc_5DBC8:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 27D1h
call die
loc_5DBE7:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 27D4h
call die
loc_5DC06:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aStmt0; "stmt != 0"
mov esi, 27D7h
call die
loc_5DC25:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 27E3h
call die
| long long test_xjoin()
{
int v0; // ecx
long long v1; // rax
long long v2; // rbx
int v3; // r14d
long long result; // rax
if ( opt_silent <= 1 )
{
__fprintf_chk(stdout, 1LL, "\n\n#####################################\n");
v0 = test_count++;
__fprintf_chk(stdout, 1LL, "%u of (%u/%u): %s", v0, iter_count, opt_count, "test_xjoin");
__fprintf_chk(stdout, 1LL, " \n#####################################\n");
fflush(stdout);
}
if ( (unsigned int)wrap_mysql_query(mysql, (long long)"DROP TABLE IF EXISTS t1, t2, t3, t4") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 10172, "r == 0");
}
if ( (unsigned int)wrap_mysql_query(
mysql,
(long long)"create table t3 (id int(8), param1_id int(8), param2_id int(8)) ENGINE=InnoDB DEFAULT CHARSET=utf8") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 10175, "r == 0");
}
if ( (unsigned int)wrap_mysql_query(
mysql,
(long long)"create table t1 ( id int(8), name_id int(8), value varchar(10)) ENGINE=InnoDB DEFAULT CHARSET=utf8") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 10178, "r == 0");
}
if ( (unsigned int)wrap_mysql_query(
mysql,
(long long)"create table t2 (id int(8), name_id int(8), value varchar(10)) ENGINE=InnoDB DEFAULT CHARSET=utf8;") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 10181, "r == 0");
}
if ( (unsigned int)wrap_mysql_query(
mysql,
(long long)"create table t4(id int(8), value varchar(10)) ENGINE=InnoDB DEFAULT CHARSET=utf8") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 10184, "r == 0");
}
if ( (unsigned int)wrap_mysql_query(mysql, (long long)"insert into t3 values (1, 1, 1), (2, 2, null)") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 10187, "r == 0");
}
if ( (unsigned int)wrap_mysql_query(mysql, (long long)"insert into t1 values (1, 1, 'aaa'), (2, null, 'bbb')") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 10190, "r == 0");
}
if ( (unsigned int)wrap_mysql_query(mysql, (long long)"insert into t2 values (1, 2, 'ccc')") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 10193, "r == 0");
}
if ( (unsigned int)wrap_mysql_query(mysql, (long long)"insert into t4 values (1, 'Name1'), (2, null)") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 10196, "r == 0");
}
v1 = mysql_simple_prepare(
mysql,
(long long)"select t.id, p1.value, n1.value, p2.value, n2.value from t3 t LEFT JOIN t1 p1 ON (p1.id=t.param1_id) L"
"EFT JOIN t2 p2 ON (p2.id=t.param2_id) LEFT JOIN t4 n1 ON (n1.id=p1.name_id) LEFT JOIN t4 n2 ON (n2.id="
"p2.name_id) where t.id=1");
if ( !v1 )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 10199, "stmt != 0");
}
v2 = v1;
v3 = 3;
do
{
if ( (unsigned int)wrap_mysql_stmt_execute(v2) )
{
print_st_error(v2);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 10204, "rc == 0");
}
if ( (unsigned int)my_process_stmt_result(v2) != 1 )
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 10206, "rc == 1");
--v3;
}
while ( v3 );
wrap_mysql_stmt_close(v2);
result = wrap_mysql_query(mysql, (long long)"DROP TABLE t1, t2, t3, t4");
if ( (_DWORD)result )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 10211, "r == 0");
}
return result;
}
| test_xjoin:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x10
CMP byte ptr [0x0051a4c1],0x1
JG 0x0015d955
MOV RBX,qword ptr [0x0049ffc0]
MOV RDI,qword ptr [RBX]
LEA RDX,[0x1df4c4]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x00139240
MOV RDI,qword ptr [RBX]
MOV ECX,dword ptr [0x0051a70c]
LEA EAX,[RCX + 0x1]
MOV dword ptr [0x0051a70c],EAX
MOV R8D,dword ptr [0x0051a708]
MOV R9D,dword ptr [0x0051a4ec]
LEA RAX,[0x1dfdbd]
MOV qword ptr [RSP],RAX
LEA RDX,[0x1e07cc]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x00139240
MOV RDI,qword ptr [RBX]
LEA RDX,[0x1df4fc]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x00139240
MOV RDI,qword ptr [RBX]
CALL 0x001394b0
LAB_0015d955:
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1e9eec]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x0015daef
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1ea404]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x0015db0e
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1ea467]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x0015db2d
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1ea4ca]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x0015db4c
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1ea52d]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x0015db6b
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1ea57e]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x0015db8a
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1ea5ac]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x0015dba9
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1ea5e2]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x0015dbc8
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1ea606]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x0015dbe7
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1ea31f]
CALL 0x0013ba15
TEST RAX,RAX
JZ 0x0015dc06
MOV RBX,RAX
MOV R14D,0x3
LAB_0015da6d:
MOV RDI,RBX
CALL 0x0013b510
TEST EAX,EAX
JNZ 0x0015dacf
MOV RDI,RBX
CALL 0x0013bc81
CMP EAX,0x1
JNZ 0x0015dab7
DEC R14D
JNZ 0x0015da6d
MOV RDI,RBX
CALL 0x0013b639
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1ea634]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x0015dc25
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
LAB_0015dab7:
LEA RDI,[0x1dedac]
LEA RDX,[0x1e102a]
MOV ESI,0x27de
CALL 0x0013bb30
LAB_0015dacf:
MOV RDI,RBX
CALL 0x0013bbbe
LEA RDI,[0x1dedac]
LEA RDX,[0x1ea967]
MOV ESI,0x27dc
CALL 0x0013bb30
LAB_0015daef:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0x27bc
CALL 0x0013bb30
LAB_0015db0e:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0x27bf
CALL 0x0013bb30
LAB_0015db2d:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0x27c2
CALL 0x0013bb30
LAB_0015db4c:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0x27c5
CALL 0x0013bb30
LAB_0015db6b:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0x27c8
CALL 0x0013bb30
LAB_0015db8a:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0x27cb
CALL 0x0013bb30
LAB_0015dba9:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0x27ce
CALL 0x0013bb30
LAB_0015dbc8:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0x27d1
CALL 0x0013bb30
LAB_0015dbe7:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0x27d4
CALL 0x0013bb30
LAB_0015dc06:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1deb0a]
MOV ESI,0x27d7
CALL 0x0013bb30
LAB_0015dc25:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0x27e3
CALL 0x0013bb30
|
void test_xjoin(void)
{
int *puVar1;
int iVar2;
int iVar3;
long lVar4;
puVar1 = PTR_stdout_0049ffc0;
if (opt_silent < '\x02') {
__fprintf_chk(*(int8 *)PTR_stdout_0049ffc0,1,"\n\n#####################################\n"
);
iVar2 = test_count;
test_count = test_count + 1;
__fprintf_chk(*(int8 *)puVar1,1,"%u of (%u/%u): %s",iVar2,iter_count,opt_count,
"test_xjoin");
__fprintf_chk(*(int8 *)puVar1,1," \n#####################################\n");
fflush(*(FILE **)puVar1);
}
iVar2 = wrap_mysql_query(mysql,"DROP TABLE IF EXISTS t1, t2, t3, t4");
if (iVar2 != 0) {
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x27bc,"r == 0");
}
iVar2 = wrap_mysql_query(mysql,
"create table t3 (id int(8), param1_id int(8), param2_id int(8)) ENGINE=InnoDB DEFAULT CHARSET=utf8"
);
if (iVar2 != 0) {
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x27bf,"r == 0");
}
iVar2 = wrap_mysql_query(mysql,
"create table t1 ( id int(8), name_id int(8), value varchar(10)) ENGINE=InnoDB DEFAULT CHARSET=utf8"
);
if (iVar2 != 0) {
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x27c2,"r == 0");
}
iVar2 = wrap_mysql_query(mysql,
"create table t2 (id int(8), name_id int(8), value varchar(10)) ENGINE=InnoDB DEFAULT CHARSET=utf8;"
);
if (iVar2 != 0) {
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x27c5,"r == 0");
}
iVar2 = wrap_mysql_query(mysql,
"create table t4(id int(8), value varchar(10)) ENGINE=InnoDB DEFAULT CHARSET=utf8"
);
if (iVar2 != 0) {
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x27c8,"r == 0");
}
iVar2 = wrap_mysql_query(mysql,"insert into t3 values (1, 1, 1), (2, 2, null)");
if (iVar2 != 0) {
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x27cb,"r == 0");
}
iVar2 = wrap_mysql_query(mysql,"insert into t1 values (1, 1, \'aaa\'), (2, null, \'bbb\')");
if (iVar2 == 0) {
iVar2 = wrap_mysql_query(mysql,"insert into t2 values (1, 2, \'ccc\')");
if (iVar2 != 0) {
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x27d1,"r == 0");
}
iVar2 = wrap_mysql_query(mysql,"insert into t4 values (1, \'Name1\'), (2, null)");
if (iVar2 == 0) {
lVar4 = mysql_simple_prepare
(mysql,
"select t.id, p1.value, n1.value, p2.value, n2.value from t3 t LEFT JOIN t1 p1 ON (p1.id=t.param1_id) LEFT JOIN t2 p2 ON (p2.id=t.param2_id) LEFT JOIN t4 n1 ON (n1.id=p1.name_id) LEFT JOIN t4 n2 ON (n2.id=p2.name_id) where t.id=1"
);
if (lVar4 == 0) {
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x27d7,"stmt != 0")
;
}
iVar2 = 3;
while( true ) {
iVar3 = wrap_mysql_stmt_execute(lVar4);
if (iVar3 != 0) {
print_st_error(lVar4);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x27dc,"rc == 0")
;
}
iVar3 = my_process_stmt_result(lVar4);
if (iVar3 != 1) break;
iVar2 = iVar2 + -1;
if (iVar2 == 0) {
wrap_mysql_stmt_close(lVar4);
iVar2 = wrap_mysql_query(mysql,"DROP TABLE t1, t2, t3, t4");
if (iVar2 == 0) {
return;
}
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x27e3,"r == 0");
}
}
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x27de,"rc == 1");
}
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x27d4,"r == 0");
}
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x27ce,"r == 0");
}
| |
41,254 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | monkey531[P]llama/common/json.hpp | const_reference operator[](const typename object_t::key_type& key) const
{
// const operator[] only works for objects
if (JSON_HEDLEY_LIKELY(is_object()))
{
auto it = m_data.m_value.object->find(key);
JSON_ASSERT(it != m_data.m_value.object->end());
return it->second;
}
JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
} | O2 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0x7e99e
movq 0x8(%r14), %rdi
callq 0x7ea42
movq 0x8(%r14), %rcx
cmpq 0x8(%rcx), %rax
je 0x7e9fa
addq $0x20, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x24460
movq %rax, %rbx
movq %r14, %rdi
callq 0x434f0
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x383a4(%rip), %rsi # 0xb6d64
leaq 0x10(%rsp), %rdi
callq 0x7e731
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x131, %esi # imm = 0x131
movq %r14, %rcx
callq 0x63472
xorl %ebp, %ebp
leaq 0x7f54d(%rip), %rsi # 0xfdf38
leaq -0x3e972(%rip), %rdx # 0x40080
movq %rbx, %rdi
callq 0x24ee0
leaq 0x331e5(%rip), %rdi # 0xb1be6
leaq 0x2d738(%rip), %rdx # 0xac140
leaq 0x38388(%rip), %rcx # 0xb6d97
movl $0x53ca, %esi # imm = 0x53CA
xorl %eax, %eax
callq 0x24e90
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x251b8
testb %bpl, %bpl
jne 0x7ea32
jmp 0x7ea3a
movq %rax, %r14
movq %rbx, %rdi
callq 0x24670
movq %r14, %rdi
callq 0x24f60
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixERKS9_:
push rbp; char
push r14; int
push rbx; int
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 1
jnz short loc_7E99E
mov rdi, [r14+8]
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findERSH_; nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::find(std::string const&)
mov rcx, [r14+8]
cmp rax, [rcx+8]
jz short loc_7E9FA
add rax, 20h ; ' '
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_7E99E:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aCannotUseOpera_0; "cannot use operator[] with a string arg"...
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA51_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[51],char const*>(char const(&)[51],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 131h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_7E9FA:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aItMDataMValueO; "it != m_data.m_value.object->end()"
mov esi, 53CAh
xor eax, eax
call _ggml_abort
mov r14, rax
lea rdi, [rsp+48h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_7EA32
jmp short loc_7EA3A
mov r14, rax
loc_7EA32:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_7EA3A:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[](
long long a1)
{
void *v1; // rbx
char v2; // bp
long long v3; // rax
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // rbx
long long v6; // r14
const char *v7; // [rsp+8h] [rbp-40h] BYREF
_BYTE v8[56]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
v7 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[51],char const*>(
(long long)v8,
(long long)"cannot use operator[] with a string argument with ",
&v7);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
305,
(long long)v8);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v3 = 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>>>>::find(*(_QWORD *)(a1 + 8));
if ( v3 == *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL) )
{
v6 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
21450LL,
"GGML_ASSERT(%s) failed",
"it != m_data.m_value.object->end()");
std::string::~string(v8);
if ( v2 )
__cxa_free_exception(v1);
_Unwind_Resume(v6);
}
return v3 + 32;
}
| operator[]:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x1
JNZ 0x0017e99e
MOV RDI,qword ptr [R14 + 0x8]
CALL 0x0017ea42
MOV RCX,qword ptr [R14 + 0x8]
CMP RAX,qword ptr [RCX + 0x8]
JZ 0x0017e9fa
ADD RAX,0x20
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_0017e99e:
PUSH 0x20
POP RDI
CALL 0x00124460
MOV RBX,RAX
MOV RDI,R14
CALL 0x001434f0
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_0017e9b9:
LEA RSI,[0x1b6d64]
LEA RDI,[RSP + 0x10]
CALL 0x0017e731
MOV BPL,0x1
LAB_0017e9cd:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x131
MOV RCX,R14
CALL 0x00163472
XOR EBP,EBP
LEA RSI,[0x1fdf38]
LEA RDX,[0x140080]
MOV RDI,RBX
CALL 0x00124ee0
LAB_0017e9fa:
LEA RDI,[0x1b1be6]
LEA RDX,[0x1ac140]
LEA RCX,[0x1b6d97]
MOV ESI,0x53ca
XOR EAX,EAX
CALL 0x00124e90
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::operator[](std::__cxx11::string const&) const */
long __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[](basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,string *param_1)
{
long lVar1;
int8 uVar2;
char *local_40;
detail local_38 [32];
if (*this != (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1) {
uVar2 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 0017e9b9 to 0017e9c9 has its CatchHandler @ 0017ea2f */
detail::concat<std::__cxx11::string,char_const(&)[51],char_const*>
(local_38,"cannot use operator[] with a string argument with ",&local_40);
/* try { // try from 0017e9cd to 0017e9f9 has its CatchHandler @ 0017ea1b */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar2,0x131,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,&detail::type_error::typeinfo,detail::exception::~exception);
}
lVar1 = 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>>>>
::find(*(ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)(this + 8),param_1);
if (lVar1 != *(long *)(*(long *)(this + 8) + 8)) {
return lVar1 + 0x20;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x53ca,
"GGML_ASSERT(%s) failed","it != m_data.m_value.object->end()");
}
| |
41,255 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | monkey531[P]llama/common/json.hpp | const_reference operator[](const typename object_t::key_type& key) const
{
// const operator[] only works for objects
if (JSON_HEDLEY_LIKELY(is_object()))
{
auto it = m_data.m_value.object->find(key);
JSON_ASSERT(it != m_data.m_value.object->end());
return it->second;
}
JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
} | O3 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0xab68a
movq 0x8(%r14), %rdi
callq 0xab742
movq 0x8(%r14), %rcx
cmpq 0x8(%rcx), %rax
je 0xab6e8
addq $0x20, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x1b440
movq %rax, %rbx
movq %r14, %rdi
callq 0x5eb8c
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x476c6(%rip), %rsi # 0xf2d74
leaq 0x10(%rsp), %rdi
callq 0xab3d1
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x131, %esi # imm = 0x131
movq %r14, %rcx
callq 0x8649a
xorl %ebp, %ebp
leaq 0x8085f(%rip), %rsi # 0x12bf38
leaq -0x5091e(%rip), %rdx # 0x5adc2
movq %rbx, %rdi
callq 0x1bef0
leaq 0x424f4(%rip), %rdi # 0xedbe3
leaq 0x3ca4a(%rip), %rdx # 0xe8140
leaq 0x476aa(%rip), %rcx # 0xf2da7
movl $0x53ca, %esi # imm = 0x53CA
xorl %eax, %eax
callq 0x1be80
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xab727
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1b8b0
testb %bpl, %bpl
jne 0xab731
jmp 0xab739
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b650
movq %r14, %rdi
callq 0x1bf70
nop
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixERKS9_:
push rbp; char
push r14; int
push rbx; __int64
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 1
jnz short loc_AB68A
mov rdi, [r14+8]
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findERSH_; nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::find(std::string const&)
mov rcx, [r14+8]
cmp rax, [rcx+8]
jz short loc_AB6E8
add rax, 20h ; ' '
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_AB68A:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aCannotUseOpera_0; "cannot use operator[] with a string arg"...
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA51_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[51],char const*>(char const(&)[51],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 131h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_AB6E8:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aItMDataMValueO; "it != m_data.m_value.object->end()"
mov esi, 53CAh
xor eax, eax
call _ggml_abort
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_AB727
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AB727:
test bpl, bpl
jnz short loc_AB731
jmp short loc_AB739
mov r14, rax
loc_AB731:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_AB739:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[](
long long a1)
{
void *v1; // rbx
char v2; // bp
long long v3; // rax
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
long long v6; // r14
const char *v7; // [rsp+8h] [rbp-40h] BYREF
void *v8[2]; // [rsp+10h] [rbp-38h] BYREF
long long v9; // [rsp+20h] [rbp-28h] BYREF
if ( *(_BYTE *)a1 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v7 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[51],char const*>(
(long long)v8,
(long long)"cannot use operator[] with a string argument with ",
&v7);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
305,
v8);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v3 = 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>>>>::find(*(_QWORD *)(a1 + 8));
if ( v3 == *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL) )
{
v6 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
21450LL,
"GGML_ASSERT(%s) failed",
"it != m_data.m_value.object->end()");
if ( v8[0] != &v9 )
operator delete(v8[0], v9 + 1);
if ( v2 )
__cxa_free_exception(v1);
_Unwind_Resume(v6);
}
return v3 + 32;
}
| |||
41,256 | js_parseFloat | bluesky950520[P]quickjs/quickjs.c | static JSValue js_parseFloat(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
const char *str;
JSValue ret;
int flags;
size_t len;
str = JS_ToCStringLen(ctx, &len, argv[0]);
if (!str)
return JS_EXCEPTION;
flags = ATOD_TRIM_SPACES | ATOD_ACCEPT_FLOAT | ATOD_ACCEPT_INFINITY;
ret = js_atof(ctx, str, len, NULL, 10, flags);
JS_FreeCString(ctx, str);
return ret;
} | O1 | c | js_parseFloat:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq (%r8), %rdx
movq 0x8(%r8), %rcx
movq %rsp, %rsi
xorl %ebx, %ebx
xorl %r8d, %r8d
callq 0x1ffe3
testq %rax, %rax
je 0x787f7
movq %rax, %r12
movq (%rsp), %rdx
movq %r15, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
movl $0xa, %r8d
movl $0xd, %r9d
callq 0x3d9fa
movq %rax, %rbx
movq %rdx, %r14
movq 0x18(%r15), %rdi
movl -0x18(%r12), %eax
leal -0x1(%rax), %ecx
movl %ecx, -0x18(%r12)
cmpl $0x1, %eax
jg 0x787fd
addq $-0x18, %r12
movq %r12, %rsi
movq $-0x7, %rdx
callq 0x20652
jmp 0x787fd
movl $0x6, %r14d
movq %rbx, %rax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| js_parseFloat:
push r15
push r14
push r12
push rbx
push rax
mov r15, rdi
mov rdx, [r8]
mov rcx, [r8+8]
mov rsi, rsp
xor ebx, ebx
xor r8d, r8d
call JS_ToCStringLen2
test rax, rax
jz short loc_787F7
mov r12, rax
mov rdx, [rsp+28h+var_28]
mov rdi, r15
mov rsi, rax
xor ecx, ecx
mov r8d, 0Ah
mov r9d, 0Dh
call js_atof
mov rbx, rax
mov r14, rdx
mov rdi, [r15+18h]
mov eax, [r12-18h]
lea ecx, [rax-1]
mov [r12-18h], ecx
cmp eax, 1
jg short loc_787FD
add r12, 0FFFFFFFFFFFFFFE8h
mov rsi, r12
mov rdx, 0FFFFFFFFFFFFFFF9h
call js_free_value_rt
jmp short loc_787FD
loc_787F7:
mov r14d, 6
loc_787FD:
mov rax, rbx
mov rdx, r14
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long js_parseFloat(long long a1, double a2, __m128d a3, long long a4, long long a5, long long a6, long long *a7)
{
long long v7; // rax
long long v8; // rbx
unsigned __int8 *v9; // rax
unsigned __int8 *v10; // r12
long long v11; // r8
long long v12; // r9
long long v13; // rdi
int v14; // eax
long long v15; // rcx
long long v17[5]; // [rsp+0h] [rbp-28h] BYREF
v17[0] = v7;
v8 = 0LL;
v9 = (unsigned __int8 *)JS_ToCStringLen2(a1, v17, *a7, a7[1], 0);
if ( v9 )
{
v10 = v9;
v8 = js_atof(a1, v9, v17[0], 0LL, 10, 13, a2, a3);
v13 = *(_QWORD *)(a1 + 24);
v14 = *((_DWORD *)v10 - 6);
v15 = (unsigned int)(v14 - 1);
*((_DWORD *)v10 - 6) = v15;
if ( v14 <= 1 )
js_free_value_rt(v13, (_QWORD *)v10 - 3, -7LL, v15, v11, v12);
}
return v8;
}
| js_parseFloat:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDI
MOV RDX,qword ptr [R8]
MOV RCX,qword ptr [R8 + 0x8]
MOV RSI,RSP
XOR EBX,EBX
XOR R8D,R8D
CALL 0x0011ffe3
TEST RAX,RAX
JZ 0x001787f7
MOV R12,RAX
MOV RDX,qword ptr [RSP]
MOV RDI,R15
MOV RSI,RAX
XOR ECX,ECX
MOV R8D,0xa
MOV R9D,0xd
CALL 0x0013d9fa
MOV RBX,RAX
MOV R14,RDX
MOV RDI,qword ptr [R15 + 0x18]
MOV EAX,dword ptr [R12 + -0x18]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R12 + -0x18],ECX
CMP EAX,0x1
JG 0x001787fd
ADD R12,-0x18
MOV RSI,R12
MOV RDX,-0x7
CALL 0x00120652
JMP 0x001787fd
LAB_001787f7:
MOV R14D,0x6
LAB_001787fd:
MOV RAX,RBX
MOV RDX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int1 [16] js_parseFloat(long param_1)
{
int iVar1;
int8 uVar2;
int8 in_RAX;
long lVar3;
int8 *in_R8;
int1 auVar4 [16];
int8 local_28;
local_28 = in_RAX;
lVar3 = JS_ToCStringLen2(param_1,&local_28,*in_R8,in_R8[1],0);
if (lVar3 == 0) {
auVar4 = ZEXT816(6) << 0x40;
}
else {
auVar4 = js_atof(param_1,lVar3,local_28,0,10,0xd);
uVar2 = *(int8 *)(param_1 + 0x18);
iVar1 = *(int *)(lVar3 + -0x18);
*(int *)(lVar3 + -0x18) = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(uVar2,lVar3 + -0x18,0xfffffffffffffff9);
}
}
return auVar4;
}
| |
41,257 | common_log::pause() | monkey531[P]llama/common/log.cpp | void pause() {
{
std::lock_guard<std::mutex> lock(mtx);
if (!running) {
return;
}
running = false;
// push an entry to signal the worker thread to stop
{
auto & entry = entries[tail];
entry.is_end = true;
tail = (tail + 1) % entries.size();
}
cv.notify_one();
}
thrd.join();
} | O3 | cpp | common_log::pause():
pushq %rbx
movq %rdi, %rbx
callq 0x1bcc0
testl %eax, %eax
jne 0xcc6fb
cmpb $0x0, 0x6a(%rbx)
je 0xcc6f2
movb $0x0, 0x6a(%rbx)
movq 0x78(%rbx), %rcx
movq 0x98(%rbx), %rax
leaq (%rax,%rax,2), %rdx
shlq $0x4, %rdx
movb $0x1, 0x28(%rcx,%rdx)
incq %rax
movq 0x80(%rbx), %rdx
subq %rcx, %rdx
sarq $0x4, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, 0x98(%rbx)
leaq 0x30(%rbx), %rdi
callq 0x1b450
movq %rbx, %rdi
callq 0x1b6a0
addq $0x28, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x1bef0
movq %rbx, %rdi
popq %rbx
jmp 0x1b6a0
movl %eax, %edi
callq 0x1b5d0
| _ZN10common_log5pauseEv:
push rbx
mov rbx, rdi
call _pthread_mutex_lock
test eax, eax
jnz short loc_CC6FB
cmp byte ptr [rbx+6Ah], 0
jz short loc_CC6F2
mov byte ptr [rbx+6Ah], 0
mov rcx, [rbx+78h]
mov rax, [rbx+98h]
lea rdx, [rax+rax*2]
shl rdx, 4
mov byte ptr [rcx+rdx+28h], 1
inc rax
mov rdx, [rbx+80h]
sub rdx, rcx
sar rdx, 4
mov rcx, 0AAAAAAAAAAAAAAABh
imul rcx, rdx
xor edx, edx
div rcx
mov [rbx+98h], rdx
lea rdi, [rbx+30h]; this
call __ZNSt18condition_variable10notify_oneEv; std::condition_variable::notify_one(void)
mov rdi, rbx
call _pthread_mutex_unlock
add rbx, 28h ; '('
mov rdi, rbx; this
pop rbx
jmp __ZNSt6thread4joinEv; std::thread::join(void)
loc_CC6F2:
mov rdi, rbx
pop rbx
jmp _pthread_mutex_unlock
loc_CC6FB:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
| long long common_log::pause(common_log *this)
{
int v1; // eax
long long v2; // rcx
long long v3; // rax
v1 = pthread_mutex_lock();
if ( v1 )
std::__throw_system_error(v1);
if ( !*((_BYTE *)this + 106) )
return pthread_mutex_unlock(this);
*((_BYTE *)this + 106) = 0;
v2 = *((_QWORD *)this + 15);
v3 = *((_QWORD *)this + 19);
*(_BYTE *)(v2 + 48 * v3 + 40) = 1;
*((_QWORD *)this + 19) = (v3 + 1) % (0xAAAAAAAAAAAAAAABLL * ((*((_QWORD *)this + 16) - v2) >> 4));
std::condition_variable::notify_one((common_log *)((char *)this + 48));
pthread_mutex_unlock(this);
return std::thread::join((common_log *)((char *)this + 40));
}
| pause:
PUSH RBX
MOV RBX,RDI
CALL 0x0011bcc0
TEST EAX,EAX
JNZ 0x001cc6fb
CMP byte ptr [RBX + 0x6a],0x0
JZ 0x001cc6f2
MOV byte ptr [RBX + 0x6a],0x0
MOV RCX,qword ptr [RBX + 0x78]
MOV RAX,qword ptr [RBX + 0x98]
LEA RDX,[RAX + RAX*0x2]
SHL RDX,0x4
MOV byte ptr [RCX + RDX*0x1 + 0x28],0x1
INC RAX
MOV RDX,qword ptr [RBX + 0x80]
SUB RDX,RCX
SAR RDX,0x4
MOV RCX,-0x5555555555555555
IMUL RCX,RDX
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBX + 0x98],RDX
LEA RDI,[RBX + 0x30]
CALL 0x0011b450
MOV RDI,RBX
CALL 0x0011b6a0
ADD RBX,0x28
MOV RDI,RBX
POP RBX
JMP 0x0011bef0
LAB_001cc6f2:
MOV RDI,RBX
POP RBX
JMP 0x0011b6a0
LAB_001cc6fb:
MOV EDI,EAX
CALL 0x0011b5d0
|
/* common_log::pause() */
void __thiscall common_log::pause(common_log *this)
{
long lVar1;
long lVar2;
int iVar3;
iVar3 = pthread_mutex_lock((pthread_mutex_t *)this);
if (iVar3 != 0) {
/* WARNING: Subroutine does not return */
std::__throw_system_error(iVar3);
}
if (this[0x6a] != (common_log)0x0) {
this[0x6a] = (common_log)0x0;
lVar1 = *(long *)(this + 0x78);
lVar2 = *(long *)(this + 0x98);
*(int1 *)(lVar1 + 0x28 + lVar2 * 0x30) = 1;
*(ulong *)(this + 0x98) =
(lVar2 + 1U) % (ulong)((*(long *)(this + 0x80) - lVar1 >> 4) * -0x5555555555555555);
std::condition_variable::notify_one();
pthread_mutex_unlock((pthread_mutex_t *)this);
std::thread::join();
return;
}
pthread_mutex_unlock((pthread_mutex_t *)this);
return;
}
| |
41,258 | thr_lock_init | eloqsql/mysys/thr_lock.c | void thr_lock_init(THR_LOCK *lock)
{
DBUG_ENTER("thr_lock_init");
bzero((char*) lock,sizeof(*lock));
mysql_mutex_init(key_THR_LOCK_mutex, &lock->mutex, MY_MUTEX_INIT_FAST);
lock->read.last= &lock->read.data;
lock->read_wait.last= &lock->read_wait.data;
lock->write_wait.last= &lock->write_wait.data;
lock->write.last= &lock->write.data;
mysql_mutex_lock(&THR_LOCK_lock); /* Add to locks in use */
lock->list.data=(void*) lock;
thr_lock_thread_list=list_add(thr_lock_thread_list,&lock->list);
mysql_mutex_unlock(&THR_LOCK_lock);
DBUG_VOID_RETURN;
} | O0 | c | thr_lock_init:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0xf8, %edx
callq 0x2a2a0
leaq 0xb8c219(%rip), %rax # 0xc89adc
movl (%rax), %edi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
leaq 0xb8cefc(%rip), %rdx # 0xc8a7d0
callq 0xfd980
movq -0x8(%rbp), %rcx
addq $0x70, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x8(%rbp), %rcx
addq $0x60, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rcx
addq $0x80, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x8(%rbp), %rcx
addq $0x90, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x98(%rax)
leaq 0xb8cbec(%rip), %rdi # 0xc8a518
leaq 0x5d833(%rip), %rsi # 0x15b166
movl $0x1b0, %edx # imm = 0x1B0
callq 0xfd9f0
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
leaq 0xb8ce78(%rip), %rax # 0xc8a7c8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xe1220
movq %rax, %rcx
leaq 0xb8ce62(%rip), %rax # 0xc8a7c8
movq %rcx, (%rax)
leaq 0xb8cba8(%rip), %rdi # 0xc8a518
callq 0xfda60
jmp 0xfd977
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| thr_lock_init:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
xor esi, esi
mov edx, 0F8h
call _memset
lea rax, key_THR_LOCK_mutex
mov edi, [rax]
mov rsi, [rbp+var_8]
add rsi, 18h
lea rdx, my_fast_mutexattr
call inline_mysql_mutex_init_11
mov rcx, [rbp+var_8]
add rcx, 70h ; 'p'
mov rax, [rbp+var_8]
mov [rax+78h], rcx
mov rcx, [rbp+var_8]
add rcx, 60h ; '`'
mov rax, [rbp+var_8]
mov [rax+68h], rcx
mov rcx, [rbp+var_8]
add rcx, 80h
mov rax, [rbp+var_8]
mov [rax+88h], rcx
mov rcx, [rbp+var_8]
add rcx, 90h
mov rax, [rbp+var_8]
mov [rax+98h], rcx
lea rdi, THR_LOCK_lock
lea rsi, aWorkspaceLlm4b_40; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 1B0h
call inline_mysql_mutex_lock_27
mov rcx, [rbp+var_8]
mov rax, [rbp+var_8]
mov [rax+10h], rcx
lea rax, thr_lock_thread_list
mov rdi, [rax]
mov rsi, [rbp+var_8]
call list_add
mov rcx, rax
lea rax, thr_lock_thread_list
mov [rax], rcx
lea rdi, THR_LOCK_lock
call inline_mysql_mutex_unlock_28
jmp short $+2
loc_FD977:
add rsp, 10h
pop rbp
retn
| long long thr_lock_init(_QWORD *a1)
{
memset(a1, 0LL, 248LL);
inline_mysql_mutex_init_11(key_THR_LOCK_mutex, a1 + 3, &my_fast_mutexattr);
a1[15] = a1 + 14;
a1[13] = a1 + 12;
a1[17] = a1 + 16;
a1[19] = a1 + 18;
inline_mysql_mutex_lock_27(&THR_LOCK_lock, "/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c", 432LL);
a1[2] = a1;
thr_lock_thread_list = (long long)list_add(thr_lock_thread_list, a1);
return inline_mysql_mutex_unlock_28(&THR_LOCK_lock);
}
| thr_lock_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
XOR ESI,ESI
MOV EDX,0xf8
CALL 0x0012a2a0
LEA RAX,[0xd89adc]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0x18
LEA RDX,[0xd8a7d0]
CALL 0x001fd980
MOV RCX,qword ptr [RBP + -0x8]
ADD RCX,0x70
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x78],RCX
MOV RCX,qword ptr [RBP + -0x8]
ADD RCX,0x60
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x68],RCX
MOV RCX,qword ptr [RBP + -0x8]
ADD RCX,0x80
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x88],RCX
MOV RCX,qword ptr [RBP + -0x8]
ADD RCX,0x90
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x98],RCX
LEA RDI,[0xd8a518]
LEA RSI,[0x25b166]
MOV EDX,0x1b0
CALL 0x001fd9f0
MOV RCX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],RCX
LEA RAX,[0xd8a7c8]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x8]
CALL 0x001e1220
MOV RCX,RAX
LEA RAX,[0xd8a7c8]
MOV qword ptr [RAX],RCX
LEA RDI,[0xd8a518]
CALL 0x001fda60
JMP 0x001fd977
LAB_001fd977:
ADD RSP,0x10
POP RBP
RET
|
void thr_lock_init(void *param_1)
{
memset(param_1,0,0xf8);
inline_mysql_mutex_init(key_THR_LOCK_mutex,(long)param_1 + 0x18,&my_fast_mutexattr);
*(long *)((long)param_1 + 0x78) = (long)param_1 + 0x70;
*(long *)((long)param_1 + 0x68) = (long)param_1 + 0x60;
*(long *)((long)param_1 + 0x88) = (long)param_1 + 0x80;
*(long *)((long)param_1 + 0x98) = (long)param_1 + 0x90;
inline_mysql_mutex_lock
(THR_LOCK_lock,"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c",0x1b0);
*(void **)((long)param_1 + 0x10) = param_1;
thr_lock_thread_list = list_add(thr_lock_thread_list,param_1);
inline_mysql_mutex_unlock(THR_LOCK_lock);
return;
}
| |
41,259 | thr_lock_init | eloqsql/mysys/thr_lock.c | void thr_lock_init(THR_LOCK *lock)
{
DBUG_ENTER("thr_lock_init");
bzero((char*) lock,sizeof(*lock));
mysql_mutex_init(key_THR_LOCK_mutex, &lock->mutex, MY_MUTEX_INIT_FAST);
lock->read.last= &lock->read.data;
lock->read_wait.last= &lock->read_wait.data;
lock->write_wait.last= &lock->write_wait.data;
lock->write.last= &lock->write.data;
mysql_mutex_lock(&THR_LOCK_lock); /* Add to locks in use */
lock->list.data=(void*) lock;
thr_lock_thread_list=list_add(thr_lock_thread_list,&lock->list);
mysql_mutex_unlock(&THR_LOCK_lock);
DBUG_VOID_RETURN;
} | O3 | c | thr_lock_init:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0xf8, %edx
xorl %esi, %esi
callq 0x2a290
leaq 0xb66f65(%rip), %rax # 0xc0ddbc
movl (%rax), %edi
leaq 0x18(%rbx), %r14
leaq 0x2e5564(%rip), %r15 # 0x38c3c8
movq (%r15), %rax
movq %r14, %rsi
callq *0x40(%rax)
movq %rax, 0x58(%rbx)
movq %r14, 0x50(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
leaq 0xb67c2d(%rip), %rsi # 0xc0eab0
movq %r14, %rdi
callq 0x2a310
leaq 0x70(%rbx), %rax
movq %rax, 0x78(%rbx)
leaq 0x60(%rbx), %rax
movq %rax, 0x68(%rbx)
leaq 0x80(%rbx), %rax
movq %rax, 0x88(%rbx)
leaq 0x90(%rbx), %rax
movq %rax, 0x98(%rbx)
leaq 0xb6793a(%rip), %r14 # 0xc0e7f8
cmpq $0x0, 0x40(%r14)
jne 0xa6f09
leaq 0xb6792c(%rip), %rdi # 0xc0e7f8
callq 0x2a1f0
movq %rbx, 0x10(%rbx)
leaq 0xb67bcc(%rip), %r12 # 0xc0eaa8
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x96618
movq %rax, (%r12)
movq 0x40(%r14), %rdi
testq %rdi, %rdi
jne 0xa6f10
leaq 0xb678fc(%rip), %rdi # 0xc0e7f8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2a1c0
callq 0x30d04
jmp 0xa6ed1
movq (%r15), %rax
callq *0x160(%rax)
jmp 0xa6ef5
| thr_lock_init:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rdi
mov edx, 0F8h
xor esi, esi
call _memset
lea rax, key_THR_LOCK_mutex
mov edi, [rax]
lea r14, [rbx+18h]
lea r15, PSI_server
mov rax, [r15]
mov rsi, r14
call qword ptr [rax+40h]
mov [rbx+58h], rax
mov [rbx+50h], r14
xorps xmm0, xmm0
movups xmmword ptr [rbx+40h], xmm0
lea rsi, my_fast_mutexattr
mov rdi, r14
call _pthread_mutex_init
lea rax, [rbx+70h]
mov [rbx+78h], rax
lea rax, [rbx+60h]
mov [rbx+68h], rax
lea rax, [rbx+80h]
mov [rbx+88h], rax
lea rax, [rbx+90h]
mov [rbx+98h], rax
lea r14, THR_LOCK_lock
cmp qword ptr [r14+40h], 0
jnz short loc_A6F09
lea rdi, THR_LOCK_lock
call _pthread_mutex_lock
loc_A6ED1:
mov [rbx+10h], rbx
lea r12, thr_lock_thread_list
mov rdi, [r12]
mov rsi, rbx
call list_add
mov [r12], rax
mov rdi, [r14+40h]
test rdi, rdi
jnz short loc_A6F10
loc_A6EF5:
lea rdi, THR_LOCK_lock
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp _pthread_mutex_unlock
loc_A6F09:
call thr_lock_init_cold_1
jmp short loc_A6ED1
loc_A6F10:
mov rax, [r15]
call qword ptr [rax+160h]
jmp short loc_A6EF5
| long long thr_lock_init(long long a1)
{
memset(a1, 0LL, 248LL);
*(_QWORD *)(a1 + 88) = ((long long ( *)(_QWORD, long long))PSI_server[8])(key_THR_LOCK_mutex, a1 + 24);
*(_QWORD *)(a1 + 80) = a1 + 24;
*(_OWORD *)(a1 + 64) = 0LL;
pthread_mutex_init(a1 + 24, &my_fast_mutexattr);
*(_QWORD *)(a1 + 120) = a1 + 112;
*(_QWORD *)(a1 + 104) = a1 + 96;
*(_QWORD *)(a1 + 136) = a1 + 128;
*(_QWORD *)(a1 + 152) = a1 + 144;
if ( THR_LOCK_lock[8] )
thr_lock_init_cold_1();
else
pthread_mutex_lock(THR_LOCK_lock);
*(_QWORD *)(a1 + 16) = a1;
thr_lock_thread_list = list_add(thr_lock_thread_list, (_QWORD *)a1);
if ( THR_LOCK_lock[8] )
PSI_server[44]();
return pthread_mutex_unlock(THR_LOCK_lock);
}
| thr_lock_init:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RDI
MOV EDX,0xf8
XOR ESI,ESI
CALL 0x0012a290
LEA RAX,[0xd0ddbc]
MOV EDI,dword ptr [RAX]
LEA R14,[RBX + 0x18]
LEA R15,[0x48c3c8]
MOV RAX,qword ptr [R15]
MOV RSI,R14
CALL qword ptr [RAX + 0x40]
MOV qword ptr [RBX + 0x58],RAX
MOV qword ptr [RBX + 0x50],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x40],XMM0
LEA RSI,[0xd0eab0]
MOV RDI,R14
CALL 0x0012a310
LEA RAX,[RBX + 0x70]
MOV qword ptr [RBX + 0x78],RAX
LEA RAX,[RBX + 0x60]
MOV qword ptr [RBX + 0x68],RAX
LEA RAX,[RBX + 0x80]
MOV qword ptr [RBX + 0x88],RAX
LEA RAX,[RBX + 0x90]
MOV qword ptr [RBX + 0x98],RAX
LEA R14,[0xd0e7f8]
CMP qword ptr [R14 + 0x40],0x0
JNZ 0x001a6f09
LEA RDI,[0xd0e7f8]
CALL 0x0012a1f0
LAB_001a6ed1:
MOV qword ptr [RBX + 0x10],RBX
LEA R12,[0xd0eaa8]
MOV RDI,qword ptr [R12]
MOV RSI,RBX
CALL 0x00196618
MOV qword ptr [R12],RAX
MOV RDI,qword ptr [R14 + 0x40]
TEST RDI,RDI
JNZ 0x001a6f10
LAB_001a6ef5:
LEA RDI,[0xd0e7f8]
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x0012a1c0
LAB_001a6f09:
CALL 0x00130d04
JMP 0x001a6ed1
LAB_001a6f10:
MOV RAX,qword ptr [R15]
CALL qword ptr [RAX + 0x160]
JMP 0x001a6ef5
|
void thr_lock_init(void *param_1)
{
pthread_mutex_t *__mutex;
int8 uVar1;
memset(param_1,0,0xf8);
__mutex = (pthread_mutex_t *)((long)param_1 + 0x18);
uVar1 = (**(code **)(PSI_server + 0x40))(key_THR_LOCK_mutex,__mutex);
*(int8 *)((long)param_1 + 0x58) = uVar1;
*(pthread_mutex_t **)((long)param_1 + 0x50) = __mutex;
*(int8 *)((long)param_1 + 0x40) = 0;
*(int8 *)((long)param_1 + 0x48) = 0;
pthread_mutex_init(__mutex,(pthread_mutexattr_t *)&my_fast_mutexattr);
*(long *)((long)param_1 + 0x78) = (long)param_1 + 0x70;
*(long *)((long)param_1 + 0x68) = (long)param_1 + 0x60;
*(long *)((long)param_1 + 0x88) = (long)param_1 + 0x80;
*(long *)((long)param_1 + 0x98) = (long)param_1 + 0x90;
if (THR_LOCK_lock._64_8_ == 0) {
pthread_mutex_lock((pthread_mutex_t *)THR_LOCK_lock);
}
else {
thr_lock_init_cold_1();
}
*(void **)((long)param_1 + 0x10) = param_1;
thr_lock_thread_list = list_add(thr_lock_thread_list,param_1);
if (THR_LOCK_lock._64_8_ != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)THR_LOCK_lock);
return;
}
| |
41,260 | atoi_octal | eloqsql/mysys/my_init.c | static ulong atoi_octal(const char *str)
{
long int tmp;
while (*str && my_isspace(&my_charset_latin1, *str))
str++;
str2int(str,
(*str == '0' ? 8 : 10), /* Octalt or decimalt */
0, INT_MAX, &tmp);
return (ulong) tmp;
} | O3 | c | atoi_octal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movb (%rdi), %al
movl $0xa, %esi
testb %al, %al
je 0xa08f2
leaq 0x30d656(%rip), %rcx # 0x3adf20
movq 0x40(%rcx), %rcx
movzbl %al, %edx
testb $0x8, 0x1(%rcx,%rdx)
je 0xa08e4
movb 0x1(%rdi), %al
incq %rdi
testb %al, %al
jne 0xa08ce
jmp 0xa08f2
xorl %ecx, %ecx
cmpb $0x30, %al
setne %cl
leal 0x8(,%rcx,2), %esi
leaq -0x10(%rbp), %rbx
movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
xorl %edx, %edx
movq %rbx, %r8
callq 0xd83bc
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| atoi_octal:
push rbp
mov rbp, rsp
push rbx
push rax
mov al, [rdi]
mov esi, 0Ah
test al, al
jz short loc_A08F2
lea rcx, my_charset_latin1
mov rcx, [rcx+40h]
loc_A08CE:
movzx edx, al
test byte ptr [rcx+rdx+1], 8
jz short loc_A08E4
mov al, [rdi+1]
inc rdi
test al, al
jnz short loc_A08CE
jmp short loc_A08F2
loc_A08E4:
xor ecx, ecx
cmp al, 30h ; '0'
setnz cl
lea esi, ds:8[rcx*2]
loc_A08F2:
lea rbx, [rbp+var_10]
mov ecx, 7FFFFFFFh
xor edx, edx
mov r8, rbx
call str2int
mov rax, [rbx]
add rsp, 8
pop rbx
pop rbp
retn
| void __spoils<rdx,rcx,r8,r9,r10,r11,xmm4,xmm5> atoi_octal(unsigned __int8 *a1)
{
unsigned __int8 v1; // al
long long v2; // rsi
_BYTE v3[16]; // [rsp+0h] [rbp-10h] BYREF
v1 = *a1;
v2 = 10LL;
if ( *a1 )
{
while ( (*(_BYTE *)(*((_QWORD *)&my_charset_latin1 + 8) + v1 + 1LL) & 8) != 0 )
{
v1 = *++a1;
if ( !v1 )
goto LABEL_6;
}
v2 = 2 * (unsigned int)(v1 != 48) + 8;
}
LABEL_6:
str2int(a1, v2, 0LL, 0x7FFFFFFFLL, v3);
}
| atoi_octal:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV AL,byte ptr [RDI]
MOV ESI,0xa
TEST AL,AL
JZ 0x001a08f2
LEA RCX,[0x4adf20]
MOV RCX,qword ptr [RCX + 0x40]
LAB_001a08ce:
MOVZX EDX,AL
TEST byte ptr [RCX + RDX*0x1 + 0x1],0x8
JZ 0x001a08e4
MOV AL,byte ptr [RDI + 0x1]
INC RDI
TEST AL,AL
JNZ 0x001a08ce
JMP 0x001a08f2
LAB_001a08e4:
XOR ECX,ECX
CMP AL,0x30
SETNZ CL
LEA ESI,[0x8 + RCX*0x2]
LAB_001a08f2:
LEA RBX,[RBP + -0x10]
MOV ECX,0x7fffffff
XOR EDX,EDX
MOV R8,RBX
CALL 0x001d83bc
MOV RAX,qword ptr [RBX]
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int8 atoi_octal(byte *param_1)
{
byte bVar1;
int8 in_RAX;
char cVar2;
int8 local_18;
bVar1 = *param_1;
cVar2 = '\n';
do {
if (bVar1 == 0) {
LAB_001a08f2:
local_18 = in_RAX;
str2int(param_1,cVar2,0,0x7fffffff,&local_18);
return local_18;
}
if ((PTR_ctype_latin1_004adf60[(ulong)bVar1 + 1] & 8) == 0) {
cVar2 = (bVar1 != 0x30) * '\x02' + '\b';
goto LAB_001a08f2;
}
bVar1 = param_1[1];
param_1 = param_1 + 1;
} while( true );
}
| |
41,261 | find_git_root(std::filesystem::__cxx11::path const&) | mog/src/utils/utils.cpp | filesystem::path find_git_root(const filesystem::path &start_path)
{
filesystem::path current = start_path;
while (!filesystem::exists(current / ".git"))
{
if (current == current.root_path())
{
throw runtime_error("Not inside a git repository");
}
current = current.parent_path();
}
return current;
} | O0 | cpp | find_git_root(std::filesystem::__cxx11::path const&):
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0x15250
leaq 0x7ba2(%rip), %rsi # 0x1c75a
leaq -0x68(%rbp), %rdi
movl $0x2, %edx
callq 0x136e0
jmp 0x14bc8
movq -0xd8(%rbp), %rsi
leaq -0x40(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x152b0
jmp 0x14bde
leaq -0x40(%rbp), %rdi
callq 0x130b0
movb %al, -0xd9(%rbp)
jmp 0x14bef
movb -0xd9(%rbp), %al
xorb $-0x1, %al
movb %al, -0xda(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x123c0
leaq -0x68(%rbp), %rdi
callq 0x123c0
movb -0xda(%rbp), %al
testb $0x1, %al
jne 0x14c1e
jmp 0x14d3d
movq -0xd8(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x75d0
jmp 0x14c33
movq -0xd8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x15330
movb %al, -0xdb(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x123c0
movb -0xdb(%rbp), %al
testb $0x1, %al
jne 0x14c67
jmp 0x14d04
movl $0x10, %edi
callq 0x7290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
leaq 0x7be4(%rip), %rsi # 0x1c869
callq 0x71f0
jmp 0x14c8c
movq -0xe8(%rbp), %rdi
movq 0x11356(%rip), %rsi # 0x25ff0
movq 0x112ff(%rip), %rdx # 0x25fa0
callq 0x7710
jmp 0x14d78
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x14d63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x14cdf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x123c0
leaq -0x68(%rbp), %rdi
callq 0x123c0
jmp 0x14d63
movq -0xe8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x7370
jmp 0x14d63
movq -0xd8(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
callq 0x77d0
jmp 0x14d19
movq -0xd8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x15370
leaq -0xc8(%rbp), %rdi
callq 0x123c0
jmp 0x14bb1
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x14d53
movq -0xd8(%rbp), %rdi
callq 0x123c0
movq -0xd0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xd8(%rbp), %rdi
callq 0x123c0
movq -0x70(%rbp), %rdi
callq 0x7750
nopl (%rax,%rax)
| _Z13find_git_rootRKNSt10filesystem7__cxx114pathE:
push rbp
mov rbp, rsp
sub rsp, 0F0h
mov [rbp+var_D8], rdi
mov rax, rdi
mov [rbp+var_D0], rax
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_11], 0
mov rsi, [rbp+var_10]; std::filesystem::__cxx11::path *
call _ZNSt10filesystem7__cxx114pathC2ERKS1_; std::filesystem::__cxx11::path::path(std::filesystem::__cxx11::path const&)
loc_14BB1:
lea rsi, aGit; ".git"
lea rdi, [rbp+var_68]
mov edx, 2
call _ZNSt10filesystem7__cxx114pathC2IA5_cS1_EERKT_NS1_6formatE; std::filesystem::__cxx11::path::path<char [5],std::filesystem::__cxx11::path>(char [5] const&,std::filesystem::__cxx11::path::format)
jmp short $+2
loc_14BC8:
mov rsi, [rbp+var_D8]; std::filesystem::__cxx11::path *
lea rdi, [rbp+var_40]
lea rdx, [rbp+var_68]
call _ZNSt10filesystem7__cxx11dvERKNS0_4pathES3_; std::filesystem::__cxx11::operator/(std::filesystem::__cxx11::path const&,std::filesystem::__cxx11::path const&)
jmp short $+2
loc_14BDE:
lea rdi, [rbp+var_40]; this
call _ZNSt10filesystem6existsERKNS_7__cxx114pathE; std::filesystem::exists(std::filesystem::__cxx11::path const&)
mov [rbp+var_D9], al
jmp short $+2
loc_14BEF:
mov al, [rbp+var_D9]
xor al, 0FFh
mov [rbp+var_DA], al
lea rdi, [rbp+var_40]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
lea rdi, [rbp+var_68]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
mov al, [rbp+var_DA]
test al, 1
jnz short loc_14C1E
jmp loc_14D3D
loc_14C1E:
mov rsi, [rbp+var_D8]
lea rdi, [rbp+var_A0]; this
call __ZNKSt10filesystem7__cxx114path9root_pathEv; std::filesystem::__cxx11::path::root_path(void)
jmp short $+2
loc_14C33:
mov rdi, [rbp+var_D8]
lea rsi, [rbp+var_A0]
call _ZNSt10filesystem7__cxx11eqERKNS0_4pathES3_; std::filesystem::__cxx11::operator==(std::filesystem::__cxx11::path const&,std::filesystem::__cxx11::path const&)
mov [rbp+var_DB], al
lea rdi, [rbp+var_A0]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
mov al, [rbp+var_DB]
test al, 1
jnz short loc_14C67
jmp loc_14D04
loc_14C67:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rbp+var_E8], rax
lea rsi, aNotInsideAGitR; "Not inside a git repository"
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_14C8C:
mov rdi, [rbp+var_E8]; void *
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_14D78
mov rcx, rax
mov eax, edx
mov [rbp+var_70], rcx
mov [rbp+var_74], eax
jmp loc_14D63
mov rcx, rax
mov eax, edx
mov [rbp+var_70], rcx
mov [rbp+var_74], eax
jmp short loc_14CDF
mov rcx, rax
mov eax, edx
mov [rbp+var_70], rcx
mov [rbp+var_74], eax
lea rdi, [rbp+var_40]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
loc_14CDF:
lea rdi, [rbp+var_68]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
jmp short loc_14D63
mov rdi, [rbp+var_E8]; void *
mov rcx, rax
mov eax, edx
mov [rbp+var_70], rcx
mov [rbp+var_74], eax
call ___cxa_free_exception
jmp short loc_14D63
loc_14D04:
mov rsi, [rbp+var_D8]
lea rdi, [rbp+var_C8]; this
call __ZNKSt10filesystem7__cxx114path11parent_pathEv; std::filesystem::__cxx11::path::parent_path(void)
jmp short $+2
loc_14D19:
mov rdi, [rbp+var_D8]
lea rsi, [rbp+var_C8]
call _ZNSt10filesystem7__cxx114pathaSEOS1_; std::filesystem::__cxx11::path::operator=(std::filesystem::__cxx11::path&&)
lea rdi, [rbp+var_C8]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
jmp loc_14BB1
loc_14D3D:
mov [rbp+var_11], 1
test [rbp+var_11], 1
jnz short loc_14D53
mov rdi, [rbp+var_D8]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
loc_14D53:
mov rax, [rbp+var_D0]
add rsp, 0F0h
pop rbp
retn
loc_14D63:
mov rdi, [rbp+var_D8]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
mov rdi, [rbp+var_70]
call __Unwind_Resume
loc_14D78:
nop dword ptr [rax+rax+00000000h]
| const std::filesystem::__cxx11::path * find_git_root(
const std::filesystem::__cxx11::path *a1,
std::filesystem::__cxx11::path *a2)
{
std::runtime_error *exception; // [rsp+8h] [rbp-E8h]
char v4; // [rsp+15h] [rbp-DBh]
char v5; // [rsp+16h] [rbp-DAh]
_BYTE v6[40]; // [rsp+28h] [rbp-C8h] BYREF
_BYTE v7[44]; // [rsp+50h] [rbp-A0h] BYREF
_BYTE v8[40]; // [rsp+88h] [rbp-68h] BYREF
_BYTE v9[48]; // [rsp+B0h] [rbp-40h] BYREF
std::filesystem::__cxx11::path *v10; // [rsp+E0h] [rbp-10h]
const std::filesystem::__cxx11::path *v11; // [rsp+E8h] [rbp-8h]
v11 = a1;
v10 = a2;
v9[47] = 0;
std::filesystem::__cxx11::path::path(a1, a2);
while ( 1 )
{
std::filesystem::__cxx11::path::path<char [5],std::filesystem::__cxx11::path>((long long)v8, (long long)".git", 2);
std::filesystem::__cxx11::operator/(v9, a1, v8);
v5 = ~std::filesystem::exists((std::filesystem *)v9, a1);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)v9);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)v8);
if ( (v5 & 1) == 0 )
break;
std::filesystem::__cxx11::path::root_path((std::filesystem::__cxx11::path *)v7);
v4 = std::filesystem::__cxx11::operator==(a1, v7);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)v7);
if ( (v4 & 1) != 0 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Not inside a git repository");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
std::filesystem::__cxx11::path::parent_path((std::filesystem::__cxx11::path *)v6);
std::filesystem::__cxx11::path::operator=(a1, v6);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)v6);
}
return a1;
}
| find_git_root:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xf0
MOV qword ptr [RBP + -0xd8],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0xd0],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV byte ptr [RBP + -0x11],0x0
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x00115250
LAB_00114bb1:
LEA RSI,[0x11c75a]
LEA RDI,[RBP + -0x68]
MOV EDX,0x2
CALL 0x001136e0
JMP 0x00114bc8
LAB_00114bc8:
MOV RSI,qword ptr [RBP + -0xd8]
LEA RDI,[RBP + -0x40]
LEA RDX,[RBP + -0x68]
CALL 0x001152b0
JMP 0x00114bde
LAB_00114bde:
LEA RDI,[RBP + -0x40]
CALL 0x001130b0
MOV byte ptr [RBP + -0xd9],AL
JMP 0x00114bef
LAB_00114bef:
MOV AL,byte ptr [RBP + -0xd9]
XOR AL,0xff
MOV byte ptr [RBP + -0xda],AL
LEA RDI,[RBP + -0x40]
CALL 0x001123c0
LEA RDI,[RBP + -0x68]
CALL 0x001123c0
MOV AL,byte ptr [RBP + -0xda]
TEST AL,0x1
JNZ 0x00114c1e
JMP 0x00114d3d
LAB_00114c1e:
MOV RSI,qword ptr [RBP + -0xd8]
LEA RDI,[RBP + -0xa0]
CALL 0x001075d0
LAB_00114c31:
JMP 0x00114c33
LAB_00114c33:
MOV RDI,qword ptr [RBP + -0xd8]
LEA RSI,[RBP + -0xa0]
CALL 0x00115330
MOV byte ptr [RBP + -0xdb],AL
LEA RDI,[RBP + -0xa0]
CALL 0x001123c0
MOV AL,byte ptr [RBP + -0xdb]
TEST AL,0x1
JNZ 0x00114c67
JMP 0x00114d04
LAB_00114c67:
MOV EDI,0x10
CALL 0x00107290
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RBP + -0xe8],RAX
LAB_00114c7e:
LEA RSI,[0x11c869]
CALL 0x001071f0
JMP 0x00114c8c
LAB_00114c8c:
MOV RDI,qword ptr [RBP + -0xe8]
MOV RSI,qword ptr [0x00125ff0]
MOV RDX,qword ptr [0x00125fa0]
CALL 0x00107710
LAB_00114d04:
MOV RSI,qword ptr [RBP + -0xd8]
LEA RDI,[RBP + -0xc8]
CALL 0x001077d0
LAB_00114d17:
JMP 0x00114d19
LAB_00114d19:
MOV RDI,qword ptr [RBP + -0xd8]
LEA RSI,[RBP + -0xc8]
CALL 0x00115370
LEA RDI,[RBP + -0xc8]
CALL 0x001123c0
JMP 0x00114bb1
LAB_00114d3d:
MOV byte ptr [RBP + -0x11],0x1
TEST byte ptr [RBP + -0x11],0x1
JNZ 0x00114d53
MOV RDI,qword ptr [RBP + -0xd8]
CALL 0x001123c0
LAB_00114d53:
MOV RAX,qword ptr [RBP + -0xd0]
ADD RSP,0xf0
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x00114d47) */
/* find_git_root(std::filesystem::__cxx11::path const&) */
path * find_git_root(path *param_1)
{
byte bVar1;
runtime_error *this;
path *in_RSI;
path local_d0 [40];
path local_a8 [56];
path local_70 [40];
__cxx11 local_48 [47];
int1 local_19;
path *local_10;
local_19 = 0;
local_10 = param_1;
std::filesystem::__cxx11::path::path(param_1,in_RSI);
while( true ) {
/* try { // try from 00114bb1 to 00114bc5 has its CatchHandler @ 00114cab */
std::filesystem::__cxx11::path::path<char[5],std::filesystem::__cxx11::path>
(local_70,&DAT_0011c75a,2);
/* try { // try from 00114bc8 to 00114bdb has its CatchHandler @ 00114cbc */
std::filesystem::__cxx11::operator/(local_48,param_1,local_70);
/* try { // try from 00114bde to 00114be6 has its CatchHandler @ 00114cca */
bVar1 = std::filesystem::exists((path *)local_48);
std::filesystem::__cxx11::path::~path((path *)local_48);
std::filesystem::__cxx11::path::~path(local_70);
if (((bVar1 ^ 0xff) & 1) == 0) {
return param_1;
}
/* try { // try from 00114c1e to 00114c30 has its CatchHandler @ 00114cab */
std::filesystem::__cxx11::path::root_path();
bVar1 = std::filesystem::__cxx11::operator==(param_1,local_a8);
std::filesystem::__cxx11::path::~path(local_a8);
if ((bVar1 & 1) != 0) break;
/* try { // try from 00114d04 to 00114d16 has its CatchHandler @ 00114cab */
std::filesystem::__cxx11::path::parent_path();
std::filesystem::__cxx11::path::operator=(param_1,local_d0);
std::filesystem::__cxx11::path::~path(local_d0);
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00114c7e to 00114c89 has its CatchHandler @ 00114cea */
std::runtime_error::runtime_error(this,"Not inside a git repository");
/* try { // try from 00114c8c to 00114ca5 has its CatchHandler @ 00114cab */
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_00125ff0,PTR__runtime_error_00125fa0);
}
| |
41,262 | lshift | eloqsql/strings/dtoa.c | static Bigint *lshift(Bigint *b, int k, Stack_alloc *alloc)
{
int i, k1, n, n1;
Bigint *b1;
ULong *x, *x1, *xe, z;
n= k >> 5;
k1= b->k;
n1= n + b->wds + 1;
for (i= b->maxwds; n1 > i; i<<= 1)
k1++;
b1= Balloc(k1, alloc);
x1= b1->p.x;
for (i= 0; i < n; i++)
*x1++= 0;
x= b->p.x;
xe= x + b->wds;
if (k&= 0x1f)
{
k1= 32 - k;
z= 0;
do
{
*x1++= *x << k | z;
z= *x++ >> k1;
}
while (x < xe);
if ((*x1= z))
++n1;
}
else
do
*x1++= *x++;
while (x < xe);
b1->wds= n1 - 1;
Bfree(b, alloc);
return b1;
} | O0 | c | lshift:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
sarl $0x5, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
addl 0x14(%rcx), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0x72c6b
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
shll %eax
movl %eax, -0x1c(%rbp)
jmp 0x72c50
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x724e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x72cb5
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x40(%rbp)
movl $0x0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x72c8d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x14(%rcx), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movl -0xc(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x72d54
movl $0x20, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x4c(%rbp)
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl -0xc(%rbp), %ecx
shll %cl, %eax
movl %eax, %ecx
orl -0x4c(%rbp), %ecx
movq -0x40(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x40(%rbp)
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x38(%rbp)
movl (%rax), %eax
movl -0x20(%rbp), %ecx
shrl %cl, %eax
movl %eax, -0x4c(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x48(%rbp), %rax
jb 0x72cf7
movl -0x4c(%rbp), %eax
movq -0x40(%rbp), %rcx
movl %eax, (%rcx)
cmpl $0x0, %eax
je 0x72d52
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x72d84
jmp 0x72d56
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x38(%rbp)
movl (%rax), %ecx
movq -0x40(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x40(%rbp)
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
cmpq -0x48(%rbp), %rax
jb 0x72d56
jmp 0x72d84
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x72b90
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| lshift:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov eax, [rbp+var_C]
sar eax, 5
mov [rbp+var_24], eax
mov rax, [rbp+var_8]
mov eax, [rax+8]
mov [rbp+var_20], eax
mov eax, [rbp+var_24]
mov rcx, [rbp+var_8]
add eax, [rcx+14h]
add eax, 1
mov [rbp+var_28], eax
mov rax, [rbp+var_8]
mov eax, [rax+0Ch]
mov [rbp+var_1C], eax
loc_72C50:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_1C]
jle short loc_72C6B
mov eax, [rbp+var_20]
add eax, 1
mov [rbp+var_20], eax
mov eax, [rbp+var_1C]
shl eax, 1
mov [rbp+var_1C], eax
jmp short loc_72C50
loc_72C6B:
mov edi, [rbp+var_20]
mov rsi, [rbp+var_18]
call Balloc
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov rax, [rax]
mov [rbp+var_40], rax
mov [rbp+var_1C], 0
loc_72C8D:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_24]
jge short loc_72CB5
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 4
mov [rbp+var_40], rcx
mov dword ptr [rax], 0
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
jmp short loc_72C8D
loc_72CB5:
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov rcx, [rbp+var_8]
movsxd rcx, dword ptr [rcx+14h]
shl rcx, 2
add rax, rcx
mov [rbp+var_48], rax
mov eax, [rbp+var_C]
and eax, 1Fh
mov [rbp+var_C], eax
cmp eax, 0
jz short loc_72D54
mov eax, 20h ; ' '
sub eax, [rbp+var_C]
mov [rbp+var_20], eax
mov [rbp+var_4C], 0
loc_72CF7:
mov rax, [rbp+var_38]
mov eax, [rax]
mov ecx, [rbp+var_C]
shl eax, cl
mov ecx, eax
or ecx, [rbp+var_4C]
mov rax, [rbp+var_40]
mov rdx, rax
add rdx, 4
mov [rbp+var_40], rdx
mov [rax], ecx
mov rax, [rbp+var_38]
mov rcx, rax
add rcx, 4
mov [rbp+var_38], rcx
mov eax, [rax]
mov ecx, [rbp+var_20]
shr eax, cl
mov [rbp+var_4C], eax
mov rax, [rbp+var_38]
cmp rax, [rbp+var_48]
jb short loc_72CF7
mov eax, [rbp+var_4C]
mov rcx, [rbp+var_40]
mov [rcx], eax
cmp eax, 0
jz short loc_72D52
mov eax, [rbp+var_28]
add eax, 1
mov [rbp+var_28], eax
loc_72D52:
jmp short loc_72D84
loc_72D54:
jmp short $+2
loc_72D56:
mov rax, [rbp+var_38]
mov rcx, rax
add rcx, 4
mov [rbp+var_38], rcx
mov ecx, [rax]
mov rax, [rbp+var_40]
mov rdx, rax
add rdx, 4
mov [rbp+var_40], rdx
mov [rax], ecx
mov rax, [rbp+var_38]
cmp rax, [rbp+var_48]
jb short loc_72D56
jmp short $+2
loc_72D84:
mov ecx, [rbp+var_28]
sub ecx, 1
mov rax, [rbp+var_30]
mov [rax+14h], ecx
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
call Bfree
mov rax, [rbp+var_30]
add rsp, 50h
pop rbp
retn
| long long lshift(unsigned long long a1, int a2, unsigned long long *a3)
{
int *v3; // rax
int *v4; // rax
int *v5; // rax
int *v6; // rax
int v7; // ecx
int *v8; // rax
int v10; // [rsp+4h] [rbp-4Ch]
unsigned long long v11; // [rsp+8h] [rbp-48h]
int *v12; // [rsp+10h] [rbp-40h]
int *v13; // [rsp+18h] [rbp-38h]
long long v14; // [rsp+20h] [rbp-30h]
int v15; // [rsp+28h] [rbp-28h]
int v16; // [rsp+30h] [rbp-20h]
int i; // [rsp+34h] [rbp-1Ch]
int j; // [rsp+34h] [rbp-1Ch]
char v20; // [rsp+44h] [rbp-Ch]
v16 = *(_DWORD *)(a1 + 8);
v15 = *(_DWORD *)(a1 + 20) + (a2 >> 5) + 1;
for ( i = *(_DWORD *)(a1 + 12); v15 > i; i *= 2 )
++v16;
v14 = Balloc(v16, (long long)a3);
v12 = *(int **)v14;
for ( j = 0; j < a2 >> 5; ++j )
{
v3 = v12++;
*v3 = 0;
}
v13 = *(int **)a1;
v11 = 4LL * *(int *)(a1 + 20) + *(_QWORD *)a1;
v20 = a2 & 0x1F;
if ( (a2 & 0x1F) != 0 )
{
v10 = 0;
do
{
v4 = v12++;
*v4 = v10 | (*v13 << v20);
v5 = v13++;
v10 = (unsigned int)*v5 >> (32 - v20);
}
while ( (unsigned long long)v13 < v11 );
*v12 = v10;
if ( v10 )
++v15;
}
else
{
do
{
v6 = v13++;
v7 = *v6;
v8 = v12++;
*v8 = v7;
}
while ( (unsigned long long)v13 < v11 );
}
*(_DWORD *)(v14 + 20) = v15 - 1;
Bfree(a1, a3);
return v14;
}
| lshift:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV EAX,dword ptr [RBP + -0xc]
SAR EAX,0x5
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x8]
ADD EAX,dword ptr [RCX + 0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x28],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0xc]
MOV dword ptr [RBP + -0x1c],EAX
LAB_00172c50:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x1c]
JLE 0x00172c6b
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x1c]
SHL EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x00172c50
LAB_00172c6b:
MOV EDI,dword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001724e0
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
MOV dword ptr [RBP + -0x1c],0x0
LAB_00172c8d:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x24]
JGE 0x00172cb5
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x40],RCX
MOV dword ptr [RAX],0x0
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x00172c8d
LAB_00172cb5:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RCX + 0x14]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
MOV EAX,dword ptr [RBP + -0xc]
AND EAX,0x1f
MOV dword ptr [RBP + -0xc],EAX
CMP EAX,0x0
JZ 0x00172d54
MOV EAX,0x20
SUB EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x20],EAX
MOV dword ptr [RBP + -0x4c],0x0
LAB_00172cf7:
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX]
MOV ECX,dword ptr [RBP + -0xc]
SHL EAX,CL
MOV ECX,EAX
OR ECX,dword ptr [RBP + -0x4c]
MOV RAX,qword ptr [RBP + -0x40]
MOV RDX,RAX
ADD RDX,0x4
MOV qword ptr [RBP + -0x40],RDX
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x38],RCX
MOV EAX,dword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x20]
SHR EAX,CL
MOV dword ptr [RBP + -0x4c],EAX
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x48]
JC 0x00172cf7
MOV EAX,dword ptr [RBP + -0x4c]
MOV RCX,qword ptr [RBP + -0x40]
MOV dword ptr [RCX],EAX
CMP EAX,0x0
JZ 0x00172d52
MOV EAX,dword ptr [RBP + -0x28]
ADD EAX,0x1
MOV dword ptr [RBP + -0x28],EAX
LAB_00172d52:
JMP 0x00172d84
LAB_00172d54:
JMP 0x00172d56
LAB_00172d56:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x38],RCX
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x40]
MOV RDX,RAX
ADD RDX,0x4
MOV qword ptr [RBP + -0x40],RDX
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x48]
JC 0x00172d56
JMP 0x00172d84
LAB_00172d84:
MOV ECX,dword ptr [RBP + -0x28]
SUB ECX,0x1
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x14],ECX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00172b90
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x50
POP RBP
RET
|
int8 * lshift(int8 *param_1,uint param_2,int8 param_3)
{
sbyte sVar1;
int iVar2;
int8 *puVar3;
uint *puVar4;
uint *puVar5;
uint *puVar6;
uint local_54;
uint *local_48;
uint *local_40;
int local_30;
int local_28;
int local_24;
local_28 = *(int *)(param_1 + 1);
iVar2 = ((int)param_2 >> 5) + *(int *)((long)param_1 + 0x14);
local_30 = iVar2 + 1;
for (local_24 = *(int *)((long)param_1 + 0xc); local_24 < local_30; local_24 = local_24 << 1) {
local_28 = local_28 + 1;
}
puVar3 = (int8 *)Balloc(local_28,param_3);
local_48 = (uint *)*puVar3;
for (local_24 = 0; local_24 < (int)param_2 >> 5; local_24 = local_24 + 1) {
*local_48 = 0;
local_48 = local_48 + 1;
}
local_40 = (uint *)*param_1;
puVar4 = local_40 + *(int *)((long)param_1 + 0x14);
if ((param_2 & 0x1f) == 0) {
do {
puVar5 = local_40 + 1;
*local_48 = *local_40;
local_48 = local_48 + 1;
local_40 = puVar5;
} while (puVar5 < puVar4);
}
else {
sVar1 = (sbyte)(param_2 & 0x1f);
local_54 = 0;
do {
puVar6 = local_48 + 1;
*local_48 = *local_40 << sVar1 | local_54;
puVar5 = local_40 + 1;
local_54 = *local_40 >> (0x20U - sVar1 & 0x1f);
local_48 = puVar6;
local_40 = puVar5;
} while (puVar5 < puVar4);
*puVar6 = local_54;
if (local_54 != 0) {
local_30 = iVar2 + 2;
}
}
*(int *)((long)puVar3 + 0x14) = local_30 + -1;
Bfree(param_1,param_3);
return puVar3;
}
| |
41,263 | register_thread_class(char const*, unsigned int, int) | eloqsql/storage/perfschema/pfs_instr_class.cc | PFS_thread_key register_thread_class(const char *name, uint name_length,
int flags)
{
/* See comments in register_mutex_class */
uint32 index;
PFS_thread_class *entry;
for (index= 0; index < thread_class_max; index++)
{
entry= &thread_class_array[index];
if ((entry->m_name_length == name_length) &&
(strncmp(entry->m_name, name, name_length) == 0))
return (index + 1);
}
index= PFS_atomic::add_u32(&thread_class_dirty_count, 1);
if (index < thread_class_max)
{
entry= &thread_class_array[index];
assert(name_length <= PFS_MAX_INFO_NAME_LENGTH);
strncpy(entry->m_name, name, name_length);
entry->m_name_length= name_length;
entry->m_enabled= true;
PFS_atomic::add_u32(&thread_class_allocated_count, 1);
return (index + 1);
}
if (pfs_enabled)
thread_class_lost++;
return 0;
} | O0 | cpp | register_thread_class(char const*, unsigned int, int):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpq 0x3c996d(%rip), %rax # 0x40c5b0
jae 0x42ca2
movq 0x3ca1fc(%rip), %rax # 0x40ce48
movl -0x1c(%rbp), %ecx
imulq $0xc0, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x90(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x42c95
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x26170
cmpl $0x0, %eax
jne 0x42c95
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x42d42
jmp 0x42c97
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x42c39
leaq 0x3ca19b(%rip), %rdi # 0x40ce44
movl $0x1, %esi
callq 0x2d580
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpq 0x3c98f0(%rip), %rax # 0x40c5b0
jae 0x42d20
movq 0x3ca17f(%rip), %rax # 0x40ce48
movl -0x1c(%rbp), %ecx
imulq $0xc0, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x261a0
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x90(%rax)
movq -0x28(%rbp), %rax
movb $0x1, (%rax)
leaq 0x3ca135(%rip), %rdi # 0x40ce40
movl $0x1, %esi
callq 0x2d580
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x42d42
cmpb $0x0, 0x1d0609(%rip) # 0x213330
je 0x42d3b
movq 0x3c9888(%rip), %rax # 0x40c5b8
addq $0x1, %rax
movq %rax, 0x3c987d(%rip) # 0x40c5b8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _Z21register_thread_classPKcji:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_1C], 0
loc_42C39:
mov eax, [rbp+var_1C]
cmp rax, cs:thread_class_max
jnb short loc_42CA2
mov rax, cs:_ZL18thread_class_array; thread_class_array
mov ecx, [rbp+var_1C]
imul rcx, 0C0h
add rax, rcx
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov eax, [rax+90h]
cmp eax, [rbp+var_14]
jnz short loc_42C95
mov rdi, [rbp+var_28]
add rdi, 10h
mov rsi, [rbp+var_10]
mov eax, [rbp+var_14]
mov edx, eax
call _strncmp
cmp eax, 0
jnz short loc_42C95
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_4], eax
jmp loc_42D42
loc_42C95:
jmp short $+2
loc_42C97:
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
jmp short loc_42C39
loc_42CA2:
lea rdi, _ZL24thread_class_dirty_count; this
mov esi, (offset dword_0+1); unsigned int *
call _ZN10PFS_atomic7add_u32EPjj; PFS_atomic::add_u32(uint *,uint)
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
cmp rax, cs:thread_class_max
jnb short loc_42D20
mov rax, cs:_ZL18thread_class_array; thread_class_array
mov ecx, [rbp+var_1C]
imul rcx, 0C0h
add rax, rcx
mov [rbp+var_28], rax
mov rdi, [rbp+var_28]
add rdi, 10h
mov rsi, [rbp+var_10]
mov eax, [rbp+var_14]
mov edx, eax
call _strncpy
mov ecx, [rbp+var_14]
mov rax, [rbp+var_28]
mov [rax+90h], ecx
mov rax, [rbp+var_28]
mov byte ptr [rax], 1
lea rdi, _ZL28thread_class_allocated_count; this
mov esi, (offset dword_0+1); unsigned int *
call _ZN10PFS_atomic7add_u32EPjj; PFS_atomic::add_u32(uint *,uint)
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_4], eax
jmp short loc_42D42
loc_42D20:
cmp cs:pfs_enabled, 0
jz short loc_42D3B
mov rax, cs:thread_class_lost
add rax, 1
mov cs:thread_class_lost, rax
loc_42D3B:
mov [rbp+var_4], 0
loc_42D42:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long register_thread_class(const char *a1, unsigned int a2)
{
long long v3; // [rsp+8h] [rbp-28h]
long long v4; // [rsp+8h] [rbp-28h]
unsigned int i; // [rsp+14h] [rbp-1Ch]
unsigned int v6; // [rsp+14h] [rbp-1Ch]
for ( i = 0; i < thread_class_max; ++i )
{
v3 = 192LL * i + thread_class_array;
if ( *(_DWORD *)(v3 + 144) == a2 && !(unsigned int)strncmp(v3 + 16, a1, a2) )
return i + 1;
}
v6 = PFS_atomic::add_u32((PFS_atomic *)&thread_class_dirty_count, (unsigned int *)((char *)&dword_0 + 1));
if ( v6 >= thread_class_max )
{
if ( pfs_enabled )
++thread_class_lost;
return 0;
}
else
{
v4 = 192LL * v6 + thread_class_array;
strncpy(v4 + 16, a1, a2);
*(_DWORD *)(v4 + 144) = a2;
*(_BYTE *)v4 = 1;
PFS_atomic::add_u32((PFS_atomic *)&thread_class_allocated_count, (unsigned int *)((char *)&dword_0 + 1));
return v6 + 1;
}
}
| register_thread_class:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV dword ptr [RBP + -0x1c],0x0
LAB_00142c39:
MOV EAX,dword ptr [RBP + -0x1c]
CMP RAX,qword ptr [0x0050c5b0]
JNC 0x00142ca2
MOV RAX,qword ptr [0x0050ce48]
MOV ECX,dword ptr [RBP + -0x1c]
IMUL RCX,RCX,0xc0
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX + 0x90]
CMP EAX,dword ptr [RBP + -0x14]
JNZ 0x00142c95
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x10
MOV RSI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
CALL 0x00126170
CMP EAX,0x0
JNZ 0x00142c95
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00142d42
LAB_00142c95:
JMP 0x00142c97
LAB_00142c97:
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x00142c39
LAB_00142ca2:
LEA RDI,[0x50ce44]
MOV ESI,0x1
CALL 0x0012d580
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
CMP RAX,qword ptr [0x0050c5b0]
JNC 0x00142d20
MOV RAX,qword ptr [0x0050ce48]
MOV ECX,dword ptr [RBP + -0x1c]
IMUL RCX,RCX,0xc0
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x10
MOV RSI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
CALL 0x001261a0
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x90],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX],0x1
LEA RDI,[0x50ce40]
MOV ESI,0x1
CALL 0x0012d580
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00142d42
LAB_00142d20:
CMP byte ptr [0x00313330],0x0
JZ 0x00142d3b
MOV RAX,qword ptr [0x0050c5b8]
ADD RAX,0x1
MOV qword ptr [0x0050c5b8],RAX
LAB_00142d3b:
MOV dword ptr [RBP + -0x4],0x0
LAB_00142d42:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
/* register_thread_class(char const*, unsigned int, int) */
int register_thread_class(char *param_1,uint param_2,int param_3)
{
int iVar1;
uint uVar2;
long lVar3;
int1 *puVar4;
uint local_24;
int local_c;
local_24 = 0;
while( true ) {
if (thread_class_max <= local_24) {
uVar2 = PFS_atomic::add_u32(&thread_class_dirty_count,1);
if (uVar2 < thread_class_max) {
puVar4 = (int1 *)(thread_class_array + (ulong)uVar2 * 0xc0);
strncpy(puVar4 + 0x10,param_1,(ulong)param_2);
*(uint *)(puVar4 + 0x90) = param_2;
*puVar4 = 1;
PFS_atomic::add_u32(&thread_class_allocated_count,1);
local_c = uVar2 + 1;
}
else {
if (pfs_enabled != '\0') {
thread_class_lost = thread_class_lost + 1;
}
local_c = 0;
}
return local_c;
}
lVar3 = thread_class_array + (ulong)local_24 * 0xc0;
if ((*(uint *)(lVar3 + 0x90) == param_2) &&
(iVar1 = strncmp((char *)(lVar3 + 0x10),param_1,(ulong)param_2), iVar1 == 0)) break;
local_24 = local_24 + 1;
}
return local_24 + 1;
}
| |
41,264 | evmone::instr::core::datacopy(evmone::StackTop, long, evmone::ExecutionState&) | corpus-core[P]colibri-stateless/build_O3/_deps/evmone_external-src/lib/evmone/instructions.hpp | inline Result datacopy(StackTop stack, int64_t gas_left, ExecutionState& state) noexcept
{
const auto data = state.analysis.baseline->eof_data();
const auto& mem_index = stack.pop();
const auto& data_index = stack.pop();
const auto& size = stack.pop();
if (!check_memory(gas_left, state.memory, mem_index, size))
return {EVMC_OUT_OF_GAS, gas_left};
const auto dst = static_cast<size_t>(mem_index);
// TODO why?
const auto src = data.size() < data_index ? data.size() : static_cast<size_t>(data_index);
const auto s = static_cast<size_t>(size);
const auto copy_size = std::min(s, data.size() - src);
if (const auto cost = copy_cost(s); (gas_left -= cost) < 0)
return {EVMC_OUT_OF_GAS, gas_left};
if (copy_size > 0)
std::memcpy(&state.memory[dst], &data[src], copy_size);
if (s - copy_size > 0)
std::memset(&state.memory[dst + copy_size], 0, s - copy_size);
return {EVMC_SUCCESS, gas_left};
} | O3 | cpp | evmone::instr::core::datacopy(evmone::StackTop, long, evmone::ExecutionState&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movq 0x1f8(%rdx), %rax
leaq 0x48(%rax), %rdi
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x40b2c
movq %rax, %r14
movq %rdx, %r9
movdqu -0x40(%r12), %xmm0
movdqu -0x30(%r12), %xmm1
por %xmm0, %xmm1
leaq 0x8(%r15), %r8
ptest %xmm1, %xmm1
je 0x40c2f
movq -0x30(%r12), %rax
orq -0x28(%r12), %rax
movl $0x3, %ebp
orq -0x38(%r12), %rax
jne 0x40ccf
movq -0x40(%r12), %rax
movq %rax, %rcx
shrq $0x20, %rcx
jne 0x40ccf
movq 0x10(%r12), %rcx
orq 0x18(%r12), %rcx
orq 0x8(%r12), %rcx
jne 0x40ccf
movq (%r12), %rdx
movq %rdx, %rcx
shrq $0x20, %rcx
jne 0x40ccf
addq %rax, %rdx
cmpq 0x10(%r15), %rdx
jbe 0x40c26
movq %rbx, %rdi
movq %r8, %rsi
movq %r8, %rbx
movq %r9, %r15
callq 0x3fbe5
movq %r15, %r9
movq %rbx, %r8
movq %rax, %rbx
testq %rbx, %rbx
js 0x40ccf
movq -0x10(%r12), %rcx
movq -0x8(%r12), %rdx
xorl %esi, %esi
movq %rdx, %rax
orq %rcx, %rax
movq -0x20(%r12), %rax
cmoveq %rax, %rcx
cmoveq -0x18(%r12), %rdx
movl $0x0, %edi
cmoveq %r14, %rdi
cmpq %rcx, %rdi
sbbq %rdx, %rsi
movq -0x40(%r12), %r15
cmovbq %r14, %rax
subq %rax, %r14
cmpq %r15, %r14
movq %r15, %r13
cmovbq %r14, %r13
leaq 0x1f(%r15), %rcx
shrq $0x5, %rcx
leaq (%rcx,%rcx,2), %rcx
subq %rcx, %rbx
js 0x40cca
movq (%r12), %r12
testq %r13, %r13
je 0x40ca9
movq (%r8), %rdi
addq %r12, %rdi
addq %rax, %r9
movq %r9, %rsi
movq %r13, %rdx
movq %r8, %rbp
callq 0x211a0
movq %rbp, %r8
xorl %ebp, %ebp
cmpq %r14, %r15
jbe 0x40ccf
addq (%r8), %r12
addq %r13, %r12
subq %r13, %r15
xorl %ebp, %ebp
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x21120
jmp 0x40ccf
movl $0x3, %ebp
movl %ebp, %eax
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| _ZN6evmone5instr4core8datacopyENS_8StackTopElRNS_14ExecutionStateE:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rdx
mov rbx, rsi
mov r12, rdi
mov rax, [rdx+1F8h]
lea rdi, [rax+48h]
mov rsi, [rax]
mov rdx, [rax+8]
call _ZNK6evmone10EOF1Header8get_dataESt17basic_string_viewIhN4evmc11byte_traitsIhEEE; evmone::EOF1Header::get_data(std::basic_string_view<uchar,evmc::byte_traits<uchar>>)
mov r14, rax
mov r9, rdx
movdqu xmm0, xmmword ptr [r12-40h]
movdqu xmm1, xmmword ptr [r12-30h]
por xmm1, xmm0
lea r8, [r15+8]
ptest xmm1, xmm1
jz short loc_40C2F
mov rax, [r12-30h]
or rax, [r12-28h]
mov ebp, 3
or rax, [r12-38h]
jnz loc_40CCF
mov rax, [r12-40h]
mov rcx, rax
shr rcx, 20h
jnz loc_40CCF
mov rcx, [r12+10h]
or rcx, [r12+18h]
or rcx, [r12+8]
jnz loc_40CCF
mov rdx, [r12]
mov rcx, rdx
shr rcx, 20h; unsigned __int64
jnz loc_40CCF
add rdx, rax; evmone::Memory *
cmp rdx, [r15+10h]
jbe short loc_40C26
mov rdi, rbx; this
mov rsi, r8; __int64
mov rbx, r8
mov r15, r9
call _ZN6evmone11grow_memoryElRNS_6MemoryEm; evmone::grow_memory(long,evmone::Memory &,ulong)
mov r9, r15
mov r8, rbx
mov rbx, rax
loc_40C26:
test rbx, rbx
js loc_40CCF
loc_40C2F:
mov rcx, [r12-10h]
mov rdx, [r12-8]
xor esi, esi
mov rax, rdx
or rax, rcx
mov rax, [r12-20h]
cmovz rcx, rax
cmovz rdx, [r12-18h]
mov edi, 0
cmovz rdi, r14
cmp rdi, rcx
sbb rsi, rdx
mov r15, [r12-40h]
cmovb rax, r14
sub r14, rax
cmp r14, r15
mov r13, r15
cmovb r13, r14
lea rcx, [r15+1Fh]
shr rcx, 5
lea rcx, [rcx+rcx*2]
sub rbx, rcx
js short loc_40CCA
mov r12, [r12]
test r13, r13
jz short loc_40CA9
mov rdi, [r8]
add rdi, r12
add r9, rax
mov rsi, r9
mov rdx, r13
mov rbp, r8
call _memcpy
mov r8, rbp
loc_40CA9:
xor ebp, ebp
cmp r15, r14
jbe short loc_40CCF
add r12, [r8]
add r12, r13
sub r15, r13
xor ebp, ebp
mov rdi, r12
xor esi, esi
mov rdx, r15
call _memset
jmp short loc_40CCF
loc_40CCA:
mov ebp, 3
loc_40CCF:
mov eax, ebp
mov rdx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long evmone::instr::core::datacopy(const __m128i *a1, evmone *a2, long long a3)
{
long long v4; // rbx
unsigned long long data; // r14
__m128i v7; // xmm1
_QWORD *v8; // r8
unsigned int v9; // ebp
evmone::Memory *v10; // rdx
char *v11; // rax
long long v12; // rcx
long long v13; // rdx
unsigned __int128 v14; // rdi
unsigned long long v15; // rax
unsigned long long v16; // r15
unsigned long long v17; // r14
long long v18; // r13
long long v19; // r12
_QWORD *v20; // rbp
v4 = (long long)a2;
data = evmone::EOF1Header::get_data(*(_QWORD *)(a3 + 504) + 72LL, **(_QWORD **)(a3 + 504));
v7 = _mm_or_si128(_mm_loadu_si128(a1 - 3), _mm_loadu_si128(a1 - 4));
v8 = (_QWORD *)(a3 + 8);
if ( _mm_testz_si128(v7, v7) )
goto LABEL_9;
v9 = 3;
if ( !(a1[-4].m128i_i64[1] | a1[-3].m128i_i64[1] | a1[-3].m128i_i64[0])
&& !HIDWORD(a1[-4].m128i_i64[0])
&& !(a1->m128i_i64[1] | a1[1].m128i_i64[1] | a1[1].m128i_i64[0])
&& !HIDWORD(a1->m128i_i64[0]) )
{
v10 = (evmone::Memory *)(a1[-4].m128i_i64[0] + a1->m128i_i64[0]);
if ( (unsigned long long)v10 > *(_QWORD *)(a3 + 16) )
{
v11 = evmone::grow_memory(a2, (evmone::Memory *)(a3 + 8), v10);
v8 = (_QWORD *)(a3 + 8);
v4 = (long long)v11;
}
if ( v4 >= 0 )
{
LABEL_9:
v12 = a1[-1].m128i_i64[0];
v13 = a1[-1].m128i_i64[1];
*((_QWORD *)&v14 + 1) = 0LL;
v15 = a1[-2].m128i_u64[0];
if ( *(_OWORD *)&a1[-1] == 0LL )
{
v12 = a1[-2].m128i_i64[0];
v13 = a1[-2].m128i_i64[1];
}
*(_QWORD *)&v14 = 0LL;
if ( *(_OWORD *)&a1[-1] == 0LL )
*(_QWORD *)&v14 = data;
v16 = a1[-4].m128i_u64[0];
if ( v14 < __PAIR128__(v13, v12) )
v15 = data;
v17 = data - v15;
v18 = a1[-4].m128i_i64[0];
if ( v17 < v16 )
v18 = v17;
if ( (long long)(v4 - 3 * ((v16 + 31) >> 5)) < 0 )
{
return 3;
}
else
{
v19 = a1->m128i_i64[0];
if ( v18 )
{
v20 = v8;
memcpy(v19 + *v8);
v8 = v20;
}
v9 = 0;
if ( v16 > v17 )
{
v9 = 0;
memset(v18 + *v8 + v19, 0LL, v16 - v18);
}
}
}
}
return v9;
}
| datacopy:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV RBX,RSI
MOV R12,RDI
MOV RAX,qword ptr [RDX + 0x1f8]
LEA RDI,[RAX + 0x48]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x00140b2c
MOV R14,RAX
MOV R9,RDX
MOVDQU XMM0,xmmword ptr [R12 + -0x40]
MOVDQU XMM1,xmmword ptr [R12 + -0x30]
POR XMM1,XMM0
LEA R8,[R15 + 0x8]
PTEST XMM1,XMM1
JZ 0x00140c2f
MOV RAX,qword ptr [R12 + -0x30]
OR RAX,qword ptr [R12 + -0x28]
MOV EBP,0x3
OR RAX,qword ptr [R12 + -0x38]
JNZ 0x00140ccf
MOV RAX,qword ptr [R12 + -0x40]
MOV RCX,RAX
SHR RCX,0x20
JNZ 0x00140ccf
MOV RCX,qword ptr [R12 + 0x10]
OR RCX,qword ptr [R12 + 0x18]
OR RCX,qword ptr [R12 + 0x8]
JNZ 0x00140ccf
MOV RDX,qword ptr [R12]
MOV RCX,RDX
SHR RCX,0x20
JNZ 0x00140ccf
ADD RDX,RAX
CMP RDX,qword ptr [R15 + 0x10]
JBE 0x00140c26
MOV RDI,RBX
MOV RSI,R8
MOV RBX,R8
MOV R15,R9
CALL 0x0013fbe5
MOV R9,R15
MOV R8,RBX
MOV RBX,RAX
LAB_00140c26:
TEST RBX,RBX
JS 0x00140ccf
LAB_00140c2f:
MOV RCX,qword ptr [R12 + -0x10]
MOV RDX,qword ptr [R12 + -0x8]
XOR ESI,ESI
MOV RAX,RDX
OR RAX,RCX
MOV RAX,qword ptr [R12 + -0x20]
CMOVZ RCX,RAX
CMOVZ RDX,qword ptr [R12 + -0x18]
MOV EDI,0x0
CMOVZ RDI,R14
CMP RDI,RCX
SBB RSI,RDX
MOV R15,qword ptr [R12 + -0x40]
CMOVC RAX,R14
SUB R14,RAX
CMP R14,R15
MOV R13,R15
CMOVC R13,R14
LEA RCX,[R15 + 0x1f]
SHR RCX,0x5
LEA RCX,[RCX + RCX*0x2]
SUB RBX,RCX
JS 0x00140cca
MOV R12,qword ptr [R12]
TEST R13,R13
JZ 0x00140ca9
MOV RDI,qword ptr [R8]
ADD RDI,R12
ADD R9,RAX
MOV RSI,R9
MOV RDX,R13
MOV RBP,R8
CALL 0x001211a0
MOV R8,RBP
LAB_00140ca9:
XOR EBP,EBP
CMP R15,R14
JBE 0x00140ccf
ADD R12,qword ptr [R8]
ADD R12,R13
SUB R15,R13
XOR EBP,EBP
MOV RDI,R12
XOR ESI,ESI
MOV RDX,R15
CALL 0x00121120
JMP 0x00140ccf
LAB_00140cca:
MOV EBP,0x3
LAB_00140ccf:
MOV EAX,EBP
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* evmone::instr::core::datacopy(evmone::StackTop, long, evmone::ExecutionState&) */
int1 [16] evmone::instr::core::datacopy(ulong *param_1,long param_2,long param_3)
{
Memory *pMVar1;
int8 *puVar2;
ulong uVar3;
bool bVar4;
bool bVar5;
ulong uVar6;
ulong uVar7;
ulong uVar8;
int8 uVar9;
ulong uVar10;
ulong uVar11;
int1 auVar12 [16];
puVar2 = *(int8 **)(param_3 + 0x1f8);
auVar12 = EOF1Header::get_data(puVar2 + 9,*puVar2,puVar2[1]);
uVar11 = auVar12._0_8_;
pMVar1 = (Memory *)(param_3 + 8);
if (*(int1 (*) [16])(param_1 + -6) != (int1 [16])0x0 ||
*(int1 (*) [16])(param_1 + -8) != (int1 [16])0x0) {
uVar9 = 3;
if (((((param_1[-6] != 0 || param_1[-5] != 0) || param_1[-7] != 0) || (param_1[-8] >> 0x20 != 0)
) || ((param_1[2] != 0 || param_1[3] != 0) || param_1[1] != 0)) || (*param_1 >> 0x20 != 0))
goto LAB_00140ccf;
uVar7 = *param_1 + param_1[-8];
if (*(ulong *)(param_3 + 0x10) < uVar7) {
param_2 = grow_memory(param_2,pMVar1,uVar7);
}
if (param_2 < 0) goto LAB_00140ccf;
}
bVar4 = param_1[-1] == 0;
bVar5 = param_1[-2] == 0;
uVar7 = param_1[-2];
if (bVar4 && bVar5) {
uVar7 = param_1[-4];
}
uVar8 = param_1[-1];
if (bVar4 && bVar5) {
uVar8 = param_1[-3];
}
uVar10 = 0;
if (bVar4 && bVar5) {
uVar10 = uVar11;
}
uVar3 = param_1[-8];
uVar6 = param_1[-4];
if (uVar8 != 0 || -uVar8 < (ulong)(uVar10 < uVar7)) {
uVar6 = uVar11;
}
uVar11 = uVar11 - uVar6;
uVar7 = uVar3;
if (uVar11 < uVar3) {
uVar7 = uVar11;
}
param_2 = param_2 + (uVar3 + 0x1f >> 5) * -3;
if (param_2 < 0) {
uVar9 = 3;
}
else {
uVar8 = *param_1;
if (uVar7 != 0) {
memcpy((void *)(*(long *)pMVar1 + uVar8),(void *)(auVar12._8_8_ + uVar6),uVar7);
}
uVar9 = 0;
if (uVar11 < uVar3) {
uVar9 = 0;
memset((void *)(uVar8 + *(long *)pMVar1 + uVar7),0,uVar3 - uVar7);
}
}
LAB_00140ccf:
auVar12._8_8_ = param_2;
auVar12._0_8_ = uVar9;
return auVar12;
}
| |
41,265 | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::operator++() | monkey531[P]llama/common/json.hpp | iter_impl& operator++()
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
std::advance(m_it.object_iterator, 1);
break;
}
case value_t::array:
{
std::advance(m_it.array_iterator, 1);
break;
}
case value_t::null:
case value_t::string:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::binary:
case value_t::discarded:
default:
{
++m_it.primitive_iterator;
break;
}
}
return *this;
} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::operator++():
movq (%rdi), %rax
testq %rax, %rax
je 0x43e5f
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x43e50
cmpl $0x1, %eax
jne 0x43e57
addq $0x30, 0x8(%rdi)
jmp 0x43e5b
addq $0x10, 0x10(%rdi)
jmp 0x43e5b
incq 0x18(%rdi)
movq %rdi, %rax
retq
pushq %rax
leaq 0x6d575(%rip), %rdi # 0xb13dc
leaq 0x674f0(%rip), %rdx # 0xab35e
leaq 0x727f4(%rip), %rcx # 0xb6669
movl $0x33c0, %esi # imm = 0x33C0
xorl %eax, %eax
callq 0x23f60
nop
| _ZN8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv:
mov rax, [rdi]
test rax, rax
jz short loc_43E5F
movzx eax, byte ptr [rax]
cmp eax, 2
jz short loc_43E50
cmp eax, 1
jnz short loc_43E57
add qword ptr [rdi+8], 30h ; '0'
jmp short loc_43E5B
loc_43E50:
add qword ptr [rdi+10h], 10h
jmp short loc_43E5B
loc_43E57:
inc qword ptr [rdi+18h]
loc_43E5B:
mov rax, rdi
retn
loc_43E5F:
push rax
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAnchorMObjectN+7; "m_object != nullptr"
mov esi, 33C0h
xor eax, eax
call _ggml_abort
nop
| long long nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::operator++(
unsigned __int8 **a1)
{
int v1; // eax
if ( *a1 )
{
v1 = **a1;
if ( v1 == 2 )
{
a1[2] += 16;
}
else if ( v1 == 1 )
{
a1[1] += 48;
}
else
{
++a1[3];
}
return (long long)a1;
}
else
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
13248LL,
"GGML_ASSERT(%s) failed",
"m_object != nullptr");
return nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp");
}
}
| operator++:
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x00143e5f
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x2
JZ 0x00143e50
CMP EAX,0x1
JNZ 0x00143e57
ADD qword ptr [RDI + 0x8],0x30
JMP 0x00143e5b
LAB_00143e50:
ADD qword ptr [RDI + 0x10],0x10
JMP 0x00143e5b
LAB_00143e57:
INC qword ptr [RDI + 0x18]
LAB_00143e5b:
MOV RAX,RDI
RET
LAB_00143e5f:
PUSH RAX
LEA RDI,[0x1b13dc]
LEA RDX,[0x1ab35e]
LEA RCX,[0x1b6669]
MOV ESI,0x33c0
XOR EAX,EAX
CALL 0x00123f60
|
/* nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::TEMPNAMEPLACEHOLDERVALUE() */
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
* __thiscall
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::operator++(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this)
{
char cVar1;
int8 in_R8;
int8 in_R9;
if (*(char **)this != (char *)0x0) {
cVar1 = **(char **)this;
if (cVar1 == '\x02') {
*(long *)(this + 0x10) = *(long *)(this + 0x10) + 0x10;
}
else if (cVar1 == '\x01') {
*(long *)(this + 8) = *(long *)(this + 8) + 0x30;
}
else {
*(long *)(this + 0x18) = *(long *)(this + 0x18) + 1;
}
return this;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x33c0,
"GGML_ASSERT(%s) failed","m_object != nullptr",in_R8,in_R9,0);
}
| |
41,266 | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::operator++() | monkey531[P]llama/common/json.hpp | iter_impl& operator++()
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
std::advance(m_it.object_iterator, 1);
break;
}
case value_t::array:
{
std::advance(m_it.array_iterator, 1);
break;
}
case value_t::null:
case value_t::string:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::binary:
case value_t::discarded:
default:
{
++m_it.primitive_iterator;
break;
}
}
return *this;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::operator++():
movq (%rdi), %rax
testq %rax, %rax
je 0x8f1cb
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x8f1bc
cmpl $0x1, %eax
jne 0x8f1c3
addq $0x30, 0x8(%rdi)
jmp 0x8f1c7
addq $0x10, 0x10(%rdi)
jmp 0x8f1c7
incq 0x18(%rdi)
movq %rdi, %rax
retq
pushq %rax
leaq 0x5f206(%rip), %rdi # 0xee3d9
leaq 0x59184(%rip), %rdx # 0xe835e
leaq 0x64498(%rip), %rcx # 0xf3679
movl $0x33c0, %esi # imm = 0x33C0
xorl %eax, %eax
callq 0x1bf40
nop
| _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv:
mov rax, [rdi]
test rax, rax
jz short loc_8F1CB
movzx eax, byte ptr [rax]
cmp eax, 2
jz short loc_8F1BC
cmp eax, 1
jnz short loc_8F1C3
add qword ptr [rdi+8], 30h ; '0'
jmp short loc_8F1C7
loc_8F1BC:
add qword ptr [rdi+10h], 10h
jmp short loc_8F1C7
loc_8F1C3:
inc qword ptr [rdi+18h]
loc_8F1C7:
mov rax, rdi
retn
loc_8F1CB:
push rax
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAnchorMObjectN+7; "m_object != nullptr"
mov esi, 33C0h
xor eax, eax
call _ggml_abort
nop
| long long nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator++(
unsigned __int8 **a1)
{
int v1; // eax
if ( *a1 )
{
v1 = **a1;
if ( v1 == 2 )
{
a1[2] += 16;
}
else if ( v1 == 1 )
{
a1[1] += 48;
}
else
{
++a1[3];
}
return (long long)a1;
}
else
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
13248LL,
"GGML_ASSERT(%s) failed",
"m_object != nullptr");
return nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator*("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp");
}
}
| operator++:
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x0018f1cb
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x2
JZ 0x0018f1bc
CMP EAX,0x1
JNZ 0x0018f1c3
ADD qword ptr [RDI + 0x8],0x30
JMP 0x0018f1c7
LAB_0018f1bc:
ADD qword ptr [RDI + 0x10],0x10
JMP 0x0018f1c7
LAB_0018f1c3:
INC qword ptr [RDI + 0x18]
LAB_0018f1c7:
MOV RAX,RDI
RET
LAB_0018f1cb:
PUSH RAX
LEA RDI,[0x1ee3d9]
LEA RDX,[0x1e835e]
LEA RCX,[0x1f3679]
MOV ESI,0x33c0
XOR EAX,EAX
CALL 0x0011bf40
|
/* nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const>::TEMPNAMEPLACEHOLDERVALUE() */
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
* __thiscall
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator++(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*this)
{
char cVar1;
int8 in_R8;
int8 in_R9;
if (*(char **)this != (char *)0x0) {
cVar1 = **(char **)this;
if (cVar1 == '\x02') {
*(long *)(this + 0x10) = *(long *)(this + 0x10) + 0x10;
}
else if (cVar1 == '\x01') {
*(long *)(this + 8) = *(long *)(this + 8) + 0x30;
}
else {
*(long *)(this + 0x18) = *(long *)(this + 0x18) + 1;
}
return this;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x33c0,
"GGML_ASSERT(%s) failed","m_object != nullptr",in_R8,in_R9,0);
}
| |
41,267 | 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 0x77ad3
movl $0x1, -0x24(%rbp)
jmp 0x77b1e
cmpq $0x800, -0x18(%rbp) # imm = 0x800
jae 0x77ae6
movl $0x2, -0x24(%rbp)
jmp 0x77b1c
cmpq $0x10000, -0x18(%rbp) # imm = 0x10000
jae 0x77af9
movl $0x3, -0x24(%rbp)
jmp 0x77b1a
cmpq $0x200000, -0x18(%rbp) # imm = 0x200000
jae 0x77b0c
movl $0x4, -0x24(%rbp)
jmp 0x77b18
movl $0x0, -0x4(%rbp)
jmp 0x77beb
jmp 0x77b1a
jmp 0x77b1c
jmp 0x77b1e
movl -0x24(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x3, %eax
ja 0x77be5
movq -0x30(%rbp), %rax
leaq 0x147dd3(%rip), %rcx # 0x1bf910
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_77AD3
mov [rbp+var_24], 1
jmp short loc_77B1E
loc_77AD3:
cmp [rbp+var_18], 800h
jnb short loc_77AE6
mov [rbp+var_24], 2
jmp short loc_77B1C
loc_77AE6:
cmp [rbp+var_18], 10000h
jnb short loc_77AF9
mov [rbp+var_24], 3
jmp short loc_77B1A
loc_77AF9:
cmp [rbp+var_18], offset unk_200000
jnb short loc_77B0C
mov [rbp+var_24], 4
jmp short loc_77B18
loc_77B0C:
mov [rbp+var_4], 0
jmp loc_77BEB
loc_77B18:
jmp short $+2
loc_77B1A:
jmp short $+2
loc_77B1C:
jmp short $+2
loc_77B1E:
mov eax, [rbp+var_24]
dec eax; switch 4 cases
mov ecx, eax
mov [rbp+var_30], rcx
sub eax, 3
ja def_77B44; jumptable 0000000000077B44 default case
mov rax, [rbp+var_30]
lea rcx, jpt_77B44
movsxd rax, ds:(jpt_77B44 - 1BF910h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_77B46:
mov rax, [rbp+var_18]; jumptable 0000000000077B44 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_77B77:
mov rax, [rbp+var_18]; jumptable 0000000000077B44 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_77BA8:
mov rax, [rbp+var_18]; jumptable 0000000000077B44 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_77BD9:
mov rax, [rbp+var_18]; jumptable 0000000000077B44 case 1
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
def_77B44:
mov eax, [rbp+var_24]; jumptable 0000000000077B44 default case
mov [rbp+var_4], eax
loc_77BEB:
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 0x00177ad3
MOV dword ptr [RBP + -0x24],0x1
JMP 0x00177b1e
LAB_00177ad3:
CMP qword ptr [RBP + -0x18],0x800
JNC 0x00177ae6
MOV dword ptr [RBP + -0x24],0x2
JMP 0x00177b1c
LAB_00177ae6:
CMP qword ptr [RBP + -0x18],0x10000
JNC 0x00177af9
MOV dword ptr [RBP + -0x24],0x3
JMP 0x00177b1a
LAB_00177af9:
CMP qword ptr [RBP + -0x18],0x200000
JNC 0x00177b0c
MOV dword ptr [RBP + -0x24],0x4
JMP 0x00177b18
LAB_00177b0c:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00177beb
LAB_00177b18:
JMP 0x00177b1a
LAB_00177b1a:
JMP 0x00177b1c
LAB_00177b1c:
JMP 0x00177b1e
LAB_00177b1e:
MOV EAX,dword ptr [RBP + -0x24]
DEC EAX
MOV ECX,EAX
MOV qword ptr [RBP + -0x30],RCX
SUB EAX,0x3
JA 0x00177be5
MOV RAX,qword ptr [RBP + -0x30]
LEA RCX,[0x2bf910]
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_00177beb:
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;
}
}
| |
41,268 | OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::~LocalPointHelper() | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchTableFactory.cpp | PatchTableBuilder::LocalPointHelper::~LocalPointHelper() {
if (_options.doubleStencilTable) {
delete _stencilTable.Get<double>();
delete _stencilTableVarying.Get<double>();
} else {
delete _stencilTable.Get<float>();
delete _stencilTableVarying.Get<float>();
}
} | O1 | cpp | OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::~LocalPointHelper():
pushq %rbx
movq %rdi, %rbx
testb $0x10, 0x8(%rdi)
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x6e025
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x6e034
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x30(%rbx), %rdi
callq 0x3b840
addq $0x18, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x3b840
| _ZN10OpenSubdiv6v3_6_03Far17PatchTableBuilder16LocalPointHelperD2Ev:
push rbx; Alternative name is 'OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::~LocalPointHelper()'
mov rbx, rdi
test byte ptr [rdi+8], 10h
mov rdi, [rdi+48h]
test rdi, rdi
jz short loc_6E025
mov rax, [rdi]
call qword ptr [rax+8]
loc_6E025:
mov rdi, [rbx+50h]
test rdi, rdi
jz short loc_6E034
mov rax, [rdi]
call qword ptr [rax+8]
loc_6E034:
lea rdi, [rbx+30h]
call __ZNSt6vectorIS_IiSaIiEESaIS1_EED2Ev; std::vector<std::vector<int>>::~vector()
add rbx, 18h
mov rdi, rbx
pop rbx
jmp __ZNSt6vectorIS_IiSaIiEESaIS1_EED2Ev; std::vector<std::vector<int>>::~vector()
| void OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::~LocalPointHelper(
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper *this)
{
long long v2; // rdi
long long v3; // rdi
v2 = *((_QWORD *)this + 9);
if ( v2 )
(*(void ( **)(long long))(*(_QWORD *)v2 + 8LL))(v2);
v3 = *((_QWORD *)this + 10);
if ( v3 )
(*(void ( **)(long long))(*(_QWORD *)v3 + 8LL))(v3);
std::vector<std::vector<int>>::~vector((char *)this + 48);
std::vector<std::vector<int>>::~vector((char *)this + 24);
}
| ~LocalPointHelper:
PUSH RBX
MOV RBX,RDI
TEST byte ptr [RDI + 0x8],0x10
MOV RDI,qword ptr [RDI + 0x48]
TEST RDI,RDI
JZ 0x0016e025
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0016e025:
MOV RDI,qword ptr [RBX + 0x50]
TEST RDI,RDI
JZ 0x0016e034
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0016e034:
LEA RDI,[RBX + 0x30]
CALL 0x0013b840
ADD RBX,0x18
MOV RDI,RBX
POP RBX
JMP 0x0013b840
|
/* OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::~LocalPointHelper() */
void __thiscall
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::~LocalPointHelper
(LocalPointHelper *this)
{
if (*(long **)(this + 0x48) != (long *)0x0) {
(**(code **)(**(long **)(this + 0x48) + 8))();
}
if (*(long **)(this + 0x50) != (long *)0x0) {
(**(code **)(**(long **)(this + 0x50) + 8))();
}
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::~vector((vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)(this + 0x30));
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::~vector((vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)(this + 0x18));
return;
}
| |
41,269 | OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::~LocalPointHelper() | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchTableFactory.cpp | PatchTableBuilder::LocalPointHelper::~LocalPointHelper() {
if (_options.doubleStencilTable) {
delete _stencilTable.Get<double>();
delete _stencilTableVarying.Get<double>();
} else {
delete _stencilTable.Get<float>();
delete _stencilTableVarying.Get<float>();
}
} | O2 | cpp | OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::~LocalPointHelper():
pushq %rbx
movq %rdi, %rbx
testb $0x10, 0x8(%rdi)
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x7fc0b
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x7fc1a
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x30(%rbx), %rdi
callq 0x54b80
addq $0x18, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x54b80
| _ZN10OpenSubdiv6v3_6_03Far17PatchTableBuilder16LocalPointHelperD2Ev:
push rbx; Alternative name is 'OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::~LocalPointHelper()'
mov rbx, rdi
test byte ptr [rdi+8], 10h
mov rdi, [rdi+48h]
test rdi, rdi
jz short loc_7FC0B
mov rax, [rdi]
call qword ptr [rax+8]
loc_7FC0B:
mov rdi, [rbx+50h]
test rdi, rdi
jz short loc_7FC1A
mov rax, [rdi]
call qword ptr [rax+8]
loc_7FC1A:
lea rdi, [rbx+30h]
call __ZNSt6vectorIS_IiSaIiEESaIS1_EED2Ev; std::vector<std::vector<int>>::~vector()
add rbx, 18h
mov rdi, rbx
pop rbx
jmp __ZNSt6vectorIS_IiSaIiEESaIS1_EED2Ev; std::vector<std::vector<int>>::~vector()
| void OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::~LocalPointHelper(
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper *this)
{
long long v2; // rdi
long long v3; // rdi
v2 = *((_QWORD *)this + 9);
if ( v2 )
(*(void ( **)(long long))(*(_QWORD *)v2 + 8LL))(v2);
v3 = *((_QWORD *)this + 10);
if ( v3 )
(*(void ( **)(long long))(*(_QWORD *)v3 + 8LL))(v3);
std::vector<std::vector<int>>::~vector((char *)this + 48);
std::vector<std::vector<int>>::~vector((char *)this + 24);
}
| ~LocalPointHelper:
PUSH RBX
MOV RBX,RDI
TEST byte ptr [RDI + 0x8],0x10
MOV RDI,qword ptr [RDI + 0x48]
TEST RDI,RDI
JZ 0x0017fc0b
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0017fc0b:
MOV RDI,qword ptr [RBX + 0x50]
TEST RDI,RDI
JZ 0x0017fc1a
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0017fc1a:
LEA RDI,[RBX + 0x30]
CALL 0x00154b80
ADD RBX,0x18
MOV RDI,RBX
POP RBX
JMP 0x00154b80
|
/* OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::~LocalPointHelper() */
void __thiscall
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::~LocalPointHelper
(LocalPointHelper *this)
{
if (*(long **)(this + 0x48) != (long *)0x0) {
(**(code **)(**(long **)(this + 0x48) + 8))();
}
if (*(long **)(this + 0x50) != (long *)0x0) {
(**(code **)(**(long **)(this + 0x50) + 8))();
}
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::~vector((vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)(this + 0x30));
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::~vector((vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)(this + 0x18));
return;
}
| |
41,270 | ftxui::(anonymous namespace)::Bold::Render(ftxui::Screen&) | Andrewchistyakov[P]flashcards_lyc/build_O3/_deps/ftxui-src/src/ftxui/dom/bold.cpp | void Render(Screen& screen) override {
for (int y = box_.y_min; y <= box_.y_max; ++y) {
for (int x = box_.x_min; x <= box_.x_max; ++x) {
screen.PixelAt(x, y).bold = true;
}
}
Node::Render(screen);
} | O3 | cpp | ftxui::(anonymous namespace)::Bold::Render(ftxui::Screen&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x54(%rdi), %r15d
movl 0x58(%rdi), %ecx
cmpl %ecx, %r15d
jg 0x375c7
movl 0x50(%r14), %eax
movl 0x4c(%r14), %r12d
cmpl %eax, %r12d
jg 0x375bb
movq %rbx, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0x3985c
orb $0x2, (%rax)
leal 0x1(%r12), %ecx
movl 0x50(%r14), %eax
cmpl %eax, %r12d
movl %ecx, %r12d
jl 0x37595
movl 0x58(%r14), %ecx
leal 0x1(%r15), %edx
cmpl %ecx, %r15d
movl %edx, %r15d
jl 0x3758c
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x23eae
nopl (%rax)
| _ZN5ftxui12_GLOBAL__N_14Bold6RenderERNS_6ScreenE:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov r15d, [rdi+54h]
mov ecx, [rdi+58h]
cmp r15d, ecx
jg short loc_375C7
mov eax, [r14+50h]
loc_3758C:
mov r12d, [r14+4Ch]
cmp r12d, eax
jg short loc_375BB
loc_37595:
mov rdi, rbx; this
mov esi, r12d; int
mov edx, r15d; int
call _ZN5ftxui6Screen7PixelAtEii; ftxui::Screen::PixelAt(int,int)
or byte ptr [rax], 2
lea ecx, [r12+1]
mov eax, [r14+50h]
cmp r12d, eax
mov r12d, ecx
jl short loc_37595
mov ecx, [r14+58h]
loc_375BB:
lea edx, [r15+1]
cmp r15d, ecx
mov r15d, edx
jl short loc_3758C
loc_375C7:
mov rdi, r14
mov rsi, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
jmp _ZN5ftxui4Node6RenderERNS_6ScreenE; ftxui::Node::Render(ftxui::Screen &)
| long long ftxui::`anonymous namespace'::Bold::Render(
ftxui::_anonymous_namespace_::Bold *this,
ftxui::Screen *a2)
{
int v2; // r15d
int v3; // ecx
int v4; // eax
int v5; // r12d
_BYTE *v6; // rax
bool v7; // cc
v2 = *((_DWORD *)this + 21);
v3 = *((_DWORD *)this + 22);
if ( v2 <= v3 )
{
v4 = *((_DWORD *)this + 20);
do
{
v5 = *((_DWORD *)this + 19);
if ( v5 <= v4 )
{
do
{
v6 = (_BYTE *)ftxui::Screen::PixelAt(a2, v5, v2);
*v6 |= 2u;
v4 = *((_DWORD *)this + 20);
v7 = v5++ < v4;
}
while ( v7 );
v3 = *((_DWORD *)this + 22);
}
v7 = v2++ < v3;
}
while ( v7 );
}
return ftxui::Node::Render(this, a2);
}
| Render:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV R15D,dword ptr [RDI + 0x54]
MOV ECX,dword ptr [RDI + 0x58]
CMP R15D,ECX
JG 0x001375c7
MOV EAX,dword ptr [R14 + 0x50]
LAB_0013758c:
MOV R12D,dword ptr [R14 + 0x4c]
CMP R12D,EAX
JG 0x001375bb
LAB_00137595:
MOV RDI,RBX
MOV ESI,R12D
MOV EDX,R15D
CALL 0x0013985c
OR byte ptr [RAX],0x2
LEA ECX,[R12 + 0x1]
MOV EAX,dword ptr [R14 + 0x50]
CMP R12D,EAX
MOV R12D,ECX
JL 0x00137595
MOV ECX,dword ptr [R14 + 0x58]
LAB_001375bb:
LEA EDX,[R15 + 0x1]
CMP R15D,ECX
MOV R15D,EDX
JL 0x0013758c
LAB_001375c7:
MOV RDI,R14
MOV RSI,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
JMP 0x00123eae
|
/* ftxui::(anonymous namespace)::Bold::Render(ftxui::Screen&) */
void __thiscall ftxui::(anonymous_namespace)::Bold::Render(Bold *this,Screen *param_1)
{
bool bVar1;
int iVar2;
byte *pbVar3;
int iVar4;
int iVar5;
int iVar6;
iVar4 = *(int *)(this + 0x58);
if (*(int *)(this + 0x54) <= iVar4) {
iVar2 = *(int *)(this + 0x50);
iVar6 = *(int *)(this + 0x54);
do {
iVar5 = *(int *)(this + 0x4c);
if (*(int *)(this + 0x4c) <= iVar2) {
do {
pbVar3 = (byte *)Screen::PixelAt(param_1,iVar5,iVar6);
*pbVar3 = *pbVar3 | 2;
iVar2 = *(int *)(this + 0x50);
bVar1 = iVar5 < iVar2;
iVar5 = iVar5 + 1;
} while (bVar1);
iVar4 = *(int *)(this + 0x58);
}
bVar1 = iVar6 < iVar4;
iVar6 = iVar6 + 1;
} while (bVar1);
}
Node::Render((Node *)this,param_1);
return;
}
| |
41,271 | FileDescriptor::FDWrapper::FDWrapper(int) | minnow/util/file_descriptor.cc | FileDescriptor::FDWrapper::FDWrapper( int fd ) : fd_( fd )
{
if ( fd < 0 ) {
throw runtime_error( "invalid fd number:" + to_string( fd ) );
}
const int flags = CheckSystemCall( "fcntl", fcntl( fd, F_GETFL ) ); // NOLINT(*-vararg)
non_blocking_ = flags & O_NONBLOCK; // NOLINT(*-bitwise)
} | O0 | cpp | FileDescriptor::FDWrapper::FDWrapper(int):
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movb $0x0, 0x4(%rax)
movb $0x0, 0x5(%rax)
movb $0x0, 0x6(%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
cmpl $0x0, -0xc(%rbp)
jge 0x15dcb
movb $0x1, -0x5d(%rbp)
movl $0x10, %edi
callq 0x5140
movq %rax, -0x90(%rbp)
movl -0xc(%rbp), %esi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xecc0
movq -0x88(%rbp), %rdx
leaq 0x5989(%rip), %rsi # 0x1b6d2
leaq -0x30(%rbp), %rdi
callq 0x12660
jmp 0x15d54
movq -0x90(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5390
jmp 0x15d66
movq -0x90(%rbp), %rdi
movb $0x0, -0x5d(%rbp)
movq 0x13260(%rip), %rsi # 0x28fd8
movq 0x13211(%rip), %rdx # 0x28f90
callq 0x53d0
jmp 0x15e2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x15dac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5e50
leaq -0x50(%rbp), %rdi
callq 0x5e50
testb $0x1, -0x5d(%rbp)
jne 0x15dbd
jmp 0x15dc9
movq -0x90(%rbp), %rdi
callq 0x51f0
jmp 0x15e24
leaq -0x78(%rbp), %rdi
leaq 0x590f(%rip), %rsi # 0x1b6e5
callq 0xed90
movl -0xc(%rbp), %edi
movl $0x3, %esi
movb $0x0, %al
callq 0x51b0
movq -0x80(%rbp), %rdi
movl %eax, %ecx
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x16b40
movl %eax, %ecx
movq -0x80(%rbp), %rax
movl %ecx, -0x64(%rbp)
movl -0x64(%rbp), %ecx
andl $0x800, %ecx # imm = 0x800
cmpl $0x0, %ecx
setne %cl
andb $0x1, %cl
movb %cl, 0x6(%rax)
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x53f0
nopl (%rax)
| _ZN14FileDescriptor9FDWrapperC2Ei:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov rax, [rbp+var_8]
mov [rbp+var_80], rax
mov ecx, [rbp+var_C]
mov [rax], ecx
mov byte ptr [rax+4], 0
mov byte ptr [rax+5], 0
mov byte ptr [rax+6], 0
mov dword ptr [rax+8], 0
mov dword ptr [rax+0Ch], 0
cmp [rbp+var_C], 0
jge loc_15DCB
mov [rbp+var_5D], 1
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov [rbp+var_90], rax
mov esi, [rbp+var_C]; int
lea rdi, [rbp+var_50]; this
mov [rbp+var_88], rdi
call _ZNSt7__cxx119to_stringEi; std::to_string(int)
mov rdx, [rbp+var_88]
lea rsi, aInvalidFdNumbe; "invalid fd number:"
lea rdi, [rbp+var_30]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
jmp short $+2
loc_15D54:
mov rdi, [rbp+var_90]
lea rsi, [rbp+var_30]
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
jmp short $+2
loc_15D66:
mov rdi, [rbp+var_90]; void *
mov [rbp+var_5D], 0
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_15E2D
mov rcx, rax
mov eax, edx
mov [rbp+var_58], rcx
mov [rbp+var_5C], eax
jmp short loc_15DAC
mov rcx, rax
mov eax, edx
mov [rbp+var_58], rcx
mov [rbp+var_5C], eax
lea rdi, [rbp+var_30]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_15DAC:
lea rdi, [rbp+var_50]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test [rbp+var_5D], 1
jnz short loc_15DBD
jmp short loc_15DC9
loc_15DBD:
mov rdi, [rbp+var_90]; void *
call ___cxa_free_exception
loc_15DC9:
jmp short loc_15E24
loc_15DCB:
lea rdi, [rbp+var_78]
lea rsi, aFcntl_0; "fcntl"
call _ZNSt17basic_string_viewIcSt11char_traitsIcEEC2EPKc; std::string_view::basic_string_view(char const*)
mov edi, [rbp+var_C]
mov esi, 3
mov al, 0
call _fcntl
mov rdi, [rbp+var_80]
mov ecx, eax
mov rsi, [rbp+var_78]
mov rdx, [rbp+var_70]
call _ZNK14FileDescriptor9FDWrapper15CheckSystemCallIiEET_St17basic_string_viewIcSt11char_traitsIcEES2_; FileDescriptor::FDWrapper::CheckSystemCall<int>(std::string_view,int)
mov ecx, eax
mov rax, [rbp+var_80]
mov [rbp+var_64], ecx
mov ecx, [rbp+var_64]
and ecx, 800h
cmp ecx, 0
setnz cl
and cl, 1
mov [rax+6], cl
add rsp, 90h
pop rbp
retn
loc_15E24:
mov rdi, [rbp+var_58]
call __Unwind_Resume
loc_15E2D:
nop dword ptr [rax]
| FileDescriptor::FDWrapper * FileDescriptor::FDWrapper::FDWrapper(FileDescriptor::FDWrapper *this, int a2)
{
unsigned int v2; // eax
__int16 v3; // cx
FileDescriptor::FDWrapper *result; // rax
void *exception; // [rsp+0h] [rbp-90h]
long long v6[2]; // [rsp+18h] [rbp-78h] BYREF
char v7; // [rsp+33h] [rbp-5Dh]
_BYTE v8[32]; // [rsp+40h] [rbp-50h] BYREF
_QWORD v9[4]; // [rsp+60h] [rbp-30h] BYREF
int v10; // [rsp+84h] [rbp-Ch]
FileDescriptor::FDWrapper *v11; // [rsp+88h] [rbp-8h]
v11 = this;
v10 = a2;
*(_DWORD *)this = a2;
*((_BYTE *)this + 4) = 0;
*((_BYTE *)this + 5) = 0;
*((_BYTE *)this + 6) = 0;
*((_DWORD *)this + 2) = 0;
*((_DWORD *)this + 3) = 0;
if ( v10 < 0 )
{
exception = __cxa_allocate_exception(0x10uLL);
std::to_string((std::__cxx11 *)v8, v10);
std::operator+<char>(v9, (long long)"invalid fd number:", (long long)v8);
std::runtime_error::runtime_error(exception, v9);
v7 = 0;
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
std::string_view::basic_string_view(v6, (long long)"fcntl");
v2 = fcntl((unsigned int)v10, 3LL);
v3 = FileDescriptor::FDWrapper::CheckSystemCall<int>(this, v6[0], v6[1], v2);
result = this;
*((_BYTE *)this + 6) = (v3 & 0x800) != 0;
return result;
}
| FDWrapper:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x80],RAX
MOV ECX,dword ptr [RBP + -0xc]
MOV dword ptr [RAX],ECX
MOV byte ptr [RAX + 0x4],0x0
MOV byte ptr [RAX + 0x5],0x0
MOV byte ptr [RAX + 0x6],0x0
MOV dword ptr [RAX + 0x8],0x0
MOV dword ptr [RAX + 0xc],0x0
CMP dword ptr [RBP + -0xc],0x0
JGE 0x00115dcb
MOV byte ptr [RBP + -0x5d],0x1
MOV EDI,0x10
CALL 0x00105140
MOV qword ptr [RBP + -0x90],RAX
MOV ESI,dword ptr [RBP + -0xc]
LEA RDI,[RBP + -0x50]
MOV qword ptr [RBP + -0x88],RDI
CALL 0x0010ecc0
MOV RDX,qword ptr [RBP + -0x88]
LAB_00115d42:
LEA RSI,[0x11b6d2]
LEA RDI,[RBP + -0x30]
CALL 0x00112660
JMP 0x00115d54
LAB_00115d54:
MOV RDI,qword ptr [RBP + -0x90]
LEA RSI,[RBP + -0x30]
CALL 0x00105390
JMP 0x00115d66
LAB_00115d66:
MOV RDI,qword ptr [RBP + -0x90]
MOV byte ptr [RBP + -0x5d],0x0
MOV RSI,qword ptr [0x00128fd8]
MOV RDX,qword ptr [0x00128f90]
CALL 0x001053d0
LAB_00115dcb:
LEA RDI,[RBP + -0x78]
LEA RSI,[0x11b6e5]
CALL 0x0010ed90
MOV EDI,dword ptr [RBP + -0xc]
MOV ESI,0x3
MOV AL,0x0
CALL 0x001051b0
MOV RDI,qword ptr [RBP + -0x80]
MOV ECX,EAX
MOV RSI,qword ptr [RBP + -0x78]
MOV RDX,qword ptr [RBP + -0x70]
CALL 0x00116b40
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x80]
MOV dword ptr [RBP + -0x64],ECX
MOV ECX,dword ptr [RBP + -0x64]
AND ECX,0x800
CMP ECX,0x0
SETNZ CL
AND CL,0x1
MOV byte ptr [RAX + 0x6],CL
ADD RSP,0x90
POP RBP
RET
|
/* FileDescriptor::FDWrapper::FDWrapper(int) */
void __thiscall FileDescriptor::FDWrapper::FDWrapper(FDWrapper *this,int param_1)
{
int iVar1;
uint uVar2;
runtime_error *this_00;
int8 local_80;
int8 local_78;
int1 local_65;
__cxx11 local_58 [32];
string local_38 [36];
int local_14;
FDWrapper *local_10;
*(int *)this = param_1;
this[4] = (FDWrapper)0x0;
this[5] = (FDWrapper)0x0;
this[6] = (FDWrapper)0x0;
*(int4 *)(this + 8) = 0;
*(int4 *)(this + 0xc) = 0;
local_14 = param_1;
local_10 = this;
if (param_1 < 0) {
local_65 = 1;
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
std::__cxx11::to_string(local_58,local_14);
/* try { // try from 00115d42 to 00115d51 has its CatchHandler @ 00115d89 */
std::operator+((char *)local_38,(string *)"invalid fd number:");
/* try { // try from 00115d54 to 00115d83 has its CatchHandler @ 00115d97 */
std::runtime_error::runtime_error(this_00,local_38);
local_65 = 0;
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_00128fd8,PTR__runtime_error_00128f90);
}
std::basic_string_view<char,std::char_traits<char>>::basic_string_view
((basic_string_view<char,std::char_traits<char>> *)&local_80,"fcntl");
iVar1 = fcntl(local_14,3);
uVar2 = CheckSystemCall<int>(this,local_80,local_78,iVar1);
this[6] = (FDWrapper)((uVar2 & 0x800) != 0);
return;
}
| |
41,272 | mariadb_uncompress | eloqsql/libmariadb/libmariadb/ma_compress.c | my_bool _mariadb_uncompress (NET *net, unsigned char *packet, size_t *len, size_t *complen)
{
if (*complen) /* If compressed */
{
unsigned char *compbuf = (unsigned char *) malloc (*complen);
if (!compbuf)
return 1; /* Not enough memory */
if (compression_plugin(net)->decompress(compression_ctx(net), compbuf, complen, packet, len))
{ /* Probably wrong packet */
free(compbuf);
return 1;
}
*len = *complen;
memcpy(packet,compbuf,*len);
free(compbuf);
}
else *complen= *len;
return 0;
} | O3 | c | mariadb_uncompress:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, -0x30(%rbp)
movq %rdi, %r12
movq (%rcx), %rdi
testq %rdi, %rdi
je 0x1e040
callq 0x13600
movb $0x1, %bl
testq %rax, %rax
je 0x1e063
movq %rax, %r13
movq 0x2a0(%r12), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rax
movq %r13, %rsi
movq %r14, %rdx
movq -0x30(%rbp), %r12
movq %r12, %rcx
movq %r15, %r8
callq *0x70(%rax)
testb %al, %al
je 0x1e048
movq %r13, %rdi
callq 0x13570
jmp 0x1e063
movq (%r15), %rax
movq %rax, (%r14)
jmp 0x1e061
movq (%r14), %rdx
movq %rdx, (%r15)
movq %r12, %rdi
movq %r13, %rsi
callq 0x13390
movq %r13, %rdi
callq 0x13570
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _mariadb_uncompress:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rcx
mov r15, rdx
mov [rbp+var_30], rsi
mov r12, rdi
mov rdi, [rcx]
test rdi, rdi
jz short loc_1E040
call _malloc
mov bl, 1
test rax, rax
jz short loc_1E063
mov r13, rax
mov rax, [r12+2A0h]
mov rdi, [rax+8]
mov rax, [rax+10h]
mov rsi, r13
mov rdx, r14
mov r12, [rbp+var_30]
mov rcx, r12
mov r8, r15
call qword ptr [rax+70h]
test al, al
jz short loc_1E048
mov rdi, r13
call _free
jmp short loc_1E063
loc_1E040:
mov rax, [r15]
mov [r14], rax
jmp short loc_1E061
loc_1E048:
mov rdx, [r14]
mov [r15], rdx
mov rdi, r12
mov rsi, r13
call _memcpy
mov rdi, r13
call _free
loc_1E061:
xor ebx, ebx
loc_1E063:
mov eax, ebx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long mariadb_uncompress(long long a1, long long a2, _QWORD *a3, _QWORD *a4)
{
unsigned int v4; // ebx
long long v7; // rax
long long v8; // r13
long long v9; // rdx
if ( !*a4 )
{
*a4 = *a3;
return 0;
}
v7 = malloc(*a4);
LOBYTE(v4) = 1;
if ( v7 )
{
v8 = v7;
if ( (*(unsigned __int8 ( **)(_QWORD, long long, _QWORD *, long long, _QWORD *))(*(_QWORD *)(*(_QWORD *)(a1 + 672) + 16LL)
+ 112LL))(
*(_QWORD *)(*(_QWORD *)(a1 + 672) + 8LL),
v7,
a4,
a2,
a3) )
{
free(v8);
return v4;
}
v9 = *a4;
*a3 = *a4;
memcpy(a2, v8, v9);
free(v8);
return 0;
}
return v4;
}
| _mariadb_uncompress:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RCX
MOV R15,RDX
MOV qword ptr [RBP + -0x30],RSI
MOV R12,RDI
MOV RDI,qword ptr [RCX]
TEST RDI,RDI
JZ 0x0011e040
CALL 0x00113600
MOV BL,0x1
TEST RAX,RAX
JZ 0x0011e063
MOV R13,RAX
MOV RAX,qword ptr [R12 + 0x2a0]
MOV RDI,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RSI,R13
MOV RDX,R14
MOV R12,qword ptr [RBP + -0x30]
MOV RCX,R12
MOV R8,R15
CALL qword ptr [RAX + 0x70]
TEST AL,AL
JZ 0x0011e048
MOV RDI,R13
CALL 0x00113570
JMP 0x0011e063
LAB_0011e040:
MOV RAX,qword ptr [R15]
MOV qword ptr [R14],RAX
JMP 0x0011e061
LAB_0011e048:
MOV RDX,qword ptr [R14]
MOV qword ptr [R15],RDX
MOV RDI,R12
MOV RSI,R13
CALL 0x00113390
MOV RDI,R13
CALL 0x00113570
LAB_0011e061:
XOR EBX,EBX
LAB_0011e063:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong _mariadb_uncompress(long param_1,void *param_2,size_t *param_3,size_t *param_4)
{
size_t __n;
char cVar1;
void *__src;
int8 unaff_RBX;
ulong uVar2;
if (*param_4 == 0) {
*param_4 = *param_3;
}
else {
__src = malloc(*param_4);
uVar2 = CONCAT71((int7)((ulong)unaff_RBX >> 8),1);
if (__src == (void *)0x0) goto LAB_0011e063;
cVar1 = (**(code **)(*(long *)(*(long *)(param_1 + 0x2a0) + 0x10) + 0x70))
(*(int8 *)(*(long *)(param_1 + 0x2a0) + 8),__src,param_4,param_2,param_3
);
if (cVar1 != '\0') {
free(__src);
goto LAB_0011e063;
}
__n = *param_4;
*param_3 = __n;
memcpy(param_2,__src,__n);
free(__src);
}
uVar2 = 0;
LAB_0011e063:
return uVar2 & 0xffffffff;
}
| |
41,273 | voxel_sounds::init() | untodesu[P]voxelius/game/client/voxel_sounds.cc | void voxel_sounds::init(void)
{
add_footsteps_effect(voxel_surface::DEFAULT, "sounds/surface/default1.wav");
add_footsteps_effect(voxel_surface::DEFAULT, "sounds/surface/default2.wav");
add_footsteps_effect(voxel_surface::DEFAULT, "sounds/surface/default3.wav");
add_footsteps_effect(voxel_surface::DEFAULT, "sounds/surface/default4.wav");
add_footsteps_effect(voxel_surface::DIRT, "sounds/surface/dirt1.wav");
add_footsteps_effect(voxel_surface::GRASS, "sounds/surface/grass1.wav");
add_footsteps_effect(voxel_surface::GRASS, "sounds/surface/grass2.wav");
add_footsteps_effect(voxel_surface::GRASS, "sounds/surface/grass3.wav");
add_footsteps_effect(voxel_surface::GRAVEL, "sounds/surface/gravel1.wav");
add_footsteps_effect(voxel_surface::SAND, "sounds/surface/sand1.wav");
add_footsteps_effect(voxel_surface::SAND, "sounds/surface/sand2.wav");
add_footsteps_effect(voxel_surface::WOOD, "sounds/surface/wood1.wav");
add_footsteps_effect(voxel_surface::WOOD, "sounds/surface/wood2.wav");
add_footsteps_effect(voxel_surface::WOOD, "sounds/surface/wood3.wav");
} | O3 | cpp | voxel_sounds::init():
pushq %rax
leaq 0x129833(%rip), %rsi # 0x19bfdb
xorl %edi, %edi
callq 0x72881
leaq 0x129841(%rip), %rsi # 0x19bff7
xorl %edi, %edi
callq 0x72881
leaq 0x12984f(%rip), %rsi # 0x19c013
xorl %edi, %edi
callq 0x72881
leaq 0x12985d(%rip), %rsi # 0x19c02f
xorl %edi, %edi
callq 0x72881
leaq 0x12986b(%rip), %rsi # 0x19c04b
movl $0x2, %edi
callq 0x72881
leaq 0x129873(%rip), %rsi # 0x19c064
movl $0x4, %edi
callq 0x72881
leaq 0x12987c(%rip), %rsi # 0x19c07e
movl $0x4, %edi
callq 0x72881
leaq 0x129885(%rip), %rsi # 0x19c098
movl $0x4, %edi
callq 0x72881
leaq 0x12988e(%rip), %rsi # 0x19c0b2
movl $0x5, %edi
callq 0x72881
leaq 0x129898(%rip), %rsi # 0x19c0cd
movl $0x7, %edi
callq 0x72881
leaq 0x1298a0(%rip), %rsi # 0x19c0e6
movl $0x7, %edi
callq 0x72881
leaq 0x1298a8(%rip), %rsi # 0x19c0ff
movl $0x8, %edi
callq 0x72881
leaq 0x1298b0(%rip), %rsi # 0x19c118
movl $0x8, %edi
callq 0x72881
leaq 0x1298b8(%rip), %rsi # 0x19c131
movl $0x8, %edi
popq %rax
jmp 0x72881
| _ZN12voxel_sounds4initEv:
push rax
lea rsi, aSoundsSurfaceD; "sounds/surface/default1.wav"
xor edi, edi
call _ZL20add_footsteps_effect13voxel_surfacePKc; add_footsteps_effect(voxel_surface,char const*)
lea rsi, aSoundsSurfaceD_0; "sounds/surface/default2.wav"
xor edi, edi
call _ZL20add_footsteps_effect13voxel_surfacePKc; add_footsteps_effect(voxel_surface,char const*)
lea rsi, aSoundsSurfaceD_1; "sounds/surface/default3.wav"
xor edi, edi
call _ZL20add_footsteps_effect13voxel_surfacePKc; add_footsteps_effect(voxel_surface,char const*)
lea rsi, aSoundsSurfaceD_2; "sounds/surface/default4.wav"
xor edi, edi
call _ZL20add_footsteps_effect13voxel_surfacePKc; add_footsteps_effect(voxel_surface,char const*)
lea rsi, aSoundsSurfaceD_3; "sounds/surface/dirt1.wav"
mov edi, 2
call _ZL20add_footsteps_effect13voxel_surfacePKc; add_footsteps_effect(voxel_surface,char const*)
lea rsi, aSoundsSurfaceG; "sounds/surface/grass1.wav"
mov edi, 4
call _ZL20add_footsteps_effect13voxel_surfacePKc; add_footsteps_effect(voxel_surface,char const*)
lea rsi, aSoundsSurfaceG_0; "sounds/surface/grass2.wav"
mov edi, 4
call _ZL20add_footsteps_effect13voxel_surfacePKc; add_footsteps_effect(voxel_surface,char const*)
lea rsi, aSoundsSurfaceG_1; "sounds/surface/grass3.wav"
mov edi, 4
call _ZL20add_footsteps_effect13voxel_surfacePKc; add_footsteps_effect(voxel_surface,char const*)
lea rsi, aSoundsSurfaceG_2; "sounds/surface/gravel1.wav"
mov edi, 5
call _ZL20add_footsteps_effect13voxel_surfacePKc; add_footsteps_effect(voxel_surface,char const*)
lea rsi, aSoundsSurfaceS; "sounds/surface/sand1.wav"
mov edi, 7
call _ZL20add_footsteps_effect13voxel_surfacePKc; add_footsteps_effect(voxel_surface,char const*)
lea rsi, aSoundsSurfaceS_0; "sounds/surface/sand2.wav"
mov edi, 7
call _ZL20add_footsteps_effect13voxel_surfacePKc; add_footsteps_effect(voxel_surface,char const*)
lea rsi, aSoundsSurfaceW; "sounds/surface/wood1.wav"
mov edi, 8
call _ZL20add_footsteps_effect13voxel_surfacePKc; add_footsteps_effect(voxel_surface,char const*)
lea rsi, aSoundsSurfaceW_0; "sounds/surface/wood2.wav"
mov edi, 8
call _ZL20add_footsteps_effect13voxel_surfacePKc; add_footsteps_effect(voxel_surface,char const*)
lea rsi, aSoundsSurfaceW_1; "sounds/surface/wood3.wav"
mov edi, 8
pop rax
jmp short $+2; add_footsteps_effect(voxel_surface,char const*)
| init:
PUSH RAX
LEA RSI,[0x29bfdb]
XOR EDI,EDI
CALL 0x00172881
LEA RSI,[0x29bff7]
XOR EDI,EDI
CALL 0x00172881
LEA RSI,[0x29c013]
XOR EDI,EDI
CALL 0x00172881
LEA RSI,[0x29c02f]
XOR EDI,EDI
CALL 0x00172881
LEA RSI,[0x29c04b]
MOV EDI,0x2
CALL 0x00172881
LEA RSI,[0x29c064]
MOV EDI,0x4
CALL 0x00172881
LEA RSI,[0x29c07e]
MOV EDI,0x4
CALL 0x00172881
LEA RSI,[0x29c098]
MOV EDI,0x4
CALL 0x00172881
LEA RSI,[0x29c0b2]
MOV EDI,0x5
CALL 0x00172881
LEA RSI,[0x29c0cd]
MOV EDI,0x7
CALL 0x00172881
LEA RSI,[0x29c0e6]
MOV EDI,0x7
CALL 0x00172881
LEA RSI,[0x29c0ff]
MOV EDI,0x8
CALL 0x00172881
LEA RSI,[0x29c118]
MOV EDI,0x8
CALL 0x00172881
LEA RSI,[0x29c131]
MOV EDI,0x8
POP RAX
JMP 0x00172881
|
/* voxel_sounds::init() */
void voxel_sounds::init(void)
{
add_footsteps_effect(0,"sounds/surface/default1.wav");
add_footsteps_effect(0,"sounds/surface/default2.wav");
add_footsteps_effect(0,"sounds/surface/default3.wav");
add_footsteps_effect(0,"sounds/surface/default4.wav");
add_footsteps_effect(2,"sounds/surface/dirt1.wav");
add_footsteps_effect(4,"sounds/surface/grass1.wav");
add_footsteps_effect(4,"sounds/surface/grass2.wav");
add_footsteps_effect(4,"sounds/surface/grass3.wav");
add_footsteps_effect(5,"sounds/surface/gravel1.wav");
add_footsteps_effect(7,"sounds/surface/sand1.wav");
add_footsteps_effect(7,"sounds/surface/sand2.wav");
add_footsteps_effect(8,"sounds/surface/wood1.wav");
add_footsteps_effect(8,"sounds/surface/wood2.wav");
add_footsteps_effect(8,"sounds/surface/wood3.wav");
return;
}
| ||
41,274 | Catch::formatReconstructedExpression(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::StringRef, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AlayaLite/build_O3/_deps/libcoro-src/test/catch_amalgamated.cpp | void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
if( lhs.size() + rhs.size() < 40 &&
lhs.find('\n') == std::string::npos &&
rhs.find('\n') == std::string::npos )
os << lhs << ' ' << op << ' ' << rhs;
else
os << lhs << '\n' << op << '\n' << rhs;
} | O3 | cpp | Catch::formatReconstructedExpression(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::StringRef, 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 $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, 0x10(%rsp)
movq %rsi, %rbp
movq %rdi, %r13
movq 0x8(%rsi), %r12
movq 0x8(%r8), %r14
leaq (%r14,%r12), %rax
cmpq $0x27, %rax
ja 0x5bfad
testq %r12, %r12
movq %r15, 0x8(%rsp)
je 0x5bf3e
movq (%rbp), %r15
movq %r15, %rdi
movl $0xa, %esi
movq %r12, %rdx
callq 0x17500
testq %rax, %rax
setne %cl
subq %r15, %rax
movq 0x8(%rsp), %r15
cmpq $-0x1, %rax
setne %al
testb %al, %cl
jne 0x5bfad
testq %r14, %r14
je 0x5bf6f
movq (%rbx), %r15
movq %r15, %rdi
movl $0xa, %esi
movq %r14, %rdx
callq 0x17500
testq %rax, %rax
setne %cl
subq %r15, %rax
movq 0x8(%rsp), %r15
cmpq $-0x1, %rax
setne %al
testb %al, %cl
jne 0x5bfad
movq (%rbp), %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0x17be0
movb $0x20, %bpl
leaq 0x4(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x17be0
movq %rax, %rdi
movq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x17580
leaq 0x5(%rsp), %rsi
jmp 0x5bfe9
movq (%rbp), %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0x17be0
movb $0xa, %bpl
leaq 0x6(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x17be0
movq %rax, %rdi
movq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x17580
leaq 0x7(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x17be0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %rax, %rdi
callq 0x17be0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN5Catch29formatReconstructedExpressionERSoRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_9StringRefES8_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, r8
mov r15, rcx
mov [rsp+48h+var_38], rdx
mov rbp, rsi
mov r13, rdi
mov r12, [rsi+8]
mov r14, [r8+8]
lea rax, [r14+r12]
cmp rax, 27h ; '''
ja loc_5BFAD
test r12, r12
mov [rsp+48h+var_40], r15
jz short loc_5BF3E
mov r15, [rbp+0]
mov rdi, r15
mov esi, 0Ah
mov rdx, r12
call _memchr
test rax, rax
setnz cl
sub rax, r15
mov r15, [rsp+48h+var_40]
cmp rax, 0FFFFFFFFFFFFFFFFh
setnz al
test cl, al
jnz short loc_5BFAD
loc_5BF3E:
test r14, r14
jz short loc_5BF6F
mov r15, [rbx]
mov rdi, r15
mov esi, 0Ah
mov rdx, r14
call _memchr
test rax, rax
setnz cl
sub rax, r15
mov r15, [rsp+48h+var_40]
cmp rax, 0FFFFFFFFFFFFFFFFh
setnz al
test cl, al
jnz short loc_5BFAD
loc_5BF6F:
mov rsi, [rbp+0]
mov rdi, r13
mov rdx, r12
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov bpl, 20h ; ' '
lea rsi, [rsp+48h+var_44]
mov [rsi], bpl
mov edx, 1
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, rax; this
mov rsi, [rsp+48h+var_38]; char *
mov rdx, r15; __int64
call __ZNSo5writeEPKcl; std::ostream::write(char const*,long)
lea rsi, [rsp+48h+var_43]
jmp short loc_5BFE9
loc_5BFAD:
mov rsi, [rbp+0]
mov rdi, r13
mov rdx, r12
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov bpl, 0Ah
lea rsi, [rsp+48h+var_42]
mov [rsi], bpl
mov edx, 1
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, rax; this
mov rsi, [rsp+48h+var_38]; char *
mov rdx, r15; __int64
call __ZNSo5writeEPKcl; std::ostream::write(char const*,long)
lea rsi, [rsp+48h+var_41]
loc_5BFE9:
mov [rsi], bpl
mov edx, 1
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rsi, [rbx]
mov rdx, [rbx+8]
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long Catch::formatReconstructedExpression(long long a1, _QWORD *a2, char *a3, long long a4, _QWORD *a5)
{
long long v6; // r15
long long v7; // r12
long long v8; // r14
long long v9; // r15
long long v10; // rax
bool v11; // cl
long long v12; // rax
long long v13; // r15
long long v14; // rax
bool v15; // cl
long long v16; // rax
long long v17; // rax
char v18; // bp
std::ostream *v19; // rax
long long v20; // rax
char *v21; // rsi
long long v22; // rax
std::ostream *v23; // rax
long long v24; // rax
char v26; // [rsp+4h] [rbp-44h] BYREF
char v27; // [rsp+5h] [rbp-43h] BYREF
char v28; // [rsp+6h] [rbp-42h] BYREF
char v29; // [rsp+7h] [rbp-41h] BYREF
long long v30; // [rsp+8h] [rbp-40h]
char *v31; // [rsp+10h] [rbp-38h]
v6 = a4;
v31 = a3;
v7 = a2[1];
v8 = a5[1];
if ( (unsigned long long)(v8 + v7) > 0x27 )
goto LABEL_7;
v30 = a4;
if ( v7 )
{
v9 = *a2;
v10 = memchr(*a2, 10LL, v7);
v11 = v10 != 0;
v12 = v10 - v9;
v6 = v30;
if ( v12 != -1 && v11 )
goto LABEL_7;
}
if ( v8 && (v13 = *a5, v14 = memchr(*a5, 10LL, v8), v15 = v14 != 0, v16 = v14 - v13, v6 = v30, v16 != -1 && v15) )
{
LABEL_7:
v22 = std::__ostream_insert<char,std::char_traits<char>>(a1, *a2, v7);
v18 = 10;
v28 = 10;
v23 = (std::ostream *)std::__ostream_insert<char,std::char_traits<char>>(v22, &v28, 1LL);
v20 = std::ostream::write(v23, v31, v6);
v21 = &v29;
}
else
{
v17 = std::__ostream_insert<char,std::char_traits<char>>(a1, *a2, v7);
v18 = 32;
v26 = 32;
v19 = (std::ostream *)std::__ostream_insert<char,std::char_traits<char>>(v17, &v26, 1LL);
v20 = std::ostream::write(v19, v31, v6);
v21 = &v27;
}
*v21 = v18;
v24 = std::__ostream_insert<char,std::char_traits<char>>(v20, v21, 1LL);
return std::__ostream_insert<char,std::char_traits<char>>(v24, *a5, a5[1]);
}
| formatReconstructedExpression:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,R8
MOV R15,RCX
MOV qword ptr [RSP + 0x10],RDX
MOV RBP,RSI
MOV R13,RDI
MOV R12,qword ptr [RSI + 0x8]
MOV R14,qword ptr [R8 + 0x8]
LEA RAX,[R14 + R12*0x1]
CMP RAX,0x27
JA 0x0015bfad
TEST R12,R12
MOV qword ptr [RSP + 0x8],R15
JZ 0x0015bf3e
MOV R15,qword ptr [RBP]
MOV RDI,R15
MOV ESI,0xa
MOV RDX,R12
CALL 0x00117500
TEST RAX,RAX
SETNZ CL
SUB RAX,R15
MOV R15,qword ptr [RSP + 0x8]
CMP RAX,-0x1
SETNZ AL
TEST CL,AL
JNZ 0x0015bfad
LAB_0015bf3e:
TEST R14,R14
JZ 0x0015bf6f
MOV R15,qword ptr [RBX]
MOV RDI,R15
MOV ESI,0xa
MOV RDX,R14
CALL 0x00117500
TEST RAX,RAX
SETNZ CL
SUB RAX,R15
MOV R15,qword ptr [RSP + 0x8]
CMP RAX,-0x1
SETNZ AL
TEST CL,AL
JNZ 0x0015bfad
LAB_0015bf6f:
MOV RSI,qword ptr [RBP]
MOV RDI,R13
MOV RDX,R12
CALL 0x00117be0
MOV BPL,0x20
LEA RSI,[RSP + 0x4]
MOV byte ptr [RSI],BPL
MOV EDX,0x1
MOV RDI,RAX
CALL 0x00117be0
MOV RDI,RAX
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,R15
CALL 0x00117580
LEA RSI,[RSP + 0x5]
JMP 0x0015bfe9
LAB_0015bfad:
MOV RSI,qword ptr [RBP]
MOV RDI,R13
MOV RDX,R12
CALL 0x00117be0
MOV BPL,0xa
LEA RSI,[RSP + 0x6]
MOV byte ptr [RSI],BPL
MOV EDX,0x1
MOV RDI,RAX
CALL 0x00117be0
MOV RDI,RAX
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,R15
CALL 0x00117580
LEA RSI,[RSP + 0x7]
LAB_0015bfe9:
MOV byte ptr [RSI],BPL
MOV EDX,0x1
MOV RDI,RAX
CALL 0x00117be0
MOV RSI,qword ptr [RBX]
MOV RDX,qword ptr [RBX + 0x8]
MOV RDI,RAX
CALL 0x00117be0
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* Catch::formatReconstructedExpression(std::ostream&, std::__cxx11::string const&,
Catch::StringRef, std::__cxx11::string const&) */
void __thiscall
Catch::formatReconstructedExpression
(Catch *this,int8 *param_1,long param_2,int8 param_4,int8 *param_5)
{
size_t __n;
size_t __n_00;
void *pvVar1;
void *pvVar2;
ostream *poVar3;
char cVar4;
char *pcVar5;
char local_44;
char local_43 [3];
int8 local_40;
long local_38;
__n = param_1[1];
__n_00 = param_5[1];
local_38 = param_2;
if (__n_00 + __n < 0x28) {
local_40 = param_4;
if (__n != 0) {
pvVar1 = (void *)*param_1;
pvVar2 = memchr(pvVar1,10,__n);
if (pvVar2 != (void *)0x0 && (long)pvVar2 - (long)pvVar1 != -1) goto LAB_0015bfad;
}
if (__n_00 != 0) {
pvVar1 = (void *)*param_5;
pvVar2 = memchr(pvVar1,10,__n_00);
if (pvVar2 != (void *)0x0 && (long)pvVar2 - (long)pvVar1 != -1) goto LAB_0015bfad;
}
poVar3 = std::__ostream_insert<char,std::char_traits<char>>
((ostream *)this,(char *)*param_1,__n);
cVar4 = ' ';
local_44 = ' ';
poVar3 = std::__ostream_insert<char,std::char_traits<char>>(poVar3,&local_44,1);
poVar3 = (ostream *)std::ostream::write((char *)poVar3,local_38);
pcVar5 = local_43;
}
else {
LAB_0015bfad:
poVar3 = std::__ostream_insert<char,std::char_traits<char>>
((ostream *)this,(char *)*param_1,__n);
cVar4 = '\n';
local_43[1] = 10;
poVar3 = std::__ostream_insert<char,std::char_traits<char>>(poVar3,local_43 + 1,1);
poVar3 = (ostream *)std::ostream::write((char *)poVar3,local_38);
pcVar5 = local_43 + 2;
}
*pcVar5 = cVar4;
poVar3 = std::__ostream_insert<char,std::char_traits<char>>(poVar3,pcVar5,1);
std::__ostream_insert<char,std::char_traits<char>>(poVar3,(char *)*param_5,param_5[1]);
return;
}
| |
41,275 | ma_write_dynamic_record | eloqsql/storage/maria/ma_dynrec.c | my_bool _ma_write_dynamic_record(MARIA_HA *info, const uchar *record)
{
ulong reclength= _ma_rec_pack(info,info->rec_buff + MARIA_REC_BUFF_OFFSET,
record);
if (!reclength)
return 1;
return (write_dynamic_record(info,info->rec_buff + MARIA_REC_BUFF_OFFSET,
reclength));
} | O0 | c | ma_write_dynamic_record:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x3a0(%rax), %rsi
addq $0x18, %rsi
movq -0x18(%rbp), %rdx
callq 0x3ba70
movl %eax, %eax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3ba3f
movb $0x1, -0x1(%rbp)
jmp 0x3ba5e
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x3a0(%rax), %rsi
addq $0x18, %rsi
movq -0x20(%rbp), %rdx
callq 0x3c060
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ma_write_dynamic_record:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rdi, [rbp+var_10]
mov rax, [rbp+var_10]
mov rsi, [rax+3A0h]
add rsi, 18h
mov rdx, [rbp+var_18]
call _ma_rec_pack
mov eax, eax
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jnz short loc_3BA3F
mov [rbp+var_1], 1
jmp short loc_3BA5E
loc_3BA3F:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_10]
mov rsi, [rax+3A0h]
add rsi, 18h
mov rdx, [rbp+var_20]
call write_dynamic_record
mov [rbp+var_1], al
loc_3BA5E:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char ma_write_dynamic_record(long long a1, long long a2)
{
unsigned int v2; // eax
v2 = ma_rec_pack(a1, *(_QWORD *)(a1 + 928) + 24LL, a2);
if ( v2 )
return write_dynamic_record(a1, *(_QWORD *)(a1 + 928) + 24LL, v2);
else
return 1;
}
| _ma_write_dynamic_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x3a0]
ADD RSI,0x18
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x0013ba70
MOV EAX,EAX
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x0013ba3f
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0013ba5e
LAB_0013ba3f:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x3a0]
ADD RSI,0x18
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0013c060
MOV byte ptr [RBP + -0x1],AL
LAB_0013ba5e:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 _ma_write_dynamic_record(long param_1,int8 param_2)
{
int iVar1;
int1 local_9;
iVar1 = _ma_rec_pack(param_1,*(long *)(param_1 + 0x3a0) + 0x18,param_2);
if (iVar1 == 0) {
local_9 = 1;
}
else {
local_9 = write_dynamic_record(param_1,*(long *)(param_1 + 0x3a0) + 0x18,iVar1);
}
return local_9;
}
| |
41,276 | ma_write_dynamic_record | eloqsql/storage/maria/ma_dynrec.c | my_bool _ma_write_dynamic_record(MARIA_HA *info, const uchar *record)
{
ulong reclength= _ma_rec_pack(info,info->rec_buff + MARIA_REC_BUFF_OFFSET,
record);
if (!reclength)
return 1;
return (write_dynamic_record(info,info->rec_buff + MARIA_REC_BUFF_OFFSET,
reclength));
} | O3 | c | ma_write_dynamic_record:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x3a0(%rdi), %rsi
addq $0x18, %rsi
callq 0x3c4c9
testl %eax, %eax
je 0x3c4c0
movl %eax, %edx
movq 0x3a0(%rbx), %rsi
addq $0x18, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3c831
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| _ma_write_dynamic_record:
push rbp
mov rbp, rsp
push rbx
push rax
mov rdx, rsi
mov rbx, rdi
mov rsi, [rdi+3A0h]
add rsi, 18h
call _ma_rec_pack
test eax, eax
jz short loc_3C4C0
mov edx, eax
mov rsi, [rbx+3A0h]
add rsi, 18h
mov rdi, rbx
add rsp, 8
pop rbx
pop rbp
jmp write_dynamic_record
loc_3C4C0:
mov al, 1
add rsp, 8
pop rbx
pop rbp
retn
| int ma_write_dynamic_record(long long a1, long long a2)
{
unsigned int v2; // eax
v2 = ma_rec_pack(a1, *(_QWORD *)(a1 + 928) + 24LL, a2);
if ( v2 )
return write_dynamic_record(a1, *(_QWORD *)(a1 + 928) + 24LL, v2);
else
return 1;
}
| _ma_write_dynamic_record:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RDX,RSI
MOV RBX,RDI
MOV RSI,qword ptr [RDI + 0x3a0]
ADD RSI,0x18
CALL 0x0013c4c9
TEST EAX,EAX
JZ 0x0013c4c0
MOV EDX,EAX
MOV RSI,qword ptr [RBX + 0x3a0]
ADD RSI,0x18
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x0013c831
LAB_0013c4c0:
MOV AL,0x1
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int4 _ma_write_dynamic_record(long param_1,int8 param_2)
{
int iVar1;
int4 uVar2;
iVar1 = _ma_rec_pack(param_1,*(long *)(param_1 + 0x3a0) + 0x18,param_2);
if (iVar1 != 0) {
uVar2 = write_dynamic_record(param_1,*(long *)(param_1 + 0x3a0) + 0x18,iVar1);
return uVar2;
}
return 1;
}
| |
41,277 | ms3_put | eloqsql/storage/maria/libmarias3/src/marias3.c | uint8_t ms3_put(ms3_st *ms3, const char *bucket, const char *key,
const uint8_t *data, size_t length)
{
uint8_t res;
if (!ms3 || !bucket || !key || !data)
{
return MS3_ERR_PARAMETER;
}
if (length == 0)
{
return MS3_ERR_NO_DATA;
}
// mhash can't hash more than 4GB it seems
if (length > UINT32_MAX)
{
return MS3_ERR_TOO_BIG;
}
res = execute_request(ms3, MS3_CMD_PUT, bucket, key, NULL, NULL, NULL, data,
length, NULL,
NULL);
return res;
} | O3 | c | ms3_put:
movq %rdx, %r9
movq %rsi, %rdx
movq %rsi, %xmm0
movq %rdi, %xmm1
punpcklqdq %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movq %rcx, %xmm0
movq %r9, %xmm2
punpcklqdq %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
pxor %xmm0, %xmm0
pcmpeqd %xmm0, %xmm2
pcmpeqd %xmm0, %xmm1
movdqa %xmm1, %xmm0
shufps $0xdd, %xmm2, %xmm0 # xmm0 = xmm0[1,3],xmm2[1,3]
shufps $0x88, %xmm2, %xmm1 # xmm1 = xmm1[0,2],xmm2[0,2]
andps %xmm0, %xmm1
movmskps %xmm1, %esi
movb $0x1, %al
testl %esi, %esi
je 0x313df
retq
testq %r8, %r8
je 0x3142a
movq %r8, %rax
shrq $0x20, %rax
movb $0xb, %al
jne 0x313de
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq $0x0, (%rsp)
movl $0x2, %esi
movq %r9, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x31818
addq $0x30, %rsp
popq %rbp
retq
movb $0x2, %al
retq
| ms3_put:
mov r9, rdx
mov rdx, rsi
movq xmm0, rsi
movq xmm1, rdi
punpcklqdq xmm1, xmm0
movq xmm0, rcx
movq xmm2, r9
punpcklqdq xmm2, xmm0
pxor xmm0, xmm0
pcmpeqd xmm2, xmm0
pcmpeqd xmm1, xmm0
movdqa xmm0, xmm1
shufps xmm0, xmm2, 0DDh
shufps xmm1, xmm2, 88h
andps xmm1, xmm0
movmskps esi, xmm1
mov al, 1
test esi, esi
jz short loc_313DF
locret_313DE:
retn
loc_313DF:
test r8, r8
jz short loc_3142A
mov rax, r8
shr rax, 20h
mov al, 0Bh
jnz short locret_313DE
push rbp
mov rbp, rsp
sub rsp, 30h
xorps xmm0, xmm0
movups [rsp+38h+var_20], xmm0
mov [rsp+38h+var_28], r8
mov [rsp+38h+var_30], rcx
mov [rsp+38h+var_38], 0
mov esi, 2
mov rcx, r9
xor r8d, r8d
xor r9d, r9d
call execute_request
add rsp, 30h
pop rbp
retn
loc_3142A:
mov al, 2
retn
| char ms3_put(unsigned long long a1, unsigned long long a2, unsigned long long a3, long long a4, unsigned long long a5)
{
__m128 v5; // xmm2
__m128 v6; // xmm1
char result; // al
v5 = (__m128)_mm_cmpeq_epi32(_mm_unpacklo_epi64((__m128i)a3, (__m128i)(unsigned long long)a4), (__m128i)0LL);
v6 = (__m128)_mm_cmpeq_epi32(_mm_unpacklo_epi64((__m128i)a1, (__m128i)a2), (__m128i)0LL);
result = 1;
if ( !_mm_movemask_ps(_mm_and_ps(_mm_shuffle_ps(v6, v5, 136), _mm_shuffle_ps(v6, v5, 221))) )
{
if ( a5 )
{
result = 11;
if ( !HIDWORD(a5) )
return execute_request(a1, 2, a2, a3, 0, 0, 0LL, a4, a5, 0LL, 0LL);
}
else
{
return 2;
}
}
return result;
}
| ms3_put:
MOV R9,RDX
MOV RDX,RSI
MOVQ XMM0,RSI
MOVQ XMM1,RDI
PUNPCKLQDQ XMM1,XMM0
MOVQ XMM0,RCX
MOVQ XMM2,R9
PUNPCKLQDQ XMM2,XMM0
PXOR XMM0,XMM0
PCMPEQD XMM2,XMM0
PCMPEQD XMM1,XMM0
MOVDQA XMM0,XMM1
SHUFPS XMM0,XMM2,0xdd
SHUFPS XMM1,XMM2,0x88
ANDPS XMM1,XMM0
MOVMSKPS ESI,XMM1
MOV AL,0x1
TEST ESI,ESI
JZ 0x001313df
LAB_001313de:
RET
LAB_001313df:
TEST R8,R8
JZ 0x0013142a
MOV RAX,R8
SHR RAX,0x20
MOV AL,0xb
JNZ 0x001313de
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP + 0x18],XMM0
MOV qword ptr [RSP + 0x10],R8
MOV qword ptr [RSP + 0x8],RCX
MOV qword ptr [RSP],0x0
MOV ESI,0x2
MOV RCX,R9
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00131818
ADD RSP,0x30
POP RBP
RET
LAB_0013142a:
MOV AL,0x2
RET
|
int8
ms3_put(int8 param_1,int8 param_2,int8 param_3,int8 param_4,ulong param_5)
{
int8 uVar1;
int iVar2;
int1 auVar3 [16];
auVar3._0_4_ = -(uint)((int)((ulong)param_1 >> 0x20) == 0 && (int)param_1 == 0);
auVar3._4_4_ = -(uint)((int)param_2 == 0 && (int)((ulong)param_2 >> 0x20) == 0);
auVar3._8_4_ = -(uint)((int)((ulong)param_3 >> 0x20) == 0 && (int)param_3 == 0);
auVar3._12_4_ = -(uint)((int)param_4 == 0 && (int)((ulong)param_4 >> 0x20) == 0);
iVar2 = movmskps((int)param_2,auVar3);
uVar1 = 1;
if (iVar2 == 0) {
if (param_5 == 0) {
return 2;
}
uVar1 = 0xb;
if (param_5 >> 0x20 == 0) {
uVar1 = execute_request(param_1,2,param_2,param_3,0,0,0,param_4,param_5,0,0);
return uVar1;
}
}
return uVar1;
}
| |
41,278 | ma_alloc_root | eloqsql/libmariadb/libmariadb/ma_alloc.c | void * ma_alloc_root(MA_MEM_ROOT *mem_root, size_t Size)
{
#if defined(HAVE_purify) && defined(EXTRA_DEBUG)
reg1 MA_USED_MEM *next;
Size+=ALIGN_SIZE(sizeof(MA_USED_MEM));
if (!(next = (MA_USED_MEM*) malloc(Size)))
{
if (mem_root->error_handler)
(*mem_root->error_handler)();
return((void *) 0); /* purecov: inspected */
}
next->next=mem_root->used;
mem_root->used=next;
return (void *) (((char*) next)+ALIGN_SIZE(sizeof(MA_USED_MEM)));
#else
size_t get_size;
void * point;
reg1 MA_USED_MEM *next= 0;
reg2 MA_USED_MEM **prev;
Size= ALIGN_SIZE(Size);
if ((*(prev= &mem_root->free)))
{
if ((*prev)->left < Size &&
mem_root->first_block_usage++ >= 16 &&
(*prev)->left < 4096)
{
next= *prev;
*prev= next->next;
next->next= mem_root->used;
mem_root->used= next;
mem_root->first_block_usage= 0;
}
for (next= *prev; next && next->left < Size; next= next->next)
prev= &next->next;
}
if (! next)
{ /* Time to alloc new block */
get_size= MAX(Size+ALIGN_SIZE(sizeof(MA_USED_MEM)),
(mem_root->block_size & ~1) * (mem_root->block_num >> 2));
if (!(next = (MA_USED_MEM*) malloc(get_size)))
{
if (mem_root->error_handler)
(*mem_root->error_handler)();
return((void *) 0); /* purecov: inspected */
}
mem_root->block_num++;
next->next= *prev;
next->size= get_size;
next->left= get_size-ALIGN_SIZE(sizeof(MA_USED_MEM));
*prev=next;
}
point= (void *) ((char*) next+ (next->size-next->left));
if ((next->left-= Size) < mem_root->min_malloc)
{ /* Full block */
*prev=next->next; /* Remove block from list */
next->next=mem_root->used;
mem_root->used=next;
mem_root->first_block_usage= 0;
}
return(point);
#endif
} | O3 | c | ma_alloc_root:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x7, %r14
andq $-0x8, %r14
movq (%rdi), %rax
movq %rdi, %r12
testq %rax, %rax
je 0x1db9d
cmpq %r14, 0x8(%rax)
jae 0x1db84
movl 0x2c(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x2c(%rbx)
cmpl $0x10, %ecx
jb 0x1db84
cmpq $0xfff, 0x8(%rax) # imm = 0xFFF
ja 0x1db84
movq (%rax), %rcx
movq %rcx, (%rbx)
movq 0x8(%rbx), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%rbx)
movl $0x0, 0x2c(%rbx)
movq %rbx, %rax
movq %rax, %r12
movq (%rax), %rax
testq %rax, %rax
je 0x1db9d
movq 0x8(%rax), %rdx
cmpq %r14, %rdx
jb 0x1db87
jmp 0x1dbee
leaq 0x18(%r14), %rax
movq 0x20(%rbx), %rcx
andq $-0x2, %rcx
movl 0x28(%rbx), %r13d
movl %r13d, %r15d
shrl $0x2, %r15d
imulq %rcx, %r15
cmpq %r15, %rax
cmovaq %rax, %r15
movq %r15, %rdi
callq 0x13600
testq %rax, %rax
je 0x1dc20
incl %r13d
movl %r13d, 0x28(%rbx)
movq (%r12), %rcx
movq %rcx, (%rax)
movq %r15, 0x10(%rax)
addq $-0x18, %r15
movq %r15, 0x8(%rax)
movq %rax, (%r12)
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
subq %rdx, %rcx
addq %rax, %rcx
subq %r14, %rdx
movq %rdx, 0x8(%rax)
cmpq 0x18(%rbx), %rdx
jae 0x1dc2d
movq (%rax), %rdx
movq %rdx, (%r12)
movq 0x8(%rbx), %rdx
movq %rdx, (%rax)
movq %rax, 0x8(%rbx)
movl $0x0, 0x2c(%rbx)
jmp 0x1dc2d
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x1dc2b
callq *%rax
xorl %ecx, %ecx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ma_alloc_root:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rsi
mov rbx, rdi
add r14, 7
and r14, 0FFFFFFFFFFFFFFF8h
mov rax, [rdi]
mov r12, rdi
test rax, rax
jz short loc_1DB9D
cmp [rax+8], r14
jnb short loc_1DB84
mov ecx, [rbx+2Ch]
lea edx, [rcx+1]
mov [rbx+2Ch], edx
cmp ecx, 10h
jb short loc_1DB84
cmp qword ptr [rax+8], 0FFFh
ja short loc_1DB84
mov rcx, [rax]
mov [rbx], rcx
mov rcx, [rbx+8]
mov [rax], rcx
mov [rbx+8], rax
mov dword ptr [rbx+2Ch], 0
loc_1DB84:
mov rax, rbx
loc_1DB87:
mov r12, rax
mov rax, [rax]
test rax, rax
jz short loc_1DB9D
mov rdx, [rax+8]
cmp rdx, r14
jb short loc_1DB87
jmp short loc_1DBEE
loc_1DB9D:
lea rax, [r14+18h]
mov rcx, [rbx+20h]
and rcx, 0FFFFFFFFFFFFFFFEh
mov r13d, [rbx+28h]
mov r15d, r13d
shr r15d, 2
imul r15, rcx
cmp rax, r15
cmova r15, rax
mov rdi, r15
call _malloc
test rax, rax
jz short loc_1DC20
inc r13d
mov [rbx+28h], r13d
mov rcx, [r12]
mov [rax], rcx
mov [rax+10h], r15
add r15, 0FFFFFFFFFFFFFFE8h
mov [rax+8], r15
mov [r12], rax
mov rdx, [rax+8]
loc_1DBEE:
mov rcx, [rax+10h]
sub rcx, rdx
add rcx, rax
sub rdx, r14
mov [rax+8], rdx
cmp rdx, [rbx+18h]
jnb short loc_1DC2D
mov rdx, [rax]
mov [r12], rdx
mov rdx, [rbx+8]
mov [rax], rdx
mov [rbx+8], rax
mov dword ptr [rbx+2Ch], 0
jmp short loc_1DC2D
loc_1DC20:
mov rax, [rbx+30h]
test rax, rax
jz short loc_1DC2B
call rax
loc_1DC2B:
xor ecx, ecx
loc_1DC2D:
mov rax, rcx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| char * ma_alloc_root(long long a1, long long a2)
{
unsigned long long v2; // r14
_QWORD *v3; // rax
_QWORD *v4; // r12
unsigned int v5; // ecx
_QWORD *v6; // rax
unsigned long long v7; // rdx
unsigned int v8; // r13d
unsigned long long v9; // r15
char *v10; // rcx
unsigned long long v11; // rdx
void ( *v12)(unsigned long long); // rax
v2 = (a2 + 7) & 0xFFFFFFFFFFFFFFF8LL;
v3 = *(_QWORD **)a1;
v4 = (_QWORD *)a1;
if ( *(_QWORD *)a1 )
{
if ( v3[1] < v2 )
{
v5 = *(_DWORD *)(a1 + 44);
*(_DWORD *)(a1 + 44) = v5 + 1;
if ( v5 >= 0x10 && v3[1] <= 0xFFFuLL )
{
*(_QWORD *)a1 = *v3;
*v3 = *(_QWORD *)(a1 + 8);
*(_QWORD *)(a1 + 8) = v3;
*(_DWORD *)(a1 + 44) = 0;
}
}
v6 = (_QWORD *)a1;
while ( 1 )
{
v4 = v6;
v6 = (_QWORD *)*v6;
if ( !v6 )
break;
v7 = v6[1];
if ( v7 >= v2 )
goto LABEL_14;
}
}
v8 = *(_DWORD *)(a1 + 40);
v9 = (*(_QWORD *)(a1 + 32) & 0xFFFFFFFFFFFFFFFELL) * (v8 >> 2);
if ( v2 + 24 > v9 )
v9 = v2 + 24;
v6 = (_QWORD *)malloc(v9);
if ( v6 )
{
*(_DWORD *)(a1 + 40) = v8 + 1;
*v6 = *v4;
v6[2] = v9;
v6[1] = v9 - 24;
*v4 = v6;
v7 = v6[1];
LABEL_14:
v10 = (char *)v6 + v6[2] - v7;
v11 = v7 - v2;
v6[1] = v11;
if ( v11 < *(_QWORD *)(a1 + 24) )
{
*v4 = *v6;
*v6 = *(_QWORD *)(a1 + 8);
*(_QWORD *)(a1 + 8) = v6;
*(_DWORD *)(a1 + 44) = 0;
}
}
else
{
v12 = *(void ( **)(unsigned long long))(a1 + 48);
if ( v12 )
v12(v9);
return 0LL;
}
return v10;
}
| ma_alloc_root:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
ADD R14,0x7
AND R14,-0x8
MOV RAX,qword ptr [RDI]
MOV R12,RDI
TEST RAX,RAX
JZ 0x0011db9d
CMP qword ptr [RAX + 0x8],R14
JNC 0x0011db84
MOV ECX,dword ptr [RBX + 0x2c]
LEA EDX,[RCX + 0x1]
MOV dword ptr [RBX + 0x2c],EDX
CMP ECX,0x10
JC 0x0011db84
CMP qword ptr [RAX + 0x8],0xfff
JA 0x0011db84
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBX],RCX
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RAX],RCX
MOV qword ptr [RBX + 0x8],RAX
MOV dword ptr [RBX + 0x2c],0x0
LAB_0011db84:
MOV RAX,RBX
LAB_0011db87:
MOV R12,RAX
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x0011db9d
MOV RDX,qword ptr [RAX + 0x8]
CMP RDX,R14
JC 0x0011db87
JMP 0x0011dbee
LAB_0011db9d:
LEA RAX,[R14 + 0x18]
MOV RCX,qword ptr [RBX + 0x20]
AND RCX,-0x2
MOV R13D,dword ptr [RBX + 0x28]
MOV R15D,R13D
SHR R15D,0x2
IMUL R15,RCX
CMP RAX,R15
CMOVA R15,RAX
MOV RDI,R15
CALL 0x00113600
TEST RAX,RAX
JZ 0x0011dc20
INC R13D
MOV dword ptr [RBX + 0x28],R13D
MOV RCX,qword ptr [R12]
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x10],R15
ADD R15,-0x18
MOV qword ptr [RAX + 0x8],R15
MOV qword ptr [R12],RAX
MOV RDX,qword ptr [RAX + 0x8]
LAB_0011dbee:
MOV RCX,qword ptr [RAX + 0x10]
SUB RCX,RDX
ADD RCX,RAX
SUB RDX,R14
MOV qword ptr [RAX + 0x8],RDX
CMP RDX,qword ptr [RBX + 0x18]
JNC 0x0011dc2d
MOV RDX,qword ptr [RAX]
MOV qword ptr [R12],RDX
MOV RDX,qword ptr [RBX + 0x8]
MOV qword ptr [RAX],RDX
MOV qword ptr [RBX + 0x8],RAX
MOV dword ptr [RBX + 0x2c],0x0
JMP 0x0011dc2d
LAB_0011dc20:
MOV RAX,qword ptr [RBX + 0x30]
TEST RAX,RAX
JZ 0x0011dc2b
CALL RAX
LAB_0011dc2b:
XOR ECX,ECX
LAB_0011dc2d:
MOV RAX,RCX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long ma_alloc_root(long *param_1,long param_2)
{
uint uVar1;
long *plVar2;
long lVar3;
long *plVar4;
long *plVar5;
ulong uVar6;
ulong uVar7;
uVar6 = param_2 + 7U & 0xfffffffffffffff8;
plVar2 = (long *)*param_1;
plVar5 = param_1;
if (plVar2 == (long *)0x0) {
LAB_0011db9d:
uVar1 = *(uint *)(param_1 + 5);
uVar7 = (ulong)(uVar1 >> 2) * (param_1[4] & 0xfffffffffffffffeU);
if (uVar7 < uVar6 + 0x18) {
uVar7 = uVar6 + 0x18;
}
plVar4 = (long *)malloc(uVar7);
if (plVar4 == (long *)0x0) {
if ((code *)param_1[6] != (code *)0x0) {
(*(code *)param_1[6])();
}
return 0;
}
*(uint *)(param_1 + 5) = uVar1 + 1;
*plVar4 = *plVar5;
plVar4[2] = uVar7;
plVar4[1] = uVar7 - 0x18;
*plVar5 = (long)plVar4;
uVar7 = plVar4[1];
}
else {
plVar4 = param_1;
if ((((ulong)plVar2[1] < uVar6) &&
(uVar1 = *(uint *)((long)param_1 + 0x2c), *(uint *)((long)param_1 + 0x2c) = uVar1 + 1,
0xf < uVar1)) && ((ulong)plVar2[1] < 0x1000)) {
*param_1 = *plVar2;
*plVar2 = param_1[1];
param_1[1] = (long)plVar2;
*(int4 *)((long)param_1 + 0x2c) = 0;
}
do {
plVar5 = plVar4;
plVar4 = (long *)*plVar5;
if (plVar4 == (long *)0x0) goto LAB_0011db9d;
uVar7 = plVar4[1];
} while (uVar7 < uVar6);
}
lVar3 = plVar4[2];
plVar4[1] = uVar7 - uVar6;
if (uVar7 - uVar6 < (ulong)param_1[3]) {
*plVar5 = *plVar4;
*plVar4 = param_1[1];
param_1[1] = (long)plVar4;
*(int4 *)((long)param_1 + 0x2c) = 0;
}
return (lVar3 - uVar7) + (long)plVar4;
}
| |
41,279 | translog_page_next | eloqsql/storage/maria/ma_loghandler.c | static my_bool translog_page_next(TRANSLOG_ADDRESS *horizon,
struct st_buffer_cursor *cursor,
struct st_translog_buffer **prev_buffer)
{
struct st_translog_buffer *buffer= cursor->buffer;
DBUG_ENTER("translog_page_next");
*prev_buffer= NULL;
if ((cursor->ptr + TRANSLOG_PAGE_SIZE >
cursor->buffer->buffer + TRANSLOG_WRITE_BUFFER) ||
(LSN_OFFSET(*horizon) >
log_descriptor.log_file_max_size - TRANSLOG_PAGE_SIZE))
{
DBUG_PRINT("info", ("Switch to next buffer Buffer Size: %lu (%lu) => %d "
"File size: %lu max: %lu => %d",
(ulong) cursor->buffer->size,
(ulong) (cursor->ptr - cursor->buffer->buffer),
(cursor->ptr + TRANSLOG_PAGE_SIZE >
cursor->buffer->buffer + TRANSLOG_WRITE_BUFFER),
(ulong) LSN_OFFSET(*horizon),
(ulong) log_descriptor.log_file_max_size,
(LSN_OFFSET(*horizon) >
(log_descriptor.log_file_max_size -
TRANSLOG_PAGE_SIZE))));
if (translog_buffer_next(horizon, cursor,
LSN_OFFSET(*horizon) >
(log_descriptor.log_file_max_size -
TRANSLOG_PAGE_SIZE)))
DBUG_RETURN(1);
*prev_buffer= buffer;
DBUG_PRINT("info", ("Buffer #%u (%p): have to be flushed",
(uint) buffer->buffer_no, buffer));
}
else
{
DBUG_PRINT("info", ("Use the same buffer #%u (%p): "
"Buffer Size: %lu (%lu)",
(uint) buffer->buffer_no,
buffer,
(ulong) cursor->buffer->size,
(ulong) (cursor->ptr - cursor->buffer->buffer)));
translog_finish_page(horizon, cursor);
translog_new_page_header(horizon, cursor);
}
DBUG_RETURN(0);
} | O0 | c | translog_page_next:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x2000, %rax # imm = 0x2000
movq -0x18(%rbp), %rcx
movq 0x28(%rcx), %rcx
addq $0x100000, %rcx # imm = 0x100000
cmpq %rcx, %rax
ja 0x59ad1
movq -0x10(%rbp), %rcx
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq (%rcx), %rax
movl 0x41f90c(%rip), %ecx # 0x4793d0
subl $0x2000, %ecx # imm = 0x2000
movl %ecx, %ecx
cmpq %rcx, %rax
jbe 0x59b2a
jmp 0x59ad3
jmp 0x59ad5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rcx
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq (%rcx), %rax
movl 0x41f8dc(%rip), %ecx # 0x4793d0
subl $0x2000, %ecx # imm = 0x2000
movl %ecx, %ecx
cmpq %rcx, %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movsbl %al, %edx
callq 0x57db0
cmpb $0x0, %al
je 0x59b1b
jmp 0x59b15
movb $0x1, -0x1(%rbp)
jmp 0x59b4e
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x59b28
jmp 0x59b48
jmp 0x59b2c
jmp 0x59b2e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x53be0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x52b50
jmp 0x59b4a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| translog_page_next:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_18]
mov rax, [rax+28h]
mov [rbp+var_28], rax
mov rax, [rbp+var_20]
mov qword ptr [rax], 0
mov rax, [rbp+var_18]
mov rax, [rax+20h]
add rax, 2000h
mov rcx, [rbp+var_18]
mov rcx, [rcx+28h]
add rcx, 100000h
cmp rax, rcx
ja short loc_59AD1
mov rcx, [rbp+var_10]
mov rax, 0FFFFFFFFh
and rax, [rcx]
mov ecx, cs:dword_4793D0
sub ecx, 2000h
mov ecx, ecx
cmp rax, rcx
jbe short loc_59B2A
loc_59AD1:
jmp short $+2
loc_59AD3:
jmp short $+2
loc_59AD5:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rcx, [rbp+var_10]
mov rax, 0FFFFFFFFh
and rax, [rcx]
mov ecx, cs:dword_4793D0
sub ecx, 2000h
mov ecx, ecx
cmp rax, rcx
setnbe al
and al, 1
movzx eax, al
movsx edx, al
call translog_buffer_next
cmp al, 0
jz short loc_59B1B
jmp short $+2
loc_59B15:
mov [rbp+var_1], 1
jmp short loc_59B4E
loc_59B1B:
mov rcx, [rbp+var_28]
mov rax, [rbp+var_20]
mov [rax], rcx
jmp short $+2
loc_59B28:
jmp short loc_59B48
loc_59B2A:
jmp short $+2
loc_59B2C:
jmp short $+2
loc_59B2E:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call translog_finish_page
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call translog_new_page_header
loc_59B48:
jmp short $+2
loc_59B4A:
mov [rbp+var_1], 0
loc_59B4E:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char translog_page_next(long long *a1, long long a2, _QWORD *a3)
{
long long v4; // [rsp+8h] [rbp-28h]
v4 = *(_QWORD *)(a2 + 40);
*a3 = 0LL;
if ( *(_QWORD *)(a2 + 32) + 0x2000LL <= (unsigned long long)(*(_QWORD *)(a2 + 40) + 0x100000LL)
&& (unsigned int)*a1 <= (unsigned long long)(unsigned int)(dword_4793D0 - 0x2000) )
{
translog_finish_page(a1, a2);
translog_new_page_header(a1, a2);
return 0;
}
if ( !translog_buffer_next(a1, a2, (unsigned int)*a1 > (unsigned long long)(unsigned int)(dword_4793D0 - 0x2000)) )
{
*a3 = v4;
return 0;
}
return 1;
}
| translog_page_next:
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 RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x20]
ADD RAX,0x2000
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX + 0x28]
ADD RCX,0x100000
CMP RAX,RCX
JA 0x00159ad1
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,0xffffffff
AND RAX,qword ptr [RCX]
MOV ECX,dword ptr [0x005793d0]
SUB ECX,0x2000
MOV ECX,ECX
CMP RAX,RCX
JBE 0x00159b2a
LAB_00159ad1:
JMP 0x00159ad3
LAB_00159ad3:
JMP 0x00159ad5
LAB_00159ad5:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,0xffffffff
AND RAX,qword ptr [RCX]
MOV ECX,dword ptr [0x005793d0]
SUB ECX,0x2000
MOV ECX,ECX
CMP RAX,RCX
SETA AL
AND AL,0x1
MOVZX EAX,AL
MOVSX EDX,AL
CALL 0x00157db0
CMP AL,0x0
JZ 0x00159b1b
JMP 0x00159b15
LAB_00159b15:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00159b4e
LAB_00159b1b:
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
JMP 0x00159b28
LAB_00159b28:
JMP 0x00159b48
LAB_00159b2a:
JMP 0x00159b2c
LAB_00159b2c:
JMP 0x00159b2e
LAB_00159b2e:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00153be0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00152b50
LAB_00159b48:
JMP 0x00159b4a
LAB_00159b4a:
MOV byte ptr [RBP + -0x1],0x0
LAB_00159b4e:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 translog_page_next(ulong *param_1,long param_2,int8 *param_3)
{
int8 uVar1;
char cVar2;
uVar1 = *(int8 *)(param_2 + 0x28);
*param_3 = 0;
if ((*(long *)(param_2 + 0x28) + 0x100000U < *(long *)(param_2 + 0x20) + 0x2000U) ||
((ulong)(DAT_005793d0 - 0x2000) < (*param_1 & 0xffffffff))) {
cVar2 = translog_buffer_next
(param_1,param_2,(ulong)(DAT_005793d0 - 0x2000) < (*param_1 & 0xffffffff));
if (cVar2 != '\0') {
return 1;
}
*param_3 = uVar1;
}
else {
translog_finish_page(param_1,param_2);
translog_new_page_header(param_1,param_2);
}
return 0;
}
| |
41,280 | resize_shape_hash | bluesky950520[P]quickjs/quickjs.c | static int resize_shape_hash(JSRuntime *rt, int new_shape_hash_bits)
{
int new_shape_hash_size, i;
uint32_t h;
JSShape **new_shape_hash, *sh, *sh_next;
new_shape_hash_size = 1 << new_shape_hash_bits;
new_shape_hash = js_mallocz_rt(rt, sizeof(rt->shape_hash[0]) *
new_shape_hash_size);
if (!new_shape_hash)
return -1;
for(i = 0; i < rt->shape_hash_size; i++) {
for(sh = rt->shape_hash[i]; sh != NULL; sh = sh_next) {
sh_next = sh->shape_hash_next;
h = get_shape_hash(sh->hash, new_shape_hash_bits);
sh->shape_hash_next = new_shape_hash[h];
new_shape_hash[h] = sh;
}
}
js_free_rt(rt, rt->shape_hash);
rt->shape_hash_bits = new_shape_hash_bits;
rt->shape_hash_size = new_shape_hash_size;
rt->shape_hash = new_shape_hash;
return 0;
} | O0 | c | resize_shape_hash:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl 0x24(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x20(%rsp), %rsi
shlq $0x3, %rsi
callq 0x21b60
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x5db29
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x5dc1c
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x188(%rcx), %eax
jge 0x5dbcf
movq 0x28(%rsp), %rax
movq 0x190(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x5dbbd
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movl 0x1c(%rax), %edi
movl 0x24(%rsp), %esi
callq 0x5d890
movl %eax, 0x18(%rsp)
movq 0x10(%rsp), %rax
movl 0x18(%rsp), %ecx
movq (%rax,%rcx,8), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movl 0x18(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x5db60
jmp 0x5dbbf
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x5db31
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x190(%rax), %rsi
callq 0x21960
movl 0x24(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x184(%rax)
movl 0x20(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x188(%rax)
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x190(%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
| resize_shape_hash:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_14], esi
mov ecx, [rsp+38h+var_14]
mov eax, 1
shl eax, cl
mov [rsp+38h+var_18], eax
mov rdi, [rsp+38h+var_10]
movsxd rsi, [rsp+38h+var_18]
shl rsi, 3
call js_mallocz_rt
mov [rsp+38h+var_28], rax
cmp [rsp+38h+var_28], 0
jnz short loc_5DB29
mov [rsp+38h+var_4], 0FFFFFFFFh
jmp loc_5DC1C
loc_5DB29:
mov [rsp+38h+var_1C], 0
loc_5DB31:
mov eax, [rsp+38h+var_1C]
mov rcx, [rsp+38h+var_10]
cmp eax, [rcx+188h]
jge loc_5DBCF
mov rax, [rsp+38h+var_10]
mov rax, [rax+190h]
movsxd rcx, [rsp+38h+var_1C]
mov rax, [rax+rcx*8]
mov [rsp+38h+var_30], rax
loc_5DB60:
cmp [rsp+38h+var_30], 0
jz short loc_5DBBD
mov rax, [rsp+38h+var_30]
mov rax, [rax+30h]
mov [rsp+38h+var_38], rax
mov rax, [rsp+38h+var_30]
mov edi, [rax+1Ch]
mov esi, [rsp+38h+var_14]
call get_shape_hash
mov [rsp+38h+var_20], eax
mov rax, [rsp+38h+var_28]
mov ecx, [rsp+38h+var_20]
mov rcx, [rax+rcx*8]
mov rax, [rsp+38h+var_30]
mov [rax+30h], rcx
mov rdx, [rsp+38h+var_30]
mov rax, [rsp+38h+var_28]
mov ecx, [rsp+38h+var_20]
mov [rax+rcx*8], rdx
mov rax, [rsp+38h+var_38]
mov [rsp+38h+var_30], rax
jmp short loc_5DB60
loc_5DBBD:
jmp short $+2
loc_5DBBF:
mov eax, [rsp+38h+var_1C]
add eax, 1
mov [rsp+38h+var_1C], eax
jmp loc_5DB31
loc_5DBCF:
mov rdi, [rsp+38h+var_10]
mov rax, [rsp+38h+var_10]
mov rsi, [rax+190h]
call js_free_rt
mov ecx, [rsp+38h+var_14]
mov rax, [rsp+38h+var_10]
mov [rax+184h], ecx
mov ecx, [rsp+38h+var_18]
mov rax, [rsp+38h+var_10]
mov [rax+188h], ecx
mov rcx, [rsp+38h+var_28]
mov rax, [rsp+38h+var_10]
mov [rax+190h], rcx
mov [rsp+38h+var_4], 0
loc_5DC1C:
mov eax, [rsp+38h+var_4]
add rsp, 38h
retn
| long long resize_shape_hash(long long a1, int a2)
{
long long v3; // [rsp+0h] [rbp-38h]
long long j; // [rsp+8h] [rbp-30h]
long long v5; // [rsp+10h] [rbp-28h]
unsigned int shape_hash; // [rsp+18h] [rbp-20h]
int i; // [rsp+1Ch] [rbp-1Ch]
v5 = js_mallocz_rt(a1, 8LL * (1 << a2));
if ( v5 )
{
for ( i = 0; i < *(_DWORD *)(a1 + 392); ++i )
{
for ( j = *(_QWORD *)(*(_QWORD *)(a1 + 400) + 8LL * i); j; j = v3 )
{
v3 = *(_QWORD *)(j + 48);
shape_hash = get_shape_hash(*(_DWORD *)(j + 28), a2);
*(_QWORD *)(j + 48) = *(_QWORD *)(v5 + 8LL * shape_hash);
*(_QWORD *)(v5 + 8LL * shape_hash) = j;
}
}
js_free_rt(a1, *(_QWORD *)(a1 + 400));
*(_DWORD *)(a1 + 388) = a2;
*(_DWORD *)(a1 + 392) = 1 << a2;
*(_QWORD *)(a1 + 400) = v5;
return 0;
}
else
{
return (unsigned int)-1;
}
}
| resize_shape_hash:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV dword ptr [RSP + 0x24],ESI
MOV ECX,dword ptr [RSP + 0x24]
MOV EAX,0x1
SHL EAX,CL
MOV dword ptr [RSP + 0x20],EAX
MOV RDI,qword ptr [RSP + 0x28]
MOVSXD RSI,dword ptr [RSP + 0x20]
SHL RSI,0x3
CALL 0x00121b60
MOV qword ptr [RSP + 0x10],RAX
CMP qword ptr [RSP + 0x10],0x0
JNZ 0x0015db29
MOV dword ptr [RSP + 0x34],0xffffffff
JMP 0x0015dc1c
LAB_0015db29:
MOV dword ptr [RSP + 0x1c],0x0
LAB_0015db31:
MOV EAX,dword ptr [RSP + 0x1c]
MOV RCX,qword ptr [RSP + 0x28]
CMP EAX,dword ptr [RCX + 0x188]
JGE 0x0015dbcf
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0x190]
MOVSXD RCX,dword ptr [RSP + 0x1c]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RSP + 0x8],RAX
LAB_0015db60:
CMP qword ptr [RSP + 0x8],0x0
JZ 0x0015dbbd
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV EDI,dword ptr [RAX + 0x1c]
MOV ESI,dword ptr [RSP + 0x24]
CALL 0x0015d890
MOV dword ptr [RSP + 0x18],EAX
MOV RAX,qword ptr [RSP + 0x10]
MOV ECX,dword ptr [RSP + 0x18]
MOV RCX,qword ptr [RAX + RCX*0x8]
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x30],RCX
MOV RDX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x10]
MOV ECX,dword ptr [RSP + 0x18]
MOV qword ptr [RAX + RCX*0x8],RDX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x8],RAX
JMP 0x0015db60
LAB_0015dbbd:
JMP 0x0015dbbf
LAB_0015dbbf:
MOV EAX,dword ptr [RSP + 0x1c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x1c],EAX
JMP 0x0015db31
LAB_0015dbcf:
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RAX + 0x190]
CALL 0x00121960
MOV ECX,dword ptr [RSP + 0x24]
MOV RAX,qword ptr [RSP + 0x28]
MOV dword ptr [RAX + 0x184],ECX
MOV ECX,dword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x28]
MOV dword ptr [RAX + 0x188],ECX
MOV RCX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RAX + 0x190],RCX
MOV dword ptr [RSP + 0x34],0x0
LAB_0015dc1c:
MOV EAX,dword ptr [RSP + 0x34]
ADD RSP,0x38
RET
|
int4 resize_shape_hash(long param_1,int4 param_2)
{
long lVar1;
int iVar2;
uint uVar3;
long lVar4;
int8 local_30;
int4 local_1c;
int4 local_4;
iVar2 = 1 << ((byte)param_2 & 0x1f);
lVar4 = js_mallocz_rt(param_1,(long)iVar2 << 3);
if (lVar4 == 0) {
local_4 = 0xffffffff;
}
else {
for (local_1c = 0; local_1c < *(int *)(param_1 + 0x188); local_1c = local_1c + 1) {
local_30 = *(long *)(*(long *)(param_1 + 400) + (long)local_1c * 8);
while (local_30 != 0) {
lVar1 = *(long *)(local_30 + 0x30);
uVar3 = get_shape_hash(*(int4 *)(local_30 + 0x1c),param_2);
*(int8 *)(local_30 + 0x30) = *(int8 *)(lVar4 + (ulong)uVar3 * 8);
*(long *)(lVar4 + (ulong)uVar3 * 8) = local_30;
local_30 = lVar1;
}
}
js_free_rt(param_1,*(int8 *)(param_1 + 400));
*(int4 *)(param_1 + 0x184) = param_2;
*(int *)(param_1 + 0x188) = iVar2;
*(long *)(param_1 + 400) = lVar4;
local_4 = 0;
}
return local_4;
}
| |
41,281 | nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::basic_json<nlohmann::json_abi_v3_11_3::detail::json_ref<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>>, 0>(nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> const&) | llama.cpp/common/json.hpp | basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {} | O3 | cpp | nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::basic_json<nlohmann::json_abi_v3_11_3::detail::json_ref<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>>, 0>(nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> const&):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x810c8
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x739d2
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x739d2
movq %r14, %rdi
xorl %esi, %esi
callq 0x739d2
movq %r14, %rdi
callq 0x79520
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2INS0_6detail8json_refISD_EETnNSt9enable_ifIXsr6detail11conjunctionINSF_11is_json_refIT_EESt7is_sameINSK_10value_typeESD_EEE5valueEiE4typeELi0EEERKSK_:
push r14
push rbx
sub rsp, 18h
mov rbx, rdi
lea r14, [rsp+28h+var_20]
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15moved_or_copiedEv; nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::moved_or_copied(void)
movups xmm0, xmmword ptr [r14]
movups xmmword ptr [rbx], xmm0
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, rbx
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
add rsp, 18h
pop rbx
pop r14
retn
| long long ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2INS0_6detail8json_refISD_EETnNSt9enable_ifIXsr6detail11conjunctionINSF_11is_json_refIT_EESt7is_sameINSK_10value_typeESD_EEE5valueEiE4typeELi0EEERKSK_(
char *a1,
long long a2)
{
_OWORD v3[2]; // [rsp+8h] [rbp-20h] BYREF
nlohmann::json_abi_v3_11_3::detail::json_ref<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>>::moved_or_copied(
(unsigned __int8 *)v3,
a2);
*(_OWORD *)a1 = v3[0];
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v3);
LOBYTE(v3[0]) = 0;
*((_QWORD *)&v3[0] + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(a1);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v3);
return nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v3);
}
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2INS0_6detail8json_refISD_EETnNSt9enable_ifIXsr6detail11conjunctionINSF_11is_json_refIT_EESt7is_sameINSK_10value_typeESD_EEE5valueEiE4typeELi0EEERKSK_:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
LEA R14,[RSP + 0x8]
MOV RDI,R14
CALL 0x001810c8
MOVUPS XMM0,xmmword ptr [R14]
MOVUPS xmmword ptr [RBX],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x001739d2
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,RBX
MOV ESI,0x1
CALL 0x001739d2
MOV RDI,R14
XOR ESI,ESI
CALL 0x001739d2
MOV RDI,R14
CALL 0x00179520
ADD RSP,0x18
POP RBX
POP R14
RET
|
void _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2INS0_6detail8json_refISD_EETnNSt9enable_ifIXsr6detail11conjunctionINSF_11is_json_refIT_EESt7is_sameINSK_10value_typeESD_EEE5valueEiE4typeELi0EEERKSK_
(int8 *param_1)
{
bool bVar1;
data local_20;
int7 uStack_1f;
int8 uStack_18;
nlohmann::json_abi_v3_11_3::detail::
json_ref<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>>
::moved_or_copied();
*param_1 = CONCAT71(uStack_1f,local_20);
param_1[1] = uStack_18;
bVar1 = SUB81(&local_20,0);
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>
::assert_invariant(bVar1);
local_20 = (data)0x0;
uStack_18 = 0;
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>
::assert_invariant(SUB81(param_1,0));
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>
::assert_invariant(bVar1);
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>
::data::~data(&local_20);
return;
}
| |
41,282 | js_os_seek | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_os_seek(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
int fd, whence;
int64_t pos, ret;
BOOL is_bigint;
if (JS_ToInt32(ctx, &fd, argv[0]))
return JS_EXCEPTION;
is_bigint = JS_IsBigInt(ctx, argv[1]);
if (JS_ToInt64Ext(ctx, &pos, argv[1]))
return JS_EXCEPTION;
if (JS_ToInt32(ctx, &whence, argv[2]))
return JS_EXCEPTION;
ret = lseek(fd, pos, whence);
if (ret == -1)
ret = -errno;
if (is_bigint)
return JS_NewBigInt64(ctx, ret);
else
return JS_NewInt64(ctx, ret);
} | O1 | c | js_os_seek:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rdi, %rbx
movq (%r8), %rdx
movq 0x8(%r8), %rcx
leaq 0xc(%rsp), %rsi
callq 0x26d9c
movl $0x6, %r14d
testl %eax, %eax
jne 0x17d16
movq 0x10(%r15), %rdx
movq 0x18(%r15), %r12
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r12, %rcx
callq 0x26d5c
testl %eax, %eax
jne 0x17d16
movq 0x20(%r15), %rdx
movq 0x28(%r15), %rcx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x26d9c
testl %eax, %eax
je 0x17d2f
xorl %eax, %eax
xorl %r15d, %r15d
movl %eax, %eax
orq %r15, %rax
movq %r14, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl %r12d, %r14d
movl 0xc(%rsp), %edi
movq 0x10(%rsp), %rsi
movl 0x8(%rsp), %edx
callq 0xe320
cmpq $-0x1, %rax
jne 0x17d55
callq 0xe0b0
movslq (%rax), %rax
negq %rax
movabsq $-0x100000000, %r15 # imm = 0xFFFFFFFF00000000
cmpl $-0x9, %r14d
jne 0x17d75
movq %rbx, %rdi
movq %rax, %rsi
callq 0x27762
movq %rdx, %r14
jmp 0x17d97
movslq %eax, %rcx
xorl %edx, %edx
cmpq %rax, %rcx
cvtsi2sd %rax, %xmm0
movl %ecx, %ecx
movq %xmm0, %rax
cmoveq %rcx, %rax
movl $0x7, %r14d
cmoveq %rdx, %r14
andq %rax, %r15
jmp 0x17d1b
| js_os_seek:
push r15
push r14
push r12
push rbx
sub rsp, 18h
mov r15, r8
mov rbx, rdi
mov rdx, [r8]
mov rcx, [r8+8]
lea rsi, [rsp+38h+var_2C]
call JS_ToInt32
mov r14d, 6
test eax, eax
jnz short loc_17D16
mov rdx, [r15+10h]
mov r12, [r15+18h]
lea rsi, [rsp+38h+var_28]
mov rdi, rbx
mov rcx, r12
call JS_ToInt64Ext
test eax, eax
jnz short loc_17D16
mov rdx, [r15+20h]
mov rcx, [r15+28h]
lea rsi, [rsp+38h+var_30]
mov rdi, rbx
call JS_ToInt32
test eax, eax
jz short loc_17D2F
loc_17D16:
xor eax, eax
xor r15d, r15d
loc_17D1B:
mov eax, eax
or rax, r15
mov rdx, r14
add rsp, 18h
pop rbx
pop r12
pop r14
pop r15
retn
loc_17D2F:
mov r14d, r12d
mov edi, [rsp+38h+var_2C]
mov rsi, [rsp+38h+var_28]
mov edx, [rsp+38h+var_30]
call _lseek
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_17D55
call ___errno_location
movsxd rax, dword ptr [rax]
neg rax
loc_17D55:
mov r15, 0FFFFFFFF00000000h
cmp r14d, 0FFFFFFF7h
jnz short loc_17D75
mov rdi, rbx
mov rsi, rax
call JS_NewBigInt64
mov r14, rdx
jmp short loc_17D97
loc_17D75:
movsxd rcx, eax
xor edx, edx
cmp rcx, rax
cvtsi2sd xmm0, rax
mov ecx, ecx
movq rax, xmm0
cmovz rax, rcx
mov r14d, 7
cmovz r14, rdx
loc_17D97:
and r15, rax
jmp loc_17D1B
| unsigned long long js_os_seek(long long a1, long long a2, long long a3, long long a4, _QWORD *a5)
{
long long v7; // r12
double v8; // rax
unsigned long long v9; // r15
long long v11; // rdi
long long v12; // rax
bool v13; // zf
double v14; // rcx
unsigned int v15; // [rsp+8h] [rbp-30h] BYREF
unsigned int v16; // [rsp+Ch] [rbp-2Ch] BYREF
_QWORD v17[5]; // [rsp+10h] [rbp-28h] BYREF
if ( (unsigned int)JS_ToInt32(a1, &v16, *a5, a5[1])
|| (v7 = a5[3], (unsigned int)JS_ToInt64Ext(a1, v17, a5[2], v7))
|| (unsigned int)JS_ToInt32(a1, &v15, a5[4], a5[5]) )
{
LODWORD(v8) = 0;
v9 = 0LL;
}
else
{
v11 = v16;
v12 = lseek(v16, v17[0], v15);
if ( v12 == -1 )
v12 = -(long long)*(int *)__errno_location(v11);
if ( (_DWORD)v7 == -9 )
{
v8 = COERCE_DOUBLE(JS_NewBigInt64(a1, v12));
}
else
{
v13 = (int)v12 == v12;
*(_QWORD *)&v14 = (unsigned int)v12;
v8 = (double)(int)v12;
if ( v13 )
v8 = v14;
}
v9 = *(_QWORD *)&v8 & 0xFFFFFFFF00000000LL;
}
return v9 | LODWORD(v8);
}
| js_os_seek:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15,R8
MOV RBX,RDI
MOV RDX,qword ptr [R8]
MOV RCX,qword ptr [R8 + 0x8]
LEA RSI,[RSP + 0xc]
CALL 0x00126d9c
MOV R14D,0x6
TEST EAX,EAX
JNZ 0x00117d16
MOV RDX,qword ptr [R15 + 0x10]
MOV R12,qword ptr [R15 + 0x18]
LEA RSI,[RSP + 0x10]
MOV RDI,RBX
MOV RCX,R12
CALL 0x00126d5c
TEST EAX,EAX
JNZ 0x00117d16
MOV RDX,qword ptr [R15 + 0x20]
MOV RCX,qword ptr [R15 + 0x28]
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00126d9c
TEST EAX,EAX
JZ 0x00117d2f
LAB_00117d16:
XOR EAX,EAX
XOR R15D,R15D
LAB_00117d1b:
MOV EAX,EAX
OR RAX,R15
MOV RDX,R14
ADD RSP,0x18
POP RBX
POP R12
POP R14
POP R15
RET
LAB_00117d2f:
MOV R14D,R12D
MOV EDI,dword ptr [RSP + 0xc]
MOV RSI,qword ptr [RSP + 0x10]
MOV EDX,dword ptr [RSP + 0x8]
CALL 0x0010e320
CMP RAX,-0x1
JNZ 0x00117d55
CALL 0x0010e0b0
MOVSXD RAX,dword ptr [RAX]
NEG RAX
LAB_00117d55:
MOV R15,-0x100000000
CMP R14D,-0x9
JNZ 0x00117d75
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00127762
MOV R14,RDX
JMP 0x00117d97
LAB_00117d75:
MOVSXD RCX,EAX
XOR EDX,EDX
CMP RCX,RAX
CVTSI2SD XMM0,RAX
MOV ECX,ECX
MOVQ RAX,XMM0
CMOVZ RAX,RCX
MOV R14D,0x7
CMOVZ R14,RDX
LAB_00117d97:
AND R15,RAX
JMP 0x00117d1b
|
int1 [16] js_os_seek(int8 param_1)
{
int8 uVar1;
int1 auVar2 [16];
int iVar3;
ulong uVar4;
int *piVar5;
double dVar6;
int8 *in_R8;
bool bVar7;
int1 auVar8 [16];
int1 auVar9 [16];
int local_30;
int local_2c;
__off_t local_28;
iVar3 = JS_ToInt32(param_1,&local_2c,*in_R8,in_R8[1]);
if (iVar3 == 0) {
uVar1 = in_R8[3];
iVar3 = JS_ToInt64Ext(param_1,&local_28,in_R8[2],uVar1);
if (iVar3 == 0) {
iVar3 = JS_ToInt32(param_1,&local_30,in_R8[4],in_R8[5]);
if (iVar3 == 0) {
uVar4 = lseek(local_2c,local_28,local_30);
if (uVar4 == 0xffffffffffffffff) {
piVar5 = __errno_location();
uVar4 = -(long)*piVar5;
}
if ((int)uVar1 == -9) {
auVar9 = JS_NewBigInt64(param_1,uVar4);
}
else {
bVar7 = (long)(int)uVar4 == uVar4;
dVar6 = (double)(long)uVar4;
if (bVar7) {
dVar6 = (double)(uVar4 & 0xffffffff);
}
auVar2._8_8_ = 0;
auVar2._0_8_ = dVar6;
auVar9._8_8_ = 7;
auVar9._0_8_ = dVar6;
if (bVar7) {
auVar9 = auVar2;
}
}
uVar4 = auVar9._0_8_ & 0xffffffff00000000;
goto LAB_00117d1b;
}
}
}
auVar9 = ZEXT816(6) << 0x40;
uVar4 = 0;
LAB_00117d1b:
auVar8._0_8_ = auVar9._0_8_ & 0xffffffff | uVar4;
auVar8._8_8_ = auVar9._8_8_;
return auVar8;
}
| |
41,283 | js_os_seek | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_os_seek(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
int fd, whence;
int64_t pos, ret;
BOOL is_bigint;
if (JS_ToInt32(ctx, &fd, argv[0]))
return JS_EXCEPTION;
is_bigint = JS_IsBigInt(ctx, argv[1]);
if (JS_ToInt64Ext(ctx, &pos, argv[1]))
return JS_EXCEPTION;
if (JS_ToInt32(ctx, &whence, argv[2]))
return JS_EXCEPTION;
ret = lseek(fd, pos, whence);
if (ret == -1)
ret = -errno;
if (is_bigint)
return JS_NewBigInt64(ctx, ret);
else
return JS_NewInt64(ctx, ret);
} | O3 | c | js_os_seek:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rdi, %rbx
movq (%r8), %rdx
movq 0x8(%r8), %rcx
leaq 0xc(%rsp), %rsi
callq 0x273ff
movl $0x6, %r14d
testl %eax, %eax
jne 0x18710
movq 0x10(%r15), %rdx
movq 0x18(%r15), %r12
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r12, %rcx
callq 0x273d3
testl %eax, %eax
jne 0x18710
movq 0x20(%r15), %rdx
movq 0x28(%r15), %rcx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x273ff
testl %eax, %eax
je 0x18729
xorl %eax, %eax
xorl %r15d, %r15d
movl %eax, %eax
orq %r15, %rax
movq %r14, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl %r12d, %r14d
movl 0xc(%rsp), %edi
movq 0x10(%rsp), %rsi
movl 0x8(%rsp), %edx
callq 0xe320
cmpq $-0x1, %rax
jne 0x1874f
callq 0xe0b0
movslq (%rax), %rax
negq %rax
movabsq $-0x100000000, %r15 # imm = 0xFFFFFFFF00000000
cmpl $-0x9, %r14d
jne 0x1876f
movq %rbx, %rdi
movq %rax, %rsi
callq 0x27d6d
movq %rdx, %r14
jmp 0x18791
movslq %eax, %rcx
xorl %edx, %edx
cmpq %rax, %rcx
cvtsi2sd %rax, %xmm0
movl %ecx, %ecx
movq %xmm0, %rax
cmoveq %rcx, %rax
movl $0x7, %r14d
cmoveq %rdx, %r14
andq %rax, %r15
jmp 0x18715
| js_os_seek:
push r15
push r14
push r12
push rbx
sub rsp, 18h
mov r15, r8
mov rbx, rdi
mov rdx, [r8]
mov rcx, [r8+8]
lea rsi, [rsp+38h+var_2C]
call JS_ToInt32
mov r14d, 6
test eax, eax
jnz short loc_18710
mov rdx, [r15+10h]
mov r12, [r15+18h]
lea rsi, [rsp+38h+var_28]
mov rdi, rbx
mov rcx, r12
call JS_ToInt64Ext
test eax, eax
jnz short loc_18710
mov rdx, [r15+20h]
mov rcx, [r15+28h]
lea rsi, [rsp+38h+var_30]
mov rdi, rbx
call JS_ToInt32
test eax, eax
jz short loc_18729
loc_18710:
xor eax, eax
xor r15d, r15d
loc_18715:
mov eax, eax
or rax, r15
mov rdx, r14
add rsp, 18h
pop rbx
pop r12
pop r14
pop r15
retn
loc_18729:
mov r14d, r12d
mov edi, [rsp+38h+var_2C]
mov rsi, [rsp+38h+var_28]
mov edx, [rsp+38h+var_30]
call _lseek
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_1874F
call ___errno_location
movsxd rax, dword ptr [rax]
neg rax
loc_1874F:
mov r15, 0FFFFFFFF00000000h
cmp r14d, 0FFFFFFF7h
jnz short loc_1876F
mov rdi, rbx
mov rsi, rax
call JS_NewBigInt64
mov r14, rdx
jmp short loc_18791
loc_1876F:
movsxd rcx, eax
xor edx, edx
cmp rcx, rax
cvtsi2sd xmm0, rax
mov ecx, ecx
movq rax, xmm0
cmovz rax, rcx
mov r14d, 7
cmovz r14, rdx
loc_18791:
and r15, rax
jmp loc_18715
| unsigned long long js_os_seek(long long a1, long long a2, long long a3, long long a4, _QWORD *a5)
{
long long v7; // r12
double v8; // rax
unsigned long long v9; // r15
long long v11; // rdi
long long v12; // rax
bool v13; // zf
double v14; // rcx
unsigned int v15; // [rsp+8h] [rbp-30h] BYREF
unsigned int v16; // [rsp+Ch] [rbp-2Ch] BYREF
_QWORD v17[5]; // [rsp+10h] [rbp-28h] BYREF
if ( (unsigned int)JS_ToInt32(a1, &v16, *a5, a5[1])
|| (v7 = a5[3], (unsigned int)JS_ToInt64Ext(a1, v17, a5[2], v7))
|| (unsigned int)JS_ToInt32(a1, &v15, a5[4], a5[5]) )
{
LODWORD(v8) = 0;
v9 = 0LL;
}
else
{
v11 = v16;
v12 = lseek(v16, v17[0], v15);
if ( v12 == -1 )
v12 = -(long long)*(int *)__errno_location(v11);
if ( (_DWORD)v7 == -9 )
{
v8 = COERCE_DOUBLE(JS_NewBigInt64(a1, v12));
}
else
{
v13 = (int)v12 == v12;
*(_QWORD *)&v14 = (unsigned int)v12;
v8 = (double)(int)v12;
if ( v13 )
v8 = v14;
}
v9 = *(_QWORD *)&v8 & 0xFFFFFFFF00000000LL;
}
return v9 | LODWORD(v8);
}
| js_os_seek:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15,R8
MOV RBX,RDI
MOV RDX,qword ptr [R8]
MOV RCX,qword ptr [R8 + 0x8]
LEA RSI,[RSP + 0xc]
CALL 0x001273ff
MOV R14D,0x6
TEST EAX,EAX
JNZ 0x00118710
MOV RDX,qword ptr [R15 + 0x10]
MOV R12,qword ptr [R15 + 0x18]
LEA RSI,[RSP + 0x10]
MOV RDI,RBX
MOV RCX,R12
CALL 0x001273d3
TEST EAX,EAX
JNZ 0x00118710
MOV RDX,qword ptr [R15 + 0x20]
MOV RCX,qword ptr [R15 + 0x28]
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x001273ff
TEST EAX,EAX
JZ 0x00118729
LAB_00118710:
XOR EAX,EAX
XOR R15D,R15D
LAB_00118715:
MOV EAX,EAX
OR RAX,R15
MOV RDX,R14
ADD RSP,0x18
POP RBX
POP R12
POP R14
POP R15
RET
LAB_00118729:
MOV R14D,R12D
MOV EDI,dword ptr [RSP + 0xc]
MOV RSI,qword ptr [RSP + 0x10]
MOV EDX,dword ptr [RSP + 0x8]
CALL 0x0010e320
CMP RAX,-0x1
JNZ 0x0011874f
CALL 0x0010e0b0
MOVSXD RAX,dword ptr [RAX]
NEG RAX
LAB_0011874f:
MOV R15,-0x100000000
CMP R14D,-0x9
JNZ 0x0011876f
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00127d6d
MOV R14,RDX
JMP 0x00118791
LAB_0011876f:
MOVSXD RCX,EAX
XOR EDX,EDX
CMP RCX,RAX
CVTSI2SD XMM0,RAX
MOV ECX,ECX
MOVQ RAX,XMM0
CMOVZ RAX,RCX
MOV R14D,0x7
CMOVZ R14,RDX
LAB_00118791:
AND R15,RAX
JMP 0x00118715
|
int1 [16] js_os_seek(int8 param_1)
{
int8 uVar1;
int1 auVar2 [16];
int iVar3;
ulong uVar4;
int *piVar5;
double dVar6;
int8 *in_R8;
bool bVar7;
int1 auVar8 [16];
int1 auVar9 [16];
int local_30;
int local_2c;
__off_t local_28;
iVar3 = JS_ToInt32(param_1,&local_2c,*in_R8,in_R8[1]);
if (iVar3 == 0) {
uVar1 = in_R8[3];
iVar3 = JS_ToInt64Ext(param_1,&local_28,in_R8[2],uVar1);
if (iVar3 == 0) {
iVar3 = JS_ToInt32(param_1,&local_30,in_R8[4],in_R8[5]);
if (iVar3 == 0) {
uVar4 = lseek(local_2c,local_28,local_30);
if (uVar4 == 0xffffffffffffffff) {
piVar5 = __errno_location();
uVar4 = -(long)*piVar5;
}
if ((int)uVar1 == -9) {
auVar9 = JS_NewBigInt64(param_1,uVar4);
}
else {
bVar7 = (long)(int)uVar4 == uVar4;
dVar6 = (double)(long)uVar4;
if (bVar7) {
dVar6 = (double)(uVar4 & 0xffffffff);
}
auVar2._8_8_ = 0;
auVar2._0_8_ = dVar6;
auVar9._8_8_ = 7;
auVar9._0_8_ = dVar6;
if (bVar7) {
auVar9 = auVar2;
}
}
uVar4 = auVar9._0_8_ & 0xffffffff00000000;
goto LAB_00118715;
}
}
}
auVar9 = ZEXT816(6) << 0x40;
uVar4 = 0;
LAB_00118715:
auVar8._0_8_ = auVar9._0_8_ & 0xffffffff | uVar4;
auVar8._8_8_ = auVar9._8_8_;
return auVar8;
}
| |
41,284 | strlength | eloqsql/mysys/mf_format.c | size_t strlength(const char *str)
{
reg1 const char * pos;
reg2 const char * found;
DBUG_ENTER("strlength");
pos= found= str;
while (*pos)
{
if (*pos != ' ')
{
while (*++pos && *pos != ' ') {};
if (!*pos)
{
found=pos; /* String ends here */
break;
}
}
found=pos;
while (*++pos == ' ') {};
}
DBUG_RETURN((size_t) (found - str));
} | O0 | c | strlength:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x34923
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x348fc
jmp 0x348af
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl 0x1(%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x348dc
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x348e5
jmp 0x348e7
jmp 0x348af
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x348fa
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x34923
jmp 0x348fc
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl 0x1(%rax), %eax
cmpl $0x20, %eax
jne 0x3491e
jmp 0x34904
jmp 0x34894
jmp 0x34925
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
| strlength:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
mov [rbp+var_10], rax
loc_34894:
mov rax, [rbp+var_10]
cmp byte ptr [rax], 0
jz loc_34923
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 20h ; ' '
jz short loc_348FC
jmp short $+2
loc_348AF:
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
movsx ecx, byte ptr [rax+1]
xor eax, eax
cmp ecx, 0
mov [rbp+var_19], al
jz short loc_348DC
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 20h ; ' '
setnz al
mov [rbp+var_19], al
loc_348DC:
mov al, [rbp+var_19]
test al, 1
jnz short loc_348E5
jmp short loc_348E7
loc_348E5:
jmp short loc_348AF
loc_348E7:
mov rax, [rbp+var_10]
cmp byte ptr [rax], 0
jnz short loc_348FA
mov rax, [rbp+var_10]
mov [rbp+var_18], rax
jmp short loc_34923
loc_348FA:
jmp short $+2
loc_348FC:
mov rax, [rbp+var_10]
mov [rbp+var_18], rax
loc_34904:
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
movsx eax, byte ptr [rax+1]
cmp eax, 20h ; ' '
jnz short loc_3491E
jmp short loc_34904
loc_3491E:
jmp loc_34894
loc_34923:
jmp short $+2
loc_34925:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_8]
sub rax, rcx
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
pop rbp
retn
| long long strlength(_BYTE *a1)
{
_BYTE *v1; // rax
_BYTE *v2; // rax
bool v4; // [rsp+Fh] [rbp-19h]
_BYTE *v5; // [rsp+10h] [rbp-18h]
_BYTE *v6; // [rsp+18h] [rbp-10h]
v5 = a1;
v6 = a1;
while ( *v6 )
{
if ( *v6 != 32 )
{
do
{
v1 = v6++;
v4 = 0;
if ( v1[1] )
v4 = *v6 != 32;
}
while ( v4 );
if ( !*v6 )
{
v5 = v6;
return v5 - a1;
}
}
v5 = v6;
do
v2 = v6++;
while ( v2[1] == 32 );
}
return v5 - a1;
}
| strlength:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV qword ptr [RBP + -0x10],RAX
LAB_00134894:
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX],0x0
JZ 0x00134923
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x20
JZ 0x001348fc
JMP 0x001348af
LAB_001348af:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOVSX ECX,byte ptr [RAX + 0x1]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x19],AL
JZ 0x001348dc
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x20
SETNZ AL
MOV byte ptr [RBP + -0x19],AL
LAB_001348dc:
MOV AL,byte ptr [RBP + -0x19]
TEST AL,0x1
JNZ 0x001348e5
JMP 0x001348e7
LAB_001348e5:
JMP 0x001348af
LAB_001348e7:
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX],0x0
JNZ 0x001348fa
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00134923
LAB_001348fa:
JMP 0x001348fc
LAB_001348fc:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x18],RAX
LAB_00134904:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOVSX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x20
JNZ 0x0013491e
JMP 0x00134904
LAB_0013491e:
JMP 0x00134894
LAB_00134923:
JMP 0x00134925
LAB_00134925:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x8]
SUB RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
POP RBP
RET
|
long strlength(char *param_1)
{
char *pcVar1;
char *pcVar2;
bool bVar3;
char *local_20;
char *local_18;
local_20 = param_1;
local_18 = param_1;
while (*local_18 != '\0') {
if (*local_18 != ' ') {
do {
local_20 = local_18 + 1;
bVar3 = false;
if (local_18[1] != '\0') {
bVar3 = *local_20 != ' ';
}
local_18 = local_20;
} while (bVar3);
if (*local_20 == '\0') break;
}
local_20 = local_18;
do {
pcVar2 = local_18 + 1;
pcVar1 = local_18 + 1;
local_18 = pcVar2;
} while (*pcVar1 == ' ');
}
return (long)local_20 - (long)param_1;
}
| |
41,285 | JS_NewObjectProtoClass | bluesky950520[P]quickjs/quickjs.c | JSValue JS_NewObjectProtoClass(JSContext *ctx, JSValue proto_val,
JSClassID class_id)
{
JSShape *sh;
JSObject *proto;
proto = get_proto_obj(proto_val);
sh = find_hashed_shape_proto(ctx->rt, proto);
if (likely(sh)) {
sh = js_dup_shape(sh);
} else {
sh = js_new_shape(ctx, proto);
if (!sh)
return JS_EXCEPTION;
}
return JS_NewObjectFromShape(ctx, sh, class_id);
} | O0 | c | JS_NewObjectProtoClass:
subq $0x48, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x29f70
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x29fa0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x29f0e
movq 0x10(%rsp), %rdi
callq 0x2a050
movq %rax, 0x10(%rsp)
jmp 0x29f3f
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2a070
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x29f3d
movl $0x0, 0x38(%rsp)
movq $0x6, 0x40(%rsp)
jmp 0x29f5c
jmp 0x29f3f
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x1c(%rsp), %edx
callq 0x2a0a0
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x48, %rsp
retq
nopl (%rax,%rax)
| JS_NewObjectProtoClass:
sub rsp, 48h
mov [rsp+48h+var_20], rsi
mov [rsp+48h+var_18], rdx
mov [rsp+48h+var_28], rdi
mov [rsp+48h+var_2C], ecx
mov rdi, [rsp+48h+var_20]
mov rsi, [rsp+48h+var_18]
call get_proto_obj
mov [rsp+48h+var_40], rax
mov rax, [rsp+48h+var_28]
mov rdi, [rax+18h]
mov rsi, [rsp+48h+var_40]
call find_hashed_shape_proto
mov [rsp+48h+var_38], rax
cmp [rsp+48h+var_38], 0
setnz al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_29F0E
mov rdi, [rsp+48h+var_38]
call js_dup_shape
mov [rsp+48h+var_38], rax
jmp short loc_29F3F
loc_29F0E:
mov rdi, [rsp+48h+var_28]
mov rsi, [rsp+48h+var_40]
call js_new_shape
mov [rsp+48h+var_38], rax
cmp [rsp+48h+var_38], 0
jnz short loc_29F3D
mov dword ptr [rsp+48h+var_10], 0
mov [rsp+48h+var_8], 6
jmp short loc_29F5C
loc_29F3D:
jmp short $+2
loc_29F3F:
mov rdi, [rsp+48h+var_28]
mov rsi, [rsp+48h+var_38]
mov edx, [rsp+48h+var_2C]
call JS_NewObjectFromShape
mov [rsp+48h+var_10], rax
mov [rsp+48h+var_8], rdx
loc_29F5C:
mov rax, [rsp+48h+var_10]
mov rdx, [rsp+48h+var_8]
add rsp, 48h
retn
| long long JS_NewObjectProtoClass(long long a1, long long a2, long long a3, unsigned int a4)
{
long long proto_obj; // [rsp+8h] [rbp-40h]
long long hashed_shape_proto; // [rsp+10h] [rbp-38h]
long long v8; // [rsp+10h] [rbp-38h]
long long v9; // [rsp+10h] [rbp-38h]
long long v11; // [rsp+38h] [rbp-10h]
proto_obj = get_proto_obj(a2, a3);
hashed_shape_proto = find_hashed_shape_proto(*(_QWORD *)(a1 + 24), proto_obj);
if ( hashed_shape_proto )
{
v8 = js_dup_shape(hashed_shape_proto);
return JS_NewObjectFromShape(a1, v8, a4);
}
v9 = js_new_shape(a1, proto_obj);
if ( v9 )
return JS_NewObjectFromShape(a1, v9, a4);
LODWORD(v11) = 0;
return v11;
}
| JS_NewObjectProtoClass:
SUB RSP,0x48
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RSP + 0x20],RDI
MOV dword ptr [RSP + 0x1c],ECX
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x30]
CALL 0x00129f70
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV RDI,qword ptr [RAX + 0x18]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x00129fa0
MOV qword ptr [RSP + 0x10],RAX
CMP qword ptr [RSP + 0x10],0x0
SETNZ AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x00129f0e
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x0012a050
MOV qword ptr [RSP + 0x10],RAX
JMP 0x00129f3f
LAB_00129f0e:
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x0012a070
MOV qword ptr [RSP + 0x10],RAX
CMP qword ptr [RSP + 0x10],0x0
JNZ 0x00129f3d
MOV dword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x6
JMP 0x00129f5c
LAB_00129f3d:
JMP 0x00129f3f
LAB_00129f3f:
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x10]
MOV EDX,dword ptr [RSP + 0x1c]
CALL 0x0012a0a0
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x40],RDX
LAB_00129f5c:
MOV RAX,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
ADD RSP,0x48
RET
|
int1 [16]
JS_NewObjectProtoClass(long param_1,int8 param_2,int8 param_3,int4 param_4)
{
int8 uVar1;
long lVar2;
int1 auVar3 [16];
long local_38;
int4 local_10;
int4 uStack_c;
int8 local_8;
uVar1 = get_proto_obj(param_2,param_3);
lVar2 = find_hashed_shape_proto(*(int8 *)(param_1 + 0x18),uVar1);
if (lVar2 == 0) {
local_38 = js_new_shape(param_1,uVar1);
if (local_38 == 0) {
local_10 = 0;
local_8 = 6;
goto LAB_00129f5c;
}
}
else {
local_38 = js_dup_shape(lVar2);
}
auVar3 = JS_NewObjectFromShape(param_1,local_38,param_4);
local_8 = auVar3._8_8_;
local_10 = auVar3._0_4_;
uStack_c = auVar3._4_4_;
LAB_00129f5c:
auVar3._4_4_ = uStack_c;
auVar3._0_4_ = local_10;
auVar3._8_8_ = local_8;
return auVar3;
}
| |
41,286 | JS_NewObjectProtoClass | bluesky950520[P]quickjs/quickjs.c | JSValue JS_NewObjectProtoClass(JSContext *ctx, JSValue proto_val,
JSClassID class_id)
{
JSShape *sh;
JSObject *proto;
proto = get_proto_obj(proto_val);
sh = find_hashed_shape_proto(ctx->rt, proto);
if (likely(sh)) {
sh = js_dup_shape(sh);
} else {
sh = js_new_shape(ctx, proto);
if (!sh)
return JS_EXCEPTION;
}
return JS_NewObjectFromShape(ctx, sh, class_id);
} | O1 | c | JS_NewObjectProtoClass:
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rsi, %rax
xorl %esi, %esi
cmpl $-0x1, %edx
cmovneq %rsi, %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
imull $0x9e370001, %eax, %ecx # imm = 0x9E370001
movq %rax, %rdx
shrq $0x20, %rdx
addl %ecx, %edx
imull $0x9e370001, %edx, %edx # imm = 0x9E370001
addl $0x3c6e0001, %edx # imm = 0x3C6E0001
xorl %ecx, %ecx
subb 0x184(%rdi), %cl
movl %edx, %r8d
shrl %cl, %r8d
movq 0x190(%rdi), %rcx
movq (%rcx,%r8,8), %rcx
testq %rcx, %rcx
je 0x20f73
xorl %esi, %esi
cmpl %edx, 0x1c(%rcx)
jne 0x20f6a
cmpq %rax, 0x38(%rcx)
jne 0x20f6a
cmpl $0x0, 0x28(%rcx)
je 0x20f8c
movq 0x30(%rcx), %rcx
testq %rcx, %rcx
jne 0x20f59
testq %rsi, %rsi
je 0x20f91
incl (%rsi)
movq %r14, %rdi
movl %ebx, %edx
callq 0xf516
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rcx, %rsi
jmp 0x20f73
movq %r14, %rdi
movq %rax, %rsi
movl $0x2, %edx
callq 0x3bd61
testq %rax, %rax
jne 0x20faf
movl $0x6, %edx
xorl %eax, %eax
jmp 0x20f84
movq %rax, %rsi
jmp 0x20f7a
| JS_NewObjectProtoClass:
push r14
push rbx
push rax
mov ebx, ecx
mov rax, rsi
xor esi, esi
cmp edx, 0FFFFFFFFh
cmovnz rax, rsi
mov r14, rdi
mov rdi, [rdi+18h]
imul ecx, eax, 9E370001h
mov rdx, rax
shr rdx, 20h
add edx, ecx
imul edx, 9E370001h
add edx, 3C6E0001h
xor ecx, ecx
sub cl, [rdi+184h]
mov r8d, edx
shr r8d, cl
mov rcx, [rdi+190h]
mov rcx, [rcx+r8*8]
test rcx, rcx
jz short loc_20F73
xor esi, esi
loc_20F59:
cmp [rcx+1Ch], edx
jnz short loc_20F6A
cmp [rcx+38h], rax
jnz short loc_20F6A
cmp dword ptr [rcx+28h], 0
jz short loc_20F8C
loc_20F6A:
mov rcx, [rcx+30h]
test rcx, rcx
jnz short loc_20F59
loc_20F73:
test rsi, rsi
jz short loc_20F91
inc dword ptr [rsi]
loc_20F7A:
mov rdi, r14
mov edx, ebx
call JS_NewObjectFromShape
loc_20F84:
add rsp, 8
pop rbx
pop r14
retn
loc_20F8C:
mov rsi, rcx
jmp short loc_20F73
loc_20F91:
mov rdi, r14
mov rsi, rax
mov edx, 2
call js_new_shape2
test rax, rax
jnz short loc_20FAF
mov edx, 6
xor eax, eax
jmp short loc_20F84
loc_20FAF:
mov rsi, rax
jmp short loc_20F7A
| long long JS_NewObjectProtoClass(long long a1, long long a2, int a3, unsigned int a4)
{
_DWORD *v6; // rsi
long long v7; // rcx
long long v9; // rax
v6 = 0LL;
if ( a3 != -1 )
a2 = 0LL;
v7 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 400LL)
+ 8LL
* ((unsigned int)(-1640562687 * (-1640562687 * a2 + HIDWORD(a2)) + 1013841921) >> -*(_BYTE *)(*(_QWORD *)(a1 + 24) + 388LL)));
if ( v7 )
{
v6 = 0LL;
while ( *(_DWORD *)(v7 + 28) != -1640562687 * (-1640562687 * (_DWORD)a2 + HIDWORD(a2)) + 1013841921
|| *(_QWORD *)(v7 + 56) != a2
|| *(_DWORD *)(v7 + 40) )
{
v7 = *(_QWORD *)(v7 + 48);
if ( !v7 )
goto LABEL_9;
}
v6 = (_DWORD *)v7;
}
LABEL_9:
if ( v6 )
{
++*v6;
}
else
{
v9 = js_new_shape2(a1, a2, 2LL);
if ( !v9 )
return 0LL;
v6 = (_DWORD *)v9;
}
return JS_NewObjectFromShape(a1, v6, a4);
}
| JS_NewObjectProtoClass:
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,ECX
MOV RAX,RSI
XOR ESI,ESI
CMP EDX,-0x1
CMOVNZ RAX,RSI
MOV R14,RDI
MOV RDI,qword ptr [RDI + 0x18]
IMUL ECX,EAX,-0x61c8ffff
MOV RDX,RAX
SHR RDX,0x20
ADD EDX,ECX
IMUL EDX,EDX,-0x61c8ffff
ADD EDX,0x3c6e0001
XOR ECX,ECX
SUB CL,byte ptr [RDI + 0x184]
MOV R8D,EDX
SHR R8D,CL
MOV RCX,qword ptr [RDI + 0x190]
MOV RCX,qword ptr [RCX + R8*0x8]
TEST RCX,RCX
JZ 0x00120f73
XOR ESI,ESI
LAB_00120f59:
CMP dword ptr [RCX + 0x1c],EDX
JNZ 0x00120f6a
CMP qword ptr [RCX + 0x38],RAX
JNZ 0x00120f6a
CMP dword ptr [RCX + 0x28],0x0
JZ 0x00120f8c
LAB_00120f6a:
MOV RCX,qword ptr [RCX + 0x30]
TEST RCX,RCX
JNZ 0x00120f59
LAB_00120f73:
TEST RSI,RSI
JZ 0x00120f91
INC dword ptr [RSI]
LAB_00120f7a:
MOV RDI,R14
MOV EDX,EBX
CALL 0x0010f516
LAB_00120f84:
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_00120f8c:
MOV RSI,RCX
JMP 0x00120f73
LAB_00120f91:
MOV RDI,R14
MOV RSI,RAX
MOV EDX,0x2
CALL 0x0013bd61
TEST RAX,RAX
JNZ 0x00120faf
MOV EDX,0x6
XOR EAX,EAX
JMP 0x00120f84
LAB_00120faf:
MOV RSI,RAX
JMP 0x00120f7a
|
int8 JS_NewObjectProtoClass(long param_1,int *param_2,int param_3,int4 param_4)
{
int8 uVar1;
int *piVar2;
int *piVar3;
uint uVar4;
if (param_3 != -1) {
param_2 = (int *)0x0;
}
uVar4 = ((int)((ulong)param_2 >> 0x20) + (int)param_2 * -0x61c8ffff) * -0x61c8ffff + 0x3c6e0001;
piVar3 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 400) +
(ulong)(uVar4 >> (-*(char *)(*(long *)(param_1 + 0x18) + 0x184) & 0x1fU)) * 8);
piVar2 = (int *)0x0;
if (piVar3 != (int *)0x0) {
do {
if (((piVar3[7] == uVar4) && (*(int **)(piVar3 + 0xe) == param_2)) &&
(piVar2 = piVar3, piVar3[10] == 0)) break;
piVar3 = *(int **)(piVar3 + 0xc);
piVar2 = (int *)0x0;
} while (piVar3 != (int *)0x0);
}
if (piVar2 == (int *)0x0) {
piVar2 = (int *)js_new_shape2(param_1,param_2,2);
if (piVar2 == (int *)0x0) {
return 0;
}
}
else {
*piVar2 = *piVar2 + 1;
}
uVar1 = JS_NewObjectFromShape(param_1,piVar2,param_4);
return uVar1;
}
| |
41,287 | JS_NewObjectProtoClass | bluesky950520[P]quickjs/quickjs.c | JSValue JS_NewObjectProtoClass(JSContext *ctx, JSValue proto_val,
JSClassID class_id)
{
JSShape *sh;
JSObject *proto;
proto = get_proto_obj(proto_val);
sh = find_hashed_shape_proto(ctx->rt, proto);
if (likely(sh)) {
sh = js_dup_shape(sh);
} else {
sh = js_new_shape(ctx, proto);
if (!sh)
return JS_EXCEPTION;
}
return JS_NewObjectFromShape(ctx, sh, class_id);
} | O2 | c | JS_NewObjectProtoClass:
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdi, %r14
xorl %ecx, %ecx
cmpl $-0x1, %edx
cmovneq %rcx, %rsi
movq 0x18(%rdi), %rdi
imull $0x9e370001, %esi, %eax # imm = 0x9E370001
movq %rsi, %rdx
shrq $0x20, %rdx
addl %eax, %edx
imull $0x9e370001, %edx, %edx # imm = 0x9E370001
addl $0x3c6e0001, %edx # imm = 0x3C6E0001
subb 0x184(%rdi), %cl
movl %edx, %eax
shrl %cl, %eax
shlq $0x3, %rax
addq 0x190(%rdi), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x1b0ce
cmpl %edx, 0x1c(%rax)
jne 0x1b0c8
cmpq %rsi, 0x38(%rax)
jne 0x1b0c8
cmpl $0x0, 0x28(%rax)
je 0x1b0e5
addq $0x30, %rax
jmp 0x1b0af
pushq $0x2
popq %rdx
movq %r14, %rdi
callq 0x34b64
testq %rax, %rax
jne 0x1b0e7
pushq $0x6
popq %rdx
xorl %eax, %eax
jmp 0x1b0f4
incl (%rax)
movq %r14, %rdi
movq %rax, %rsi
movl %ebx, %edx
callq 0x1b0fc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| JS_NewObjectProtoClass:
push r14
push rbx
push rax
mov ebx, ecx
mov r14, rdi
xor ecx, ecx
cmp edx, 0FFFFFFFFh
cmovnz rsi, rcx
mov rdi, [rdi+18h]
imul eax, esi, 9E370001h
mov rdx, rsi
shr rdx, 20h
add edx, eax
imul edx, 9E370001h
add edx, 3C6E0001h
sub cl, [rdi+184h]
mov eax, edx
shr eax, cl
shl rax, 3
add rax, [rdi+190h]
loc_1B0AF:
mov rax, [rax]
test rax, rax
jz short loc_1B0CE
cmp [rax+1Ch], edx
jnz short loc_1B0C8
cmp [rax+38h], rsi
jnz short loc_1B0C8
cmp dword ptr [rax+28h], 0
jz short loc_1B0E5
loc_1B0C8:
add rax, 30h ; '0'
jmp short loc_1B0AF
loc_1B0CE:
push 2
pop rdx
mov rdi, r14
call js_new_shape2
test rax, rax
jnz short loc_1B0E7
push 6
pop rdx
xor eax, eax
jmp short loc_1B0F4
loc_1B0E5:
inc dword ptr [rax]
loc_1B0E7:
mov rdi, r14
mov rsi, rax
mov edx, ebx
call JS_NewObjectFromShape
loc_1B0F4:
add rsp, 8
pop rbx
pop r14
retn
| long long JS_NewObjectProtoClass(long long a1, long long a2, int a3, unsigned int a4)
{
long long *i; // rax
long long v6; // rax
if ( a3 != -1 )
a2 = 0LL;
for ( i = (long long *)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 400LL)
+ 8LL
* ((unsigned int)(-1640562687 * (-1640562687 * a2 + HIDWORD(a2)) + 1013841921) >> -*(_BYTE *)(*(_QWORD *)(a1 + 24) + 388LL)));
;
i = (long long *)(v6 + 48) )
{
v6 = *i;
if ( !v6 )
break;
if ( *(_DWORD *)(v6 + 28) == -1640562687 * (-1640562687 * (_DWORD)a2 + HIDWORD(a2)) + 1013841921
&& *(_QWORD *)(v6 + 56) == a2
&& !*(_DWORD *)(v6 + 40) )
{
++*(_DWORD *)v6;
return JS_NewObjectFromShape(a1, v6, a4);
}
}
v6 = js_new_shape2(a1, a2, 2LL);
if ( !v6 )
return 0LL;
return JS_NewObjectFromShape(a1, v6, a4);
}
| JS_NewObjectProtoClass:
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,ECX
MOV R14,RDI
XOR ECX,ECX
CMP EDX,-0x1
CMOVNZ RSI,RCX
MOV RDI,qword ptr [RDI + 0x18]
IMUL EAX,ESI,-0x61c8ffff
MOV RDX,RSI
SHR RDX,0x20
ADD EDX,EAX
IMUL EDX,EDX,-0x61c8ffff
ADD EDX,0x3c6e0001
SUB CL,byte ptr [RDI + 0x184]
MOV EAX,EDX
SHR EAX,CL
SHL RAX,0x3
ADD RAX,qword ptr [RDI + 0x190]
LAB_0011b0af:
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x0011b0ce
CMP dword ptr [RAX + 0x1c],EDX
JNZ 0x0011b0c8
CMP qword ptr [RAX + 0x38],RSI
JNZ 0x0011b0c8
CMP dword ptr [RAX + 0x28],0x0
JZ 0x0011b0e5
LAB_0011b0c8:
ADD RAX,0x30
JMP 0x0011b0af
LAB_0011b0ce:
PUSH 0x2
POP RDX
MOV RDI,R14
CALL 0x00134b64
TEST RAX,RAX
JNZ 0x0011b0e7
PUSH 0x6
POP RDX
XOR EAX,EAX
JMP 0x0011b0f4
LAB_0011b0e5:
INC dword ptr [RAX]
LAB_0011b0e7:
MOV RDI,R14
MOV RSI,RAX
MOV EDX,EBX
CALL 0x0011b0fc
LAB_0011b0f4:
ADD RSP,0x8
POP RBX
POP R14
RET
|
int8 JS_NewObjectProtoClass(long param_1,long param_2,int param_3,int4 param_4)
{
int *piVar1;
int8 uVar2;
uint uVar3;
if (param_3 != -1) {
param_2 = 0;
}
uVar3 = ((int)((ulong)param_2 >> 0x20) + (int)param_2 * -0x61c8ffff) * -0x61c8ffff + 0x3c6e0001;
piVar1 = (int *)((ulong)(uVar3 >> (-*(char *)(*(long *)(param_1 + 0x18) + 0x184) & 0x1fU)) * 8 +
*(long *)(*(long *)(param_1 + 0x18) + 400));
do {
piVar1 = *(int **)piVar1;
if (piVar1 == (int *)0x0) {
piVar1 = (int *)js_new_shape2(param_1,param_2,2);
if (piVar1 == (int *)0x0) {
uVar2 = 0;
}
else {
LAB_0011b0e7:
uVar2 = JS_NewObjectFromShape(param_1,piVar1,param_4);
}
return uVar2;
}
if (((piVar1[7] == uVar3) && (*(long *)(piVar1 + 0xe) == param_2)) && (piVar1[10] == 0)) {
*piVar1 = *piVar1 + 1;
goto LAB_0011b0e7;
}
piVar1 = piVar1 + 0xc;
} while( true );
}
| |
41,288 | FTB_WORD_cmp | eloqsql/storage/myisam/ft_boolean_search.c | static int FTB_WORD_cmp(my_off_t *v, FTB_WORD *a, FTB_WORD *b)
{
int i;
/* if a==curdoc, take it as a < b */
if (v && a->docid[0] == *v)
return -1;
/* ORDER BY docid, ndepth DESC */
i=CMP_NUM(a->docid[0], b->docid[0]);
if (!i)
i=CMP_NUM(b->ndepth,a->ndepth);
return i;
} | O3 | c | FTB_WORD_cmp:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rsi), %rcx
testq %rdi, %rdi
je 0x72b45
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq (%rdi), %rcx
je 0x72b68
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
setne %al
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmovbl %ecx, %eax
testl %eax, %eax
jne 0x72b68
movl 0x44(%rdx), %edx
xorl %eax, %eax
cmpl 0x44(%rsi), %edx
setne %al
cmovbl %ecx, %eax
popq %rbp
retq
| FTB_WORD_cmp:
push rbp
mov rbp, rsp
mov rcx, [rsi+10h]
test rdi, rdi
jz short loc_72B45
mov eax, 0FFFFFFFFh
cmp rcx, [rdi]
jz short loc_72B68
loc_72B45:
xor eax, eax
cmp rcx, [rdx+10h]
setnz al
mov ecx, 0FFFFFFFFh
cmovb eax, ecx
test eax, eax
jnz short loc_72B68
mov edx, [rdx+44h]
xor eax, eax
cmp edx, [rsi+44h]
setnz al
cmovb eax, ecx
loc_72B68:
pop rbp
retn
| long long FTB_WORD_cmp(_QWORD *a1, long long a2, long long a3)
{
unsigned long long v3; // rcx
long long result; // rax
unsigned int v5; // edx
v3 = *(_QWORD *)(a2 + 16);
if ( !a1 || (result = 0xFFFFFFFFLL, v3 != *a1) )
{
result = v3 != *(_QWORD *)(a3 + 16);
if ( v3 < *(_QWORD *)(a3 + 16) )
result = 0xFFFFFFFFLL;
if ( !(_DWORD)result )
{
v5 = *(_DWORD *)(a3 + 68);
result = v5 != *(_DWORD *)(a2 + 68);
if ( v5 < *(_DWORD *)(a2 + 68) )
return 0xFFFFFFFFLL;
}
}
return result;
}
| FTB_WORD_cmp:
PUSH RBP
MOV RBP,RSP
MOV RCX,qword ptr [RSI + 0x10]
TEST RDI,RDI
JZ 0x00172b45
MOV EAX,0xffffffff
CMP RCX,qword ptr [RDI]
JZ 0x00172b68
LAB_00172b45:
XOR EAX,EAX
CMP RCX,qword ptr [RDX + 0x10]
SETNZ AL
MOV ECX,0xffffffff
CMOVC EAX,ECX
TEST EAX,EAX
JNZ 0x00172b68
MOV EDX,dword ptr [RDX + 0x44]
XOR EAX,EAX
CMP EDX,dword ptr [RSI + 0x44]
SETNZ AL
CMOVC EAX,ECX
LAB_00172b68:
POP RBP
RET
|
uint FTB_WORD_cmp(ulong *param_1,long param_2,long param_3)
{
ulong uVar1;
uint uVar2;
uVar1 = *(ulong *)(param_2 + 0x10);
if ((param_1 == (ulong *)0x0) || (uVar2 = 0xffffffff, uVar1 != *param_1)) {
uVar2 = (uint)(uVar1 != *(ulong *)(param_3 + 0x10));
if (uVar1 < *(ulong *)(param_3 + 0x10)) {
uVar2 = 0xffffffff;
}
if ((uVar2 == 0) &&
(uVar2 = (uint)(*(uint *)(param_3 + 0x44) != *(uint *)(param_2 + 0x44)),
*(uint *)(param_3 + 0x44) < *(uint *)(param_2 + 0x44))) {
uVar2 = 0xffffffff;
}
}
return uVar2;
}
| |
41,289 | Logger::write(LogMessage*) const | SylCore-WoTLK/src/common/Logging/Logger.cpp | void Logger::write(LogMessage* message) const
{
if (!level || level < message->level || message->text.empty())
{
//fprintf(stderr, "Logger::write: Logger %s, Level %u. Msg %s Level %u WRONG LEVEL MASK OR EMPTY MSG\n", getName().c_str(), getLogLevel(), message.text.c_str(), message.level);
return;
}
for (std::pair<uint8 const, Appender*> const& appender : appenders)
if (appender.second)
{
appender.second->write(message);
}
} | O0 | cpp | Logger::write(LogMessage*) const:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
cmpb $0x0, 0x20(%rax)
je 0x1c1b55
movq (%rsp), %rax
movzbl 0x20(%rax), %eax
movq 0x28(%rsp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jl 0x1c1b55
movq 0x28(%rsp), %rdi
addq $0x28, %rdi
callq 0x2e120
testb $0x1, %al
jne 0x1c1b55
jmp 0x1c1b57
jmp 0x1c1bd5
movq (%rsp), %rax
addq $0x28, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1c1c50
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1c1c80
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1c1cb0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1c1b99
jmp 0x1c1bd5
leaq 0x18(%rsp), %rdi
callq 0x1c1ce0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1c1bc7
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x1b3710
jmp 0x1c1bc9
leaq 0x18(%rsp), %rdi
callq 0x1c1d20
jmp 0x1c1b82
addq $0x38, %rsp
retq
nopw (%rax,%rax)
| _ZNK6Logger5writeEP10LogMessage:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_10], rsi
mov rax, [rsp+38h+var_8]
mov [rsp+38h+var_38], rax
cmp byte ptr [rax+20h], 0
jz short loc_1C1B55
mov rax, [rsp+38h+var_38]
movzx eax, byte ptr [rax+20h]
mov rcx, [rsp+38h+var_10]
movzx ecx, byte ptr [rcx]
cmp eax, ecx
jl short loc_1C1B55
mov rdi, [rsp+38h+var_10]
add rdi, 28h ; '('
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz short loc_1C1B55
jmp short loc_1C1B57
loc_1C1B55:
jmp short loc_1C1BD5
loc_1C1B57:
mov rax, [rsp+38h+var_38]
add rax, 28h ; '('
mov [rsp+38h+var_18], rax
mov rdi, [rsp+38h+var_18]
call _ZNKSt13unordered_mapIhP8AppenderSt4hashIhESt8equal_toIhESaISt4pairIKhS1_EEE5beginEv; std::unordered_map<uchar,Appender *>::begin(void)
mov [rsp+38h+var_20], rax
mov rdi, [rsp+38h+var_18]
call _ZNKSt13unordered_mapIhP8AppenderSt4hashIhESt8equal_toIhESaISt4pairIKhS1_EEE3endEv; std::unordered_map<uchar,Appender *>::end(void)
mov [rsp+38h+var_28], rax
loc_1C1B82:
lea rdi, [rsp+38h+var_20]
lea rsi, [rsp+38h+var_28]
call _ZNSt8__detaileqERKNS_20_Node_const_iteratorISt4pairIKhP8AppenderELb0ELb0EEES8_; std::__detail::operator==(std::__detail::_Node_const_iterator<std::pair<uchar const,Appender *>,false,false> const&,std::__detail::_Node_const_iterator<std::pair<uchar const,Appender *>,false,false> const&)
xor al, 0FFh
test al, 1
jnz short loc_1C1B99
jmp short loc_1C1BD5
loc_1C1B99:
lea rdi, [rsp+38h+var_20]
call _ZNKSt8__detail20_Node_const_iteratorISt4pairIKhP8AppenderELb0ELb0EEdeEv; std::__detail::_Node_const_iterator<std::pair<uchar const,Appender *>,false,false>::operator*(void)
mov [rsp+38h+var_30], rax
mov rax, [rsp+38h+var_30]
cmp qword ptr [rax+8], 0
jz short loc_1C1BC7
mov rax, [rsp+38h+var_30]
mov rdi, [rax+8]; this
mov rsi, [rsp+38h+var_10]; LogMessage *
call _ZN8Appender5writeEP10LogMessage; Appender::write(LogMessage *)
loc_1C1BC7:
jmp short $+2
loc_1C1BC9:
lea rdi, [rsp+38h+var_20]
call _ZNSt8__detail20_Node_const_iteratorISt4pairIKhP8AppenderELb0ELb0EEppEv; std::__detail::_Node_const_iterator<std::pair<uchar const,Appender *>,false,false>::operator++(void)
jmp short loc_1C1B82
loc_1C1BD5:
add rsp, 38h
retn
| char Logger::write(Logger *this, LogMessage *a2)
{
int v2; // eax
long long v4; // [rsp+8h] [rbp-30h]
long long v5; // [rsp+10h] [rbp-28h] BYREF
_QWORD v6[2]; // [rsp+18h] [rbp-20h] BYREF
LogMessage *v7; // [rsp+28h] [rbp-10h]
Logger *v8; // [rsp+30h] [rbp-8h]
v8 = this;
v7 = a2;
LOBYTE(v2) = (_BYTE)this;
if ( *((_BYTE *)this + 32) )
{
v2 = *((unsigned __int8 *)this + 32);
if ( v2 >= *(unsigned __int8 *)v7 )
{
LOBYTE(v2) = std::string::empty((long long)v7 + 40);
if ( (v2 & 1) == 0 )
{
v6[1] = (char *)this + 40;
v6[0] = std::unordered_map<unsigned char,Appender *>::begin((char *)this + 40);
v5 = std::unordered_map<unsigned char,Appender *>::end((char *)this + 40);
while ( 1 )
{
LOBYTE(v2) = ~(unsigned __int8)std::__detail::operator==(v6, &v5);
if ( (v2 & 1) == 0 )
break;
v4 = std::__detail::_Node_const_iterator<std::pair<unsigned char const,Appender *>,false,false>::operator*(v6);
if ( *(_QWORD *)(v4 + 8) )
Appender::write(*(Appender **)(v4 + 8), v7);
std::__detail::_Node_const_iterator<std::pair<unsigned char const,Appender *>,false,false>::operator++(v6);
}
}
}
}
return v2;
}
| |||
41,290 | Logger::write(LogMessage*) const | SylCore-WoTLK/src/common/Logging/Logger.cpp | void Logger::write(LogMessage* message) const
{
if (!level || level < message->level || message->text.empty())
{
//fprintf(stderr, "Logger::write: Logger %s, Level %u. Msg %s Level %u WRONG LEVEL MASK OR EMPTY MSG\n", getName().c_str(), getLogLevel(), message.text.c_str(), message.level);
return;
}
for (std::pair<uint8 const, Appender*> const& appender : appenders)
if (appender.second)
{
appender.second->write(message);
}
} | O3 | cpp | Logger::write(LogMessage*) const:
movb 0x20(%rdi), %al
testb %al, %al
je 0xb6864
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb (%rsi), %al
jb 0xb685d
cmpq $0x0, 0x30(%rbx)
sete %al
movq 0x38(%rdi), %r14
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0xb685d
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xb6855
movq %rbx, %rsi
callq 0xb2972
movq (%r14), %r14
testq %r14, %r14
jne 0xb6844
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| _ZNK6Logger5writeEP10LogMessage:
mov al, [rdi+20h]
test al, al
jz short locret_B6864
push r14
push rbx
push rax
mov rbx, rsi
cmp al, [rsi]
jb short loc_B685D
cmp qword ptr [rbx+30h], 0
setz al
mov r14, [rdi+38h]
test r14, r14
setz cl
or cl, al
jnz short loc_B685D
loc_B6844:
mov rdi, [r14+10h]
test rdi, rdi
jz short loc_B6855
mov rsi, rbx
call _ZN8Appender5writeEP10LogMessage; Appender::write(LogMessage *)
loc_B6855:
mov r14, [r14]
test r14, r14
jnz short loc_B6844
loc_B685D:
add rsp, 8
pop rbx
pop r14
locret_B6864:
retn
| void Logger::write(long long a1, long long a2)
{
unsigned __int8 v2; // al
_QWORD *v3; // r14
_BYTE *v4; // rdi
v2 = *(_BYTE *)(a1 + 32);
if ( v2 )
{
if ( v2 >= *(_BYTE *)a2 )
{
v3 = *(_QWORD **)(a1 + 56);
if ( *(_QWORD *)(a2 + 48) != 0LL && v3 != 0LL )
{
do
{
v4 = (_BYTE *)v3[2];
if ( v4 )
Appender::write(v4, a2);
v3 = (_QWORD *)*v3;
}
while ( v3 );
}
}
}
}
| write:
MOV AL,byte ptr [RDI + 0x20]
TEST AL,AL
JZ 0x001b6864
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
CMP AL,byte ptr [RSI]
JC 0x001b685d
CMP qword ptr [RBX + 0x30],0x0
SETZ AL
MOV R14,qword ptr [RDI + 0x38]
TEST R14,R14
SETZ CL
OR CL,AL
JNZ 0x001b685d
LAB_001b6844:
MOV RDI,qword ptr [R14 + 0x10]
TEST RDI,RDI
JZ 0x001b6855
MOV RSI,RBX
CALL 0x001b2972
LAB_001b6855:
MOV R14,qword ptr [R14]
TEST R14,R14
JNZ 0x001b6844
LAB_001b685d:
ADD RSP,0x8
POP RBX
POP R14
LAB_001b6864:
RET
|
/* Logger::write(LogMessage*) const */
void __thiscall Logger::write(Logger *this,LogMessage *param_1)
{
long *plVar1;
if (((*(LogMessage *)(this + 0x20) != (LogMessage)0x0) &&
((byte)*param_1 <= (byte)*(LogMessage *)(this + 0x20))) &&
(plVar1 = *(long **)(this + 0x38), plVar1 != (long *)0x0 && *(long *)(param_1 + 0x30) != 0)) {
do {
if ((Appender *)plVar1[2] != (Appender *)0x0) {
Appender::write((Appender *)plVar1[2],param_1);
}
plVar1 = (long *)*plVar1;
} while (plVar1 != (long *)0x0);
}
return;
}
| |
41,291 | get_charset_number | eloqsql/mysys/charset.c | uint get_charset_number(const char *charset_name, uint cs_flags, myf flags)
{
uint id;
const char *new_charset_name= flags & MY_UTF8_IS_UTF8MB3 ? "utf8mb3" :
"utf8mb4";
my_pthread_once(&charsets_initialized, init_available_charsets);
if ((id= get_charset_number_internal(charset_name, cs_flags)))
return id;
if ((charset_name= !my_strcasecmp(&my_charset_latin1, charset_name, "utf8") ?
new_charset_name : NULL))
return get_charset_number_internal(charset_name, cs_flags);
return 0;
} | O0 | c | get_charset_number:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdx
andq $0x400, %rdx # imm = 0x400
leaq 0x776d7(%rip), %rax # 0x152d4c
leaq 0x776c8(%rip), %rcx # 0x152d44
cmpq $0x0, %rdx
cmovneq %rcx, %rax
movq %rax, -0x30(%rbp)
leaq 0xba60a5(%rip), %rdi # 0xc81734
leaq -0x306(%rip), %rsi # 0xdb390
callq 0x2a240
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xdb730
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0xdb6b7
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xdb71a
leaq 0x289912(%rip), %rax # 0x364fd0
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rsi
leaq 0x2898fc(%rip), %rdi # 0x364fd0
leaq 0x77679(%rip), %rdx # 0x152d54
callq *%rax
cmpl $0x0, %eax
jne 0xdb6ec
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xdb6f4
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0xdb6f4
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xdb713
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xdb730
movl %eax, -0x4(%rbp)
jmp 0xdb71a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| get_charset_number:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov rdx, [rbp+var_20]
and rdx, 400h
lea rax, aUtf8mb4; "utf8mb4"
lea rcx, aUtf8mb3; "utf8mb3"
cmp rdx, 0
cmovnz rax, rcx
mov [rbp+var_30], rax
lea rdi, charsets_initialized
lea rsi, init_available_charsets
call _pthread_once
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
call get_charset_number_internal
mov [rbp+var_24], eax
cmp eax, 0
jz short loc_DB6B7
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
jmp short loc_DB71A
loc_DB6B7:
lea rax, my_charset_latin1
mov rax, [rax+0C0h]
mov rax, [rax+40h]
mov rsi, [rbp+var_10]
lea rdi, my_charset_latin1
lea rdx, aUtf8; "utf8"
call rax
cmp eax, 0
jnz short loc_DB6EC
mov rax, [rbp+var_30]
mov [rbp+var_38], rax
jmp short loc_DB6F4
loc_DB6EC:
xor eax, eax
mov [rbp+var_38], rax
jmp short $+2
loc_DB6F4:
mov rax, [rbp+var_38]
mov [rbp+var_10], rax
cmp rax, 0
jz short loc_DB713
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
call get_charset_number_internal
mov [rbp+var_4], eax
jmp short loc_DB71A
loc_DB713:
mov [rbp+var_4], 0
loc_DB71A:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
| long long get_charset_number(long long a1, unsigned int a2, __int16 a3)
{
const char *v3; // rax
const char *v5; // [rsp+8h] [rbp-38h]
const char *v6; // [rsp+10h] [rbp-30h]
unsigned int charset_number_internal; // [rsp+1Ch] [rbp-24h]
v3 = "utf8mb4";
if ( (a3 & 0x400) != 0 )
v3 = "utf8mb3";
v6 = v3;
pthread_once(&charsets_initialized, init_available_charsets);
charset_number_internal = get_charset_number_internal(a1, a2);
if ( charset_number_internal )
{
return charset_number_internal;
}
else
{
if ( (*(unsigned int ( **)(void *, long long, const char *))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
a1,
"utf8") )
{
v5 = 0LL;
}
else
{
v5 = v6;
}
if ( v5 )
return (unsigned int)get_charset_number_internal(v5, a2);
else
return 0;
}
}
| get_charset_number:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV RDX,qword ptr [RBP + -0x20]
AND RDX,0x400
LEA RAX,[0x252d4c]
LEA RCX,[0x252d44]
CMP RDX,0x0
CMOVNZ RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
LEA RDI,[0xd81734]
LEA RSI,[0x1db390]
CALL 0x0012a240
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
CALL 0x001db730
MOV dword ptr [RBP + -0x24],EAX
CMP EAX,0x0
JZ 0x001db6b7
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001db71a
LAB_001db6b7:
LEA RAX,[0x464fd0]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDI,[0x464fd0]
LEA RDX,[0x252d54]
CALL RAX
CMP EAX,0x0
JNZ 0x001db6ec
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001db6f4
LAB_001db6ec:
XOR EAX,EAX
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001db6f4
LAB_001db6f4:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x10],RAX
CMP RAX,0x0
JZ 0x001db713
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
CALL 0x001db730
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001db71a
LAB_001db713:
MOV dword ptr [RBP + -0x4],0x0
LAB_001db71a:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int get_charset_number(int8 param_1,int4 param_2,ulong param_3)
{
int iVar1;
char *local_40;
int local_c;
local_40 = "utf8mb4";
if ((param_3 & 0x400) != 0) {
local_40 = "utf8mb3";
}
pthread_once(&charsets_initialized,init_available_charsets);
local_c = get_charset_number_internal(param_1,param_2);
if (local_c == 0) {
iVar1 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_00465090 + 0x40))
(&my_charset_latin1,param_1,&DAT_00252d54);
if (iVar1 != 0) {
local_40 = (char *)0x0;
}
if (local_40 == (char *)0x0) {
local_c = 0;
}
else {
local_c = get_charset_number_internal(local_40,param_2);
}
}
return local_c;
}
| |
41,292 | pocketflow::BaseNode<std::nullptr_t, std::optional<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::internalRun(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::any, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::any>>>&) | The-Pocket[P]PocketFlow-CPP/pocketflow.h | std::optional<std::string> internalRun(Context& sharedContext) override {
P prepRes = prep(sharedContext);
E execRes = internalExec(std::move(prepRes)); // Use move if P is movable
// Need to handle void return type E potentially
if constexpr (std::is_same_v<E, void>) {
return post(sharedContext, prepRes, {}); // Pass dummy value for void E
} else {
return post(sharedContext, prepRes, execRes);
}
} | O0 | c | pocketflow::BaseNode<std::nullptr_t, std::optional<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::internalRun(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::any, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::any>>>&):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x50(%rax)
movq -0x30(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
movq (%rdi), %rax
callq *0x68(%rax)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdx
movq (%rsi), %rax
leaq -0x1c(%rbp), %rcx
leaq -0x20(%rbp), %r8
callq *0x60(%rax)
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZN10pocketflow8BaseNodeIiiE11internalRunERSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt3anySt4lessIS8_ESaISt4pairIKS8_S9_EEE:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov rax, rdi
mov [rbp+var_28], rax
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rdi, [rbp+var_10]
mov [rbp+var_30], rdi
mov rsi, [rbp+var_18]
mov rax, [rdi]
call qword ptr [rax+50h]
mov rdi, [rbp+var_30]
mov [rbp+var_1C], eax
mov esi, [rbp+var_1C]
mov rax, [rdi]
call qword ptr [rax+68h]
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_30]
mov [rbp+var_20], eax
mov rdx, [rbp+var_18]
mov rax, [rsi]
lea rcx, [rbp+var_1C]
lea r8, [rbp+var_20]
call qword ptr [rax+60h]
mov rax, [rbp+var_28]
add rsp, 40h
pop rbp
retn
| long long pocketflow::BaseNode<int,int>::internalRun(long long a1, long long a2, long long a3)
{
int v5; // [rsp+20h] [rbp-20h] BYREF
unsigned int v6; // [rsp+24h] [rbp-1Ch] BYREF
long long v7; // [rsp+28h] [rbp-18h]
long long v8; // [rsp+30h] [rbp-10h]
long long v9; // [rsp+38h] [rbp-8h]
v9 = a1;
v8 = a2;
v7 = a3;
v6 = (*(long long ( **)(long long, long long))(*(_QWORD *)a2 + 80LL))(a2, a3);
v5 = (*(long long ( **)(long long, _QWORD))(*(_QWORD *)a2 + 104LL))(a2, v6);
(*(void ( **)(long long, long long, long long, unsigned int *, int *))(*(_QWORD *)a2 + 96LL))(
a1,
a2,
v7,
&v6,
&v5);
return a1;
}
| internalRun:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0x28],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RDI,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RDI
MOV RSI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x50]
MOV RDI,qword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x1c],EAX
MOV ESI,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x68]
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x20],EAX
MOV RDX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RSI]
LEA RCX,[RBP + -0x1c]
LEA R8,[RBP + -0x20]
CALL qword ptr [RAX + 0x60]
MOV RAX,qword ptr [RBP + -0x28]
ADD RSP,0x40
POP RBP
RET
|
/* pocketflow::BaseNode<int, int>::internalRun(std::map<std::__cxx11::string, std::any,
std::less<std::__cxx11::string >, std::allocator<std::pair<std::__cxx11::string const, std::any>
> >&) */
map * pocketflow::BaseNode<int,int>::internalRun(map *param_1)
{
int8 in_RDX;
long *in_RSI;
int4 local_28;
int4 local_24;
int8 local_20;
map *local_10;
local_20 = in_RDX;
local_10 = param_1;
local_24 = (**(code **)(*in_RSI + 0x50))(in_RSI,in_RDX);
local_28 = (**(code **)(*in_RSI + 0x68))(in_RSI,local_24);
(**(code **)(*in_RSI + 0x60))(param_1,in_RSI,local_20,&local_24,&local_28);
return param_1;
}
| |
41,293 | pocketflow::BaseNode<std::nullptr_t, std::optional<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::internalRun(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::any, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::any>>>&) | The-Pocket[P]PocketFlow-CPP/pocketflow.h | std::optional<std::string> internalRun(Context& sharedContext) override {
P prepRes = prep(sharedContext);
E execRes = internalExec(std::move(prepRes)); // Use move if P is movable
// Need to handle void return type E potentially
if constexpr (std::is_same_v<E, void>) {
return post(sharedContext, prepRes, {}); // Pass dummy value for void E
} else {
return post(sharedContext, prepRes, execRes);
}
} | O1 | c | pocketflow::BaseNode<std::nullptr_t, std::optional<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::internalRun(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::any, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::any>>>&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq %rsi, %rdi
movq %rdx, %rsi
callq *0x50(%rax)
leaq 0xc(%rsp), %r12
movl %eax, (%r12)
movq (%r14), %rcx
movq %r14, %rdi
movl %eax, %esi
callq *0x68(%rcx)
leaq 0x10(%rsp), %r8
movq %rax, (%r8)
movq (%r14), %rax
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq *0x60(%rax)
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| _ZN10pocketflow8BaseNodeIiDnE11internalRunERSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt3anySt4lessIS8_ESaISt4pairIKS8_S9_EEE:
push r15
push r14
push r12
push rbx
sub rsp, 18h
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rax, [rsi]
mov rdi, rsi
mov rsi, rdx
call qword ptr [rax+50h]
lea r12, [rsp+38h+var_2C]
mov [r12], eax
mov rcx, [r14]
mov rdi, r14
mov esi, eax
call qword ptr [rcx+68h]
lea r8, [rsp+38h+var_28]
mov [r8], rax
mov rax, [r14]
mov rdi, r15
mov rsi, r14
mov rdx, rbx
mov rcx, r12
call qword ptr [rax+60h]
mov rax, r15
add rsp, 18h
pop rbx
pop r12
pop r14
pop r15
retn
| long long pocketflow::BaseNode<int,decltype(nullptr)>::internalRun(long long a1, long long a2, long long a3)
{
unsigned int v6; // [rsp+Ch] [rbp-2Ch] BYREF
long long v7; // [rsp+10h] [rbp-28h]
v6 = (*(long long ( **)(long long, long long))(*(_QWORD *)a2 + 80LL))(a2, a3);
v7 = (*(long long ( **)(long long, _QWORD))(*(_QWORD *)a2 + 104LL))(a2, v6);
(*(void ( **)(long long, long long, long long, unsigned int *))(*(_QWORD *)a2 + 96LL))(a1, a2, a3, &v6);
return a1;
}
| internalRun:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RAX,qword ptr [RSI]
MOV RDI,RSI
MOV RSI,RDX
CALL qword ptr [RAX + 0x50]
LEA R12,[RSP + 0xc]
MOV dword ptr [R12],EAX
MOV RCX,qword ptr [R14]
MOV RDI,R14
MOV ESI,EAX
CALL qword ptr [RCX + 0x68]
LEA R8,[RSP + 0x10]
MOV qword ptr [R8],RAX
MOV RAX,qword ptr [R14]
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
MOV RCX,R12
CALL qword ptr [RAX + 0x60]
MOV RAX,R15
ADD RSP,0x18
POP RBX
POP R12
POP R14
POP R15
RET
|
/* pocketflow::BaseNode<int, decltype(nullptr)>::internalRun(std::map<std::__cxx11::string,
std::any, std::less<std::__cxx11::string >, std::allocator<std::pair<std::__cxx11::string const,
std::any> > >&) */
map * pocketflow::BaseNode<int,decltype(nullptr)>::internalRun(map *param_1)
{
long *in_RSI;
(**(code **)(*in_RSI + 0x50))();
(**(code **)(*in_RSI + 0x68))();
(**(code **)(*in_RSI + 0x60))(param_1);
return param_1;
}
| |
41,294 | pocketflow::BaseNode<std::nullptr_t, std::optional<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::internalRun(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::any, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::any>>>&) | The-Pocket[P]PocketFlow-CPP/pocketflow.h | std::optional<std::string> internalRun(Context& sharedContext) override {
P prepRes = prep(sharedContext);
E execRes = internalExec(std::move(prepRes)); // Use move if P is movable
// Need to handle void return type E potentially
if constexpr (std::is_same_v<E, void>) {
return post(sharedContext, prepRes, {}); // Pass dummy value for void E
} else {
return post(sharedContext, prepRes, execRes);
}
} | O3 | c | pocketflow::BaseNode<std::nullptr_t, std::optional<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::internalRun(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::any, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::any>>>&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq %rsi, %rdi
movq %rdx, %rsi
callq *0x50(%rax)
leaq 0xc(%rsp), %r12
movl %eax, (%r12)
movq (%r14), %rcx
movq %r14, %rdi
movl %eax, %esi
callq *0x68(%rcx)
leaq 0x10(%rsp), %r8
movq %rax, (%r8)
movq (%r14), %rax
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq *0x60(%rax)
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| _ZN10pocketflow8BaseNodeIiDnE11internalRunERSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt3anySt4lessIS8_ESaISt4pairIKS8_S9_EEE:
push r15
push r14
push r12
push rbx
sub rsp, 18h
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rax, [rsi]
mov rdi, rsi
mov rsi, rdx
call qword ptr [rax+50h]
lea r12, [rsp+38h+var_2C]
mov [r12], eax
mov rcx, [r14]
mov rdi, r14
mov esi, eax
call qword ptr [rcx+68h]
lea r8, [rsp+38h+var_28]
mov [r8], rax
mov rax, [r14]
mov rdi, r15
mov rsi, r14
mov rdx, rbx
mov rcx, r12
call qword ptr [rax+60h]
mov rax, r15
add rsp, 18h
pop rbx
pop r12
pop r14
pop r15
retn
| long long pocketflow::BaseNode<int,decltype(nullptr)>::internalRun(long long a1, long long a2, long long a3)
{
unsigned int v6; // [rsp+Ch] [rbp-2Ch] BYREF
long long v7; // [rsp+10h] [rbp-28h]
v6 = (*(long long ( **)(long long, long long))(*(_QWORD *)a2 + 80LL))(a2, a3);
v7 = (*(long long ( **)(long long, _QWORD))(*(_QWORD *)a2 + 104LL))(a2, v6);
(*(void ( **)(long long, long long, long long, unsigned int *))(*(_QWORD *)a2 + 96LL))(a1, a2, a3, &v6);
return a1;
}
| internalRun:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RAX,qword ptr [RSI]
MOV RDI,RSI
MOV RSI,RDX
CALL qword ptr [RAX + 0x50]
LEA R12,[RSP + 0xc]
MOV dword ptr [R12],EAX
MOV RCX,qword ptr [R14]
MOV RDI,R14
MOV ESI,EAX
CALL qword ptr [RCX + 0x68]
LEA R8,[RSP + 0x10]
MOV qword ptr [R8],RAX
MOV RAX,qword ptr [R14]
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
MOV RCX,R12
CALL qword ptr [RAX + 0x60]
MOV RAX,R15
ADD RSP,0x18
POP RBX
POP R12
POP R14
POP R15
RET
|
/* pocketflow::BaseNode<int, decltype(nullptr)>::internalRun(std::map<std::__cxx11::string,
std::any, std::less<std::__cxx11::string >, std::allocator<std::pair<std::__cxx11::string const,
std::any> > >&) */
map * pocketflow::BaseNode<int,decltype(nullptr)>::internalRun(map *param_1)
{
long *in_RSI;
(**(code **)(*in_RSI + 0x50))();
(**(code **)(*in_RSI + 0x68))();
(**(code **)(*in_RSI + 0x60))(param_1);
return param_1;
}
| |
41,295 | ma_write_clr | eloqsql/storage/maria/ma_key_recover.c | my_bool _ma_write_clr(MARIA_HA *info, LSN undo_lsn,
enum translog_record_type undo_type,
my_bool store_checksum, ha_checksum checksum,
LSN *res_lsn, void *extra_msg)
{
uchar log_data[LSN_STORE_SIZE + FILEID_STORE_SIZE + CLR_TYPE_STORE_SIZE +
HA_CHECKSUM_STORE_SIZE+ KEY_NR_STORE_SIZE + PAGE_STORE_SIZE];
uchar *log_pos;
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 1];
struct st_msg_to_write_hook_for_clr_end msg;
my_bool res;
DBUG_ENTER("_ma_write_clr");
/* undo_lsn must be first for compression to work */
lsn_store(log_data, undo_lsn);
clr_type_store(log_data + LSN_STORE_SIZE + FILEID_STORE_SIZE, undo_type);
log_pos= log_data + LSN_STORE_SIZE + FILEID_STORE_SIZE + CLR_TYPE_STORE_SIZE;
/* Extra_msg is handled in write_hook_for_clr_end() */
msg.undone_record_type= undo_type;
msg.previous_undo_lsn= undo_lsn;
msg.extra_msg= extra_msg;
msg.checksum_delta= 0;
if (store_checksum)
{
msg.checksum_delta= checksum;
ha_checksum_store(log_pos, checksum);
log_pos+= HA_CHECKSUM_STORE_SIZE;
}
else if (undo_type == LOGREC_UNDO_KEY_INSERT_WITH_ROOT ||
undo_type == LOGREC_UNDO_KEY_DELETE_WITH_ROOT)
{
/* Key root changed. Store new key root */
struct st_msg_to_write_hook_for_undo_key *undo_msg= extra_msg;
pgcache_page_no_t page;
key_nr_store(log_pos, undo_msg->keynr);
page= (undo_msg->value == HA_OFFSET_ERROR ? IMPOSSIBLE_PAGE_NO :
undo_msg->value / info->s->block_size);
page_store(log_pos + KEY_NR_STORE_SIZE, page);
log_pos+= KEY_NR_STORE_SIZE + PAGE_STORE_SIZE;
}
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= (uint) (log_pos - log_data);
/*
We need intern_lock mutex for calling _ma_state_info_write in the trigger.
We do it here to have the same sequence of mutexes locking everywhere
(first intern_lock then transactional log buffer lock)
*/
if (undo_type == LOGREC_UNDO_BULK_INSERT)
mysql_mutex_lock(&info->s->intern_lock);
res= translog_write_record(res_lsn, LOGREC_CLR_END,
info->trn, info,
(translog_size_t)
log_array[TRANSLOG_INTERNAL_PARTS + 0].length,
TRANSLOG_INTERNAL_PARTS + 1, log_array,
log_data + LSN_STORE_SIZE, &msg);
if (undo_type == LOGREC_UNDO_BULK_INSERT)
mysql_mutex_unlock(&info->s->intern_lock);
DBUG_RETURN(res);
} | O0 | c | ma_write_clr:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movb %cl, %al
movq 0x10(%rbp), %rcx
movq %fs:0x28, %rcx
movq %rcx, -0x8(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movl %edx, -0x34(%rbp)
movb %al, -0x35(%rbp)
movl %r8d, -0x3c(%rbp)
movq %r9, -0x48(%rbp)
jmp 0x441d6
movq -0x30(%rbp), %rax
sarq $0x20, %rax
movb %al, -0x20(%rbp)
movq -0x30(%rbp), %rax
sarq $0x20, %rax
shrl $0x8, %eax
movb %al, -0x1f(%rbp)
movq -0x30(%rbp), %rax
sarq $0x20, %rax
shrl $0x10, %eax
movb %al, -0x1e(%rbp)
jmp 0x441ff
leaq -0x20(%rbp), %rax
addq $0x3, %rax
movq %rax, -0xa8(%rbp)
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0xa8(%rbp), %rax
movl %ecx, (%rax)
jmp 0x44229
movl -0x34(%rbp), %eax
movb %al, -0x17(%rbp)
leaq -0x20(%rbp), %rax
addq $0x7, %rax
addq $0x2, %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x98(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movl $0x0, -0x8c(%rbp)
cmpb $0x0, -0x35(%rbp)
je 0x442a3
movl -0x3c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl -0x3c(%rbp), %ecx
movq -0xb0(%rbp), %rax
movl %ecx, (%rax)
movq -0x50(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x50(%rbp)
jmp 0x44369
cmpl $0x16, -0x34(%rbp)
je 0x442b3
cmpl $0x18, -0x34(%rbp)
jne 0x44367
movq 0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
movl 0x10(%rax), %eax
movb %al, %cl
movq -0x50(%rbp), %rax
movb %cl, (%rax)
movq -0xb8(%rbp), %rax
cmpq $-0x1, 0x8(%rax)
jne 0x442f1
movabsq $0xffffffffff, %rax # imm = 0xFFFFFFFFFF
movq %rax, -0xd0(%rbp)
jmp 0x44315
movq -0xb8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rcx
movl 0x7bc(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0xd0(%rbp)
movq -0xd0(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc8(%rbp)
movq -0xc0(%rbp), %rax
movl %eax, %ecx
movq -0xc8(%rbp), %rax
movl %ecx, (%rax)
movq -0xc0(%rbp), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0xc8(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x50(%rbp), %rax
addq $0x6, %rax
movq %rax, -0x50(%rbp)
jmp 0x44369
leaq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x50(%rbp), %rax
leaq -0x20(%rbp), %rcx
subq %rcx, %rax
movl %eax, %eax
movq %rax, -0x58(%rbp)
cmpl $0x27, -0x34(%rbp)
jne 0x443a7
movq -0x28(%rbp), %rax
movq (%rax), %rdi
addq $0x8f0, %rdi # imm = 0x8F0
leaq 0x10de8d(%rip), %rsi # 0x15222a
movl $0x86, %edx
callq 0x44450
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x28(%rbp), %rcx
movq -0x58(%rbp), %rax
movl %eax, %r8d
leaq -0x80(%rbp), %r11
leaq -0x20(%rbp), %r10
addq $0x7, %r10
movl $0x10, %esi
movl $0x3, %r9d
leaq -0x98(%rbp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x32050
movb %al, -0x99(%rbp)
cmpl $0x27, -0x34(%rbp)
jne 0x4440e
movq -0x28(%rbp), %rax
movq (%rax), %rdi
addq $0x8f0, %rdi # imm = 0x8F0
callq 0x444c0
jmp 0x44410
movb -0x99(%rbp), %al
movb %al, -0xd1(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x4443d
movb -0xd1(%rbp), %al
addq $0xf0, %rsp
popq %rbp
retq
callq 0x2a250
nopw %cs:(%rax,%rax)
| _ma_write_clr:
push rbp
mov rbp, rsp
sub rsp, 0F0h
mov al, cl
mov rcx, [rbp+arg_0]
mov rcx, fs:28h
mov [rbp+var_8], rcx
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_34], edx
mov [rbp+var_35], al
mov [rbp+var_3C], r8d
mov [rbp+var_48], r9
jmp short $+2
loc_441D6:
mov rax, [rbp+var_30]
sar rax, 20h
mov [rbp+var_20], al
mov rax, [rbp+var_30]
sar rax, 20h
shr eax, 8
mov [rbp+var_1F], al
mov rax, [rbp+var_30]
sar rax, 20h
shr eax, 10h
mov [rbp+var_1E], al
jmp short $+2
loc_441FF:
lea rax, [rbp+var_20]
add rax, 3
mov [rbp+var_A8], rax
mov rax, 0FFFFFFFFh
and rax, [rbp+var_30]
mov ecx, eax
mov rax, [rbp+var_A8]
mov [rax], ecx
jmp short $+2
loc_44229:
mov eax, [rbp+var_34]
mov [rbp+var_17], al
lea rax, [rbp+var_20]
add rax, 7
add rax, 2
add rax, 1
mov [rbp+var_50], rax
mov eax, [rbp+var_34]
mov [rbp+var_90], eax
mov rax, [rbp+var_30]
mov [rbp+var_98], rax
mov rax, [rbp+arg_0]
mov [rbp+var_88], rax
mov [rbp+var_8C], 0
cmp [rbp+var_35], 0
jz short loc_442A3
mov eax, [rbp+var_3C]
mov [rbp+var_8C], eax
mov rax, [rbp+var_50]
mov [rbp+var_B0], rax
mov ecx, [rbp+var_3C]
mov rax, [rbp+var_B0]
mov [rax], ecx
mov rax, [rbp+var_50]
add rax, 4
mov [rbp+var_50], rax
jmp loc_44369
loc_442A3:
cmp [rbp+var_34], 16h
jz short loc_442B3
cmp [rbp+var_34], 18h
jnz loc_44367
loc_442B3:
mov rax, [rbp+arg_0]
mov [rbp+var_B8], rax
mov rax, [rbp+var_B8]
mov eax, [rax+10h]
mov cl, al
mov rax, [rbp+var_50]
mov [rax], cl
mov rax, [rbp+var_B8]
cmp qword ptr [rax+8], 0FFFFFFFFFFFFFFFFh
jnz short loc_442F1
mov rax, 0FFFFFFFFFFh
mov [rbp+var_D0], rax
jmp short loc_44315
loc_442F1:
mov rax, [rbp+var_B8]
mov rax, [rax+8]
mov rcx, [rbp+var_28]
mov rcx, [rcx]
mov ecx, [rcx+7BCh]
xor edx, edx
div rcx
mov [rbp+var_D0], rax
loc_44315:
mov rax, [rbp+var_D0]
mov [rbp+var_C0], rax
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_C8], rax
mov rax, [rbp+var_C0]
mov ecx, eax
mov rax, [rbp+var_C8]
mov [rax], ecx
mov rax, [rbp+var_C0]
shr rax, 20h
mov cl, al
mov rax, [rbp+var_C8]
mov [rax+4], cl
mov rax, [rbp+var_50]
add rax, 6
mov [rbp+var_50], rax
loc_44367:
jmp short $+2
loc_44369:
lea rax, [rbp+var_20]
mov [rbp+var_60], rax
mov rax, [rbp+var_50]
lea rcx, [rbp+var_20]
sub rax, rcx
mov eax, eax
mov [rbp+var_58], rax
cmp [rbp+var_34], 27h ; '''
jnz short loc_443A7
mov rax, [rbp+var_28]
mov rdi, [rax]
add rdi, 8F0h
lea rsi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 86h
call inline_mysql_mutex_lock_4
loc_443A7:
mov rdi, [rbp+var_48]
mov rax, [rbp+var_28]
mov rdx, [rax+8]
mov rcx, [rbp+var_28]
mov rax, [rbp+var_58]
mov r8d, eax
lea r11, [rbp+var_80]
lea r10, [rbp+var_20]
add r10, 7
mov esi, 10h
mov r9d, 3
lea rax, [rbp+var_98]
mov [rsp+0F0h+var_F0], r11
mov [rsp+0F0h+var_E8], r10
mov [rsp+0F0h+var_E0], rax
call translog_write_record
mov [rbp+var_99], al
cmp [rbp+var_34], 27h ; '''
jnz short loc_4440E
mov rax, [rbp+var_28]
mov rdi, [rax]
add rdi, 8F0h
call inline_mysql_mutex_unlock_4
loc_4440E:
jmp short $+2
loc_44410:
mov al, [rbp+var_99]
mov [rbp+var_D1], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_4443D
mov al, [rbp+var_D1]
add rsp, 0F0h
pop rbp
retn
loc_4443D:
call ___stack_chk_fail
| char ma_write_clr(long long *a1, long long a2, int a3, char a4, int a5, long long a6, long long a7)
{
unsigned long long v8; // [rsp+20h] [rbp-D0h]
char *v9; // [rsp+28h] [rbp-C8h]
char v10; // [rsp+57h] [rbp-99h]
long long v11; // [rsp+58h] [rbp-98h] BYREF
int v12; // [rsp+60h] [rbp-90h]
int v13; // [rsp+64h] [rbp-8Ch]
long long v14; // [rsp+68h] [rbp-88h]
_QWORD v15[5]; // [rsp+70h] [rbp-80h] BYREF
long long v16; // [rsp+98h] [rbp-58h]
_DWORD *v17; // [rsp+A0h] [rbp-50h]
long long v18; // [rsp+A8h] [rbp-48h]
int v19; // [rsp+B4h] [rbp-3Ch]
char v20; // [rsp+BBh] [rbp-35h]
int v21; // [rsp+BCh] [rbp-34h]
long long v22; // [rsp+C0h] [rbp-30h]
long long *v23; // [rsp+C8h] [rbp-28h]
__int16 v24; // [rsp+D0h] [rbp-20h] BYREF
char v25; // [rsp+D2h] [rbp-1Eh]
int v26; // [rsp+D3h] [rbp-1Dh]
__int16 v27; // [rsp+D7h] [rbp-19h] BYREF
char v28; // [rsp+D9h] [rbp-17h]
_BYTE v29[22]; // [rsp+DAh] [rbp-16h] BYREF
*(_QWORD *)&v29[14] = __readfsqword(0x28u);
v23 = a1;
v22 = a2;
v21 = a3;
v20 = a4;
v19 = a5;
v18 = a6;
v24 = WORD2(a2);
v25 = BYTE6(a2);
v26 = a2;
v28 = a3;
v17 = v29;
v12 = a3;
v11 = a2;
v14 = a7;
v13 = 0;
if ( a4 )
{
v13 = v19;
*v17++ = v19;
}
else if ( v21 == 22 || v21 == 24 )
{
*(_BYTE *)v17 = *(_DWORD *)(a7 + 16);
if ( *(_QWORD *)(a7 + 8) == -1LL )
v8 = 0xFFFFFFFFFFLL;
else
v8 = *(_QWORD *)(a7 + 8) / (unsigned long long)*(unsigned int *)(*v23 + 1980);
v9 = (char *)v17 + 1;
*(_DWORD *)((char *)v17 + 1) = v8;
v9[4] = BYTE4(v8);
v17 = (_DWORD *)((char *)v17 + 6);
}
v15[4] = &v24;
v16 = (unsigned int)v17 - (unsigned int)&v24;
if ( v21 == 39 )
inline_mysql_mutex_lock_4(
*v23 + 2288,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_key_recover.c",
134LL);
v10 = translog_write_record(v18, 0x10u, v23[1], v23, v16, 3u, v15, &v27, (long long)&v11);
if ( v21 == 39 )
inline_mysql_mutex_unlock_4(*v23 + 2288);
return v10;
}
| _ma_write_clr:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xf0
MOV AL,CL
MOV RCX,qword ptr [RBP + 0x10]
MOV RCX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RCX
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV dword ptr [RBP + -0x34],EDX
MOV byte ptr [RBP + -0x35],AL
MOV dword ptr [RBP + -0x3c],R8D
MOV qword ptr [RBP + -0x48],R9
JMP 0x001441d6
LAB_001441d6:
MOV RAX,qword ptr [RBP + -0x30]
SAR RAX,0x20
MOV byte ptr [RBP + -0x20],AL
MOV RAX,qword ptr [RBP + -0x30]
SAR RAX,0x20
SHR EAX,0x8
MOV byte ptr [RBP + -0x1f],AL
MOV RAX,qword ptr [RBP + -0x30]
SAR RAX,0x20
SHR EAX,0x10
MOV byte ptr [RBP + -0x1e],AL
JMP 0x001441ff
LAB_001441ff:
LEA RAX,[RBP + -0x20]
ADD RAX,0x3
MOV qword ptr [RBP + -0xa8],RAX
MOV RAX,0xffffffff
AND RAX,qword ptr [RBP + -0x30]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0xa8]
MOV dword ptr [RAX],ECX
JMP 0x00144229
LAB_00144229:
MOV EAX,dword ptr [RBP + -0x34]
MOV byte ptr [RBP + -0x17],AL
LEA RAX,[RBP + -0x20]
ADD RAX,0x7
ADD RAX,0x2
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x90],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x88],RAX
MOV dword ptr [RBP + -0x8c],0x0
CMP byte ptr [RBP + -0x35],0x0
JZ 0x001442a3
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x8c],EAX
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0xb0],RAX
MOV ECX,dword ptr [RBP + -0x3c]
MOV RAX,qword ptr [RBP + -0xb0]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x4
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00144369
LAB_001442a3:
CMP dword ptr [RBP + -0x34],0x16
JZ 0x001442b3
CMP dword ptr [RBP + -0x34],0x18
JNZ 0x00144367
LAB_001442b3:
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0xb8],RAX
MOV RAX,qword ptr [RBP + -0xb8]
MOV EAX,dword ptr [RAX + 0x10]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x50]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0xb8]
CMP qword ptr [RAX + 0x8],-0x1
JNZ 0x001442f1
MOV RAX,0xffffffffff
MOV qword ptr [RBP + -0xd0],RAX
JMP 0x00144315
LAB_001442f1:
MOV RAX,qword ptr [RBP + -0xb8]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RCX]
MOV ECX,dword ptr [RCX + 0x7bc]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0xd0],RAX
LAB_00144315:
MOV RAX,qword ptr [RBP + -0xd0]
MOV qword ptr [RBP + -0xc0],RAX
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x1
MOV qword ptr [RBP + -0xc8],RAX
MOV RAX,qword ptr [RBP + -0xc0]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0xc8]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0xc0]
SHR RAX,0x20
MOV CL,AL
MOV RAX,qword ptr [RBP + -0xc8]
MOV byte ptr [RAX + 0x4],CL
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x6
MOV qword ptr [RBP + -0x50],RAX
LAB_00144367:
JMP 0x00144369
LAB_00144369:
LEA RAX,[RBP + -0x20]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x50]
LEA RCX,[RBP + -0x20]
SUB RAX,RCX
MOV EAX,EAX
MOV qword ptr [RBP + -0x58],RAX
CMP dword ptr [RBP + -0x34],0x27
JNZ 0x001443a7
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX]
ADD RDI,0x8f0
LEA RSI,[0x25222a]
MOV EDX,0x86
CALL 0x00144450
LAB_001443a7:
MOV RDI,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x58]
MOV R8D,EAX
LEA R11,[RBP + -0x80]
LEA R10,[RBP + -0x20]
ADD R10,0x7
MOV ESI,0x10
MOV R9D,0x3
LEA RAX,[RBP + -0x98]
MOV qword ptr [RSP],R11
MOV qword ptr [RSP + 0x8],R10
MOV qword ptr [RSP + 0x10],RAX
CALL 0x00132050
MOV byte ptr [RBP + -0x99],AL
CMP dword ptr [RBP + -0x34],0x27
JNZ 0x0014440e
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX]
ADD RDI,0x8f0
CALL 0x001444c0
LAB_0014440e:
JMP 0x00144410
LAB_00144410:
MOV AL,byte ptr [RBP + -0x99]
MOV byte ptr [RBP + -0xd1],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0014443d
MOV AL,byte ptr [RBP + -0xd1]
ADD RSP,0xf0
POP RBP
RET
LAB_0014443d:
CALL 0x0012a250
|
int8
_ma_write_clr(long *param_1,int8 param_2,int param_3,char param_4,int4 param_5,
int8 param_6,long param_7)
{
int1 uVar1;
long in_FS_OFFSET;
int1 uStack_d4;
int8 local_a0;
int local_98;
int4 local_94;
long local_90;
int1 local_88 [32];
int1 *local_68;
ulong local_60;
int4 *local_58;
int8 local_50;
int4 local_44;
char local_3d;
int local_3c;
int8 local_38;
long *local_30;
int1 local_28;
int1 local_27;
int1 local_26;
int4 local_25;
int1 auStack_21 [2];
int1 local_1f;
int4 local_1e;
int1 auStack_1a [10];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_28 = (int1)((ulong)param_2 >> 0x20);
local_27 = (int1)((ulong)param_2 >> 0x28);
local_26 = (int1)((ulong)param_2 >> 0x30);
local_25 = (int4)param_2;
local_1f = (int1)param_3;
local_58 = &local_1e;
local_90 = param_7;
local_94 = 0;
if (param_4 == '\0') {
if ((param_3 == 0x16) || (param_3 == 0x18)) {
local_1e = CONCAT31(local_1e._1_3_,(char)*(int4 *)(param_7 + 0x10));
if (*(long *)(param_7 + 8) == -1) {
uStack_d4 = 0xff;
}
else {
uStack_d4 = (int1)
(*(ulong *)(param_7 + 8) / (ulong)*(uint *)(*param_1 + 0x7bc) >> 0x20);
}
auStack_1a[1] = uStack_d4;
local_58 = (int4 *)(auStack_1a + 2);
}
}
else {
local_58 = (int4 *)auStack_1a;
local_94 = param_5;
local_1e = param_5;
}
local_68 = &local_28;
local_60 = (ulong)(uint)((int)local_58 - (int)&local_28);
local_a0 = param_2;
local_98 = param_3;
local_50 = param_6;
local_44 = param_5;
local_3d = param_4;
local_3c = param_3;
local_38 = param_2;
local_30 = param_1;
if (param_3 == 0x27) {
inline_mysql_mutex_lock
(*param_1 + 0x8f0,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_key_recover.c",0x86);
}
uVar1 = translog_write_record
(local_50,0x10,local_30[1],local_30,local_60 & 0xffffffff,3,local_88,auStack_21,
&local_a0);
if (local_3c == 0x27) {
inline_mysql_mutex_unlock(*local_30 + 0x8f0);
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),uVar1);
}
| |
41,296 | File::Rename(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&) | Dolphin-anty/Source/Core/Common/FileUtil.cpp | bool Rename(const std::string& srcFilename, const std::string& destFilename)
{
DEBUG_LOG_FMT(COMMON, "{}: {} --> {}", __func__, srcFilename, destFilename);
std::error_code error;
std::filesystem::rename(StringToPath(srcFilename), StringToPath(destFilename), error);
if (error)
{
ERROR_LOG_FMT(COMMON, "{} failed: {} --> {}: {}", __func__, srcFilename, destFilename,
error.message());
}
return !error;
} | O0 | cpp | File::Rename(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&):
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
jmp 0x42629
jmp 0x4262b
jmp 0x4262d
leaq 0xc8(%rsp), %rdi
callq 0x475a0
movq 0xe0(%rsp), %rdi
callq 0x129c0
movq %rax, 0x90(%rsp)
movq %rdx, 0x98(%rsp)
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
leaq 0xa0(%rsp), %rdi
callq 0x28f70
movq 0xd8(%rsp), %rdi
callq 0x129c0
movq %rax, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
leaq 0x68(%rsp), %rdi
callq 0x28f70
leaq 0xa0(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0xc8(%rsp), %rdx
callq 0x9af0
leaq 0x68(%rsp), %rdi
callq 0x47640
leaq 0xa0(%rsp), %rdi
callq 0x47640
leaq 0xc8(%rsp), %rdi
callq 0x475d0
testb $0x1, %al
jne 0x426e6
jmp 0x4277b
jmp 0x426e8
jmp 0x426ea
movq $0x4, 0x50(%rsp)
leaq 0x4e(%rsp), %rdi
callq 0x42920
movq 0xe0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x47690
movq 0x18(%rsp), %r11
movq 0x20(%rsp), %r10
movl $0x2, %edi
movl $0x6, %esi
leaq 0x5d936(%rip), %rdx # 0xa007a
movl $0x126, %ecx # imm = 0x126
leaq 0x4f(%rsp), %r8
leaq 0x5d9a8(%rip), %r9 # 0xa00fd
leaq 0x28(%rsp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x427a0
leaq 0x28(%rsp), %rdi
callq 0x12a10
jmp 0x42779
jmp 0x4277b
leaq 0xc8(%rsp), %rdi
callq 0x475d0
xorb $-0x1, %al
andb $0x1, %al
addq $0xe8, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZN4File6RenameERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES7_:
sub rsp, 0E8h
mov [rsp+0E8h+var_8], rdi
mov [rsp+0E8h+var_10], rsi
jmp short $+2
loc_42629:
jmp short $+2
loc_4262B:
jmp short $+2
loc_4262D:
lea rdi, [rsp+0E8h+var_20]; this
call _ZNSt10error_codeC2Ev; std::error_code::error_code(void)
mov rdi, [rsp+0E8h+var_8]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEcvSt17basic_string_viewIcS2_EEv; std::string::operator std::string_view(void)
mov [rsp+0E8h+var_58], rax
mov [rsp+0E8h+var_50], rdx
mov rsi, [rsp+0E8h+var_58]
mov rdx, [rsp+0E8h+var_50]
lea rdi, [rsp+0E8h+var_48]
call _Z12StringToPathB5cxx11St17basic_string_viewIcSt11char_traitsIcEE; StringToPath(std::string_view)
mov rdi, [rsp+0E8h+var_10]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEcvSt17basic_string_viewIcS2_EEv; std::string::operator std::string_view(void)
mov [rsp+0E8h+var_90], rax
mov [rsp+0E8h+var_88], rdx
mov rsi, [rsp+0E8h+var_90]
mov rdx, [rsp+0E8h+var_88]
lea rdi, [rsp+0E8h+var_80]
call _Z12StringToPathB5cxx11St17basic_string_viewIcSt11char_traitsIcEE; StringToPath(std::string_view)
lea rdi, [rsp+0E8h+var_48]; this
lea rsi, [rsp+0E8h+var_80]; std::filesystem::__cxx11::path *
lea rdx, [rsp+0E8h+var_20]; std::filesystem::__cxx11::path *
call __ZNSt10filesystem6renameERKNS_7__cxx114pathES3_RSt10error_code; std::filesystem::rename(std::filesystem::__cxx11::path const&,std::filesystem::__cxx11::path const&,std::error_code &)
lea rdi, [rsp+0E8h+var_80]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
lea rdi, [rsp+0E8h+var_48]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
lea rdi, [rsp+0E8h+var_20]
call _ZNKSt10error_codecvbEv; std::error_code::operator bool(void)
test al, 1
jnz short loc_426E6
jmp loc_4277B
loc_426E6:
jmp short $+2
loc_426E8:
jmp short $+2
loc_426EA:
mov [rsp+0E8h+var_98], 4
lea rdi, [rsp+0E8h+var_9A]
call _ZZN4File6RenameERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES7_ENK3$_1clEv; File::Rename(std::string const&,std::string const&)::$_1::operator()(void)
mov rax, [rsp+0E8h+var_8]
mov [rsp+0E8h+var_D0], rax
mov rax, [rsp+0E8h+var_10]
mov [rsp+0E8h+var_C8], rax
lea rdi, [rsp+0E8h+var_C0]
lea rsi, [rsp+0E8h+var_20]
call _ZNKSt10error_code7messageB5cxx11Ev; std::error_code::message(void)
mov r11, [rsp+0E8h+var_D0]
mov r10, [rsp+0E8h+var_C8]
mov edi, 2
mov esi, 6
lea rdx, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/Dolphi"...
mov ecx, 126h
lea r8, [rsp+0E8h+var_99]
lea r9, aRename; "Rename"
lea rax, [rsp+0E8h+var_C0]
mov [rsp+0E8h+var_E8], r11
mov [rsp+0E8h+var_E0], r10
mov [rsp+0E8h+var_D8], rax
call _ZN6Common3Log13GenericLogFmtILm4EZZN4File6RenameERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESA_ENK3$_1clEvE18FMT_COMPILE_STRINGJA7_cS8_S8_S8_EEEvNS0_8LogLevelENS0_7LogTypeEPKciRKT0_DpRKT1_; Common::Log::GenericLogFmt<4ul,File::Rename(std::string const&,std::string const&)::$_1::operator() const(void)::FMT_COMPILE_STRING,char [7],std::string,std::string,std::string>(Common::Log::LogLevel,Common::Log::LogType,char const*,int,File::Rename(std::string const&,std::string const&)::$_1::operator() const(void)::FMT_COMPILE_STRING const&,char [7],std::string,std::string,std::string const&)
lea rdi, [rsp+0E8h+var_C0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short $+2
loc_42779:
jmp short $+2
loc_4277B:
lea rdi, [rsp+0E8h+var_20]
call _ZNKSt10error_codecvbEv; std::error_code::operator bool(void)
xor al, 0FFh
and al, 1
add rsp, 0E8h
retn
| bool File::Rename(long long a1, long long a2)
{
long long v2; // rdx
long long v3; // rdx
std::error_code *v4; // rcx
long long v6; // [rsp+18h] [rbp-D0h]
long long v7; // [rsp+20h] [rbp-C8h]
_BYTE v8[38]; // [rsp+28h] [rbp-C0h] BYREF
char v9; // [rsp+4Eh] [rbp-9Ah] BYREF
char v10; // [rsp+4Fh] [rbp-99h] BYREF
long long v11; // [rsp+50h] [rbp-98h]
long long v12; // [rsp+58h] [rbp-90h]
long long v13; // [rsp+60h] [rbp-88h]
_BYTE v14[40]; // [rsp+68h] [rbp-80h] BYREF
long long v15; // [rsp+90h] [rbp-58h]
long long v16; // [rsp+98h] [rbp-50h]
_BYTE v17[40]; // [rsp+A0h] [rbp-48h] BYREF
_BYTE v18[16]; // [rsp+C8h] [rbp-20h] BYREF
long long v19; // [rsp+D8h] [rbp-10h]
long long v20; // [rsp+E0h] [rbp-8h]
v20 = a1;
v19 = a2;
std::error_code::error_code((std::error_code *)v18);
v15 = std::string::operator std::string_view(v20);
v16 = v2;
StringToPath[abi:cxx11]((long long)v17, v15, v2);
v12 = std::string::operator std::string_view(v19);
v13 = v3;
StringToPath[abi:cxx11]((long long)v14, v12, v3);
std::filesystem::rename(
(std::filesystem *)v17,
(const std::filesystem::__cxx11::path *)v14,
(const std::filesystem::__cxx11::path *)v18,
v4);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)v14);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)v17);
if ( (std::error_code::operator bool(v18) & 1) != 0 )
{
v11 = 4LL;
File::Rename(std::string const&,std::string const&)::$_1::operator()(&v9);
v6 = v20;
v7 = v19;
std::error_code::message[abi:cxx11](v8, v18);
Common::Log::GenericLogFmt<4ul,File::Rename(std::string const&,std::string const&)::$_1::operator() const(void)::FMT_COMPILE_STRING,char [7],std::string,std::string,std::string>(
2,
6,
(unsigned int)"/workspace/llm4binary/github2025/Dolphin-anty/Source/Core/Common/FileUtil.cpp",
294,
(unsigned int)&v10,
(unsigned int)"Rename",
v6,
v7,
(long long)v8);
std::string::~string(v8);
}
return (std::error_code::operator bool(v18) & 1) == 0;
}
| Rename:
SUB RSP,0xe8
MOV qword ptr [RSP + 0xe0],RDI
MOV qword ptr [RSP + 0xd8],RSI
JMP 0x00142629
LAB_00142629:
JMP 0x0014262b
LAB_0014262b:
JMP 0x0014262d
LAB_0014262d:
LEA RDI,[RSP + 0xc8]
CALL 0x001475a0
MOV RDI,qword ptr [RSP + 0xe0]
CALL 0x001129c0
MOV qword ptr [RSP + 0x90],RAX
MOV qword ptr [RSP + 0x98],RDX
MOV RSI,qword ptr [RSP + 0x90]
MOV RDX,qword ptr [RSP + 0x98]
LEA RDI,[RSP + 0xa0]
CALL 0x00128f70
MOV RDI,qword ptr [RSP + 0xd8]
CALL 0x001129c0
MOV qword ptr [RSP + 0x58],RAX
MOV qword ptr [RSP + 0x60],RDX
MOV RSI,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x60]
LEA RDI,[RSP + 0x68]
CALL 0x00128f70
LEA RDI,[RSP + 0xa0]
LEA RSI,[RSP + 0x68]
LEA RDX,[RSP + 0xc8]
CALL 0x00109af0
LEA RDI,[RSP + 0x68]
CALL 0x00147640
LEA RDI,[RSP + 0xa0]
CALL 0x00147640
LEA RDI,[RSP + 0xc8]
CALL 0x001475d0
TEST AL,0x1
JNZ 0x001426e6
JMP 0x0014277b
LAB_001426e6:
JMP 0x001426e8
LAB_001426e8:
JMP 0x001426ea
LAB_001426ea:
MOV qword ptr [RSP + 0x50],0x4
LEA RDI,[RSP + 0x4e]
CALL 0x00142920
MOV RAX,qword ptr [RSP + 0xe0]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0xd8]
MOV qword ptr [RSP + 0x20],RAX
LEA RDI,[RSP + 0x28]
LEA RSI,[RSP + 0xc8]
CALL 0x00147690
MOV R11,qword ptr [RSP + 0x18]
MOV R10,qword ptr [RSP + 0x20]
MOV EDI,0x2
MOV ESI,0x6
LEA RDX,[0x1a007a]
MOV ECX,0x126
LEA R8,[RSP + 0x4f]
LEA R9,[0x1a00fd]
LEA RAX,[RSP + 0x28]
MOV qword ptr [RSP],R11
MOV qword ptr [RSP + 0x8],R10
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001427a0
LEA RDI,[RSP + 0x28]
CALL 0x00112a10
JMP 0x00142779
LAB_00142779:
JMP 0x0014277b
LAB_0014277b:
LEA RDI,[RSP + 0xc8]
CALL 0x001475d0
XOR AL,0xff
AND AL,0x1
ADD RSP,0xe8
RET
|
/* File::Rename(std::__cxx11::string const&, std::__cxx11::string const&) */
ulong File::Rename(string *param_1,string *param_2)
{
string *psVar1;
string *psVar2;
bool bVar3;
int7 extraout_var;
string local_c0 [38];
__1 local_9a;
int1 local_99;
int8 local_98;
int1 local_90 [16];
path local_80 [40];
int1 local_58 [16];
path local_48 [40];
error_code local_20 [16];
string *local_10;
string *local_8;
local_10 = param_2;
local_8 = param_1;
std::error_code::error_code(local_20);
local_58 = std::__cxx11::string::operator_cast_to_basic_string_view(local_8);
StringToPath_abi_cxx11_(local_48,local_58._0_8_,local_58._8_8_);
local_90 = std::__cxx11::string::operator_cast_to_basic_string_view(local_10);
StringToPath_abi_cxx11_(local_80,local_90._0_8_,local_90._8_8_);
std::filesystem::rename(local_48,local_80,local_20);
std::filesystem::__cxx11::path::~path(local_80);
std::filesystem::__cxx11::path::~path(local_48);
bVar3 = std::error_code::operator_cast_to_bool(local_20);
if (bVar3) {
local_98 = 4;
Rename(std::__cxx11::string_const&,std::__cxx11::string_const&)::$_1::operator()(&local_9a);
psVar2 = local_8;
psVar1 = local_10;
std::error_code::message_abi_cxx11_();
Common::Log::operator()
(2,6,"/workspace/llm4binary/github2025/Dolphin-anty/Source/Core/Common/FileUtil.cpp",
0x126,&local_99,"Rename",psVar2,psVar1,local_c0);
std::__cxx11::string::~string(local_c0);
}
bVar3 = std::error_code::operator_cast_to_bool(local_20);
return (CONCAT71(extraout_var,bVar3) ^ 0xff) & 0xffffffffffffff01;
}
| |
41,297 | UCIAdapter::handleUCI() | Razamindset[P]pawnstar-chess-engine/src/main.cpp | void handleUCI() {
std::cout << "id name Pawnstar" << std::endl;
std::cout << "id author Razamindset" << std::endl;
// Output available options if any
// std::cout << "option name Hash type spin default 64 min 1 max 1024" <<
// std::endl;
std::cout << "uciok" << std::endl;
} | O0 | cpp | UCIAdapter::handleUCI():
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x22e1d(%rip), %rdi # 0x30fc0
leaq 0x14c35(%rip), %rsi # 0x22ddf
callq 0x32c0
movq %rax, %rdi
movq 0x22def(%rip), %rsi # 0x30fa8
callq 0x3300
movq 0x22dfb(%rip), %rdi # 0x30fc0
leaq 0x14c24(%rip), %rsi # 0x22df0
callq 0x32c0
movq %rax, %rdi
movq 0x22dcd(%rip), %rsi # 0x30fa8
callq 0x3300
movq 0x22dd9(%rip), %rdi # 0x30fc0
leaq 0x14c18(%rip), %rsi # 0x22e06
callq 0x32c0
movq %rax, %rdi
movq 0x22dab(%rip), %rsi # 0x30fa8
callq 0x3300
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZN10UCIAdapter9handleUCIEv:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, cs:_ZSt4cout_ptr
lea rsi, aIdNamePawnstar; "id name Pawnstar"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
mov rsi, cs:_ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6__ptr
call __ZNSolsEPFRSoS_E; std::ostream::operator<<(std::ostream & (*)(std::ostream &))
mov rdi, cs:_ZSt4cout_ptr
lea rsi, aIdAuthorRazami; "id author Razamindset"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
mov rsi, cs:_ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6__ptr
call __ZNSolsEPFRSoS_E; std::ostream::operator<<(std::ostream & (*)(std::ostream &))
mov rdi, cs:_ZSt4cout_ptr
lea rsi, aUciok; "uciok"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
mov rsi, cs:_ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6__ptr
call __ZNSolsEPFRSoS_E; std::ostream::operator<<(std::ostream & (*)(std::ostream &))
add rsp, 10h
pop rbp
retn
| long long UCIAdapter::handleUCI(UCIAdapter *this)
{
long long v1; // rax
long long v2; // rax
long long v3; // rax
v1 = std::operator<<<std::char_traits<char>>(&std::cout, "id name Pawnstar");
std::ostream::operator<<(v1, &std::endl<char,std::char_traits<char>>);
v2 = std::operator<<<std::char_traits<char>>(&std::cout, "id author Razamindset");
std::ostream::operator<<(v2, &std::endl<char,std::char_traits<char>>);
v3 = std::operator<<<std::char_traits<char>>(&std::cout, "uciok");
return std::ostream::operator<<(v3, &std::endl<char,std::char_traits<char>>);
}
| handleUCI:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [0x00130fc0]
LEA RSI,[0x122ddf]
CALL 0x001032c0
MOV RDI,RAX
MOV RSI,qword ptr [0x00130fa8]
CALL 0x00103300
MOV RDI,qword ptr [0x00130fc0]
LEA RSI,[0x122df0]
CALL 0x001032c0
MOV RDI,RAX
MOV RSI,qword ptr [0x00130fa8]
CALL 0x00103300
MOV RDI,qword ptr [0x00130fc0]
LEA RSI,[0x122e06]
CALL 0x001032c0
MOV RDI,RAX
MOV RSI,qword ptr [0x00130fa8]
CALL 0x00103300
ADD RSP,0x10
POP RBP
RET
|
/* UCIAdapter::handleUCI() */
void UCIAdapter::handleUCI(void)
{
ostream *poVar1;
poVar1 = std::operator<<((ostream *)PTR_cout_00130fc0,"id name Pawnstar");
std::ostream::operator<<
(poVar1,(_func_ostream_ptr_ostream_ptr *)PTR_endl<char,std_char_traits<char>>_00130fa8);
poVar1 = std::operator<<((ostream *)PTR_cout_00130fc0,"id author Razamindset");
std::ostream::operator<<
(poVar1,(_func_ostream_ptr_ostream_ptr *)PTR_endl<char,std_char_traits<char>>_00130fa8);
poVar1 = std::operator<<((ostream *)PTR_cout_00130fc0,"uciok");
std::ostream::operator<<
(poVar1,(_func_ostream_ptr_ostream_ptr *)PTR_endl<char,std_char_traits<char>>_00130fa8);
return;
}
| |
41,298 | UCIAdapter::handleUCI() | Razamindset[P]pawnstar-chess-engine/src/main.cpp | void handleUCI() {
std::cout << "id name Pawnstar" << std::endl;
std::cout << "id author Razamindset" << std::endl;
// Output available options if any
// std::cout << "option name Hash type spin default 64 min 1 max 1024" <<
// std::endl;
std::cout << "uciok" << std::endl;
} | O2 | cpp | UCIAdapter::handleUCI():
pushq %rbx
movq 0x109d0(%rip), %rbx # 0x15fc0
leaq 0x878e(%rip), %rsi # 0xdd85
movq %rbx, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x20f0
leaq 0x8788(%rip), %rsi # 0xdd96
movq %rbx, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x20f0
leaq 0x8787(%rip), %rsi # 0xddac
movq %rbx, %rdi
callq 0x2220
movq %rax, %rdi
popq %rbx
jmp 0x20f0
| _ZN10UCIAdapter9handleUCIEv:
push rbx
mov rbx, cs:_ZSt4cout_ptr
lea rsi, aIdNamePawnstar; "id name Pawnstar"
mov rdi, rbx
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
call __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_; std::endl<char,std::char_traits<char>>(std::ostream &)
lea rsi, aIdAuthorRazami; "id author Razamindset"
mov rdi, rbx
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
call __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_; std::endl<char,std::char_traits<char>>(std::ostream &)
lea rsi, aUciok; "uciok"
mov rdi, rbx
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
pop rbx
jmp __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_; std::endl<char,std::char_traits<char>>(std::ostream &)
| long long UCIAdapter::handleUCI(UCIAdapter *this)
{
long long v1; // rax
long long v2; // rax
long long v3; // rax
v1 = std::operator<<<std::char_traits<char>>(&std::cout, "id name Pawnstar");
std::endl<char,std::char_traits<char>>(v1);
v2 = std::operator<<<std::char_traits<char>>(&std::cout, "id author Razamindset");
std::endl<char,std::char_traits<char>>(v2);
v3 = std::operator<<<std::char_traits<char>>(&std::cout, "uciok");
return std::endl<char,std::char_traits<char>>(v3);
}
| handleUCI:
PUSH RBX
MOV RBX,qword ptr [0x00115fc0]
LEA RSI,[0x10dd85]
MOV RDI,RBX
CALL 0x00102220
MOV RDI,RAX
CALL 0x001020f0
LEA RSI,[0x10dd96]
MOV RDI,RBX
CALL 0x00102220
MOV RDI,RAX
CALL 0x001020f0
LEA RSI,[0x10ddac]
MOV RDI,RBX
CALL 0x00102220
MOV RDI,RAX
POP RBX
JMP 0x001020f0
|
/* UCIAdapter::handleUCI() */
void UCIAdapter::handleUCI(void)
{
int *puVar1;
ostream *poVar2;
puVar1 = PTR_cout_00115fc0;
poVar2 = std::operator<<((ostream *)PTR_cout_00115fc0,"id name Pawnstar");
std::endl<char,std::char_traits<char>>(poVar2);
poVar2 = std::operator<<((ostream *)puVar1,"id author Razamindset");
std::endl<char,std::char_traits<char>>(poVar2);
poVar2 = std::operator<<((ostream *)puVar1,"uciok");
std::endl<char,std::char_traits<char>>(poVar2);
return;
}
| |
41,299 | minja::IfExpr::IfExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::Expression>&&) | monkey531[P]llama/common/minja.hpp | Expression(const Location & location) : location(location) {} | O1 | cpp | minja::IfExpr::IfExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::Expression>&&):
leaq 0x6f3b1(%rip), %rax # 0xe9868
addq $0x10, %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x7a4e8
movq 0x70ab7(%rip), %r9 # 0xeaf90
cmpb $0x0, (%r9)
je 0x7a4e4
incl 0x8(%rax)
jmp 0x7a4e8
lock
incl 0x8(%rax)
movq 0x10(%rsi), %rax
movq %rax, 0x18(%rdi)
leaq 0x6f991(%rip), %rax # 0xe9e88
addq $0x10, %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
movups (%rdx), %xmm0
movq %rax, 0x8(%rdx)
movups %xmm0, 0x20(%rdi)
movq %rax, (%rdx)
movq %rax, 0x38(%rdi)
movups (%rcx), %xmm0
movq %rax, 0x8(%rcx)
movups %xmm0, 0x30(%rdi)
movq %rax, (%rcx)
movq %rax, 0x48(%rdi)
movups (%r8), %xmm0
movq %rax, 0x8(%r8)
movups %xmm0, 0x40(%rdi)
movq %rax, (%r8)
retq
| _ZN5minja6IfExprC2ERKNS_8LocationEOSt10shared_ptrINS_10ExpressionEES7_S7_:
lea rax, _ZTVN5minja10ExpressionE; `vtable for'minja::Expression
add rax, 10h
mov [rdi], rax
mov rax, [rsi]
mov [rdi+8], rax
mov rax, [rsi+8]
mov [rdi+10h], rax
test rax, rax
jz short loc_7A4E8
mov r9, cs:__libc_single_threaded_ptr
cmp byte ptr [r9], 0
jz short loc_7A4E4
inc dword ptr [rax+8]
jmp short loc_7A4E8
loc_7A4E4:
lock inc dword ptr [rax+8]
loc_7A4E8:
mov rax, [rsi+10h]
mov [rdi+18h], rax
lea rax, _ZTVN5minja6IfExprE; `vtable for'minja::IfExpr
add rax, 10h
mov [rdi], rax
xor eax, eax
mov [rdi+28h], rax
movups xmm0, xmmword ptr [rdx]
mov [rdx+8], rax
movups xmmword ptr [rdi+20h], xmm0
mov [rdx], rax
mov [rdi+38h], rax
movups xmm0, xmmword ptr [rcx]
mov [rcx+8], rax
movups xmmword ptr [rdi+30h], xmm0
mov [rcx], rax
mov [rdi+48h], rax
movups xmm0, xmmword ptr [r8]
mov [r8+8], rax
movups xmmword ptr [rdi+40h], xmm0
mov [r8], rax
retn
| long long minja::IfExpr::IfExpr(long long a1, _QWORD *a2, __int128 *a3, __int128 *a4, __int128 *a5)
{
long long v5; // rax
long long result; // rax
__int128 v7; // xmm0
__int128 v8; // xmm0
__int128 v9; // xmm0
*(_QWORD *)a1 = &`vtable for'minja::Expression + 2;
*(_QWORD *)(a1 + 8) = *a2;
v5 = a2[1];
*(_QWORD *)(a1 + 16) = v5;
if ( v5 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v5 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v5 + 8));
}
*(_QWORD *)(a1 + 24) = a2[2];
*(_QWORD *)a1 = &`vtable for'minja::IfExpr + 2;
result = 0LL;
*(_QWORD *)(a1 + 40) = 0LL;
v7 = *a3;
*((_QWORD *)a3 + 1) = 0LL;
*(_OWORD *)(a1 + 32) = v7;
*(_QWORD *)a3 = 0LL;
*(_QWORD *)(a1 + 56) = 0LL;
v8 = *a4;
*((_QWORD *)a4 + 1) = 0LL;
*(_OWORD *)(a1 + 48) = v8;
*(_QWORD *)a4 = 0LL;
*(_QWORD *)(a1 + 72) = 0LL;
v9 = *a5;
*((_QWORD *)a5 + 1) = 0LL;
*(_OWORD *)(a1 + 64) = v9;
*(_QWORD *)a5 = 0LL;
return result;
}
| IfExpr:
LEA RAX,[0x1e9868]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x8],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],RAX
TEST RAX,RAX
JZ 0x0017a4e8
MOV R9,qword ptr [0x001eaf90]
CMP byte ptr [R9],0x0
JZ 0x0017a4e4
INC dword ptr [RAX + 0x8]
JMP 0x0017a4e8
LAB_0017a4e4:
INC.LOCK dword ptr [RAX + 0x8]
LAB_0017a4e8:
MOV RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RDI + 0x18],RAX
LEA RAX,[0x1e9e88]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x28],RAX
MOVUPS XMM0,xmmword ptr [RDX]
MOV qword ptr [RDX + 0x8],RAX
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOV qword ptr [RDX],RAX
MOV qword ptr [RDI + 0x38],RAX
MOVUPS XMM0,xmmword ptr [RCX]
MOV qword ptr [RCX + 0x8],RAX
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOV qword ptr [RCX],RAX
MOV qword ptr [RDI + 0x48],RAX
MOVUPS XMM0,xmmword ptr [R8]
MOV qword ptr [R8 + 0x8],RAX
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOV qword ptr [R8],RAX
RET
|
/* minja::IfExpr::IfExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&,
std::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::Expression>&&) */
void __thiscall
minja::IfExpr::IfExpr
(IfExpr *this,Location *param_1,shared_ptr *param_2,shared_ptr *param_3,
shared_ptr *param_4)
{
long lVar1;
int8 uVar2;
*(int ***)this = &PTR___cxa_pure_virtual_001e9878;
*(int8 *)(this + 8) = *(int8 *)param_1;
lVar1 = *(long *)(param_1 + 8);
*(long *)(this + 0x10) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_001eaf90 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
*(int8 *)(this + 0x18) = *(int8 *)(param_1 + 0x10);
*(int ***)this = &PTR_do_evaluate_001e9e98;
*(int8 *)(this + 0x28) = 0;
uVar2 = *(int8 *)(param_2 + 8);
*(int8 *)(param_2 + 8) = 0;
*(int8 *)(this + 0x20) = *(int8 *)param_2;
*(int8 *)(this + 0x28) = uVar2;
*(int8 *)param_2 = 0;
*(int8 *)(this + 0x38) = 0;
uVar2 = *(int8 *)(param_3 + 8);
*(int8 *)(param_3 + 8) = 0;
*(int8 *)(this + 0x30) = *(int8 *)param_3;
*(int8 *)(this + 0x38) = uVar2;
*(int8 *)param_3 = 0;
*(int8 *)(this + 0x48) = 0;
uVar2 = *(int8 *)(param_4 + 8);
*(int8 *)(param_4 + 8) = 0;
*(int8 *)(this + 0x40) = *(int8 *)param_4;
*(int8 *)(this + 0x48) = uVar2;
*(int8 *)param_4 = 0;
return;
}
|
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.