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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
42,800 | LefDefParser::defiNet::viaOrientStr(int) const | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiNet.cpp | const char* defiNet::viaOrientStr(int index) const {
char errMsg[128];
if (index < 0 || index > numPts_) {
sprintf (errMsg, "ERROR (DEFPARS-6085): The index number %d specified for the NET POLYGON is invalid.\nValid index is from 0 to %d. Specify a valid index number and then try again.",
index, numPts_);
defiError(0, 6085, errMsg, defData);
return 0;
}
return (defiOrientStr(viaOrients_[index]));
} | O3 | cpp | LefDefParser::defiNet::viaOrientStr(int) const:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movl %esi, %edx
movq %rdi, %rbx
testl %esi, %esi
sets %al
movl 0x210(%rdi), %ecx
cmpl %esi, %ecx
setl %sil
orb %al, %sil
cmpb $0x1, %sil
jne 0x24b0c
leaq 0x1e2a2(%rip), %rsi # 0x42d7e
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x6060
movq 0x240(%rbx), %rcx
xorl %edi, %edi
movl $0x17c5, %esi # imm = 0x17C5
movq %r14, %rdx
callq 0x18f80
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
movq 0x218(%rbx), %rax
movl %edx, %ecx
movl (%rax,%rcx,4), %edi
addq $0x88, %rsp
popq %rbx
popq %r14
jmp 0x1d75c
nop
| _ZNK12LefDefParser7defiNet12viaOrientStrEi:
push r14
push rbx
sub rsp, 88h
mov edx, esi
mov rbx, rdi
test esi, esi
sets al
mov ecx, [rdi+210h]
cmp ecx, esi
setl sil
or sil, al; int
cmp sil, 1
jnz short loc_24B0C
lea rsi, aErrorDefpars60_6; "ERROR (DEFPARS-6085): The index number "...
mov r14, rsp
mov rdi, r14
xor eax, eax
call _sprintf
mov rcx, [rbx+240h]; LefDefParser::defrData *
xor edi, edi; this
mov esi, 17C5h; int
mov rdx, r14; char *
call _ZN12LefDefParser9defiErrorEiiPKcPNS_8defrDataE; LefDefParser::defiError(int,int,char const*,LefDefParser::defrData *)
xor eax, eax
add rsp, 88h
pop rbx
pop r14
retn
loc_24B0C:
mov rax, [rbx+218h]
mov ecx, edx
mov edi, [rax+rcx*4]; this
add rsp, 88h
pop rbx
pop r14
jmp _ZN12LefDefParser13defiOrientStrEi; LefDefParser::defiOrientStr(int)
| char * LefDefParser::defiNet::viaOrientStr(LefDefParser::defiNet *this, int a2)
{
int v2; // ecx
LefDefParser::defrData *v3; // r8
char v5[152]; // [rsp+0h] [rbp-98h] BYREF
v2 = *((_DWORD *)this + 132);
if ( a2 >= 0 && v2 >= a2 )
return LefDefParser::defiOrientStr((LefDefParser *)*(unsigned int *)(*((_QWORD *)this + 67) + 4LL * (unsigned int)a2));
sprintf(
v5,
"ERROR (DEFPARS-6085): The index number %d specified for the NET POLYGON is invalid.\n"
"Valid index is from 0 to %d. Specify a valid index number and then try again.",
a2,
v2);
LefDefParser::defiError(0LL, 6085, v5, *((LefDefParser::defrData **)this + 72), v3);
return 0LL;
}
| viaOrientStr:
PUSH R14
PUSH RBX
SUB RSP,0x88
MOV EDX,ESI
MOV RBX,RDI
TEST ESI,ESI
SETS AL
MOV ECX,dword ptr [RDI + 0x210]
CMP ECX,ESI
SETL SIL
OR SIL,AL
CMP SIL,0x1
JNZ 0x00124b0c
LEA RSI,[0x142d7e]
MOV R14,RSP
MOV RDI,R14
XOR EAX,EAX
CALL 0x00106060
MOV RCX,qword ptr [RBX + 0x240]
XOR EDI,EDI
MOV ESI,0x17c5
MOV RDX,R14
CALL 0x00118f80
XOR EAX,EAX
ADD RSP,0x88
POP RBX
POP R14
RET
LAB_00124b0c:
MOV RAX,qword ptr [RBX + 0x218]
MOV ECX,EDX
MOV EDI,dword ptr [RAX + RCX*0x4]
ADD RSP,0x88
POP RBX
POP R14
JMP 0x0011d75c
|
/* LefDefParser::defiNet::viaOrientStr(int) const */
int8 __thiscall LefDefParser::defiNet::viaOrientStr(defiNet *this,int param_1)
{
int8 uVar1;
char acStack_98 [136];
if (*(int *)(this + 0x210) < param_1 || param_1 < 0) {
sprintf(acStack_98,
"ERROR (DEFPARS-6085): The index number %d specified for the NET POLYGON is invalid.\nValid index is from 0 to %d. Specify a valid index number and then try again."
);
defiError(0,0x17c5,acStack_98,*(defrData **)(this + 0x240));
return 0;
}
uVar1 = defiOrientStr(*(int *)(*(long *)(this + 0x218) + (ulong)(uint)param_1 * 4));
return uVar1;
}
| |
42,801 | bytes_dup | corpus-core[P]colibri-stateless/src/util/bytes.c | bytes_t bytes_dup(bytes_t data) {
bytes_t result = {.data = safe_malloc(data.len), .len = data.len};
if (!result.data && data.len > 0) {
// This case should technically not be reached if safe_malloc exits on failure,
// but kept for conceptual completeness or if safe_malloc behaviour changes.
return NULL_BYTES; // Indicate failure if malloc fails
}
memcpy(result.data, data.data, data.len);
return result;
} | O2 | c | bytes_dup:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movl %edi, %ebx
movl %edi, %r12d
movq %r12, %rdi
callq 0x4aee0
movq %rax, %r14
testq %rax, %rax
sete %cl
testl %ebx, %ebx
setne %dl
xorl %eax, %eax
testb %cl, %dl
jne 0x4b47f
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x22090
movl %ebx, %eax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| bytes_dup:
push r15
push r14
push r12
push rbx
push rax
mov r15, rsi
mov ebx, edi
mov r12d, edi
mov rdi, r12
call safe_malloc
mov r14, rax
test rax, rax
setz cl
test ebx, ebx
setnz dl
xor eax, eax
test dl, cl
jnz short loc_4B47F
mov rdi, r14
mov rsi, r15
mov rdx, r12
call _memcpy
mov eax, ebx
loc_4B47F:
mov rdx, r14
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long bytes_dup(unsigned int a1, long long a2)
{
long long v2; // rcx
long long v3; // r14
long long result; // rax
v3 = safe_malloc(a1);
result = 0LL;
if ( v3 != 0 || a1 == 0 )
{
LOBYTE(v2) = v3 == 0;
memcpy(v3, a2, a1, v2);
return a1;
}
return result;
}
| bytes_dup:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RSI
MOV EBX,EDI
MOV R12D,EDI
MOV RDI,R12
CALL 0x0014aee0
MOV R14,RAX
TEST RAX,RAX
SETZ CL
TEST EBX,EBX
SETNZ DL
XOR EAX,EAX
TEST DL,CL
JNZ 0x0014b47f
MOV RDI,R14
MOV RSI,R15
MOV RDX,R12
CALL 0x00122090
MOV EAX,EBX
LAB_0014b47f:
MOV RDX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int1 [16] bytes_dup(uint param_1,void *param_2)
{
void *__dest;
ulong uVar1;
int1 auVar2 [16];
__dest = (void *)safe_malloc((ulong)param_1);
uVar1 = 0;
if (param_1 == 0 || __dest != (void *)0x0) {
memcpy(__dest,param_2,(ulong)param_1);
uVar1 = (ulong)param_1;
}
auVar2._8_8_ = __dest;
auVar2._0_8_ = uVar1;
return auVar2;
}
| |
42,802 | bytes_dup | corpus-core[P]colibri-stateless/src/util/bytes.c | bytes_t bytes_dup(bytes_t data) {
bytes_t result = {.data = safe_malloc(data.len), .len = data.len};
if (!result.data && data.len > 0) {
// This case should technically not be reached if safe_malloc exits on failure,
// but kept for conceptual completeness or if safe_malloc behaviour changes.
return NULL_BYTES; // Indicate failure if malloc fails
}
memcpy(result.data, data.data, data.len);
return result;
} | O3 | c | bytes_dup:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movl %edi, %ebx
movl %edi, %r12d
movq %r12, %rdi
callq 0x52f18
movq %rax, %r14
testq %rax, %rax
sete %cl
testl %ebx, %ebx
setne %dl
xorl %eax, %eax
testb %cl, %dl
jne 0x534e4
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x22090
movl %ebx, %eax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| bytes_dup:
push r15
push r14
push r12
push rbx
push rax
mov r15, rsi
mov ebx, edi
mov r12d, edi
mov rdi, r12
call safe_malloc
mov r14, rax
test rax, rax
setz cl
test ebx, ebx
setnz dl
xor eax, eax
test dl, cl
jnz short loc_534E4
mov rdi, r14
mov rsi, r15
mov rdx, r12
call _memcpy
mov eax, ebx
loc_534E4:
mov rdx, r14
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long bytes_dup(unsigned int a1)
{
long long v1; // r14
long long result; // rax
v1 = safe_malloc(a1);
result = 0LL;
if ( v1 != 0 || a1 == 0 )
{
memcpy(v1);
return a1;
}
return result;
}
| bytes_dup:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RSI
MOV EBX,EDI
MOV R12D,EDI
MOV RDI,R12
CALL 0x00152f18
MOV R14,RAX
TEST RAX,RAX
SETZ CL
TEST EBX,EBX
SETNZ DL
XOR EAX,EAX
TEST DL,CL
JNZ 0x001534e4
MOV RDI,R14
MOV RSI,R15
MOV RDX,R12
CALL 0x00122090
MOV EAX,EBX
LAB_001534e4:
MOV RDX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int1 [16] bytes_dup(uint param_1,void *param_2)
{
void *__dest;
ulong uVar1;
int1 auVar2 [16];
__dest = (void *)safe_malloc((ulong)param_1);
uVar1 = 0;
if (param_1 == 0 || __dest != (void *)0x0) {
memcpy(__dest,param_2,(ulong)param_1);
uVar1 = (ulong)param_1;
}
auVar2._8_8_ = __dest;
auVar2._0_8_ = uVar1;
return auVar2;
}
| |
42,803 | js_atomics_notify | bluesky950520[P]quickjs/quickjs.c | static JSValue js_atomics_notify(JSContext *ctx,
JSValue this_obj,
int argc, JSValue *argv)
{
struct list_head *el, *el1, waiter_list;
int32_t count, n;
void *ptr;
JSAtomicsWaiter *waiter;
JSArrayBuffer *abuf;
ptr = js_atomics_get_ptr(ctx, &abuf, NULL, NULL, argv[0], argv[1], 1);
if (!ptr)
return JS_EXCEPTION;
if (JS_IsUndefined(argv[2])) {
count = INT32_MAX;
} else {
if (JS_ToInt32Clamp(ctx, &count, argv[2], 0, INT32_MAX, 0))
return JS_EXCEPTION;
}
if (abuf->detached)
return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
n = 0;
if (abuf->shared && count > 0) {
js_mutex_lock(&js_atomics_mutex);
init_list_head(&waiter_list);
list_for_each_safe(el, el1, &js_atomics_waiter_list) {
waiter = list_entry(el, JSAtomicsWaiter, link);
if (waiter->ptr == ptr) {
list_del(&waiter->link);
waiter->linked = FALSE;
list_add_tail(&waiter->link, &waiter_list);
n++;
if (n >= count)
break;
}
}
list_for_each(el, &waiter_list) {
waiter = list_entry(el, JSAtomicsWaiter, link);
js_cond_signal(&waiter->cond);
}
js_mutex_unlock(&js_atomics_mutex);
}
return js_int32(n);
} | O3 | c | js_atomics_notify:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r13
movq %rdi, %r12
movq (%r8), %r8
movq 0x8(%r13), %r9
movups 0x10(%r13), %xmm0
movups %xmm0, (%rsp)
movl $0x1, 0x10(%rsp)
xorl %ebx, %ebx
leaq 0x20(%rsp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x81840
movl $0x6, %r15d
testq %rax, %rax
je 0x8182b
movq %rax, %r14
movq 0x28(%r13), %rcx
cmpl $0x3, %ecx
jne 0x81725
movl $0x7fffffff, 0x1c(%rsp) # imm = 0x7FFFFFFF
jmp 0x81750
movq 0x20(%r13), %rdx
movl $0x0, (%rsp)
leaq 0x1c(%rsp), %rsi
xorl %ebx, %ebx
movq %r12, %rdi
xorl %r8d, %r8d
movl $0x7fffffff, %r9d # imm = 0x7FFFFFFF
callq 0x271f4
testl %eax, %eax
jne 0x8182b
movq 0x20(%rsp), %rax
cmpb $0x0, 0x8(%rax)
je 0x81773
leaq 0x22549(%rip), %rsi # 0xa3cab
xorl %ebx, %ebx
movq %r12, %rdi
xorl %eax, %eax
callq 0x2214f
jmp 0x8182b
cmpb $0x0, 0x9(%rax)
setne %al
movl 0x1c(%rsp), %ebp
testl %ebp, %ebp
setg %cl
andb %al, %cl
xorl %ebx, %ebx
cmpb $0x1, %cl
jne 0x81828
leaq 0x4ce31(%rip), %rdi # 0xce5c8
callq 0x1c429
leaq 0x28(%rsp), %r15
movq %r15, (%r15)
movq %r15, 0x8(%r15)
movq 0x4cd89(%rip), %rcx # 0xce538
leaq 0x4cd7a(%rip), %rax # 0xce530
cmpq %rax, %rcx
je 0x8181a
xorl %ebx, %ebx
xorps %xmm0, %xmm0
movq 0x8(%rcx), %rdx
cmpq %r14, 0x48(%rcx)
jne 0x817f9
movq (%rcx), %rsi
movq %rdx, 0x8(%rsi)
movq %rsi, (%rdx)
movups %xmm0, (%rcx)
movl $0x0, 0x10(%rcx)
movq 0x28(%rsp), %rsi
movq %rcx, 0x8(%rsi)
movq %rsi, (%rcx)
movq %r15, 0x8(%rcx)
movq %rcx, 0x28(%rsp)
incl %ebx
cmpl %ebp, %ebx
jge 0x81801
movq %rdx, %rcx
cmpq %rax, %rdx
jne 0x817c0
movq 0x30(%rsp), %r14
cmpq %r15, %r14
je 0x8181a
leaq 0x18(%r14), %rdi
callq 0x1c4af
movq 0x8(%r14), %r14
jmp 0x81806
movl %ebx, %ebx
leaq 0x4cda5(%rip), %rdi # 0xce5c8
callq 0x1c43a
xorl %r15d, %r15d
movq %rbx, %rax
movq %r15, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_atomics_notify:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r13, r8
mov r12, rdi
mov r8, [r8]
mov r9, [r13+8]
movups xmm0, xmmword ptr [r13+10h]
movups [rsp+68h+var_68], xmm0
mov [rsp+68h+var_58], 1
xor ebx, ebx
lea rsi, [rsp+68h+var_48]
xor edx, edx
xor ecx, ecx
call js_atomics_get_ptr
mov r15d, 6
test rax, rax
jz loc_8182B
mov r14, rax
mov rcx, [r13+28h]
cmp ecx, 3
jnz short loc_81725
mov [rsp+68h+var_4C], 7FFFFFFFh
jmp short loc_81750
loc_81725:
mov rdx, [r13+20h]
mov dword ptr [rsp+68h+var_68], 0
lea rsi, [rsp+68h+var_4C]
xor ebx, ebx
mov rdi, r12
xor r8d, r8d
mov r9d, 7FFFFFFFh
call JS_ToInt32Clamp
test eax, eax
jnz loc_8182B
loc_81750:
mov rax, [rsp+68h+var_48]
cmp byte ptr [rax+8], 0
jz short loc_81773
lea rsi, aArraybufferIsD; "ArrayBuffer is detached"
xor ebx, ebx
mov rdi, r12
xor eax, eax
call JS_ThrowTypeError
jmp loc_8182B
loc_81773:
cmp byte ptr [rax+9], 0
setnz al
mov ebp, [rsp+68h+var_4C]
test ebp, ebp
setnle cl
and cl, al
xor ebx, ebx
cmp cl, 1
jnz loc_81828
lea rdi, js_atomics_mutex
call js_mutex_lock
lea r15, [rsp+68h+var_40]
mov [r15], r15
mov [r15+8], r15
mov rcx, cs:off_CE538
lea rax, js_atomics_waiter_list
cmp rcx, rax
jz short loc_8181A
xor ebx, ebx
xorps xmm0, xmm0
loc_817C0:
mov rdx, [rcx+8]
cmp [rcx+48h], r14
jnz short loc_817F9
mov rsi, [rcx]
mov [rsi+8], rdx
mov [rdx], rsi
movups xmmword ptr [rcx], xmm0
mov dword ptr [rcx+10h], 0
mov rsi, [rsp+68h+var_40]
mov [rsi+8], rcx
mov [rcx], rsi
mov [rcx+8], r15
mov [rsp+68h+var_40], rcx
inc ebx
cmp ebx, ebp
jge short loc_81801
loc_817F9:
mov rcx, rdx
cmp rdx, rax
jnz short loc_817C0
loc_81801:
mov r14, [rsp+68h+var_38]
loc_81806:
cmp r14, r15
jz short loc_8181A
lea rdi, [r14+18h]
call js_cond_signal
mov r14, [r14+8]
jmp short loc_81806
loc_8181A:
mov ebx, ebx
lea rdi, js_atomics_mutex
call js_mutex_unlock
loc_81828:
xor r15d, r15d
loc_8182B:
mov rax, rbx
mov rdx, r15
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long js_atomics_notify(
long long a1,
double a2,
__m128 a3,
__m128 a4,
__m128 a5,
double a6,
double a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long a13)
{
__m128 v14; // xmm0
long long v15; // rbx
long long ptr; // rax
long long v17; // rdx
long long v18; // r8
long long v19; // r9
__m128 v20; // xmm4
__m128 v21; // xmm5
void *v22; // r14
long long v23; // rcx
int v24; // ebp
_UNKNOWN **v25; // rcx
_UNKNOWN **v26; // rdx
long long v27; // rsi
void *v28; // rsi
_QWORD *i; // r14
char v31; // [rsp+0h] [rbp-68h]
int v32; // [rsp+1Ch] [rbp-4Ch] BYREF
long long v33; // [rsp+20h] [rbp-48h] BYREF
_UNKNOWN **v34; // [rsp+28h] [rbp-40h] BYREF
_QWORD *v35; // [rsp+30h] [rbp-38h]
v14 = *(__m128 *)(a13 + 16);
v15 = 0LL;
ptr = js_atomics_get_ptr(
a1,
(unsigned int)&v33,
0,
0,
*(_QWORD *)a13,
*(_QWORD *)(a13 + 8),
*(_QWORD *)(a13 + 16),
*(_QWORD *)(a13 + 24),
1);
if ( ptr )
{
v22 = (void *)ptr;
v23 = *(_QWORD *)(a13 + 40);
if ( (_DWORD)v23 == 3 )
{
v32 = 0x7FFFFFFF;
}
else
{
v15 = 0LL;
if ( (unsigned int)JS_ToInt32Clamp(a1, &v32, *(_DWORD **)(a13 + 32), v23, 0, 0x7FFFFFFF, 0) )
return v15;
}
if ( *(_BYTE *)(v33 + 8) )
{
v15 = 0LL;
JS_ThrowTypeError(
a1,
(long long)"ArrayBuffer is detached",
v17,
v23,
v18,
v19,
v14,
a3,
a4,
a5,
v20,
v21,
a8,
a9,
v31);
}
else
{
v24 = v32;
v15 = 0LL;
if ( *(_BYTE *)(v33 + 9) != 0 && v32 > 0 )
{
js_mutex_lock((long long)&js_atomics_mutex);
v34 = (_UNKNOWN **)&v34;
v35 = &v34;
v25 = off_CE538;
if ( off_CE538 != &js_atomics_waiter_list )
{
LODWORD(v15) = 0;
do
{
v26 = (_UNKNOWN **)v25[1];
if ( v25[9] == v22 )
{
v27 = (long long)*v25;
*(_QWORD *)(v27 + 8) = v26;
*v26 = (_UNKNOWN *)v27;
*(_OWORD *)v25 = 0LL;
*((_DWORD *)v25 + 4) = 0;
v28 = v34;
v34[1] = v25;
*v25 = v28;
v25[1] = &v34;
v34 = v25;
LODWORD(v15) = v15 + 1;
if ( (int)v15 >= v24 )
break;
}
v25 = v26;
}
while ( v26 != &js_atomics_waiter_list );
for ( i = v35; i != &v34; i = (_QWORD *)i[1] )
js_cond_signal();
}
v15 = (unsigned int)v15;
js_mutex_unlock((long long)&js_atomics_mutex);
}
}
}
return v15;
}
| js_atomics_notify:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R13,R8
MOV R12,RDI
MOV R8,qword ptr [R8]
MOV R9,qword ptr [R13 + 0x8]
MOVUPS XMM0,xmmword ptr [R13 + 0x10]
MOVUPS xmmword ptr [RSP],XMM0
MOV dword ptr [RSP + 0x10],0x1
XOR EBX,EBX
LEA RSI,[RSP + 0x20]
XOR EDX,EDX
XOR ECX,ECX
CALL 0x00181840
MOV R15D,0x6
TEST RAX,RAX
JZ 0x0018182b
MOV R14,RAX
MOV RCX,qword ptr [R13 + 0x28]
CMP ECX,0x3
JNZ 0x00181725
MOV dword ptr [RSP + 0x1c],0x7fffffff
JMP 0x00181750
LAB_00181725:
MOV RDX,qword ptr [R13 + 0x20]
MOV dword ptr [RSP],0x0
LEA RSI,[RSP + 0x1c]
XOR EBX,EBX
MOV RDI,R12
XOR R8D,R8D
MOV R9D,0x7fffffff
CALL 0x001271f4
TEST EAX,EAX
JNZ 0x0018182b
LAB_00181750:
MOV RAX,qword ptr [RSP + 0x20]
CMP byte ptr [RAX + 0x8],0x0
JZ 0x00181773
LEA RSI,[0x1a3cab]
XOR EBX,EBX
MOV RDI,R12
XOR EAX,EAX
CALL 0x0012214f
JMP 0x0018182b
LAB_00181773:
CMP byte ptr [RAX + 0x9],0x0
SETNZ AL
MOV EBP,dword ptr [RSP + 0x1c]
TEST EBP,EBP
SETG CL
AND CL,AL
XOR EBX,EBX
CMP CL,0x1
JNZ 0x00181828
LEA RDI,[0x1ce5c8]
CALL 0x0011c429
LEA R15,[RSP + 0x28]
MOV qword ptr [R15],R15
MOV qword ptr [R15 + 0x8],R15
MOV RCX,qword ptr [0x001ce538]
LEA RAX,[0x1ce530]
CMP RCX,RAX
JZ 0x0018181a
XOR EBX,EBX
XORPS XMM0,XMM0
LAB_001817c0:
MOV RDX,qword ptr [RCX + 0x8]
CMP qword ptr [RCX + 0x48],R14
JNZ 0x001817f9
MOV RSI,qword ptr [RCX]
MOV qword ptr [RSI + 0x8],RDX
MOV qword ptr [RDX],RSI
MOVUPS xmmword ptr [RCX],XMM0
MOV dword ptr [RCX + 0x10],0x0
MOV RSI,qword ptr [RSP + 0x28]
MOV qword ptr [RSI + 0x8],RCX
MOV qword ptr [RCX],RSI
MOV qword ptr [RCX + 0x8],R15
MOV qword ptr [RSP + 0x28],RCX
INC EBX
CMP EBX,EBP
JGE 0x00181801
LAB_001817f9:
MOV RCX,RDX
CMP RDX,RAX
JNZ 0x001817c0
LAB_00181801:
MOV R14,qword ptr [RSP + 0x30]
LAB_00181806:
CMP R14,R15
JZ 0x0018181a
LEA RDI,[R14 + 0x18]
CALL 0x0011c4af
MOV R14,qword ptr [R14 + 0x8]
JMP 0x00181806
LAB_0018181a:
MOV EBX,EBX
LEA RDI,[0x1ce5c8]
CALL 0x0011c43a
LAB_00181828:
XOR R15D,R15D
LAB_0018182b:
MOV RAX,RBX
MOV RDX,R15
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int js_atomics_notify(int8 param_1)
{
long ******pppppplVar1;
long *****ppppplVar2;
int iVar3;
long *****ppppplVar4;
long ******pppppplVar5;
int iVar6;
int8 *in_R8;
long ******pppppplVar7;
int local_4c;
long local_48;
long *****local_40;
long *****local_38;
iVar6 = 0;
ppppplVar4 = (long *****)
js_atomics_get_ptr(param_1,&local_48,0,0,*in_R8,in_R8[1],*(int4 *)(in_R8 + 2),
*(int4 *)(in_R8 + 3),1);
if (ppppplVar4 != (long *****)0x0) {
if ((int)in_R8[5] == 3) {
local_4c = 0x7fffffff;
}
else {
iVar6 = JS_ToInt32Clamp(param_1,&local_4c,in_R8[4],in_R8[5],0,0x7fffffff,0);
if (iVar6 != 0) {
return 0;
}
}
iVar3 = local_4c;
if (*(char *)(local_48 + 8) == '\0') {
iVar6 = 0;
if (0 < local_4c && *(char *)(local_48 + 9) != '\0') {
js_mutex_lock(js_atomics_mutex);
local_40 = (long *****)&local_40;
local_38 = (long *****)&local_40;
if ((int **)PTR_LOOP_001ce538 != &js_atomics_waiter_list) {
iVar6 = 0;
pppppplVar5 = (long ******)PTR_LOOP_001ce538;
do {
pppppplVar1 = (long ******)pppppplVar5[1];
if (pppppplVar5[9] == ppppplVar4) {
ppppplVar2 = *pppppplVar5;
ppppplVar2[1] = (long ****)pppppplVar1;
*pppppplVar1 = ppppplVar2;
*pppppplVar5 = (long *****)0x0;
pppppplVar5[1] = (long *****)0x0;
*(int4 *)(pppppplVar5 + 2) = 0;
local_40[1] = (long ****)pppppplVar5;
*pppppplVar5 = local_40;
pppppplVar5[1] = (long *****)&local_40;
iVar6 = iVar6 + 1;
pppppplVar7 = (long ******)local_38;
local_40 = (long *****)pppppplVar5;
if (iVar3 <= iVar6) break;
}
pppppplVar5 = pppppplVar1;
pppppplVar7 = (long ******)local_38;
} while (pppppplVar1 != (long ******)&js_atomics_waiter_list);
for (; pppppplVar7 != &local_40; pppppplVar7 = (long ******)pppppplVar7[1]) {
js_cond_signal(pppppplVar7 + 3);
}
}
js_mutex_unlock(js_atomics_mutex);
}
}
else {
iVar6 = 0;
JS_ThrowTypeError(param_1,"ArrayBuffer is detached");
}
}
return iVar6;
}
| |
42,804 | copy_decode_table | eloqsql/storage/myisam/mi_packrec.c | static uint copy_decode_table(uint16 *to_pos, uint offset,
uint16 *decode_table)
{
uint prev_offset= offset;
DBUG_ENTER("copy_decode_table");
/* Descent on the left side. */
if (!(*decode_table & IS_CHAR))
{
/* Set a pointer to the next target node. */
to_pos[offset]=2;
/* Copy the left hand subtree there. */
offset=copy_decode_table(to_pos,offset+2,decode_table+ *decode_table);
}
else
{
/* Copy the byte value. */
to_pos[offset]= *decode_table;
/* Step behind this node. */
offset+=2;
}
/* Descent on the right side. */
decode_table++;
if (!(*decode_table & IS_CHAR))
{
/* Set a pointer to the next free target node. */
to_pos[prev_offset+1]=(uint16) (offset-prev_offset-1);
/* Copy the right hand subtree to the entry of that node. */
offset=copy_decode_table(to_pos,offset,decode_table+ *decode_table);
}
else
{
/* Copy the byte value. */
to_pos[prev_offset+1]= *decode_table;
}
DBUG_RETURN(offset);
} | O0 | c | copy_decode_table:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
andl $0x8000, %eax # imm = 0x8000
cmpl $0x0, %eax
jne 0x4898e
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movw $0x2, (%rax,%rcx,2)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
cltq
shlq %rax
addq %rax, %rdx
callq 0x48930
movl %eax, -0xc(%rbp)
jmp 0x489a9
movq -0x18(%rbp), %rax
movw (%rax), %dx
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movw %dx, (%rax,%rcx,2)
movl -0xc(%rbp), %eax
addl $0x2, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
andl $0x8000, %eax # imm = 0x8000
cmpl $0x0, %eax
jne 0x48a06
movl -0xc(%rbp), %eax
subl -0x1c(%rbp), %eax
subl $0x1, %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movw %dx, (%rax,%rcx,2)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
cltq
shlq %rax
addq %rax, %rdx
callq 0x48930
movl %eax, -0xc(%rbp)
jmp 0x48a1d
movq -0x18(%rbp), %rax
movw (%rax), %dx
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movw %dx, (%rax,%rcx,2)
jmp 0x48a1f
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
| copy_decode_table:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov eax, [rbp+var_C]
mov [rbp+var_1C], eax
mov rax, [rbp+var_18]
movzx eax, word ptr [rax]
and eax, 8000h
cmp eax, 0
jnz short loc_4898E
mov rax, [rbp+var_8]
mov ecx, [rbp+var_C]
mov word ptr [rax+rcx*2], 2
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
add esi, 2
mov rdx, [rbp+var_18]
mov rax, [rbp+var_18]
movzx eax, word ptr [rax]
cdqe
shl rax, 1
add rdx, rax
call copy_decode_table
mov [rbp+var_C], eax
jmp short loc_489A9
loc_4898E:
mov rax, [rbp+var_18]
mov dx, [rax]
mov rax, [rbp+var_8]
mov ecx, [rbp+var_C]
mov [rax+rcx*2], dx
mov eax, [rbp+var_C]
add eax, 2
mov [rbp+var_C], eax
loc_489A9:
mov rax, [rbp+var_18]
add rax, 2
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
movzx eax, word ptr [rax]
and eax, 8000h
cmp eax, 0
jnz short loc_48A06
mov eax, [rbp+var_C]
sub eax, [rbp+var_1C]
sub eax, 1
mov dx, ax
mov rax, [rbp+var_8]
mov ecx, [rbp+var_1C]
add ecx, 1
mov ecx, ecx
mov [rax+rcx*2], dx
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_18]
mov rax, [rbp+var_18]
movzx eax, word ptr [rax]
cdqe
shl rax, 1
add rdx, rax
call copy_decode_table
mov [rbp+var_C], eax
jmp short loc_48A1D
loc_48A06:
mov rax, [rbp+var_18]
mov dx, [rax]
mov rax, [rbp+var_8]
mov ecx, [rbp+var_1C]
add ecx, 1
mov ecx, ecx
mov [rax+rcx*2], dx
loc_48A1D:
jmp short $+2
loc_48A1F:
mov eax, [rbp+var_C]
mov [rbp+var_20], eax
mov eax, [rbp+var_20]
add rsp, 20h
pop rbp
retn
| long long copy_decode_table(long long a1, unsigned int a2, _WORD *a3)
{
_WORD *v5; // [rsp+8h] [rbp-18h]
unsigned int v6; // [rsp+14h] [rbp-Ch]
if ( (*a3 & 0x8000) != 0 )
{
*(_WORD *)(a1 + 2LL * a2) = *a3;
v6 = a2 + 2;
}
else
{
*(_WORD *)(a1 + 2LL * a2) = 2;
v6 = copy_decode_table(a1, a2 + 2, &a3[(unsigned __int16)*a3]);
}
v5 = a3 + 1;
if ( (*v5 & 0x8000) != 0 )
{
*(_WORD *)(a1 + 2LL * (a2 + 1)) = *v5;
}
else
{
*(_WORD *)(a1 + 2LL * (a2 + 1)) = v6 - a2 - 1;
return (unsigned int)copy_decode_table(a1, v6, &v5[(unsigned __int16)*v5]);
}
return v6;
}
| copy_decode_table:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX]
AND EAX,0x8000
CMP EAX,0x0
JNZ 0x0014898e
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0xc]
MOV word ptr [RAX + RCX*0x2],0x2
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
ADD ESI,0x2
MOV RDX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX]
CDQE
SHL RAX,0x1
ADD RDX,RAX
CALL 0x00148930
MOV dword ptr [RBP + -0xc],EAX
JMP 0x001489a9
LAB_0014898e:
MOV RAX,qword ptr [RBP + -0x18]
MOV DX,word ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0xc]
MOV word ptr [RAX + RCX*0x2],DX
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x2
MOV dword ptr [RBP + -0xc],EAX
LAB_001489a9:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x2
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX]
AND EAX,0x8000
CMP EAX,0x0
JNZ 0x00148a06
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
MOV DX,AX
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0x1c]
ADD ECX,0x1
MOV ECX,ECX
MOV word ptr [RAX + RCX*0x2],DX
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX]
CDQE
SHL RAX,0x1
ADD RDX,RAX
CALL 0x00148930
MOV dword ptr [RBP + -0xc],EAX
JMP 0x00148a1d
LAB_00148a06:
MOV RAX,qword ptr [RBP + -0x18]
MOV DX,word ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0x1c]
ADD ECX,0x1
MOV ECX,ECX
MOV word ptr [RAX + RCX*0x2],DX
LAB_00148a1d:
JMP 0x00148a1f
LAB_00148a1f:
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x20]
ADD RSP,0x20
POP RBP
RET
|
int copy_decode_table(long param_1,uint param_2,ushort *param_3)
{
int local_14;
if ((*param_3 & 0x8000) == 0) {
*(int2 *)(param_1 + (ulong)param_2 * 2) = 2;
local_14 = copy_decode_table(param_1,param_2 + 2,param_3 + (int)(uint)*param_3);
}
else {
*(ushort *)(param_1 + (ulong)param_2 * 2) = *param_3;
local_14 = param_2 + 2;
}
param_3 = param_3 + 1;
if ((*param_3 & 0x8000) == 0) {
*(short *)(param_1 + (ulong)(param_2 + 1) * 2) = ((short)local_14 - (short)param_2) + -1;
local_14 = copy_decode_table(param_1,local_14,param_3 + (int)(uint)*param_3);
}
else {
*(ushort *)(param_1 + (ulong)(param_2 + 1) * 2) = *param_3;
}
return local_14;
}
| |
42,805 | cr_add_interval | bluesky950520[P]quickjs/libunicode.h | static inline int cr_add_interval(CharRange *cr, uint32_t c1, uint32_t c2)
{
if ((cr->len + 2) > cr->size) {
if (cr_realloc(cr, cr->len + 2))
return -1;
}
cr->points[cr->len++] = c1;
cr->points[cr->len++] = c2;
return 0;
} | O2 | c | cr_add_interval:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl (%rdi), %eax
leal 0x2(%rax), %esi
cmpl 0x4(%rdi), %esi
jle 0x800c2
movq %r14, %rdi
callq 0x7f42c
testl %eax, %eax
je 0x800bf
pushq $-0x1
popq %rax
jmp 0x800df
movl (%r14), %eax
movq 0x8(%r14), %rcx
leal 0x1(%rax), %edx
movl %edx, (%r14)
cltq
movl %ebp, (%rcx,%rax,4)
movslq (%r14), %rax
leal 0x1(%rax), %edx
movl %edx, (%r14)
movl %ebx, (%rcx,%rax,4)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
| cr_add_interval:
push rbp
push r14
push rbx
mov ebx, edx
mov ebp, esi
mov r14, rdi
mov eax, [rdi]
lea esi, [rax+2]
cmp esi, [rdi+4]
jle short loc_800C2
mov rdi, r14
call cr_realloc
test eax, eax
jz short loc_800BF
push 0FFFFFFFFFFFFFFFFh
pop rax
jmp short loc_800DF
loc_800BF:
mov eax, [r14]
loc_800C2:
mov rcx, [r14+8]
lea edx, [rax+1]
mov [r14], edx
cdqe
mov [rcx+rax*4], ebp
movsxd rax, dword ptr [r14]
lea edx, [rax+1]
mov [r14], edx
mov [rcx+rax*4], ebx
xor eax, eax
loc_800DF:
pop rbx
pop r14
pop rbp
retn
| long long cr_add_interval(int *a1, int a2, int a3)
{
int v5; // eax
int v6; // esi
long long v8; // rcx
long long v9; // rax
v5 = *a1;
v6 = *a1 + 2;
if ( v6 > a1[1] )
{
if ( (unsigned int)cr_realloc((long long)a1, v6) )
return -1LL;
v5 = *a1;
}
v8 = *((_QWORD *)a1 + 1);
*a1 = v5 + 1;
*(_DWORD *)(v8 + 4LL * v5) = a2;
v9 = *a1;
*a1 = v9 + 1;
*(_DWORD *)(v8 + 4 * v9) = a3;
return 0LL;
}
| cr_add_interval:
PUSH RBP
PUSH R14
PUSH RBX
MOV EBX,EDX
MOV EBP,ESI
MOV R14,RDI
MOV EAX,dword ptr [RDI]
LEA ESI,[RAX + 0x2]
CMP ESI,dword ptr [RDI + 0x4]
JLE 0x001800c2
MOV RDI,R14
CALL 0x0017f42c
TEST EAX,EAX
JZ 0x001800bf
PUSH -0x1
POP RAX
JMP 0x001800df
LAB_001800bf:
MOV EAX,dword ptr [R14]
LAB_001800c2:
MOV RCX,qword ptr [R14 + 0x8]
LEA EDX,[RAX + 0x1]
MOV dword ptr [R14],EDX
CDQE
MOV dword ptr [RCX + RAX*0x4],EBP
MOVSXD RAX,dword ptr [R14]
LEA EDX,[RAX + 0x1]
MOV dword ptr [R14],EDX
MOV dword ptr [RCX + RAX*0x4],EBX
XOR EAX,EAX
LAB_001800df:
POP RBX
POP R14
POP RBP
RET
|
int8 cr_add_interval(int *param_1,int4 param_2,int4 param_3)
{
long lVar1;
int iVar2;
iVar2 = *param_1;
if (param_1[1] < iVar2 + 2) {
iVar2 = cr_realloc(param_1);
if (iVar2 != 0) {
return 0xffffffffffffffff;
}
iVar2 = *param_1;
}
lVar1 = *(long *)(param_1 + 2);
*param_1 = iVar2 + 1;
*(int4 *)(lVar1 + (long)iVar2 * 4) = param_2;
iVar2 = *param_1;
*param_1 = iVar2 + 1;
*(int4 *)(lVar1 + (long)iVar2 * 4) = param_3;
return 0;
}
| |
42,806 | 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>::size() const | monkey531[P]llama/common/json.hpp | size_type size() const noexcept
{
switch (m_data.m_type)
{
case value_t::null:
{
// null values are empty
return 0;
}
case value_t::array:
{
// delegate call to array_t::size()
return m_data.m_value.array->size();
}
case value_t::object:
{
// delegate call to object_t::size()
return m_data.m_value.object->size();
}
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:
{
// all other types have size 1
return 1;
}
}
} | O0 | 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>::size() const:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movzbl (%rax), %eax
movq %rax, 0x10(%rsp)
subq $0x9, %rax
ja 0xb1f3d
movq 0x10(%rsp), %rax
leaq 0x15716f(%rip), %rcx # 0x20906c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x0, 0x20(%rsp)
jmp 0xb1f46
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xb13d0
movq %rax, 0x20(%rsp)
jmp 0xb1f46
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xb1fd0
movq %rax, 0x20(%rsp)
jmp 0xb1f46
jmp 0xb1f3d
movq $0x1, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4sizeEv:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov rax, [rsp+28h+var_10]
mov [rsp+28h+var_20], rax
movzx eax, byte ptr [rax]
mov [rsp+28h+var_18], rax
sub rax, 9; switch 10 cases
ja short def_B1F04; jumptable 00000000000B1F04 default case
mov rax, [rsp+28h+var_18]
lea rcx, jpt_B1F04
movsxd rax, ds:(jpt_B1F04 - 20906Ch)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_B1F06:
mov [rsp+28h+var_8], 0; jumptable 00000000000B1F04 case 0
jmp short loc_B1F46
loc_B1F11:
mov rax, [rsp+28h+var_20]; jumptable 00000000000B1F04 case 2
mov rdi, [rax+8]
call _ZNKSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE4sizeEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::size(void)
mov [rsp+28h+var_8], rax
jmp short loc_B1F46
loc_B1F26:
mov rax, [rsp+28h+var_20]; jumptable 00000000000B1F04 case 1
mov rdi, [rax+8]
call _ZNKSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE4sizeEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::size(void)
mov [rsp+28h+var_8], rax
jmp short loc_B1F46
loc_B1F3B:
jmp short $+2; jumptable 00000000000B1F04 cases 3-9
def_B1F04:
mov [rsp+28h+var_8], 1; jumptable 00000000000B1F04 default case
loc_B1F46:
mov rax, [rsp+28h+var_8]
add rsp, 28h
retn
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::size(
long long a1)
{
long long v2; // [rsp+20h] [rbp-8h]
switch ( *(_BYTE *)a1 )
{
case 0:
v2 = 0LL;
break;
case 1:
v2 = std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::size(*(_QWORD *)(a1 + 8));
break;
case 2:
v2 = std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::size(*(_QWORD **)(a1 + 8));
break;
default:
v2 = 1LL;
break;
}
return v2;
}
| size:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x8],RAX
MOVZX EAX,byte ptr [RAX]
MOV qword ptr [RSP + 0x10],RAX
SUB RAX,0x9
JA 0x001b1f3d
MOV RAX,qword ptr [RSP + 0x10]
LEA RCX,[0x30906c]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
MOV qword ptr [RSP + 0x20],0x0
JMP 0x001b1f46
caseD_2:
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x001b13d0
MOV qword ptr [RSP + 0x20],RAX
JMP 0x001b1f46
caseD_1:
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x001b1fd0
MOV qword ptr [RSP + 0x20],RAX
JMP 0x001b1f46
caseD_3:
JMP 0x001b1f3d
default:
MOV qword ptr [RSP + 0x20],0x1
LAB_001b1f46:
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x28
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::size() const */
int8 __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>
::size(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this)
{
int8 local_8;
switch(*this) {
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0:
local_8 = 0;
break;
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1:
local_8 = std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::size(*(vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)(this + 8));
break;
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2:
local_8 = std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::size(*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(this + 8));
break;
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x3:
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x4:
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x5:
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x6:
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x7:
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x8:
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x9:
default:
local_8 = 1;
}
return local_8;
}
| |
42,807 | print_min_range_operator(String*, ha_rkey_function) | eloqsql/sql/opt_range.cc | static void print_min_range_operator(String *out, const ha_rkey_function flag)
{
if (flag == HA_READ_AFTER_KEY)
out->append(STRING_WITH_LEN(" < "));
else if (flag == HA_READ_KEY_EXACT || flag == HA_READ_KEY_OR_NEXT)
out->append(STRING_WITH_LEN(" <= "));
else
out->append(STRING_WITH_LEN(" ? "));
} | O0 | cpp | print_min_range_operator(String*, ha_rkey_function):
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jne 0xa5473c
movq -0x8(%rbp), %rdi
leaq 0x3775c5(%rip), %rsi # 0xdcbcf5
movl $0x3, %edx
callq 0x673fe0
jmp 0xa54776
cmpl $0x0, -0xc(%rbp)
je 0xa54748
cmpl $0x1, -0xc(%rbp)
jne 0xa5475f
movq -0x8(%rbp), %rdi
leaq 0x3775a6(%rip), %rsi # 0xdcbcf9
movl $0x4, %edx
callq 0x673fe0
jmp 0xa54774
movq -0x8(%rbp), %rdi
leaq 0x377594(%rip), %rsi # 0xdcbcfe
movl $0x3, %edx
callq 0x673fe0
jmp 0xa54776
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| _ZL24print_min_range_operatorP6String16ha_rkey_function:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
cmp [rbp+var_C], 3
jnz short loc_A5473C
mov rdi, [rbp+var_8]; this
lea rsi, asc_DCBCF5; " < "
mov edx, 3; unsigned __int64
call _ZN6String6appendEPKcm; String::append(char const*,ulong)
jmp short loc_A54776
loc_A5473C:
cmp [rbp+var_C], 0
jz short loc_A54748
cmp [rbp+var_C], 1
jnz short loc_A5475F
loc_A54748:
mov rdi, [rbp+var_8]; this
lea rsi, asc_DCBCF9; " <= "
mov edx, 4; unsigned __int64
call _ZN6String6appendEPKcm; String::append(char const*,ulong)
jmp short loc_A54774
loc_A5475F:
mov rdi, [rbp+var_8]; this
lea rsi, asc_DCBCFE; " ? "
mov edx, 3; unsigned __int64
call _ZN6String6appendEPKcm; String::append(char const*,ulong)
loc_A54774:
jmp short $+2
loc_A54776:
add rsp, 10h
pop rbp
retn
| char print_min_range_operator(String *a1, unsigned int a2)
{
if ( a2 == 3 )
return String::append(a1, " < ", 3LL);
if ( a2 > 1 )
return String::append(a1, " ? ", 3LL);
return String::append(a1, " <= ", 4LL);
}
| val_real_from_str_op:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RDI
MOV RSI,RDI
ADD RSI,0x28
CALL 0x008cf740
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00a5474f
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x00a0db10
MOVSD qword ptr [RBP + -0x20],XMM0
JMP 0x00a54759
LAB_00a5474f:
XORPS XMM0,XMM0
MOVSD qword ptr [RBP + -0x20],XMM0
JMP 0x00a54759
LAB_00a54759:
MOVSD XMM0,qword ptr [RBP + -0x20]
ADD RSP,0x20
POP RBP
RET
|
/* Item_func_hybrid_field_type::val_real_from_str_op() */
int8 __thiscall
Item_func_hybrid_field_type::val_real_from_str_op(Item_func_hybrid_field_type *this)
{
String *pSVar1;
int8 local_28;
pSVar1 = (String *)str_op_with_null_check(this,(String *)(this + 0x28));
if (pSVar1 == (String *)0x0) {
local_28 = 0;
}
else {
local_28 = Value_source::double_from_string_with_check((Value_source *)this,pSVar1);
}
return local_28;
}
| |
42,808 | my_fcvt | eloqsql/strings/dtoa.c | size_t my_fcvt(double x, int precision, char *to, my_bool *error)
{
int decpt, sign, len, i;
char *res, *src, *end, *dst= to;
char buf[DTOA_BUFF_SIZE];
DBUG_ASSERT(precision >= 0 && precision < DECIMAL_NOT_SPECIFIED && to != NULL);
res= dtoa(x, 5, precision, &decpt, &sign, &end, buf, sizeof(buf));
if (decpt == DTOA_OVERFLOW)
{
dtoa_free(res, buf, sizeof(buf));
*to++= '0';
*to= '\0';
if (error != NULL)
*error= TRUE;
return 1;
}
src= res;
len= (int)(end - src);
if (sign)
*dst++= '-';
if (decpt <= 0)
{
*dst++= '0';
*dst++= '.';
for (i= decpt; i < 0; i++)
*dst++= '0';
}
for (i= 1; i <= len; i++)
{
*dst++= *src++;
if (i == decpt && i < len)
*dst++= '.';
}
while (i++ <= decpt)
*dst++= '0';
if (precision > 0)
{
if (len <= decpt)
*dst++= '.';
for (i= precision - MY_MAX(0, (len - decpt)); i > 0; i--)
*dst++= '0';
}
*dst= '\0';
if (error != NULL)
*error= FALSE;
dtoa_free(res, buf, sizeof(buf));
return dst - to;
} | O3 | c | my_fcvt:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe98, %rsp # imm = 0xE98
movq %rdx, -0xea8(%rbp)
movq %rsi, %r14
movl %edi, %esi
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq -0xe94(%rbp), %r13
leaq -0xe9c(%rbp), %rcx
leaq -0xec0(%rbp), %r8
leaq -0xe90(%rbp), %rbx
movl $0x5, %edi
movl %esi, -0xe98(%rbp)
movq %r13, %rdx
movq %rbx, %r9
callq 0x5571a
movq %rax, %r15
movl (%r13), %r12d
cmpl $0x270f, %r12d # imm = 0x270F
jne 0x55587
cmpq %rbx, %r15
setae %al
leaq -0x30(%rbp), %rcx
cmpq %r15, %rcx
seta %cl
testb %cl, %al
jne 0x55563
movq %r15, %rdi
callq 0x24380
movw $0x30, (%r14)
movl $0x1, %r13d
movq -0xea8(%rbp), %rax
testq %rax, %rax
je 0x556f1
movb $0x1, (%rax)
jmp 0x556f1
movq -0xec0(%rbp), %rbx
movq %r14, %rax
movl %ebx, %r14d
cmpl $0x0, -0xe9c(%rbp)
movq %rax, %r13
je 0x555a7
leaq 0x1(%rax), %r13
movb $0x2d, (%rax)
movq %rax, -0xeb8(%rbp)
subl %r15d, %r14d
testl %r12d, %r12d
movl -0xe98(%rbp), %r8d
jg 0x55601
movw $0x2e30, (%r13) # imm = 0x2E30
leaq 0x2(%r13), %rdi
testl %r12d, %r12d
js 0x555d2
movq %rdi, %r13
jmp 0x55601
movl %r12d, %eax
notl %eax
movq %rax, -0xeb0(%rbp)
leaq 0x1(%rax), %rdx
movl $0x30, %esi
callq 0x24170
movl -0xe98(%rbp), %r8d
movq -0xeb0(%rbp), %rax
addq %rax, %r13
addq $0x3, %r13
testl %r14d, %r14d
jle 0x55648
subl %r15d, %ebx
incl %ebx
movl %r14d, %eax
xorl %ecx, %ecx
movq %r13, %rdx
leal 0x1(%rcx), %esi
movb (%r15,%rcx), %dil
incq %r13
movb %dil, (%rdx)
cmpl -0xe94(%rbp), %esi
jne 0x55638
cmpl %r14d, %esi
jge 0x55638
movb $0x2e, 0x1(%rdx)
addq $0x2, %rdx
movq %rdx, %r13
incq %rcx
cmpl %ecx, %eax
jne 0x55610
movl -0xe94(%rbp), %r12d
jmp 0x5564d
movl $0x1, %ebx
cmpl %r12d, %ebx
jg 0x5566a
decl %ebx
movb $0x30, (%r13)
incq %r13
movl -0xe94(%rbp), %r12d
incl %ebx
cmpl %r12d, %ebx
jl 0x55654
testl %r8d, %r8d
jle 0x556b0
cmpl %r14d, %r12d
jl 0x55683
movb $0x2e, (%r13)
incq %r13
movl -0xe94(%rbp), %r12d
subl %r12d, %r14d
cmpl %r8d, %r14d
jge 0x556b0
xorl %ebx, %ebx
testl %r14d, %r14d
cmovgl %r14d, %ebx
notl %ebx
addl %r8d, %ebx
leaq 0x1(%rbx), %rdx
movq %r13, %rdi
movl $0x30, %esi
callq 0x24170
addq %rbx, %r13
incq %r13
movb $0x0, (%r13)
movq -0xea8(%rbp), %rax
testq %rax, %rax
movq -0xeb8(%rbp), %rbx
je 0x556cb
movb $0x0, (%rax)
leaq -0xe90(%rbp), %rax
cmpq %rax, %r15
setae %al
leaq -0x30(%rbp), %rcx
cmpq %r15, %rcx
seta %cl
testb %cl, %al
jne 0x556ee
movq %r15, %rdi
callq 0x24380
subq %rbx, %r13
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x55715
movq %r13, %rax
addq $0xe98, %rsp # imm = 0xE98
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x24320
| my_fcvt:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0E98h
mov [rbp+var_EA8], rdx
mov r14, rsi
mov esi, edi
mov rax, fs:28h
mov [rbp+var_30], rax
lea r13, [rbp+var_E94]
lea rcx, [rbp+var_E9C]
lea r8, [rbp+var_EC0]
lea rbx, [rbp+var_E90]
mov edi, 5
mov [rbp+var_E98], esi
mov rdx, r13
mov r9, rbx
call dtoa
mov r15, rax
mov r12d, [r13+0]
cmp r12d, 270Fh
jnz short loc_55587
cmp r15, rbx
setnb al
lea rcx, [rbp+var_30]
cmp rcx, r15
setnbe cl
test al, cl
jnz short loc_55563
mov rdi, r15
call _free
loc_55563:
mov word ptr [r14], 30h ; '0'
mov r13d, 1
mov rax, [rbp+var_EA8]
test rax, rax
jz loc_556F1
mov byte ptr [rax], 1
jmp loc_556F1
loc_55587:
mov rbx, [rbp+var_EC0]
mov rax, r14
mov r14d, ebx
cmp [rbp+var_E9C], 0
mov r13, rax
jz short loc_555A7
lea r13, [rax+1]
mov byte ptr [rax], 2Dh ; '-'
loc_555A7:
mov [rbp+var_EB8], rax
sub r14d, r15d
test r12d, r12d
mov r8d, [rbp+var_E98]
jg short loc_55601
mov word ptr [r13+0], 2E30h
lea rdi, [r13+2]
test r12d, r12d
js short loc_555D2
mov r13, rdi
jmp short loc_55601
loc_555D2:
mov eax, r12d
not eax
mov [rbp+var_EB0], rax
lea rdx, [rax+1]
mov esi, 30h ; '0'
call _memset
mov r8d, [rbp+var_E98]
mov rax, [rbp+var_EB0]
add r13, rax
add r13, 3
loc_55601:
test r14d, r14d
jle short loc_55648
sub ebx, r15d
inc ebx
mov eax, r14d
xor ecx, ecx
loc_55610:
mov rdx, r13
lea esi, [rcx+1]
mov dil, [r15+rcx]
inc r13
mov [rdx], dil
cmp esi, [rbp+var_E94]
jnz short loc_55638
cmp esi, r14d
jge short loc_55638
mov byte ptr [rdx+1], 2Eh ; '.'
add rdx, 2
mov r13, rdx
loc_55638:
inc rcx
cmp eax, ecx
jnz short loc_55610
mov r12d, [rbp+var_E94]
jmp short loc_5564D
loc_55648:
mov ebx, 1
loc_5564D:
cmp ebx, r12d
jg short loc_5566A
dec ebx
loc_55654:
mov byte ptr [r13+0], 30h ; '0'
inc r13
mov r12d, [rbp+var_E94]
inc ebx
cmp ebx, r12d
jl short loc_55654
loc_5566A:
test r8d, r8d
jle short loc_556B0
cmp r12d, r14d
jl short loc_55683
mov byte ptr [r13+0], 2Eh ; '.'
inc r13
mov r12d, [rbp+var_E94]
loc_55683:
sub r14d, r12d
cmp r14d, r8d
jge short loc_556B0
xor ebx, ebx
test r14d, r14d
cmovg ebx, r14d
not ebx
add ebx, r8d
lea rdx, [rbx+1]
mov rdi, r13
mov esi, 30h ; '0'
call _memset
add r13, rbx
inc r13
loc_556B0:
mov byte ptr [r13+0], 0
mov rax, [rbp+var_EA8]
test rax, rax
mov rbx, [rbp+var_EB8]
jz short loc_556CB
mov byte ptr [rax], 0
loc_556CB:
lea rax, [rbp+var_E90]
cmp r15, rax
setnb al
lea rcx, [rbp+var_30]
cmp rcx, r15
setnbe cl
test al, cl
jnz short loc_556EE
mov rdi, r15
call _free
loc_556EE:
sub r13, rbx
loc_556F1:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_55715
mov rax, r13
add rsp, 0E98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_55715:
call ___stack_chk_fail
| _BYTE * my_fcvt(unsigned int a1, _WORD *a2, _BYTE *a3)
{
unsigned long long v3; // r15
int v4; // r12d
long long v5; // r13
int v6; // ebx
int v7; // r14d
_BYTE *v8; // r13
int v9; // r14d
int v10; // r8d
int v11; // ebx
long long v12; // rcx
_BYTE *v13; // rdx
int v14; // ebx
int v15; // r14d
int v16; // ebx
long long v17; // rbx
_WORD *v18; // rbx
long long v20; // [rsp+0h] [rbp-EC0h] BYREF
_WORD *v21; // [rsp+8h] [rbp-EB8h]
long long v22; // [rsp+10h] [rbp-EB0h]
_BYTE *v23; // [rsp+18h] [rbp-EA8h]
int v24; // [rsp+24h] [rbp-E9Ch] BYREF
int v25; // [rsp+28h] [rbp-E98h]
int v26; // [rsp+2Ch] [rbp-E94h] BYREF
_BYTE v27[3680]; // [rsp+30h] [rbp-E90h] BYREF
_QWORD v28[6]; // [rsp+E90h] [rbp-30h] BYREF
v23 = a3;
v28[0] = __readfsqword(0x28u);
v25 = a1;
v3 = dtoa(5LL, a1, &v26, &v24, &v20, v27);
v4 = v26;
if ( v26 == 9999 )
{
if ( (unsigned long long)v28 <= v3 || v3 < (unsigned long long)v27 )
free(v3);
*a2 = 48;
v5 = 1LL;
if ( v23 )
*v23 = 1;
}
else
{
v6 = v20;
v7 = v20;
v8 = a2;
if ( v24 )
{
v8 = (char *)a2 + 1;
*(_BYTE *)a2 = 45;
}
v21 = a2;
v9 = v7 - v3;
v10 = v25;
if ( v4 <= 0 )
{
*(_WORD *)v8 = 11824;
if ( v4 < 0 )
{
v22 = (unsigned int)~v4;
memset(v8 + 2, 48LL, v22 + 1);
v10 = v25;
v8 += v22 + 3;
}
else
{
v8 += 2;
}
}
if ( v9 <= 0 )
{
v11 = 1;
}
else
{
v11 = v6 - v3 + 1;
v12 = 0LL;
do
{
v13 = v8++;
*v13 = *(_BYTE *)(v3 + v12);
if ( (_DWORD)v12 + 1 == v26 && (int)v12 + 1 < v9 )
{
v13[1] = 46;
v8 = v13 + 2;
}
++v12;
}
while ( v9 != (_DWORD)v12 );
v4 = v26;
}
if ( v11 <= v4 )
{
v14 = v11 - 1;
do
{
*v8++ = 48;
v4 = v26;
++v14;
}
while ( v14 < v26 );
}
if ( v10 > 0 )
{
if ( v4 >= v9 )
{
*v8++ = 46;
v4 = v26;
}
v15 = v9 - v4;
if ( v15 < v10 )
{
v16 = 0;
if ( v15 > 0 )
v16 = v15;
v17 = (unsigned int)(v10 + ~v16);
memset(v8, 48LL, v17 + 1);
v8 += v17 + 1;
}
}
*v8 = 0;
v18 = v21;
if ( v23 )
*v23 = 0;
if ( (unsigned long long)v28 <= v3 || v3 < (unsigned long long)v27 )
free(v3);
return (_BYTE *)(v8 - (_BYTE *)v18);
}
return (_BYTE *)v5;
}
| my_fcvt:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xe98
MOV qword ptr [RBP + -0xea8],RDX
MOV R14,RSI
MOV ESI,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA R13,[RBP + -0xe94]
LEA RCX,[RBP + -0xe9c]
LEA R8,[RBP + -0xec0]
LEA RBX,[RBP + -0xe90]
MOV EDI,0x5
MOV dword ptr [RBP + -0xe98],ESI
MOV RDX,R13
MOV R9,RBX
CALL 0x0015571a
MOV R15,RAX
MOV R12D,dword ptr [R13]
CMP R12D,0x270f
JNZ 0x00155587
CMP R15,RBX
SETNC AL
LEA RCX,[RBP + -0x30]
CMP RCX,R15
SETA CL
TEST AL,CL
JNZ 0x00155563
MOV RDI,R15
CALL 0x00124380
LAB_00155563:
MOV word ptr [R14],0x30
MOV R13D,0x1
MOV RAX,qword ptr [RBP + -0xea8]
TEST RAX,RAX
JZ 0x001556f1
MOV byte ptr [RAX],0x1
JMP 0x001556f1
LAB_00155587:
MOV RBX,qword ptr [RBP + -0xec0]
MOV RAX,R14
MOV R14D,EBX
CMP dword ptr [RBP + -0xe9c],0x0
MOV R13,RAX
JZ 0x001555a7
LEA R13,[RAX + 0x1]
MOV byte ptr [RAX],0x2d
LAB_001555a7:
MOV qword ptr [RBP + -0xeb8],RAX
SUB R14D,R15D
TEST R12D,R12D
MOV R8D,dword ptr [RBP + -0xe98]
JG 0x00155601
MOV word ptr [R13],0x2e30
LEA RDI,[R13 + 0x2]
TEST R12D,R12D
JS 0x001555d2
MOV R13,RDI
JMP 0x00155601
LAB_001555d2:
MOV EAX,R12D
NOT EAX
MOV qword ptr [RBP + -0xeb0],RAX
LEA RDX,[RAX + 0x1]
MOV ESI,0x30
CALL 0x00124170
MOV R8D,dword ptr [RBP + -0xe98]
MOV RAX,qword ptr [RBP + -0xeb0]
ADD R13,RAX
ADD R13,0x3
LAB_00155601:
TEST R14D,R14D
JLE 0x00155648
SUB EBX,R15D
INC EBX
MOV EAX,R14D
XOR ECX,ECX
LAB_00155610:
MOV RDX,R13
LEA ESI,[RCX + 0x1]
MOV DIL,byte ptr [R15 + RCX*0x1]
INC R13
MOV byte ptr [RDX],DIL
CMP ESI,dword ptr [RBP + -0xe94]
JNZ 0x00155638
CMP ESI,R14D
JGE 0x00155638
MOV byte ptr [RDX + 0x1],0x2e
ADD RDX,0x2
MOV R13,RDX
LAB_00155638:
INC RCX
CMP EAX,ECX
JNZ 0x00155610
MOV R12D,dword ptr [RBP + -0xe94]
JMP 0x0015564d
LAB_00155648:
MOV EBX,0x1
LAB_0015564d:
CMP EBX,R12D
JG 0x0015566a
DEC EBX
LAB_00155654:
MOV byte ptr [R13],0x30
INC R13
MOV R12D,dword ptr [RBP + -0xe94]
INC EBX
CMP EBX,R12D
JL 0x00155654
LAB_0015566a:
TEST R8D,R8D
JLE 0x001556b0
CMP R12D,R14D
JL 0x00155683
MOV byte ptr [R13],0x2e
INC R13
MOV R12D,dword ptr [RBP + -0xe94]
LAB_00155683:
SUB R14D,R12D
CMP R14D,R8D
JGE 0x001556b0
XOR EBX,EBX
TEST R14D,R14D
CMOVG EBX,R14D
NOT EBX
ADD EBX,R8D
LEA RDX,[RBX + 0x1]
MOV RDI,R13
MOV ESI,0x30
CALL 0x00124170
ADD R13,RBX
INC R13
LAB_001556b0:
MOV byte ptr [R13],0x0
MOV RAX,qword ptr [RBP + -0xea8]
TEST RAX,RAX
MOV RBX,qword ptr [RBP + -0xeb8]
JZ 0x001556cb
MOV byte ptr [RAX],0x0
LAB_001556cb:
LEA RAX,[RBP + -0xe90]
CMP R15,RAX
SETNC AL
LEA RCX,[RBP + -0x30]
CMP RCX,R15
SETA CL
TEST AL,CL
JNZ 0x001556ee
MOV RDI,R15
CALL 0x00124380
LAB_001556ee:
SUB R13,RBX
LAB_001556f1:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00155715
MOV RAX,R13
ADD RSP,0xe98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00155715:
CALL 0x00124320
|
long my_fcvt(int param_1,int2 *param_2,int1 *param_3)
{
long *__ptr;
int iVar1;
uint uVar2;
uint uVar3;
long lVar4;
int2 *puVar5;
int2 *__s;
int iVar6;
long in_FS_OFFSET;
int local_ec8 [2];
int2 *local_ec0;
ulong local_eb8;
int1 *local_eb0;
int local_ea4;
int local_ea0;
uint local_e9c;
long local_e98 [460];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_eb0 = param_3;
local_ea0 = param_1;
__ptr = (long *)dtoa(5,param_1,&local_e9c,&local_ea4,local_ec8,local_e98);
uVar3 = local_e9c;
if (local_e9c == 9999) {
if (__ptr < local_e98 || &local_38 <= __ptr) {
free(__ptr);
}
*param_2 = 0x30;
lVar4 = 1;
if (local_eb0 != (int1 *)0x0) {
*local_eb0 = 1;
}
}
else {
puVar5 = param_2;
if (local_ea4 != 0) {
puVar5 = (int2 *)((long)param_2 + 1);
*(int1 *)param_2 = 0x2d;
}
iVar6 = local_ec8[0] - (int)__ptr;
__s = puVar5;
local_ec0 = param_2;
if ((int)local_e9c < 1) {
*puVar5 = 0x2e30;
__s = puVar5 + 1;
if ((int)local_e9c < 0) {
local_eb8 = (ulong)~local_e9c;
memset(__s,0x30,local_eb8 + 1);
__s = (int2 *)((long)puVar5 + local_eb8 + 3);
}
}
if (iVar6 < 1) {
iVar1 = 1;
}
else {
iVar1 = (local_ec8[0] - (int)__ptr) + 1;
lVar4 = 0;
puVar5 = __s;
do {
uVar3 = (int)lVar4 + 1;
__s = (int2 *)((long)puVar5 + 1);
*(int1 *)puVar5 = *(int1 *)((long)__ptr + lVar4);
if ((uVar3 == local_e9c) && ((int)uVar3 < iVar6)) {
*(int1 *)((long)puVar5 + 1) = 0x2e;
__s = puVar5 + 1;
}
lVar4 = lVar4 + 1;
puVar5 = __s;
uVar3 = local_e9c;
} while (iVar6 != (int)lVar4);
}
if (iVar1 <= (int)uVar3) {
iVar1 = iVar1 + -1;
do {
*(int1 *)__s = 0x30;
__s = (int2 *)((long)__s + 1);
iVar1 = iVar1 + 1;
uVar3 = local_e9c;
} while (iVar1 < (int)local_e9c);
}
if (0 < local_ea0) {
if (iVar6 <= (int)uVar3) {
*(int1 *)__s = 0x2e;
__s = (int2 *)((long)__s + 1);
uVar3 = local_e9c;
}
uVar3 = iVar6 - uVar3;
if ((int)uVar3 < local_ea0) {
uVar2 = 0;
if (0 < (int)uVar3) {
uVar2 = uVar3;
}
uVar3 = ~uVar2 + local_ea0;
memset(__s,0x30,(ulong)uVar3 + 1);
__s = (int2 *)((long)__s + (ulong)uVar3 + 1);
}
}
puVar5 = local_ec0;
*(int1 *)__s = 0;
if (local_eb0 != (int1 *)0x0) {
*local_eb0 = 0;
}
if (__ptr < local_e98 || &local_38 <= __ptr) {
free(__ptr);
}
lVar4 = (long)__s - (long)puVar5;
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return lVar4;
}
| |
42,809 | malloc | seiftnesse[P]memoryallocator/src/custom_alloc_core.c | void *_malloc(size_t size) {
HEAP_LOG("Memory allocation request: %zu bytes\n", size);
if (size == 0) {
HEAP_LOG("Zero-size allocation requested, returning NULL\n");
return NULL;
}
// Try small allocation first for small sizes
if (size <= SMALL_ALLOCATION_THRESHOLD) {
void *ptr = allocate_small(size);
if (ptr) {
return ptr;
}
HEAP_LOG("Small allocation failed, falling back to regular allocation\n");
// If small allocation failed, fall back to regular allocation
}
EnsureHeapInitialized();
// Calculate required blocks including segment header and alignment
int required_blocks = GetNumBlock(size + sizeof(segment_t) + ALIGNMENT);
HEAP_LOG("Required blocks for allocation: %d (incl. overhead)\n", required_blocks);
// Try last free segment first, then full search
segment_t *it = last_free_segment ? SearchFree(last_free_segment, required_blocks) : NULL;
if (!it) {
HEAP_LOG("Last free segment not suitable, performing full search\n");
it = SearchFree(segments, required_blocks);
}
if (!it) {
HEAP_LOG("Memory allocation failed: no suitable segment found for %zu bytes\n", size);
return NULL; // No suitable memory found
}
// Mark segment as used
it->is_free = 0;
// Set debug tracking info
it->allocation_id = next_allocation_id++;
HEAP_LOG("Assigned allocation ID: %u to segment %p\n", it->allocation_id, it);
// Split if we have enough extra space
if (it->size > required_blocks + 1) {
HEAP_LOG("Splitting segment: original size=%d, required=%d\n", it->size, required_blocks);
segment_t *remaining = CutSegment(it, it->size - required_blocks);
remaining->is_free = 1;
last_free_segment = remaining;
} else {
// We're using the whole segment
if (last_free_segment == it) {
HEAP_LOG("Using entire last free segment, resetting last_free_segment\n");
last_free_segment = NULL;
}
}
// Update allocation statistics
update_stats_allocate(it->size * BLOCK_SIZE);
// Update integrity metadata after allocation
initialize_segment_integrity(it);
// Return aligned user pointer
void *result = SegmentToPtr(it);
HEAP_LOG("Memory allocated: %p, size=%zu bytes, segment=%p\n", result, size, it);
return result;
} | O3 | c | malloc:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x209c
movq %rdi, %rbx
cmpq $0x100, %rdi # imm = 0x100
ja 0x1ff9
movq %rbx, %rdi
callq 0x2484
testq %rax, %rax
jne 0x209e
cmpl $0x0, 0x30f0(%rip) # 0x50f0
jne 0x201d
leaq 0x1030f7(%rip), %rdi # 0x105100
movl $0x4000000, %esi # imm = 0x4000000
callq 0x1f44
movl $0x1, 0x30d3(%rip) # 0x50f0
addq $0x40, %rbx
movq %rbx, %rdi
callq 0x26f3
movl %eax, %r14d
movq 0x30b5(%rip), %rdi # 0x50e8
testq %rdi, %rdi
je 0x2045
movl %r14d, %esi
callq 0x2694
testq %rax, %rax
jne 0x2059
movq 0x3094(%rip), %rdi # 0x50e0
movl %r14d, %esi
callq 0x2694
testq %rax, %rax
je 0x209c
movq %rax, %rbx
movl $0x0, (%rax)
movl 0x3050(%rip), %eax # 0x50b8
leal 0x1(%rax), %ecx
movl %ecx, 0x3047(%rip) # 0x50b8
movl %eax, 0x24(%rbx)
movl 0x4(%rbx), %esi
leal 0x1(%r14), %eax
cmpl %eax, %esi
jle 0x20a6
subl %r14d, %esi
movq %rbx, %rdi
callq 0x270e
movl $0x1, (%rax)
movq %rax, 0x3051(%rip) # 0x50e8
movl 0x4(%rbx), %esi
jmp 0x20ba
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpq %rbx, 0x303b(%rip) # 0x50e8
jne 0x20ba
movq $0x0, 0x302e(%rip) # 0x50e8
shll $0xc, %esi
movslq %esi, %rdi
callq 0x2e01
movq %rbx, %rdi
callq 0x276b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x282c
| _malloc:
push r14
push rbx
push rax
test rdi, rdi
jz loc_209C
mov rbx, rdi
cmp rdi, 100h
ja short loc_1FF9
mov rdi, rbx
call allocate_small
test rax, rax
jnz loc_209E
loc_1FF9:
cmp cs:heap_initialized, 0
jnz short loc_201D
lea rdi, memory
mov esi, offset unk_4000000
call HeapInit
mov cs:heap_initialized, 1
loc_201D:
add rbx, 40h ; '@'
mov rdi, rbx
call GetNumBlock
mov r14d, eax
mov rdi, cs:last_free_segment
test rdi, rdi
jz short loc_2045
mov esi, r14d
call SearchFree
test rax, rax
jnz short loc_2059
loc_2045:
mov rdi, cs:segments
mov esi, r14d
call SearchFree
test rax, rax
jz short loc_209C
loc_2059:
mov rbx, rax
mov dword ptr [rax], 0
mov eax, cs:next_allocation_id
lea ecx, [rax+1]
mov cs:next_allocation_id, ecx
mov [rbx+24h], eax
mov esi, [rbx+4]
lea eax, [r14+1]
cmp esi, eax
jle short loc_20A6
sub esi, r14d
mov rdi, rbx
call CutSegment
mov dword ptr [rax], 1
mov cs:last_free_segment, rax
mov esi, [rbx+4]
jmp short loc_20BA
loc_209C:
xor eax, eax
loc_209E:
add rsp, 8
pop rbx
pop r14
retn
loc_20A6:
cmp cs:last_free_segment, rbx
jnz short loc_20BA
mov cs:last_free_segment, 0
loc_20BA:
shl esi, 0Ch
movsxd rdi, esi
call update_stats_allocate
mov rdi, rbx
call initialize_segment_integrity
mov rdi, rbx
add rsp, 8
pop rbx
pop r14
jmp SegmentToPtr
| long long malloc(unsigned long long a1)
{
long long result; // rax
unsigned int NumBlock; // eax
unsigned int v3; // r14d
_DWORD *v4; // rax
_DWORD *v5; // rbx
int v6; // eax
int v7; // esi
_DWORD *v8; // rax
if ( !a1 )
return 0LL;
if ( a1 <= 0x100 )
{
result = allocate_small(a1);
if ( result )
return result;
}
if ( !heap_initialized )
{
HeapInit((unsigned long long)&memory, (unsigned long long)&unk_4000000);
heap_initialized = 1;
}
NumBlock = GetNumBlock(a1 + 64);
v3 = NumBlock;
if ( !last_free_segment || (v4 = (_DWORD *)SearchFree(last_free_segment, NumBlock)) == 0LL )
{
v4 = (_DWORD *)SearchFree(segments, v3);
if ( !v4 )
return 0LL;
}
v5 = v4;
*v4 = 0;
v6 = next_allocation_id++;
v5[9] = v6;
v7 = v5[1];
if ( v7 <= (int)(v3 + 1) )
{
if ( (_DWORD *)last_free_segment == v5 )
last_free_segment = 0LL;
}
else
{
v8 = (_DWORD *)CutSegment(v5, v7 - v3);
*v8 = 1;
last_free_segment = (long long)v8;
v7 = v5[1];
}
update_stats_allocate(v7 << 12);
initialize_segment_integrity(v5);
return SegmentToPtr(v5);
}
| _malloc:
PUSH R14
PUSH RBX
PUSH RAX
TEST RDI,RDI
JZ 0x0010209c
MOV RBX,RDI
CMP RDI,0x100
JA 0x00101ff9
MOV RDI,RBX
CALL 0x00102484
TEST RAX,RAX
JNZ 0x0010209e
LAB_00101ff9:
CMP dword ptr [0x001050f0],0x0
JNZ 0x0010201d
LEA RDI,[0x205100]
MOV ESI,0x4000000
CALL 0x00101f44
MOV dword ptr [0x001050f0],0x1
LAB_0010201d:
ADD RBX,0x40
MOV RDI,RBX
CALL 0x001026f3
MOV R14D,EAX
MOV RDI,qword ptr [0x001050e8]
TEST RDI,RDI
JZ 0x00102045
MOV ESI,R14D
CALL 0x00102694
TEST RAX,RAX
JNZ 0x00102059
LAB_00102045:
MOV RDI,qword ptr [0x001050e0]
MOV ESI,R14D
CALL 0x00102694
TEST RAX,RAX
JZ 0x0010209c
LAB_00102059:
MOV RBX,RAX
MOV dword ptr [RAX],0x0
MOV EAX,dword ptr [0x001050b8]
LEA ECX,[RAX + 0x1]
MOV dword ptr [0x001050b8],ECX
MOV dword ptr [RBX + 0x24],EAX
MOV ESI,dword ptr [RBX + 0x4]
LEA EAX,[R14 + 0x1]
CMP ESI,EAX
JLE 0x001020a6
SUB ESI,R14D
MOV RDI,RBX
CALL 0x0010270e
MOV dword ptr [RAX],0x1
MOV qword ptr [0x001050e8],RAX
MOV ESI,dword ptr [RBX + 0x4]
JMP 0x001020ba
LAB_0010209c:
XOR EAX,EAX
LAB_0010209e:
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_001020a6:
CMP qword ptr [0x001050e8],RBX
JNZ 0x001020ba
MOV qword ptr [0x001050e8],0x0
LAB_001020ba:
SHL ESI,0xc
MOVSXD RDI,ESI
CALL 0x00102e01
MOV RDI,RBX
CALL 0x0010276b
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x0010282c
|
void * _malloc(size_t __size)
{
int iVar1;
void *pvVar2;
int4 *puVar3;
int iVar4;
if (__size != 0) {
if ((__size < 0x101) && (pvVar2 = (void *)allocate_small(__size), pvVar2 != (void *)0x0)) {
return pvVar2;
}
if (heap_initialized == 0) {
HeapInit(memory,0x4000000);
heap_initialized = 1;
}
iVar1 = GetNumBlock(__size + 0x40);
if (((last_free_segment != (int4 *)0x0) &&
(puVar3 = (int4 *)SearchFree(last_free_segment,iVar1), puVar3 != (int4 *)0x0))
|| (puVar3 = (int4 *)SearchFree(segments,iVar1), puVar3 != (int4 *)0x0)) {
*puVar3 = 0;
iVar4 = next_allocation_id + 1;
puVar3[9] = next_allocation_id;
next_allocation_id = iVar4;
iVar4 = puVar3[1];
if (iVar1 + 1 < iVar4) {
last_free_segment = (int4 *)CutSegment(puVar3,iVar4 - iVar1);
*last_free_segment = 1;
iVar4 = puVar3[1];
}
else if (last_free_segment == puVar3) {
last_free_segment = (int4 *)0x0;
}
update_stats_allocate((long)(iVar4 << 0xc),iVar4 << 0xc);
initialize_segment_integrity(puVar3);
pvVar2 = (void *)SegmentToPtr(puVar3);
return pvVar2;
}
}
return (void *)0x0;
}
| |
42,810 | ggml_tallocr_new_from_buffer | 7CodeWizard[P]stablediffusion/ggml/src/ggml-alloc.c | ggml_tallocr_t ggml_tallocr_new_from_buffer(struct ggml_backend_buffer * buffer) {
ggml_tallocr_t alloc = (ggml_tallocr_t)malloc(sizeof(struct ggml_tallocr));
*alloc = (struct ggml_tallocr) {
/*.buffer = */ buffer,
/*.buffer_owned = */ false,
/*.base = */ ggml_backend_buffer_get_base(buffer),
/*.alignment = */ ggml_backend_buffer_get_alignment(buffer),
/*.n_free_blocks = */ 0,
/*.free_blocks = */ {{0}},
/*.max_size = */ 0,
/*.measure = */ false,
#ifdef GGML_ALLOCATOR_DEBUG
/*.allocated_tensors = */ {0},
#endif
};
ggml_tallocr_reset(alloc);
return alloc;
} | O0 | c | ggml_tallocr_new_from_buffer:
subq $0x1058, %rsp # imm = 0x1058
movq %rdi, 0x1050(%rsp)
movl $0x1038, %edi # imm = 0x1038
callq 0xba00
movq %rax, 0x1048(%rsp)
movq 0x1048(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x1038, %edx # imm = 0x1038
callq 0xb390
movq 0x1050(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x1050(%rsp), %rdi
callq 0x1669b0
movq %rax, 0x20(%rsp)
movq 0x1050(%rsp), %rdi
callq 0x166a70
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
leaq 0x10(%rsp), %rsi
movl $0x1038, %edx # imm = 0x1038
callq 0xb600
movq 0x1048(%rsp), %rdi
callq 0x164b60
movq 0x1048(%rsp), %rax
addq $0x1058, %rsp # imm = 0x1058
retq
nopw %cs:(%rax,%rax)
| ggml_tallocr_new_from_buffer:
sub rsp, 1058h
mov [rsp+1058h+var_8], rdi
mov edi, 1038h
call _malloc
mov [rsp+1058h+var_10], rax
mov rax, [rsp+1058h+var_10]
mov [rsp+1058h+var_1050], rax
lea rdi, [rsp+1058h+var_1048]
xor esi, esi
mov edx, 1038h
call _memset
mov rax, [rsp+1058h+var_8]
mov [rsp+1058h+var_1048], rax
mov rdi, [rsp+1058h+var_8]
call ggml_backend_buffer_get_base
mov [rsp+1058h+var_1038], rax
mov rdi, [rsp+1058h+var_8]
call ggml_backend_buffer_get_alignment
mov rdi, [rsp+1058h+var_1050]
mov [rsp+1058h+var_1030], rax
lea rsi, [rsp+1058h+var_1048]
mov edx, 1038h
call _memcpy
mov rdi, [rsp+1058h+var_10]
call ggml_tallocr_reset
mov rax, [rsp+1058h+var_10]
add rsp, 1058h
retn
| long long ggml_tallocr_new_from_buffer(long long a1)
{
long long v2; // [rsp+8h] [rbp-1050h]
_QWORD v3[519]; // [rsp+10h] [rbp-1048h] BYREF
long long v4; // [rsp+1048h] [rbp-10h]
long long v5; // [rsp+1050h] [rbp-8h]
v5 = a1;
v4 = malloc(4152LL);
v2 = v4;
memset(v3, 0LL, sizeof(v3));
v3[0] = v5;
v3[2] = ggml_backend_buffer_get_base(v5);
v3[3] = ggml_backend_buffer_get_alignment(v5);
memcpy(v2, v3, 4152LL);
ggml_tallocr_reset(v4);
return v4;
}
| |||
42,811 | ggml_tallocr_new_from_buffer | 7CodeWizard[P]stablediffusion/ggml/src/ggml-alloc.c | ggml_tallocr_t ggml_tallocr_new_from_buffer(struct ggml_backend_buffer * buffer) {
ggml_tallocr_t alloc = (ggml_tallocr_t)malloc(sizeof(struct ggml_tallocr));
*alloc = (struct ggml_tallocr) {
/*.buffer = */ buffer,
/*.buffer_owned = */ false,
/*.base = */ ggml_backend_buffer_get_base(buffer),
/*.alignment = */ ggml_backend_buffer_get_alignment(buffer),
/*.n_free_blocks = */ 0,
/*.free_blocks = */ {{0}},
/*.max_size = */ 0,
/*.measure = */ false,
#ifdef GGML_ALLOCATOR_DEBUG
/*.allocated_tensors = */ {0},
#endif
};
ggml_tallocr_reset(alloc);
return alloc;
} | O1 | c | ggml_tallocr_new_from_buffer:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1038, %edi # imm = 0x1038
callq 0xa7c0
movq %rax, %r14
movq %rbx, %rdi
callq 0xb3e61
movq %rax, %r15
movq %rbx, %rdi
callq 0xb3e7d
movq %rbx, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, 0x10(%r14)
movq %rax, 0x18(%r14)
leaq 0x20(%r14), %rdi
movl $0x1018, %edx # imm = 0x1018
xorl %esi, %esi
callq 0xa300
movq %r14, %rdi
callq 0xb2fa2
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
| ggml_tallocr_new_from_buffer:
push r15
push r14
push rbx
mov rbx, rdi
mov edi, 1038h
call _malloc
mov r14, rax
mov rdi, rbx
call ggml_backend_buffer_get_base
mov r15, rax
mov rdi, rbx
call ggml_backend_buffer_get_alignment
mov [r14], rbx
mov qword ptr [r14+8], 0
mov [r14+10h], r15
mov [r14+18h], rax
lea rdi, [r14+20h]
mov edx, 1018h
xor esi, esi
call _memset
mov rdi, r14
call ggml_tallocr_reset
mov rax, r14
pop rbx
pop r14
pop r15
retn
| _QWORD * ggml_tallocr_new_from_buffer(long long a1)
{
_QWORD *v1; // r14
long long base; // r15
long long alignment; // rax
v1 = (_QWORD *)malloc(4152LL);
base = ggml_backend_buffer_get_base(a1);
alignment = ggml_backend_buffer_get_alignment(a1);
*v1 = a1;
v1[1] = 0LL;
v1[2] = base;
v1[3] = alignment;
memset(v1 + 4, 0LL, 4120LL);
ggml_tallocr_reset((long long)v1);
return v1;
}
| |||
42,812 | ggml_tallocr_new_from_buffer | 7CodeWizard[P]stablediffusion/ggml/src/ggml-alloc.c | ggml_tallocr_t ggml_tallocr_new_from_buffer(struct ggml_backend_buffer * buffer) {
ggml_tallocr_t alloc = (ggml_tallocr_t)malloc(sizeof(struct ggml_tallocr));
*alloc = (struct ggml_tallocr) {
/*.buffer = */ buffer,
/*.buffer_owned = */ false,
/*.base = */ ggml_backend_buffer_get_base(buffer),
/*.alignment = */ ggml_backend_buffer_get_alignment(buffer),
/*.n_free_blocks = */ 0,
/*.free_blocks = */ {{0}},
/*.max_size = */ 0,
/*.measure = */ false,
#ifdef GGML_ALLOCATOR_DEBUG
/*.allocated_tensors = */ {0},
#endif
};
ggml_tallocr_reset(alloc);
return alloc;
} | O2 | c | ggml_tallocr_new_from_buffer:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1038, %edi # imm = 0x1038
callq 0xa7e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x8fc60
movq %rax, %r15
movq %rbx, %rdi
callq 0x8fcb9
movq %rbx, (%r14)
andq $0x0, 0x8(%r14)
movq %r15, 0x10(%r14)
movq %rax, 0x18(%r14)
leaq 0x20(%r14), %rdi
movl $0x1018, %edx # imm = 0x1018
xorl %esi, %esi
callq 0xa2f0
movq %r14, %rdi
callq 0x8eea9
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
| ggml_tallocr_new_from_buffer:
push r15
push r14
push rbx
mov rbx, rdi
mov edi, 1038h
call _malloc
mov r14, rax
mov rdi, rbx
call ggml_backend_buffer_get_base
mov r15, rax
mov rdi, rbx
call ggml_backend_buffer_get_alignment
mov [r14], rbx
and qword ptr [r14+8], 0
mov [r14+10h], r15
mov [r14+18h], rax
lea rdi, [r14+20h]
mov edx, 1018h
xor esi, esi
call _memset
mov rdi, r14
call ggml_tallocr_reset
mov rax, r14
pop rbx
pop r14
pop r15
retn
| _QWORD * ggml_tallocr_new_from_buffer(long long a1)
{
_QWORD *v1; // r14
long long base; // r15
long long alignment; // rax
v1 = (_QWORD *)malloc(4152LL);
base = ggml_backend_buffer_get_base(a1);
alignment = ggml_backend_buffer_get_alignment(a1);
*v1 = a1;
v1[1] = 0LL;
v1[2] = base;
v1[3] = alignment;
memset(v1 + 4, 0LL, 4120LL);
ggml_tallocr_reset((long long)v1);
return v1;
}
| ggml_tallocr_new_from_buffer:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV EDI,0x1038
CALL 0x0010a7e0
MOV R14,RAX
MOV RDI,RBX
CALL 0x0018fc60
MOV R15,RAX
MOV RDI,RBX
CALL 0x0018fcb9
MOV qword ptr [R14],RBX
AND qword ptr [R14 + 0x8],0x0
MOV qword ptr [R14 + 0x10],R15
MOV qword ptr [R14 + 0x18],RAX
LEA RDI,[R14 + 0x20]
MOV EDX,0x1018
XOR ESI,ESI
CALL 0x0010a2f0
MOV RDI,R14
CALL 0x0018eea9
MOV RAX,R14
POP RBX
POP R14
POP R15
RET
|
int8 * ggml_tallocr_new_from_buffer(int8 param_1)
{
int8 *puVar1;
int8 uVar2;
int8 uVar3;
puVar1 = (int8 *)malloc(0x1038);
uVar2 = ggml_backend_buffer_get_base(param_1);
uVar3 = ggml_backend_buffer_get_alignment(param_1);
*puVar1 = param_1;
puVar1[1] = 0;
puVar1[2] = uVar2;
puVar1[3] = uVar3;
memset(puVar1 + 4,0,0x1018);
ggml_tallocr_reset(puVar1);
return puVar1;
}
| |
42,813 | ggml_tallocr_new_from_buffer | 7CodeWizard[P]stablediffusion/ggml/src/ggml-alloc.c | ggml_tallocr_t ggml_tallocr_new_from_buffer(struct ggml_backend_buffer * buffer) {
ggml_tallocr_t alloc = (ggml_tallocr_t)malloc(sizeof(struct ggml_tallocr));
*alloc = (struct ggml_tallocr) {
/*.buffer = */ buffer,
/*.buffer_owned = */ false,
/*.base = */ ggml_backend_buffer_get_base(buffer),
/*.alignment = */ ggml_backend_buffer_get_alignment(buffer),
/*.n_free_blocks = */ 0,
/*.free_blocks = */ {{0}},
/*.max_size = */ 0,
/*.measure = */ false,
#ifdef GGML_ALLOCATOR_DEBUG
/*.allocated_tensors = */ {0},
#endif
};
ggml_tallocr_reset(alloc);
return alloc;
} | O3 | c | ggml_tallocr_new_from_buffer:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1038, %edi # imm = 0x1038
callq 0xa7b0
movq %rax, %r14
movq %rbx, %rdi
callq 0xb2a49
movq %rax, %r15
movq %rbx, %rdi
callq 0xb2a65
movq %rbx, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, 0x10(%r14)
movq %rax, 0x18(%r14)
leaq 0x20(%r14), %rdi
movl $0x1018, %edx # imm = 0x1018
xorl %esi, %esi
callq 0xa2f0
movq %r14, %rdi
callq 0xb1c3f
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
| ggml_tallocr_new_from_buffer:
push r15
push r14
push rbx
mov rbx, rdi
mov edi, 1038h
call _malloc
mov r14, rax
mov rdi, rbx
call ggml_backend_buffer_get_base
mov r15, rax
mov rdi, rbx
call ggml_backend_buffer_get_alignment
mov [r14], rbx
mov qword ptr [r14+8], 0
mov [r14+10h], r15
mov [r14+18h], rax
lea rdi, [r14+20h]
mov edx, 1018h
xor esi, esi
call _memset
mov rdi, r14
call ggml_tallocr_reset
mov rax, r14
pop rbx
pop r14
pop r15
retn
| _QWORD * ggml_tallocr_new_from_buffer(long long a1)
{
_QWORD *v1; // r14
long long base; // r15
long long alignment; // rax
v1 = (_QWORD *)malloc(4152LL);
base = ggml_backend_buffer_get_base(a1);
alignment = ggml_backend_buffer_get_alignment(a1);
*v1 = a1;
v1[1] = 0LL;
v1[2] = base;
v1[3] = alignment;
memset(v1 + 4, 0LL, 4120LL);
ggml_tallocr_reset((long long)v1);
return v1;
}
| |||
42,814 | update_token_ident | bluesky950520[P]quickjs/quickjs.c | static void update_token_ident(JSParseState *s)
{
if (s->token.u.ident.atom <= JS_ATOM_LAST_KEYWORD ||
(s->token.u.ident.atom <= JS_ATOM_LAST_STRICT_KEYWORD &&
s->cur_func->is_strict_mode) ||
(s->token.u.ident.atom == JS_ATOM_yield &&
((s->cur_func->func_kind & JS_FUNC_GENERATOR) ||
(s->cur_func->func_type == JS_PARSE_FUNC_ARROW &&
!s->cur_func->in_function_body && s->cur_func->parent &&
(s->cur_func->parent->func_kind & JS_FUNC_GENERATOR)))) ||
(s->token.u.ident.atom == JS_ATOM_await &&
(s->is_module ||
(s->cur_func->func_kind & JS_FUNC_ASYNC) ||
s->cur_func->func_type == JS_PARSE_FUNC_CLASS_STATIC_INIT ||
(s->cur_func->func_type == JS_PARSE_FUNC_ARROW &&
!s->cur_func->in_function_body && s->cur_func->parent &&
((s->cur_func->parent->func_kind & JS_FUNC_ASYNC) ||
s->cur_func->parent->func_type == JS_PARSE_FUNC_CLASS_STATIC_INIT))))) {
if (s->token.u.ident.has_escape) {
s->token.u.ident.is_reserved = TRUE;
s->token.val = TOK_IDENT;
} else {
/* The keywords atoms are pre allocated */
s->token.val = s->token.u.ident.atom - 1 + TOK_FIRST_KEYWORD;
}
}
} | O3 | c | update_token_ident:
movl 0x38(%rdi), %eax
cmpl $0x25, %eax
jae 0x61990
cmpl $0x0, 0x3c(%rdi)
je 0x619da
movl $0x1, 0x40(%rdi)
movl $0xffffff83, %eax # imm = 0xFFFFFF83
jmp 0x619dd
cmpl $0x2d, %eax
ja 0x619e1
movq 0x90(%rdi), %rcx
movzwl 0x84(%rcx), %edx
testw %dx, %dx
js 0x6197c
cmpl $0x2d, %eax
jne 0x619e0
testb $0x1, %dl
jne 0x6197c
andl $0x7f00, %edx # imm = 0x7F00
cmpl $0x300, %edx # imm = 0x300
jne 0x619e0
cmpl $0x0, 0x7c(%rcx)
jne 0x619e0
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x619e0
testb $0x1, 0x84(%rcx)
jne 0x6197c
jmp 0x619e0
addl $-0x56, %eax
movl %eax, 0x20(%rdi)
retq
cmpl $0x2e, %eax
jne 0x619e0
cmpl $0x0, 0x98(%rdi)
jne 0x6197c
movq 0x90(%rdi), %rcx
movzwl 0x84(%rcx), %edx
testb $0x2, %dl
jne 0x6197c
shrl $0x8, %edx
andl $0x7f, %edx
cmpl $0x7, %edx
je 0x6197c
cmpl $0x3, %edx
jne 0x619e0
cmpl $0x0, 0x7c(%rcx)
jne 0x619e0
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x619e0
movzwl 0x84(%rcx), %ecx
testb $0x2, %cl
sete %dl
andl $0x7f00, %ecx # imm = 0x7F00
cmpl $0x700, %ecx # imm = 0x700
setne %cl
testb %cl, %dl
je 0x6197c
jmp 0x619e0
| update_token_ident:
mov eax, [rdi+38h]
cmp eax, 25h ; '%'
jnb short loc_61990
loc_6197C:
cmp dword ptr [rdi+3Ch], 0
jz short loc_619DA
mov dword ptr [rdi+40h], 1
mov eax, 0FFFFFF83h
jmp short loc_619DD
loc_61990:
cmp eax, 2Dh ; '-'
ja short loc_619E1
mov rcx, [rdi+90h]
movzx edx, word ptr [rcx+84h]
test dx, dx
js short loc_6197C
cmp eax, 2Dh ; '-'
jnz short locret_619E0
test dl, 1
jnz short loc_6197C
and edx, 7F00h
cmp edx, 300h
jnz short locret_619E0
cmp dword ptr [rcx+7Ch], 0
jnz short locret_619E0
mov rcx, [rcx+8]
test rcx, rcx
jz short locret_619E0
test byte ptr [rcx+84h], 1
jnz short loc_6197C
jmp short locret_619E0
loc_619DA:
add eax, 0FFFFFFAAh
loc_619DD:
mov [rdi+20h], eax
locret_619E0:
retn
loc_619E1:
cmp eax, 2Eh ; '.'
jnz short locret_619E0
cmp dword ptr [rdi+98h], 0
jnz short loc_6197C
mov rcx, [rdi+90h]
movzx edx, word ptr [rcx+84h]
test dl, 2
jnz loc_6197C
shr edx, 8
and edx, 7Fh
cmp edx, 7
jz loc_6197C
cmp edx, 3
jnz short locret_619E0
cmp dword ptr [rcx+7Ch], 0
jnz short locret_619E0
mov rcx, [rcx+8]
test rcx, rcx
jz short locret_619E0
movzx ecx, word ptr [rcx+84h]
test cl, 2
setz dl
and ecx, 7F00h
cmp ecx, 700h
setnz cl
test dl, cl
jz loc_6197C
jmp short locret_619E0
| long long update_token_ident(long long a1)
{
long long result; // rax
long long v2; // rcx
__int16 v3; // dx
long long v4; // rcx
long long v5; // rcx
unsigned int v6; // edx
int v7; // edx
long long v8; // rcx
result = *(unsigned int *)(a1 + 56);
if ( (unsigned int)result >= 0x25 )
{
if ( (unsigned int)result > 0x2D )
{
if ( (_DWORD)result != 46 )
return result;
if ( !*(_DWORD *)(a1 + 152) )
{
v5 = *(_QWORD *)(a1 + 144);
v6 = *(unsigned __int16 *)(v5 + 132);
if ( (v6 & 2) == 0 )
{
v7 = (v6 >> 8) & 0x7F;
if ( v7 != 7 )
{
if ( v7 != 3 )
return result;
if ( *(_DWORD *)(v5 + 124) )
return result;
v8 = *(_QWORD *)(v5 + 8);
if ( !v8 || (*(_WORD *)(v8 + 132) & 0x7F00) != 1792 && (*(_WORD *)(v8 + 132) & 2) == 0 )
return result;
}
}
}
}
else
{
v2 = *(_QWORD *)(a1 + 144);
v3 = *(_WORD *)(v2 + 132);
if ( v3 >= 0 )
{
if ( (_DWORD)result != 45 )
return result;
if ( (v3 & 1) == 0 )
{
if ( (v3 & 0x7F00) != 0x300 )
return result;
if ( *(_DWORD *)(v2 + 124) )
return result;
v4 = *(_QWORD *)(v2 + 8);
if ( !v4 || (*(_BYTE *)(v4 + 132) & 1) == 0 )
return result;
}
}
}
}
if ( *(_DWORD *)(a1 + 60) )
{
*(_DWORD *)(a1 + 64) = 1;
result = 4294967171LL;
}
else
{
result = (unsigned int)(result - 86);
}
*(_DWORD *)(a1 + 32) = result;
return result;
}
| update_token_ident:
MOV EAX,dword ptr [RDI + 0x38]
CMP EAX,0x25
JNC 0x00161990
LAB_0016197c:
CMP dword ptr [RDI + 0x3c],0x0
JZ 0x001619da
MOV dword ptr [RDI + 0x40],0x1
MOV EAX,0xffffff83
JMP 0x001619dd
LAB_00161990:
CMP EAX,0x2d
JA 0x001619e1
MOV RCX,qword ptr [RDI + 0x90]
MOVZX EDX,word ptr [RCX + 0x84]
TEST DX,DX
JS 0x0016197c
CMP EAX,0x2d
JNZ 0x001619e0
TEST DL,0x1
JNZ 0x0016197c
AND EDX,0x7f00
CMP EDX,0x300
JNZ 0x001619e0
CMP dword ptr [RCX + 0x7c],0x0
JNZ 0x001619e0
MOV RCX,qword ptr [RCX + 0x8]
TEST RCX,RCX
JZ 0x001619e0
TEST byte ptr [RCX + 0x84],0x1
JNZ 0x0016197c
JMP 0x001619e0
LAB_001619da:
ADD EAX,-0x56
LAB_001619dd:
MOV dword ptr [RDI + 0x20],EAX
LAB_001619e0:
RET
LAB_001619e1:
CMP EAX,0x2e
JNZ 0x001619e0
CMP dword ptr [RDI + 0x98],0x0
JNZ 0x0016197c
MOV RCX,qword ptr [RDI + 0x90]
MOVZX EDX,word ptr [RCX + 0x84]
TEST DL,0x2
JNZ 0x0016197c
SHR EDX,0x8
AND EDX,0x7f
CMP EDX,0x7
JZ 0x0016197c
CMP EDX,0x3
JNZ 0x001619e0
CMP dword ptr [RCX + 0x7c],0x0
JNZ 0x001619e0
MOV RCX,qword ptr [RCX + 0x8]
TEST RCX,RCX
JZ 0x001619e0
MOVZX ECX,word ptr [RCX + 0x84]
TEST CL,0x2
SETZ DL
AND ECX,0x7f00
CMP ECX,0x700
SETNZ CL
TEST DL,CL
JZ 0x0016197c
JMP 0x001619e0
|
void update_token_ident(long param_1)
{
uint uVar1;
long lVar2;
int iVar3;
ushort uVar4;
uVar1 = *(uint *)(param_1 + 0x38);
if (0x24 < uVar1) {
if (uVar1 < 0x2e) {
lVar2 = *(long *)(param_1 + 0x90);
uVar4 = *(ushort *)(lVar2 + 0x84);
if (-1 < (short)uVar4) {
if (uVar1 != 0x2d) {
return;
}
if ((uVar4 & 1) == 0) {
if ((uVar4 & 0x7f00) != 0x300) {
return;
}
if (*(int *)(lVar2 + 0x7c) != 0) {
return;
}
if (*(long *)(lVar2 + 8) == 0) {
return;
}
if ((*(byte *)(*(long *)(lVar2 + 8) + 0x84) & 1) == 0) {
return;
}
}
}
}
else {
if (uVar1 != 0x2e) {
return;
}
if (*(int *)(param_1 + 0x98) == 0) {
lVar2 = *(long *)(param_1 + 0x90);
if (((*(ushort *)(lVar2 + 0x84) & 2) == 0) &&
(uVar4 = *(ushort *)(lVar2 + 0x84) >> 8 & 0x7f, uVar4 != 7)) {
if (uVar4 != 3) {
return;
}
if (*(int *)(lVar2 + 0x7c) != 0) {
return;
}
if (*(long *)(lVar2 + 8) == 0) {
return;
}
uVar4 = *(ushort *)(*(long *)(lVar2 + 8) + 0x84);
if ((uVar4 & 2) == 0 && (uVar4 & 0x7f00) != 0x700) {
return;
}
}
}
}
}
if (*(int *)(param_1 + 0x3c) == 0) {
iVar3 = uVar1 - 0x56;
}
else {
*(int4 *)(param_1 + 0x40) = 1;
iVar3 = -0x7d;
}
*(int *)(param_1 + 0x20) = iVar3;
return;
}
| |
42,815 | mysql_open_cursor(THD*, select_result*, Server_side_cursor**) | eloqsql/sql/sql_cursor.cc | int mysql_open_cursor(THD *thd, select_result *result,
Server_side_cursor **pcursor)
{
sql_digest_state *parent_digest;
PSI_statement_locker *parent_locker;
select_result *save_result;
Select_materialize *result_materialize;
LEX *lex= thd->lex;
int rc;
if (!(result_materialize= new (thd->mem_root) Select_materialize(thd, result)))
return 1;
save_result= lex->result;
lex->result= result_materialize;
MYSQL_QUERY_EXEC_START(thd->query(),
thd->thread_id,
thd->get_db(),
&thd->security_ctx->priv_user[0],
(char *) thd->security_ctx->host_or_ip,
2);
parent_digest= thd->m_digest;
parent_locker= thd->m_statement_psi;
thd->m_digest= NULL;
thd->m_statement_psi= NULL;
/* Mark that we can't use query cache with cursors */
thd->query_cache_is_applicable= 0;
rc= mysql_execute_command(thd);
thd->lex->restore_set_statement_var();
thd->m_digest= parent_digest;
thd->m_statement_psi= parent_locker;
MYSQL_QUERY_EXEC_DONE(rc);
lex->result= save_result;
/*
Possible options here:
- a materialized cursor is open. In this case rc is 0 and
result_materialize->materialized is not NULL
- an error occurred during materialization.
result_materialize->materialized_cursor is not NULL, but rc != 0
- successful completion of mysql_execute_command without
a cursor: rc is 0, result_materialize->materialized_cursor is NULL.
This is possible if some command writes directly to the
network, bypassing select_result mechanism. An example of
such command is SHOW VARIABLES or SHOW STATUS.
*/
if (rc)
{
if (result_materialize->materialized_cursor)
{
/* Rollback metadata in the client-server protocol. */
result_materialize->abort_result_set();
delete result_materialize->materialized_cursor;
}
goto end;
}
if (result_materialize->materialized_cursor)
{
Materialized_cursor *materialized_cursor=
result_materialize->materialized_cursor;
/*
NOTE: close_thread_tables() has been called in
mysql_execute_command(), so all tables except from the cursor
temporary table have been closed.
*/
if ((rc= materialized_cursor->open(0)))
{
delete materialized_cursor;
goto end;
}
*pcursor= materialized_cursor;
rc|= (thd->stmt_arena->cleanup_stmt(true)? 1 : 0);
}
end:
delete result_materialize;
return rc;
} | O0 | cpp | mysql_open_cursor(THD*, select_result*, Server_side_cursor**):
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq %rsi, -0x80(%rbp)
movl $0xf8, %edi
callq 0x886b10
movq %rax, %rcx
movq %rcx, -0x78(%rbp)
movb $0x0, -0x4d(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x70(%rbp)
je 0x987021
movq -0x78(%rbp), %rdi
movb $0x1, -0x4d(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x987d40
jmp 0x987017
movq -0x78(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0x987021
movq -0x70(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x987061
movl $0x1, -0x4(%rbp)
jmp 0x987207
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
testb $0x1, -0x4d(%rbp)
jne 0x98704f
jmp 0x98705c
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0x886b80
jmp 0x987213
movq -0x48(%rbp), %rax
movq 0xdb0(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0xdb0(%rax)
movq -0x10(%rbp), %rax
movq 0x3b48(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x3b90(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x3b48(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x3b90(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0xb8(%rax)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x9e5ba0
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x9b85b0
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x3b48(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x3b90(%rax)
movq -0x38(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0xdb0(%rax)
cmpl $0x0, -0x4c(%rbp)
je 0x987158
movq -0x40(%rbp), %rax
cmpq $0x0, 0xf0(%rax)
je 0x987153
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
movq -0x40(%rbp), %rax
movq 0xf0(%rax), %rax
movq %rax, -0x88(%rbp)
cmpq $0x0, %rax
je 0x987151
movq -0x88(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x987153
jmp 0x9871e3
movq -0x40(%rbp), %rax
cmpq $0x0, 0xf0(%rax)
je 0x9871e1
movq -0x40(%rbp), %rax
movq 0xf0(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
xorl %ecx, %ecx
movl %ecx, %esi
callq *0x28(%rax)
movl %eax, -0x4c(%rbp)
cmpl $0x0, %eax
je 0x9871ab
movq -0x68(%rbp), %rax
movq %rax, -0x90(%rbp)
cmpq $0x0, %rax
je 0x9871a9
movq -0x90(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x9871e3
movq -0x68(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x3a40(%rax), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x18(%rax)
movb %al, %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
orl -0x4c(%rbp), %eax
movl %eax, -0x4c(%rbp)
jmp 0x9871e3
movq -0x40(%rbp), %rax
movq %rax, -0x98(%rbp)
cmpq $0x0, %rax
je 0x987201
movq -0x98(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl -0x4c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x775a20
nopl (%rax)
| _Z17mysql_open_cursorP3THDP13select_resultPP18Server_side_cursor:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov [rbp+var_48], rax
mov rax, [rbp+var_10]
mov rsi, [rax+28h]
mov [rbp+var_80], rsi
mov edi, 0F8h
call _ZN9Sql_allocnwEmP11st_mem_root; Sql_alloc::operator new(ulong,st_mem_root *)
mov rcx, rax
mov [rbp+var_78], rcx
mov [rbp+var_4D], 0
xor eax, eax
cmp rcx, 0
mov [rbp+var_70], rax
jz short loc_987021
mov rdi, [rbp+var_78]; this
mov [rbp+var_4D], 1
mov rsi, [rbp+var_10]; THD *
mov rdx, [rbp+var_18]; select_result *
call _ZN18Select_materializeC2EP3THDP13select_result; Select_materialize::Select_materialize(THD *,select_result *)
jmp short $+2
loc_987017:
mov rax, [rbp+var_78]
mov [rbp+var_70], rax
jmp short $+2
loc_987021:
mov rax, [rbp+var_70]
mov [rbp+var_40], rax
cmp rax, 0
jnz short loc_987061
mov [rbp+var_4], 1
jmp loc_987207
mov rcx, rax
mov eax, edx
mov [rbp+var_58], rcx
mov [rbp+var_5C], eax
test [rbp+var_4D], 1
jnz short loc_98704F
jmp short loc_98705C
loc_98704F:
mov rsi, [rbp+var_80]
mov rdi, [rbp+var_78]
call _ZN9Sql_allocdlEPvP11st_mem_root; Sql_alloc::operator delete(void *,st_mem_root *)
loc_98705C:
jmp loc_987213
loc_987061:
mov rax, [rbp+var_48]
mov rax, [rax+0DB0h]
mov [rbp+var_38], rax
mov rcx, [rbp+var_40]
mov rax, [rbp+var_48]
mov [rax+0DB0h], rcx
mov rax, [rbp+var_10]
mov rax, [rax+3B48h]
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov rax, [rax+3B90h]
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov qword ptr [rax+3B48h], 0
mov rax, [rbp+var_10]
mov qword ptr [rax+3B90h], 0
mov rax, [rbp+var_10]
mov byte ptr [rax+0B8h], 0
mov rdi, [rbp+var_10]; THD *
xor esi, esi; bool
call _Z21mysql_execute_commandP3THDb; mysql_execute_command(THD *,bool)
mov [rbp+var_4C], eax
mov rax, [rbp+var_10]
mov rdi, [rax+58h]; this
call _ZN3LEX25restore_set_statement_varEv; LEX::restore_set_statement_var(void)
mov rcx, [rbp+var_28]
mov rax, [rbp+var_10]
mov [rax+3B48h], rcx
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax+3B90h], rcx
mov rcx, [rbp+var_38]
mov rax, [rbp+var_48]
mov [rax+0DB0h], rcx
cmp [rbp+var_4C], 0
jz short loc_987158
mov rax, [rbp+var_40]
cmp qword ptr [rax+0F0h], 0
jz short loc_987153
mov rdi, [rbp+var_40]
mov rax, [rdi]
call qword ptr [rax+58h]
mov rax, [rbp+var_40]
mov rax, [rax+0F0h]
mov [rbp+var_88], rax
cmp rax, 0
jz short loc_987151
mov rdi, [rbp+var_88]
mov rax, [rdi]
call qword ptr [rax+10h]
loc_987151:
jmp short $+2
loc_987153:
jmp loc_9871E3
loc_987158:
mov rax, [rbp+var_40]
cmp qword ptr [rax+0F0h], 0
jz short loc_9871E1
mov rax, [rbp+var_40]
mov rax, [rax+0F0h]
mov [rbp+var_68], rax
mov rdi, [rbp+var_68]
mov rax, [rdi]
xor ecx, ecx
mov esi, ecx
call qword ptr [rax+28h]
mov [rbp+var_4C], eax
cmp eax, 0
jz short loc_9871AB
mov rax, [rbp+var_68]
mov [rbp+var_90], rax
cmp rax, 0
jz short loc_9871A9
mov rdi, [rbp+var_90]
mov rax, [rdi]
call qword ptr [rax+10h]
loc_9871A9:
jmp short loc_9871E3
loc_9871AB:
mov rcx, [rbp+var_68]
mov rax, [rbp+var_20]
mov [rax], rcx
mov rax, [rbp+var_10]
mov rdi, [rax+3A40h]
mov rax, [rdi]
mov esi, 1
call qword ptr [rax+18h]
mov dl, al
xor eax, eax
mov ecx, 1
test dl, 1
cmovnz eax, ecx
or eax, [rbp+var_4C]
mov [rbp+var_4C], eax
loc_9871E1:
jmp short $+2
loc_9871E3:
mov rax, [rbp+var_40]
mov [rbp+var_98], rax
cmp rax, 0
jz short loc_987201
mov rdi, [rbp+var_98]
mov rax, [rdi]
call qword ptr [rax+10h]
loc_987201:
mov eax, [rbp+var_4C]
mov [rbp+var_4], eax
loc_987207:
mov eax, [rbp+var_4]
add rsp, 0A0h
pop rbp
retn
loc_987213:
mov rdi, [rbp+var_58]
call __Unwind_Resume
| long long mysql_open_cursor(THD *a1, select_result *a2, Server_side_cursor **a3)
{
long long v4; // [rsp+18h] [rbp-88h]
Select_materialize *v5; // [rsp+28h] [rbp-78h]
Select_materialize *v6; // [rsp+30h] [rbp-70h]
Server_side_cursor *v7; // [rsp+38h] [rbp-68h]
unsigned int v8; // [rsp+54h] [rbp-4Ch]
long long v9; // [rsp+58h] [rbp-48h]
long long v10; // [rsp+68h] [rbp-38h]
long long v11; // [rsp+70h] [rbp-30h]
long long v12; // [rsp+78h] [rbp-28h]
v9 = *((_QWORD *)a1 + 11);
v5 = (Select_materialize *)Sql_alloc::operator new(248LL, *((_QWORD *)a1 + 5));
v6 = 0LL;
if ( v5 )
{
Select_materialize::Select_materialize(v5, a1, a2);
v6 = v5;
}
if ( v6 )
{
v10 = *(_QWORD *)(v9 + 3504);
*(_QWORD *)(v9 + 3504) = v6;
v12 = *((_QWORD *)a1 + 1897);
v11 = *((_QWORD *)a1 + 1906);
*((_QWORD *)a1 + 1897) = 0LL;
*((_QWORD *)a1 + 1906) = 0LL;
*((_BYTE *)a1 + 184) = 0;
v8 = mysql_execute_command(a1, 0);
LEX::restore_set_statement_var(*((LEX **)a1 + 11));
*((_QWORD *)a1 + 1897) = v12;
*((_QWORD *)a1 + 1906) = v11;
*(_QWORD *)(v9 + 3504) = v10;
if ( v8 )
{
if ( *((_QWORD *)v6 + 30) )
{
(*(void ( **)(Select_materialize *))(*(_QWORD *)v6 + 88LL))(v6);
v4 = *((_QWORD *)v6 + 30);
if ( v4 )
(*(void ( **)(long long))(*(_QWORD *)v4 + 16LL))(v4);
}
}
else if ( *((_QWORD *)v6 + 30) )
{
v7 = (Server_side_cursor *)*((_QWORD *)v6 + 30);
v8 = (*(long long ( **)(Server_side_cursor *, _QWORD))(*(_QWORD *)v7 + 40LL))(v7, 0LL);
if ( v8 )
{
if ( v7 )
(*(void ( **)(Server_side_cursor *))(*(_QWORD *)v7 + 16LL))(v7);
}
else
{
*a3 = v7;
v8 = ((*(long long ( **)(_QWORD, long long))(**((_QWORD **)a1 + 1864) + 24LL))(
*((_QWORD *)a1 + 1864),
1LL) & 1) != 0;
}
}
(*(void ( **)(Select_materialize *))(*(_QWORD *)v6 + 16LL))(v6);
return v8;
}
else
{
return 1;
}
}
| operator():
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
POP RBP
RET
|
/* std::_Select1st<std::pair<unsigned int const, unsigned int>
>::TEMPNAMEPLACEHOLDERVALUE(std::pair<unsigned int const, unsigned int> const&) const */
pair * __thiscall
std::_Select1st<std::pair<unsigned_int_const,unsigned_int>>::operator()
(_Select1st<std::pair<unsigned_int_const,unsigned_int>> *this,pair *param_1)
{
return param_1;
}
| |
42,816 | JS_EvalFunctionInternal | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_EvalFunctionInternal(JSContext *ctx, JSValue fun_obj,
JSValue this_obj,
JSVarRef **var_refs, JSStackFrame *sf)
{
JSValue ret_val;
uint32_t tag;
tag = JS_VALUE_GET_TAG(fun_obj);
if (tag == JS_TAG_FUNCTION_BYTECODE) {
fun_obj = js_closure(ctx, fun_obj, var_refs, sf);
ret_val = JS_CallFree(ctx, fun_obj, this_obj, 0, NULL);
} else if (tag == JS_TAG_MODULE) {
JSModuleDef *m;
m = JS_VALUE_GET_PTR(fun_obj);
/* the module refcount should be >= 2 */
JS_FreeValue(ctx, fun_obj);
if (js_create_module_function(ctx, m) < 0)
goto fail;
if (js_link_module(ctx, m) < 0)
goto fail;
ret_val = js_evaluate_module(ctx, m);
if (JS_IsException(ret_val)) {
fail:
return JS_EXCEPTION;
}
} else {
JS_FreeValue(ctx, fun_obj);
ret_val = JS_ThrowTypeError(ctx, "bytecode function expected");
}
return ret_val;
} | O0 | c | JS_EvalFunctionInternal:
subq $0xa8, %rsp
movq 0xb0(%rsp), %rax
movq %rsi, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x78(%rsp)
movq %r8, 0x80(%rsp)
movq %rdi, 0x70(%rsp)
movq %r9, 0x68(%rsp)
movq 0x90(%rsp), %rax
movl %eax, 0x54(%rsp)
cmpl $-0x2, 0x54(%rsp)
jne 0x4aa6f
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rcx
movq 0xb0(%rsp), %r8
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
callq 0x64010
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x70(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
movq 0x78(%rsp), %rcx
movq 0x80(%rsp), %r8
xorl %r9d, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0x2e280
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x4ab78
cmpl $-0x3, 0x54(%rsp)
jne 0x4ab2b
movq 0x88(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x70(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
callq 0x23c90
movq 0x70(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x752f0
cmpl $0x0, %eax
jge 0x4aab7
jmp 0x4ab10
movq 0x70(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x75480
cmpl $0x0, %eax
jge 0x4aacd
jmp 0x4ab10
movq 0x70(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x75510
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0x4ab29
jmp 0x4ab10
movl $0x0, 0x98(%rsp)
movq $0x6, 0xa0(%rsp)
jmp 0x4ab92
jmp 0x4ab76
movq 0x70(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
callq 0x23c90
movq 0x70(%rsp), %rdi
leaq 0xc3d10(%rip), %rsi # 0x10e861
movb $0x0, %al
callq 0x2d300
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x4ab78
movq 0x58(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0x98(%rsp), %rax
movq 0xa0(%rsp), %rdx
addq $0xa8, %rsp
retq
nopw (%rax,%rax)
| JS_EvalFunctionInternal:
sub rsp, 0A8h
mov rax, [rsp+0A8h+arg_0]
mov [rsp+0A8h+var_20], rsi
mov [rsp+0A8h+var_18], rdx
mov [rsp+0A8h+var_30], rcx
mov [rsp+0A8h+var_28], r8
mov [rsp+0A8h+var_38], rdi
mov [rsp+0A8h+var_40], r9
mov rax, [rsp+0A8h+var_18]
mov [rsp+0A8h+var_54], eax
cmp [rsp+0A8h+var_54], 0FFFFFFFEh
jnz loc_4AA6F
mov rdi, [rsp+0A8h+var_38]
mov rcx, [rsp+0A8h+var_40]
mov r8, [rsp+0A8h+arg_0]
mov rsi, [rsp+0A8h+var_20]
mov rdx, [rsp+0A8h+var_18]
call js_closure
mov [rsp+0A8h+var_68], rax
mov [rsp+0A8h+var_60], rdx
mov rax, [rsp+0A8h+var_68]
mov [rsp+0A8h+var_20], rax
mov rax, [rsp+0A8h+var_60]
mov [rsp+0A8h+var_18], rax
mov rdi, [rsp+0A8h+var_38]
mov rsi, [rsp+0A8h+var_20]
mov rdx, [rsp+0A8h+var_18]
mov rcx, [rsp+0A8h+var_30]
mov r8, [rsp+0A8h+var_28]
xor r9d, r9d
xor eax, eax
mov [rsp+0A8h+var_A8], 0
call JS_CallFree
mov [rsp+0A8h+var_78], rax
mov [rsp+0A8h+var_70], rdx
mov rax, [rsp+0A8h+var_78]
mov [rsp+0A8h+var_50], rax
mov rax, [rsp+0A8h+var_70]
mov [rsp+0A8h+var_48], rax
jmp loc_4AB78
loc_4AA6F:
cmp [rsp+0A8h+var_54], 0FFFFFFFDh
jnz loc_4AB2B
mov rax, [rsp+0A8h+var_20]
mov [rsp+0A8h+var_80], rax
mov rdi, [rsp+0A8h+var_38]
mov rsi, [rsp+0A8h+var_20]
mov rdx, [rsp+0A8h+var_18]
call JS_FreeValue
mov rdi, [rsp+0A8h+var_38]
mov rsi, [rsp+0A8h+var_80]
call js_create_module_function
cmp eax, 0
jge short loc_4AAB7
jmp short loc_4AB10
loc_4AAB7:
mov rdi, [rsp+0A8h+var_38]
mov rsi, [rsp+0A8h+var_80]
call js_link_module
cmp eax, 0
jge short loc_4AACD
jmp short loc_4AB10
loc_4AACD:
mov rdi, [rsp+0A8h+var_38]
mov rsi, [rsp+0A8h+var_80]
call js_evaluate_module
mov [rsp+0A8h+var_90], rax
mov [rsp+0A8h+var_88], rdx
mov rax, [rsp+0A8h+var_90]
mov [rsp+0A8h+var_50], rax
mov rax, [rsp+0A8h+var_88]
mov [rsp+0A8h+var_48], rax
mov rdi, [rsp+0A8h+var_50]
mov rsi, [rsp+0A8h+var_48]
call JS_IsException_1
cmp eax, 0
jz short loc_4AB29
jmp short $+2
loc_4AB10:
mov dword ptr [rsp+0A8h+var_10], 0
mov [rsp+0A8h+var_8], 6
jmp short loc_4AB92
loc_4AB29:
jmp short loc_4AB76
loc_4AB2B:
mov rdi, [rsp+0A8h+var_38]
mov rsi, [rsp+0A8h+var_20]
mov rdx, [rsp+0A8h+var_18]
call JS_FreeValue
mov rdi, [rsp+0A8h+var_38]
lea rsi, aBytecodeFuncti_0; "bytecode function expected"
mov al, 0
call JS_ThrowTypeError
mov [rsp+0A8h+var_A0], rax
mov [rsp+0A8h+var_98], rdx
mov rax, [rsp+0A8h+var_A0]
mov [rsp+0A8h+var_50], rax
mov rax, [rsp+0A8h+var_98]
mov [rsp+0A8h+var_48], rax
loc_4AB76:
jmp short $+2
loc_4AB78:
mov rax, [rsp+0A8h+var_50]
mov [rsp+0A8h+var_10], rax
mov rax, [rsp+0A8h+var_48]
mov [rsp+0A8h+var_8], rax
loc_4AB92:
mov rax, [rsp+0A8h+var_10]
mov rdx, [rsp+0A8h+var_8]
add rsp, 0A8h
retn
| long long JS_EvalFunctionInternal(
long long a1,
long long a2,
long long a3,
int a4,
int a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
long long a15)
{
long long v15; // rdx
int v16; // edx
long long v17; // rdx
long long v18; // rcx
long long v19; // r8
long long v20; // r9
__m128 v21; // xmm4
__m128 v22; // xmm5
char v24; // [rsp+0h] [rbp-A8h]
long long v25; // [rsp+40h] [rbp-68h]
long long v26; // [rsp+58h] [rbp-50h]
long long v29; // [rsp+98h] [rbp-10h]
if ( (_DWORD)a3 == -2 )
{
v25 = js_closure(a1, a2, a3, a6, a15, *(double *)a7.m128_u64);
return JS_CallFree(a1, v25, v15, a4, a5, 0, 0LL);
}
if ( (_DWORD)a3 != -3 )
{
JS_FreeValue(a1, a2, a3);
return JS_ThrowTypeError(
a1,
(long long)"bytecode function expected",
v17,
v18,
v19,
v20,
a7,
a8,
a9,
a10,
v21,
v22,
a13,
a14,
v24);
}
JS_FreeValue(a1, a2, a3);
if ( (int)js_create_module_function(a1, a2) >= 0 && (int)js_link_module(a1, a2) >= 0 )
{
v26 = js_evaluate_module(a1, a2);
if ( !JS_IsException_1(v26, v16) )
return v26;
}
LODWORD(v29) = 0;
return v29;
}
| JS_EvalFunctionInternal:
SUB RSP,0xa8
MOV RAX,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0x88],RSI
MOV qword ptr [RSP + 0x90],RDX
MOV qword ptr [RSP + 0x78],RCX
MOV qword ptr [RSP + 0x80],R8
MOV qword ptr [RSP + 0x70],RDI
MOV qword ptr [RSP + 0x68],R9
MOV RAX,qword ptr [RSP + 0x90]
MOV dword ptr [RSP + 0x54],EAX
CMP dword ptr [RSP + 0x54],-0x2
JNZ 0x0014aa6f
MOV RDI,qword ptr [RSP + 0x70]
MOV RCX,qword ptr [RSP + 0x68]
MOV R8,qword ptr [RSP + 0xb0]
MOV RSI,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x90]
CALL 0x00164010
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x88],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x90],RAX
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x90]
MOV RCX,qword ptr [RSP + 0x78]
MOV R8,qword ptr [RSP + 0x80]
XOR R9D,R9D
XOR EAX,EAX
MOV qword ptr [RSP],0x0
CALL 0x0012e280
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x38],RDX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x60],RAX
JMP 0x0014ab78
LAB_0014aa6f:
CMP dword ptr [RSP + 0x54],-0x3
JNZ 0x0014ab2b
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x90]
CALL 0x00123c90
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x001752f0
CMP EAX,0x0
JGE 0x0014aab7
JMP 0x0014ab10
LAB_0014aab7:
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x00175480
CMP EAX,0x0
JGE 0x0014aacd
JMP 0x0014ab10
LAB_0014aacd:
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x00175510
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x60],RAX
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RSP + 0x60]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x0014ab29
JMP 0x0014ab10
LAB_0014ab10:
MOV dword ptr [RSP + 0x98],0x0
MOV qword ptr [RSP + 0xa0],0x6
JMP 0x0014ab92
LAB_0014ab29:
JMP 0x0014ab76
LAB_0014ab2b:
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x90]
CALL 0x00123c90
MOV RDI,qword ptr [RSP + 0x70]
LEA RSI,[0x20e861]
MOV AL,0x0
CALL 0x0012d300
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x60],RAX
LAB_0014ab76:
JMP 0x0014ab78
LAB_0014ab78:
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x98],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0xa0],RAX
LAB_0014ab92:
MOV RAX,qword ptr [RSP + 0x98]
MOV RDX,qword ptr [RSP + 0xa0]
ADD RSP,0xa8
RET
|
int1 [16]
JS_EvalFunctionInternal
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7)
{
int iVar1;
int1 auVar2 [16];
int8 local_48;
int4 local_10;
int4 uStack_c;
int8 local_8;
if ((int)param_3 == -2) {
auVar2 = js_closure(param_1,param_2,param_3,param_6,param_7);
auVar2 = JS_CallFree(param_1,auVar2._0_8_,auVar2._8_8_,param_4,param_5,0,0);
}
else {
if ((int)param_3 == -3) {
JS_FreeValue(param_1,param_2,param_3);
iVar1 = js_create_module_function(param_1,param_2);
if ((-1 < iVar1) && (iVar1 = js_link_module(param_1,param_2), -1 < iVar1)) {
auVar2 = js_evaluate_module(param_1,param_2);
iVar1 = JS_IsException(auVar2._0_8_,auVar2._8_8_);
if (iVar1 == 0) goto LAB_0014ab78;
}
local_10 = 0;
local_8 = 6;
goto LAB_0014ab92;
}
JS_FreeValue(param_1,param_2,param_3);
auVar2 = JS_ThrowTypeError(param_1,"bytecode function expected");
}
LAB_0014ab78:
local_48 = auVar2._8_8_;
local_10 = auVar2._0_4_;
uStack_c = auVar2._4_4_;
local_8 = local_48;
LAB_0014ab92:
auVar2._4_4_ = uStack_c;
auVar2._0_4_ = local_10;
auVar2._8_8_ = local_8;
return auVar2;
}
| |
42,817 | JS_EvalFunctionInternal | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_EvalFunctionInternal(JSContext *ctx, JSValue fun_obj,
JSValue this_obj,
JSVarRef **var_refs, JSStackFrame *sf)
{
JSValue ret_val;
uint32_t tag;
tag = JS_VALUE_GET_TAG(fun_obj);
if (tag == JS_TAG_FUNCTION_BYTECODE) {
fun_obj = js_closure(ctx, fun_obj, var_refs, sf);
ret_val = JS_CallFree(ctx, fun_obj, this_obj, 0, NULL);
} else if (tag == JS_TAG_MODULE) {
JSModuleDef *m;
m = JS_VALUE_GET_PTR(fun_obj);
/* the module refcount should be >= 2 */
JS_FreeValue(ctx, fun_obj);
if (js_create_module_function(ctx, m) < 0)
goto fail;
if (js_link_module(ctx, m) < 0)
goto fail;
ret_val = js_evaluate_module(ctx, m);
if (JS_IsException(ret_val)) {
fail:
return JS_EXCEPTION;
}
} else {
JS_FreeValue(ctx, fun_obj);
ret_val = JS_ThrowTypeError(ctx, "bytecode function expected");
}
return ret_val;
} | O1 | c | JS_EvalFunctionInternal:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq %rsi, 0x30(%rsp)
cmpl $-0x3, %edx
je 0x31271
cmpl $-0x2, %edx
jne 0x312cc
movq %r8, %r14
movq %rcx, %r15
movq 0x80(%rsp), %r8
movq %rbx, %rdi
movq %r9, %rcx
callq 0x3efde
movq %rax, 0x30(%rsp)
movq $0x0, (%rsp)
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rcx
movq %r14, %r8
xorl %r9d, %r9d
callq 0x22c9d
movq %rax, %r14
jmp 0x314f2
movq 0x30(%rsp), %r14
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x1d8c6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4444b
testl %eax, %eax
js 0x313cb
leaq 0x20(%rsp), %rdx
movq $0x0, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x4461d
testl %eax, %eax
jns 0x312fb
movq 0x20(%rsp), %rcx
testq %rcx, %rcx
je 0x312f3
movb $0x0, 0x83(%rcx)
movq 0x90(%rcx), %rcx
jmp 0x312b7
movq 0x18(%rbx), %rdi
callq 0x1d8c6
leaq 0x6e521(%rip), %rsi # 0x9f7fd
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22567
movl $0x6, %edx
jmp 0x314f2
testl %eax, %eax
js 0x313cb
movl $0xfe000000, %eax # imm = 0xFE000000
andl 0x80(%r14), %eax
cmpl $0x4000000, %eax # imm = 0x4000000
jne 0x31315
movq 0xb8(%r14), %r14
movq 0xc8(%r14), %rax
cmpl $0x3, %eax
jne 0x313d2
leaq 0xd0(%r14), %rsi
xorl %r15d, %r15d
movl $0x3, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x362b6
movq %rax, 0xc0(%r14)
movq %rdx, 0xc8(%r14)
movl $0x6, %eax
movl $0x0, %esi
cmpl $0x6, %edx
je 0x314d4
leaq 0x38(%rsp), %rcx
movq $0x0, (%rcx)
leaq 0x40(%rsp), %r8
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x44a7b
testl %eax, %eax
js 0x313de
cmpl $0x0, 0xac(%r14)
jne 0x314a8
xorl %eax, %eax
leaq 0x50(%rsp), %rcx
movl %eax, (%rcx)
movl $0x3, %edi
movq %rdi, 0x8(%rcx)
movq 0xd0(%r14), %rsi
movq 0xd8(%r14), %rdx
movl %eax, 0x20(%rsp)
movq %rdi, 0x28(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rcx, 0x10(%rsp)
jmp 0x3147e
xorl %edx, %edx
jmp 0x314e0
movq 0xc0(%r14), %r15
jmp 0x314b6
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x31432
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %rdx
movb $0x5, 0x83(%rax)
movb $0x1, 0xf0(%rax)
movq %rcx, 0x20(%rsp)
cmpl $-0x9, %edx
jb 0x31411
movq 0x20(%rsp), %rsi
incl (%rsi)
movq %rcx, 0xf8(%rax)
movq %rdx, 0x100(%rax)
movq %r14, 0xb8(%rax)
movq 0x90(%rax), %rax
testq %rax, %rax
jne 0x313f2
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x18(%rbx), %rdi
callq 0x1d8c6
leaq 0xf8(%r14), %rax
movq 0xe0(%r14), %rsi
movq 0xe8(%r14), %rdx
movl $0x0, 0x20(%rsp)
movq $0x3, 0x28(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movl $0x3, %r8d
movq %rbx, %rdi
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x284ca
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0x1d8c6
movq 0xc0(%r14), %r15
movq 0xc8(%r14), %rax
movq %r15, 0x20(%rsp)
cmpl $-0x9, %eax
jb 0x314c7
movq 0x20(%rsp), %rcx
incl (%rcx)
movabsq $-0x100000000, %rsi # imm = 0xFFFFFFFF00000000
andq %r15, %rsi
movl %r15d, %ecx
orq %rsi, %rcx
cmpl $0x6, %eax
setne %dl
xorl %r14d, %r14d
testb %dl, %dl
movl $0x6, %edx
cmovneq %rax, %rdx
cmovneq %rcx, %r14
movq %r14, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
| JS_EvalFunctionInternal:
push r15
push r14
push rbx
sub rsp, 60h
mov rbx, rdi
mov [rsp+78h+var_48], rsi
cmp edx, 0FFFFFFFDh
jz short loc_31271
cmp edx, 0FFFFFFFEh
jnz loc_312CC
mov r14, r8
mov r15, rcx
mov r8, [rsp+78h+arg_0]
mov rdi, rbx
mov rcx, r9
call js_closure
mov [rsp+78h+var_48], rax
mov qword ptr [rsp+78h+var_78], 0
mov rdi, rbx
mov rsi, rax
mov rcx, r15
mov r8, r14
xor r9d, r9d
call JS_CallFree
mov r14, rax
jmp loc_314F2
loc_31271:
mov r14, [rsp+78h+var_48]
mov rdi, [rbx+18h]
mov rsi, r14
call JS_FreeValueRT
mov rdi, rbx
mov rsi, r14
call js_create_module_function
test eax, eax
js loc_313CB
lea rdx, [rsp+78h+var_58]
mov qword ptr [rdx], 0
mov rdi, rbx
mov rsi, r14
xor ecx, ecx
call js_inner_module_linking
test eax, eax
jns short loc_312FB
mov rcx, qword ptr [rsp+78h+var_58]
loc_312B7:
test rcx, rcx
jz short loc_312F3
mov byte ptr [rcx+83h], 0
mov rcx, [rcx+90h]
jmp short loc_312B7
loc_312CC:
mov rdi, [rbx+18h]
call JS_FreeValueRT
lea rsi, aBytecodeFuncti_0; "bytecode function expected"
xor r14d, r14d
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
mov edx, 6
jmp loc_314F2
loc_312F3:
test eax, eax
js loc_313CB
loc_312FB:
mov eax, 0FE000000h
and eax, [r14+80h]
cmp eax, 4000000h
jnz short loc_31315
mov r14, [r14+0B8h]
loc_31315:
mov rax, [r14+0C8h]
cmp eax, 3
jnz loc_313D2
lea rsi, [r14+0D0h]
xor r15d, r15d
mov ecx, 3
mov rdi, rbx
xor edx, edx
call js_new_promise_capability
mov [r14+0C0h], rax
mov [r14+0C8h], rdx
mov eax, 6
mov esi, 0
cmp edx, 6
jz loc_314D4
lea rcx, [rsp+78h+var_40]
mov qword ptr [rcx], 0
lea r8, [rsp+78h+var_38]
mov rdi, rbx
mov rsi, r14
xor edx, edx
call js_inner_module_evaluation
test eax, eax
js short loc_313DE
cmp dword ptr [r14+0ACh], 0
jnz loc_314A8
xor eax, eax
lea rcx, [rsp+78h+var_28]
mov [rcx], eax
mov edi, 3
mov [rcx+8], rdi
mov rsi, [r14+0D0h]
mov rdx, [r14+0D8h]
mov dword ptr [rsp+78h+var_58], eax
mov qword ptr [rsp+78h+var_58+8], rdi
movups xmm0, [rsp+78h+var_58]
movups [rsp+78h+var_78], xmm0
mov [rsp+78h+var_68], rcx
jmp loc_3147E
loc_313CB:
xor edx, edx
jmp loc_314E0
loc_313D2:
mov r15, [r14+0C0h]
jmp loc_314B6
loc_313DE:
mov rax, [rsp+78h+var_40]
test rax, rax
jz short loc_31432
mov rcx, [rsp+78h+var_38]
mov rdx, [rsp+78h+var_30]
loc_313F2:
mov byte ptr [rax+83h], 5
mov byte ptr [rax+0F0h], 1
mov qword ptr [rsp+78h+var_58], rcx
cmp edx, 0FFFFFFF7h
jb short loc_31411
mov rsi, qword ptr [rsp+78h+var_58]
inc dword ptr [rsi]
loc_31411:
mov [rax+0F8h], rcx
mov [rax+100h], rdx
mov [rax+0B8h], r14
mov rax, [rax+90h]
test rax, rax
jnz short loc_313F2
loc_31432:
mov [rsp+78h+var_40], rax
mov rsi, [rsp+78h+var_38]
mov rdx, [rsp+78h+var_30]
mov rdi, [rbx+18h]
call JS_FreeValueRT
lea rax, [r14+0F8h]
mov rsi, [r14+0E0h]
mov rdx, [r14+0E8h]
mov dword ptr [rsp+78h+var_58], 0
mov qword ptr [rsp+78h+var_58+8], 3
movups xmm0, [rsp+78h+var_58]
movups [rsp+78h+var_78], xmm0
mov [rsp+78h+var_68], rax
loc_3147E:
mov [rsp+78h+var_60], 2
mov r8d, 3
mov rdi, rbx
xor ecx, ecx
mov r9d, 1
call JS_CallInternal
mov rdi, [rbx+18h]
mov rsi, rax
call JS_FreeValueRT
loc_314A8:
mov r15, [r14+0C0h]
mov rax, [r14+0C8h]
loc_314B6:
mov qword ptr [rsp+78h+var_58], r15
cmp eax, 0FFFFFFF7h
jb short loc_314C7
mov rcx, qword ptr [rsp+78h+var_58]
inc dword ptr [rcx]
loc_314C7:
mov rsi, 0FFFFFFFF00000000h
and rsi, r15
loc_314D4:
mov ecx, r15d
or rcx, rsi
cmp eax, 6
setnz dl
loc_314E0:
xor r14d, r14d
test dl, dl
mov edx, 6
cmovnz rdx, rax
cmovnz r14, rcx
loc_314F2:
mov rax, r14
add rsp, 60h
pop rbx
pop r14
pop r15
retn
| long long JS_EvalFunctionInternal(
long long a1,
_DWORD *a2,
long long a3,
int a4,
int a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
long long a15)
{
long long v17; // rdx
long long v18; // r14
_DWORD *v19; // r14
unsigned long long i; // rcx
long long v21; // rdx
long long v22; // rcx
long long v23; // r8
long long v24; // r9
__m128 v25; // xmm4
__m128 v26; // xmm5
long long v27; // rax
unsigned long long v28; // r15
long long v29; // rdx
unsigned long long v30; // rsi
__m128 v31; // xmm4
__m128 v32; // xmm5
long long v33; // rsi
long long v34; // rdx
_DWORD *v35; // rax
long long v36; // rdx
bool v37; // dl
long long v38; // rax
_DWORD *v39; // rcx
long long v40; // rdx
long long v41; // rsi
long long v42; // rdx
__m128 v43; // xmm4
__m128 v44; // xmm5
char v46; // [rsp+0h] [rbp-78h]
__m128 v47; // [rsp+20h] [rbp-58h] BYREF
_DWORD *v48; // [rsp+30h] [rbp-48h]
long long v49; // [rsp+38h] [rbp-40h] BYREF
_DWORD *v50; // [rsp+40h] [rbp-38h] BYREF
long long v51; // [rsp+48h] [rbp-30h]
int v52; // [rsp+50h] [rbp-28h] BYREF
long long v53; // [rsp+58h] [rbp-20h]
v48 = a2;
if ( (_DWORD)a3 != -3 )
{
if ( (_DWORD)a3 == -2 )
{
v48 = (_DWORD *)js_closure(a1, a2, a3, a6, a15);
return JS_CallFree(a1, v48, v17, a4, a5, 0, 0LL);
}
else
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), a2, a3);
v18 = 0LL;
JS_ThrowTypeError(
a1,
(long long)"bytecode function expected",
v21,
v22,
v23,
v24,
a7,
a8,
a9,
a10,
v25,
v26,
a13,
a14,
v46);
}
return v18;
}
v19 = v48;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v48, a3);
if ( (int)js_create_module_function(a1, v48) < 0 )
goto LABEL_18;
v47.m128_u64[0] = 0LL;
if ( (int)js_inner_module_linking(a1, v48, &v47, 0LL) < 0 )
{
for ( i = v47.m128_u64[0]; i; i = *(_QWORD *)(i + 144) )
*(_BYTE *)(i + 131) = 0;
LABEL_18:
v37 = 0;
goto LABEL_32;
}
if ( (v19[32] & 0xFE000000) == 0x4000000 )
v19 = (_DWORD *)*((_QWORD *)v19 + 23);
v27 = *((_QWORD *)v19 + 25);
if ( (_DWORD)v27 != 3 )
{
v28 = *((_QWORD *)v19 + 24);
LABEL_28:
v47.m128_u64[0] = v28;
if ( (unsigned int)v27 >= 0xFFFFFFF7 )
++*(_DWORD *)v47.m128_u64[0];
v30 = v28 & 0xFFFFFFFF00000000LL;
goto LABEL_31;
}
LODWORD(v28) = 0;
*((_QWORD *)v19 + 24) = js_new_promise_capability(a1, v19 + 52, 0LL);
*((_QWORD *)v19 + 25) = v29;
LODWORD(v27) = 6;
v30 = 0LL;
if ( (_DWORD)v29 != 6 )
{
v49 = 0LL;
if ( (int)js_inner_module_evaluation(a1, v19, 0LL, &v49, &v50) < 0 )
{
v38 = v49;
if ( v49 )
{
v39 = v50;
v40 = v51;
do
{
*(_BYTE *)(v38 + 131) = 5;
*(_BYTE *)(v38 + 240) = 1;
v47.m128_u64[0] = (unsigned long long)v39;
if ( (unsigned int)v40 >= 0xFFFFFFF7 )
++*(_DWORD *)v47.m128_u64[0];
*(_QWORD *)(v38 + 248) = v39;
*(_QWORD *)(v38 + 256) = v40;
*(_QWORD *)(v38 + 184) = v19;
v38 = *(_QWORD *)(v38 + 144);
}
while ( v38 );
}
v49 = v38;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v50, v51);
v41 = *((_QWORD *)v19 + 28);
v42 = *((_QWORD *)v19 + 29);
v47.m128_i32[0] = 0;
v47.m128_u64[1] = 3LL;
v35 = (_DWORD *)JS_CallInternal(
a1,
v41,
v42,
0LL,
3LL,
1LL,
v47,
a8,
a9,
a10,
v43,
v44,
a13,
a14,
0,
3,
(long long)(v19 + 62),
2u);
}
else
{
if ( v19[43] )
{
LABEL_27:
v28 = *((_QWORD *)v19 + 24);
v27 = *((_QWORD *)v19 + 25);
goto LABEL_28;
}
v52 = 0;
v53 = 3LL;
v33 = *((_QWORD *)v19 + 26);
v34 = *((_QWORD *)v19 + 27);
v47.m128_i32[0] = 0;
v47.m128_u64[1] = 3LL;
v35 = (_DWORD *)JS_CallInternal(
a1,
v33,
v34,
0LL,
3LL,
1LL,
v47,
a8,
a9,
a10,
v31,
v32,
a13,
a14,
0,
3,
(long long)&v52,
2u);
}
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v35, v36);
goto LABEL_27;
}
LABEL_31:
i = v30 | (unsigned int)v28;
v37 = (_DWORD)v27 != 6;
LABEL_32:
v18 = 0LL;
if ( v37 )
return i;
return v18;
}
| |||
42,818 | JS_EvalFunctionInternal | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_EvalFunctionInternal(JSContext *ctx, JSValue fun_obj,
JSValue this_obj,
JSVarRef **var_refs, JSStackFrame *sf)
{
JSValue ret_val;
uint32_t tag;
tag = JS_VALUE_GET_TAG(fun_obj);
if (tag == JS_TAG_FUNCTION_BYTECODE) {
fun_obj = js_closure(ctx, fun_obj, var_refs, sf);
ret_val = JS_CallFree(ctx, fun_obj, this_obj, 0, NULL);
} else if (tag == JS_TAG_MODULE) {
JSModuleDef *m;
m = JS_VALUE_GET_PTR(fun_obj);
/* the module refcount should be >= 2 */
JS_FreeValue(ctx, fun_obj);
if (js_create_module_function(ctx, m) < 0)
goto fail;
if (js_link_module(ctx, m) < 0)
goto fail;
ret_val = js_evaluate_module(ctx, m);
if (JS_IsException(ret_val)) {
fail:
return JS_EXCEPTION;
}
} else {
JS_FreeValue(ctx, fun_obj);
ret_val = JS_ThrowTypeError(ctx, "bytecode function expected");
}
return ret_val;
} | O2 | c | JS_EvalFunctionInternal:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x3, %edx
je 0x297b3
cmpl $-0x2, %edx
jne 0x29868
movq %r8, %r15
movq %rcx, %r12
movq 0x60(%rsp), %r8
movq %rbx, %rdi
movq %r14, %rsi
movq %r9, %rcx
callq 0x37433
andq $0x0, (%rsp)
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rcx
movq %r15, %r8
xorl %r9d, %r9d
callq 0x1cd8e
movq %rax, %r14
movq %rdx, %r15
jmp 0x299aa
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1801e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3bfa3
pushq $0x6
popq %r15
testl %eax, %eax
js 0x29860
leaq 0x10(%rsp), %r12
andq $0x0, (%r12)
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x3c1a2
testl %eax, %eax
js 0x29857
movl $0xfe000000, %eax # imm = 0xFE000000
andl 0x80(%r14), %eax
cmpl $0x4000000, %eax # imm = 0x4000000
jne 0x2980d
movq 0xb8(%r14), %r14
movq 0xc8(%r14), %rax
cmpl $0x3, %eax
jne 0x29890
leaq 0xd0(%r14), %rsi
movq %rbx, %rdi
callq 0x2956d
movq %rax, 0xc0(%r14)
movq %rdx, 0xc8(%r14)
cmpl $0x6, %edx
jne 0x2989c
pushq $0x6
popq %rax
xorl %ecx, %ecx
xorl %edx, %edx
jmp 0x29993
movb $0x0, 0x83(%r12)
addq $0x90, %r12
movq (%r12), %r12
testq %r12, %r12
jne 0x29847
xorl %r14d, %r14d
jmp 0x299aa
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1801e
leaq 0x5ced3(%rip), %rsi # 0x8674d
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1c64d
pushq $0x6
popq %r15
jmp 0x299aa
movq 0xc0(%r14), %rcx
jmp 0x2997f
leaq 0x20(%rsp), %r15
andq $0x0, (%r15)
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x3c554
testl %eax, %eax
js 0x298ec
cmpl $0x0, 0xac(%r14)
jne 0x29971
leaq 0x28(%rsp), %rax
andl $0x0, (%rax)
movq $0x3, 0x8(%rax)
movq 0xd0(%r14), %rsi
movq 0xd8(%r14), %rdx
jmp 0x29950
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq (%r15), %r15
testq %r15, %r15
je 0x29933
movb $0x5, 0x83(%r15)
movb $0x1, 0xf0(%r15)
cmpl $-0x9, %edx
jb 0x29915
incl (%rsi)
movq %rsi, 0xf8(%r15)
movq %rdx, 0x100(%r15)
movq %r14, 0xb8(%r15)
addq $0x90, %r15
jmp 0x298f6
movq %rbx, %rdi
callq 0x1801e
leaq 0xf8(%r14), %rax
movq 0xe0(%r14), %rsi
movq 0xe8(%r14), %rdx
movq %rax, (%rsp)
pushq $0x3
popq %r8
pushq $0x1
popq %r9
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x21eb6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1801e
movq 0xc0(%r14), %rcx
movq 0xc8(%r14), %rax
cmpl $-0x9, %eax
jb 0x29986
incl (%rcx)
movabsq $-0x100000000, %rdx # imm = 0xFFFFFFFF00000000
andq %rcx, %rdx
movl %ecx, %ecx
orq %rdx, %rcx
xorl %r14d, %r14d
cmpl $0x6, %eax
pushq $0x6
popq %r15
cmovneq %rax, %r15
cmovneq %rcx, %r14
movq %r14, %rax
movq %r15, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| JS_EvalFunctionInternal:
push r15
push r14
push r12
push rbx
sub rsp, 38h
mov r14, rsi
mov rbx, rdi
cmp edx, 0FFFFFFFDh
jz short loc_297B3
cmp edx, 0FFFFFFFEh
jnz loc_29868
mov r15, r8
mov r12, rcx
mov r8, [rsp+58h+arg_0]
mov rdi, rbx
mov rsi, r14
mov rcx, r9
call js_closure
and [rsp+58h+var_58], 0
mov rdi, rbx
mov rsi, rax
mov rcx, r12
mov r8, r15
xor r9d, r9d
call JS_CallFree
mov r14, rax
mov r15, rdx
jmp loc_299AA
loc_297B3:
mov rdi, rbx
mov rsi, r14
call JS_FreeValue
mov rdi, rbx
mov rsi, r14
call js_create_module_function
push 6
pop r15
test eax, eax
js loc_29860
lea r12, [rsp+58h+var_48]
and qword ptr [r12], 0
mov rdi, rbx
mov rsi, r14
mov rdx, r12
xor ecx, ecx
call js_inner_module_linking
test eax, eax
js short loc_29857
mov eax, 0FE000000h
and eax, [r14+80h]
cmp eax, 4000000h
jnz short loc_2980D
mov r14, [r14+0B8h]
loc_2980D:
mov rax, [r14+0C8h]
cmp eax, 3
jnz short loc_29890
lea rsi, [r14+0D0h]
mov rdi, rbx
call JS_NewPromiseCapability
mov [r14+0C0h], rax
mov [r14+0C8h], rdx
cmp edx, 6
jnz short loc_2989C
push 6
pop rax
xor ecx, ecx
xor edx, edx
jmp loc_29993
loc_29847:
mov byte ptr [r12+83h], 0
add r12, 90h
loc_29857:
mov r12, [r12]
test r12, r12
jnz short loc_29847
loc_29860:
xor r14d, r14d
jmp loc_299AA
loc_29868:
mov rdi, rbx
mov rsi, r14
call JS_FreeValue
lea rsi, aBytecodeFuncti_0; "bytecode function expected"
xor r14d, r14d
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
push 6
pop r15
jmp loc_299AA
loc_29890:
mov rcx, [r14+0C0h]
jmp loc_2997F
loc_2989C:
lea r15, [rsp+58h+var_38]
and qword ptr [r15], 0
lea r8, [rsp+58h+var_48]
mov rdi, rbx
mov rsi, r14
xor edx, edx
mov rcx, r15
call js_inner_module_evaluation
test eax, eax
js short loc_298EC
cmp dword ptr [r14+0ACh], 0
jnz loc_29971
lea rax, [rsp+58h+var_30]
and dword ptr [rax], 0
mov qword ptr [rax+8], 3
mov rsi, [r14+0D0h]
mov rdx, [r14+0D8h]
jmp short loc_29950
loc_298EC:
mov rsi, [rsp+58h+var_48]
mov rdx, [rsp+58h+var_40]
loc_298F6:
mov r15, [r15]
test r15, r15
jz short loc_29933
mov byte ptr [r15+83h], 5
mov byte ptr [r15+0F0h], 1
cmp edx, 0FFFFFFF7h
jb short loc_29915
inc dword ptr [rsi]
loc_29915:
mov [r15+0F8h], rsi
mov [r15+100h], rdx
mov [r15+0B8h], r14
add r15, 90h
jmp short loc_298F6
loc_29933:
mov rdi, rbx
call JS_FreeValue
lea rax, [r14+0F8h]
mov rsi, [r14+0E0h]
mov rdx, [r14+0E8h]
loc_29950:
mov [rsp+58h+var_58], rax
push 3
pop r8
push 1
pop r9
mov rdi, rbx
xor ecx, ecx
call JS_Call
mov rdi, rbx
mov rsi, rax
call JS_FreeValue
loc_29971:
mov rcx, [r14+0C0h]
mov rax, [r14+0C8h]
loc_2997F:
cmp eax, 0FFFFFFF7h
jb short loc_29986
inc dword ptr [rcx]
loc_29986:
mov rdx, 0FFFFFFFF00000000h
and rdx, rcx
loc_29993:
mov ecx, ecx
or rcx, rdx
xor r14d, r14d
cmp eax, 6
push 6
pop r15
cmovnz r15, rax
cmovnz r14, rcx
loc_299AA:
mov rax, r14
mov rdx, r15
add rsp, 38h
pop rbx
pop r12
pop r14
pop r15
retn
| long long JS_EvalFunctionInternal(
long long a1,
long long a2,
long long a3,
int a4,
int a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
long long a15)
{
long long v15; // r14
long long v18; // rax
long long v19; // rdx
long long v20; // r14
long long *v21; // r12
long long v22; // rax
long long v23; // rdx
unsigned long long v24; // rcx
unsigned long long v25; // rdx
long long v26; // r12
long long v27; // rdx
long long v28; // rcx
long long v29; // r8
long long v30; // r9
__m128 v31; // xmm4
__m128 v32; // xmm5
long long *v33; // r15
int *v34; // rax
long long v35; // rsi
long long v36; // rdx
_DWORD *v37; // rsi
long long v38; // rdx
long long v39; // r15
long long v40; // rax
long long v41; // rdx
unsigned long long v42; // rcx
char v44; // [rsp+0h] [rbp-58h]
_QWORD v45[2]; // [rsp+10h] [rbp-48h] BYREF
long long v46; // [rsp+20h] [rbp-38h] BYREF
int v47; // [rsp+28h] [rbp-30h] BYREF
long long v48; // [rsp+30h] [rbp-28h]
v15 = a2;
if ( (_DWORD)a3 != -3 )
{
if ( (_DWORD)a3 == -2 )
{
v18 = js_closure(a1, a2, a3, a6, a15);
return JS_CallFree(a1, v18, v19, a4, a5, 0, 0LL);
}
else
{
JS_FreeValue(a1, a2, a3);
v20 = 0LL;
JS_ThrowTypeError(
a1,
(long long)"bytecode function expected",
v27,
v28,
v29,
v30,
a7,
a8,
a9,
a10,
v31,
v32,
a13,
a14,
v44);
}
return v20;
}
JS_FreeValue(a1, a2, a3);
if ( (int)js_create_module_function(a1, a2) < 0 )
return 0LL;
v21 = v45;
v45[0] = 0LL;
if ( (int)js_inner_module_linking(a1, a2, v45, 0LL) < 0 )
{
while ( 1 )
{
v26 = *v21;
if ( !v26 )
break;
*(_BYTE *)(v26 + 131) = 0;
v21 = (long long *)(v26 + 144);
}
return 0LL;
}
if ( (*(_DWORD *)(a2 + 128) & 0xFE000000) == 0x4000000 )
v15 = *(_QWORD *)(a2 + 184);
v22 = *(_QWORD *)(v15 + 200);
if ( (_DWORD)v22 != 3 )
{
v24 = *(_QWORD *)(v15 + 192);
LABEL_27:
if ( (unsigned int)v22 >= 0xFFFFFFF7 )
++*(_DWORD *)v24;
v25 = v24 & 0xFFFFFFFF00000000LL;
goto LABEL_30;
}
*(_QWORD *)(v15 + 192) = JS_NewPromiseCapability(a1, v15 + 208);
*(_QWORD *)(v15 + 200) = v23;
if ( (_DWORD)v23 != 6 )
{
v33 = &v46;
v46 = 0LL;
if ( (int)js_inner_module_evaluation(a1, v15, 0LL, &v46, v45) < 0 )
{
v37 = (_DWORD *)v45[0];
v38 = v45[1];
while ( 1 )
{
v39 = *v33;
if ( !v39 )
break;
*(_BYTE *)(v39 + 131) = 5;
*(_BYTE *)(v39 + 240) = 1;
if ( (unsigned int)v38 >= 0xFFFFFFF7 )
++*v37;
*(_QWORD *)(v39 + 248) = v37;
*(_QWORD *)(v39 + 256) = v38;
*(_QWORD *)(v39 + 184) = v15;
v33 = (long long *)(v39 + 144);
}
JS_FreeValue(a1, (long long)v37, v38);
v34 = (int *)(v15 + 248);
v35 = *(_QWORD *)(v15 + 224);
v36 = *(_QWORD *)(v15 + 232);
}
else
{
if ( *(_DWORD *)(v15 + 172) )
{
LABEL_26:
v24 = *(_QWORD *)(v15 + 192);
v22 = *(_QWORD *)(v15 + 200);
goto LABEL_27;
}
v34 = &v47;
v47 = 0;
v48 = 3LL;
v35 = *(_QWORD *)(v15 + 208);
v36 = *(_QWORD *)(v15 + 216);
}
v40 = JS_Call(a1, v35, v36, 0, 3, 1, (long long)v34);
JS_FreeValue(a1, v40, v41);
goto LABEL_26;
}
LODWORD(v22) = 6;
LODWORD(v24) = 0;
v25 = 0LL;
LABEL_30:
v42 = v25 | (unsigned int)v24;
v20 = 0LL;
if ( (_DWORD)v22 != 6 )
return v42;
return v20;
}
| JS_EvalFunctionInternal:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R14,RSI
MOV RBX,RDI
CMP EDX,-0x3
JZ 0x001297b3
CMP EDX,-0x2
JNZ 0x00129868
MOV R15,R8
MOV R12,RCX
MOV R8,qword ptr [RSP + 0x60]
MOV RDI,RBX
MOV RSI,R14
MOV RCX,R9
CALL 0x00137433
AND qword ptr [RSP],0x0
MOV RDI,RBX
MOV RSI,RAX
MOV RCX,R12
MOV R8,R15
XOR R9D,R9D
CALL 0x0011cd8e
MOV R14,RAX
MOV R15,RDX
JMP 0x001299aa
LAB_001297b3:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011801e
MOV RDI,RBX
MOV RSI,R14
CALL 0x0013bfa3
PUSH 0x6
POP R15
TEST EAX,EAX
JS 0x00129860
LEA R12,[RSP + 0x10]
AND qword ptr [R12],0x0
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R12
XOR ECX,ECX
CALL 0x0013c1a2
TEST EAX,EAX
JS 0x00129857
MOV EAX,0xfe000000
AND EAX,dword ptr [R14 + 0x80]
CMP EAX,0x4000000
JNZ 0x0012980d
MOV R14,qword ptr [R14 + 0xb8]
LAB_0012980d:
MOV RAX,qword ptr [R14 + 0xc8]
CMP EAX,0x3
JNZ 0x00129890
LEA RSI,[R14 + 0xd0]
MOV RDI,RBX
CALL 0x0012956d
MOV qword ptr [R14 + 0xc0],RAX
MOV qword ptr [R14 + 0xc8],RDX
CMP EDX,0x6
JNZ 0x0012989c
PUSH 0x6
POP RAX
XOR ECX,ECX
XOR EDX,EDX
JMP 0x00129993
LAB_00129847:
MOV byte ptr [R12 + 0x83],0x0
ADD R12,0x90
LAB_00129857:
MOV R12,qword ptr [R12]
TEST R12,R12
JNZ 0x00129847
LAB_00129860:
XOR R14D,R14D
JMP 0x001299aa
LAB_00129868:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011801e
LEA RSI,[0x18674d]
XOR R14D,R14D
MOV RDI,RBX
XOR EAX,EAX
CALL 0x0011c64d
PUSH 0x6
POP R15
JMP 0x001299aa
LAB_00129890:
MOV RCX,qword ptr [R14 + 0xc0]
JMP 0x0012997f
LAB_0012989c:
LEA R15,[RSP + 0x20]
AND qword ptr [R15],0x0
LEA R8,[RSP + 0x10]
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
MOV RCX,R15
CALL 0x0013c554
TEST EAX,EAX
JS 0x001298ec
CMP dword ptr [R14 + 0xac],0x0
JNZ 0x00129971
LEA RAX,[RSP + 0x28]
AND dword ptr [RAX],0x0
MOV qword ptr [RAX + 0x8],0x3
MOV RSI,qword ptr [R14 + 0xd0]
MOV RDX,qword ptr [R14 + 0xd8]
JMP 0x00129950
LAB_001298ec:
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x18]
LAB_001298f6:
MOV R15,qword ptr [R15]
TEST R15,R15
JZ 0x00129933
MOV byte ptr [R15 + 0x83],0x5
MOV byte ptr [R15 + 0xf0],0x1
CMP EDX,-0x9
JC 0x00129915
INC dword ptr [RSI]
LAB_00129915:
MOV qword ptr [R15 + 0xf8],RSI
MOV qword ptr [R15 + 0x100],RDX
MOV qword ptr [R15 + 0xb8],R14
ADD R15,0x90
JMP 0x001298f6
LAB_00129933:
MOV RDI,RBX
CALL 0x0011801e
LEA RAX,[R14 + 0xf8]
MOV RSI,qword ptr [R14 + 0xe0]
MOV RDX,qword ptr [R14 + 0xe8]
LAB_00129950:
MOV qword ptr [RSP],RAX
PUSH 0x3
POP R8
PUSH 0x1
POP R9
MOV RDI,RBX
XOR ECX,ECX
CALL 0x00121eb6
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0011801e
LAB_00129971:
MOV RCX,qword ptr [R14 + 0xc0]
MOV RAX,qword ptr [R14 + 0xc8]
LAB_0012997f:
CMP EAX,-0x9
JC 0x00129986
INC dword ptr [RCX]
LAB_00129986:
MOV RDX,-0x100000000
AND RDX,RCX
LAB_00129993:
MOV ECX,ECX
OR RCX,RDX
XOR R14D,R14D
CMP EAX,0x6
PUSH 0x6
POP R15
CMOVNZ R15,RAX
CMOVNZ R14,RCX
LAB_001299aa:
MOV RAX,R14
MOV RDX,R15
ADD RSP,0x38
POP RBX
POP R12
POP R14
POP R15
RET
|
int1 [16]
JS_EvalFunctionInternal
(int8 param_1,long param_2,int8 param_3,int8 param_4,int8 param_5,
int8 param_6,int8 param_7)
{
long lVar1;
int iVar2;
int4 *puVar3;
int8 uVar4;
int *piVar5;
int8 uVar6;
ulong uVar7;
int **ppiVar8;
long *plVar9;
int1 auVar10 [16];
int *local_48;
int8 local_40;
long local_38;
int4 local_30 [2];
int8 local_28;
if ((int)param_3 != -3) {
if ((int)param_3 == -2) {
auVar10 = js_closure(param_1,param_2,param_3,param_6,param_7);
auVar10 = JS_CallFree(param_1,auVar10._0_8_,auVar10._8_8_,param_4,param_5,0,0);
return auVar10;
}
JS_FreeValue(param_1,param_2);
JS_ThrowTypeError(param_1,"bytecode function expected");
return ZEXT816(6) << 0x40;
}
JS_FreeValue(param_1,param_2);
iVar2 = js_create_module_function(param_1,param_2);
if (iVar2 < 0) {
LAB_00129860:
return ZEXT816(6) << 0x40;
}
ppiVar8 = &local_48;
local_48 = (int *)0x0;
iVar2 = js_inner_module_linking(param_1,param_2,ppiVar8,0);
if (iVar2 < 0) {
while (piVar5 = *ppiVar8, piVar5 != (int *)0x0) {
*(int1 *)((long)piVar5 + 0x83) = 0;
ppiVar8 = (int **)(piVar5 + 0x24);
}
goto LAB_00129860;
}
if ((*(uint *)(param_2 + 0x80) & 0xfe000000) == 0x4000000) {
param_2 = *(long *)(param_2 + 0xb8);
}
uVar4 = *(int8 *)(param_2 + 200);
if ((int)uVar4 == 3) {
auVar10 = JS_NewPromiseCapability(param_1,param_2 + 0xd0);
*(int1 (*) [16])(param_2 + 0xc0) = auVar10;
if (auVar10._8_4_ == 6) {
uVar4 = 6;
piVar5 = (int *)0x0;
uVar7 = 0;
goto LAB_00129993;
}
plVar9 = &local_38;
local_38 = 0;
iVar2 = js_inner_module_evaluation(param_1,param_2,0,plVar9,&local_48);
if (iVar2 < 0) {
while (lVar1 = *plVar9, lVar1 != 0) {
*(int1 *)(lVar1 + 0x83) = 5;
*(int1 *)(lVar1 + 0xf0) = 1;
if (0xfffffff6 < (uint)local_40) {
*local_48 = *local_48 + 1;
}
*(int **)(lVar1 + 0xf8) = local_48;
*(int8 *)(lVar1 + 0x100) = local_40;
*(long *)(lVar1 + 0xb8) = param_2;
plVar9 = (long *)(lVar1 + 0x90);
}
JS_FreeValue(param_1);
puVar3 = (int4 *)(param_2 + 0xf8);
uVar4 = *(int8 *)(param_2 + 0xe0);
uVar6 = *(int8 *)(param_2 + 0xe8);
LAB_00129950:
uVar4 = JS_Call(param_1,uVar4,uVar6,0,3,1,puVar3);
JS_FreeValue(param_1,uVar4);
}
else if (*(int *)(param_2 + 0xac) == 0) {
puVar3 = local_30;
local_30[0] = 0;
local_28 = 3;
uVar4 = *(int8 *)(param_2 + 0xd0);
uVar6 = *(int8 *)(param_2 + 0xd8);
goto LAB_00129950;
}
piVar5 = *(int **)(param_2 + 0xc0);
uVar4 = *(int8 *)(param_2 + 200);
}
else {
piVar5 = *(int **)(param_2 + 0xc0);
}
if (0xfffffff6 < (uint)uVar4) {
*piVar5 = *piVar5 + 1;
}
uVar7 = (ulong)piVar5 & 0xffffffff00000000;
LAB_00129993:
auVar10._8_8_ = uVar4;
auVar10._0_8_ = (ulong)piVar5 & 0xffffffff | uVar7;
if ((int)uVar4 == 6) {
return ZEXT816(6) << 0x40;
}
return auVar10;
}
| |
42,819 | mi_end_bulk_insert | eloqsql/storage/myisam/mi_write.c | int mi_end_bulk_insert(MI_INFO *info, my_bool abort)
{
int first_error= 0;
if (info->bulk_insert)
{
uint i;
for (i=0 ; i < info->s->base.keys ; i++)
{
if (is_tree_inited(& info->bulk_insert[i]))
{
int error;
if ((error= delete_tree(& info->bulk_insert[i], abort)))
{
first_error= first_error ? first_error : error;
abort= 1;
}
}
}
my_free(info->bulk_insert);
info->bulk_insert=0;
}
return first_error;
} | O3 | c | mi_end_bulk_insert:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x80(%rdi), %rdi
testq %rdi, %rdi
je 0x895d1
movq (%rbx), %rax
cmpl $0x0, 0x180(%rax)
je 0x895d6
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %r14d, %r14d
movq 0x80(%rbx), %rdi
cmpq $0x0, (%rdi,%r12)
je 0x895b3
addq %r12, %rdi
movsbl %sil, %r15d
movl %r15d, %esi
callq 0xa42ba
testl %r14d, %r14d
movl %r14d, %ecx
cmovel %eax, %ecx
testl %eax, %eax
cmovnel %ecx, %r14d
movzbl %r15b, %esi
movl $0x1, %eax
cmovnel %eax, %esi
movq (%rbx), %rax
incq %r13
movl 0x180(%rax), %ecx
addq $0x298, %r12 # imm = 0x298
cmpq %rcx, %r13
jb 0x89578
movq 0x80(%rbx), %rdi
jmp 0x895d9
xorl %r14d, %r14d
jmp 0x895e9
xorl %r14d, %r14d
callq 0x9fb2e
movq $0x0, 0x80(%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| mi_end_bulk_insert:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
mov rdi, [rdi+80h]
test rdi, rdi
jz short loc_895D1
mov rax, [rbx]
cmp dword ptr [rax+180h], 0
jz short loc_895D6
xor r12d, r12d
xor r13d, r13d
xor r14d, r14d
loc_89578:
mov rdi, [rbx+80h]
cmp qword ptr [rdi+r12], 0
jz short loc_895B3
add rdi, r12
movsx r15d, sil
mov esi, r15d
call delete_tree
test r14d, r14d
mov ecx, r14d
cmovz ecx, eax
test eax, eax
cmovnz r14d, ecx
movzx esi, r15b
mov eax, 1
cmovnz esi, eax
mov rax, [rbx]
loc_895B3:
inc r13
mov ecx, [rax+180h]
add r12, 298h
cmp r13, rcx
jb short loc_89578
mov rdi, [rbx+80h]
jmp short loc_895D9
loc_895D1:
xor r14d, r14d
jmp short loc_895E9
loc_895D6:
xor r14d, r14d
loc_895D9:
call my_free
mov qword ptr [rbx+80h], 0
loc_895E9:
mov eax, r14d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long mi_end_bulk_insert(_QWORD *a1, char a2)
{
long long v3; // rdi
long long v4; // rax
long long v5; // r12
unsigned long long v6; // r13
unsigned int v7; // r14d
long long v8; // rdi
int v9; // eax
int v10; // ecx
v3 = a1[16];
if ( v3 )
{
v4 = *a1;
if ( *(_DWORD *)(*a1 + 384LL) )
{
v5 = 0LL;
v6 = 0LL;
v7 = 0;
do
{
v8 = a1[16];
if ( *(_QWORD *)(v8 + v5) )
{
v9 = delete_tree(v5 + v8, (unsigned int)a2);
v10 = v7;
if ( !v7 )
v10 = v9;
if ( v9 )
{
v7 = v10;
a2 = 1;
}
v4 = *a1;
}
++v6;
v5 += 664LL;
}
while ( v6 < *(unsigned int *)(v4 + 384) );
v3 = a1[16];
}
else
{
v7 = 0;
}
my_free(v3);
a1[16] = 0LL;
}
else
{
return 0;
}
return v7;
}
| mi_end_bulk_insert:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x80]
TEST RDI,RDI
JZ 0x001895d1
MOV RAX,qword ptr [RBX]
CMP dword ptr [RAX + 0x180],0x0
JZ 0x001895d6
XOR R12D,R12D
XOR R13D,R13D
XOR R14D,R14D
LAB_00189578:
MOV RDI,qword ptr [RBX + 0x80]
CMP qword ptr [RDI + R12*0x1],0x0
JZ 0x001895b3
ADD RDI,R12
MOVSX R15D,SIL
MOV ESI,R15D
CALL 0x001a42ba
TEST R14D,R14D
MOV ECX,R14D
CMOVZ ECX,EAX
TEST EAX,EAX
CMOVNZ R14D,ECX
MOVZX ESI,R15B
MOV EAX,0x1
CMOVNZ ESI,EAX
MOV RAX,qword ptr [RBX]
LAB_001895b3:
INC R13
MOV ECX,dword ptr [RAX + 0x180]
ADD R12,0x298
CMP R13,RCX
JC 0x00189578
MOV RDI,qword ptr [RBX + 0x80]
JMP 0x001895d9
LAB_001895d1:
XOR R14D,R14D
JMP 0x001895e9
LAB_001895d6:
XOR R14D,R14D
LAB_001895d9:
CALL 0x0019fb2e
MOV qword ptr [RBX + 0x80],0x0
LAB_001895e9:
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int mi_end_bulk_insert(long *param_1,char param_2)
{
int iVar1;
long lVar2;
int iVar3;
long lVar4;
ulong uVar5;
int iVar6;
lVar4 = param_1[0x10];
if (lVar4 == 0) {
iVar6 = 0;
}
else {
lVar2 = *param_1;
if (*(int *)(lVar2 + 0x180) == 0) {
iVar6 = 0;
}
else {
lVar4 = 0;
uVar5 = 0;
iVar6 = 0;
do {
if (*(long *)(param_1[0x10] + lVar4) != 0) {
iVar1 = delete_tree(param_1[0x10] + lVar4,(int)param_2);
iVar3 = iVar6;
if (iVar6 == 0) {
iVar3 = iVar1;
}
if (iVar1 != 0) {
iVar6 = iVar3;
}
if (iVar1 != 0) {
param_2 = '\x01';
}
lVar2 = *param_1;
}
uVar5 = uVar5 + 1;
lVar4 = lVar4 + 0x298;
} while (uVar5 < *(uint *)(lVar2 + 0x180));
lVar4 = param_1[0x10];
}
my_free(lVar4);
param_1[0x10] = 0;
}
return iVar6;
}
| |
42,820 | 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>::push_back(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&) | monkey531[P]llama/common/json.hpp | void push_back(const basic_json& val)
{
// push_back only works for null objects or arrays
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
{
JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
}
// transform null object into an array
if (is_null())
{
m_data.m_type = value_t::array;
m_data.m_value = value_t::array;
assert_invariant();
}
// add element to array
const auto old_capacity = m_data.m_value.array->capacity();
m_data.m_value.array->push_back(val);
set_parent(m_data.m_value.array->back(), old_capacity);
} | 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>::push_back(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
jne 0x6dfba
movb $0x2, (%r14)
movl $0x18, %edi
callq 0x1a720
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x426e2
jmp 0x6dfbf
cmpl $0x2, %eax
jne 0x6dfd3
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x741da
movl $0x20, %edi
callq 0x1a390
movq %rax, %rbx
movq %r14, %rdi
callq 0x42dd6
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x43b20(%rip), %rsi # 0xb1b17
leaq 0x10(%rsp), %rdi
callq 0x42d4d
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x134, %esi # imm = 0x134
movq %r14, %rcx
callq 0x4ea00
xorl %ebp, %ebp
leaq 0x732a6(%rip), %rsi # 0xe12c8
leaq -0x1cf8d(%rip), %rdx # 0x5109c
movq %rbx, %rdi
callq 0x1acd0
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6e04f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a740
testb %bpl, %bpl
jne 0x6e059
jmp 0x6e061
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a530
movq %r14, %rdi
callq 0x1ad30
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9push_backERKSD_:
push rbp; char
push r14; int
push rbx; __int64
sub rsp, 30h
mov rbx, rsi
mov r14, rdi
movzx eax, byte ptr [rdi]
test eax, eax
jnz short loc_6DFBA
mov byte ptr [r14], 2
mov edi, 18h; unsigned __int64
call __Znwm; operator new(ulong)
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
mov [r14+8], rax
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
jmp short loc_6DFBF
loc_6DFBA:
cmp eax, 2
jnz short loc_6DFD3
loc_6DFBF:
mov rdi, [r14+8]
mov rsi, rbx
add rsp, 30h
pop rbx
pop r14
pop rbp
jmp _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE9push_backERKSD_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::push_back(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
loc_6DFD3:
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, aCannotUsePushB; "cannot use push_back() with "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA29_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(char const(&)[29],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 134h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
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
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_6E04F
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_6E04F:
test bpl, bpl
jnz short loc_6E059
jmp short loc_6E061
mov r14, rax
loc_6E059:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_6E061:
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>::push_back(
long long a1,
long long a2)
{
long long v2; // rax
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
const char *v5; // [rsp+8h] [rbp-40h] BYREF
_QWORD v6[2]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 )
{
if ( *(_BYTE *)a1 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v5 = 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(&)[29],char const*>(
(long long)v6,
(long long)"cannot use push_back() with ",
&v5);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
308,
v6);
__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);
}
}
else
{
*(_BYTE *)a1 = 2;
v2 = operator new(0x18uLL);
*(_OWORD *)v2 = 0LL;
*(_QWORD *)(v2 + 16) = 0LL;
*(_QWORD *)(a1 + 8) = v2;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
}
return std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::push_back(
*(_QWORD *)(a1 + 8),
a2);
}
| push_back:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RSI
MOV R14,RDI
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JNZ 0x0016dfba
MOV byte ptr [R14],0x2
MOV EDI,0x18
CALL 0x0011a720
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
MOV qword ptr [R14 + 0x8],RAX
MOV RDI,R14
MOV ESI,0x1
CALL 0x001426e2
JMP 0x0016dfbf
LAB_0016dfba:
CMP EAX,0x2
JNZ 0x0016dfd3
LAB_0016dfbf:
MOV RDI,qword ptr [R14 + 0x8]
MOV RSI,RBX
ADD RSP,0x30
POP RBX
POP R14
POP RBP
JMP 0x001741da
LAB_0016dfd3:
MOV EDI,0x20
CALL 0x0011a390
MOV RBX,RAX
MOV RDI,R14
CALL 0x00142dd6
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_0016dff0:
LEA RSI,[0x1b1b17]
LEA RDI,[RSP + 0x10]
CALL 0x00142d4d
MOV BPL,0x1
LAB_0016e004:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x134
MOV RCX,R14
CALL 0x0014ea00
XOR EBP,EBP
LEA RSI,[0x1e12c8]
LEA RDX,[0x15109c]
MOV RDI,RBX
CALL 0x0011acd0
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >,
void>::push_back(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&) */
void __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::push_back(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,basic_json *param_1)
{
int8 *puVar1;
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>
)0x0) {
*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>
)0x2;
puVar1 = (int8 *)operator_new(0x18);
*puVar1 = 0;
puVar1[1] = 0;
puVar1[2] = 0;
*(int8 **)(this + 8) = puVar1;
assert_invariant(SUB81(this,0));
}
else 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>
)0x2) {
uVar2 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 0016dff0 to 0016e000 has its CatchHandler @ 0016e056 */
detail::concat<std::__cxx11::string,char_const(&)[29],char_const*>
(local_38,"cannot use push_back() with ",&local_40);
/* try { // try from 0016e004 to 0016e030 has its CatchHandler @ 0016e031 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar2,0x134,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,&detail::type_error::typeinfo,detail::exception::~exception);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::push_back(*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(this + 8),param_1);
return;
}
| |
42,821 | 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>::get_binary() const | monkey531[P]llama/common/json.hpp | const binary_t& get_binary() const
{
if (!is_binary())
{
JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));
}
return *get_ptr<const binary_t*>();
} | 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>::get_binary() const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x8, (%rdi)
jne 0x841f3
movq 0x8(%r14), %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x23470
movq %rax, %rbx
movq %r14, %rdi
callq 0x445e8
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x320b7(%rip), %rsi # 0xb62cc
leaq 0x10(%rsp), %rdi
callq 0x645c7
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12e, %esi # imm = 0x12E
movq %r14, %rcx
callq 0x644da
xorl %ebp, %ebp
leaq 0x78cf8(%rip), %rsi # 0xfcf38
leaq -0x430cf(%rip), %rdx # 0x41178
movq %rbx, %rdi
callq 0x23f00
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x241c8
testb %bpl, %bpl
jne 0x84266
jmp 0x8426e
movq %rax, %r14
movq %rbx, %rdi
callq 0x236a0
movq %r14, %rdi
callq 0x23f80
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10get_binaryEv:
push rbp; char
push r14; int
push rbx; int
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 8
jnz short loc_841F3
mov rax, [r14+8]
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_841F3:
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, aTypeMustBeBina; "type must be binary, but is "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA29_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(char const(&)[29],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 12Eh; 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
mov r14, rax
lea rdi, [rsp+48h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_84266
jmp short loc_8426E
mov r14, rax
loc_84266:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_8426E:
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>::get_binary(
long long a1)
{
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // rbx
const char *v3; // [rsp+8h] [rbp-40h] BYREF
_BYTE v4[56]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 != 8 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
v3 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(
(long long)v4,
(long long)"type must be binary, but is ",
&v3);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
302,
(long long)v4);
__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);
}
return *(_QWORD *)(a1 + 8);
}
| get_binary:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x8
JNZ 0x001841f3
MOV RAX,qword ptr [R14 + 0x8]
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_001841f3:
PUSH 0x20
POP RDI
CALL 0x00123470
MOV RBX,RAX
MOV RDI,R14
CALL 0x001445e8
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_0018420e:
LEA RSI,[0x1b62cc]
LEA RDI,[RSP + 0x10]
CALL 0x001645c7
MOV BPL,0x1
LAB_00184222:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12e
MOV RCX,R14
CALL 0x001644da
XOR EBP,EBP
LEA RSI,[0x1fcf38]
LEA RDX,[0x141178]
MOV RDI,RBX
CALL 0x00123f00
|
/* 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>::get_binary() const */
int8 __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>
::get_binary(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this)
{
int8 uVar1;
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>
)0x8) {
return *(int8 *)(this + 8);
}
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 0018420e to 0018421e has its CatchHandler @ 00184263 */
detail::concat<std::__cxx11::string,char_const(&)[29],char_const*>
(local_38,"type must be binary, but is ",&local_40);
/* try { // try from 00184222 to 0018424e has its CatchHandler @ 0018424f */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar1,0x12e,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
| |
42,822 | pagecache_delete_internal | eloqsql/storage/maria/ma_pagecache.c | static my_bool pagecache_delete_internal(PAGECACHE *pagecache,
PAGECACHE_BLOCK_LINK *block,
PAGECACHE_HASH_LINK *page_link,
my_bool flush)
{
my_bool error= 0;
if (block->status & PCBLOCK_IN_FLUSH)
{
/*
this call is just 'hint' for the cache to free the page so we will
not interferes with flushing process but must return success
*/
goto out;
}
if (block->status & PCBLOCK_CHANGED)
{
flush= (flush || (block->status & PCBLOCK_DEL_WRITE));
if (flush)
{
/* The block contains a dirty page - push it out of the cache */
KEYCACHE_DBUG_PRINT("find_block", ("block is dirty"));
/*
The call is thread safe because only the current
thread might change the block->hash_link value
*/
DBUG_ASSERT(block->pins == 1);
pagecache_pthread_mutex_unlock(&pagecache->cache_lock);
error= pagecache_fwrite(pagecache,
&block->hash_link->file,
block->buffer,
block->hash_link->pageno,
block->type,
pagecache->readwrite_flags);
pagecache_pthread_mutex_lock(&pagecache->cache_lock);
pagecache->global_cache_write++;
if (error)
{
block->status|= PCBLOCK_ERROR;
block->error= (int16) my_errno;
my_debug_put_break_here();
goto out;
}
}
else
{
PAGECACHE_IO_HOOK_ARGS args;
PAGECACHE_FILE *filedesc= &block->hash_link->file;
args.page= block->buffer;
args.pageno= block->hash_link->pageno;
args.data= filedesc->callback_data;
/* We are not going to write the page but have to call callbacks */
DBUG_PRINT("info", ("flush_callback: %p data: %p",
filedesc->flush_log_callback,
filedesc->callback_data));
if ((*filedesc->flush_log_callback)(&args))
{
DBUG_PRINT("error", ("flush or write callback problem"));
error= 1;
goto out;
}
}
pagecache->blocks_changed--;
pagecache->global_blocks_changed--;
/*
free_block() will change the status and rec_lsn of the block so no
need to change them here.
*/
}
/* Cache is locked, so we can relese page before freeing it */
if (make_lock_and_pin(pagecache, block,
PAGECACHE_LOCK_WRITE_UNLOCK,
PAGECACHE_UNPIN, FALSE))
DBUG_ASSERT(0);
DBUG_ASSERT(block->hash_link->requests > 0);
page_link->requests--;
/* See NOTE for pagecache_unlock() about registering requests. */
free_block(pagecache, block, 0);
dec_counter_for_resize_op(pagecache);
return 0;
out:
/* Cache is locked, so we can relese page before freeing it */
if (make_lock_and_pin(pagecache, block,
PAGECACHE_LOCK_WRITE_UNLOCK,
PAGECACHE_UNPIN, FALSE))
DBUG_ASSERT(0);
page_link->requests--;
unreg_request(pagecache, block, 1);
dec_counter_for_resize_op(pagecache);
return error;
} | O3 | c | pagecache_delete_internal:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x74(%rsi), %eax
testb $0x10, %al
jne 0x50c6b
testb $0x20, %al
je 0x50d4a
testb %cl, %cl
sete %cl
testb %al, %al
setns %al
testb %al, %cl
je 0x50cc5
movq 0x20(%r14), %rax
movq 0x30(%r14), %rcx
leaq -0x48(%rbp), %rdi
movq %rcx, (%rdi)
movq 0x60(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq 0x58(%rax), %rcx
movq %rcx, 0x10(%rdi)
callq *0x50(%rax)
movb $0x1, %r12b
testb %al, %al
jne 0x50c6e
jmp 0x50d3f
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r14, %rsi
movl $0x6, %edx
movl $0x3, %ecx
callq 0x4f65f
decl 0x68(%r15)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x4f7cf
decq 0x68(%rbx)
jne 0x50da4
movq 0x110(%rbx), %rax
testq %rax, %rax
je 0x50da4
movq 0x88(%rax), %rbx
movq 0x38(%rbx), %rdi
addq $0x8, %rbx
jmp 0x50d97
leaq 0xc8(%rbx), %r13
movq 0x108(%rbx), %rdi
testq %rdi, %rdi
jne 0x50dcd
movq %r13, %rdi
callq 0x2a1e0
movq 0x20(%r14), %rsi
movq 0x30(%r14), %rdx
movq 0x60(%rsi), %rcx
addq $0x18, %rsi
movq 0x198(%rbx), %r8
movq %rbx, %rdi
callq 0x517e0
movl %eax, %r12d
cmpq $0x0, 0x108(%rbx)
jne 0x50de2
movq %r13, %rdi
callq 0x2a220
incq 0x178(%rbx)
testb %r12b, %r12b
je 0x50d3f
orb $0x1, 0x74(%r14)
callq 0xa66da
movzwl (%rax), %eax
movw %ax, 0x76(%r14)
jmp 0x50c6e
decq 0x58(%rbx)
decq 0x168(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x6, %edx
movl $0x3, %ecx
callq 0x4f65f
decl 0x68(%r15)
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x52381
decq 0x68(%rbx)
jne 0x50da4
movq 0x110(%rbx), %rax
testq %rax, %rax
je 0x50db6
movq 0x88(%rax), %rbx
movq 0x38(%rbx), %rdi
addq $0x8, %rbx
xorl %r12d, %r12d
testq %rdi, %rdi
jne 0x50dbb
movq %rbx, %rdi
callq 0x2a600
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
jmp 0x50da4
leaq 0x33d406(%rip), %rax # 0x38e1c8
movq (%rax), %rax
callq *0x170(%rax)
jmp 0x50d9c
leaq 0x33d3f4(%rip), %rax # 0x38e1c8
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x50cdc
leaq 0x90237(%rip), %rsi # 0xe1020
movq %r13, %rdi
movl $0xfa2, %edx # imm = 0xFA2
callq 0x2fc0f
jmp 0x50d1c
| pagecache_delete_internal:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
movzx eax, word ptr [rsi+74h]
test al, 10h
jnz short loc_50C6B
test al, 20h
jz loc_50D4A
test cl, cl
setz cl
test al, al
setns al
test cl, al
jz loc_50CC5
mov rax, [r14+20h]
mov rcx, [r14+30h]
lea rdi, [rbp+var_48]
mov [rdi], rcx
mov rcx, [rax+60h]
mov [rdi+8], rcx
mov rcx, [rax+58h]
mov [rdi+10h], rcx
call qword ptr [rax+50h]
mov r12b, 1
test al, al
jnz short loc_50C6E
jmp loc_50D3F
loc_50C6B:
xor r12d, r12d
loc_50C6E:
mov rdi, rbx
mov rsi, r14
mov edx, 6
mov ecx, 3
call make_lock_and_pin
dec dword ptr [r15+68h]
mov rdi, rbx
mov rsi, r14
mov edx, 1
call unreg_request
dec qword ptr [rbx+68h]
jnz loc_50DA4
mov rax, [rbx+110h]
test rax, rax
jz loc_50DA4
mov rbx, [rax+88h]
mov rdi, [rbx+38h]
add rbx, 8
jmp loc_50D97
loc_50CC5:
lea r13, [rbx+0C8h]
mov rdi, [rbx+108h]
test rdi, rdi
jnz loc_50DCD
loc_50CDC:
mov rdi, r13
call _pthread_mutex_unlock
mov rsi, [r14+20h]
mov rdx, [r14+30h]
mov rcx, [rsi+60h]
add rsi, 18h
mov r8, [rbx+198h]
mov rdi, rbx
call pagecache_fwrite
mov r12d, eax
cmp qword ptr [rbx+108h], 0
jnz loc_50DE2
mov rdi, r13
call _pthread_mutex_lock
loc_50D1C:
inc qword ptr [rbx+178h]
test r12b, r12b
jz short loc_50D3F
or byte ptr [r14+74h], 1
call _my_thread_var
movzx eax, word ptr [rax]
mov [r14+76h], ax
jmp loc_50C6E
loc_50D3F:
dec qword ptr [rbx+58h]
dec qword ptr [rbx+168h]
loc_50D4A:
mov rdi, rbx
mov rsi, r14
mov edx, 6
mov ecx, 3
call make_lock_and_pin
dec dword ptr [r15+68h]
xor r12d, r12d
mov rdi, rbx
mov rsi, r14
xor edx, edx
call free_block
dec qword ptr [rbx+68h]
jnz short loc_50DA4
mov rax, [rbx+110h]
test rax, rax
jz short loc_50DB6
mov rbx, [rax+88h]
mov rdi, [rbx+38h]
add rbx, 8
xor r12d, r12d
loc_50D97:
test rdi, rdi
jnz short loc_50DBB
loc_50D9C:
mov rdi, rbx
call _pthread_cond_signal
loc_50DA4:
mov eax, r12d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_50DB6:
xor r12d, r12d
jmp short loc_50DA4
loc_50DBB:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+170h]
jmp short loc_50D9C
loc_50DCD:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_50CDC
loc_50DE2:
lea rsi, aWorkspaceLlm4b_29; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r13
mov edx, 0FA2h
call psi_mutex_lock
jmp loc_50D1C
| long long pagecache_delete_internal(_QWORD *a1, long long a2, long long a3, char a4)
{
unsigned int v4; // r12d
__int16 v7; // ax
bool v8; // zf
long long v9; // rax
long long v10; // rbx
long long v11; // rdi
long long v12; // rbx
_QWORD *v13; // rdi
long long v14; // rax
long long v15; // rbx
v7 = *(_WORD *)(a2 + 116);
if ( (v7 & 0x10) != 0 )
{
v4 = 0;
}
else
{
if ( (v7 & 0x20) == 0 )
{
LABEL_17:
make_lock_and_pin((long long)a1, a2, 6, 3);
--*(_DWORD *)(a3 + 104);
v4 = 0;
free_block(a1, a2, 0LL);
v8 = a1[13]-- == 1LL;
if ( !v8 )
return v4;
v14 = a1[34];
if ( !v14 )
return 0;
v15 = *(_QWORD *)(v14 + 136);
v11 = *(_QWORD *)(v15 + 56);
v12 = v15 + 8;
v4 = 0;
goto LABEL_20;
}
if ( (v7 & 0x80u) == 0 && a4 == 0 )
{
LOBYTE(v4) = 1;
if ( !(*(unsigned __int8 (**)(void))(*(_QWORD *)(a2 + 32) + 80LL))() )
{
LABEL_16:
--a1[11];
--a1[45];
goto LABEL_17;
}
}
else
{
if ( a1[33] )
PSI_server[44]();
pthread_mutex_unlock(a1 + 25);
v4 = pagecache_fwrite(
a1,
*(_QWORD *)(a2 + 32) + 24LL,
*(_QWORD *)(a2 + 48),
*(_QWORD *)(*(_QWORD *)(a2 + 32) + 96LL),
a1[51]);
v13 = a1 + 25;
if ( a1[33] )
psi_mutex_lock(
(long long)(a1 + 25),
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0xFA2u);
else
pthread_mutex_lock(a1 + 25);
++a1[47];
if ( !(_BYTE)v4 )
goto LABEL_16;
*(_BYTE *)(a2 + 116) |= 1u;
*(_WORD *)(a2 + 118) = *(_WORD *)my_thread_var(v13);
}
}
make_lock_and_pin((long long)a1, a2, 6, 3);
--*(_DWORD *)(a3 + 104);
unreg_request(a1, a2, 1);
v8 = a1[13]-- == 1LL;
if ( !v8 )
return v4;
v9 = a1[34];
if ( !v9 )
return v4;
v10 = *(_QWORD *)(v9 + 136);
v11 = *(_QWORD *)(v10 + 56);
v12 = v10 + 8;
LABEL_20:
if ( v11 )
PSI_server[46]();
pthread_cond_signal(v12);
return v4;
}
| pagecache_delete_internal:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
MOVZX EAX,word ptr [RSI + 0x74]
TEST AL,0x10
JNZ 0x00150c6b
TEST AL,0x20
JZ 0x00150d4a
TEST CL,CL
SETZ CL
TEST AL,AL
SETNS AL
TEST CL,AL
JZ 0x00150cc5
MOV RAX,qword ptr [R14 + 0x20]
MOV RCX,qword ptr [R14 + 0x30]
LEA RDI,[RBP + -0x48]
MOV qword ptr [RDI],RCX
MOV RCX,qword ptr [RAX + 0x60]
MOV qword ptr [RDI + 0x8],RCX
MOV RCX,qword ptr [RAX + 0x58]
MOV qword ptr [RDI + 0x10],RCX
CALL qword ptr [RAX + 0x50]
MOV R12B,0x1
TEST AL,AL
JNZ 0x00150c6e
JMP 0x00150d3f
LAB_00150c6b:
XOR R12D,R12D
LAB_00150c6e:
MOV RDI,RBX
MOV RSI,R14
MOV EDX,0x6
MOV ECX,0x3
CALL 0x0014f65f
DEC dword ptr [R15 + 0x68]
MOV RDI,RBX
MOV RSI,R14
MOV EDX,0x1
CALL 0x0014f7cf
DEC qword ptr [RBX + 0x68]
JNZ 0x00150da4
MOV RAX,qword ptr [RBX + 0x110]
TEST RAX,RAX
JZ 0x00150da4
MOV RBX,qword ptr [RAX + 0x88]
MOV RDI,qword ptr [RBX + 0x38]
ADD RBX,0x8
JMP 0x00150d97
LAB_00150cc5:
LEA R13,[RBX + 0xc8]
MOV RDI,qword ptr [RBX + 0x108]
TEST RDI,RDI
JNZ 0x00150dcd
LAB_00150cdc:
MOV RDI,R13
CALL 0x0012a1e0
MOV RSI,qword ptr [R14 + 0x20]
MOV RDX,qword ptr [R14 + 0x30]
MOV RCX,qword ptr [RSI + 0x60]
ADD RSI,0x18
MOV R8,qword ptr [RBX + 0x198]
MOV RDI,RBX
CALL 0x001517e0
MOV R12D,EAX
CMP qword ptr [RBX + 0x108],0x0
JNZ 0x00150de2
MOV RDI,R13
CALL 0x0012a220
LAB_00150d1c:
INC qword ptr [RBX + 0x178]
TEST R12B,R12B
JZ 0x00150d3f
OR byte ptr [R14 + 0x74],0x1
CALL 0x001a66da
MOVZX EAX,word ptr [RAX]
MOV word ptr [R14 + 0x76],AX
JMP 0x00150c6e
LAB_00150d3f:
DEC qword ptr [RBX + 0x58]
DEC qword ptr [RBX + 0x168]
LAB_00150d4a:
MOV RDI,RBX
MOV RSI,R14
MOV EDX,0x6
MOV ECX,0x3
CALL 0x0014f65f
DEC dword ptr [R15 + 0x68]
XOR R12D,R12D
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
CALL 0x00152381
DEC qword ptr [RBX + 0x68]
JNZ 0x00150da4
MOV RAX,qword ptr [RBX + 0x110]
TEST RAX,RAX
JZ 0x00150db6
MOV RBX,qword ptr [RAX + 0x88]
MOV RDI,qword ptr [RBX + 0x38]
ADD RBX,0x8
XOR R12D,R12D
LAB_00150d97:
TEST RDI,RDI
JNZ 0x00150dbb
LAB_00150d9c:
MOV RDI,RBX
CALL 0x0012a600
LAB_00150da4:
MOV EAX,R12D
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00150db6:
XOR R12D,R12D
JMP 0x00150da4
LAB_00150dbb:
LEA RAX,[0x48e1c8]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x170]
JMP 0x00150d9c
LAB_00150dcd:
LEA RAX,[0x48e1c8]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00150cdc
LAB_00150de2:
LEA RSI,[0x1e1020]
MOV RDI,R13
MOV EDX,0xfa2
CALL 0x0012fc0f
JMP 0x00150d1c
|
ulong pagecache_delete_internal(long param_1,long param_2,long param_3,char param_4)
{
long *plVar1;
pthread_mutex_t *__mutex;
ushort uVar2;
long lVar3;
char cVar4;
uint uVar5;
int2 *puVar6;
long lVar7;
int8 unaff_R12;
ulong uVar8;
uVar2 = *(ushort *)(param_2 + 0x74);
if ((uVar2 & 0x10) != 0) {
uVar8 = 0;
goto LAB_00150c6e;
}
if ((uVar2 & 0x20) == 0) {
LAB_00150d4a:
make_lock_and_pin(param_1,param_2,6,3);
*(int *)(param_3 + 0x68) = *(int *)(param_3 + 0x68) + -1;
uVar8 = 0;
free_block(param_1,param_2,0);
plVar1 = (long *)(param_1 + 0x68);
*plVar1 = *plVar1 + -1;
if (*plVar1 != 0) goto LAB_00150da4;
if (*(long *)(param_1 + 0x110) == 0) {
uVar8 = 0;
goto LAB_00150da4;
}
lVar3 = *(long *)(*(long *)(param_1 + 0x110) + 0x88);
lVar7 = *(long *)(lVar3 + 0x38);
uVar8 = 0;
}
else {
if (param_4 == '\0' && -1 < (char)uVar2) {
cVar4 = (**(code **)(*(long *)(param_2 + 0x20) + 0x50))();
uVar8 = CONCAT71((int7)((ulong)unaff_R12 >> 8),1);
if (cVar4 == '\0') {
LAB_00150d3f:
*(long *)(param_1 + 0x58) = *(long *)(param_1 + 0x58) + -1;
*(long *)(param_1 + 0x168) = *(long *)(param_1 + 0x168) + -1;
goto LAB_00150d4a;
}
}
else {
__mutex = (pthread_mutex_t *)(param_1 + 200);
if (*(long *)(param_1 + 0x108) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
uVar5 = pagecache_fwrite(param_1,*(long *)(param_2 + 0x20) + 0x18,
*(int8 *)(param_2 + 0x30),
*(int8 *)(*(long *)(param_2 + 0x20) + 0x60),
*(int8 *)(param_1 + 0x198));
uVar8 = (ulong)uVar5;
if (*(long *)(param_1 + 0x108) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",0xfa2
);
}
*(long *)(param_1 + 0x178) = *(long *)(param_1 + 0x178) + 1;
if ((char)uVar5 == '\0') goto LAB_00150d3f;
*(byte *)(param_2 + 0x74) = *(byte *)(param_2 + 0x74) | 1;
puVar6 = (int2 *)_my_thread_var();
*(int2 *)(param_2 + 0x76) = *puVar6;
}
LAB_00150c6e:
make_lock_and_pin(param_1,param_2,6,3);
*(int *)(param_3 + 0x68) = *(int *)(param_3 + 0x68) + -1;
unreg_request(param_1,param_2,1);
plVar1 = (long *)(param_1 + 0x68);
*plVar1 = *plVar1 + -1;
if ((*plVar1 != 0) || (*(long *)(param_1 + 0x110) == 0)) goto LAB_00150da4;
lVar3 = *(long *)(*(long *)(param_1 + 0x110) + 0x88);
lVar7 = *(long *)(lVar3 + 0x38);
}
if (lVar7 != 0) {
(**(code **)(PSI_server + 0x170))();
}
pthread_cond_signal((pthread_cond_t *)(lVar3 + 8));
LAB_00150da4:
return uVar8 & 0xffffffff;
}
| |
42,823 | test_matrix_transpose | tsotchke[P]eshkol/tests/unit/test_vector.c | static void test_matrix_transpose(void) {
printf("Testing matrix transpose...\n");
// Create an arena
Arena* arena = arena_create(1024);
assert(arena != NULL);
// Create matrix
MatrixF* a = matrix_f_create(arena, 2, 3);
assert(a != NULL);
// Set matrix
float a_data[6] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f};
assert(matrix_f_set(a, a_data, 2, 3));
// Transpose matrix
MatrixF* b = matrix_f_transpose(arena, a);
assert(b != NULL);
assert(b->rows == 3 && b->cols == 2);
assert(b->data[0][0] == 1.0f && b->data[0][1] == 4.0f);
assert(b->data[1][0] == 2.0f && b->data[1][1] == 5.0f);
assert(b->data[2][0] == 3.0f && b->data[2][1] == 6.0f);
// Destroy the arena
arena_destroy(arena);
printf("PASS: matrix_transpose\n");
} | O0 | c | test_matrix_transpose:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x7979(%rip), %rdi # 0xae28
movb $0x0, %al
callq 0x1080
movl $0x400, %edi # imm = 0x400
callq 0x42a0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x34cd
jmp 0x34ec
leaq 0x6d01(%rip), %rdi # 0xa1d5
leaq 0x6c56(%rip), %rsi # 0xa131
movl $0x206, %edx # imm = 0x206
leaq 0x795e(%rip), %rcx # 0xae45
callq 0x1090
movq -0x8(%rbp), %rdi
movl $0x2, %esi
movl $0x3, %edx
callq 0x6220
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x350c
jmp 0x352b
leaq 0x6cc6(%rip), %rdi # 0xa1d9
leaq 0x6c17(%rip), %rsi # 0xa131
movl $0x20a, %edx # imm = 0x20A
leaq 0x791f(%rip), %rcx # 0xae45
callq 0x1090
movq 0x7f5e(%rip), %rax # 0xb490
movq %rax, -0x30(%rbp)
movq 0x7f5b(%rip), %rax # 0xb498
movq %rax, -0x28(%rbp)
movq 0x7f58(%rip), %rax # 0xb4a0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x2, %edx
movl $0x3, %ecx
callq 0x6530
testb $0x1, %al
jne 0x3569
jmp 0x356b
jmp 0x358a
leaq 0x7725(%rip), %rdi # 0xac97
leaq 0x6bb8(%rip), %rsi # 0xa131
movl $0x20e, %edx # imm = 0x20E
leaq 0x78c0(%rip), %rcx # 0xae45
callq 0x1090
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6d40
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x35a4
jmp 0x35c3
leaq 0x6efe(%rip), %rdi # 0xa4a9
leaq 0x6b7f(%rip), %rsi # 0xa131
movl $0x212, %edx # imm = 0x212
leaq 0x7887(%rip), %rcx # 0xae45
callq 0x1090
movq -0x38(%rbp), %rax
cmpq $0x3, 0x40(%rax)
jne 0x35db
movq -0x38(%rbp), %rax
cmpq $0x2, 0x48(%rax)
jne 0x35db
jmp 0x35fa
leaq 0x7884(%rip), %rdi # 0xae66
leaq 0x6b48(%rip), %rsi # 0xa131
movl $0x213, %edx # imm = 0x213
leaq 0x7850(%rip), %rcx # 0xae45
callq 0x1090
movq -0x38(%rbp), %rax
movss (%rax), %xmm0
movss 0x69fa(%rip), %xmm1 # 0xa004
ucomiss %xmm1, %xmm0
jne 0x362b
jp 0x362b
movq -0x38(%rbp), %rax
movss 0x4(%rax), %xmm0
movss 0x69fa(%rip), %xmm1 # 0xa01c
ucomiss %xmm1, %xmm0
jne 0x362b
jp 0x362b
jmp 0x364a
leaq 0x7851(%rip), %rdi # 0xae83
leaq 0x6af8(%rip), %rsi # 0xa131
movl $0x214, %edx # imm = 0x214
leaq 0x7800(%rip), %rcx # 0xae45
callq 0x1090
movq -0x38(%rbp), %rax
movss 0x10(%rax), %xmm0
movss 0x69ad(%rip), %xmm1 # 0xa008
ucomiss %xmm1, %xmm0
jne 0x367c
jp 0x367c
movq -0x38(%rbp), %rax
movss 0x14(%rax), %xmm0
movss 0x699d(%rip), %xmm1 # 0xa010
ucomiss %xmm1, %xmm0
jne 0x367c
jp 0x367c
jmp 0x369b
leaq 0x782f(%rip), %rdi # 0xaeb2
leaq 0x6aa7(%rip), %rsi # 0xa131
movl $0x215, %edx # imm = 0x215
leaq 0x77af(%rip), %rcx # 0xae45
callq 0x1090
movq -0x38(%rbp), %rax
movss 0x20(%rax), %xmm0
movss 0x6960(%rip), %xmm1 # 0xa00c
ucomiss %xmm1, %xmm0
jne 0x36cd
jp 0x36cd
movq -0x38(%rbp), %rax
movss 0x24(%rax), %xmm0
movss 0x695c(%rip), %xmm1 # 0xa020
ucomiss %xmm1, %xmm0
jne 0x36cd
jp 0x36cd
jmp 0x36ec
leaq 0x780d(%rip), %rdi # 0xaee1
leaq 0x6a56(%rip), %rsi # 0xa131
movl $0x216, %edx # imm = 0x216
leaq 0x775e(%rip), %rcx # 0xae45
callq 0x1090
movq -0x8(%rbp), %rdi
callq 0x4880
leaq 0x7814(%rip), %rdi # 0xaf10
movb $0x0, %al
callq 0x1080
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
| test_matrix_transpose:
push rbp
mov rbp, rsp
sub rsp, 40h
lea rdi, aTestingMatrixT; "Testing matrix transpose...\n"
mov al, 0
call _printf
mov edi, 400h
call arena_create
mov [rbp+var_8], rax
cmp [rbp+var_8], 0
jz short loc_34CD
jmp short loc_34EC
loc_34CD:
lea rdi, aArenaNull; "arena != NULL"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 206h
lea rcx, aVoidTestMatrix_5; "void test_matrix_transpose(void)"
call ___assert_fail
loc_34EC:
mov rdi, [rbp+var_8]
mov esi, 2
mov edx, 3
call matrix_f_create
mov [rbp+var_10], rax
cmp [rbp+var_10], 0
jz short loc_350C
jmp short loc_352B
loc_350C:
lea rdi, aArenaNull+4; "a != NULL"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 20Ah
lea rcx, aVoidTestMatrix_5; "void test_matrix_transpose(void)"
call ___assert_fail
loc_352B:
mov rax, cs:qword_B490
mov [rbp+var_30], rax
mov rax, cs:qword_B498
mov [rbp+var_28], rax
mov rax, cs:qword_B4A0
mov [rbp+var_20], rax
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_30]
mov edx, 2
mov ecx, 3
call matrix_f_set
test al, 1
jnz short loc_3569
jmp short loc_356B
loc_3569:
jmp short loc_358A
loc_356B:
lea rdi, aMatrixFSetAADa_0; "matrix_f_set(a, a_data, 2, 3)"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 20Eh
lea rcx, aVoidTestMatrix_5; "void test_matrix_transpose(void)"
call ___assert_fail
loc_358A:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
call matrix_f_transpose
mov [rbp+var_38], rax
cmp [rbp+var_38], 0
jz short loc_35A4
jmp short loc_35C3
loc_35A4:
lea rdi, aBNull; "b != NULL"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 212h
lea rcx, aVoidTestMatrix_5; "void test_matrix_transpose(void)"
call ___assert_fail
loc_35C3:
mov rax, [rbp+var_38]
cmp qword ptr [rax+40h], 3
jnz short loc_35DB
mov rax, [rbp+var_38]
cmp qword ptr [rax+48h], 2
jnz short loc_35DB
jmp short loc_35FA
loc_35DB:
lea rdi, aBRows3BCols2; "b->rows == 3 && b->cols == 2"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 213h
lea rcx, aVoidTestMatrix_5; "void test_matrix_transpose(void)"
call ___assert_fail
loc_35FA:
mov rax, [rbp+var_38]
movss xmm0, dword ptr [rax]
movss xmm1, cs:dword_A004
ucomiss xmm0, xmm1
jnz short loc_362B
jp short loc_362B
mov rax, [rbp+var_38]
movss xmm0, dword ptr [rax+4]
movss xmm1, cs:dword_A01C
ucomiss xmm0, xmm1
jnz short loc_362B
jp short loc_362B
jmp short loc_364A
loc_362B:
lea rdi, aBData0010fBDat; "b->data[0][0] == 1.0f && b->data[0][1] "...
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 214h
lea rcx, aVoidTestMatrix_5; "void test_matrix_transpose(void)"
call ___assert_fail
loc_364A:
mov rax, [rbp+var_38]
movss xmm0, dword ptr [rax+10h]
movss xmm1, cs:dword_A008
ucomiss xmm0, xmm1
jnz short loc_367C
jp short loc_367C
mov rax, [rbp+var_38]
movss xmm0, dword ptr [rax+14h]
movss xmm1, cs:dword_A010
ucomiss xmm0, xmm1
jnz short loc_367C
jp short loc_367C
jmp short loc_369B
loc_367C:
lea rdi, aBData1020fBDat; "b->data[1][0] == 2.0f && b->data[1][1] "...
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 215h
lea rcx, aVoidTestMatrix_5; "void test_matrix_transpose(void)"
call ___assert_fail
loc_369B:
mov rax, [rbp+var_38]
movss xmm0, dword ptr [rax+20h]
movss xmm1, cs:dword_A00C
ucomiss xmm0, xmm1
jnz short loc_36CD
jp short loc_36CD
mov rax, [rbp+var_38]
movss xmm0, dword ptr [rax+24h]
movss xmm1, cs:dword_A020
ucomiss xmm0, xmm1
jnz short loc_36CD
jp short loc_36CD
jmp short loc_36EC
loc_36CD:
lea rdi, aBData2030fBDat; "b->data[2][0] == 3.0f && b->data[2][1] "...
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 216h
lea rcx, aVoidTestMatrix_5; "void test_matrix_transpose(void)"
call ___assert_fail
loc_36EC:
mov rdi, [rbp+var_8]
call arena_destroy
lea rdi, aPassMatrixTran; "PASS: matrix_transpose\n"
mov al, 0
call _printf
add rsp, 40h
pop rbp
retn
| long long test_matrix_transpose(long long a1, long long a2, long long a3)
{
long long v3; // r8
long long v4; // r9
long long v5; // rsi
long long v6; // rax
long long v7; // rdx
_QWORD v9[4]; // [rsp+10h] [rbp-30h] BYREF
long long v10; // [rsp+30h] [rbp-10h]
long long v11; // [rsp+38h] [rbp-8h]
printf("Testing matrix transpose...\n", a2, a3);
v11 = arena_create(1024LL);
if ( !v11 )
__assert_fail(
"arena != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_vector.c",
518LL,
"void test_matrix_transpose(void)");
v10 = matrix_f_create(v11, 2LL, 3LL);
if ( !v10 )
__assert_fail(
"a != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_vector.c",
522LL,
"void test_matrix_transpose(void)");
v9[0] = 0x400000003F800000LL;
v9[1] = 0x4080000040400000LL;
v9[2] = 0x40C0000040A00000LL;
if ( (matrix_f_set(v10, v9, 2LL, 3LL, v3, v4) & 1) == 0 )
__assert_fail(
"matrix_f_set(a, a_data, 2, 3)",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_vector.c",
526LL,
"void test_matrix_transpose(void)");
v5 = v10;
v6 = matrix_f_transpose(v11, v10);
if ( !v6 )
__assert_fail(
"b != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_vector.c",
530LL,
"void test_matrix_transpose(void)");
if ( *(_QWORD *)(v6 + 64) != 3LL || *(_QWORD *)(v6 + 72) != 2LL )
__assert_fail(
"b->rows == 3 && b->cols == 2",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_vector.c",
531LL,
"void test_matrix_transpose(void)");
if ( *(float *)v6 != 1.0 || *(float *)(v6 + 4) != 4.0 )
__assert_fail(
"b->data[0][0] == 1.0f && b->data[0][1] == 4.0f",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_vector.c",
532LL,
"void test_matrix_transpose(void)");
if ( *(float *)(v6 + 16) != 2.0 || *(float *)(v6 + 20) != 5.0 )
__assert_fail(
"b->data[1][0] == 2.0f && b->data[1][1] == 5.0f",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_vector.c",
533LL,
"void test_matrix_transpose(void)");
if ( *(float *)(v6 + 32) != 3.0 || *(float *)(v6 + 36) != 6.0 )
__assert_fail(
"b->data[2][0] == 3.0f && b->data[2][1] == 6.0f",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_vector.c",
534LL,
"void test_matrix_transpose(void)");
arena_destroy(v11);
return printf("PASS: matrix_transpose\n", v5, v7);
}
| test_matrix_transpose:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
LEA RDI,[0x10ae16]
MOV AL,0x0
CALL 0x00101080
MOV EDI,0x400
CALL 0x001042a0
MOV qword ptr [RBP + -0x8],RAX
CMP qword ptr [RBP + -0x8],0x0
JZ 0x001034cd
JMP 0x001034ec
LAB_001034cd:
LEA RDI,[0x10a1c3]
LEA RSI,[0x10a131]
MOV EDX,0x206
LEA RCX,[0x10ae33]
CALL 0x00101090
LAB_001034ec:
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,0x2
MOV EDX,0x3
CALL 0x00106220
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0010350c
JMP 0x0010352b
LAB_0010350c:
LEA RDI,[0x10a1c7]
LEA RSI,[0x10a131]
MOV EDX,0x20a
LEA RCX,[0x10ae33]
CALL 0x00101090
LAB_0010352b:
MOV RAX,qword ptr [0x0010b470]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [0x0010b478]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [0x0010b480]
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x30]
MOV EDX,0x2
MOV ECX,0x3
CALL 0x00106530
TEST AL,0x1
JNZ 0x00103569
JMP 0x0010356b
LAB_00103569:
JMP 0x0010358a
LAB_0010356b:
LEA RDI,[0x10ac85]
LEA RSI,[0x10a131]
MOV EDX,0x20e
LEA RCX,[0x10ae33]
CALL 0x00101090
LAB_0010358a:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x00106d40
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],0x0
JZ 0x001035a4
JMP 0x001035c3
LAB_001035a4:
LEA RDI,[0x10a497]
LEA RSI,[0x10a131]
MOV EDX,0x212
LEA RCX,[0x10ae33]
CALL 0x00101090
LAB_001035c3:
MOV RAX,qword ptr [RBP + -0x38]
CMP qword ptr [RAX + 0x40],0x3
JNZ 0x001035db
MOV RAX,qword ptr [RBP + -0x38]
CMP qword ptr [RAX + 0x48],0x2
JNZ 0x001035db
JMP 0x001035fa
LAB_001035db:
LEA RDI,[0x10ae54]
LEA RSI,[0x10a131]
MOV EDX,0x213
LEA RCX,[0x10ae33]
CALL 0x00101090
LAB_001035fa:
MOV RAX,qword ptr [RBP + -0x38]
MOVSS XMM0,dword ptr [RAX]
MOVSS XMM1,dword ptr [0x0010a004]
UCOMISS XMM0,XMM1
JNZ 0x0010362b
JP 0x0010362b
MOV RAX,qword ptr [RBP + -0x38]
MOVSS XMM0,dword ptr [RAX + 0x4]
MOVSS XMM1,dword ptr [0x0010a01c]
UCOMISS XMM0,XMM1
JNZ 0x0010362b
JP 0x0010362b
JMP 0x0010364a
LAB_0010362b:
LEA RDI,[0x10ae71]
LEA RSI,[0x10a131]
MOV EDX,0x214
LEA RCX,[0x10ae33]
CALL 0x00101090
LAB_0010364a:
MOV RAX,qword ptr [RBP + -0x38]
MOVSS XMM0,dword ptr [RAX + 0x10]
MOVSS XMM1,dword ptr [0x0010a008]
UCOMISS XMM0,XMM1
JNZ 0x0010367c
JP 0x0010367c
MOV RAX,qword ptr [RBP + -0x38]
MOVSS XMM0,dword ptr [RAX + 0x14]
MOVSS XMM1,dword ptr [0x0010a010]
UCOMISS XMM0,XMM1
JNZ 0x0010367c
JP 0x0010367c
JMP 0x0010369b
LAB_0010367c:
LEA RDI,[0x10aea0]
LEA RSI,[0x10a131]
MOV EDX,0x215
LEA RCX,[0x10ae33]
CALL 0x00101090
LAB_0010369b:
MOV RAX,qword ptr [RBP + -0x38]
MOVSS XMM0,dword ptr [RAX + 0x20]
MOVSS XMM1,dword ptr [0x0010a00c]
UCOMISS XMM0,XMM1
JNZ 0x001036cd
JP 0x001036cd
MOV RAX,qword ptr [RBP + -0x38]
MOVSS XMM0,dword ptr [RAX + 0x24]
MOVSS XMM1,dword ptr [0x0010a020]
UCOMISS XMM0,XMM1
JNZ 0x001036cd
JP 0x001036cd
JMP 0x001036ec
LAB_001036cd:
LEA RDI,[0x10aecf]
LEA RSI,[0x10a131]
MOV EDX,0x216
LEA RCX,[0x10ae33]
CALL 0x00101090
LAB_001036ec:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00104880
LEA RDI,[0x10aefe]
MOV AL,0x0
CALL 0x00101080
ADD RSP,0x40
POP RBP
RET
|
void test_matrix_transpose(void)
{
ulong uVar1;
float *pfVar2;
int8 local_38;
int8 local_30;
int8 local_28;
long local_18;
long local_10;
printf("Testing matrix transpose...\n");
local_10 = arena_create(0x400);
if (local_10 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("arena != NULL","/workspace/llm4binary/github2025/eshkol/tests/unit/test_vector.c"
,0x206,"void test_matrix_transpose(void)");
}
local_18 = matrix_f_create(local_10,2,3);
if (local_18 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("a != NULL","/workspace/llm4binary/github2025/eshkol/tests/unit/test_vector.c",
0x20a,"void test_matrix_transpose(void)");
}
local_38 = DAT_0010b470;
local_30 = DAT_0010b478;
local_28 = DAT_0010b480;
uVar1 = matrix_f_set(local_18,&local_38,2,3);
if ((uVar1 & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("matrix_f_set(a, a_data, 2, 3)",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_vector.c",0x20e,
"void test_matrix_transpose(void)");
}
pfVar2 = (float *)matrix_f_transpose(local_10,local_18);
if (pfVar2 != (float *)0x0) {
if ((*(long *)(pfVar2 + 0x10) != 3) || (*(long *)(pfVar2 + 0x12) != 2)) {
/* WARNING: Subroutine does not return */
__assert_fail("b->rows == 3 && b->cols == 2",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_vector.c",0x213,
"void test_matrix_transpose(void)");
}
if ((((*pfVar2 == DAT_0010a004) && (!NAN(*pfVar2) && !NAN(DAT_0010a004))) &&
(pfVar2[1] == DAT_0010a01c)) && (!NAN(pfVar2[1]) && !NAN(DAT_0010a01c))) {
if (((pfVar2[4] == DAT_0010a008) && (!NAN(pfVar2[4]) && !NAN(DAT_0010a008))) &&
((pfVar2[5] == DAT_0010a010 && (!NAN(pfVar2[5]) && !NAN(DAT_0010a010))))) {
if ((pfVar2[8] == DAT_0010a00c) && (!NAN(pfVar2[8]) && !NAN(DAT_0010a00c))) {
if ((pfVar2[9] == DAT_0010a020) && (!NAN(pfVar2[9]) && !NAN(DAT_0010a020))) {
arena_destroy(local_10);
printf("PASS: matrix_transpose\n");
return;
}
}
/* WARNING: Subroutine does not return */
__assert_fail("b->data[2][0] == 3.0f && b->data[2][1] == 6.0f",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_vector.c",0x216,
"void test_matrix_transpose(void)");
}
/* WARNING: Subroutine does not return */
__assert_fail("b->data[1][0] == 2.0f && b->data[1][1] == 5.0f",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_vector.c",0x215,
"void test_matrix_transpose(void)");
}
/* WARNING: Subroutine does not return */
__assert_fail("b->data[0][0] == 1.0f && b->data[0][1] == 4.0f",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_vector.c",0x214,
"void test_matrix_transpose(void)");
}
/* WARNING: Subroutine does not return */
__assert_fail("b != NULL","/workspace/llm4binary/github2025/eshkol/tests/unit/test_vector.c",0x212
,"void test_matrix_transpose(void)");
}
| |
42,824 | httplib::detail::MultipartFormDataParser::buf_append(char const*, unsigned long) | hkr04[P]cpp-mcp/common/httplib.h | void buf_append(const char *data, size_t n) {
auto remaining_size = buf_size();
if (remaining_size > 0 && buf_spos_ > 0) {
for (size_t i = 0; i < remaining_size; i++) {
buf_[i] = buf_[buf_spos_ + i];
}
}
buf_spos_ = 0;
buf_epos_ = remaining_size;
if (remaining_size + n > buf_.size()) { buf_.resize(remaining_size + n); }
for (size_t i = 0; i < n; i++) {
buf_[buf_epos_ + i] = data[i];
}
buf_epos_ += n;
} | O0 | c | httplib::detail::MultipartFormDataParser::buf_append(char const*, unsigned long):
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x3bd20
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
jbe 0x3bc47
movq 0x20(%rsp), %rax
cmpq $0x0, 0x150(%rax)
jbe 0x3bc47
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x3bc45
movq 0x20(%rsp), %rax
movq %rax, %rdi
addq $0x130, %rdi # imm = 0x130
movq 0x150(%rax), %rsi
addq 0x30(%rsp), %rsi
callq 0xcf80
movq 0x20(%rsp), %rdi
movb (%rax), %al
movb %al, 0x1f(%rsp)
addq $0x130, %rdi # imm = 0x130
movq 0x30(%rsp), %rsi
callq 0xcf80
movb 0x1f(%rsp), %cl
movb %cl, (%rax)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x3bbe7
jmp 0x3bc47
movq 0x20(%rsp), %rdi
movq $0x0, 0x150(%rdi)
movq 0x38(%rsp), %rax
movq %rax, 0x158(%rdi)
movq 0x38(%rsp), %rax
addq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x130, %rdi # imm = 0x130
callq 0xc610
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jbe 0x3bca6
movq 0x20(%rsp), %rdi
addq $0x130, %rdi # imm = 0x130
movq 0x38(%rsp), %rsi
addq 0x40(%rsp), %rsi
callq 0xcba0
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x40(%rsp), %rax
jae 0x3bd02
movq 0x20(%rsp), %rax
movq 0x48(%rsp), %rcx
movq 0x28(%rsp), %rdx
movb (%rcx,%rdx), %cl
movb %cl, 0xf(%rsp)
movq %rax, %rdi
addq $0x130, %rdi # imm = 0x130
movq 0x158(%rax), %rsi
addq 0x28(%rsp), %rsi
callq 0xcf80
movb 0xf(%rsp), %cl
movb %cl, (%rax)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x3bcaf
movq 0x20(%rsp), %rax
movq 0x40(%rsp), %rcx
addq 0x158(%rax), %rcx
movq %rcx, 0x158(%rax)
addq $0x58, %rsp
retq
nop
| _ZN7httplib6detail23MultipartFormDataParser10buf_appendEPKcm:
sub rsp, 58h
mov [rsp+58h+var_8], rdi
mov [rsp+58h+var_10], rsi
mov [rsp+58h+var_18], rdx
mov rdi, [rsp+58h+var_8]; this
mov [rsp+58h+var_38], rdi
call _ZNK7httplib6detail23MultipartFormDataParser8buf_sizeEv; httplib::detail::MultipartFormDataParser::buf_size(void)
mov [rsp+58h+var_20], rax
cmp [rsp+58h+var_20], 0
jbe short loc_3BC47
mov rax, [rsp+58h+var_38]
cmp qword ptr [rax+150h], 0
jbe short loc_3BC47
mov [rsp+58h+var_28], 0
loc_3BBE7:
mov rax, [rsp+58h+var_28]
cmp rax, [rsp+58h+var_20]
jnb short loc_3BC45
mov rax, [rsp+58h+var_38]
mov rdi, rax
add rdi, 130h
mov rsi, [rax+150h]
add rsi, [rsp+58h+var_28]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm; std::string::operator[](ulong)
mov rdi, [rsp+58h+var_38]
mov al, [rax]
mov [rsp+58h+var_39], al
add rdi, 130h
mov rsi, [rsp+58h+var_28]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm; std::string::operator[](ulong)
mov cl, [rsp+58h+var_39]
mov [rax], cl
mov rax, [rsp+58h+var_28]
add rax, 1
mov [rsp+58h+var_28], rax
jmp short loc_3BBE7
loc_3BC45:
jmp short $+2
loc_3BC47:
mov rdi, [rsp+58h+var_38]
mov qword ptr [rdi+150h], 0
mov rax, [rsp+58h+var_20]
mov [rdi+158h], rax
mov rax, [rsp+58h+var_20]
add rax, [rsp+58h+var_18]
mov [rsp+58h+var_48], rax
add rdi, 130h
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4sizeEv; std::string::size(void)
mov rcx, rax
mov rax, [rsp+58h+var_48]
cmp rax, rcx
jbe short loc_3BCA6
mov rdi, [rsp+58h+var_38]
add rdi, 130h
mov rsi, [rsp+58h+var_20]
add rsi, [rsp+58h+var_18]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEm; std::string::resize(ulong)
loc_3BCA6:
mov [rsp+58h+var_30], 0
loc_3BCAF:
mov rax, [rsp+58h+var_30]
cmp rax, [rsp+58h+var_18]
jnb short loc_3BD02
mov rax, [rsp+58h+var_38]
mov rcx, [rsp+58h+var_10]
mov rdx, [rsp+58h+var_30]
mov cl, [rcx+rdx]
mov [rsp+58h+var_49], cl
mov rdi, rax
add rdi, 130h
mov rsi, [rax+158h]
add rsi, [rsp+58h+var_30]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm; std::string::operator[](ulong)
mov cl, [rsp+58h+var_49]
mov [rax], cl
mov rax, [rsp+58h+var_30]
add rax, 1
mov [rsp+58h+var_30], rax
jmp short loc_3BCAF
loc_3BD02:
mov rax, [rsp+58h+var_38]
mov rcx, [rsp+58h+var_18]
add rcx, [rax+158h]
mov [rax+158h], rcx
add rsp, 58h
retn
| httplib::detail::MultipartFormDataParser * httplib::detail::MultipartFormDataParser::buf_append(
httplib::detail::MultipartFormDataParser *this,
const char *a2,
unsigned long long a3)
{
httplib::detail::MultipartFormDataParser *result; // rax
char v4; // [rsp+Fh] [rbp-49h]
char v5; // [rsp+1Fh] [rbp-39h]
unsigned long long j; // [rsp+28h] [rbp-30h]
unsigned long long i; // [rsp+30h] [rbp-28h]
unsigned long long v8; // [rsp+38h] [rbp-20h]
v8 = httplib::detail::MultipartFormDataParser::buf_size(this);
if ( v8 && *((_QWORD *)this + 42) )
{
for ( i = 0LL; i < v8; ++i )
{
v5 = *(_BYTE *)std::string::operator[]((char *)this + 304, i + *((_QWORD *)this + 42));
*(_BYTE *)std::string::operator[]((char *)this + 304, i) = v5;
}
}
*((_QWORD *)this + 42) = 0LL;
*((_QWORD *)this + 43) = v8;
if ( a3 + v8 > std::string::size((char *)this + 304) )
std::string::resize((char *)this + 304, a3 + v8);
for ( j = 0LL; j < a3; ++j )
{
v4 = a2[j];
*(_BYTE *)std::string::operator[]((char *)this + 304, j + *((_QWORD *)this + 43)) = v4;
}
result = this;
*((_QWORD *)this + 43) += a3;
return result;
}
| buf_append:
SUB RSP,0x58
MOV qword ptr [RSP + 0x50],RDI
MOV qword ptr [RSP + 0x48],RSI
MOV qword ptr [RSP + 0x40],RDX
MOV RDI,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x20],RDI
CALL 0x0013bd20
MOV qword ptr [RSP + 0x38],RAX
CMP qword ptr [RSP + 0x38],0x0
JBE 0x0013bc47
MOV RAX,qword ptr [RSP + 0x20]
CMP qword ptr [RAX + 0x150],0x0
JBE 0x0013bc47
MOV qword ptr [RSP + 0x30],0x0
LAB_0013bbe7:
MOV RAX,qword ptr [RSP + 0x30]
CMP RAX,qword ptr [RSP + 0x38]
JNC 0x0013bc45
MOV RAX,qword ptr [RSP + 0x20]
MOV RDI,RAX
ADD RDI,0x130
MOV RSI,qword ptr [RAX + 0x150]
ADD RSI,qword ptr [RSP + 0x30]
CALL 0x0010cf80
MOV RDI,qword ptr [RSP + 0x20]
MOV AL,byte ptr [RAX]
MOV byte ptr [RSP + 0x1f],AL
ADD RDI,0x130
MOV RSI,qword ptr [RSP + 0x30]
CALL 0x0010cf80
MOV CL,byte ptr [RSP + 0x1f]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RSP + 0x30]
ADD RAX,0x1
MOV qword ptr [RSP + 0x30],RAX
JMP 0x0013bbe7
LAB_0013bc45:
JMP 0x0013bc47
LAB_0013bc47:
MOV RDI,qword ptr [RSP + 0x20]
MOV qword ptr [RDI + 0x150],0x0
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RDI + 0x158],RAX
MOV RAX,qword ptr [RSP + 0x38]
ADD RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x10],RAX
ADD RDI,0x130
CALL 0x0010c610
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x10]
CMP RAX,RCX
JBE 0x0013bca6
MOV RDI,qword ptr [RSP + 0x20]
ADD RDI,0x130
MOV RSI,qword ptr [RSP + 0x38]
ADD RSI,qword ptr [RSP + 0x40]
CALL 0x0010cba0
LAB_0013bca6:
MOV qword ptr [RSP + 0x28],0x0
LAB_0013bcaf:
MOV RAX,qword ptr [RSP + 0x28]
CMP RAX,qword ptr [RSP + 0x40]
JNC 0x0013bd02
MOV RAX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x28]
MOV CL,byte ptr [RCX + RDX*0x1]
MOV byte ptr [RSP + 0xf],CL
MOV RDI,RAX
ADD RDI,0x130
MOV RSI,qword ptr [RAX + 0x158]
ADD RSI,qword ptr [RSP + 0x28]
CALL 0x0010cf80
MOV CL,byte ptr [RSP + 0xf]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RSP + 0x28]
ADD RAX,0x1
MOV qword ptr [RSP + 0x28],RAX
JMP 0x0013bcaf
LAB_0013bd02:
MOV RAX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x40]
ADD RCX,qword ptr [RAX + 0x158]
MOV qword ptr [RAX + 0x158],RCX
ADD RSP,0x58
RET
|
/* httplib::detail::MultipartFormDataParser::buf_append(char const*, unsigned long) */
void __thiscall
httplib::detail::MultipartFormDataParser::buf_append
(MultipartFormDataParser *this,char *param_1,ulong param_2)
{
int1 uVar1;
char cVar2;
ulong uVar3;
int1 *puVar4;
ulong uVar5;
char *pcVar6;
ulong local_30;
ulong local_28;
uVar3 = buf_size(this);
if ((uVar3 != 0) && (*(long *)(this + 0x150) != 0)) {
for (local_28 = 0; local_28 < uVar3; local_28 = local_28 + 1) {
puVar4 = (int1 *)std::__cxx11::string::operator[]((ulong)(this + 0x130));
uVar1 = *puVar4;
puVar4 = (int1 *)std::__cxx11::string::operator[]((ulong)(this + 0x130));
*puVar4 = uVar1;
}
}
*(int8 *)(this + 0x150) = 0;
*(ulong *)(this + 0x158) = uVar3;
uVar5 = std::__cxx11::string::size();
if (uVar5 < uVar3 + param_2) {
std::__cxx11::string::resize((ulong)(this + 0x130));
}
for (local_30 = 0; local_30 < param_2; local_30 = local_30 + 1) {
cVar2 = param_1[local_30];
pcVar6 = (char *)std::__cxx11::string::operator[]((ulong)(this + 0x130));
*pcVar6 = cVar2;
}
*(ulong *)(this + 0x158) = param_2 + *(long *)(this + 0x158);
return;
}
| |
42,825 | js_function_proto_fileName | bluesky950520[P]quickjs/quickjs.c | static JSValue js_function_proto_fileName(JSContext *ctx,
JSValue this_val)
{
JSFunctionBytecode *b = JS_GetFunctionBytecode(this_val);
if (b) {
return JS_AtomToString(ctx, b->filename);
}
return JS_UNDEFINED;
} | O2 | c | js_function_proto_fileName:
movq %rdx, %rax
pushq $0x3
popq %rdx
cmpl $-0x1, %eax
jne 0x63a25
movzwl 0x6(%rsi), %ecx
xorl %eax, %eax
cmpq $0x38, %rcx
ja 0x63a24
movabsq $0x110000000012000, %r8 # imm = 0x110000000012000
btq %rcx, %r8
jae 0x63a24
movq 0x30(%rsi), %rax
testq %rax, %rax
je 0x63a25
pushq %rax
movl 0x68(%rax), %esi
callq 0x1e540
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
| js_function_proto_fileName:
mov rax, rdx
push 3
pop rdx
cmp eax, 0FFFFFFFFh
jnz short loc_63A25
movzx ecx, word ptr [rsi+6]
xor eax, eax
cmp rcx, 38h ; '8'
ja short locret_63A24
mov r8, 110000000012000h
bt r8, rcx
jnb short locret_63A24
mov rax, [rsi+30h]
test rax, rax
jz short loc_63A25
push rax
mov esi, [rax+68h]
call JS_AtomToString
add rsp, 8
locret_63A24:
retn
loc_63A25:
xor eax, eax
retn
| long long js_function_proto_fileName(long long a1, long long a2, int a3)
{
unsigned long long v3; // rcx
long long result; // rax
long long v5; // r8
long long v6; // rax
if ( a3 != -1 )
return 0LL;
v3 = *(unsigned __int16 *)(a2 + 6);
result = 0LL;
if ( v3 <= 0x38 )
{
v5 = 0x110000000012000LL;
if ( _bittest64(&v5, v3) )
{
v6 = *(_QWORD *)(a2 + 48);
if ( v6 )
return JS_AtomToString(a1, *(_DWORD *)(v6 + 104));
return 0LL;
}
}
return result;
}
| js_function_proto_fileName:
MOV RAX,RDX
PUSH 0x3
POP RDX
CMP EAX,-0x1
JNZ 0x00163a25
MOVZX ECX,word ptr [RSI + 0x6]
XOR EAX,EAX
CMP RCX,0x38
JA 0x00163a24
MOV R8,0x110000000012000
BT R8,RCX
JNC 0x00163a24
MOV RAX,qword ptr [RSI + 0x30]
TEST RAX,RAX
JZ 0x00163a25
PUSH RAX
MOV ESI,dword ptr [RAX + 0x68]
CALL 0x0011e540
ADD RSP,0x8
LAB_00163a24:
RET
LAB_00163a25:
XOR EAX,EAX
RET
|
int8 js_function_proto_fileName(int8 param_1,long param_2,int param_3)
{
int8 uVar1;
if (param_3 != -1) {
return 0;
}
uVar1 = 0;
if (((ulong)*(ushort *)(param_2 + 6) < 0x39) &&
((0x110000000012000U >> ((ulong)*(ushort *)(param_2 + 6) & 0x3f) & 1) != 0)) {
if (*(long *)(param_2 + 0x30) == 0) {
return 0;
}
uVar1 = JS_AtomToString(param_1,*(int4 *)(*(long *)(param_2 + 0x30) + 0x68),3);
}
return uVar1;
}
| |
42,826 | my_filename | eloqsql/mysys/my_div.c | char * my_filename(File fd)
{
DBUG_ENTER("my_filename");
if ((uint) fd >= (uint) my_file_limit || !my_file_info[fd].name)
DBUG_RETURN((char*) "UNKNOWN");
if (fd >= 0 && my_file_info[fd].type != UNOPEN)
{
DBUG_RETURN(my_file_info[fd].name);
}
else
DBUG_RETURN((char*) "UNOPENED"); /* Debug message */
} | O0 | c | my_filename:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x1cacdf(%rip), %rcx # 0x2b3100
cmpl (%rcx), %eax
jae 0xe8440
leaq 0x1cacdc(%rip), %rax # 0x2b3108
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0xe844f
jmp 0xe8442
leaq 0x63015(%rip), %rax # 0x14b45e
movq %rax, -0x8(%rbp)
jmp 0xe849d
cmpl $0x0, -0xc(%rbp)
jl 0xe8490
leaq 0x1cacac(%rip), %rax # 0x2b3108
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
je 0xe8490
jmp 0xe8472
leaq 0x1cac8f(%rip), %rax # 0x2b3108
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xe849d
jmp 0xe8492
leaq 0x62fcd(%rip), %rax # 0x14b466
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| my_filename:
push rbp
mov rbp, rsp
mov [rbp+var_C], edi
mov eax, [rbp+var_C]
lea rcx, my_file_limit
cmp eax, [rcx]
jnb short loc_E8440
lea rax, my_file_info
mov rax, [rax]
movsxd rcx, [rbp+var_C]
shl rcx, 4
add rax, rcx
cmp qword ptr [rax], 0
jnz short loc_E844F
loc_E8440:
jmp short $+2
loc_E8442:
lea rax, aUnknown_0; "UNKNOWN"
mov [rbp+var_8], rax
jmp short loc_E849D
loc_E844F:
cmp [rbp+var_C], 0
jl short loc_E8490
lea rax, my_file_info
mov rax, [rax]
movsxd rcx, [rbp+var_C]
shl rcx, 4
add rax, rcx
cmp dword ptr [rax+8], 0
jz short loc_E8490
jmp short $+2
loc_E8472:
lea rax, my_file_info
mov rax, [rax]
movsxd rcx, [rbp+var_C]
shl rcx, 4
add rax, rcx
mov rax, [rax]
mov [rbp+var_8], rax
jmp short loc_E849D
loc_E8490:
jmp short $+2
loc_E8492:
lea rax, aUnopened; "UNOPENED"
mov [rbp+var_8], rax
loc_E849D:
mov rax, [rbp+var_8]
pop rbp
retn
| const char * my_filename(int a1)
{
if ( (unsigned int)a1 >= my_file_limit || !*((_QWORD *)my_file_info + 2 * a1) )
return "UNKNOWN";
if ( a1 >= 0 && *((_DWORD *)my_file_info + 4 * a1 + 2) )
return (const char *)*((_QWORD *)my_file_info + 2 * a1);
return "UNOPENED";
}
| my_filename:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0xc],EDI
MOV EAX,dword ptr [RBP + -0xc]
LEA RCX,[0x3b3100]
CMP EAX,dword ptr [RCX]
JNC 0x001e8440
LEA RAX,[0x3b3108]
MOV RAX,qword ptr [RAX]
MOVSXD RCX,dword ptr [RBP + -0xc]
SHL RCX,0x4
ADD RAX,RCX
CMP qword ptr [RAX],0x0
JNZ 0x001e844f
LAB_001e8440:
JMP 0x001e8442
LAB_001e8442:
LEA RAX,[0x24b45e]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001e849d
LAB_001e844f:
CMP dword ptr [RBP + -0xc],0x0
JL 0x001e8490
LEA RAX,[0x3b3108]
MOV RAX,qword ptr [RAX]
MOVSXD RCX,dword ptr [RBP + -0xc]
SHL RCX,0x4
ADD RAX,RCX
CMP dword ptr [RAX + 0x8],0x0
JZ 0x001e8490
JMP 0x001e8472
LAB_001e8472:
LEA RAX,[0x3b3108]
MOV RAX,qword ptr [RAX]
MOVSXD RCX,dword ptr [RBP + -0xc]
SHL RCX,0x4
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001e849d
LAB_001e8490:
JMP 0x001e8492
LAB_001e8492:
LEA RAX,[0x24b466]
MOV qword ptr [RBP + -0x8],RAX
LAB_001e849d:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
char * my_filename(uint param_1)
{
char *local_10;
if ((param_1 < my_file_limit) && (*(long *)(my_file_info + (long)(int)param_1 * 0x10) != 0)) {
if (((int)param_1 < 0) || (*(int *)(my_file_info + (long)(int)param_1 * 0x10 + 8) == 0)) {
local_10 = "UNOPENED";
}
else {
local_10 = *(char **)(my_file_info + (long)(int)param_1 * 0x10);
}
}
else {
local_10 = "UNKNOWN";
}
return local_10;
}
| |
42,827 | my_hash_update | eloqsql/mysys/hash.c | my_bool my_hash_update(HASH *hash, uchar *record, uchar *old_key,
size_t old_key_length)
{
uint new_index, new_pos_index, org_index, records, idx;
size_t length, empty, blength;
my_hash_value_type hash_nr;
HASH_LINK org_link,*data,*previous,*pos;
uchar *new_key;
DBUG_ENTER("my_hash_update");
new_key= (uchar*) my_hash_key(hash, record, &length, 1);
hash_nr= hash->hash_function(hash->charset, new_key, length);
if (HASH_UNIQUE & hash->flags)
{
HASH_SEARCH_STATE state;
uchar *found;
if ((found= my_hash_first_from_hash_value(hash, hash_nr, new_key, length,
&state)))
{
do
{
if (found != record)
DBUG_RETURN(1); /* Duplicate entry */
}
while ((found= my_hash_next(hash, new_key, length, &state)));
}
}
data=dynamic_element(&hash->array,0,HASH_LINK*);
blength=hash->blength; records=hash->records;
/* Search after record with key */
idx= my_hash_mask(hash->hash_function(hash->charset, old_key,
(old_key_length ? old_key_length :
hash->key_length)),
blength, records);
org_index= idx;
new_index= my_hash_mask(hash_nr, blength, records);
previous=0;
for (;;)
{
if ((pos= data+idx)->data == record)
break;
previous=pos;
if ((idx=pos->next) == NO_RECORD)
DBUG_RETURN(1); /* Not found in links */
}
if (org_index == new_index)
{
data[idx].hash_nr= hash_nr; /* Hash number may have changed */
DBUG_RETURN(0); /* Record is in right position */
}
org_link= *pos;
empty=idx;
/* Relink record from current chain */
if (!previous)
{
if (pos->next != NO_RECORD)
{
empty=pos->next;
*pos= data[pos->next];
}
}
else
previous->next=pos->next; /* unlink pos */
/* Move data to correct position */
if (new_index == empty)
{
/*
At this point record is unlinked from the old chain, thus it holds
random position. By the chance this position is equal to position
for the first element in the new chain. That means updated record
is the only record in the new chain.
*/
if (empty != idx)
{
/*
Record was moved while unlinking it from the old chain.
Copy data to a new position.
*/
data[empty]= org_link;
}
data[empty].next= NO_RECORD;
data[empty].hash_nr= hash_nr;
DBUG_RETURN(0);
}
pos=data+new_index;
new_pos_index= my_hash_rec_mask(pos, blength, records);
if (new_index != new_pos_index)
{ /* Other record in wrong position */
data[empty]= *pos;
movelink(data,new_index,new_pos_index, (uint) empty);
org_link.next=NO_RECORD;
data[new_index]= org_link;
data[new_index].hash_nr= hash_nr;
}
else
{ /* Link in chain at right position */
org_link.next=data[new_index].next;
data[empty]=org_link;
data[empty].hash_nr= hash_nr;
data[new_index].next= (uint) empty;
}
DBUG_RETURN(0);
} | O3 | c | my_hash_update:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, -0x60(%rbp)
movq %rsi, %r14
movq %rdi, %r13
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq 0x50(%rdi), %rax
testq %rax, %rax
movq %rdx, -0x58(%rbp)
je 0x4a82b
leaq -0x48(%rbp), %r12
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq *%rax
movq %rax, %rbx
movq (%r12), %rdx
jmp 0x4a83a
movq 0x8(%r13), %rdx
movq %rdx, -0x48(%rbp)
movq (%r13), %rbx
addq %r14, %rbx
movq 0x68(%r13), %rdi
movq %rbx, %rsi
callq *0x58(%r13)
testb $0x1, 0x20(%r13)
je 0x4a890
movq -0x48(%rbp), %rcx
leaq -0x40(%rbp), %r8
movq %r13, %rdi
movl %eax, %r15d
movl %eax, %esi
movq %rbx, %rdx
callq 0x4a08f
testq %rax, %rax
je 0x4a88d
leaq -0x40(%rbp), %r12
cmpq %r14, %rax
jne 0x4a938
movq -0x48(%rbp), %rdx
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rcx
callq 0x4a1e8
testq %rax, %rax
jne 0x4a86d
movl %r15d, %eax
movl %eax, -0x4c(%rbp)
movq 0x28(%r13), %rbx
movq 0x10(%r13), %r12
movl 0x18(%r13), %r15d
movq 0x58(%r13), %rax
movq 0x68(%r13), %rdi
movq -0x60(%rbp), %rdx
testq %rdx, %rdx
jne 0x4a8b4
movq 0x8(%r13), %rdx
movq -0x58(%rbp), %rsi
callq *%rax
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
leaq (%r12,%rdi), %rsi
movl %esi, %ecx
andl %eax, %ecx
shrq %r12
decl %r12d
andl %r12d, %eax
cmpl %r15d, %ecx
cmovbl %ecx, %eax
movl %esi, %ecx
movl -0x4c(%rbp), %r11d
andl %r11d, %ecx
movl %r11d, %edx
andl %r12d, %edx
cmpl %r15d, %ecx
cmovbl %ecx, %edx
movq %rax, %rcx
shlq $0x4, %rcx
leaq (%rbx,%rcx), %r8
cmpq %r14, 0x8(%rbx,%rcx)
je 0x4a93c
movl (%r8), %ecx
cmpq %rdi, %rcx
je 0x4a938
movq %r8, %r9
movq %rcx, %r10
shlq $0x4, %r10
leaq (%rbx,%r10), %r8
cmpq %r14, 0x8(%rbx,%r10)
jne 0x4a8fd
cmpl %edx, %eax
je 0x4a943
movl (%r8), %eax
movl 0xc(%r8), %edi
movl %edi, -0x38(%rbp)
movq 0x4(%r8), %rdi
movq %rdi, -0x40(%rbp)
movl %eax, (%r9)
movq %rcx, %rax
jmp 0x4a975
movb $0x1, %al
jmp 0x4a9a6
cmpl %edx, %eax
jne 0x4a949
movq %rax, %rcx
shlq $0x4, %rcx
jmp 0x4a99f
movl (%r8), %ecx
movl 0xc(%r8), %r9d
movl %r9d, -0x38(%rbp)
movq 0x4(%r8), %r9
movq %r9, -0x40(%rbp)
cmpq %rdi, %rcx
je 0x4a972
movq %rcx, %rdi
shlq $0x4, %rdi
movups (%rbx,%rdi), %xmm0
movups %xmm0, (%r8)
jmp 0x4a975
movq %rax, %rcx
cmpl %edx, %ecx
jne 0x4a9c8
cmpl %eax, %ecx
je 0x4a994
movq %rcx, %rax
shlq $0x4, %rax
movl -0x38(%rbp), %edx
movl %edx, 0xc(%rbx,%rax)
movq -0x40(%rbp), %rdx
movq %rdx, 0x4(%rbx,%rax)
shlq $0x4, %rcx
movl $0xffffffff, (%rbx,%rcx) # imm = 0xFFFFFFFF
movl %r11d, 0x4(%rbx,%rcx)
xorl %eax, %eax
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x4aa55
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %edx, %edi
shlq $0x4, %rdi
leaq (%rbx,%rdi), %rax
movl 0x4(%rbx,%rdi), %r8d
andl %r8d, %esi
andl %r8d, %r12d
cmpl %r15d, %esi
cmovbl %esi, %r12d
cmpl %r12d, %edx
jne 0x4aa0e
movl (%rax), %edx
movq %rcx, %rsi
shlq $0x4, %rsi
movl %edx, (%rbx,%rsi)
movq -0x40(%rbp), %rdx
movq %rdx, 0x4(%rbx,%rsi)
movl -0x38(%rbp), %edx
movl %edx, 0xc(%rbx,%rsi)
movl %r11d, 0x4(%rbx,%rsi)
movl %ecx, (%rax)
jmp 0x4a9a4
leaq (%rbx,%rdi), %rsi
addq $0x4, %rsi
movq %rcx, %rdi
shlq $0x4, %rdi
movups (%rax), %xmm0
movups %xmm0, (%rbx,%rdi)
movl %r12d, %edi
shlq $0x4, %rdi
movl (%rbx,%rdi), %r12d
cmpl %edx, %r12d
jne 0x4aa24
addq %rdi, %rbx
movl %ecx, (%rbx)
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
movl -0x38(%rbp), %ecx
movl %ecx, 0x8(%rsi)
movq -0x40(%rbp), %rcx
movq %rcx, (%rsi)
movl %r11d, 0x4(%rax)
jmp 0x4a9a4
callq 0x263a0
| my_hash_update:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov [rbp+var_60], rcx
mov r14, rsi
mov r13, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov rax, [rdi+50h]
test rax, rax
mov [rbp+var_58], rdx
jz short loc_4A82B
lea r12, [rbp+var_48]
mov rdi, r14
mov rsi, r12
mov edx, 1
call rax
mov rbx, rax
mov rdx, [r12]
jmp short loc_4A83A
loc_4A82B:
mov rdx, [r13+8]
mov [rbp+var_48], rdx
mov rbx, [r13+0]
add rbx, r14
loc_4A83A:
mov rdi, [r13+68h]
mov rsi, rbx
call qword ptr [r13+58h]
test byte ptr [r13+20h], 1
jz short loc_4A890
mov rcx, [rbp+var_48]
lea r8, [rbp+var_40]
mov rdi, r13
mov r15d, eax
mov esi, eax
mov rdx, rbx
call my_hash_first_from_hash_value
test rax, rax
jz short loc_4A88D
lea r12, [rbp+var_40]
loc_4A86D:
cmp rax, r14
jnz loc_4A938
mov rdx, [rbp+var_48]
mov rdi, r13
mov rsi, rbx
mov rcx, r12
call my_hash_next
test rax, rax
jnz short loc_4A86D
loc_4A88D:
mov eax, r15d
loc_4A890:
mov [rbp+var_4C], eax
mov rbx, [r13+28h]
mov r12, [r13+10h]
mov r15d, [r13+18h]
mov rax, [r13+58h]
mov rdi, [r13+68h]
mov rdx, [rbp+var_60]
test rdx, rdx
jnz short loc_4A8B4
mov rdx, [r13+8]
loc_4A8B4:
mov rsi, [rbp+var_58]
call rax
mov edi, 0FFFFFFFFh
lea rsi, [r12+rdi]
mov ecx, esi
and ecx, eax
shr r12, 1
dec r12d
and eax, r12d
cmp ecx, r15d
cmovb eax, ecx
mov ecx, esi
mov r11d, [rbp+var_4C]
and ecx, r11d
mov edx, r11d
and edx, r12d
cmp ecx, r15d
cmovb edx, ecx
mov rcx, rax
shl rcx, 4
lea r8, [rbx+rcx]
cmp [rbx+rcx+8], r14
jz short loc_4A93C
loc_4A8FD:
mov ecx, [r8]
cmp rcx, rdi
jz short loc_4A938
mov r9, r8
mov r10, rcx
shl r10, 4
lea r8, [rbx+r10]
cmp [rbx+r10+8], r14
jnz short loc_4A8FD
cmp eax, edx
jz short loc_4A943
mov eax, [r8]
mov edi, [r8+0Ch]
mov [rbp+var_38], edi
mov rdi, [r8+4]
mov [rbp+var_40], rdi
mov [r9], eax
mov rax, rcx
jmp short loc_4A975
loc_4A938:
mov al, 1
jmp short loc_4A9A6
loc_4A93C:
cmp eax, edx
jnz short loc_4A949
mov rcx, rax
loc_4A943:
shl rcx, 4
jmp short loc_4A99F
loc_4A949:
mov ecx, [r8]
mov r9d, [r8+0Ch]
mov [rbp+var_38], r9d
mov r9, [r8+4]
mov [rbp+var_40], r9
cmp rcx, rdi
jz short loc_4A972
mov rdi, rcx
shl rdi, 4
movups xmm0, xmmword ptr [rbx+rdi]
movups xmmword ptr [r8], xmm0
jmp short loc_4A975
loc_4A972:
mov rcx, rax
loc_4A975:
cmp ecx, edx
jnz short loc_4A9C8
cmp ecx, eax
jz short loc_4A994
mov rax, rcx
shl rax, 4
mov edx, [rbp+var_38]
mov [rbx+rax+0Ch], edx
mov rdx, [rbp+var_40]
mov [rbx+rax+4], rdx
loc_4A994:
shl rcx, 4
mov dword ptr [rbx+rcx], 0FFFFFFFFh
loc_4A99F:
mov [rbx+rcx+4], r11d
loc_4A9A4:
xor eax, eax
loc_4A9A6:
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz loc_4AA55
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4A9C8:
mov edi, edx
shl rdi, 4
lea rax, [rbx+rdi]
mov r8d, [rbx+rdi+4]
and esi, r8d
and r12d, r8d
cmp esi, r15d
cmovb r12d, esi
cmp edx, r12d
jnz short loc_4AA0E
mov edx, [rax]
mov rsi, rcx
shl rsi, 4
mov [rbx+rsi], edx
mov rdx, [rbp+var_40]
mov [rbx+rsi+4], rdx
mov edx, [rbp+var_38]
mov [rbx+rsi+0Ch], edx
mov [rbx+rsi+4], r11d
mov [rax], ecx
jmp short loc_4A9A4
loc_4AA0E:
lea rsi, [rbx+rdi]
add rsi, 4
mov rdi, rcx
shl rdi, 4
movups xmm0, xmmword ptr [rax]
movups xmmword ptr [rbx+rdi], xmm0
loc_4AA24:
mov edi, r12d
shl rdi, 4
mov r12d, [rbx+rdi]
cmp r12d, edx
jnz short loc_4AA24
add rbx, rdi
mov [rbx], ecx
mov dword ptr [rax], 0FFFFFFFFh
mov ecx, [rbp+var_38]
mov [rsi+8], ecx
mov rcx, [rbp+var_40]
mov [rsi], rcx
mov [rax+4], r11d
jmp loc_4A9A4
loc_4AA55:
call ___stack_chk_fail
| char my_hash_update(long long a1, long long a2, long long a3)
{
long long ( *v4)(long long, long long *, long long); // rax
long long v5; // rbx
long long v6; // rdx
int v7; // eax
int v8; // r15d
long long v9; // rax
long long v10; // rbx
unsigned long long v11; // r12
unsigned int v12; // r15d
unsigned int v13; // eax
unsigned int v14; // esi
unsigned int v15; // ecx
int v16; // r12d
long long v17; // rax
unsigned int v18; // edx
unsigned int *v19; // r8
long long v20; // rcx
_DWORD *v21; // r9
int v22; // eax
long long v24; // rcx
long long v25; // rax
long long v26; // rdi
_DWORD *v27; // rax
int v28; // r8d
unsigned int v29; // esi
unsigned int v30; // r12d
long long v31; // rsi
long long v32; // rsi
long long v33; // rdi
int v35; // [rsp+14h] [rbp-4Ch]
long long v36; // [rsp+18h] [rbp-48h] BYREF
long long v37; // [rsp+20h] [rbp-40h] BYREF
unsigned int v38; // [rsp+28h] [rbp-38h]
unsigned long long v39; // [rsp+30h] [rbp-30h]
v39 = __readfsqword(0x28u);
v4 = *(long long ( **)(long long, long long *, long long))(a1 + 80);
if ( v4 )
{
v5 = v4(a2, &v36, 1LL);
v6 = v36;
}
else
{
v6 = *(_QWORD *)(a1 + 8);
v36 = v6;
v5 = a2 + *(_QWORD *)a1;
}
v7 = (*(long long ( **)(_QWORD, long long, long long))(a1 + 88))(*(_QWORD *)(a1 + 104), v5, v6);
if ( (*(_BYTE *)(a1 + 32) & 1) != 0 )
{
v8 = v7;
v9 = my_hash_first_from_hash_value((_QWORD *)a1, v7, v5, v36, (unsigned int *)&v37);
if ( v9 )
{
while ( v9 == a2 )
{
v9 = my_hash_next((_QWORD *)a1, v5, v36, &v37);
if ( !v9 )
goto LABEL_8;
}
return 1;
}
LABEL_8:
v7 = v8;
}
v35 = v7;
v10 = *(_QWORD *)(a1 + 40);
v11 = *(_QWORD *)(a1 + 16);
v12 = *(_DWORD *)(a1 + 24);
v13 = (*(long long ( **)(_QWORD, long long))(a1 + 88))(*(_QWORD *)(a1 + 104), a3);
v14 = v11 - 1;
v15 = v13 & (v11 - 1);
v16 = (v11 >> 1) - 1;
v17 = v16 & v13;
if ( v15 < v12 )
v17 = v15;
v18 = v16 & v35;
if ( (v35 & v14) < v12 )
v18 = v35 & v14;
v19 = (unsigned int *)(v10 + 16 * v17);
if ( *((_QWORD *)v19 + 1) != a2 )
{
while ( 1 )
{
v20 = *v19;
if ( v20 == 0xFFFFFFFFLL )
return 1;
v21 = v19;
v19 = (unsigned int *)(v10 + 16 * v20);
if ( *((_QWORD *)v19 + 1) == a2 )
{
if ( (_DWORD)v17 == v18 )
goto LABEL_21;
v22 = *v19;
v38 = v19[3];
v37 = *(_QWORD *)(v19 + 1);
*v21 = v22;
LODWORD(v17) = v20;
goto LABEL_25;
}
}
}
if ( (_DWORD)v17 == v18 )
{
v20 = v17;
LABEL_21:
v24 = 16 * v20;
}
else
{
v20 = *v19;
v38 = v19[3];
v37 = *(_QWORD *)(v19 + 1);
if ( v20 == 0xFFFFFFFFLL )
v20 = v17;
else
*(_OWORD *)v19 = *(_OWORD *)(v10 + 16 * v20);
LABEL_25:
if ( (_DWORD)v20 != v18 )
{
v26 = 16LL * v18;
v27 = (_DWORD *)(v10 + v26);
v28 = *(_DWORD *)(v10 + v26 + 4);
v29 = v28 & v14;
v30 = v28 & v16;
if ( v29 < v12 )
v30 = v29;
if ( v18 == v30 )
{
v31 = 16 * v20;
*(_DWORD *)(v10 + v31) = *v27;
*(_QWORD *)(v10 + v31 + 4) = v37;
*(_DWORD *)(v10 + v31 + 12) = v38;
*(_DWORD *)(v10 + v31 + 4) = v35;
*v27 = v20;
}
else
{
v32 = v10 + v26 + 4;
*(_OWORD *)(v10 + 16 * v20) = *(_OWORD *)v27;
do
{
v33 = 16LL * v30;
v30 = *(_DWORD *)(v10 + v33);
}
while ( v30 != v18 );
*(_DWORD *)(v33 + v10) = v20;
*v27 = -1;
*(_DWORD *)(v32 + 8) = v38;
*(_QWORD *)v32 = v37;
v27[1] = v35;
}
return 0;
}
if ( (_DWORD)v20 != (_DWORD)v17 )
{
v25 = 16 * v20;
*(_DWORD *)(v10 + v25 + 12) = v38;
*(_QWORD *)(v10 + v25 + 4) = v37;
}
v24 = 16 * v20;
*(_DWORD *)(v10 + v24) = -1;
}
*(_DWORD *)(v10 + v24 + 4) = v35;
return 0;
}
| my_hash_update:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x60],RCX
MOV R14,RSI
MOV R13,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RDI + 0x50]
TEST RAX,RAX
MOV qword ptr [RBP + -0x58],RDX
JZ 0x0014a82b
LEA R12,[RBP + -0x48]
MOV RDI,R14
MOV RSI,R12
MOV EDX,0x1
CALL RAX
MOV RBX,RAX
MOV RDX,qword ptr [R12]
JMP 0x0014a83a
LAB_0014a82b:
MOV RDX,qword ptr [R13 + 0x8]
MOV qword ptr [RBP + -0x48],RDX
MOV RBX,qword ptr [R13]
ADD RBX,R14
LAB_0014a83a:
MOV RDI,qword ptr [R13 + 0x68]
MOV RSI,RBX
CALL qword ptr [R13 + 0x58]
TEST byte ptr [R13 + 0x20],0x1
JZ 0x0014a890
MOV RCX,qword ptr [RBP + -0x48]
LEA R8,[RBP + -0x40]
MOV RDI,R13
MOV R15D,EAX
MOV ESI,EAX
MOV RDX,RBX
CALL 0x0014a08f
TEST RAX,RAX
JZ 0x0014a88d
LEA R12,[RBP + -0x40]
LAB_0014a86d:
CMP RAX,R14
JNZ 0x0014a938
MOV RDX,qword ptr [RBP + -0x48]
MOV RDI,R13
MOV RSI,RBX
MOV RCX,R12
CALL 0x0014a1e8
TEST RAX,RAX
JNZ 0x0014a86d
LAB_0014a88d:
MOV EAX,R15D
LAB_0014a890:
MOV dword ptr [RBP + -0x4c],EAX
MOV RBX,qword ptr [R13 + 0x28]
MOV R12,qword ptr [R13 + 0x10]
MOV R15D,dword ptr [R13 + 0x18]
MOV RAX,qword ptr [R13 + 0x58]
MOV RDI,qword ptr [R13 + 0x68]
MOV RDX,qword ptr [RBP + -0x60]
TEST RDX,RDX
JNZ 0x0014a8b4
MOV RDX,qword ptr [R13 + 0x8]
LAB_0014a8b4:
MOV RSI,qword ptr [RBP + -0x58]
CALL RAX
MOV EDI,0xffffffff
LEA RSI,[R12 + RDI*0x1]
MOV ECX,ESI
AND ECX,EAX
SHR R12,0x1
DEC R12D
AND EAX,R12D
CMP ECX,R15D
CMOVC EAX,ECX
MOV ECX,ESI
MOV R11D,dword ptr [RBP + -0x4c]
AND ECX,R11D
MOV EDX,R11D
AND EDX,R12D
CMP ECX,R15D
CMOVC EDX,ECX
MOV RCX,RAX
SHL RCX,0x4
LEA R8,[RBX + RCX*0x1]
CMP qword ptr [RBX + RCX*0x1 + 0x8],R14
JZ 0x0014a93c
LAB_0014a8fd:
MOV ECX,dword ptr [R8]
CMP RCX,RDI
JZ 0x0014a938
MOV R9,R8
MOV R10,RCX
SHL R10,0x4
LEA R8,[RBX + R10*0x1]
CMP qword ptr [RBX + R10*0x1 + 0x8],R14
JNZ 0x0014a8fd
CMP EAX,EDX
JZ 0x0014a943
MOV EAX,dword ptr [R8]
MOV EDI,dword ptr [R8 + 0xc]
MOV dword ptr [RBP + -0x38],EDI
MOV RDI,qword ptr [R8 + 0x4]
MOV qword ptr [RBP + -0x40],RDI
MOV dword ptr [R9],EAX
MOV RAX,RCX
JMP 0x0014a975
LAB_0014a938:
MOV AL,0x1
JMP 0x0014a9a6
LAB_0014a93c:
CMP EAX,EDX
JNZ 0x0014a949
MOV RCX,RAX
LAB_0014a943:
SHL RCX,0x4
JMP 0x0014a99f
LAB_0014a949:
MOV ECX,dword ptr [R8]
MOV R9D,dword ptr [R8 + 0xc]
MOV dword ptr [RBP + -0x38],R9D
MOV R9,qword ptr [R8 + 0x4]
MOV qword ptr [RBP + -0x40],R9
CMP RCX,RDI
JZ 0x0014a972
MOV RDI,RCX
SHL RDI,0x4
MOVUPS XMM0,xmmword ptr [RBX + RDI*0x1]
MOVUPS xmmword ptr [R8],XMM0
JMP 0x0014a975
LAB_0014a972:
MOV RCX,RAX
LAB_0014a975:
CMP ECX,EDX
JNZ 0x0014a9c8
CMP ECX,EAX
JZ 0x0014a994
MOV RAX,RCX
SHL RAX,0x4
MOV EDX,dword ptr [RBP + -0x38]
MOV dword ptr [RBX + RAX*0x1 + 0xc],EDX
MOV RDX,qword ptr [RBP + -0x40]
MOV qword ptr [RBX + RAX*0x1 + 0x4],RDX
LAB_0014a994:
SHL RCX,0x4
MOV dword ptr [RBX + RCX*0x1],0xffffffff
LAB_0014a99f:
MOV dword ptr [RBX + RCX*0x1 + 0x4],R11D
LAB_0014a9a4:
XOR EAX,EAX
LAB_0014a9a6:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x0014aa55
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014a9c8:
MOV EDI,EDX
SHL RDI,0x4
LEA RAX,[RBX + RDI*0x1]
MOV R8D,dword ptr [RBX + RDI*0x1 + 0x4]
AND ESI,R8D
AND R12D,R8D
CMP ESI,R15D
CMOVC R12D,ESI
CMP EDX,R12D
JNZ 0x0014aa0e
MOV EDX,dword ptr [RAX]
MOV RSI,RCX
SHL RSI,0x4
MOV dword ptr [RBX + RSI*0x1],EDX
MOV RDX,qword ptr [RBP + -0x40]
MOV qword ptr [RBX + RSI*0x1 + 0x4],RDX
MOV EDX,dword ptr [RBP + -0x38]
MOV dword ptr [RBX + RSI*0x1 + 0xc],EDX
MOV dword ptr [RBX + RSI*0x1 + 0x4],R11D
MOV dword ptr [RAX],ECX
JMP 0x0014a9a4
LAB_0014aa0e:
LEA RSI,[RBX + RDI*0x1]
ADD RSI,0x4
MOV RDI,RCX
SHL RDI,0x4
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [RBX + RDI*0x1],XMM0
LAB_0014aa24:
MOV EDI,R12D
SHL RDI,0x4
MOV R12D,dword ptr [RBX + RDI*0x1]
CMP R12D,EDX
JNZ 0x0014aa24
ADD RBX,RDI
MOV dword ptr [RBX],ECX
MOV dword ptr [RAX],0xffffffff
MOV ECX,dword ptr [RBP + -0x38]
MOV dword ptr [RSI + 0x8],ECX
MOV RCX,qword ptr [RBP + -0x40]
MOV qword ptr [RSI],RCX
MOV dword ptr [RAX + 0x4],R11D
JMP 0x0014a9a4
LAB_0014aa55:
CALL 0x001263a0
|
int8 my_hash_update(long *param_1,long param_2,int8 param_3,long param_4)
{
uint *puVar1;
uint uVar2;
uint uVar3;
uint uVar4;
uint uVar5;
uint uVar6;
uint uVar7;
long lVar8;
long lVar9;
ulong uVar10;
int8 uVar11;
uint uVar12;
ulong uVar13;
uint uVar14;
uint *puVar15;
uint uVar16;
long in_FS_OFFSET;
long local_50;
int8 local_48;
uint local_40;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
if ((code *)param_1[10] == (code *)0x0) {
local_50 = param_1[1];
lVar8 = *param_1 + param_2;
}
else {
lVar8 = (*(code *)param_1[10])(param_2,&local_50,1);
}
uVar5 = (*(code *)param_1[0xb])(param_1[0xd],lVar8,local_50);
if (((*(byte *)(param_1 + 4) & 1) != 0) &&
(lVar9 = my_hash_first_from_hash_value(param_1,uVar5,lVar8,local_50,&local_48), lVar9 != 0)) {
do {
if (lVar9 != param_2) goto LAB_0014a938;
lVar9 = my_hash_next(param_1,lVar8,local_50,&local_48);
} while (lVar9 != 0);
}
lVar8 = param_1[5];
uVar10 = param_1[2];
uVar2 = *(uint *)(param_1 + 3);
if (param_4 == 0) {
param_4 = param_1[1];
}
uVar6 = (*(code *)param_1[0xb])(param_1[0xd],param_3,param_4);
uVar14 = (int)uVar10 - 1;
uVar16 = (int)(uVar10 >> 1) - 1;
uVar7 = uVar6 & uVar16;
if ((uVar14 & uVar6) < uVar2) {
uVar7 = uVar14 & uVar6;
}
uVar10 = (ulong)uVar7;
uVar6 = uVar5 & uVar16;
if ((uVar14 & uVar5) < uVar2) {
uVar6 = uVar14 & uVar5;
}
puVar1 = (uint *)(lVar8 + uVar10 * 0x10);
if (*(long *)(lVar8 + 8 + uVar10 * 0x10) == param_2) {
if (uVar7 != uVar6) {
uVar13 = (ulong)*puVar1;
local_40 = puVar1[3];
local_48 = *(int8 *)(puVar1 + 1);
if (uVar13 != 0xffffffff) {
puVar15 = (uint *)(lVar8 + uVar13 * 0x10);
uVar12 = puVar15[1];
uVar3 = puVar15[2];
uVar4 = puVar15[3];
*puVar1 = *puVar15;
puVar1[1] = uVar12;
puVar1[2] = uVar3;
puVar1[3] = uVar4;
uVar10 = uVar13;
}
goto LAB_0014a975;
}
LAB_0014a943:
lVar9 = uVar10 << 4;
LAB_0014a99f:
*(uint *)(lVar8 + 4 + lVar9) = uVar5;
}
else {
do {
puVar15 = puVar1;
uVar12 = *puVar15;
uVar10 = (ulong)uVar12;
if (uVar10 == 0xffffffff) goto LAB_0014a938;
puVar1 = (uint *)(lVar8 + uVar10 * 0x10);
} while (*(long *)(lVar8 + 8 + uVar10 * 0x10) != param_2);
if (uVar7 == uVar6) goto LAB_0014a943;
local_40 = puVar1[3];
local_48 = *(int8 *)(puVar1 + 1);
*puVar15 = *puVar1;
uVar7 = uVar12;
LAB_0014a975:
uVar12 = (uint)uVar10;
if (uVar12 == uVar6) {
if (uVar12 != uVar7) {
*(uint *)(lVar8 + 0xc + uVar10 * 0x10) = local_40;
*(int8 *)(lVar8 + 4 + uVar10 * 0x10) = local_48;
}
lVar9 = uVar10 * 0x10;
*(int4 *)(lVar8 + lVar9) = 0xffffffff;
goto LAB_0014a99f;
}
lVar9 = (ulong)uVar6 * 0x10;
puVar1 = (uint *)(lVar8 + lVar9);
uVar7 = *(uint *)(lVar8 + 4 + lVar9);
uVar14 = uVar14 & uVar7;
uVar7 = uVar16 & uVar7;
if (uVar14 < uVar2) {
uVar7 = uVar14;
}
if (uVar6 == uVar7) {
lVar9 = uVar10 * 0x10;
*(uint *)(lVar8 + lVar9) = *puVar1;
*(int8 *)(lVar8 + 4 + lVar9) = local_48;
*(uint *)(lVar8 + 0xc + lVar9) = local_40;
*(uint *)(lVar8 + 4 + lVar9) = uVar5;
*puVar1 = uVar12;
}
else {
uVar2 = puVar1[1];
uVar14 = puVar1[2];
uVar16 = puVar1[3];
puVar15 = (uint *)(lVar8 + uVar10 * 0x10);
*puVar15 = *puVar1;
puVar15[1] = uVar2;
puVar15[2] = uVar14;
puVar15[3] = uVar16;
do {
uVar10 = (ulong)uVar7;
uVar7 = *(uint *)(lVar8 + uVar10 * 0x10);
} while (uVar7 != uVar6);
*(uint *)(lVar8 + uVar10 * 0x10) = uVar12;
*puVar1 = 0xffffffff;
*(uint *)(lVar8 + lVar9 + 0xc) = local_40;
*(int8 *)(lVar8 + lVar9 + 4) = local_48;
puVar1[1] = uVar5;
}
}
uVar11 = 0;
LAB_0014a9a6:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar11;
LAB_0014a938:
uVar11 = 1;
goto LAB_0014a9a6;
}
| |
42,828 | extend_area_on_page | eloqsql/storage/maria/ma_blockrec.c | static my_bool extend_area_on_page(MARIA_HA *info,
uchar *buff, uchar *dir,
uint rownr,
uint request_length,
uint *empty_space, uint *ret_offset,
uint *ret_length,
my_bool head_page)
{
uint rec_offset, length, org_rec_length;
uint max_entry= (uint) buff[DIR_COUNT_OFFSET];
MARIA_SHARE *share= info->s;
uint block_size= share->block_size;
DBUG_ENTER("extend_area_on_page");
/*
We can't check for min length here as we may have called
extend_directory() to create a new (empty) entry just before
*/
check_directory(share, buff, block_size, 0, *empty_space);
rec_offset= uint2korr(dir);
if (rec_offset)
{
/* Extending old row; Mark current space as 'free' */
length= org_rec_length= uint2korr(dir + 2);
DBUG_PRINT("info", ("rec_offset: %u length: %u request_length: %u "
"empty_space: %u",
rec_offset, org_rec_length, request_length,
*empty_space));
*empty_space+= org_rec_length;
}
else
{
/* Reusing free directory entry; Free it from the directory list */
if (dir[2] == END_OF_DIR_FREE_LIST)
buff[DIR_FREE_OFFSET]= dir[3];
else
{
uchar *prev_dir= dir_entry_pos(buff, block_size, (uint) dir[2]);
DBUG_ASSERT(uint2korr(prev_dir) == 0 && prev_dir[3] == (uchar) rownr);
prev_dir[3]= dir[3];
}
if (dir[3] != END_OF_DIR_FREE_LIST)
{
uchar *next_dir= dir_entry_pos(buff, block_size, (uint) dir[3]);
DBUG_ASSERT(uint2korr(next_dir) == 0 && next_dir[2] == (uchar) rownr);
next_dir[2]= dir[2];
}
rec_offset= start_of_next_entry(dir);
length= 0;
}
if (length < request_length)
{
uint old_rec_offset;
/*
New data did not fit in old position.
Find first possible position where to put new data.
*/
old_rec_offset= rec_offset;
rec_offset= end_of_previous_entry(share,
dir, buff + block_size -
PAGE_SUFFIX_SIZE);
length+= (uint) (old_rec_offset - rec_offset);
DBUG_ASSERT(old_rec_offset);
/*
'length' is 0 if we are doing an insert into a not allocated block.
This can only happen during "REDO of INSERT" or "UNDO of DELETE."
*/
if (length < request_length)
{
/*
Did not fit in current block + empty space. Extend with
empty space after block.
*/
if (rownr == max_entry - 1)
{
/* Last entry; Everything is free between this and directory */
length= ((block_size - PAGE_SUFFIX_SIZE - DIR_ENTRY_SIZE * max_entry) -
rec_offset);
}
else
length= start_of_next_entry(dir) - rec_offset;
DBUG_ASSERT((int) length >= 0);
if (length < request_length)
{
/* Not enough continuous space, compact page to get more */
int2store(dir, rec_offset);
/* Reset length, as this may be a deleted block */
int2store(dir+2, 0);
_ma_compact_block_page(share,
buff, rownr, 1,
head_page ? info->trn->min_read_from: 0,
head_page ? share->base.min_block_length : 0);
rec_offset= uint2korr(dir);
length= uint2korr(dir+2);
if (length < request_length)
{
DBUG_PRINT("error", ("Not enough space: "
"length: %u request_length: %u",
length, request_length));
_ma_set_fatal_error(info, HA_ERR_WRONG_IN_RECORD);
DBUG_RETURN(1); /* Error in block */
}
*empty_space= length; /* All space is here */
}
}
}
int2store(dir, rec_offset);
int2store(dir + 2, length);
*ret_offset= rec_offset;
*ret_length= length;
check_directory(share,
buff, block_size,
head_page ? share->base.min_block_length : 0,
*empty_space - length);
DBUG_RETURN(0);
} | O0 | c | extend_area_on_page:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movb 0x20(%rbp), %al
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x8(%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl 0x7bc(%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x20(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x59710
movq -0x20(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, -0x3c(%rbp)
movl %eax, -0x38(%rbp)
jmp 0x59700
movl -0x3c(%rbp), %ecx
movq -0x30(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x597a1
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0xff, %eax
jne 0x5972f
movq -0x20(%rbp), %rax
movb 0x3(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x9(%rax)
jmp 0x59757
movq -0x18(%rbp), %rdi
movl -0x4c(%rbp), %esi
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %edx
callq 0x54350
movq %rax, -0x58(%rbp)
jmp 0x59749
movq -0x20(%rbp), %rax
movb 0x3(%rax), %cl
movq -0x58(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x20(%rbp), %rax
movzbl 0x3(%rax), %eax
cmpl $0xff, %eax
je 0x5978e
movq -0x18(%rbp), %rdi
movl -0x4c(%rbp), %esi
movq -0x20(%rbp), %rax
movzbl 0x3(%rax), %edx
callq 0x54350
movq %rax, -0x60(%rbp)
jmp 0x59780
movq -0x20(%rbp), %rax
movb 0x2(%rax), %cl
movq -0x60(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x20(%rbp), %rdi
callq 0x5f590
movl %eax, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x28(%rbp), %eax
jae 0x5994d
movl -0x34(%rbp), %eax
movl %eax, -0x64(%rbp)
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x4c(%rbp), %eax
addq %rax, %rdx
addq $-0x4, %rdx
callq 0x5f520
movl %eax, -0x34(%rbp)
movl -0x64(%rbp), %eax
subl -0x34(%rbp), %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x597df
movl -0x38(%rbp), %eax
cmpl -0x28(%rbp), %eax
jae 0x5994b
movl -0x24(%rbp), %eax
movl -0x40(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x5980e
movl -0x4c(%rbp), %eax
subl $0x4, %eax
movl -0x40(%rbp), %ecx
shll $0x2, %ecx
subl %ecx, %eax
subl -0x34(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x5981d
movq -0x20(%rbp), %rdi
callq 0x5f590
subl -0x34(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x5981f
jmp 0x59821
movl -0x38(%rbp), %eax
cmpl -0x28(%rbp), %eax
jae 0x59949
jmp 0x5982f
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movl -0x34(%rbp), %eax
movw %ax, %cx
movq -0x70(%rbp), %rax
movw %cx, (%rax)
jmp 0x59846
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movw $0x0, (%rax)
movq -0x48(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x8c(%rbp)
movsbl 0x20(%rbp), %eax
cmpl $0x0, %eax
je 0x5989b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x80(%rax), %rax
movq %rax, -0xa8(%rbp)
jmp 0x598a6
xorl %eax, %eax
movq %rax, -0xa8(%rbp)
jmp 0x598a6
movq -0xa8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movsbl 0x20(%rbp), %eax
cmpl $0x0, %eax
je 0x598d1
movq -0x48(%rbp), %rax
movq 0x3b8(%rax), %rax
movq %rax, -0xb8(%rbp)
jmp 0x598dc
xorl %eax, %eax
movq %rax, -0xb8(%rbp)
jmp 0x598dc
movq -0xb0(%rbp), %r8
movl -0x8c(%rbp), %edx
movq -0x98(%rbp), %rsi
movq -0xa0(%rbp), %rdi
movq -0xb8(%rbp), %rax
movl %eax, %r9d
movl $0x1, %ecx
callq 0x53c20
movq -0x20(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x28(%rbp), %eax
jae 0x59940
jmp 0x5992a
jmp 0x5992c
movq -0x10(%rbp), %rdi
movl $0x7f, %esi
callq 0x39b70
movb $0x1, -0x1(%rbp)
jmp 0x5999b
movl -0x38(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
jmp 0x5994b
jmp 0x5994d
jmp 0x5994f
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x34(%rbp), %eax
movw %ax, %cx
movq -0x80(%rbp), %rax
movw %cx, (%rax)
jmp 0x59966
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x88(%rbp)
movl -0x38(%rbp), %eax
movw %ax, %cx
movq -0x88(%rbp), %rax
movw %cx, (%rax)
movl -0x34(%rbp), %ecx
movq 0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x38(%rbp), %ecx
movq 0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0xc0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| extend_area_on_page:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov al, [rbp+arg_10]
mov rax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_28], r8d
mov [rbp+var_30], r9
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+8]
mov [rbp+var_40], eax
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_48], rax
mov rax, [rbp+var_48]
mov eax, [rax+7BCh]
mov [rbp+var_4C], eax
mov rax, [rbp+var_20]
movzx eax, word ptr [rax]
mov [rbp+var_34], eax
cmp [rbp+var_34], 0
jz short loc_59710
mov rax, [rbp+var_20]
movzx eax, word ptr [rax+2]
mov [rbp+var_3C], eax
mov [rbp+var_38], eax
jmp short $+2
loc_59700:
mov ecx, [rbp+var_3C]
mov rax, [rbp+var_30]
add ecx, [rax]
mov [rax], ecx
jmp loc_597A1
loc_59710:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+2]
cmp eax, 0FFh
jnz short loc_5972F
mov rax, [rbp+var_20]
mov cl, [rax+3]
mov rax, [rbp+var_18]
mov [rax+9], cl
jmp short loc_59757
loc_5972F:
mov rdi, [rbp+var_18]
mov esi, [rbp+var_4C]
mov rax, [rbp+var_20]
movzx edx, byte ptr [rax+2]
call dir_entry_pos
mov [rbp+var_58], rax
jmp short $+2
loc_59749:
mov rax, [rbp+var_20]
mov cl, [rax+3]
mov rax, [rbp+var_58]
mov [rax+3], cl
loc_59757:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+3]
cmp eax, 0FFh
jz short loc_5978E
mov rdi, [rbp+var_18]
mov esi, [rbp+var_4C]
mov rax, [rbp+var_20]
movzx edx, byte ptr [rax+3]
call dir_entry_pos
mov [rbp+var_60], rax
jmp short $+2
loc_59780:
mov rax, [rbp+var_20]
mov cl, [rax+2]
mov rax, [rbp+var_60]
mov [rax+2], cl
loc_5978E:
mov rdi, [rbp+var_20]
call start_of_next_entry
mov [rbp+var_34], eax
mov [rbp+var_38], 0
loc_597A1:
mov eax, [rbp+var_38]
cmp eax, [rbp+var_28]
jnb loc_5994D
mov eax, [rbp+var_34]
mov [rbp+var_64], eax
mov rdi, [rbp+var_48]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_18]
mov eax, [rbp+var_4C]
add rdx, rax
add rdx, 0FFFFFFFFFFFFFFFCh
call end_of_previous_entry
mov [rbp+var_34], eax
mov eax, [rbp+var_64]
sub eax, [rbp+var_34]
add eax, [rbp+var_38]
mov [rbp+var_38], eax
jmp short $+2
loc_597DF:
mov eax, [rbp+var_38]
cmp eax, [rbp+var_28]
jnb loc_5994B
mov eax, [rbp+var_24]
mov ecx, [rbp+var_40]
sub ecx, 1
cmp eax, ecx
jnz short loc_5980E
mov eax, [rbp+var_4C]
sub eax, 4
mov ecx, [rbp+var_40]
shl ecx, 2
sub eax, ecx
sub eax, [rbp+var_34]
mov [rbp+var_38], eax
jmp short loc_5981D
loc_5980E:
mov rdi, [rbp+var_20]
call start_of_next_entry
sub eax, [rbp+var_34]
mov [rbp+var_38], eax
loc_5981D:
jmp short $+2
loc_5981F:
jmp short $+2
loc_59821:
mov eax, [rbp+var_38]
cmp eax, [rbp+var_28]
jnb loc_59949
jmp short $+2
loc_5982F:
mov rax, [rbp+var_20]
mov [rbp+var_70], rax
mov eax, [rbp+var_34]
mov cx, ax
mov rax, [rbp+var_70]
mov [rax], cx
jmp short $+2
loc_59846:
mov rax, [rbp+var_20]
add rax, 2
mov [rbp+var_78], rax
mov rax, [rbp+var_78]
mov word ptr [rax], 0
mov rax, [rbp+var_48]
mov [rbp+var_A0], rax
mov rax, [rbp+var_18]
mov [rbp+var_98], rax
mov eax, [rbp+var_24]
mov [rbp+var_8C], eax
movsx eax, [rbp+arg_10]
cmp eax, 0
jz short loc_5989B
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov rax, [rax+80h]
mov [rbp+var_A8], rax
jmp short loc_598A6
loc_5989B:
xor eax, eax
mov [rbp+var_A8], rax
jmp short $+2
loc_598A6:
mov rax, [rbp+var_A8]
mov [rbp+var_B0], rax
movsx eax, [rbp+arg_10]
cmp eax, 0
jz short loc_598D1
mov rax, [rbp+var_48]
mov rax, [rax+3B8h]
mov [rbp+var_B8], rax
jmp short loc_598DC
loc_598D1:
xor eax, eax
mov [rbp+var_B8], rax
jmp short $+2
loc_598DC:
mov r8, [rbp+var_B0]
mov edx, [rbp+var_8C]
mov rsi, [rbp+var_98]
mov rdi, [rbp+var_A0]
mov rax, [rbp+var_B8]
mov r9d, eax
mov ecx, 1
call _ma_compact_block_page
mov rax, [rbp+var_20]
movzx eax, word ptr [rax]
mov [rbp+var_34], eax
mov rax, [rbp+var_20]
movzx eax, word ptr [rax+2]
mov [rbp+var_38], eax
mov eax, [rbp+var_38]
cmp eax, [rbp+var_28]
jnb short loc_59940
jmp short $+2
loc_5992A:
jmp short $+2
loc_5992C:
mov rdi, [rbp+var_10]
mov esi, 7Fh
call _ma_set_fatal_error
mov [rbp+var_1], 1
jmp short loc_5999B
loc_59940:
mov ecx, [rbp+var_38]
mov rax, [rbp+var_30]
mov [rax], ecx
loc_59949:
jmp short $+2
loc_5994B:
jmp short $+2
loc_5994D:
jmp short $+2
loc_5994F:
mov rax, [rbp+var_20]
mov [rbp+var_80], rax
mov eax, [rbp+var_34]
mov cx, ax
mov rax, [rbp+var_80]
mov [rax], cx
jmp short $+2
loc_59966:
mov rax, [rbp+var_20]
add rax, 2
mov [rbp+var_88], rax
mov eax, [rbp+var_38]
mov cx, ax
mov rax, [rbp+var_88]
mov [rax], cx
mov ecx, [rbp+var_34]
mov rax, [rbp+arg_0]
mov [rax], ecx
mov ecx, [rbp+var_38]
mov rax, [rbp+arg_8]
mov [rax], ecx
mov [rbp+var_1], 0
loc_5999B:
mov al, [rbp+var_1]
add rsp, 0C0h
pop rbp
retn
| char extend_area_on_page(
long long *a1,
long long a2,
unsigned __int16 *a3,
unsigned int a4,
unsigned int a5,
unsigned int *a6,
_DWORD *a7,
unsigned int *a8,
char a9)
{
long long v9; // rdx
long long v10; // rcx
long long v11; // r8
int v12; // r9d
unsigned long long v14; // [rsp+18h] [rbp-A8h]
int v15; // [rsp+5Ch] [rbp-64h]
unsigned int v16; // [rsp+74h] [rbp-4Ch]
long long v17; // [rsp+78h] [rbp-48h]
int v18; // [rsp+80h] [rbp-40h]
unsigned int v19; // [rsp+88h] [rbp-38h]
int entry; // [rsp+8Ch] [rbp-34h]
v18 = *(unsigned __int8 *)(a2 + 8);
v17 = *a1;
v16 = *(_DWORD *)(*a1 + 1980);
entry = *a3;
if ( *a3 )
{
v19 = a3[1];
*a6 += v19;
}
else
{
if ( *((unsigned __int8 *)a3 + 2) == 255 )
*(_BYTE *)(a2 + 9) = *((_BYTE *)a3 + 3);
else
*(_BYTE *)(dir_entry_pos(a2, v16, *((unsigned __int8 *)a3 + 2)) + 3) = *((_BYTE *)a3 + 3);
if ( *((unsigned __int8 *)a3 + 3) != 255 )
*(_BYTE *)(dir_entry_pos(a2, v16, *((unsigned __int8 *)a3 + 3)) + 2) = *((_BYTE *)a3 + 2);
entry = start_of_next_entry(a3);
v19 = 0;
}
if ( v19 >= a5 )
goto LABEL_24;
v15 = entry;
entry = end_of_previous_entry(v17, a3, v16 + a2 - 4);
v19 += v15 - entry;
if ( v19 >= a5 )
goto LABEL_24;
v19 = a4 == v18 - 1 ? v16 - 4 - 4 * v18 - entry : start_of_next_entry(a3) - entry;
if ( v19 >= a5 )
goto LABEL_24;
*a3 = entry;
a3[1] = 0;
if ( a9 )
v14 = *(_QWORD *)(a1[1] + 128);
else
v14 = 0LL;
if ( a9 )
ma_compact_block_page(v17, a2, a4, 1, v14, *(_QWORD *)(v17 + 952));
else
ma_compact_block_page(v17, a2, a4, 1, v14, 0);
entry = *a3;
v19 = a3[1];
if ( v19 >= a5 )
{
*a6 = v19;
LABEL_24:
*a3 = entry;
a3[1] = v19;
*a7 = entry;
*a8 = v19;
return 0;
}
ma_set_fatal_error(a1, 0x7Fu, v9, v10, v11, v12);
return 1;
}
| extend_area_on_page:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc0
MOV AL,byte ptr [RBP + 0x20]
MOV RAX,qword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV dword ptr [RBP + -0x28],R8D
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x40],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX + 0x7bc]
MOV dword ptr [RBP + -0x4c],EAX
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RAX]
MOV dword ptr [RBP + -0x34],EAX
CMP dword ptr [RBP + -0x34],0x0
JZ 0x00159710
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RAX + 0x2]
MOV dword ptr [RBP + -0x3c],EAX
MOV dword ptr [RBP + -0x38],EAX
JMP 0x00159700
LAB_00159700:
MOV ECX,dword ptr [RBP + -0x3c]
MOV RAX,qword ptr [RBP + -0x30]
ADD ECX,dword ptr [RAX]
MOV dword ptr [RAX],ECX
JMP 0x001597a1
LAB_00159710:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x2]
CMP EAX,0xff
JNZ 0x0015972f
MOV RAX,qword ptr [RBP + -0x20]
MOV CL,byte ptr [RAX + 0x3]
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x9],CL
JMP 0x00159757
LAB_0015972f:
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x4c]
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EDX,byte ptr [RAX + 0x2]
CALL 0x00154350
MOV qword ptr [RBP + -0x58],RAX
JMP 0x00159749
LAB_00159749:
MOV RAX,qword ptr [RBP + -0x20]
MOV CL,byte ptr [RAX + 0x3]
MOV RAX,qword ptr [RBP + -0x58]
MOV byte ptr [RAX + 0x3],CL
LAB_00159757:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x3]
CMP EAX,0xff
JZ 0x0015978e
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x4c]
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EDX,byte ptr [RAX + 0x3]
CALL 0x00154350
MOV qword ptr [RBP + -0x60],RAX
JMP 0x00159780
LAB_00159780:
MOV RAX,qword ptr [RBP + -0x20]
MOV CL,byte ptr [RAX + 0x2]
MOV RAX,qword ptr [RBP + -0x60]
MOV byte ptr [RAX + 0x2],CL
LAB_0015978e:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x0015f590
MOV dword ptr [RBP + -0x34],EAX
MOV dword ptr [RBP + -0x38],0x0
LAB_001597a1:
MOV EAX,dword ptr [RBP + -0x38]
CMP EAX,dword ptr [RBP + -0x28]
JNC 0x0015994d
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x64],EAX
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x4c]
ADD RDX,RAX
ADD RDX,-0x4
CALL 0x0015f520
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x64]
SUB EAX,dword ptr [RBP + -0x34]
ADD EAX,dword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x38],EAX
JMP 0x001597df
LAB_001597df:
MOV EAX,dword ptr [RBP + -0x38]
CMP EAX,dword ptr [RBP + -0x28]
JNC 0x0015994b
MOV EAX,dword ptr [RBP + -0x24]
MOV ECX,dword ptr [RBP + -0x40]
SUB ECX,0x1
CMP EAX,ECX
JNZ 0x0015980e
MOV EAX,dword ptr [RBP + -0x4c]
SUB EAX,0x4
MOV ECX,dword ptr [RBP + -0x40]
SHL ECX,0x2
SUB EAX,ECX
SUB EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x38],EAX
JMP 0x0015981d
LAB_0015980e:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x0015f590
SUB EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x38],EAX
LAB_0015981d:
JMP 0x0015981f
LAB_0015981f:
JMP 0x00159821
LAB_00159821:
MOV EAX,dword ptr [RBP + -0x38]
CMP EAX,dword ptr [RBP + -0x28]
JNC 0x00159949
JMP 0x0015982f
LAB_0015982f:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x70],RAX
MOV EAX,dword ptr [RBP + -0x34]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x70]
MOV word ptr [RAX],CX
JMP 0x00159846
LAB_00159846:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV word ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0xa0],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x98],RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x8c],EAX
MOVSX EAX,byte ptr [RBP + 0x20]
CMP EAX,0x0
JZ 0x0015989b
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x80]
MOV qword ptr [RBP + -0xa8],RAX
JMP 0x001598a6
LAB_0015989b:
XOR EAX,EAX
MOV qword ptr [RBP + -0xa8],RAX
JMP 0x001598a6
LAB_001598a6:
MOV RAX,qword ptr [RBP + -0xa8]
MOV qword ptr [RBP + -0xb0],RAX
MOVSX EAX,byte ptr [RBP + 0x20]
CMP EAX,0x0
JZ 0x001598d1
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX + 0x3b8]
MOV qword ptr [RBP + -0xb8],RAX
JMP 0x001598dc
LAB_001598d1:
XOR EAX,EAX
MOV qword ptr [RBP + -0xb8],RAX
JMP 0x001598dc
LAB_001598dc:
MOV R8,qword ptr [RBP + -0xb0]
MOV EDX,dword ptr [RBP + -0x8c]
MOV RSI,qword ptr [RBP + -0x98]
MOV RDI,qword ptr [RBP + -0xa0]
MOV RAX,qword ptr [RBP + -0xb8]
MOV R9D,EAX
MOV ECX,0x1
CALL 0x00153c20
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RAX]
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RAX + 0x2]
MOV dword ptr [RBP + -0x38],EAX
MOV EAX,dword ptr [RBP + -0x38]
CMP EAX,dword ptr [RBP + -0x28]
JNC 0x00159940
JMP 0x0015992a
LAB_0015992a:
JMP 0x0015992c
LAB_0015992c:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x7f
CALL 0x00139b70
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0015999b
LAB_00159940:
MOV ECX,dword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],ECX
LAB_00159949:
JMP 0x0015994b
LAB_0015994b:
JMP 0x0015994d
LAB_0015994d:
JMP 0x0015994f
LAB_0015994f:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x80],RAX
MOV EAX,dword ptr [RBP + -0x34]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x80]
MOV word ptr [RAX],CX
JMP 0x00159966
LAB_00159966:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
MOV qword ptr [RBP + -0x88],RAX
MOV EAX,dword ptr [RBP + -0x38]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x88]
MOV word ptr [RAX],CX
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + 0x10]
MOV dword ptr [RAX],ECX
MOV ECX,dword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + 0x18]
MOV dword ptr [RAX],ECX
MOV byte ptr [RBP + -0x1],0x0
LAB_0015999b:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0xc0
POP RBP
RET
|
int1
extend_area_on_page(long *param_1,long param_2,ushort *param_3,int param_4,uint param_5,
uint *param_6,uint *param_7,uint *param_8,char param_9)
{
byte bVar1;
uint uVar2;
long lVar3;
uint uVar4;
int iVar5;
long lVar6;
ulong local_c0;
int8 local_b0;
uint local_40;
uint local_3c;
bVar1 = *(byte *)(param_2 + 8);
lVar3 = *param_1;
uVar2 = *(uint *)(lVar3 + 0x7bc);
local_3c = (uint)*param_3;
if (local_3c == 0) {
if ((char)param_3[1] == -1) {
*(int1 *)(param_2 + 9) = *(int1 *)((long)param_3 + 3);
}
else {
lVar6 = dir_entry_pos(param_2,uVar2,(char)param_3[1]);
*(int1 *)(lVar6 + 3) = *(int1 *)((long)param_3 + 3);
}
if (*(char *)((long)param_3 + 3) != -1) {
lVar6 = dir_entry_pos(param_2,uVar2,*(int1 *)((long)param_3 + 3));
*(char *)(lVar6 + 2) = (char)param_3[1];
}
local_3c = start_of_next_entry(param_3);
local_40 = 0;
}
else {
local_40 = (uint)param_3[1];
*param_6 = local_40 + *param_6;
}
if (local_40 < param_5) {
uVar4 = end_of_previous_entry(lVar3,param_3,param_2 + (ulong)uVar2 + -4);
local_40 = (local_3c - uVar4) + local_40;
local_3c = uVar4;
if (local_40 < param_5) {
if (param_4 == bVar1 - 1) {
local_40 = ((uVar2 - 4) + (uint)bVar1 * -4) - uVar4;
}
else {
iVar5 = start_of_next_entry(param_3);
local_40 = iVar5 - uVar4;
}
if (local_40 < param_5) {
*param_3 = (ushort)uVar4;
param_3[1] = 0;
if (param_9 == '\0') {
local_b0 = 0;
local_c0 = 0;
}
else {
local_b0 = *(int8 *)(param_1[1] + 0x80);
local_c0 = *(ulong *)(lVar3 + 0x3b8);
}
_ma_compact_block_page(lVar3,param_2,param_4,1,local_b0,local_c0 & 0xffffffff);
local_3c = (uint)*param_3;
local_40 = (uint)param_3[1];
if (local_40 < param_5) {
_ma_set_fatal_error(param_1,0x7f);
return 1;
}
*param_6 = local_40;
}
}
}
*param_3 = (ushort)local_3c;
param_3[1] = (ushort)local_40;
*param_7 = local_3c;
*param_8 = local_40;
return 0;
}
| |
42,829 | mysql_stmt_internal_reset | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | static my_bool mysql_stmt_internal_reset(MYSQL_STMT *stmt, my_bool is_close)
{
MYSQL *mysql= stmt->mysql;
my_bool ret= 1;
unsigned int flags= MADB_RESET_LONGDATA | MADB_RESET_BUFFER | MADB_RESET_ERROR;
if (!mysql)
{
/* connection could be invalid, e.g. after mysql_stmt_close or failed reconnect
attempt (see bug CONC-97) */
SET_CLIENT_STMT_ERROR(stmt, CR_SERVER_LOST, SQLSTATE_UNKNOWN, 0);
return(1);
}
if (stmt->state >= MYSQL_STMT_USER_FETCHING &&
stmt->fetch_row_func == stmt_unbuffered_fetch)
flags|= MADB_RESET_BUFFER;
ret= madb_reset_stmt(stmt, flags);
if (stmt->stmt_id)
{
if ((stmt->state > MYSQL_STMT_EXECUTED &&
stmt->mysql->status != MYSQL_STATUS_READY) ||
stmt->mysql->server_status & SERVER_MORE_RESULTS_EXIST)
{
/* flush any pending (multiple) result sets */
if (stmt->state == MYSQL_STMT_WAITING_USE_OR_STORE)
{
stmt->default_rset_handler(stmt);
stmt->state = MYSQL_STMT_USER_FETCHING;
}
if (stmt->field_count)
{
while (mysql_stmt_next_result(stmt) == 0);
stmt->mysql->status= MYSQL_STATUS_READY;
}
}
if (!is_close)
ret= madb_reset_stmt(stmt, MADB_RESET_SERVER);
stmt->state= MYSQL_STMT_PREPARED;
}
else
stmt->state= MYSQL_STMT_INITTED;
stmt->upsert_status.affected_rows= mysql->affected_rows;
stmt->upsert_status.last_insert_id= mysql->insert_id;
stmt->upsert_status.server_status= mysql->server_status;
stmt->upsert_status.warning_count= mysql->warning_count;
mysql->status= MYSQL_STATUS_READY;
return(ret);
} | O0 | c | mysql_stmt_internal_reset:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movb $0x1, -0x21(%rbp)
movl $0xb, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4f53e
jmp 0x4f4d2
movq -0x10(%rbp), %rax
movl $0x7dd, 0x108(%rax) # imm = 0x7DD
movq -0x10(%rbp), %rdi
addq $0x30d, %rdi # imm = 0x30D
leaq 0x1e825e(%rip), %rax # 0x237750
movq (%rax), %rsi
movl $0x5, %edx
callq 0x37150
movq -0x10(%rbp), %rax
movb $0x0, 0x312(%rax)
movq -0x10(%rbp), %rdi
addq $0x10c, %rdi # imm = 0x10C
leaq 0x1e8244(%rip), %rax # 0x237760
movq 0x68(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x37150
movq -0x10(%rbp), %rax
movb $0x0, 0x30b(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x4f6a1
movq -0x10(%rbp), %rax
cmpl $0x5, 0x50(%rax)
jb 0x4f565
movq -0x10(%rbp), %rax
leaq -0x2383(%rip), %rcx # 0x4d1d0
cmpq %rcx, 0x348(%rax)
jne 0x4f565
movl -0x28(%rbp), %eax
orl $0x8, %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x50ba0
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x4f62e
movq -0x10(%rbp), %rax
cmpl $0x2, 0x50(%rax)
jbe 0x4f59e
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpl $0x0, 0x488(%rax)
jne 0x4f5b4
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl 0x380(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x4f60a
movq -0x10(%rbp), %rax
cmpl $0x3, 0x50(%rax)
jne 0x4f5da
movq -0x10(%rbp), %rax
movq 0x358(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rax
movl $0x5, 0x50(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x60(%rax)
je 0x4f608
jmp 0x4f5e6
movq -0x10(%rbp), %rdi
callq 0x53720
cmpl $0x0, %eax
jne 0x4f5f6
jmp 0x4f5e6
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl $0x0, 0x488(%rax)
jmp 0x4f60a
cmpb $0x0, -0x11(%rbp)
jne 0x4f621
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x50ba0
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, 0x50(%rax)
jmp 0x4f639
movq -0x10(%rbp), %rax
movl $0x0, 0x50(%rax)
movq -0x20(%rbp), %rax
movq 0x338(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xf8(%rax)
movq -0x20(%rbp), %rax
movq 0x340(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x100(%rax)
movq -0x20(%rbp), %rax
movl 0x380(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xf4(%rax)
movq -0x20(%rbp), %rax
movl 0x388(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xf0(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x488(%rax)
movb -0x21(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| mysql_stmt_internal_reset:
push rbp
mov rbp, rsp
sub rsp, 30h
mov al, sil
mov [rbp+var_10], rdi
mov [rbp+var_11], al
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov [rbp+var_20], rax
mov [rbp+var_21], 1
mov [rbp+var_28], 0Bh
cmp [rbp+var_20], 0
jnz short loc_4F53E
jmp short $+2
loc_4F4D2:
mov rax, [rbp+var_10]
mov dword ptr [rax+108h], 7DDh
mov rdi, [rbp+var_10]
add rdi, 30Dh
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+312h], 0
mov rdi, [rbp+var_10]
add rdi, 10Ch
lea rax, client_errors
mov rsi, [rax+68h]
mov edx, 200h
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+30Bh], 0
mov [rbp+var_1], 1
jmp loc_4F6A1
loc_4F53E:
mov rax, [rbp+var_10]
cmp dword ptr [rax+50h], 5
jb short loc_4F565
mov rax, [rbp+var_10]
lea rcx, stmt_unbuffered_fetch
cmp [rax+348h], rcx
jnz short loc_4F565
mov eax, [rbp+var_28]
or eax, 8
mov [rbp+var_28], eax
loc_4F565:
mov rdi, [rbp+var_10]
mov esi, [rbp+var_28]
call madb_reset_stmt
mov [rbp+var_21], al
mov rax, [rbp+var_10]
cmp qword ptr [rax+40h], 0
jz loc_4F62E
mov rax, [rbp+var_10]
cmp dword ptr [rax+50h], 2
jbe short loc_4F59E
mov rax, [rbp+var_10]
mov rax, [rax+38h]
cmp dword ptr [rax+488h], 0
jnz short loc_4F5B4
loc_4F59E:
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov eax, [rax+380h]
and eax, 8
cmp eax, 0
jz short loc_4F60A
loc_4F5B4:
mov rax, [rbp+var_10]
cmp dword ptr [rax+50h], 3
jnz short loc_4F5DA
mov rax, [rbp+var_10]
mov rax, [rax+358h]
mov rdi, [rbp+var_10]
call rax
mov rax, [rbp+var_10]
mov dword ptr [rax+50h], 5
loc_4F5DA:
mov rax, [rbp+var_10]
cmp dword ptr [rax+60h], 0
jz short loc_4F608
jmp short $+2
loc_4F5E6:
mov rdi, [rbp+var_10]
call mysql_stmt_next_result
cmp eax, 0
jnz short loc_4F5F6
jmp short loc_4F5E6
loc_4F5F6:
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov dword ptr [rax+488h], 0
loc_4F608:
jmp short $+2
loc_4F60A:
cmp [rbp+var_11], 0
jnz short loc_4F621
mov rdi, [rbp+var_10]
mov esi, 4
call madb_reset_stmt
mov [rbp+var_21], al
loc_4F621:
mov rax, [rbp+var_10]
mov dword ptr [rax+50h], 1
jmp short loc_4F639
loc_4F62E:
mov rax, [rbp+var_10]
mov dword ptr [rax+50h], 0
loc_4F639:
mov rax, [rbp+var_20]
mov rcx, [rax+338h]
mov rax, [rbp+var_10]
mov [rax+0F8h], rcx
mov rax, [rbp+var_20]
mov rcx, [rax+340h]
mov rax, [rbp+var_10]
mov [rax+100h], rcx
mov rax, [rbp+var_20]
mov ecx, [rax+380h]
mov rax, [rbp+var_10]
mov [rax+0F4h], ecx
mov rax, [rbp+var_20]
mov ecx, [rax+388h]
mov rax, [rbp+var_10]
mov [rax+0F0h], ecx
mov rax, [rbp+var_20]
mov dword ptr [rax+488h], 0
mov al, [rbp+var_21]
mov [rbp+var_1], al
loc_4F6A1:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char mysql_stmt_internal_reset(long long a1, char a2)
{
char v3; // [rsp+Fh] [rbp-21h]
long long v4; // [rsp+10h] [rbp-20h]
v4 = *(_QWORD *)(a1 + 56);
if ( v4 )
{
v3 = madb_reset_stmt(a1, 11LL);
if ( *(_QWORD *)(a1 + 64) )
{
if ( *(_DWORD *)(a1 + 80) > 2u && *(_DWORD *)(*(_QWORD *)(a1 + 56) + 1160LL)
|| (*(_DWORD *)(*(_QWORD *)(a1 + 56) + 896LL) & 8) != 0 )
{
if ( *(_DWORD *)(a1 + 80) == 3 )
{
(*(void ( **)(long long))(a1 + 856))(a1);
*(_DWORD *)(a1 + 80) = 5;
}
if ( *(_DWORD *)(a1 + 96) )
{
while ( !(unsigned int)mysql_stmt_next_result(a1) )
;
*(_DWORD *)(*(_QWORD *)(a1 + 56) + 1160LL) = 0;
}
}
if ( !a2 )
v3 = madb_reset_stmt(a1, 4LL);
*(_DWORD *)(a1 + 80) = 1;
}
else
{
*(_DWORD *)(a1 + 80) = 0;
}
*(_QWORD *)(a1 + 248) = *(_QWORD *)(v4 + 824);
*(_QWORD *)(a1 + 256) = *(_QWORD *)(v4 + 832);
*(_DWORD *)(a1 + 244) = *(_DWORD *)(v4 + 896);
*(_DWORD *)(a1 + 240) = *(_DWORD *)(v4 + 904);
*(_DWORD *)(v4 + 1160) = 0;
return v3;
}
else
{
*(_DWORD *)(a1 + 264) = 2013;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
strncpy(a1 + 268, client_errors[13], 512LL);
*(_BYTE *)(a1 + 779) = 0;
return 1;
}
}
| mysql_stmt_internal_reset:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV AL,SIL
MOV qword ptr [RBP + -0x10],RDI
MOV byte ptr [RBP + -0x11],AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV qword ptr [RBP + -0x20],RAX
MOV byte ptr [RBP + -0x21],0x1
MOV dword ptr [RBP + -0x28],0xb
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x0014f53e
JMP 0x0014f4d2
LAB_0014f4d2:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x108],0x7dd
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x30d
LEA RAX,[0x337750]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00137150
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x312],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x10c
LEA RAX,[0x337760]
MOV RSI,qword ptr [RAX + 0x68]
MOV EDX,0x200
CALL 0x00137150
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x30b],0x0
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0014f6a1
LAB_0014f53e:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x50],0x5
JC 0x0014f565
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x14d1d0]
CMP qword ptr [RAX + 0x348],RCX
JNZ 0x0014f565
MOV EAX,dword ptr [RBP + -0x28]
OR EAX,0x8
MOV dword ptr [RBP + -0x28],EAX
LAB_0014f565:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x28]
CALL 0x00150ba0
MOV byte ptr [RBP + -0x21],AL
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x40],0x0
JZ 0x0014f62e
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x50],0x2
JBE 0x0014f59e
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
CMP dword ptr [RAX + 0x488],0x0
JNZ 0x0014f5b4
LAB_0014f59e:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV EAX,dword ptr [RAX + 0x380]
AND EAX,0x8
CMP EAX,0x0
JZ 0x0014f60a
LAB_0014f5b4:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x50],0x3
JNZ 0x0014f5da
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x358]
MOV RDI,qword ptr [RBP + -0x10]
CALL RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x50],0x5
LAB_0014f5da:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x60],0x0
JZ 0x0014f608
JMP 0x0014f5e6
LAB_0014f5e6:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00153720
CMP EAX,0x0
JNZ 0x0014f5f6
JMP 0x0014f5e6
LAB_0014f5f6:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV dword ptr [RAX + 0x488],0x0
LAB_0014f608:
JMP 0x0014f60a
LAB_0014f60a:
CMP byte ptr [RBP + -0x11],0x0
JNZ 0x0014f621
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x4
CALL 0x00150ba0
MOV byte ptr [RBP + -0x21],AL
LAB_0014f621:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x50],0x1
JMP 0x0014f639
LAB_0014f62e:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x50],0x0
LAB_0014f639:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX + 0x338]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xf8],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX + 0x340]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x100],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x380]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xf4],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x388]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xf0],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x488],0x0
MOV AL,byte ptr [RBP + -0x21]
MOV byte ptr [RBP + -0x1],AL
LAB_0014f6a1:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 mysql_stmt_internal_reset(long param_1,char param_2)
{
long lVar1;
int iVar2;
int1 local_29;
int1 local_9;
lVar1 = *(long *)(param_1 + 0x38);
if (lVar1 == 0) {
*(int4 *)(param_1 + 0x108) = 0x7dd;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
strncpy((char *)(param_1 + 0x10c),PTR_s_Lost_connection_to_server_during_003377c8,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
local_9 = 1;
}
else {
local_29 = madb_reset_stmt(param_1,0xb);
if (*(long *)(param_1 + 0x40) == 0) {
*(int4 *)(param_1 + 0x50) = 0;
}
else {
if (((2 < *(uint *)(param_1 + 0x50)) && (*(int *)(*(long *)(param_1 + 0x38) + 0x488) != 0)) ||
((*(uint *)(*(long *)(param_1 + 0x38) + 0x380) & 8) != 0)) {
if (*(int *)(param_1 + 0x50) == 3) {
(**(code **)(param_1 + 0x358))(param_1);
*(int4 *)(param_1 + 0x50) = 5;
}
if (*(int *)(param_1 + 0x60) != 0) {
do {
iVar2 = mysql_stmt_next_result(param_1);
} while (iVar2 == 0);
*(int4 *)(*(long *)(param_1 + 0x38) + 0x488) = 0;
}
}
if (param_2 == '\0') {
local_29 = madb_reset_stmt(param_1,4);
}
*(int4 *)(param_1 + 0x50) = 1;
}
*(int8 *)(param_1 + 0xf8) = *(int8 *)(lVar1 + 0x338);
*(int8 *)(param_1 + 0x100) = *(int8 *)(lVar1 + 0x340);
*(int4 *)(param_1 + 0xf4) = *(int4 *)(lVar1 + 0x380);
*(int4 *)(param_1 + 0xf0) = *(int4 *)(lVar1 + 0x388);
*(int4 *)(lVar1 + 0x488) = 0;
local_9 = local_29;
}
return local_9;
}
| |
42,830 | mysql_set_server_option_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_set_server_option_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_set_server_option,
(parms->mysql, parms->option),
parms->mysql,
int,
r_int)
} | O3 | c | mysql_set_server_option_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x480(%rax), %rcx
movq 0x28(%rcx), %rbx
movl 0x8(%rdi), %esi
movq %rax, %rdi
callq 0x1ec0c
movl %eax, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| mysql_set_server_option_start_internal:
push rbp
mov rbp, rsp
push rbx
push rax
mov rax, [rdi]
mov rcx, [rax+480h]
mov rbx, [rcx+28h]
mov esi, [rdi+8]
mov rdi, rax
call mysql_set_server_option
mov [rbx+8], eax
mov dword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
retn
| long long mysql_set_server_option_start_internal(long long a1)
{
_DWORD *v1; // rbx
long long result; // rax
v1 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)a1 + 1152LL) + 40LL);
result = mysql_set_server_option(*(_QWORD *)a1, *(_DWORD *)(a1 + 8));
v1[2] = result;
*v1 = 0;
return result;
}
| mysql_set_server_option_start_internal:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RDI]
MOV RCX,qword ptr [RAX + 0x480]
MOV RBX,qword ptr [RCX + 0x28]
MOV ESI,dword ptr [RDI + 0x8]
MOV RDI,RAX
CALL 0x0011ec0c
MOV dword ptr [RBX + 0x8],EAX
MOV dword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_set_server_option_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_set_server_option(*param_1,(int)param_1[1]);
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
| |
42,831 | mthd_stmt_flush_unbuffered | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | void mthd_stmt_flush_unbuffered(MYSQL_STMT *stmt)
{
ulong packet_len;
int in_resultset= stmt->state > MYSQL_STMT_EXECUTED &&
stmt->state < MYSQL_STMT_FETCH_DONE;
while ((packet_len = ma_net_safe_read(stmt->mysql)) != packet_error)
{
uchar *pos= stmt->mysql->net.read_pos;
if (!in_resultset && *pos == 0) /* OK */
{
pos++;
net_field_length(&pos);
net_field_length(&pos);
stmt->mysql->server_status= uint2korr(pos);
goto end;
}
if (packet_len < 8 && *pos == 254) /* EOF */
{
if (mariadb_connection(stmt->mysql))
{
stmt->mysql->server_status= uint2korr(pos + 3);
if (in_resultset)
goto end;
in_resultset= 1;
}
else
goto end;
}
}
end:
stmt->state= MYSQL_STMT_FETCH_DONE;
} | O0 | c | mthd_stmt_flush_unbuffered:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $0x2, 0x50(%rcx)
movb %al, -0x21(%rbp)
jbe 0x40489
movq -0x8(%rbp), %rax
cmpl $0x6, 0x50(%rax)
setb %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x304c0
movq %rax, -0x10(%rbp)
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmpq %rcx, %rax
je 0x4058c
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x40520
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x40520
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x30ae0
leaq -0x20(%rbp), %rdi
callq 0x30ae0
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movzwl %ax, %eax
movq -0x20(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
addl %ecx, %eax
movzwl %ax, %ecx
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movl %ecx, 0x380(%rax)
jmp 0x4058e
cmpq $0x8, -0x10(%rbp)
jae 0x40587
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xfe, %eax
jne 0x40587
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x30950
cmpb $0x0, %al
je 0x40583
movq -0x20(%rbp), %rax
movzbl 0x3(%rax), %eax
movzwl %ax, %eax
movq -0x20(%rbp), %rcx
movzbl 0x4(%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
addl %ecx, %eax
movzwl %ax, %ecx
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movl %ecx, 0x380(%rax)
cmpl $0x0, -0x14(%rbp)
je 0x4057a
jmp 0x4058e
movl $0x1, -0x14(%rbp)
jmp 0x40585
jmp 0x4058e
jmp 0x40587
jmp 0x40494
jmp 0x4058e
movq -0x8(%rbp), %rax
movl $0x6, 0x50(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
| mthd_stmt_flush_unbuffered:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov rcx, [rbp+var_8]
xor eax, eax
cmp dword ptr [rcx+50h], 2
mov [rbp+var_21], al
jbe short loc_40489
mov rax, [rbp+var_8]
cmp dword ptr [rax+50h], 6
setb al
mov [rbp+var_21], al
loc_40489:
mov al, [rbp+var_21]
and al, 1
movzx eax, al
mov [rbp+var_14], eax
loc_40494:
mov rax, [rbp+var_8]
mov rdi, [rax+38h]
call ma_net_safe_read
mov [rbp+var_10], rax
mov ecx, 0FFFFFFFFh
cmp rax, rcx
jz loc_4058C
mov rax, [rbp+var_8]
mov rax, [rax+38h]
mov rax, [rax+20h]
mov [rbp+var_20], rax
cmp [rbp+var_14], 0
jnz short loc_40520
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
cmp eax, 0
jnz short loc_40520
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
lea rdi, [rbp+var_20]
call net_field_length
lea rdi, [rbp+var_20]
call net_field_length
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
movzx eax, ax
mov rcx, [rbp+var_20]
movzx ecx, byte ptr [rcx+1]
movzx ecx, cx
shl ecx, 8
add eax, ecx
movzx ecx, ax
mov rax, [rbp+var_8]
mov rax, [rax+38h]
mov [rax+380h], ecx
jmp short loc_4058E
loc_40520:
cmp [rbp+var_10], 8
jnb short loc_40587
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
cmp eax, 0FEh
jnz short loc_40587
mov rax, [rbp+var_8]
mov rdi, [rax+38h]
call mariadb_connection
cmp al, 0
jz short loc_40583
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+3]
movzx eax, ax
mov rcx, [rbp+var_20]
movzx ecx, byte ptr [rcx+4]
movzx ecx, cx
shl ecx, 8
add eax, ecx
movzx ecx, ax
mov rax, [rbp+var_8]
mov rax, [rax+38h]
mov [rax+380h], ecx
cmp [rbp+var_14], 0
jz short loc_4057A
jmp short loc_4058E
loc_4057A:
mov [rbp+var_14], 1
jmp short loc_40585
loc_40583:
jmp short loc_4058E
loc_40585:
jmp short $+2
loc_40587:
jmp loc_40494
loc_4058C:
jmp short $+2
loc_4058E:
mov rax, [rbp+var_8]
mov dword ptr [rax+50h], 6
add rsp, 30h
pop rbp
retn
| long long mthd_stmt_flush_unbuffered(long long a1, long long a2, long long a3, long long a4, int a5, int a6)
{
long long v6; // rcx
long long result; // rax
bool v8; // [rsp+Fh] [rbp-21h]
unsigned __int8 *v9; // [rsp+10h] [rbp-20h] BYREF
int v10; // [rsp+1Ch] [rbp-14h]
unsigned long long v11; // [rsp+20h] [rbp-10h]
long long v12; // [rsp+28h] [rbp-8h]
v12 = a1;
v6 = a1;
v8 = 0;
if ( *(_DWORD *)(a1 + 80) > 2u )
v8 = *(_DWORD *)(v12 + 80) < 6u;
v10 = v8;
while ( 1 )
{
v11 = ma_net_safe_read(*(_QWORD *)(v12 + 56), a2, a3, v6, a5, a6);
v6 = 0xFFFFFFFFLL;
if ( v11 == 0xFFFFFFFF )
break;
v9 = *(unsigned __int8 **)(*(_QWORD *)(v12 + 56) + 32LL);
if ( !v10 && !*v9 )
{
++v9;
net_field_length(&v9);
net_field_length(&v9);
*(_DWORD *)(*(_QWORD *)(v12 + 56) + 896LL) = (unsigned __int16)((v9[1] << 8) + *v9);
break;
}
if ( v11 < 8 && *v9 == 254 )
{
if ( !mariadb_connection(*(_QWORD *)(v12 + 56)) )
break;
v6 = (unsigned __int16)((v9[4] << 8) + v9[3]);
*(_DWORD *)(*(_QWORD *)(v12 + 56) + 896LL) = v6;
if ( v10 )
break;
v10 = 1;
}
}
result = v12;
*(_DWORD *)(v12 + 80) = 6;
return result;
}
| mthd_stmt_flush_unbuffered:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV RCX,qword ptr [RBP + -0x8]
XOR EAX,EAX
CMP dword ptr [RCX + 0x50],0x2
MOV byte ptr [RBP + -0x21],AL
JBE 0x00140489
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x50],0x6
SETC AL
MOV byte ptr [RBP + -0x21],AL
LAB_00140489:
MOV AL,byte ptr [RBP + -0x21]
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x14],EAX
LAB_00140494:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x38]
CALL 0x001304c0
MOV qword ptr [RBP + -0x10],RAX
MOV ECX,0xffffffff
CMP RAX,RCX
JZ 0x0014058c
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RBP + -0x20],RAX
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x00140520
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x0
JNZ 0x00140520
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
LEA RDI,[RBP + -0x20]
CALL 0x00130ae0
LEA RDI,[RBP + -0x20]
CALL 0x00130ae0
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RCX + 0x1]
MOVZX ECX,CX
SHL ECX,0x8
ADD EAX,ECX
MOVZX ECX,AX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x38]
MOV dword ptr [RAX + 0x380],ECX
JMP 0x0014058e
LAB_00140520:
CMP qword ptr [RBP + -0x10],0x8
JNC 0x00140587
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xfe
JNZ 0x00140587
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x38]
CALL 0x00130950
CMP AL,0x0
JZ 0x00140583
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x3]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RCX + 0x4]
MOVZX ECX,CX
SHL ECX,0x8
ADD EAX,ECX
MOVZX ECX,AX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x38]
MOV dword ptr [RAX + 0x380],ECX
CMP dword ptr [RBP + -0x14],0x0
JZ 0x0014057a
JMP 0x0014058e
LAB_0014057a:
MOV dword ptr [RBP + -0x14],0x1
JMP 0x00140585
LAB_00140583:
JMP 0x0014058e
LAB_00140585:
JMP 0x00140587
LAB_00140587:
JMP 0x00140494
LAB_0014058c:
JMP 0x0014058e
LAB_0014058e:
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x50],0x6
ADD RSP,0x30
POP RBP
RET
|
void mthd_stmt_flush_unbuffered(long param_1)
{
char cVar1;
bool local_29;
byte *local_28;
uint local_1c;
ulong local_18;
long local_10;
local_29 = false;
if (2 < *(uint *)(param_1 + 0x50)) {
local_29 = *(uint *)(param_1 + 0x50) < 6;
}
local_1c = (uint)local_29;
local_10 = param_1;
do {
local_18 = ma_net_safe_read(*(int8 *)(local_10 + 0x38));
if (local_18 == 0xffffffff) {
LAB_0014058e:
*(int4 *)(local_10 + 0x50) = 6;
return;
}
local_28 = *(byte **)(*(long *)(local_10 + 0x38) + 0x20);
if ((local_1c == 0) && (*local_28 == 0)) {
local_28 = local_28 + 1;
net_field_length(&local_28);
net_field_length(&local_28);
*(uint *)(*(long *)(local_10 + 0x38) + 0x380) =
(uint)*local_28 + (uint)local_28[1] * 0x100 & 0xffff;
goto LAB_0014058e;
}
if ((local_18 < 8) && (*local_28 == 0xfe)) {
cVar1 = mariadb_connection(*(int8 *)(local_10 + 0x38));
if ((cVar1 == '\0') ||
(*(uint *)(*(long *)(local_10 + 0x38) + 0x380) =
(uint)local_28[3] + (uint)local_28[4] * 0x100 & 0xffff, local_1c != 0))
goto LAB_0014058e;
local_1c = 1;
}
} while( true );
}
| |
42,832 | mthd_stmt_flush_unbuffered | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | void mthd_stmt_flush_unbuffered(MYSQL_STMT *stmt)
{
ulong packet_len;
int in_resultset= stmt->state > MYSQL_STMT_EXECUTED &&
stmt->state < MYSQL_STMT_FETCH_DONE;
while ((packet_len = ma_net_safe_read(stmt->mysql)) != packet_error)
{
uchar *pos= stmt->mysql->net.read_pos;
if (!in_resultset && *pos == 0) /* OK */
{
pos++;
net_field_length(&pos);
net_field_length(&pos);
stmt->mysql->server_status= uint2korr(pos);
goto end;
}
if (packet_len < 8 && *pos == 254) /* EOF */
{
if (mariadb_connection(stmt->mysql))
{
stmt->mysql->server_status= uint2korr(pos + 3);
if (in_resultset)
goto end;
in_resultset= 1;
}
else
goto end;
}
}
end:
stmt->state= MYSQL_STMT_FETCH_DONE;
} | O3 | c | mthd_stmt_flush_unbuffered:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x50(%rdi), %r12d
movq 0x38(%rdi), %rdi
callq 0x26beb
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
cmpq %r14, %rax
je 0x2fe9a
addl $-0x3, %r12d
xorl %r15d, %r15d
cmpl $0x3, %r12d
setb %r15b
movq 0x38(%rbx), %rdi
movq 0x20(%rdi), %r12
testl %r15d, %r15d
jne 0x2fe2f
cmpb $0x0, (%r12)
je 0x2fe70
cmpq $0x7, %rax
ja 0x2fe64
cmpb $-0x2, (%r12)
jne 0x2fe64
callq 0x26f87
testb %al, %al
je 0x2fe9a
movzwl 0x3(%r12), %eax
movq 0x38(%rbx), %rcx
movl %eax, 0x380(%rcx)
testl %r15d, %r15d
jne 0x2fe9a
movq 0x38(%rbx), %rdi
movl $0x1, %r15d
callq 0x26beb
cmpq %r14, %rax
jne 0x2fe1b
jmp 0x2fe9a
incq %r12
leaq -0x28(%rbp), %r14
movq %r12, (%r14)
movq %r14, %rdi
callq 0x26fc9
movq %r14, %rdi
callq 0x26fc9
movq (%r14), %rax
movzwl (%rax), %eax
movq 0x38(%rbx), %rcx
movl %eax, 0x380(%rcx)
movl $0x6, 0x50(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| mthd_stmt_flush_unbuffered:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov rbx, rdi
mov r12d, [rdi+50h]
mov rdi, [rdi+38h]
call ma_net_safe_read
mov r14d, 0FFFFFFFFh
cmp rax, r14
jz loc_2FE9A
add r12d, 0FFFFFFFDh
xor r15d, r15d
cmp r12d, 3
setb r15b
loc_2FE1B:
mov rdi, [rbx+38h]
mov r12, [rdi+20h]
test r15d, r15d
jnz short loc_2FE2F
cmp byte ptr [r12], 0
jz short loc_2FE70
loc_2FE2F:
cmp rax, 7
ja short loc_2FE64
cmp byte ptr [r12], 0FEh
jnz short loc_2FE64
call mariadb_connection
test al, al
jz short loc_2FE9A
movzx eax, word ptr [r12+3]
mov rcx, [rbx+38h]
mov [rcx+380h], eax
test r15d, r15d
jnz short loc_2FE9A
mov rdi, [rbx+38h]
mov r15d, 1
loc_2FE64:
call ma_net_safe_read
cmp rax, r14
jnz short loc_2FE1B
jmp short loc_2FE9A
loc_2FE70:
inc r12
lea r14, [rbp+var_28]
mov [r14], r12
mov rdi, r14
call net_field_length
mov rdi, r14
call net_field_length
mov rax, [r14]
movzx eax, word ptr [rax]
mov rcx, [rbx+38h]
mov [rcx+380h], eax
loc_2FE9A:
mov dword ptr [rbx+50h], 6
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| char mthd_stmt_flush_unbuffered(long long a1, long long a2, long long a3, long long a4, unsigned long long a5, int a6)
{
int v7; // r12d
unsigned long long v8; // rax
long long v9; // rdx
long long v10; // rcx
unsigned long long v11; // r8
int v12; // r9d
BOOL v13; // r15d
long long v14; // rdi
long long v15; // r12
unsigned __int8 *v17[5]; // [rsp+8h] [rbp-28h] BYREF
v7 = *(_DWORD *)(a1 + 80);
v8 = ma_net_safe_read(*(_QWORD *)(a1 + 56), a2, a3, a4, a5, a6);
if ( v8 != 0xFFFFFFFF )
{
v13 = (unsigned int)(v7 - 3) < 3;
while ( 1 )
{
v14 = *(_QWORD *)(a1 + 56);
v15 = *(_QWORD *)(v14 + 32);
if ( !v13 && !*(_BYTE *)v15 )
break;
if ( v8 <= 7 && *(_BYTE *)v15 == 0xFE )
{
LOBYTE(v8) = mariadb_connection(v14);
if ( !(_BYTE)v8 )
goto LABEL_13;
LODWORD(v8) = *(unsigned __int16 *)(v15 + 3);
v10 = *(_QWORD *)(a1 + 56);
*(_DWORD *)(v10 + 896) = v8;
if ( v13 )
goto LABEL_13;
v14 = *(_QWORD *)(a1 + 56);
v13 = 1;
}
v8 = ma_net_safe_read(v14, a2, v9, v10, v11, v12);
if ( v8 == 0xFFFFFFFF )
goto LABEL_13;
}
v17[0] = (unsigned __int8 *)(v15 + 1);
net_field_length(v17);
net_field_length(v17);
LODWORD(v8) = *(unsigned __int16 *)v17[0];
*(_DWORD *)(*(_QWORD *)(a1 + 56) + 896LL) = v8;
}
LABEL_13:
*(_DWORD *)(a1 + 80) = 6;
return v8;
}
| mthd_stmt_flush_unbuffered:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOV R12D,dword ptr [RDI + 0x50]
MOV RDI,qword ptr [RDI + 0x38]
CALL 0x00126beb
MOV R14D,0xffffffff
CMP RAX,R14
JZ 0x0012fe9a
ADD R12D,-0x3
XOR R15D,R15D
CMP R12D,0x3
SETC R15B
LAB_0012fe1b:
MOV RDI,qword ptr [RBX + 0x38]
MOV R12,qword ptr [RDI + 0x20]
TEST R15D,R15D
JNZ 0x0012fe2f
CMP byte ptr [R12],0x0
JZ 0x0012fe70
LAB_0012fe2f:
CMP RAX,0x7
JA 0x0012fe64
CMP byte ptr [R12],0xfe
JNZ 0x0012fe64
CALL 0x00126f87
TEST AL,AL
JZ 0x0012fe9a
MOVZX EAX,word ptr [R12 + 0x3]
MOV RCX,qword ptr [RBX + 0x38]
MOV dword ptr [RCX + 0x380],EAX
TEST R15D,R15D
JNZ 0x0012fe9a
MOV RDI,qword ptr [RBX + 0x38]
MOV R15D,0x1
LAB_0012fe64:
CALL 0x00126beb
CMP RAX,R14
JNZ 0x0012fe1b
JMP 0x0012fe9a
LAB_0012fe70:
INC R12
LEA R14,[RBP + -0x28]
MOV qword ptr [R14],R12
MOV RDI,R14
CALL 0x00126fc9
MOV RDI,R14
CALL 0x00126fc9
MOV RAX,qword ptr [R14]
MOVZX EAX,word ptr [RAX]
MOV RCX,qword ptr [RBX + 0x38]
MOV dword ptr [RCX + 0x380],EAX
LAB_0012fe9a:
MOV dword ptr [RBX + 0x50],0x6
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
void mthd_stmt_flush_unbuffered(long param_1)
{
int iVar1;
char *pcVar2;
char cVar3;
ulong uVar4;
long lVar5;
bool bVar6;
ushort *local_30;
iVar1 = *(int *)(param_1 + 0x50);
uVar4 = ma_net_safe_read(*(int8 *)(param_1 + 0x38));
if (uVar4 != 0xffffffff) {
bVar6 = iVar1 - 3U < 3;
while( true ) {
lVar5 = *(long *)(param_1 + 0x38);
pcVar2 = *(char **)(lVar5 + 0x20);
if ((!bVar6) && (*pcVar2 == '\0')) break;
if ((uVar4 < 8) && (*pcVar2 == -2)) {
cVar3 = mariadb_connection();
if ((cVar3 == '\0') ||
(*(uint *)(*(long *)(param_1 + 0x38) + 0x380) = (uint)*(ushort *)(pcVar2 + 3), bVar6))
goto LAB_0012fe9a;
lVar5 = *(long *)(param_1 + 0x38);
bVar6 = true;
}
uVar4 = ma_net_safe_read(lVar5);
if (uVar4 == 0xffffffff) goto LAB_0012fe9a;
}
local_30 = (ushort *)(pcVar2 + 1);
net_field_length(&local_30);
net_field_length(&local_30);
*(uint *)(*(long *)(param_1 + 0x38) + 0x380) = (uint)*local_30;
}
LAB_0012fe9a:
*(int4 *)(param_1 + 0x50) = 6;
return;
}
| |
42,833 | ftxui::(anonymous namespace)::Inverted::Render(ftxui::Screen&) | Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/dom/inverted.cpp | void Render(Screen& screen) override {
Node::Render(screen);
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).inverted ^= true;
}
}
} | O1 | cpp | ftxui::(anonymous namespace)::Inverted::Render(ftxui::Screen&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2419e
movl 0x54(%r14), %r15d
cmpl 0x58(%r14), %r15d
jg 0x399b5
movl 0x4c(%r14), %r12d
cmpl 0x50(%r14), %r12d
jg 0x399a8
movq %rbx, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0x3a522
xorb $0x8, (%rax)
leal 0x1(%r12), %eax
cmpl 0x50(%r14), %r12d
movl %eax, %r12d
jl 0x39989
leal 0x1(%r15), %eax
cmpl 0x58(%r14), %r15d
movl %eax, %r15d
jl 0x3997f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
| _ZN5ftxui12_GLOBAL__N_18Inverted6RenderERNS_6ScreenE:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rsi
mov r14, rdi
call _ZN5ftxui4Node6RenderERNS_6ScreenE; ftxui::Node::Render(ftxui::Screen &)
mov r15d, [r14+54h]
cmp r15d, [r14+58h]
jg short loc_399B5
loc_3997F:
mov r12d, [r14+4Ch]
cmp r12d, [r14+50h]
jg short loc_399A8
loc_39989:
mov rdi, rbx; this
mov esi, r12d; int
mov edx, r15d; int
call _ZN5ftxui6Screen7PixelAtEii; ftxui::Screen::PixelAt(int,int)
xor byte ptr [rax], 8
lea eax, [r12+1]
cmp r12d, [r14+50h]
mov r12d, eax
jl short loc_39989
loc_399A8:
lea eax, [r15+1]
cmp r15d, [r14+58h]
mov r15d, eax
jl short loc_3997F
loc_399B5:
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long ftxui::`anonymous namespace'::Inverted::Render(
ftxui::_anonymous_namespace_::Inverted *this,
ftxui::Screen *a2)
{
long long result; // rax
int v3; // r15d
int v4; // r12d
_BYTE *v5; // rax
bool v6; // cc
result = ftxui::Node::Render(this, a2);
v3 = *((_DWORD *)this + 21);
if ( v3 <= *((_DWORD *)this + 22) )
{
do
{
v4 = *((_DWORD *)this + 19);
if ( v4 <= *((_DWORD *)this + 20) )
{
do
{
v5 = (_BYTE *)ftxui::Screen::PixelAt(a2, v4, v3);
*v5 ^= 8u;
v6 = v4++ < *((_DWORD *)this + 20);
}
while ( v6 );
}
result = (unsigned int)(v3 + 1);
v6 = v3++ < *((_DWORD *)this + 22);
}
while ( v6 );
}
return result;
}
| Render:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
CALL 0x0012419e
MOV R15D,dword ptr [R14 + 0x54]
CMP R15D,dword ptr [R14 + 0x58]
JG 0x001399b5
LAB_0013997f:
MOV R12D,dword ptr [R14 + 0x4c]
CMP R12D,dword ptr [R14 + 0x50]
JG 0x001399a8
LAB_00139989:
MOV RDI,RBX
MOV ESI,R12D
MOV EDX,R15D
CALL 0x0013a522
XOR byte ptr [RAX],0x8
LEA EAX,[R12 + 0x1]
CMP R12D,dword ptr [R14 + 0x50]
MOV R12D,EAX
JL 0x00139989
LAB_001399a8:
LEA EAX,[R15 + 0x1]
CMP R15D,dword ptr [R14 + 0x58]
MOV R15D,EAX
JL 0x0013997f
LAB_001399b5:
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* ftxui::(anonymous namespace)::Inverted::Render(ftxui::Screen&) */
void __thiscall ftxui::(anonymous_namespace)::Inverted::Render(Inverted *this,Screen *param_1)
{
bool bVar1;
byte *pbVar2;
int iVar3;
int iVar4;
Node::Render((Node *)this,param_1);
iVar4 = *(int *)(this + 0x54);
if (*(int *)(this + 0x54) <= *(int *)(this + 0x58)) {
do {
iVar3 = *(int *)(this + 0x4c);
if (*(int *)(this + 0x4c) <= *(int *)(this + 0x50)) {
do {
pbVar2 = (byte *)Screen::PixelAt(param_1,iVar3,iVar4);
*pbVar2 = *pbVar2 ^ 8;
bVar1 = iVar3 < *(int *)(this + 0x50);
iVar3 = iVar3 + 1;
} while (bVar1);
}
bVar1 = iVar4 < *(int *)(this + 0x58);
iVar4 = iVar4 + 1;
} while (bVar1);
}
return;
}
| |
42,834 | log_close(unsigned long) | eloqsql/storage/innobase/mtr/mtr0mtr.cc | static mtr_t::page_flush_ahead log_close(lsn_t lsn)
{
mysql_mutex_assert_owner(&log_sys.mutex);
ut_ad(lsn == log_sys.get_lsn());
byte *log_block= static_cast<byte*>(ut_align_down(log_sys.buf +
log_sys.buf_free,
OS_FILE_LOG_BLOCK_SIZE));
if (!log_block_get_first_rec_group(log_block))
{
/* We initialized a new log block which was not written
full by the current mtr: the next mtr log record group
will start within this block at the offset data_len */
log_block_set_first_rec_group(log_block,
log_block_get_data_len(log_block));
}
if (log_sys.buf_free > log_sys.max_buf_free)
log_sys.set_check_flush_or_checkpoint();
const lsn_t checkpoint_age= lsn - log_sys.last_checkpoint_lsn;
if (UNIV_UNLIKELY(checkpoint_age >= log_sys.log_capacity) &&
/* silence message on create_log_file() after the log had been deleted */
checkpoint_age != lsn)
{
time_t t= time(nullptr);
if (!log_close_warned || difftime(t, log_close_warn_time) > 15)
{
log_close_warned= true;
log_close_warn_time= t;
ib::error() << "The age of the last checkpoint is " << checkpoint_age
<< ", which exceeds the log capacity "
<< log_sys.log_capacity << ".";
}
}
else if (UNIV_LIKELY(checkpoint_age <= log_sys.max_modified_age_async))
return mtr_t::PAGE_FLUSH_NO;
else if (UNIV_LIKELY(checkpoint_age <= log_sys.max_checkpoint_age))
return mtr_t::PAGE_FLUSH_ASYNC;
log_sys.set_check_flush_or_checkpoint();
return mtr_t::PAGE_FLUSH_SYNC;
} | O0 | cpp | log_close(unsigned long):
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x190(%rbp)
jmp 0x10570d1
jmp 0x10570d3
jmp 0x10570d5
leaq 0x1500f64(%rip), %rax # 0x2558040
movq 0x108(%rax), %rdi
leaq 0x1500f56(%rip), %rax # 0x2558040
addq 0x88(%rax), %rdi
movl $0x200, %esi # imm = 0x200
callq 0x1057400
movq %rax, -0x198(%rbp)
movq -0x198(%rbp), %rdi
callq 0x1057760
cmpq $0x0, %rax
jne 0x105713d
movq -0x198(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movq -0x198(%rbp), %rdi
callq 0x1057790
movq -0x1c0(%rbp), %rdi
movq %rax, %rsi
callq 0x1057730
leaq 0x1500efc(%rip), %rax # 0x2558040
movq 0x88(%rax), %rax
leaq 0x1500eee(%rip), %rcx # 0x2558040
cmpq 0x90(%rcx), %rax
jbe 0x105716c
leaq 0x1500ede(%rip), %rdi # 0x2558040
movl $0x1, %esi
callq 0x102d100
movq -0x190(%rbp), %rax
movq %rax, -0x1c8(%rbp)
leaq 0x1500ebf(%rip), %rdi # 0x2558040
addq $0x1c8, %rdi # imm = 0x1C8
callq 0xfc4a90
movq %rax, %rcx
movq -0x1c8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x1a0(%rbp)
movq -0x1a0(%rbp), %rax
leaq 0x1500e91(%rip), %rcx # 0x2558040
cmpq 0x1a8(%rcx), %rax
jb 0x1057308
movq -0x1a0(%rbp), %rax
cmpq -0x190(%rbp), %rax
je 0x1057308
xorl %eax, %eax
movl %eax, %edi
callq 0x759d90
movq %rax, -0x1a8(%rbp)
testb $0x1, 0x15014f9(%rip) # 0x25586e0
je 0x105720e
movq -0x1a8(%rbp), %rdi
movq 0x15014f1(%rip), %rsi # 0x25586e8
callq 0x7584e0
movsd 0x3ed3d4(%rip), %xmm1 # 0x14445d8
ucomisd %xmm1, %xmm0
jbe 0x1057306
movb $0x1, 0x15014cb(%rip) # 0x25586e0
movq -0x1a8(%rbp), %rax
movq %rax, 0x15014c5(%rip) # 0x25586e8
leaq -0x180(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
xorl %esi, %esi
movl $0x178, %edx # imm = 0x178
callq 0x7584b0
movq -0x1d8(%rbp), %rdi
callq 0xfc7d30
movq -0x1d8(%rbp), %rdi
leaq 0x3c756a(%rip), %rsi # 0x141e7c1
callq 0xfc9f60
movq %rax, -0x1d0(%rbp)
jmp 0x1057265
movq -0x1d0(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0xfc49c0
movq %rax, -0x1e0(%rbp)
jmp 0x1057281
movq -0x1e0(%rbp), %rdi
leaq 0x3c7555(%rip), %rsi # 0x141e7e4
callq 0xfceba0
movq %rax, -0x1e8(%rbp)
jmp 0x105729d
movq -0x1e8(%rbp), %rdi
leaq 0x1500d95(%rip), %rsi # 0x2558040
addq $0x1a8, %rsi # imm = 0x1A8
callq 0xfc49c0
movq %rax, -0x1f0(%rbp)
jmp 0x10572c0
movq -0x1f0(%rbp), %rdi
leaq 0x3791e7(%rip), %rsi # 0x13d04b5
callq 0xfc8c60
jmp 0x10572d5
leaq -0x180(%rbp), %rdi
callq 0x11420b0
jmp 0x1057306
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x11420b0
jmp 0x105739a
jmp 0x1057352
movq -0x1a0(%rbp), %rax
leaq 0x1500d2a(%rip), %rcx # 0x2558040
cmpq 0x1b0(%rcx), %rax
ja 0x105732b
movl $0x0, -0x184(%rbp)
jmp 0x105736d
movq -0x1a0(%rbp), %rax
leaq 0x1500d07(%rip), %rcx # 0x2558040
cmpq 0x1b8(%rcx), %rax
ja 0x105734e
movl $0x1, -0x184(%rbp)
jmp 0x105736d
jmp 0x1057350
jmp 0x1057352
leaq 0x1500ce7(%rip), %rdi # 0x2558040
movl $0x1, %esi
callq 0x102d100
movl $0x2, -0x184(%rbp)
movl -0x184(%rbp), %eax
movl %eax, -0x1f4(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x10573c6
movl -0x1f4(%rbp), %eax
addq $0x200, %rsp # imm = 0x200
popq %rbp
retq
movq -0x1b0(%rbp), %rax
movq %rax, -0x200(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x10573c6
movq -0x200(%rbp), %rdi
callq 0x7589b0
callq 0x758480
nopl (%rax,%rax)
| _ZL9log_closem:
push rbp
mov rbp, rsp
sub rsp, 200h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_190], rdi
jmp short $+2
loc_10570D1:
jmp short $+2
loc_10570D3:
jmp short $+2
loc_10570D5:
lea rax, log_sys
mov rdi, [rax+108h]
lea rax, log_sys
add rdi, [rax+88h]; void *
mov esi, 200h; unsigned __int64
call _ZL13ut_align_downPvm_25; ut_align_down(void *,ulong)
mov [rbp+var_198], rax
mov rdi, [rbp+var_198]; unsigned __int8 *
call _ZL29log_block_get_first_rec_groupPKh_0; log_block_get_first_rec_group(uchar const*)
cmp rax, 0
jnz short loc_105713D
mov rax, [rbp+var_198]
mov [rbp+var_1C0], rax
mov rdi, [rbp+var_198]; unsigned __int8 *
call _ZL22log_block_get_data_lenPKh_0; log_block_get_data_len(uchar const*)
mov rdi, [rbp+var_1C0]; unsigned __int8 *
mov rsi, rax; unsigned __int64
call _ZL29log_block_set_first_rec_groupPhm_1; log_block_set_first_rec_group(uchar *,ulong)
loc_105713D:
lea rax, log_sys
mov rax, [rax+88h]
lea rcx, log_sys
cmp rax, [rcx+90h]
jbe short loc_105716C
lea rdi, log_sys; this
mov esi, 1; bool
call _ZN5log_t29set_check_flush_or_checkpointEb; log_t::set_check_flush_or_checkpoint(bool)
loc_105716C:
mov rax, [rbp+var_190]
mov [rbp+var_1C8], rax
lea rdi, log_sys
add rdi, 1C8h
call _ZNK14Atomic_relaxedImEcvmEv; Atomic_relaxed<ulong>::operator ulong(void)
mov rcx, rax
mov rax, [rbp+var_1C8]
sub rax, rcx
mov [rbp+var_1A0], rax
mov rax, [rbp+var_1A0]
lea rcx, log_sys
cmp rax, [rcx+1A8h]
jb loc_1057308
mov rax, [rbp+var_1A0]
cmp rax, [rbp+var_190]
jz loc_1057308
xor eax, eax
mov edi, eax
call _time
mov [rbp+var_1A8], rax
test cs:_ZL16log_close_warned, 1; log_close_warned
jz short loc_105720E
mov rdi, [rbp+var_1A8]
mov rsi, cs:_ZL19log_close_warn_time; log_close_warn_time
call _difftime
movsd xmm1, cs:qword_14445D8
ucomisd xmm0, xmm1
jbe loc_1057306
loc_105720E:
mov cs:_ZL16log_close_warned, 1; log_close_warned
mov rax, [rbp+var_1A8]
mov cs:_ZL19log_close_warn_time, rax; log_close_warn_time
lea rdi, [rbp+var_180]
mov [rbp+var_1D8], rdi
xor esi, esi
mov edx, 178h
call _memset
mov rdi, [rbp+var_1D8]; this
call _ZN2ib5errorC2Ev; ib::error::error(void)
mov rdi, [rbp+var_1D8]
lea rsi, aTheAgeOfTheLas; "The age of the last checkpoint is "
call _ZN2ib6loggerlsILm35EEERS0_RAT__Kc; ib::logger::operator<<<35ul>(char const(&)[35ul])
mov [rbp+var_1D0], rax
jmp short $+2
loc_1057265:
mov rdi, [rbp+var_1D0]
lea rsi, [rbp+var_1A0]
call _ZN2ib6loggerlsImEERS0_RKT_; ib::logger::operator<<<ulong>(ulong const&)
mov [rbp+var_1E0], rax
jmp short $+2
loc_1057281:
mov rdi, [rbp+var_1E0]
lea rsi, aWhichExceedsTh; ", which exceeds the log capacity "
call _ZN2ib6loggerlsILm34EEERS0_RAT__Kc; ib::logger::operator<<<34ul>(char const(&)[34ul])
mov [rbp+var_1E8], rax
jmp short $+2
loc_105729D:
mov rdi, [rbp+var_1E8]
lea rsi, log_sys
add rsi, 1A8h
call _ZN2ib6loggerlsImEERS0_RKT_; ib::logger::operator<<<ulong>(ulong const&)
mov [rbp+var_1F0], rax
jmp short $+2
loc_10572C0:
mov rdi, [rbp+var_1F0]
lea rsi, aArgument2ToFun+32h; "."
call _ZN2ib6loggerlsILm2EEERS0_RAT__Kc; ib::logger::operator<<<2ul>(char const(&)[2ul])
jmp short $+2
loc_10572D5:
lea rdi, [rbp+var_180]; this
call _ZN2ib5errorD2Ev; ib::error::~error()
jmp short loc_1057306
mov rcx, rax
mov eax, edx
mov [rbp+var_1B0], rcx
mov [rbp+var_1B4], eax
lea rdi, [rbp+var_180]; this
call _ZN2ib5errorD2Ev; ib::error::~error()
jmp loc_105739A
loc_1057306:
jmp short loc_1057352
loc_1057308:
mov rax, [rbp+var_1A0]
lea rcx, log_sys
cmp rax, [rcx+1B0h]
ja short loc_105732B
mov [rbp+var_184], 0
jmp short loc_105736D
loc_105732B:
mov rax, [rbp+var_1A0]
lea rcx, log_sys
cmp rax, [rcx+1B8h]
ja short loc_105734E
mov [rbp+var_184], 1
jmp short loc_105736D
loc_105734E:
jmp short $+2
loc_1057350:
jmp short $+2
loc_1057352:
lea rdi, log_sys; this
mov esi, 1; bool
call _ZN5log_t29set_check_flush_or_checkpointEb; log_t::set_check_flush_or_checkpoint(bool)
mov [rbp+var_184], 2
loc_105736D:
mov eax, [rbp+var_184]
mov [rbp+var_1F4], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_10573C6
mov eax, [rbp+var_1F4]
add rsp, 200h
pop rbp
retn
loc_105739A:
mov rax, [rbp+var_1B0]
mov [rbp+var_200], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_10573C6
mov rdi, [rbp+var_200]
call __Unwind_Resume
loc_10573C6:
call ___stack_chk_fail
| long long log_close(long long a1)
{
unsigned long long data_len; // rax
long long v2; // rdx
long long v4; // [rsp+10h] [rbp-1F0h]
long long v5; // [rsp+18h] [rbp-1E8h]
long long v6; // [rsp+20h] [rbp-1E0h]
long long v7; // [rsp+30h] [rbp-1D0h]
long long v8; // [rsp+58h] [rbp-1A8h]
unsigned long long v9; // [rsp+60h] [rbp-1A0h] BYREF
unsigned __int8 *v10; // [rsp+68h] [rbp-198h]
long long v11; // [rsp+70h] [rbp-190h]
_BYTE v13[376]; // [rsp+80h] [rbp-180h] BYREF
unsigned long long v14; // [rsp+1F8h] [rbp-8h]
v14 = __readfsqword(0x28u);
v11 = a1;
v10 = (unsigned __int8 *)ut_align_down((void *)(*((_QWORD *)&log_sys + 17) + *((_QWORD *)&log_sys + 33)), 0x200uLL);
if ( !log_block_get_first_rec_group(v10) )
{
data_len = log_block_get_data_len(v10);
log_block_set_first_rec_group(v10, data_len);
}
if ( *((_QWORD *)&log_sys + 17) > *((_QWORD *)&log_sys + 18) )
log_t::set_check_flush_or_checkpoint((log_t *)&log_sys, 1);
v9 = v11 - Atomic_relaxed<unsigned long>::operator unsigned long((long long)&log_sys + 456);
if ( v9 >= *((_QWORD *)&log_sys + 53) && v9 != v11 )
{
v8 = time(0LL);
if ( (log_close_warned & 1) == 0 || difftime(v8, log_close_warn_time, v2) > 15.0 )
{
log_close_warned = 1;
log_close_warn_time = v8;
memset(v13, 0LL);
ib::error::error((ib::error *)v13);
v7 = ib::logger::operator<<<35ul>((long long)v13, (long long)"The age of the last checkpoint is ");
v6 = ib::logger::operator<<<unsigned long>(v7, &v9);
v5 = ib::logger::operator<<<34ul>(v6, (long long)", which exceeds the log capacity ");
v4 = ib::logger::operator<<<unsigned long>(v5, (_QWORD *)&log_sys + 53);
ib::logger::operator<<<2ul>(v4, (long long)".");
ib::error::~error((ib::error *)v13);
}
goto LABEL_15;
}
if ( v9 > *((_QWORD *)&log_sys + 54) )
{
if ( v9 > *((_QWORD *)&log_sys + 55) )
{
LABEL_15:
log_t::set_check_flush_or_checkpoint((log_t *)&log_sys, 1);
return 2;
}
return 1;
}
else
{
return 0;
}
}
| init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV byte ptr [RAX + 0x8],0x1
MOV byte ptr [RAX + 0x9],0x1
MOV qword ptr [RAX + 0x10],0x4000
MOV qword ptr [RAX + 0x98],0x80
MOV qword ptr [RAX + 0xa0],0x80
MOV qword ptr [RAX],0x0
MOV dword ptr [RAX + 0x18],0x0
MOV dword ptr [RAX + 0x58],0x0
MOV dword ptr [RBP + -0x14],0x0
LAB_0105710a:
CMP dword ptr [RBP + -0x14],0x80
JGE 0x01057132
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,dword ptr [RBP + -0x14]
MOV qword ptr [RAX + RCX*0x8 + 0xa8],0x0
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0105710a
LAB_01057132:
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x0105714d
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x98],0x0
JMP 0x010571fe
LAB_0105714d:
CMP qword ptr [RBP + -0x10],0x0
JLE 0x010571f4
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,0x80
CQO
IDIV RCX
CMP RDX,0x0
JNZ 0x0105718a
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,0x80
CQO
IDIV RCX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x98],RCX
JMP 0x010571c3
LAB_0105718a:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,0x80
CQO
IDIV RCX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RCX,0x1
MOV qword ptr [RAX + 0x98],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,0x80
CQO
IDIV RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0xa0],RDX
LAB_010571c3:
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x9],0x0
CMP qword ptr [RAX + 0x98],0x80
JBE 0x010571f2
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x98],0x80
MOV qword ptr [RAX + 0xa0],0x80
LAB_010571f2:
JMP 0x010571fc
LAB_010571f4:
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x9],0x0
LAB_010571fc:
JMP 0x010571fe
LAB_010571fe:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x4b0
XOR EAX,EAX
MOV ESI,EAX
CALL 0x00858610
XOR EAX,EAX
ADD RSP,0x20
POP RBP
RET
|
/* PFS_buffer_scalable_container<PFS_account, 128, 128, PFS_account_array,
PFS_account_allocator>::init(long) */
int8 __thiscall
PFS_buffer_scalable_container<PFS_account,128,128,PFS_account_array,PFS_account_allocator>::init
(PFS_buffer_scalable_container<PFS_account,128,128,PFS_account_array,PFS_account_allocator>
*this,long param_1)
{
int local_1c;
this[8] = (PFS_buffer_scalable_container<PFS_account,128,128,PFS_account_array,PFS_account_allocator>
)0x1;
this[9] = (PFS_buffer_scalable_container<PFS_account,128,128,PFS_account_array,PFS_account_allocator>
)0x1;
*(int8 *)(this + 0x10) = 0x4000;
*(int8 *)(this + 0x98) = 0x80;
*(int8 *)(this + 0xa0) = 0x80;
*(int8 *)this = 0;
*(int4 *)(this + 0x18) = 0;
*(int4 *)(this + 0x58) = 0;
for (local_1c = 0; local_1c < 0x80; local_1c = local_1c + 1) {
*(int8 *)(this + (long)local_1c * 8 + 0xa8) = 0;
}
if (param_1 == 0) {
*(int8 *)(this + 0x98) = 0;
}
else if (param_1 < 1) {
this[9] = (PFS_buffer_scalable_container<PFS_account,128,128,PFS_account_array,PFS_account_allocator>
)0x0;
}
else {
if (param_1 % 0x80 == 0) {
*(long *)(this + 0x98) = param_1 / 0x80;
}
else {
*(long *)(this + 0x98) = param_1 / 0x80 + 1;
*(long *)(this + 0xa0) = param_1 % 0x80;
}
this[9] = (PFS_buffer_scalable_container<PFS_account,128,128,PFS_account_array,PFS_account_allocator>
)0x0;
if (0x80 < *(ulong *)(this + 0x98)) {
*(int8 *)(this + 0x98) = 0x80;
*(int8 *)(this + 0xa0) = 0x80;
}
}
pthread_mutex_init((pthread_mutex_t *)(this + 0x4b0),(pthread_mutexattr_t *)0x0);
return 0;
}
| |
42,835 | rlp_add_child | corpus-core[P]colibri-stateless/src/chains/eth/verifier/patricia_trie.c | static void rlp_add_child(buffer_t* buf, node_t* node) {
if (!node)
rlp_add_item(buf, NULL_BYTES);
else if (node->hash_len == 32)
rlp_add_item(buf, bytes(node->hash, 32));
else {
bytes_t decoded = {0};
bytes_t data = bytes(node->hash, node->hash_len);
rlp_decode(&data, 0, &decoded);
rlp_add_list(buf, decoded);
}
} | O2 | c | rlp_add_child:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x2d8ca
movq %rsi, %rdx
movl 0x20(%rsi), %eax
cmpl $0x20, %eax
jne 0x2d8dd
pushq $0x20
popq %rsi
movq %rbx, %rdi
jmp 0x2d8d1
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x2e039
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
leaq 0x18(%rsp), %rdi
movl %eax, (%rdi)
movq %rdx, 0x8(%rdi)
xorl %esi, %esi
movq %r14, %rdx
callq 0x2de74
movl (%r14), %esi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x2e132
addq $0x28, %rsp
popq %rbx
popq %r14
retq
| rlp_add_child:
push r14
push rbx
sub rsp, 28h
mov rbx, rdi
test rsi, rsi
jz short loc_2D8CA
mov rdx, rsi
mov eax, [rsi+20h]
cmp eax, 20h ; ' '
jnz short loc_2D8DD
push 20h ; ' '
pop rsi
mov rdi, rbx
jmp short loc_2D8D1
loc_2D8CA:
mov rdi, rbx
xor esi, esi
xor edx, edx
loc_2D8D1:
add rsp, 28h
pop rbx
pop r14
jmp rlp_add_item
loc_2D8DD:
xorps xmm0, xmm0
mov r14, rsp
movaps xmmword ptr [r14], xmm0
lea rdi, [rsp+38h+var_20]
mov [rdi], eax
mov [rdi+8], rdx
xor esi, esi
mov rdx, r14
call rlp_decode
mov esi, [r14]
mov rdx, [r14+8]
mov rdi, rbx
call rlp_add_list
add rsp, 28h
pop rbx
pop r14
retn
| long long rlp_add_child(long long a1, long long a2)
{
long long v2; // rdx
int v3; // eax
long long v4; // rsi
__int128 v6; // [rsp+0h] [rbp-38h] BYREF
int v7; // [rsp+18h] [rbp-20h] BYREF
long long v8; // [rsp+20h] [rbp-18h]
if ( !a2 )
{
v4 = 0LL;
v2 = 0LL;
return rlp_add_item(a1, v4, v2);
}
v2 = a2;
v3 = *(_DWORD *)(a2 + 32);
if ( v3 == 32 )
{
v4 = 32LL;
return rlp_add_item(a1, v4, v2);
}
v6 = 0LL;
v7 = v3;
v8 = a2;
rlp_decode(&v7, 0LL, &v6);
return rlp_add_list(a1, (unsigned int)v6, *((_QWORD *)&v6 + 1));
}
| rlp_add_child:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
TEST RSI,RSI
JZ 0x0012d8ca
MOV RDX,RSI
MOV EAX,dword ptr [RSI + 0x20]
CMP EAX,0x20
JNZ 0x0012d8dd
PUSH 0x20
POP RSI
MOV RDI,RBX
JMP 0x0012d8d1
LAB_0012d8ca:
MOV RDI,RBX
XOR ESI,ESI
XOR EDX,EDX
LAB_0012d8d1:
ADD RSP,0x28
POP RBX
POP R14
JMP 0x0012e039
LAB_0012d8dd:
XORPS XMM0,XMM0
MOV R14,RSP
MOVAPS xmmword ptr [R14],XMM0
LEA RDI,[RSP + 0x18]
MOV dword ptr [RDI],EAX
MOV qword ptr [RDI + 0x8],RDX
XOR ESI,ESI
MOV RDX,R14
CALL 0x0012de74
MOV ESI,dword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
MOV RDI,RBX
CALL 0x0012e132
ADD RSP,0x28
POP RBX
POP R14
RET
|
void rlp_add_child(int8 param_1,long param_2)
{
int8 uVar1;
ulong local_38;
int8 uStack_30;
int local_20 [2];
long local_18;
if (param_2 == 0) {
uVar1 = 0;
param_2 = 0;
}
else {
local_20[0] = *(int *)(param_2 + 0x20);
if (local_20[0] != 0x20) {
local_38 = 0;
uStack_30 = 0;
local_18 = param_2;
rlp_decode(local_20,0,&local_38);
rlp_add_list(param_1,local_38 & 0xffffffff,uStack_30);
return;
}
uVar1 = 0x20;
}
rlp_add_item(param_1,uVar1,param_2);
return;
}
| |
42,836 | google::protobuf::EnumDescriptorProto_EnumReservedRange::SharedCtor(google::protobuf::Arena*, bool) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.pb.cc | inline void EnumDescriptorProto_EnumReservedRange::SharedCtor(
::_pb::Arena* arena, bool is_message_owned) {
(void)arena;
(void)is_message_owned;
new (&_impl_) Impl_{
decltype(_impl_._has_bits_){}
, /*decltype(_impl_._cached_size_)*/{}
, decltype(_impl_.start_){0}
, decltype(_impl_.end_){0}
};
} | O0 | cpp | google::protobuf::EnumDescriptorProto_EnumReservedRange::SharedCtor(google::protobuf::Arena*, bool):
subq $0x48, %rsp
movb %dl, %al
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x38(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movl $0x0, (%rax)
addq $0x4, %rax
cmpq %rcx, %rax
movq %rax, 0x20(%rsp)
jne 0xd798f
movq 0x10(%rsp), %rdi
addq $0x4, %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0x4, %edx
callq 0x13200
movq 0x8(%rsp), %rdi
callq 0xd3ff0
movq 0x10(%rsp), %rax
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
addq $0x48, %rsp
retq
nopl (%rax)
| _ZN6google8protobuf37EnumDescriptorProto_EnumReservedRange10SharedCtorEPNS0_5ArenaEb:
sub rsp, 48h
mov al, dl
mov [rsp+48h+var_10], rdi
mov [rsp+48h+var_18], rsi
and al, 1
mov [rsp+48h+var_19], al
mov rax, [rsp+48h+var_10]
add rax, 10h
mov [rsp+48h+var_38], rax
mov [rsp+48h+var_8], rax
mov rax, [rsp+48h+var_8]
mov rcx, rax
add rcx, 4
mov [rsp+48h+var_30], rcx
mov [rsp+48h+var_28], rax
loc_D798F:
mov rax, [rsp+48h+var_28]
mov rcx, [rsp+48h+var_30]
mov dword ptr [rax], 0
add rax, 4
cmp rax, rcx
mov [rsp+48h+var_28], rax
jnz short loc_D798F
mov rdi, [rsp+48h+var_38]
add rdi, 4
mov [rsp+48h+var_40], rdi
xor esi, esi
mov edx, 4
call _memset
mov rdi, [rsp+48h+var_40]; this
call _ZN6google8protobuf8internal10CachedSizeC2Ev; google::protobuf::internal::CachedSize::CachedSize(void)
mov rax, [rsp+48h+var_38]
mov dword ptr [rax+8], 0
mov dword ptr [rax+0Ch], 0
add rsp, 48h
retn
| long long google::protobuf::EnumDescriptorProto_EnumReservedRange::SharedCtor(
google::protobuf::EnumDescriptorProto_EnumReservedRange *this,
google::protobuf::Arena *a2)
{
long long result; // rax
google::protobuf::EnumDescriptorProto_EnumReservedRange *v3; // [rsp+20h] [rbp-28h]
v3 = (google::protobuf::EnumDescriptorProto_EnumReservedRange *)((char *)this + 16);
do
{
*(_DWORD *)v3 = 0;
v3 = (google::protobuf::EnumDescriptorProto_EnumReservedRange *)((char *)v3 + 4);
}
while ( v3 != (google::protobuf::EnumDescriptorProto_EnumReservedRange *)((char *)this + 20) );
memset((char *)this + 20, 0LL, 4LL);
google::protobuf::internal::CachedSize::CachedSize((google::protobuf::EnumDescriptorProto_EnumReservedRange *)((char *)this + 20));
result = (long long)this + 16;
*((_DWORD *)this + 6) = 0;
*((_DWORD *)this + 7) = 0;
return result;
}
| SharedCtor:
SUB RSP,0x48
MOV AL,DL
MOV qword ptr [RSP + 0x38],RDI
MOV qword ptr [RSP + 0x30],RSI
AND AL,0x1
MOV byte ptr [RSP + 0x2f],AL
MOV RAX,qword ptr [RSP + 0x38]
ADD RAX,0x10
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x40]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RSP + 0x18],RCX
MOV qword ptr [RSP + 0x20],RAX
LAB_001d798f:
MOV RAX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x18]
MOV dword ptr [RAX],0x0
ADD RAX,0x4
CMP RAX,RCX
MOV qword ptr [RSP + 0x20],RAX
JNZ 0x001d798f
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x4
MOV qword ptr [RSP + 0x8],RDI
XOR ESI,ESI
MOV EDX,0x4
CALL 0x00113200
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001d3ff0
MOV RAX,qword ptr [RSP + 0x10]
MOV dword ptr [RAX + 0x8],0x0
MOV dword ptr [RAX + 0xc],0x0
ADD RSP,0x48
RET
|
/* google::protobuf::EnumDescriptorProto_EnumReservedRange::SharedCtor(google::protobuf::Arena*,
bool) */
void google::protobuf::EnumDescriptorProto_EnumReservedRange::SharedCtor
(Arena *param_1,bool param_2)
{
Arena *local_28;
local_28 = param_1 + 0x10;
do {
*(int4 *)local_28 = 0;
local_28 = local_28 + 4;
} while (local_28 != param_1 + 0x14);
memset((CachedSize *)(param_1 + 0x14),0,4);
internal::CachedSize::CachedSize((CachedSize *)(param_1 + 0x14));
*(int4 *)(param_1 + 0x18) = 0;
*(int4 *)(param_1 + 0x1c) = 0;
return;
}
| |
42,837 | Bfree | eloqsql/strings/dtoa.c | static void Bfree(Bigint *v, Stack_alloc *alloc)
{
char *gptr= (char*) v; /* generic pointer */
if (gptr < alloc->begin || gptr >= alloc->end)
free(gptr);
else if (v->k <= Kmax)
{
/*
Maintain free lists only for stack objects: this way we don't
have to bother with freeing lists in the end of dtoa;
heap should not be used normally anyway.
*/
v->p.next= alloc->freelist[v->k];
alloc->freelist[v->k]= v;
}
} | O3 | c | Bfree:
pushq %rbp
movq %rsp, %rbp
cmpq %rdi, (%rsi)
ja 0x58ec5
cmpq %rdi, 0x10(%rsi)
jbe 0x58ec5
movslq 0x8(%rdi), %rax
cmpq $0xf, %rax
jg 0x58ec3
movq 0x18(%rsi,%rax,8), %rcx
movq %rcx, (%rdi)
movq %rdi, 0x18(%rsi,%rax,8)
popq %rbp
retq
popq %rbp
jmp 0x243f0
| Bfree:
push rbp
mov rbp, rsp
cmp [rsi], rdi
ja short loc_58EC5
cmp [rsi+10h], rdi
jbe short loc_58EC5
movsxd rax, dword ptr [rdi+8]
cmp rax, 0Fh
jg short loc_58EC3
mov rcx, [rsi+rax*8+18h]
mov [rdi], rcx
mov [rsi+rax*8+18h], rdi
loc_58EC3:
pop rbp
retn
loc_58EC5:
pop rbp
jmp _free
| long long Bfree(unsigned long long a1, unsigned long long *a2)
{
long long result; // rax
if ( *a2 > a1 || a2[2] <= a1 )
return free(a1);
result = *(int *)(a1 + 8);
if ( result <= 15 )
{
*(_QWORD *)a1 = a2[result + 3];
a2[result + 3] = a1;
}
return result;
}
| Bfree:
PUSH RBP
MOV RBP,RSP
CMP qword ptr [RSI],RDI
JA 0x00158ec5
CMP qword ptr [RSI + 0x10],RDI
JBE 0x00158ec5
MOVSXD RAX,dword ptr [RDI + 0x8]
CMP RAX,0xf
JG 0x00158ec3
MOV RCX,qword ptr [RSI + RAX*0x8 + 0x18]
MOV qword ptr [RDI],RCX
MOV qword ptr [RSI + RAX*0x8 + 0x18],RDI
LAB_00158ec3:
POP RBP
RET
LAB_00158ec5:
POP RBP
JMP 0x001243f0
|
void Bfree(ulong *param_1,ulong *param_2)
{
long lVar1;
if (((ulong *)*param_2 <= param_1) && (param_1 < (ulong *)param_2[2])) {
lVar1 = (long)(int)param_1[1];
if (lVar1 < 0x10) {
*param_1 = param_2[lVar1 + 3];
param_2[lVar1 + 3] = (ulong)param_1;
}
return;
}
free(param_1);
return;
}
| |
42,838 | action_r_lt | navaro[P]qoraal-tictactoe/build_O3/_deps/qoraal_engine-src/src/parts/engine.c | int32_t
action_r_lt (PENGINE_T instance, uint32_t parm, uint32_t flags)
{
int32_t value ;
if (flags & (PART_ACTION_FLAG_VALIDATE)) {
return parts_valadate_int (instance, parm, flags, INT_MIN, INT_MAX) ;
}
value = parts_get_int (instance, parm, flags, INT_MIN, INT_MAX) ;
int32_t reg ;
engine_get_variable (instance, ENGINE_VARIABLE_REGISTER, ®) ;
int32_t res = reg < value ;
engine_set_variable (instance, ENGINE_VARIABLE_ACCUMULATOR, res) ;
return res ;
} | O3 | c | action_r_lt:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testb $0x1, %dl
jne 0x767e
movq %rbx, %rdi
movl $0x80000000, %ecx # imm = 0x80000000
movl $0x7fffffff, %r8d # imm = 0x7FFFFFFF
callq 0x82dd
movl %eax, %r14d
leaq -0x24(%rbp), %r15
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0xe6b1
xorl %r12d, %r12d
cmpl %r14d, (%r15)
setl %r12b
movq %rbx, %rdi
xorl %esi, %esi
movl %r12d, %edx
callq 0xe75e
movl %r12d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x80000000, %ecx # imm = 0x80000000
movl $0x7fffffff, %r8d # imm = 0x7FFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8254
| action_r_lt:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov rbx, rdi
test dl, 1
jnz short loc_767E
mov rdi, rbx
mov ecx, 80000000h
mov r8d, 7FFFFFFFh
call parts_get_int
mov r14d, eax
lea r15, [rbp+var_24]
mov rdi, rbx
mov esi, 1
mov rdx, r15
call engine_get_variable
xor r12d, r12d
cmp [r15], r14d
setl r12b
mov rdi, rbx
xor esi, esi
mov edx, r12d
call engine_set_variable
mov eax, r12d
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_767E:
mov rdi, rbx
mov ecx, 80000000h
mov r8d, 7FFFFFFFh
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp parts_valadate_int
| long long action_r_lt(long long a1, long long a2, long long a3)
{
int v3; // r14d
BOOL v4; // r12d
_DWORD v6[9]; // [rsp+Ch] [rbp-24h] BYREF
if ( (a3 & 1) != 0 )
return parts_valadate_int(a1, a2, a3, 0x80000000LL, 0x7FFFFFFFLL);
v3 = parts_get_int(a1, a2, a3, 0x80000000LL, 0x7FFFFFFFLL);
engine_get_variable(a1, 1LL, v6);
v4 = v6[0] < v3;
engine_set_variable(a1, 0LL, v6[0] < v3);
return v4;
}
| action_r_lt:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
TEST DL,0x1
JNZ 0x0010767e
MOV RDI,RBX
MOV ECX,0x80000000
MOV R8D,0x7fffffff
CALL 0x001082dd
MOV R14D,EAX
LEA R15,[RBP + -0x24]
MOV RDI,RBX
MOV ESI,0x1
MOV RDX,R15
CALL 0x0010e6b1
XOR R12D,R12D
CMP dword ptr [R15],R14D
SETL R12B
MOV RDI,RBX
XOR ESI,ESI
MOV EDX,R12D
CALL 0x0010e75e
MOV EAX,R12D
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0010767e:
MOV RDI,RBX
MOV ECX,0x80000000
MOV R8D,0x7fffffff
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x00108254
|
ulong action_r_lt(int8 param_1,int8 param_2,ulong param_3)
{
int iVar1;
ulong uVar2;
int local_2c;
if ((param_3 & 1) == 0) {
iVar1 = parts_get_int(param_1,param_2,param_3,0x80000000,0x7fffffff);
engine_get_variable(param_1,1,&local_2c);
engine_set_variable(param_1,0,(ulong)(local_2c < iVar1));
return (ulong)(local_2c < iVar1);
}
uVar2 = parts_valadate_int(param_1,param_2,param_3,0x80000000,0x7fffffff);
return uVar2;
}
| |
42,839 | YAML::convert<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::decode(YAML::Node const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | aimrt_mujoco_sim/_deps/yaml-cpp-src/include/yaml-cpp/node/convert.h | static bool decode(const Node& node, std::string& rhs) {
if (!node.IsScalar())
return false;
rhs = node.Scalar();
return true;
} | O3 | c | YAML::convert<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::decode(YAML::Node const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&):
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4aefe
movl %eax, %ebp
testb %al, %al
je 0x4aeb2
cmpb $0x0, (%r14)
je 0x4aeb9
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x4aea2
movq (%rax), %rax
movq (%rax), %rsi
addq $0x40, %rsi
jmp 0x4aeaa
callq 0x61054
movq %rax, %rsi
movq %rbx, %rdi
callq 0x2d240
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x40, %edi
callq 0x2c800
movq %rax, %rbx
addq $0x8, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x47084
leaq 0x1be6fc(%rip), %rsi # 0x2095d8
leaq 0x15849(%rip), %rdx # 0x6072c
movq %rbx, %rdi
callq 0x2e0f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2cc80
movq %r14, %rdi
callq 0x2e220
| _ZN4YAML7convertINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE6decodeERKNS_4NodeERS6_:
push rbp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
call _ZNK4YAML4Node8IsScalarEv; YAML::Node::IsScalar(void)
mov ebp, eax
test al, al
jz short loc_4AEB2
cmp byte ptr [r14], 0
jz short loc_4AEB9
mov rax, [r14+38h]
test rax, rax
jz short loc_4AEA2
mov rax, [rax]
mov rsi, [rax]
add rsi, 40h ; '@'
jmp short loc_4AEAA
loc_4AEA2:
call _ZN4YAML6detail9node_data12empty_scalarB5cxx11Ev; YAML::detail::node_data::empty_scalar(void)
mov rsi, rax
loc_4AEAA:
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
loc_4AEB2:
mov eax, ebp
pop rbx
pop r14
pop rbp
retn
loc_4AEB9:
mov edi, 40h ; '@'; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
add r14, 8
mov rdi, rax
mov rsi, r14
call _ZN4YAML11InvalidNodeC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; YAML::InvalidNode::InvalidNode(std::string const&)
lea rsi, _ZTIN4YAML11InvalidNodeE; lptinfo
lea rdx, _ZN4YAML9ExceptionD2Ev; 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 YAML::convert<std::string>::decode(YAML::Node *a1, long long a2)
{
unsigned int IsScalar; // ebp
_QWORD **v4; // rax
long long v5; // rsi
void *exception; // rbx
int v8; // edx
int v9; // ecx
int v10; // r8d
int v11; // r9d
IsScalar = YAML::Node::IsScalar(a1);
if ( (_BYTE)IsScalar )
{
if ( !*(_BYTE *)a1 )
{
exception = __cxa_allocate_exception(0x40uLL);
YAML::InvalidNode::InvalidNode((_DWORD)exception, (_DWORD)a1 + 8, v8, v9, v10, v11);
__cxa_throw(exception, (struct type_info *)&`typeinfo for'YAML::InvalidNode, YAML::Exception::~Exception);
}
v4 = (_QWORD **)*((_QWORD *)a1 + 7);
if ( v4 )
v5 = **v4 + 64LL;
else
v5 = YAML::detail::node_data::empty_scalar[abi:cxx11]();
std::string::_M_assign(a2, v5);
}
return IsScalar;
}
| decode:
PUSH RBP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
CALL 0x0014aefe
MOV EBP,EAX
TEST AL,AL
JZ 0x0014aeb2
CMP byte ptr [R14],0x0
JZ 0x0014aeb9
MOV RAX,qword ptr [R14 + 0x38]
TEST RAX,RAX
JZ 0x0014aea2
MOV RAX,qword ptr [RAX]
MOV RSI,qword ptr [RAX]
ADD RSI,0x40
JMP 0x0014aeaa
LAB_0014aea2:
CALL 0x00161054
MOV RSI,RAX
LAB_0014aeaa:
MOV RDI,RBX
CALL 0x0012d240
LAB_0014aeb2:
MOV EAX,EBP
POP RBX
POP R14
POP RBP
RET
LAB_0014aeb9:
MOV EDI,0x40
CALL 0x0012c800
MOV RBX,RAX
ADD R14,0x8
LAB_0014aeca:
MOV RDI,RAX
MOV RSI,R14
CALL 0x00147084
LAB_0014aed5:
LEA RSI,[0x3095d8]
LEA RDX,[0x16072c]
MOV RDI,RBX
CALL 0x0012e0f0
|
/* YAML::convert<std::__cxx11::string >::decode(YAML::Node const&, std::__cxx11::string&) */
int4 YAML::convert<std::__cxx11::string>::decode(Node *param_1,string *param_2)
{
int4 uVar1;
InvalidNode *this;
string *psVar2;
uVar1 = Node::IsScalar(param_1);
if ((char)uVar1 != '\0') {
if (*param_1 == (Node)0x0) {
this = (InvalidNode *)__cxa_allocate_exception(0x40);
/* try { // try from 0014aeca to 0014aed4 has its CatchHandler @ 0014aeeb */
InvalidNode::InvalidNode(this,(string *)(param_1 + 8));
/* WARNING: Subroutine does not return */
__cxa_throw(this,&InvalidNode::typeinfo,BadInsert::~BadInsert);
}
if (*(int8 **)(param_1 + 0x38) == (int8 *)0x0) {
psVar2 = (string *)detail::node_data::empty_scalar_abi_cxx11_();
}
else {
psVar2 = (string *)(*(long *)**(int8 **)(param_1 + 0x38) + 0x40);
}
std::__cxx11::string::_M_assign(param_2,psVar2);
}
return uVar1;
}
| |
42,840 | my_message_stderr | eloqsql/mysys/my_mess.c | void my_message_stderr(uint error __attribute__((unused)),
const char *str, myf MyFlags)
{
DBUG_ENTER("my_message_stderr");
DBUG_PRINT("enter",("message: %s",str));
(void) fflush(stdout);
if (MyFlags & (ME_NOTE | ME_ERROR_LOG_ONLY))
DBUG_VOID_RETURN;
if (MyFlags & ME_BELL)
(void) fputc('\007', stderr);
if (my_progname)
{
(void)fputs(my_progname,stderr); (void)fputs(": ",stderr);
}
(void)fputs(str,stderr);
(void)fputc('\n',stderr);
(void)fflush(stderr);
DBUG_VOID_RETURN;
} | O0 | c | my_message_stderr:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x27765
movq 0x1a884c(%rip), %rax # 0x1cffb8
movq (%rax), %rdi
callq 0x25410
movq -0x18(%rbp), %rax
andq $0x480, %rax # imm = 0x480
cmpq $0x0, %rax
je 0x2778b
jmp 0x27786
jmp 0x27821
movq -0x18(%rbp), %rax
andq $0x4, %rax
cmpq $0x0, %rax
je 0x277ad
movq 0x1a8838(%rip), %rax # 0x1cffd8
movq (%rax), %rsi
movl $0x7, %edi
callq 0x25490
leaq 0x36018c(%rip), %rax # 0x387940
cmpq $0x0, (%rax)
je 0x277e9
leaq 0x36017f(%rip), %rax # 0x387940
movq (%rax), %rdi
movq 0x1a880d(%rip), %rax # 0x1cffd8
movq (%rax), %rsi
callq 0x253e0
movq 0x1a87fe(%rip), %rax # 0x1cffd8
movq (%rax), %rsi
leaq 0x53e63(%rip), %rdi # 0x7b647
callq 0x253e0
movq -0x10(%rbp), %rdi
movq 0x1a87e4(%rip), %rax # 0x1cffd8
movq (%rax), %rsi
callq 0x253e0
movq 0x1a87d5(%rip), %rax # 0x1cffd8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x25490
movq 0x1a87c1(%rip), %rax # 0x1cffd8
movq (%rax), %rdi
callq 0x25410
jmp 0x27821
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| my_message_stderr:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
jmp short $+2
loc_27765:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, [rbp+var_18]
and rax, 480h
cmp rax, 0
jz short loc_2778B
jmp short $+2
loc_27786:
jmp loc_27821
loc_2778B:
mov rax, [rbp+var_18]
and rax, 4
cmp rax, 0
jz short loc_277AD
mov rax, cs:stderr_ptr
mov rsi, [rax]
mov edi, 7
call _fputc
loc_277AD:
lea rax, my_progname
cmp qword ptr [rax], 0
jz short loc_277E9
lea rax, my_progname
mov rdi, [rax]
mov rax, cs:stderr_ptr
mov rsi, [rax]
call _fputs
mov rax, cs:stderr_ptr
mov rsi, [rax]
lea rdi, asc_7B647; ": "
call _fputs
loc_277E9:
mov rdi, [rbp+var_10]
mov rax, cs:stderr_ptr
mov rsi, [rax]
call _fputs
mov rax, cs:stderr_ptr
mov rsi, [rax]
mov edi, 0Ah
call _fputc
mov rax, cs:stderr_ptr
mov rdi, [rax]
call _fflush
jmp short $+2
loc_27821:
add rsp, 20h
pop rbp
retn
| long long my_message_stderr(long long a1, long long a2, __int16 a3)
{
long long result; // rax
fflush(stdout);
result = a3 & 0x480;
if ( (a3 & 0x480) == 0 )
{
if ( (a3 & 4) != 0 )
fputc(7LL, stderr);
if ( my_progname )
{
fputs(my_progname, stderr);
fputs(": ", stderr);
}
fputs(a2, stderr);
fputc(10LL, stderr);
return fflush(stderr);
}
return result;
}
| my_message_stderr:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
JMP 0x00127765
LAB_00127765:
MOV RAX,qword ptr [0x002cffb8]
MOV RDI,qword ptr [RAX]
CALL 0x00125410
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x480
CMP RAX,0x0
JZ 0x0012778b
JMP 0x00127786
LAB_00127786:
JMP 0x00127821
LAB_0012778b:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x4
CMP RAX,0x0
JZ 0x001277ad
MOV RAX,qword ptr [0x002cffd8]
MOV RSI,qword ptr [RAX]
MOV EDI,0x7
CALL 0x00125490
LAB_001277ad:
LEA RAX,[0x487940]
CMP qword ptr [RAX],0x0
JZ 0x001277e9
LEA RAX,[0x487940]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [0x002cffd8]
MOV RSI,qword ptr [RAX]
CALL 0x001253e0
MOV RAX,qword ptr [0x002cffd8]
MOV RSI,qword ptr [RAX]
LEA RDI,[0x17b647]
CALL 0x001253e0
LAB_001277e9:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [0x002cffd8]
MOV RSI,qword ptr [RAX]
CALL 0x001253e0
MOV RAX,qword ptr [0x002cffd8]
MOV RSI,qword ptr [RAX]
MOV EDI,0xa
CALL 0x00125490
MOV RAX,qword ptr [0x002cffd8]
MOV RDI,qword ptr [RAX]
CALL 0x00125410
JMP 0x00127821
LAB_00127821:
ADD RSP,0x20
POP RBP
RET
|
void my_message_stderr(int8 param_1,char *param_2,ulong param_3)
{
fflush(*(FILE **)PTR_stdout_002cffb8);
if ((param_3 & 0x480) == 0) {
if ((param_3 & 4) != 0) {
fputc(7,*(FILE **)PTR_stderr_002cffd8);
}
if (my_progname != (char *)0x0) {
fputs(my_progname,*(FILE **)PTR_stderr_002cffd8);
fputs(": ",*(FILE **)PTR_stderr_002cffd8);
}
fputs(param_2,*(FILE **)PTR_stderr_002cffd8);
fputc(10,*(FILE **)PTR_stderr_002cffd8);
fflush(*(FILE **)PTR_stderr_002cffd8);
}
return;
}
| |
42,841 | DepthAnything::postprocessBatch(std::vector<cv::Size_<int>, std::allocator<cv::Size_<int>>> const&, Ort::Value const&) | Depths-CPP/include/depth_anything.hpp | std::vector<cv::Mat> DepthAnything::postprocessBatch(const std::vector<cv::Size> &originalImageSizes, const Ort::Value &outputTensor)
{
const float *rawOutput = outputTensor.GetTensorData<float>();
auto outputTypeInfo = outputTensor.GetTensorTypeAndShapeInfo();
std::vector<int64_t> outputShape = outputTypeInfo.GetShape();
if (outputShape.size() < 3 || outputShape[0] <= 0)
{
throw std::runtime_error("Invalid output tensor shape for batch processing.");
}
int batchSize = static_cast<int>(outputShape[0]);
int H = static_cast<int>(outputShape[1]);
int W = static_cast<int>(outputShape[2]);
size_t singleImageSize = H * W;
std::vector<cv::Mat> depthMaps;
depthMaps.reserve(batchSize);
for (int i = 0; i < batchSize; i++)
{
// Extract each depth map from the batch output
cv::Mat depthMap(H, W, CV_32FC1);
memcpy(depthMap.data, rawOutput + i * singleImageSize, singleImageSize * sizeof(float));
// Resize to original image dimensions
cv::Mat resizedDepth;
if (i < originalImageSizes.size()) {
cv::resize(depthMap, resizedDepth, originalImageSizes[i], 0, 0, cv::INTER_LINEAR);
} else {
resizedDepth = depthMap.clone();
}
depthMaps.push_back(resizedDepth);
}
return depthMaps;
} | O0 | cpp | DepthAnything::postprocessBatch(std::vector<cv::Size_<int>, std::allocator<cv::Size_<int>>> const&, Ort::Value const&):
subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
movq %rdx, 0x1e0(%rsp)
movq %rcx, 0x1d8(%rsp)
movq 0x1d8(%rsp), %rdi
callq 0x203a0
movq %rax, 0x1d0(%rsp)
movq 0x1d8(%rsp), %rsi
leaq 0x1c8(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x203e0
movq 0x28(%rsp), %rsi
leaq 0x1b0(%rsp), %rdi
callq 0x20450
jmp 0x1b357
leaq 0x1b0(%rsp), %rdi
callq 0x1f480
cmpq $0x3, %rax
jb 0x1b385
leaq 0x1b0(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1f4a0
cmpq $0x0, (%rax)
jg 0x1b41a
movl $0x10, %edi
callq 0x191c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
leaq 0x11db9(%rip), %rsi # 0x2d15a
callq 0x19040
jmp 0x1b3a8
movq 0x10(%rsp), %rdi
movq 0x1bc04(%rip), %rsi # 0x36fb8
movq 0x1bc3d(%rip), %rdx # 0x36ff8
callq 0x19350
jmp 0x1b79d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
jmp 0x1b783
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
callq 0x19240
jmp 0x1b776
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
jmp 0x1b776
xorl %eax, %eax
movl %eax, %esi
leaq 0x1b0(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1f4a0
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x1a0(%rsp)
movl $0x1, %esi
callq 0x1f4a0
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x19c(%rsp)
movl $0x2, %esi
callq 0x1f4a0
movq 0x18(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x198(%rsp)
movl 0x19c(%rsp), %eax
movl 0x198(%rsp), %ecx
imull %ecx, %eax
cltq
movq %rax, 0x190(%rsp)
movb $0x0, 0x18f(%rsp)
callq 0x1fc70
movq 0x18(%rsp), %rdi
movslq 0x1a0(%rsp), %rsi
callq 0x200e0
jmp 0x1b4aa
movl $0x0, 0x188(%rsp)
movl 0x188(%rsp), %eax
cmpl 0x1a0(%rsp), %eax
jge 0x1b729
movl 0x19c(%rsp), %esi
movl 0x198(%rsp), %edx
leaq 0x128(%rsp), %rdi
movl $0x5, %ecx
callq 0x19470
jmp 0x1b4eb
movq 0x138(%rsp), %rdi
movq 0x1d0(%rsp), %rsi
movslq 0x188(%rsp), %rax
imulq 0x190(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq 0x190(%rsp), %rdx
shlq $0x2, %rdx
callq 0x19410
leaq 0xc8(%rsp), %rdi
callq 0x19050
movslq 0x188(%rsp), %rax
movq %rax, (%rsp)
movq 0x1e0(%rsp), %rdi
callq 0x20590
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x1b675
leaq 0xb0(%rsp), %rdi
leaq 0x128(%rsp), %rsi
callq 0x1fc80
jmp 0x1b571
leaq 0x98(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x1fc00
jmp 0x1b588
movq 0x1e0(%rsp), %rdi
movslq 0x188(%rsp), %rsi
callq 0x205b0
movq %rax, %rsi
leaq 0x90(%rsp), %rdi
callq 0x1fa40
jmp 0x1b5af
leaq 0xb0(%rsp), %rdi
leaq 0x98(%rsp), %rsi
leaq 0x90(%rsp), %rdx
vpxor %xmm1, %xmm1, %xmm1
movl $0x1, %ecx
vmovaps %xmm1, %xmm0
callq 0x19510
jmp 0x1b5db
leaq 0x98(%rsp), %rdi
callq 0x1fc60
leaq 0xb0(%rsp), %rdi
callq 0x1fd00
jmp 0x1b6c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
jmp 0x1b76c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
jmp 0x1b70d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
jmp 0x1b663
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x1fc60
leaq 0xb0(%rsp), %rdi
callq 0x1fd00
jmp 0x1b70d
leaq 0x30(%rsp), %rdi
leaq 0x128(%rsp), %rsi
callq 0x19120
jmp 0x1b689
leaq 0xc8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x19070
jmp 0x1b69d
leaq 0x30(%rsp), %rdi
callq 0x19080
jmp 0x1b6c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x19080
jmp 0x1b70d
movq 0x18(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x202d0
jmp 0x1b6dd
leaq 0xc8(%rsp), %rdi
callq 0x19080
leaq 0x128(%rsp), %rdi
callq 0x19080
movl 0x188(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x188(%rsp)
jmp 0x1b4b5
leaq 0xc8(%rsp), %rdi
callq 0x19080
leaq 0x128(%rsp), %rdi
callq 0x19080
jmp 0x1b76c
movb $0x1, 0x18f(%rsp)
testb $0x1, 0x18f(%rsp)
jne 0x1b745
movq 0x18(%rsp), %rdi
callq 0x1ff00
leaq 0x1b0(%rsp), %rdi
callq 0x1f820
leaq 0x1c8(%rsp), %rdi
callq 0x20580
movq 0x20(%rsp), %rax
addq $0x1f8, %rsp # imm = 0x1F8
retq
movq 0x18(%rsp), %rdi
callq 0x1ff00
leaq 0x1b0(%rsp), %rdi
callq 0x1f820
leaq 0x1c8(%rsp), %rdi
callq 0x20580
movq 0x1a8(%rsp), %rdi
callq 0x19360
nopl (%rax)
| _ZN13DepthAnything16postprocessBatchERKSt6vectorIN2cv5Size_IiEESaIS3_EERKN3Ort5ValueE:
sub rsp, 1F8h
mov [rsp+1F8h+var_1E0], rdi
mov rax, rdi
mov [rsp+1F8h+var_1D8], rax
mov [rsp+1F8h+var_8], rdi
mov [rsp+1F8h+var_10], rsi
mov [rsp+1F8h+var_18], rdx
mov [rsp+1F8h+var_20], rcx
mov rdi, [rsp+1F8h+var_20]
call _ZNK3Ort6detail14ConstValueImplI8OrtValueE13GetTensorDataIfEEPKT_v; Ort::detail::ConstValueImpl<OrtValue>::GetTensorData<float>(void)
mov [rsp+1F8h+var_28], rax
mov rsi, [rsp+1F8h+var_20]
lea rdi, [rsp+1F8h+var_30]
mov [rsp+1F8h+var_1D0], rdi
call _ZNK3Ort6detail14ConstValueImplI8OrtValueE25GetTensorTypeAndShapeInfoEv; Ort::detail::ConstValueImpl<OrtValue>::GetTensorTypeAndShapeInfo(void)
mov rsi, [rsp+1F8h+var_1D0]
lea rdi, [rsp+1F8h+var_48]
call _ZNK3Ort6detail26TensorTypeAndShapeInfoImplI25OrtTensorTypeAndShapeInfoE8GetShapeEv; Ort::detail::TensorTypeAndShapeInfoImpl<OrtTensorTypeAndShapeInfo>::GetShape(void)
jmp short $+2
loc_1B357:
lea rdi, [rsp+1F8h+var_48]
call _ZNKSt6vectorIlSaIlEE4sizeEv; std::vector<long>::size(void)
cmp rax, 3
jb short loc_1B385
lea rdi, [rsp+1F8h+var_48]
xor eax, eax
mov esi, eax
call _ZNSt6vectorIlSaIlEEixEm; std::vector<long>::operator[](ulong)
cmp qword ptr [rax], 0
jg loc_1B41A
loc_1B385:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+1F8h+var_1E8], rax
lea rsi, aInvalidOutputT; "Invalid output tensor shape for batch p"...
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_1B3A8:
mov rdi, [rsp+1F8h+var_1E8]; void *
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_1B79D
mov rcx, rax
mov eax, edx
mov [rsp+arg_1A0], rcx
mov [rsp+arg_19C], eax
jmp loc_1B783
mov rdi, [rsp+arg_8]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_1A0], rcx
mov [rsp+arg_19C], eax
call ___cxa_free_exception
jmp loc_1B776
mov rcx, rax
mov eax, edx
mov [rsp+arg_1A0], rcx
mov [rsp+arg_19C], eax
jmp loc_1B776
loc_1B41A:
xor eax, eax
mov esi, eax
lea rdi, [rsp+1F8h+var_48]
mov [rsp+1F8h+var_1F0], rdi
call _ZNSt6vectorIlSaIlEEixEm; std::vector<long>::operator[](ulong)
mov rdi, [rsp+1F8h+var_1F0]
mov eax, [rax]
mov [rsp+1F8h+var_58], eax
mov esi, 1
call _ZNSt6vectorIlSaIlEEixEm; std::vector<long>::operator[](ulong)
mov rdi, [rsp+1F8h+var_1F0]
mov eax, [rax]
mov [rsp+1F8h+var_5C], eax
mov esi, 2
call _ZNSt6vectorIlSaIlEEixEm; std::vector<long>::operator[](ulong)
mov rdi, [rsp+1F8h+var_1E0]
mov eax, [rax]
mov [rsp+1F8h+var_60], eax
mov eax, [rsp+1F8h+var_5C]
mov ecx, [rsp+1F8h+var_60]
imul eax, ecx
cdqe
mov [rsp+1F8h+var_68], rax
mov [rsp+1F8h+var_69], 0
call _ZNSt6vectorIN2cv3MatESaIS1_EEC2Ev; std::vector<cv::Mat>::vector(void)
mov rdi, [rsp+1F8h+var_1E0]
movsxd rsi, [rsp+1F8h+var_58]
call _ZNSt6vectorIN2cv3MatESaIS1_EE7reserveEm; std::vector<cv::Mat>::reserve(ulong)
jmp short $+2
loc_1B4AA:
mov [rsp+1F8h+var_70], 0
loc_1B4B5:
mov eax, [rsp+1F8h+var_70]
cmp eax, [rsp+1F8h+var_58]
jge loc_1B729
mov esi, [rsp+1F8h+var_5C]; int
mov edx, [rsp+1F8h+var_60]; int
lea rdi, [rsp+1F8h+var_D0]; this
mov ecx, 5; int
call __ZN2cv3MatC1Eiii; cv::Mat::Mat(int,int,int)
jmp short $+2
loc_1B4EB:
mov rdi, [rsp+1F8h+var_C0]
mov rsi, [rsp+1F8h+var_28]
movsxd rax, [rsp+1F8h+var_70]
imul rax, [rsp+1F8h+var_68]
shl rax, 2
add rsi, rax
mov rdx, [rsp+1F8h+var_68]
shl rdx, 2
call _memcpy
lea rdi, [rsp+1F8h+var_130]; this
call __ZN2cv3MatC1Ev; cv::Mat::Mat(void)
movsxd rax, [rsp+1F8h+var_70]
mov [rsp+1F8h+var_1F8], rax
mov rdi, [rsp+1F8h+var_18]
call _ZNKSt6vectorIN2cv5Size_IiEESaIS2_EE4sizeEv; std::vector<cv::Size_<int>>::size(void)
mov rcx, rax
mov rax, [rsp+1F8h+var_1F8]
cmp rax, rcx
jnb loc_1B675
lea rdi, [rsp+1F8h+var_148]; this
lea rsi, [rsp+1F8h+var_D0]; cv::Mat *
call _ZN2cv11_InputArrayC2ERKNS_3MatE; cv::_InputArray::_InputArray(cv::Mat const&)
jmp short $+2
loc_1B571:
lea rdi, [rsp+1F8h+var_160]; this
lea rsi, [rsp+1F8h+var_130]; cv::Mat *
call _ZN2cv12_OutputArrayC2ERNS_3MatE; cv::_OutputArray::_OutputArray(cv::Mat &)
jmp short $+2
loc_1B588:
mov rdi, [rsp+1F8h+var_18]
movsxd rsi, [rsp+1F8h+var_70]
call _ZNKSt6vectorIN2cv5Size_IiEESaIS2_EEixEm; std::vector<cv::Size_<int>>::operator[](ulong)
mov rsi, rax
lea rdi, [rsp+1F8h+var_168]
call _ZN2cv5Size_IiEC2ERKS1_; cv::Size_<int>::Size_(cv::Size_<int> const&)
jmp short $+2
loc_1B5AF:
lea rdi, [rsp+1F8h+var_148]
lea rsi, [rsp+1F8h+var_160]
lea rdx, [rsp+1F8h+var_168]
vpxor xmm1, xmm1, xmm1
mov ecx, 1
vmovaps xmm0, xmm1
call __ZN2cv6resizeERKNS_11_InputArrayERKNS_12_OutputArrayENS_5Size_IiEEddi; cv::resize(cv::_InputArray const&,cv::_OutputArray const&,cv::Size_<int>,double,double,int)
jmp short $+2
loc_1B5DB:
lea rdi, [rsp+1F8h+var_160]; this
call _ZN2cv12_OutputArrayD2Ev; cv::_OutputArray::~_OutputArray()
lea rdi, [rsp+1F8h+var_148]; this
call _ZN2cv11_InputArrayD2Ev; cv::_InputArray::~_InputArray()
jmp loc_1B6C9
mov rcx, rax
mov eax, edx
mov [rsp+arg_1A0], rcx
mov [rsp+arg_19C], eax
jmp loc_1B76C
mov rcx, rax
mov eax, edx
mov [rsp+arg_1A0], rcx
mov [rsp+arg_19C], eax
jmp loc_1B70D
mov rcx, rax
mov eax, edx
mov [rsp+arg_1A0], rcx
mov [rsp+arg_19C], eax
jmp short loc_1B663
mov rcx, rax
mov eax, edx
mov [rsp+arg_1A0], rcx
mov [rsp+arg_19C], eax
lea rdi, [rsp+arg_90]; this
call _ZN2cv12_OutputArrayD2Ev; cv::_OutputArray::~_OutputArray()
loc_1B663:
lea rdi, [rsp+arg_A8]; this
call _ZN2cv11_InputArrayD2Ev; cv::_InputArray::~_InputArray()
jmp loc_1B70D
loc_1B675:
lea rdi, [rsp+1F8h+var_1C8]; this
lea rsi, [rsp+1F8h+var_D0]
call __ZNK2cv3Mat5cloneEv; cv::Mat::clone(void)
jmp short $+2
loc_1B689:
lea rdi, [rsp+1F8h+var_130]
lea rsi, [rsp+1F8h+var_1C8]
call __ZN2cv3MataSEOS0_; cv::Mat::operator=(cv::Mat&&)
jmp short $+2
loc_1B69D:
lea rdi, [rsp+1F8h+var_1C8]; this
call __ZN2cv3MatD1Ev; cv::Mat::~Mat()
jmp short loc_1B6C9
mov rcx, rax
mov eax, edx
mov [rsp+arg_1A0], rcx
mov [rsp+arg_19C], eax
lea rdi, [rsp+arg_28]; this
call __ZN2cv3MatD1Ev; cv::Mat::~Mat()
jmp short loc_1B70D
loc_1B6C9:
mov rdi, [rsp+1F8h+var_1E0]
lea rsi, [rsp+1F8h+var_130]
call _ZNSt6vectorIN2cv3MatESaIS1_EE9push_backERKS1_; std::vector<cv::Mat>::push_back(cv::Mat const&)
jmp short $+2
loc_1B6DD:
lea rdi, [rsp+1F8h+var_130]; this
call __ZN2cv3MatD1Ev; cv::Mat::~Mat()
lea rdi, [rsp+1F8h+var_D0]; this
call __ZN2cv3MatD1Ev; cv::Mat::~Mat()
mov eax, [rsp+1F8h+var_70]
add eax, 1
mov [rsp+1F8h+var_70], eax
jmp loc_1B4B5
loc_1B70D:
lea rdi, [rsp+arg_C0]; this
call __ZN2cv3MatD1Ev; cv::Mat::~Mat()
lea rdi, [rsp+arg_120]; this
call __ZN2cv3MatD1Ev; cv::Mat::~Mat()
jmp short loc_1B76C
loc_1B729:
mov [rsp+1F8h+var_69], 1
test [rsp+1F8h+var_69], 1
jnz short loc_1B745
mov rdi, [rsp+1F8h+var_1E0]
call _ZNSt6vectorIN2cv3MatESaIS1_EED2Ev; std::vector<cv::Mat>::~vector()
loc_1B745:
lea rdi, [rsp+1F8h+var_48]
call _ZNSt6vectorIlSaIlEED2Ev; std::vector<long>::~vector()
lea rdi, [rsp+1F8h+var_30]; this
call _ZN3Ort22TensorTypeAndShapeInfoD2Ev; Ort::TensorTypeAndShapeInfo::~TensorTypeAndShapeInfo()
mov rax, [rsp+1F8h+var_1D8]
add rsp, 1F8h
retn
loc_1B76C:
mov rdi, [rsp+arg_10]
call _ZNSt6vectorIN2cv3MatESaIS1_EED2Ev; std::vector<cv::Mat>::~vector()
loc_1B776:
lea rdi, [rsp+arg_1A8]
call _ZNSt6vectorIlSaIlEED2Ev; std::vector<long>::~vector()
loc_1B783:
lea rdi, [rsp+arg_1C0]; this
call _ZN3Ort22TensorTypeAndShapeInfoD2Ev; Ort::TensorTypeAndShapeInfo::~TensorTypeAndShapeInfo()
mov rdi, [rsp+arg_1A0]
call __Unwind_Resume
loc_1B79D:
nop dword ptr [rax]
| long long DepthAnything::postprocessBatch(
long long a1,
long long a2,
long long a3,
long long a4,
double a5,
__m128 _XMM1)
{
int v6; // edx
int v7; // ecx
int v8; // r8d
int v9; // r9d
long long v10; // rax
unsigned long long v13; // [rsp+0h] [rbp-1F8h]
std::runtime_error *exception; // [rsp+10h] [rbp-1E8h]
_BYTE v15[96]; // [rsp+30h] [rbp-1C8h] BYREF
_BYTE v16[8]; // [rsp+90h] [rbp-168h] BYREF
_BYTE v17[24]; // [rsp+98h] [rbp-160h] BYREF
_BYTE v18[24]; // [rsp+B0h] [rbp-148h] BYREF
_BYTE v19[96]; // [rsp+C8h] [rbp-130h] BYREF
_BYTE v20[16]; // [rsp+128h] [rbp-D0h] BYREF
long long v21; // [rsp+138h] [rbp-C0h]
int i; // [rsp+188h] [rbp-70h]
char v23; // [rsp+18Fh] [rbp-69h]
long long v24; // [rsp+190h] [rbp-68h]
int v25; // [rsp+198h] [rbp-60h]
int v26; // [rsp+19Ch] [rbp-5Ch]
int v27; // [rsp+1A0h] [rbp-58h]
_BYTE v28[24]; // [rsp+1B0h] [rbp-48h] BYREF
_BYTE v29[8]; // [rsp+1C8h] [rbp-30h] BYREF
long long Tensor; // [rsp+1D0h] [rbp-28h]
long long v31; // [rsp+1D8h] [rbp-20h]
long long v32; // [rsp+1E0h] [rbp-18h]
long long v33; // [rsp+1E8h] [rbp-10h]
long long v34; // [rsp+1F0h] [rbp-8h]
v34 = a1;
v33 = a2;
v32 = a3;
v31 = a4;
Tensor = Ort::detail::ConstValueImpl<OrtValue>::GetTensorData<float>(a4);
Ort::detail::ConstValueImpl<OrtValue>::GetTensorTypeAndShapeInfo(v29, v31);
Ort::detail::TensorTypeAndShapeInfoImpl<OrtTensorTypeAndShapeInfo>::GetShape(
(unsigned int)v28,
(unsigned int)v29,
v6,
v7,
v8,
v9);
if ( (unsigned long long)std::vector<long>::size(v28) < 3 || *(long long *)std::vector<long>::operator[](v28, 0LL) <= 0 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Invalid output tensor shape for batch processing.");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v27 = *(_DWORD *)std::vector<long>::operator[](v28, 0LL);
v26 = *(_DWORD *)std::vector<long>::operator[](v28, 1LL);
v25 = *(_DWORD *)std::vector<long>::operator[](v28, 2LL);
v24 = v25 * v26;
v23 = 0;
std::vector<cv::Mat>::vector(a1);
std::vector<cv::Mat>::reserve(a1, v27);
for ( i = 0; i < v27; ++i )
{
cv::Mat::Mat((cv::Mat *)v20, v26, v25, 5);
memcpy(v21, 4 * v24 * i + Tensor, 4 * v24);
cv::Mat::Mat((cv::Mat *)v19);
v13 = i;
if ( v13 >= std::vector<cv::Size_<int>>::size(v32) )
{
cv::Mat::clone((cv::Mat *)v15);
cv::Mat::operator=(v19, v15);
cv::Mat::~Mat((cv::Mat *)v15);
}
else
{
cv::_InputArray::_InputArray((cv::_InputArray *)v18, (const cv::Mat *)v20);
cv::_OutputArray::_OutputArray((cv::_OutputArray *)v17, (cv::Mat *)v19);
v10 = std::vector<cv::Size_<int>>::operator[](v32, i);
cv::Size_<int>::Size_(v16, v10);
__asm
{
vpxor xmm1, xmm1, xmm1
vmovaps xmm0, xmm1
}
cv::resize(v18, v17, v16, 1LL, *(double *)&_XMM0);
cv::_OutputArray::~_OutputArray((cv::_OutputArray *)v17);
cv::_InputArray::~_InputArray((cv::_InputArray *)v18);
}
std::vector<cv::Mat>::push_back(a1, v19);
cv::Mat::~Mat((cv::Mat *)v19);
cv::Mat::~Mat((cv::Mat *)v20);
}
v23 = 1;
std::vector<long>::~vector(v28);
Ort::TensorTypeAndShapeInfo::~TensorTypeAndShapeInfo((Ort::TensorTypeAndShapeInfo *)v29);
return a1;
}
| postprocessBatch:
SUB RSP,0x1f8
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x1f0],RDI
MOV qword ptr [RSP + 0x1e8],RSI
MOV qword ptr [RSP + 0x1e0],RDX
MOV qword ptr [RSP + 0x1d8],RCX
MOV RDI,qword ptr [RSP + 0x1d8]
CALL 0x001203a0
MOV qword ptr [RSP + 0x1d0],RAX
MOV RSI,qword ptr [RSP + 0x1d8]
LEA RDI,[RSP + 0x1c8]
MOV qword ptr [RSP + 0x28],RDI
CALL 0x001203e0
MOV RSI,qword ptr [RSP + 0x28]
LAB_0011b348:
LEA RDI,[RSP + 0x1b0]
CALL 0x00120450
LAB_0011b355:
JMP 0x0011b357
LAB_0011b357:
LEA RDI,[RSP + 0x1b0]
CALL 0x0011f480
CMP RAX,0x3
JC 0x0011b385
LEA RDI,[RSP + 0x1b0]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0011f4a0
CMP qword ptr [RAX],0x0
JG 0x0011b41a
LAB_0011b385:
MOV EDI,0x10
CALL 0x001191c0
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RSP + 0x10],RAX
LAB_0011b39a:
LEA RSI,[0x12d15a]
CALL 0x00119040
JMP 0x0011b3a8
LAB_0011b3a8:
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [0x00136fb8]
MOV RDX,qword ptr [0x00136ff8]
CALL 0x00119350
LAB_0011b41a:
XOR EAX,EAX
MOV ESI,EAX
LEA RDI,[RSP + 0x1b0]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x0011f4a0
MOV RDI,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RSP + 0x1a0],EAX
MOV ESI,0x1
CALL 0x0011f4a0
MOV RDI,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RSP + 0x19c],EAX
MOV ESI,0x2
CALL 0x0011f4a0
MOV RDI,qword ptr [RSP + 0x18]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RSP + 0x198],EAX
MOV EAX,dword ptr [RSP + 0x19c]
MOV ECX,dword ptr [RSP + 0x198]
IMUL EAX,ECX
CDQE
MOV qword ptr [RSP + 0x190],RAX
MOV byte ptr [RSP + 0x18f],0x0
CALL 0x0011fc70
MOV RDI,qword ptr [RSP + 0x18]
MOVSXD RSI,dword ptr [RSP + 0x1a0]
LAB_0011b4a3:
CALL 0x001200e0
JMP 0x0011b4aa
LAB_0011b4aa:
MOV dword ptr [RSP + 0x188],0x0
LAB_0011b4b5:
MOV EAX,dword ptr [RSP + 0x188]
CMP EAX,dword ptr [RSP + 0x1a0]
JGE 0x0011b729
MOV ESI,dword ptr [RSP + 0x19c]
MOV EDX,dword ptr [RSP + 0x198]
LEA RDI,[RSP + 0x128]
MOV ECX,0x5
CALL 0x00119470
LAB_0011b4e9:
JMP 0x0011b4eb
LAB_0011b4eb:
MOV RDI,qword ptr [RSP + 0x138]
MOV RSI,qword ptr [RSP + 0x1d0]
MOVSXD RAX,dword ptr [RSP + 0x188]
IMUL RAX,qword ptr [RSP + 0x190]
SHL RAX,0x2
ADD RSI,RAX
MOV RDX,qword ptr [RSP + 0x190]
SHL RDX,0x2
CALL 0x00119410
LEA RDI,[RSP + 0xc8]
CALL 0x00119050
MOVSXD RAX,dword ptr [RSP + 0x188]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x1e0]
CALL 0x00120590
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
CMP RAX,RCX
JNC 0x0011b675
LAB_0011b55a:
LEA RDI,[RSP + 0xb0]
LEA RSI,[RSP + 0x128]
CALL 0x0011fc80
JMP 0x0011b571
LAB_0011b571:
LEA RDI,[RSP + 0x98]
LEA RSI,[RSP + 0xc8]
CALL 0x0011fc00
JMP 0x0011b588
LAB_0011b588:
MOV RDI,qword ptr [RSP + 0x1e0]
MOVSXD RSI,dword ptr [RSP + 0x188]
CALL 0x001205b0
MOV RSI,RAX
LAB_0011b5a0:
LEA RDI,[RSP + 0x90]
CALL 0x0011fa40
JMP 0x0011b5af
LAB_0011b5af:
LEA RDI,[RSP + 0xb0]
LEA RSI,[RSP + 0x98]
LEA RDX,[RSP + 0x90]
VPXOR XMM1,XMM1,XMM1
MOV ECX,0x1
VMOVAPS XMM0,XMM1
CALL 0x00119510
JMP 0x0011b5db
LAB_0011b5db:
LEA RDI,[RSP + 0x98]
CALL 0x0011fc60
LEA RDI,[RSP + 0xb0]
CALL 0x0011fd00
JMP 0x0011b6c9
LAB_0011b675:
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x128]
CALL 0x00119120
JMP 0x0011b689
LAB_0011b689:
LEA RDI,[RSP + 0xc8]
LEA RSI,[RSP + 0x30]
CALL 0x00119070
JMP 0x0011b69d
LAB_0011b69d:
LEA RDI,[RSP + 0x30]
CALL 0x00119080
JMP 0x0011b6c9
LAB_0011b6c9:
MOV RDI,qword ptr [RSP + 0x18]
LEA RSI,[RSP + 0xc8]
CALL 0x001202d0
LAB_0011b6db:
JMP 0x0011b6dd
LAB_0011b6dd:
LEA RDI,[RSP + 0xc8]
CALL 0x00119080
LEA RDI,[RSP + 0x128]
CALL 0x00119080
MOV EAX,dword ptr [RSP + 0x188]
ADD EAX,0x1
MOV dword ptr [RSP + 0x188],EAX
JMP 0x0011b4b5
LAB_0011b729:
MOV byte ptr [RSP + 0x18f],0x1
TEST byte ptr [RSP + 0x18f],0x1
JNZ 0x0011b745
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x0011ff00
LAB_0011b745:
LEA RDI,[RSP + 0x1b0]
CALL 0x0011f820
LEA RDI,[RSP + 0x1c8]
CALL 0x00120580
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x1f8
RET
|
/* WARNING: Removing unreachable block (ram,0x0011b73b) */
/* DepthAnything::postprocessBatch(std::vector<cv::Size_<int>, std::allocator<cv::Size_<int> > >
const&, Ort::Value const&) */
vector * DepthAnything::postprocessBatch(vector *param_1,Value *param_2)
{
ulong uVar1;
long *plVar2;
runtime_error *this;
int *piVar3;
ulong uVar4;
Size_ *pSVar5;
ConstValueImpl<OrtValue> *in_RCX;
vector<cv::Size_<int>,std::allocator<cv::Size_<int>>> *in_RDX;
Mat local_1c8 [96];
Size_<int> local_168 [8];
_OutputArray local_160 [24];
_InputArray local_148 [24];
Mat local_130 [96];
Mat local_d0 [16];
void *local_c0;
int local_70;
int1 local_69;
long local_68;
int local_60;
int local_5c;
int local_58;
vector<long,std::allocator<long>> local_48 [24];
TensorTypeAndShapeInfo local_30 [8];
float *local_28;
vector<cv::Size_<int>,std::allocator<cv::Size_<int>>> *local_18;
Value *local_10;
vector *local_8;
local_18 = in_RDX;
local_10 = param_2;
local_8 = param_1;
local_28 = Ort::detail::ConstValueImpl<OrtValue>::GetTensorData<float>(in_RCX);
Ort::detail::ConstValueImpl<OrtValue>::GetTensorTypeAndShapeInfo();
/* try { // try from 0011b348 to 0011b354 has its CatchHandler @ 0011b3c5 */
Ort::detail::TensorTypeAndShapeInfoImpl<OrtTensorTypeAndShapeInfo>::GetShape();
uVar1 = std::vector<long,std::allocator<long>>::size(local_48);
if ((2 < uVar1) &&
(plVar2 = (long *)std::vector<long,std::allocator<long>>::operator[](local_48,0), 0 < *plVar2))
{
piVar3 = (int *)std::vector<long,std::allocator<long>>::operator[](local_48,0);
local_58 = *piVar3;
piVar3 = (int *)std::vector<long,std::allocator<long>>::operator[](local_48,1);
local_5c = *piVar3;
piVar3 = (int *)std::vector<long,std::allocator<long>>::operator[](local_48,2);
local_60 = *piVar3;
local_68 = (long)(local_5c * local_60);
local_69 = 0;
std::vector<cv::Mat,std::allocator<cv::Mat>>::vector
((vector<cv::Mat,std::allocator<cv::Mat>> *)param_1);
/* try { // try from 0011b4a3 to 0011b4e8 has its CatchHandler @ 0011b5fa */
std::vector<cv::Mat,std::allocator<cv::Mat>>::reserve
((vector<cv::Mat,std::allocator<cv::Mat>> *)param_1,(long)local_58);
for (local_70 = 0; local_70 < local_58; local_70 = local_70 + 1) {
cv::Mat::Mat(local_d0,local_5c,local_60,5);
memcpy(local_c0,local_28 + local_70 * local_68,local_68 << 2);
cv::Mat::Mat(local_130);
uVar1 = (ulong)local_70;
uVar4 = std::vector<cv::Size_<int>,std::allocator<cv::Size_<int>>>::size(local_18);
if (uVar1 < uVar4) {
/* try { // try from 0011b55a to 0011b56e has its CatchHandler @ 0011b613 */
cv::_InputArray::_InputArray(local_148,local_d0);
/* try { // try from 0011b571 to 0011b585 has its CatchHandler @ 0011b62c */
cv::_OutputArray::_OutputArray(local_160,local_130);
pSVar5 = (Size_ *)std::vector<cv::Size_<int>,std::allocator<cv::Size_<int>>>::operator[]
(local_18,(long)local_70);
/* try { // try from 0011b5a0 to 0011b5d8 has its CatchHandler @ 0011b642 */
cv::Size_<int>::Size_(local_168,pSVar5);
cv::resize(0,local_148,local_160,local_168,1);
cv::_OutputArray::~_OutputArray(local_160);
cv::_InputArray::~_InputArray(local_148);
}
else {
/* try { // try from 0011b675 to 0011b686 has its CatchHandler @ 0011b613 */
cv::Mat::clone();
/* try { // try from 0011b689 to 0011b69a has its CatchHandler @ 0011b6a9 */
cv::Mat::operator=(local_130,local_1c8);
cv::Mat::~Mat(local_1c8);
}
/* try { // try from 0011b6c9 to 0011b6da has its CatchHandler @ 0011b613 */
std::vector<cv::Mat,std::allocator<cv::Mat>>::push_back
((vector<cv::Mat,std::allocator<cv::Mat>> *)param_1,local_130);
cv::Mat::~Mat(local_130);
cv::Mat::~Mat(local_d0);
}
local_69 = 1;
std::vector<long,std::allocator<long>>::~vector(local_48);
Ort::TensorTypeAndShapeInfo::~TensorTypeAndShapeInfo(local_30);
return param_1;
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0011b39a to 0011b3a5 has its CatchHandler @ 0011b3de */
std::runtime_error::runtime_error(this,"Invalid output tensor shape for batch processing.");
/* try { // try from 0011b3a8 to 0011b3bf has its CatchHandler @ 0011b401 */
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_00136fb8,PTR__runtime_error_00136ff8);
}
| |
42,842 | Balloc | eloqsql/libmariadb/libmariadb/ma_dtoa.c | static Bigint *Balloc(int k, Stack_alloc *alloc)
{
Bigint *rv;
DBUG_ASSERT(k <= Kmax);
if (k <= Kmax && alloc->freelist[k])
{
rv= alloc->freelist[k];
alloc->freelist[k]= rv->p.next;
}
else
{
int x, len;
x= 1 << k;
len= MY_ALIGN(sizeof(Bigint) + x * sizeof(ULong), SIZEOF_CHARP);
if (alloc->free + len <= alloc->end)
{
rv= (Bigint*) alloc->free;
alloc->free+= len;
}
else
rv= (Bigint*) malloc(len);
rv->k= k;
rv->maxwds= x;
}
rv->sign= rv->wds= 0;
rv->p.x= (ULong*) (rv + 1);
return rv;
} | O0 | c | Balloc:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0xf, -0x4(%rbp)
jg 0x58eaf
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
cmpq $0x0, 0x18(%rax,%rcx,8)
je 0x58eaf
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq %rdx, 0x18(%rax,%rcx,8)
jmp 0x58f34
movl -0x4(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq $0x18, %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
ja 0x58f13
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
jmp 0x58f20
movslq -0x20(%rbp), %rdi
callq 0x368d0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x18(%rbp), %rcx
addq $0x18, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| Balloc:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
cmp [rbp+var_4], 0Fh
jg short loc_58EAF
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_4]
cmp qword ptr [rax+rcx*8+18h], 0
jz short loc_58EAF
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_4]
mov rax, [rax+rcx*8+18h]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rdx, [rax]
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_4]
mov [rax+rcx*8+18h], rdx
jmp loc_58F34
loc_58EAF:
mov ecx, [rbp+var_4]
mov eax, 1
shl eax, cl
mov [rbp+var_1C], eax
movsxd rax, [rbp+var_1C]
shl rax, 2
add rax, 18h
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_20], eax
mov rax, [rbp+var_10]
mov rax, [rax+8]
movsxd rcx, [rbp+var_20]
add rax, rcx
mov rcx, [rbp+var_10]
cmp rax, [rcx+10h]
ja short loc_58F13
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_18], rax
mov edx, [rbp+var_20]
mov rax, [rbp+var_10]
mov rcx, [rax+8]
movsxd rdx, edx
add rcx, rdx
mov [rax+8], rcx
jmp short loc_58F20
loc_58F13:
movsxd rdi, [rbp+var_20]
call _malloc
mov [rbp+var_18], rax
loc_58F20:
mov ecx, [rbp+var_4]
mov rax, [rbp+var_18]
mov [rax+8], ecx
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_18]
mov [rax+0Ch], ecx
loc_58F34:
mov rax, [rbp+var_18]
mov dword ptr [rax+14h], 0
mov rax, [rbp+var_18]
mov dword ptr [rax+10h], 0
mov rcx, [rbp+var_18]
add rcx, 18h
mov rax, [rbp+var_18]
mov [rax], rcx
mov rax, [rbp+var_18]
add rsp, 20h
pop rbp
retn
| long long Balloc(int a1, long long a2)
{
signed int v3; // [rsp+0h] [rbp-20h]
long long v4; // [rsp+8h] [rbp-18h]
if ( a1 <= 15 && *(_QWORD *)(a2 + 8LL * a1 + 24) )
{
v4 = *(_QWORD *)(a2 + 8LL * a1 + 24);
*(_QWORD *)(a2 + 8LL * a1 + 24) = *(_QWORD *)v4;
}
else
{
v3 = (4 * (1 << a1) + 31) & 0xFFFFFFF8;
if ( (unsigned long long)(v3 + *(_QWORD *)(a2 + 8)) > *(_QWORD *)(a2 + 16) )
{
v4 = malloc(v3);
}
else
{
v4 = *(_QWORD *)(a2 + 8);
*(_QWORD *)(a2 + 8) = v3 + v4;
}
*(_DWORD *)(v4 + 8) = a1;
*(_DWORD *)(v4 + 12) = 1 << a1;
}
*(_DWORD *)(v4 + 20) = 0;
*(_DWORD *)(v4 + 16) = 0;
*(_QWORD *)v4 = v4 + 24;
return v4;
}
| Balloc:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
CMP dword ptr [RBP + -0x4],0xf
JG 0x00158eaf
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x4]
CMP qword ptr [RAX + RCX*0x8 + 0x18],0x0
JZ 0x00158eaf
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x4]
MOV RAX,qword ptr [RAX + RCX*0x8 + 0x18]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x4]
MOV qword ptr [RAX + RCX*0x8 + 0x18],RDX
JMP 0x00158f34
LAB_00158eaf:
MOV ECX,dword ptr [RBP + -0x4]
MOV EAX,0x1
SHL EAX,CL
MOV dword ptr [RBP + -0x1c],EAX
MOVSXD RAX,dword ptr [RBP + -0x1c]
SHL RAX,0x2
ADD RAX,0x18
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
MOV dword ptr [RBP + -0x20],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOVSXD RCX,dword ptr [RBP + -0x20]
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x10]
JA 0x00158f13
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV EDX,dword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x8]
MOVSXD RDX,EDX
ADD RCX,RDX
MOV qword ptr [RAX + 0x8],RCX
JMP 0x00158f20
LAB_00158f13:
MOVSXD RDI,dword ptr [RBP + -0x20]
CALL 0x001368d0
MOV qword ptr [RBP + -0x18],RAX
LAB_00158f20:
MOV ECX,dword ptr [RBP + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x8],ECX
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0xc],ECX
LAB_00158f34:
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x14],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x10],0x0
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,0x18
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x20
POP RBP
RET
|
int8 * Balloc(int param_1,long param_2)
{
int iVar1;
uint uVar2;
int8 *local_20;
if ((param_1 < 0x10) && (*(long *)(param_2 + 0x18 + (long)param_1 * 8) != 0)) {
local_20 = *(int8 **)(param_2 + 0x18 + (long)param_1 * 8);
*(int8 *)(param_2 + 0x18 + (long)param_1 * 8) = *local_20;
}
else {
iVar1 = 1 << ((byte)param_1 & 0x1f);
uVar2 = iVar1 * 4 + 0x1fU & 0xfffffff8;
if (*(ulong *)(param_2 + 0x10) < (ulong)(*(long *)(param_2 + 8) + (long)(int)uVar2)) {
local_20 = (int8 *)malloc((long)(int)uVar2);
}
else {
local_20 = *(int8 **)(param_2 + 8);
*(long *)(param_2 + 8) = *(long *)(param_2 + 8) + (long)(int)uVar2;
}
*(int *)(local_20 + 1) = param_1;
*(int *)((long)local_20 + 0xc) = iVar1;
}
*(int4 *)((long)local_20 + 0x14) = 0;
*(int4 *)(local_20 + 2) = 0;
*local_20 = local_20 + 3;
return local_20;
}
| |
42,843 | minja::ElifTemplateToken::~ElifTemplateToken() | monkey531[P]llama/common/minja.hpp | ElifTemplateToken(const Location & location, SpaceHandling pre, SpaceHandling post, std::shared_ptr<Expression> && c) : TemplateToken(Type::Elif, location, pre, post), condition(std::move(c)) {} | O3 | cpp | minja::ElifTemplateToken::~ElifTemplateToken():
pushq %rbx
movq %rdi, %rbx
leaq 0x92ffd(%rip), %rax # 0x12eb68
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x9bb80
callq 0x7140a
leaq 0x92761(%rip), %rax # 0x12e2e8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x9bb9d
popq %rbx
jmp 0x7140a
popq %rbx
retq
nop
| _ZN5minja17ElifTemplateTokenD2Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja17ElifTemplateTokenE; `vtable for'minja::ElifTemplateToken
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+38h]
test rdi, rdi
jz short loc_9BB80
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9BB80:
lea rax, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_9BB9D
pop rbx
jmp _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9BB9D:
pop rbx
retn
| void minja::ElifTemplateToken::~ElifTemplateToken(minja::ElifTemplateToken *this)
{
volatile signed __int32 *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::ElifTemplateToken + 2;
v2 = (volatile signed __int32 *)*((_QWORD *)this + 7);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
*(_QWORD *)this = &`vtable for'minja::TemplateToken + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 3);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
}
| ~ElifTemplateToken:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x22eb68]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x38]
TEST RDI,RDI
JZ 0x0019bb80
CALL 0x0017140a
LAB_0019bb80:
LEA RAX,[0x22e2e8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x18]
TEST RDI,RDI
JZ 0x0019bb9d
POP RBX
JMP 0x0017140a
LAB_0019bb9d:
POP RBX
RET
|
/* minja::ElifTemplateToken::~ElifTemplateToken() */
void __thiscall minja::ElifTemplateToken::~ElifTemplateToken(ElifTemplateToken *this)
{
*(int ***)this = &PTR__ElifTemplateToken_0022eb78;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38));
}
*(int ***)this = &PTR__TemplateToken_0022e2f8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18));
return;
}
return;
}
| |
42,844 | gguf_get_arr_str | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | const char * gguf_get_arr_str(const struct gguf_context * ctx, int key_id, int i) {
GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
GGML_ASSERT(ctx->kv[key_id].type == GGUF_TYPE_ARRAY);
struct gguf_kv * kv = &ctx->kv[key_id];
struct gguf_str * str = &((struct gguf_str *) kv->value.arr.data)[i];
return str->data;
} | O1 | c | gguf_get_arr_str:
pushq %rax
testl %esi, %esi
js 0x9db99
cmpl %esi, 0x10(%rdi)
jle 0x9db99
movq 0x18(%rdi), %rax
movl %esi, %ecx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
cmpl $0x9, 0x10(%rax,%rcx)
jne 0x9db9e
addq %rcx, %rax
movq 0x28(%rax), %rax
movslq %edx, %rcx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %rax
popq %rcx
retq
callq 0x10cf9
callq 0x10d3e
| gguf_get_arr_str:
push rax
test esi, esi
js short loc_9DB99
cmp [rdi+10h], esi
jle short loc_9DB99
mov rax, [rdi+18h]
mov ecx, esi
lea rcx, [rcx+rcx*2]
shl rcx, 4
cmp dword ptr [rax+rcx+10h], 9
jnz short loc_9DB9E
add rax, rcx
mov rax, [rax+28h]
movsxd rcx, edx
shl rcx, 4
mov rax, [rax+rcx+8]
pop rcx
retn
loc_9DB99:
call gguf_get_arr_str_cold_1
loc_9DB9E:
call gguf_get_arr_str_cold_2
| long long gguf_get_arr_str(long long a1, int a2, int a3)
{
long long v3; // rax
long long v4; // rcx
if ( a2 < 0 || *(_DWORD *)(a1 + 16) <= a2 )
gguf_get_arr_str_cold_1(a1);
v3 = *(_QWORD *)(a1 + 24);
v4 = 48LL * (unsigned int)a2;
if ( *(_DWORD *)(v3 + v4 + 16) != 9 )
gguf_get_arr_str_cold_2(a1);
return *(_QWORD *)(*(_QWORD *)(v4 + v3 + 40) + 16LL * a3 + 8);
}
| |||
42,845 | gguf_get_arr_str | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | const char * gguf_get_arr_str(const struct gguf_context * ctx, int key_id, int i) {
GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
GGML_ASSERT(ctx->kv[key_id].type == GGUF_TYPE_ARRAY);
struct gguf_kv * kv = &ctx->kv[key_id];
struct gguf_str * str = &((struct gguf_str *) kv->value.arr.data)[i];
return str->data;
} | O2 | c | gguf_get_arr_str:
pushq %rax
testl %esi, %esi
js 0x7792e
cmpl %esi, 0x10(%rdi)
jle 0x7792e
movq 0x18(%rdi), %rax
movl %esi, %ecx
imulq $0x30, %rcx, %rcx
cmpl $0x9, 0x10(%rax,%rcx)
jne 0x77963
addq %rcx, %rax
movq 0x28(%rax), %rax
movslq %edx, %rcx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %rax
popq %rcx
retq
movq 0x5e613(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x5e664(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x228d0(%rip), %rsi # 0x9a21e
leaq 0x29f29(%rip), %rdx # 0xa187e
leaq 0x2b13f(%rip), %r8 # 0xa2a9b
movl $0x4b23, %ecx # imm = 0x4B23
jmp 0x77996
movq 0x5e5de(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x5e62f(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x2289b(%rip), %rsi # 0x9a21e
leaq 0x29ef4(%rip), %rdx # 0xa187e
leaq 0x2b135(%rip), %r8 # 0xa2ac6
movl $0x4b24, %ecx # imm = 0x4B24
xorl %eax, %eax
callq 0xa8b0
callq 0x67550
callq 0xa300
| gguf_get_arr_str:
push rax
test esi, esi
js short loc_7792E
cmp [rdi+10h], esi
jle short loc_7792E
mov rax, [rdi+18h]
mov ecx, esi
imul rcx, 30h ; '0'
cmp dword ptr [rax+rcx+10h], 9
jnz short loc_77963
add rax, rcx
mov rax, [rax+28h]
movsxd rcx, edx
shl rcx, 4
mov rax, [rax+rcx+8]
pop rcx
retn
loc_7792E:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aKeyId0KeyIdGgu; "key_id >= 0 && key_id < gguf_get_n_kv(c"...
mov ecx, 4B23h
jmp short loc_77996
loc_77963:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aCtxKvKeyIdType_0; "ctx->kv[key_id].type == GGUF_TYPE_ARRAY"
mov ecx, 4B24h
loc_77996:
xor eax, eax
call _fprintf
call ggml_print_backtrace
call _abort
| long long gguf_get_arr_str(long long a1, int a2, int a3)
{
long long v3; // rax
long long v4; // rcx
long long v6; // rdi
if ( a2 < 0 || *(_DWORD *)(a1 + 16) <= a2 )
{
fflush(stdout);
v6 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
19235LL,
"key_id >= 0 && key_id < gguf_get_n_kv(ctx)");
goto LABEL_7;
}
v3 = *(_QWORD *)(a1 + 24);
v4 = 48LL * (unsigned int)a2;
if ( *(_DWORD *)(v3 + v4 + 16) != 9 )
{
fflush(stdout);
v6 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
19236LL,
"ctx->kv[key_id].type == GGUF_TYPE_ARRAY");
LABEL_7:
ggml_print_backtrace();
abort(v6);
}
return *(_QWORD *)(*(_QWORD *)(v4 + v3 + 40) + 16LL * a3 + 8);
}
| gguf_get_arr_str:
PUSH RAX
TEST ESI,ESI
JS 0x0017792e
CMP dword ptr [RDI + 0x10],ESI
JLE 0x0017792e
MOV RAX,qword ptr [RDI + 0x18]
MOV ECX,ESI
IMUL RCX,RCX,0x30
CMP dword ptr [RAX + RCX*0x1 + 0x10],0x9
JNZ 0x00177963
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x28]
MOVSXD RCX,EDX
SHL RCX,0x4
MOV RAX,qword ptr [RAX + RCX*0x1 + 0x8]
POP RCX
RET
LAB_0017792e:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a2a9b]
MOV ECX,0x4b23
JMP 0x00177996
LAB_00177963:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a2ac6]
MOV ECX,0x4b24
LAB_00177996:
XOR EAX,EAX
CALL 0x0010a8b0
CALL 0x00167550
CALL 0x0010a300
|
int8 gguf_get_arr_str(long param_1,uint param_2,int param_3)
{
int8 uVar1;
FILE *__stream;
char *pcVar2;
if (((int)param_2 < 0) || (*(int *)(param_1 + 0x10) <= (int)param_2)) {
fflush(*(FILE **)PTR_stdout_001d5f48);
__stream = *(FILE **)PTR_stderr_001d5fa8;
pcVar2 = "key_id >= 0 && key_id < gguf_get_n_kv(ctx)";
uVar1 = 0x4b23;
}
else {
if (*(int *)(*(long *)(param_1 + 0x18) + 0x10 + (ulong)param_2 * 0x30) == 9) {
return *(int8 *)
(*(long *)(*(long *)(param_1 + 0x18) + (ulong)param_2 * 0x30 + 0x28) + 8 +
(long)param_3 * 0x10);
}
fflush(*(FILE **)PTR_stdout_001d5f48);
__stream = *(FILE **)PTR_stderr_001d5fa8;
pcVar2 = "ctx->kv[key_id].type == GGUF_TYPE_ARRAY";
uVar1 = 0x4b24;
}
fprintf(__stream,"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
uVar1,pcVar2);
ggml_print_backtrace();
/* WARNING: Subroutine does not return */
abort();
}
| |
42,846 | my_coll_parser_scan_shift | eloqsql/strings/ctype-uca.c | static int
my_coll_parser_scan_shift(MY_COLL_RULE_PARSER *p)
{
if (my_coll_parser_curr(p)->term == MY_COLL_LEXEM_SHIFT)
{
my_coll_rule_shift_at_level(&p->rule, my_coll_parser_curr(p)->diff);
return my_coll_parser_scan(p);
}
return 0;
} | O3 | c | my_coll_parser_scan_shift:
xorl %eax, %eax
cmpl $0x1, (%rdi)
jne 0xbd182
movl 0x20(%rdi), %eax
decl %eax
cmpl $0x3, %eax
ja 0xbd155
leaq 0x1aab1c(%rip), %rcx # 0x267c20
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
incl 0xd0(%rdi)
movl $0x0, 0xdc(%rdi)
movq $0x0, 0xd4(%rdi)
jmp 0xbd155
incl 0xd8(%rdi)
movl $0x0, 0xdc(%rdi)
jmp 0xbd155
incl 0xdc(%rdi)
jmp 0xbd155
incl 0xd4(%rdi)
movq $0x0, 0xd8(%rdi)
pushq %rbp
movq %rsp, %rbp
leaq 0x28(%rdi), %rax
movq 0x48(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movups 0x28(%rdi), %xmm0
movups 0x38(%rdi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rax, %rdi
callq 0xbce4f
movl $0x1, %eax
popq %rbp
retq
| my_coll_parser_scan_shift:
xor eax, eax
cmp dword ptr [rdi], 1
jnz locret_BD182
mov eax, [rdi+20h]
dec eax; switch 4 cases
cmp eax, 3
ja short def_BD10B; jumptable 00000000000BD10B default case
lea rcx, jpt_BD10B
movsxd rax, ds:(jpt_BD10B - 267C20h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_BD10D:
inc dword ptr [rdi+0D0h]; jumptable 00000000000BD10B case 1
mov dword ptr [rdi+0DCh], 0
mov qword ptr [rdi+0D4h], 0
jmp short def_BD10B; jumptable 00000000000BD10B default case
loc_BD12A:
inc dword ptr [rdi+0D8h]; jumptable 00000000000BD10B case 3
mov dword ptr [rdi+0DCh], 0
jmp short def_BD10B; jumptable 00000000000BD10B default case
loc_BD13C:
inc dword ptr [rdi+0DCh]; jumptable 00000000000BD10B case 4
jmp short def_BD10B; jumptable 00000000000BD10B default case
loc_BD144:
inc dword ptr [rdi+0D4h]; jumptable 00000000000BD10B case 2
mov qword ptr [rdi+0D8h], 0
def_BD10B:
push rbp; jumptable 00000000000BD10B default case
mov rbp, rsp
lea rax, [rdi+28h]
mov rcx, [rdi+48h]
mov [rdi+20h], rcx
movups xmm0, xmmword ptr [rdi+28h]
movups xmm1, xmmword ptr [rdi+38h]
movups xmmword ptr [rdi+10h], xmm1
movups xmmword ptr [rdi], xmm0
mov rdi, rax
call my_coll_lexem_next
mov eax, 1
pop rbp
locret_BD182:
retn
| long long my_coll_parser_scan_shift(long long a1)
{
long long result; // rax
__int128 v2; // xmm0
result = 0LL;
if ( *(_DWORD *)a1 == 1 )
{
switch ( *(_DWORD *)(a1 + 32) )
{
case 1:
++*(_DWORD *)(a1 + 208);
*(_DWORD *)(a1 + 220) = 0;
*(_QWORD *)(a1 + 212) = 0LL;
break;
case 2:
++*(_DWORD *)(a1 + 212);
*(_QWORD *)(a1 + 216) = 0LL;
break;
case 3:
++*(_DWORD *)(a1 + 216);
*(_DWORD *)(a1 + 220) = 0;
break;
case 4:
++*(_DWORD *)(a1 + 220);
break;
default:
break;
}
*(_QWORD *)(a1 + 32) = *(_QWORD *)(a1 + 72);
v2 = *(_OWORD *)(a1 + 40);
*(_OWORD *)(a1 + 16) = *(_OWORD *)(a1 + 56);
*(_OWORD *)a1 = v2;
my_coll_lexem_next(a1 + 40);
return 1LL;
}
return result;
}
| my_coll_parser_scan_shift:
XOR EAX,EAX
CMP dword ptr [RDI],0x1
JNZ 0x001bd182
MOV EAX,dword ptr [RDI + 0x20]
DEC EAX
CMP EAX,0x3
JA 0x001bd155
LEA RCX,[0x367c20]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
INC dword ptr [RDI + 0xd0]
MOV dword ptr [RDI + 0xdc],0x0
MOV qword ptr [RDI + 0xd4],0x0
JMP 0x001bd155
caseD_3:
INC dword ptr [RDI + 0xd8]
MOV dword ptr [RDI + 0xdc],0x0
JMP 0x001bd155
caseD_4:
INC dword ptr [RDI + 0xdc]
JMP 0x001bd155
caseD_2:
INC dword ptr [RDI + 0xd4]
MOV qword ptr [RDI + 0xd8],0x0
default:
PUSH RBP
MOV RBP,RSP
LEA RAX,[RDI + 0x28]
MOV RCX,qword ptr [RDI + 0x48]
MOV qword ptr [RDI + 0x20],RCX
MOVUPS XMM0,xmmword ptr [RDI + 0x28]
MOVUPS XMM1,xmmword ptr [RDI + 0x38]
MOVUPS xmmword ptr [RDI + 0x10],XMM1
MOVUPS xmmword ptr [RDI],XMM0
MOV RDI,RAX
CALL 0x001bce4f
MOV EAX,0x1
POP RBP
LAB_001bd182:
RET
|
int8 my_coll_parser_scan_shift(int *param_1)
{
int8 uVar1;
uVar1 = 0;
if (*param_1 == 1) {
switch(param_1[8]) {
case 1:
param_1[0x34] = param_1[0x34] + 1;
param_1[0x37] = 0;
param_1[0x35] = 0;
param_1[0x36] = 0;
break;
case 2:
param_1[0x35] = param_1[0x35] + 1;
param_1[0x36] = 0;
param_1[0x37] = 0;
break;
case 3:
param_1[0x36] = param_1[0x36] + 1;
param_1[0x37] = 0;
break;
case 4:
param_1[0x37] = param_1[0x37] + 1;
}
*(int8 *)(param_1 + 8) = *(int8 *)(param_1 + 0x12);
param_1[4] = param_1[0xe];
param_1[5] = param_1[0xf];
param_1[6] = param_1[0x10];
param_1[7] = param_1[0x11];
*param_1 = param_1[10];
param_1[1] = param_1[0xb];
param_1[2] = param_1[0xc];
param_1[3] = param_1[0xd];
my_coll_lexem_next(param_1 + 10);
uVar1 = 1;
}
return uVar1;
}
| |
42,847 | get_default_configuration_dirs | eloqsql/libmariadb/libmariadb/ma_default.c | char **get_default_configuration_dirs()
{
#ifdef _WIN32
char dirname[FN_REFLEN];
#endif
char *env;
configuration_dirs= (char **)calloc(1, (MAX_CONFIG_DIRS + 1) * sizeof(char *));
if (!configuration_dirs)
goto end;
#ifdef _WIN32
/* On Windows operating systems configuration files are stored in
1. System Windows directory
2. System directory
3. Windows directory
4. C:\
*/
if (!GetSystemWindowsDirectory(dirname, FN_REFLEN) ||
add_cfg_dir(configuration_dirs, dirname))
goto error;
if (!GetWindowsDirectory(dirname, FN_REFLEN) ||
add_cfg_dir(configuration_dirs, dirname))
goto error;
if (add_cfg_dir(configuration_dirs, "C:"))
goto error;
if (GetModuleFileName(NULL, dirname, FN_REFLEN))
{
PathRemoveFileSpec(dirname);
if (add_cfg_dir(configuration_dirs, dirname))
goto error;
}
#else
/* on *nix platforms configuration files are stored in
1. SYSCONFDIR (if build happens inside server package, or
-DDEFAULT_SYSCONFDIR was specified
2. /etc
3. /etc/mysql
*/
#ifdef DEFAULT_SYSCONFDIR
if (add_cfg_dir(configuration_dirs, DEFAULT_SYSCONFDIR))
goto error;
#else
if (add_cfg_dir(configuration_dirs, "/etc"))
goto error;
if (add_cfg_dir(configuration_dirs, "/etc/mysql"))
goto error;
#endif
#endif
/* CONC-537: Read configuration files from MYSQL_HOME directory only if
MARIADB_HOME was not set */
if (!(env= getenv("MARIADB_HOME")))
env= getenv("MYSQL_HOME");
if (env && add_cfg_dir(configuration_dirs, env))
goto error;
end:
return configuration_dirs;
error:
return NULL;
} | O3 | c | get_default_configuration_dirs:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl $0x1, %edi
movl $0x38, %esi
callq 0x132e0
movq %rax, %rbx
leaq 0x19d63(%rip), %rax # 0x4db10
movq %rbx, (%rax)
testq %rbx, %rbx
je 0x33e0e
leaq 0x5ebc(%rip), %rsi # 0x39c78
movq %rbx, %rdi
callq 0x33e18
testl %eax, %eax
jne 0x33e0c
leaq 0x5eae(%rip), %rsi # 0x39c7d
movq %rbx, %rdi
callq 0x33e18
testl %eax, %eax
jne 0x33e0c
leaq 0x5ea6(%rip), %rdi # 0x39c88
callq 0x13590
testq %rax, %rax
jne 0x33dfd
leaq 0x5ea2(%rip), %rdi # 0x39c95
callq 0x13590
testq %rax, %rax
je 0x33e0e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x33e18
testl %eax, %eax
je 0x33e0e
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| get_default_configuration_dirs:
push rbp
mov rbp, rsp
push rbx
push rax
mov edi, 1
mov esi, 38h ; '8'
call _calloc
mov rbx, rax
lea rax, configuration_dirs
mov [rax], rbx
test rbx, rbx
jz short loc_33E0E
lea rsi, aEtc; "/etc"
mov rdi, rbx
call add_cfg_dir
test eax, eax
jnz short loc_33E0C
lea rsi, aEtcMysql; "/etc/mysql"
mov rdi, rbx
call add_cfg_dir
test eax, eax
jnz short loc_33E0C
lea rdi, aMariadbHome; "MARIADB_HOME"
call _getenv
test rax, rax
jnz short loc_33DFD
lea rdi, aMysqlHome; "MYSQL_HOME"
call _getenv
test rax, rax
jz short loc_33E0E
loc_33DFD:
mov rdi, rbx
mov rsi, rax
call add_cfg_dir
test eax, eax
jz short loc_33E0E
loc_33E0C:
xor ebx, ebx
loc_33E0E:
mov rax, rbx
add rsp, 8
pop rbx
pop rbp
retn
| long long get_default_configuration_dirs()
{
long long v0; // rbx
long long v1; // rax
v0 = calloc(1LL, 56LL);
configuration_dirs = v0;
if ( v0 )
{
if ( (unsigned int)add_cfg_dir(v0, "/etc") || (unsigned int)add_cfg_dir(v0, "/etc/mysql") )
return 0LL;
v1 = getenv("MARIADB_HOME");
if ( v1 || (v1 = getenv("MYSQL_HOME")) != 0 )
{
if ( (unsigned int)add_cfg_dir(v0, v1) )
return 0LL;
}
}
return v0;
}
| get_default_configuration_dirs:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV EDI,0x1
MOV ESI,0x38
CALL 0x001132e0
MOV RBX,RAX
LEA RAX,[0x14db10]
MOV qword ptr [RAX],RBX
TEST RBX,RBX
JZ 0x00133e0e
LEA RSI,[0x139c78]
MOV RDI,RBX
CALL 0x00133e18
TEST EAX,EAX
JNZ 0x00133e0c
LEA RSI,[0x139c7d]
MOV RDI,RBX
CALL 0x00133e18
TEST EAX,EAX
JNZ 0x00133e0c
LEA RDI,[0x139c88]
CALL 0x00113590
TEST RAX,RAX
JNZ 0x00133dfd
LEA RDI,[0x139c95]
CALL 0x00113590
TEST RAX,RAX
JZ 0x00133e0e
LAB_00133dfd:
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00133e18
TEST EAX,EAX
JZ 0x00133e0e
LAB_00133e0c:
XOR EBX,EBX
LAB_00133e0e:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void * get_default_configuration_dirs(void)
{
int iVar1;
void *pvVar2;
char *pcVar3;
pvVar2 = calloc(1,0x38);
configuration_dirs = pvVar2;
if (pvVar2 != (void *)0x0) {
iVar1 = add_cfg_dir(pvVar2,&DAT_00139c78);
if ((iVar1 == 0) && (iVar1 = add_cfg_dir(pvVar2,"/etc/mysql"), iVar1 == 0)) {
pcVar3 = getenv("MARIADB_HOME");
if ((pcVar3 == (char *)0x0) && (pcVar3 = getenv("MYSQL_HOME"), pcVar3 == (char *)0x0)) {
return pvVar2;
}
iVar1 = add_cfg_dir(pvVar2,pcVar3);
if (iVar1 == 0) {
return pvVar2;
}
}
pvVar2 = (void *)0x0;
}
return pvVar2;
}
| |
42,848 | google::protobuf::io::EpsCopyOutputStream::GetDirectBufferForNBytesAndAdvance(int, unsigned char**) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/coded_stream.cc | uint8_t* EpsCopyOutputStream::GetDirectBufferForNBytesAndAdvance(int size,
uint8_t** pp) {
if (had_error_) {
*pp = buffer_;
return nullptr;
}
int s = Flush(*pp);
if (had_error_) {
*pp = buffer_;
return nullptr;
}
if (s >= size) {
auto res = buffer_end_;
*pp = SetInitialBuffer(buffer_end_ + size, s - size);
return res;
} else {
*pp = SetInitialBuffer(buffer_end_, s);
return nullptr;
}
} | O0 | cpp | google::protobuf::io::EpsCopyOutputStream::GetDirectBufferForNBytesAndAdvance(int, unsigned char**):
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x38(%rax)
je 0x20ddf
movq (%rsp), %rcx
addq $0x10, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq $0x0, 0x30(%rsp)
jmp 0x20e87
movq (%rsp), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
callq 0x206a0
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x14(%rsp)
testb $0x1, 0x38(%rax)
je 0x20e1b
movq (%rsp), %rcx
addq $0x10, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq $0x0, 0x30(%rsp)
jmp 0x20e87
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
jl 0x20e62
movq (%rsp), %rdi
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rdi), %rsi
movslq 0x24(%rsp), %rax
addq %rax, %rsi
movl 0x14(%rsp), %edx
subl 0x24(%rsp), %edx
callq 0x1d460
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x20e87
movq (%rsp), %rdi
movq 0x8(%rdi), %rsi
movl 0x14(%rsp), %edx
callq 0x1d460
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZN6google8protobuf2io19EpsCopyOutputStream34GetDirectBufferForNBytesAndAdvanceEiPPh:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_14], esi
mov [rsp+38h+var_20], rdx
mov rax, [rsp+38h+var_10]
mov [rsp+38h+var_38], rax
test byte ptr [rax+38h], 1
jz short loc_20DDF
mov rcx, [rsp+38h+var_38]
add rcx, 10h
mov rax, [rsp+38h+var_20]
mov [rax], rcx
mov [rsp+38h+var_8], 0
jmp loc_20E87
loc_20DDF:
mov rdi, [rsp+38h+var_38]; this
mov rax, [rsp+38h+var_20]
mov rsi, [rax]; unsigned __int8 *
call _ZN6google8protobuf2io19EpsCopyOutputStream5FlushEPh; google::protobuf::io::EpsCopyOutputStream::Flush(uchar *)
mov ecx, eax
mov rax, [rsp+38h+var_38]
mov [rsp+38h+var_24], ecx
test byte ptr [rax+38h], 1
jz short loc_20E1B
mov rcx, [rsp+38h+var_38]
add rcx, 10h
mov rax, [rsp+38h+var_20]
mov [rax], rcx
mov [rsp+38h+var_8], 0
jmp short loc_20E87
loc_20E1B:
mov eax, [rsp+38h+var_24]
cmp eax, [rsp+38h+var_14]
jl short loc_20E62
mov rdi, [rsp+38h+var_38]; this
mov rax, [rdi+8]
mov [rsp+38h+var_30], rax
mov rsi, [rdi+8]
movsxd rax, [rsp+38h+var_14]
add rsi, rax; void *
mov edx, [rsp+38h+var_24]
sub edx, [rsp+38h+var_14]; int
call _ZN6google8protobuf2io19EpsCopyOutputStream16SetInitialBufferEPvi; google::protobuf::io::EpsCopyOutputStream::SetInitialBuffer(void *,int)
mov rcx, rax
mov rax, [rsp+38h+var_20]
mov [rax], rcx
mov rax, [rsp+38h+var_30]
mov [rsp+38h+var_8], rax
jmp short loc_20E87
loc_20E62:
mov rdi, [rsp+38h+var_38]; this
mov rsi, [rdi+8]; void *
mov edx, [rsp+38h+var_24]; int
call _ZN6google8protobuf2io19EpsCopyOutputStream16SetInitialBufferEPvi; google::protobuf::io::EpsCopyOutputStream::SetInitialBuffer(void *,int)
mov rcx, rax
mov rax, [rsp+38h+var_20]
mov [rax], rcx
mov [rsp+38h+var_8], 0
loc_20E87:
mov rax, [rsp+38h+var_8]
add rsp, 38h
retn
| char * google::protobuf::io::EpsCopyOutputStream::GetDirectBufferForNBytesAndAdvance(
char **this,
int a2,
unsigned __int8 **a3)
{
int v3; // ecx
char *v5; // [rsp+8h] [rbp-30h]
if ( ((_BYTE)this[7] & 1) != 0 )
{
*a3 = (unsigned __int8 *)(this + 2);
return 0LL;
}
else
{
v3 = google::protobuf::io::EpsCopyOutputStream::Flush((google::protobuf::io::EpsCopyOutputStream *)this, *a3);
if ( ((_BYTE)this[7] & 1) != 0 )
{
*a3 = (unsigned __int8 *)(this + 2);
return 0LL;
}
else if ( v3 < a2 )
{
*a3 = (unsigned __int8 *)google::protobuf::io::EpsCopyOutputStream::SetInitialBuffer(
(google::protobuf::io::EpsCopyOutputStream *)this,
this[1],
v3);
return 0LL;
}
else
{
v5 = this[1];
*a3 = (unsigned __int8 *)google::protobuf::io::EpsCopyOutputStream::SetInitialBuffer(
(google::protobuf::io::EpsCopyOutputStream *)this,
&v5[a2],
v3 - a2);
return v5;
}
}
}
| GetDirectBufferForNBytesAndAdvance:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV dword ptr [RSP + 0x24],ESI
MOV qword ptr [RSP + 0x18],RDX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP],RAX
TEST byte ptr [RAX + 0x38],0x1
JZ 0x00120ddf
MOV RCX,qword ptr [RSP]
ADD RCX,0x10
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX],RCX
MOV qword ptr [RSP + 0x30],0x0
JMP 0x00120e87
LAB_00120ddf:
MOV RDI,qword ptr [RSP]
MOV RAX,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RAX]
CALL 0x001206a0
MOV ECX,EAX
MOV RAX,qword ptr [RSP]
MOV dword ptr [RSP + 0x14],ECX
TEST byte ptr [RAX + 0x38],0x1
JZ 0x00120e1b
MOV RCX,qword ptr [RSP]
ADD RCX,0x10
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX],RCX
MOV qword ptr [RSP + 0x30],0x0
JMP 0x00120e87
LAB_00120e1b:
MOV EAX,dword ptr [RSP + 0x14]
CMP EAX,dword ptr [RSP + 0x24]
JL 0x00120e62
MOV RDI,qword ptr [RSP]
MOV RAX,qword ptr [RDI + 0x8]
MOV qword ptr [RSP + 0x8],RAX
MOV RSI,qword ptr [RDI + 0x8]
MOVSXD RAX,dword ptr [RSP + 0x24]
ADD RSI,RAX
MOV EDX,dword ptr [RSP + 0x14]
SUB EDX,dword ptr [RSP + 0x24]
CALL 0x0011d460
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x30],RAX
JMP 0x00120e87
LAB_00120e62:
MOV RDI,qword ptr [RSP]
MOV RSI,qword ptr [RDI + 0x8]
MOV EDX,dword ptr [RSP + 0x14]
CALL 0x0011d460
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX],RCX
MOV qword ptr [RSP + 0x30],0x0
LAB_00120e87:
MOV RAX,qword ptr [RSP + 0x30]
ADD RSP,0x38
RET
|
/* google::protobuf::io::EpsCopyOutputStream::GetDirectBufferForNBytesAndAdvance(int, unsigned
char**) */
int8 __thiscall
google::protobuf::io::EpsCopyOutputStream::GetDirectBufferForNBytesAndAdvance
(EpsCopyOutputStream *this,int param_1,uchar **param_2)
{
int iVar1;
uchar *puVar2;
int8 local_8;
if (((byte)this[0x38] & 1) == 0) {
iVar1 = Flush(this,*param_2);
if (((byte)this[0x38] & 1) == 0) {
if (iVar1 < param_1) {
puVar2 = (uchar *)SetInitialBuffer(this,*(void **)(this + 8),iVar1);
*param_2 = puVar2;
local_8 = 0;
}
else {
local_8 = *(int8 *)(this + 8);
puVar2 = (uchar *)SetInitialBuffer(this,(void *)(*(long *)(this + 8) + (long)param_1),
iVar1 - param_1);
*param_2 = puVar2;
}
}
else {
*param_2 = (uchar *)(this + 0x10);
local_8 = 0;
}
}
else {
*param_2 = (uchar *)(this + 0x10);
local_8 = 0;
}
return local_8;
}
| |
42,849 | my_error_unregister_all | eloqsql/mysys/my_error.c | void my_error_unregister_all(void)
{
struct my_err_head *cursor, *saved_next;
for (cursor= my_errmsgs_globerrs.meh_next; cursor != NULL; cursor= saved_next)
{
/* We need this ptr, but we're about to free its container, so save it. */
saved_next= cursor->meh_next;
my_free(cursor);
}
my_errmsgs_globerrs.meh_next= NULL; /* Freed in first iteration above. */
my_errmsgs_list= &my_errmsgs_globerrs;
} | O0 | c | my_error_unregister_all:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x1cfc59(%rip), %rax # 0x2c77d8
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf7ba8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xfb710
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf7b83
movq $0x0, 0x1cfc25(%rip) # 0x2c77d8
leaq 0x1cfc1e(%rip), %rax # 0x2c77d8
movq %rax, 0x1cfc0f(%rip) # 0x2c77d0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| my_error_unregister_all:
push rbp
mov rbp, rsp
sub rsp, 10h
mov rax, cs:my_errmsgs_globerrs
mov [rbp+var_8], rax
loc_F7B83:
cmp [rbp+var_8], 0
jz short loc_F7BA8
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_10], rax
mov rdi, [rbp+var_8]
call my_free
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
jmp short loc_F7B83
loc_F7BA8:
mov cs:my_errmsgs_globerrs, 0
lea rax, my_errmsgs_globerrs
mov cs:my_errmsgs_list, rax
add rsp, 10h
pop rbp
retn
| long long *my_error_unregister_all()
{
long long *result; // rax
_QWORD *v1; // [rsp+0h] [rbp-10h]
_QWORD *i; // [rsp+8h] [rbp-8h]
for ( i = (_QWORD *)my_errmsgs_globerrs; i; i = v1 )
{
v1 = (_QWORD *)*i;
my_free(i);
}
my_errmsgs_globerrs = 0LL;
result = &my_errmsgs_globerrs;
my_errmsgs_list = &my_errmsgs_globerrs;
return result;
}
| my_error_unregister_all:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr [0x003c77d8]
MOV qword ptr [RBP + -0x8],RAX
LAB_001f7b83:
CMP qword ptr [RBP + -0x8],0x0
JZ 0x001f7ba8
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001fb710
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001f7b83
LAB_001f7ba8:
MOV qword ptr [0x003c77d8],0x0
LEA RAX,[0x3c77d8]
MOV qword ptr [0x003c77d0],RAX
ADD RSP,0x10
POP RBP
RET
|
void my_error_unregister_all(void)
{
int8 *puVar1;
int8 *local_10;
local_10 = my_errmsgs_globerrs;
while (local_10 != (int8 *)0x0) {
puVar1 = (int8 *)*local_10;
my_free(local_10);
local_10 = puVar1;
}
my_errmsgs_globerrs = (int8 *)0x0;
my_errmsgs_list = (int *)&my_errmsgs_globerrs;
return;
}
| |
42,850 | get_charset_name | eloqsql/mysys/charset.c | const char *get_charset_name(uint charset_number)
{
my_pthread_once(&charsets_initialized, init_available_charsets);
if (charset_number < array_elements(all_charsets))
{
CHARSET_INFO *cs= all_charsets[charset_number];
if (cs && (cs->number == charset_number) && cs->coll_name.str)
return cs->coll_name.str;
}
return "?"; /* this mimics find_type() */
} | O3 | c | get_charset_name:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0xba93c2(%rip), %rdi # 0xc5af30
leaq -0x302(%rip), %rsi # 0xb1873
callq 0x2b250
leaq 0x50202(%rip), %rcx # 0x101d83
cmpl $0x7ff, %ebx # imm = 0x7FF
ja 0xb1ba8
movl %ebx, %eax
leaq 0xba132e(%rip), %rdx # 0xc52ec0
movq (%rdx,%rax,8), %rax
testq %rax, %rax
je 0xb1ba8
cmpl %ebx, (%rax)
jne 0xb1ba8
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0xb1bab
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| get_charset_name:
push rbp
mov rbp, rsp
push rbx
push rax
mov ebx, edi
lea rdi, charsets_initialized
lea rsi, init_available_charsets
call _pthread_once
lea rcx, asc_101D83; "?"
cmp ebx, 7FFh
ja short loc_B1BA8
mov eax, ebx
lea rdx, all_charsets
mov rax, [rdx+rax*8]
test rax, rax
jz short loc_B1BA8
cmp [rax], ebx
jnz short loc_B1BA8
mov rax, [rax+20h]
test rax, rax
jnz short loc_B1BAB
loc_B1BA8:
mov rax, rcx
loc_B1BAB:
add rsp, 8
pop rbx
pop rbp
retn
| const char * get_charset_name(unsigned int a1)
{
long long v1; // rax
const char *result; // rax
pthread_once(&charsets_initialized, init_available_charsets);
if ( a1 > 0x7FF )
return "?";
v1 = all_charsets[a1];
if ( !v1 )
return "?";
if ( *(_DWORD *)v1 != a1 )
return "?";
result = *(const char **)(v1 + 32);
if ( !result )
return "?";
return result;
}
| get_charset_name:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV EBX,EDI
LEA RDI,[0xd5af30]
LEA RSI,[0x1b1873]
CALL 0x0012b250
LEA RCX,[0x201d83]
CMP EBX,0x7ff
JA 0x001b1ba8
MOV EAX,EBX
LEA RDX,[0xd52ec0]
MOV RAX,qword ptr [RDX + RAX*0x8]
TEST RAX,RAX
JZ 0x001b1ba8
CMP dword ptr [RAX],EBX
JNZ 0x001b1ba8
MOV RAX,qword ptr [RAX + 0x20]
TEST RAX,RAX
JNZ 0x001b1bab
LAB_001b1ba8:
MOV RAX,RCX
LAB_001b1bab:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int * get_charset_name(uint param_1)
{
uint *puVar1;
int *puVar2;
pthread_once(&charsets_initialized,init_available_charsets);
if ((((0x7ff < param_1) || (puVar1 = (uint *)(&all_charsets)[param_1], puVar1 == (uint *)0x0)) ||
(*puVar1 != param_1)) || (puVar2 = *(int **)(puVar1 + 8), puVar2 == (int *)0x0)) {
puVar2 = &DAT_00201d83;
}
return puVar2;
}
| |
42,851 | mysql_once_init | eloqsql/libmariadb/libmariadb/mariadb_lib.c | static int mysql_once_init()
#else
static void mysql_once_init()
#endif
{
ma_init(); /* Will init threads */
init_client_errs();
get_default_configuration_dirs();
set_default_charset_by_name(MARIADB_DEFAULT_CHARSET, 0);
if (mysql_client_plugin_init())
{
#ifdef _WIN32
return 1;
#else
return;
#endif
}
if (!mysql_port)
{
#if !__has_feature(memory_sanitizer) /* work around MSAN deficiency */
struct servent *serv_ptr;
#endif
char *env;
mysql_port = MARIADB_PORT;
#if !__has_feature(memory_sanitizer) /* work around MSAN deficiency */
if ((serv_ptr = getservbyname("mysql", "tcp")))
mysql_port = (uint)ntohs((ushort)serv_ptr->s_port);
#endif
if ((env = getenv("MYSQL_TCP_PORT")))
mysql_port =(uint)atoi(env);
}
if (!mysql_unix_port)
{
char *env;
#ifdef _WIN32
mysql_unix_port = (char*)MARIADB_NAMEDPIPE;
#else
mysql_unix_port = (char*)MARIADB_UNIX_ADDR;
#endif
if ((env = getenv("MYSQL_UNIX_PORT")) ||
(env = getenv("MARIADB_UNIX_PORT")))
mysql_unix_port = env;
} | O0 | c | mysql_once_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x3fbb0
callq 0x625d0
movb $0x0, %al
callq 0x61700
leaq 0x2da9a(%rip), %rdi # 0x6ae8a
xorl %esi, %esi
callq 0x61640
movb $0x0, %al
callq 0x4fec0
cmpl $0x0, %eax
je 0x3d408
jmp 0x3d508
leaq 0x43fc1(%rip), %rax # 0x813d0
cmpl $0x0, (%rax)
jne 0x3d485
leaq 0x43fb5(%rip), %rax # 0x813d0
movl $0xcea, (%rax) # imm = 0xCEA
leaq 0x301a3(%rip), %rdi # 0x6d5cb
leaq 0x2dc4c(%rip), %rsi # 0x6b07b
callq 0x14080
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x3d459
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movzwl %ax, %edi
callq 0x147b0
movzwl %ax, %ecx
leaq 0x43f79(%rip), %rax # 0x813d0
movl %ecx, (%rax)
leaq 0x2dc1f(%rip), %rdi # 0x6b07f
callq 0x14550
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x3d483
movq -0x10(%rbp), %rdi
callq 0x146c0
movl %eax, %ecx
leaq 0x43f4f(%rip), %rax # 0x813d0
movl %ecx, (%rax)
jmp 0x3d485
leaq 0x43f4c(%rip), %rax # 0x813d8
cmpq $0x0, (%rax)
jne 0x3d4df
leaq 0x43f3f(%rip), %rax # 0x813d8
leaq 0x2dbee(%rip), %rcx # 0x6b08e
movq %rcx, (%rax)
leaq 0x2dbf4(%rip), %rdi # 0x6b09e
callq 0x14550
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x3d4cf
leaq 0x2dbee(%rip), %rdi # 0x6b0ae
callq 0x14550
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x3d4dd
movq -0x18(%rbp), %rcx
leaq 0x43efe(%rip), %rax # 0x813d8
movq %rcx, (%rax)
jmp 0x3d4df
leaq 0x43f2a(%rip), %rax # 0x81410
cmpb $0x0, (%rax)
jne 0x3d4f0
callq 0x48e90
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x51040
callq 0x3d510
movb $0x1, 0x43eec(%rip) # 0x813f4
addq $0x20, %rsp
popq %rbp
retq
nop
| mysql_once_init:
push rbp
mov rbp, rsp
sub rsp, 20h
call ma_init
call init_client_errs
mov al, 0
call get_default_configuration_dirs
lea rdi, aUtf8mb4; "utf8mb4"
xor esi, esi
call set_default_charset_by_name
mov al, 0
call mysql_client_plugin_init
cmp eax, 0
jz short loc_3D408
jmp loc_3D508
loc_3D408:
lea rax, mysql_port
cmp dword ptr [rax], 0
jnz short loc_3D485
lea rax, mysql_port
mov dword ptr [rax], 0CEAh
lea rdi, aEtcMysql+5; "mysql"
lea rsi, aTcp; "tcp"
call _getservbyname
mov [rbp+var_8], rax
cmp rax, 0
jz short loc_3D459
mov rax, [rbp+var_8]
mov eax, [rax+10h]
movzx edi, ax
call _ntohs
movzx ecx, ax
lea rax, mysql_port
mov [rax], ecx
loc_3D459:
lea rdi, aMysqlTcpPort; "MYSQL_TCP_PORT"
call _getenv
mov [rbp+var_10], rax
cmp rax, 0
jz short loc_3D483
mov rdi, [rbp+var_10]
call _atoi
mov ecx, eax
lea rax, mysql_port
mov [rax], ecx
loc_3D483:
jmp short $+2
loc_3D485:
lea rax, mysql_unix_port
cmp qword ptr [rax], 0
jnz short loc_3D4DF
lea rax, mysql_unix_port
lea rcx, aTmpMysqlSock; "/tmp/mysql.sock"
mov [rax], rcx
lea rdi, aMysqlUnixPort; "MYSQL_UNIX_PORT"
call _getenv
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_3D4CF
lea rdi, aMariadbUnixPor; "MARIADB_UNIX_PORT"
call _getenv
mov [rbp+var_18], rax
cmp rax, 0
jz short loc_3D4DD
loc_3D4CF:
mov rcx, [rbp+var_18]
lea rax, mysql_unix_port
mov [rax], rcx
loc_3D4DD:
jmp short $+2
loc_3D4DF:
lea rax, mysql_ps_subsystem_initialized
cmp byte ptr [rax], 0
jnz short loc_3D4F0
call mysql_init_ps_subsystem
loc_3D4F0:
xor eax, eax
mov esi, eax
mov rdi, rsi
call ma_tls_start
call ignore_sigpipe
mov cs:mysql_client_init, 1
loc_3D508:
add rsp, 20h
pop rbp
retn
| long long mysql_once_init()
{
long long result; // rax
long long v1; // [rsp+8h] [rbp-18h]
long long v2; // [rsp+10h] [rbp-10h]
long long v3; // [rsp+18h] [rbp-8h]
ma_init();
init_client_errs();
get_default_configuration_dirs();
set_default_charset_by_name("utf8mb4", 0LL);
result = mysql_client_plugin_init();
if ( !(_DWORD)result )
{
if ( !mysql_port )
{
mysql_port = 3306;
v3 = getservbyname("mysql", "tcp");
if ( v3 )
mysql_port = (unsigned __int16)ntohs((unsigned __int16)*(_DWORD *)(v3 + 16));
v2 = getenv("MYSQL_TCP_PORT");
if ( v2 )
mysql_port = atoi(v2);
}
if ( !mysql_unix_port )
{
mysql_unix_port = "/tmp/mysql.sock";
v1 = getenv("MYSQL_UNIX_PORT");
if ( v1 || (v1 = getenv("MARIADB_UNIX_PORT")) != 0 )
mysql_unix_port = v1;
}
if ( !mysql_ps_subsystem_initialized )
mysql_init_ps_subsystem();
ma_tls_start(0LL);
result = ignore_sigpipe();
mysql_client_init = 1;
}
return result;
}
| mysql_once_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
CALL 0x0013fbb0
CALL 0x001625d0
MOV AL,0x0
CALL 0x00161700
LEA RDI,[0x16ae8a]
XOR ESI,ESI
CALL 0x00161640
MOV AL,0x0
CALL 0x0014fec0
CMP EAX,0x0
JZ 0x0013d408
JMP 0x0013d508
LAB_0013d408:
LEA RAX,[0x1813d0]
CMP dword ptr [RAX],0x0
JNZ 0x0013d485
LEA RAX,[0x1813d0]
MOV dword ptr [RAX],0xcea
LEA RDI,[0x16d5cb]
LEA RSI,[0x16b07b]
CALL 0x00114080
MOV qword ptr [RBP + -0x8],RAX
CMP RAX,0x0
JZ 0x0013d459
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x10]
MOVZX EDI,AX
CALL 0x001147b0
MOVZX ECX,AX
LEA RAX,[0x1813d0]
MOV dword ptr [RAX],ECX
LAB_0013d459:
LEA RDI,[0x16b07f]
CALL 0x00114550
MOV qword ptr [RBP + -0x10],RAX
CMP RAX,0x0
JZ 0x0013d483
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001146c0
MOV ECX,EAX
LEA RAX,[0x1813d0]
MOV dword ptr [RAX],ECX
LAB_0013d483:
JMP 0x0013d485
LAB_0013d485:
LEA RAX,[0x1813d8]
CMP qword ptr [RAX],0x0
JNZ 0x0013d4df
LEA RAX,[0x1813d8]
LEA RCX,[0x16b08e]
MOV qword ptr [RAX],RCX
LEA RDI,[0x16b09e]
CALL 0x00114550
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x0013d4cf
LEA RDI,[0x16b0ae]
CALL 0x00114550
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JZ 0x0013d4dd
LAB_0013d4cf:
MOV RCX,qword ptr [RBP + -0x18]
LEA RAX,[0x1813d8]
MOV qword ptr [RAX],RCX
LAB_0013d4dd:
JMP 0x0013d4df
LAB_0013d4df:
LEA RAX,[0x181410]
CMP byte ptr [RAX],0x0
JNZ 0x0013d4f0
CALL 0x00148e90
LAB_0013d4f0:
XOR EAX,EAX
MOV ESI,EAX
MOV RDI,RSI
CALL 0x00151040
CALL 0x0013d510
MOV byte ptr [0x001813f4],0x1
LAB_0013d508:
ADD RSP,0x20
POP RBP
RET
|
void mysql_once_init(void)
{
uint16_t uVar1;
int iVar2;
servent *psVar3;
char *__nptr;
char *local_20;
ma_init();
init_client_errs();
get_default_configuration_dirs();
set_default_charset_by_name("utf8mb4",0);
iVar2 = mysql_client_plugin_init();
if (iVar2 == 0) {
if (mysql_port == 0) {
mysql_port = 0xcea;
psVar3 = getservbyname("mysql","tcp");
if (psVar3 != (servent *)0x0) {
uVar1 = ntohs((uint16_t)psVar3->s_port);
mysql_port = (uint)uVar1;
}
__nptr = getenv("MYSQL_TCP_PORT");
if (__nptr != (char *)0x0) {
mysql_port = atoi(__nptr);
}
}
if (mysql_unix_port == (char *)0x0) {
mysql_unix_port = "/tmp/mysql.sock";
local_20 = getenv("MYSQL_UNIX_PORT");
if ((local_20 != (char *)0x0) ||
(local_20 = getenv("MARIADB_UNIX_PORT"), local_20 != (char *)0x0)) {
mysql_unix_port = local_20;
}
}
if (mysql_ps_subsystem_initialized == '\0') {
mysql_init_ps_subsystem();
}
ma_tls_start(0);
ignore_sigpipe();
mysql_client_init = 1;
}
return;
}
| |
42,852 | eth_get_account_value | corpus-core[P]colibri-stateless/src/chains/eth/verifier/eth_account.c | void eth_get_account_value(ssz_ob_t account, eth_account_field_t field, bytes32_t value) {
bytes_t last_value = get_last_value(ssz_get(&account, "accountProof"));
if (!last_value.data) return;
if (rlp_decode(&last_value, 0, &last_value) != RLP_LIST) return;
if (rlp_decode(&last_value, field - 1, &last_value) != RLP_ITEM) return;
if (last_value.len > 32) return;
memcpy(value + 32 - last_value.len, last_value.data, last_value.len);
} | O2 | c | eth_get_account_value:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x4854a(%rip), %rdx # 0x74bf1
leaq 0x28(%rsp), %r14
leaq 0x60(%rsp), %rsi
movq %r14, %rdi
callq 0x4d119
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
callq 0x2c5df
movl %eax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
testq %rdx, %rdx
je 0x2c725
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
movq %rdi, %rdx
callq 0x2de74
cmpl $0x2, %eax
jne 0x2c725
decl %ebp
leaq 0x18(%rsp), %rdi
movl %ebp, %esi
movq %rdi, %rdx
callq 0x2de74
cmpl $0x1, %eax
jne 0x2c725
movl 0x18(%rsp), %edx
cmpq $0x20, %rdx
ja 0x2c725
subq %rdx, %rbx
addq $0x20, %rbx
movq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x22090
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| eth_get_account_value:
push rbp
push r14
push rbx
sub rsp, 40h
mov rbx, rsi
mov ebp, edi
lea rdx, aAccountproof; "accountProof"
lea r14, [rsp+58h+var_30]
lea rsi, [rsp+58h+arg_0]
mov rdi, r14
call ssz_get
mov rax, [r14+10h]
mov [rsp+58h+var_48], rax
movups xmm0, xmmword ptr [r14]
movups [rsp+58h+var_58], xmm0
call get_last_value
mov [rsp+58h+var_40], eax
mov [rsp+58h+var_38], rdx
test rdx, rdx
jz short loc_2C725
lea rdi, [rsp+58h+var_40]
xor esi, esi
mov rdx, rdi
call rlp_decode
cmp eax, 2
jnz short loc_2C725
dec ebp
lea rdi, [rsp+58h+var_40]
mov esi, ebp
mov rdx, rdi
call rlp_decode
cmp eax, 1
jnz short loc_2C725
mov edx, [rsp+58h+var_40]
cmp rdx, 20h ; ' '
ja short loc_2C725
sub rbx, rdx
add rbx, 20h ; ' '
mov rsi, [rsp+58h+var_38]
mov rdi, rbx
call _memcpy
loc_2C725:
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
| long long eth_get_account_value(int a1, long long a2, _DWORD a3, _DWORD a4, _DWORD a5, _DWORD a6, char a7)
{
int v7; // edx
int v8; // ecx
int v9; // r8d
int v10; // r9d
long long result; // rax
long long v12; // rdx
long long v13; // rcx
unsigned int v14; // [rsp+18h] [rbp-40h] BYREF
long long v15; // [rsp+20h] [rbp-38h]
__int128 v16; // [rsp+28h] [rbp-30h] BYREF
long long v17; // [rsp+38h] [rbp-20h]
ssz_get(&v16, &a7, "accountProof");
result = get_last_value((int)&v16, (int)&a7, v7, v8, v9, v10, v16, v17);
v14 = result;
v15 = v12;
if ( v12 )
{
result = rlp_decode(&v14, 0LL, &v14);
if ( (_DWORD)result == 2 )
{
result = rlp_decode(&v14, (unsigned int)(a1 - 1), &v14);
if ( (_DWORD)result == 1 && v14 <= 0x20uLL )
return memcpy(a2 - v14 + 32, v15, v14, v13);
}
}
return result;
}
| eth_get_account_value:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV RBX,RSI
MOV EBP,EDI
LEA RDX,[0x174bf1]
LEA R14,[RSP + 0x28]
LEA RSI,[RSP + 0x60]
MOV RDI,R14
CALL 0x0014d119
MOV RAX,qword ptr [R14 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R14]
MOVUPS xmmword ptr [RSP],XMM0
CALL 0x0012c5df
MOV dword ptr [RSP + 0x18],EAX
MOV qword ptr [RSP + 0x20],RDX
TEST RDX,RDX
JZ 0x0012c725
LEA RDI,[RSP + 0x18]
XOR ESI,ESI
MOV RDX,RDI
CALL 0x0012de74
CMP EAX,0x2
JNZ 0x0012c725
DEC EBP
LEA RDI,[RSP + 0x18]
MOV ESI,EBP
MOV RDX,RDI
CALL 0x0012de74
CMP EAX,0x1
JNZ 0x0012c725
MOV EDX,dword ptr [RSP + 0x18]
CMP RDX,0x20
JA 0x0012c725
SUB RBX,RDX
ADD RBX,0x20
MOV RSI,qword ptr [RSP + 0x20]
MOV RDI,RBX
CALL 0x00122090
LAB_0012c725:
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
|
void eth_get_account_value(int param_1,long param_2)
{
int iVar1;
void *extraout_RDX;
ulong __n;
uint local_40 [2];
void *local_38;
int1 local_30 [24];
ssz_get(local_30,&stack0x00000008,"accountProof");
local_40[0] = get_last_value();
if (extraout_RDX != (void *)0x0) {
local_38 = extraout_RDX;
iVar1 = rlp_decode(local_40,0,local_40);
if (iVar1 == 2) {
iVar1 = rlp_decode(local_40,param_1 + -1,local_40);
if ((iVar1 == 1) && (__n = (ulong)local_40[0], __n < 0x21)) {
memcpy((void *)((param_2 - __n) + 0x20),local_38,__n);
}
}
}
return;
}
| |
42,853 | my_uca_generate_pages | eloqsql/strings/ctype-uca.c | static my_bool
my_uca_generate_pages(MY_CHARSET_LOADER *loader,
MY_UCA_WEIGHT_LEVEL *dst,
const MY_UCA_WEIGHT_LEVEL *src,
uint npages)
{
uint page;
for (page= 0; page < npages; page++)
{
if (dst->weights[page])
{
/* A page with explicit weights with no special rules */
continue;
}
if (!dst->lengths[page])
{
/*
A page with implicit weights with no special rules.
Keep dst->weights[page]==NULL and dst->lengths[page]==0.
Weights for this page will be generated at run time algorithmically,
using my_uca_scanner_next_implicit().
*/
continue;
}
/* Found a page with some special rules. */
if (my_uca_generate_page(loader, dst, src, page))
return TRUE;
}
return FALSE;
} | O0 | c | my_uca_generate_pages:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0xba1c8
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x28(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0xba18a
jmp 0xba1bd
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x28(%rbp), %ecx
cmpb $0x0, (%rax,%rcx)
jne 0xba19d
jmp 0xba1bd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x28(%rbp), %ecx
callq 0xba530
cmpb $0x0, %al
je 0xba1bb
movb $0x1, -0x1(%rbp)
jmp 0xba1cc
jmp 0xba1bd
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xba16e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_uca_generate_pages:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_28], 0
loc_BA16E:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_24]
jnb short loc_BA1C8
mov rax, [rbp+var_18]
mov rax, [rax+10h]
mov ecx, [rbp+var_28]
cmp qword ptr [rax+rcx*8], 0
jz short loc_BA18A
jmp short loc_BA1BD
loc_BA18A:
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov ecx, [rbp+var_28]
cmp byte ptr [rax+rcx], 0
jnz short loc_BA19D
jmp short loc_BA1BD
loc_BA19D:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov ecx, [rbp+var_28]
call my_uca_generate_page
cmp al, 0
jz short loc_BA1BB
mov [rbp+var_1], 1
jmp short loc_BA1CC
loc_BA1BB:
jmp short $+2
loc_BA1BD:
mov eax, [rbp+var_28]
add eax, 1
mov [rbp+var_28], eax
jmp short loc_BA16E
loc_BA1C8:
mov [rbp+var_1], 0
loc_BA1CC:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char my_uca_generate_pages(long long a1, long long a2, long long a3, unsigned int a4)
{
unsigned int i; // [rsp+8h] [rbp-28h]
for ( i = 0; i < a4; ++i )
{
if ( !*(_QWORD *)(*(_QWORD *)(a2 + 16) + 8LL * i)
&& *(_BYTE *)(*(_QWORD *)(a2 + 8) + i)
&& (unsigned __int8)my_uca_generate_page(a1, a2, a3, i) )
{
return 1;
}
}
return 0;
}
| my_uca_generate_pages:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV dword ptr [RBP + -0x28],0x0
LAB_001ba16e:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x24]
JNC 0x001ba1c8
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x10]
MOV ECX,dword ptr [RBP + -0x28]
CMP qword ptr [RAX + RCX*0x8],0x0
JZ 0x001ba18a
JMP 0x001ba1bd
LAB_001ba18a:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x28]
CMP byte ptr [RAX + RCX*0x1],0x0
JNZ 0x001ba19d
JMP 0x001ba1bd
LAB_001ba19d:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x28]
CALL 0x001ba530
CMP AL,0x0
JZ 0x001ba1bb
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001ba1cc
LAB_001ba1bb:
JMP 0x001ba1bd
LAB_001ba1bd:
MOV EAX,dword ptr [RBP + -0x28]
ADD EAX,0x1
MOV dword ptr [RBP + -0x28],EAX
JMP 0x001ba16e
LAB_001ba1c8:
MOV byte ptr [RBP + -0x1],0x0
LAB_001ba1cc:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 my_uca_generate_pages(int8 param_1,long param_2,int8 param_3,uint param_4)
{
char cVar1;
uint local_30;
local_30 = 0;
while( true ) {
if (param_4 <= local_30) {
return 0;
}
if (((*(long *)(*(long *)(param_2 + 0x10) + (ulong)local_30 * 8) == 0) &&
(*(char *)(*(long *)(param_2 + 8) + (ulong)local_30) != '\0')) &&
(cVar1 = my_uca_generate_page(param_1,param_2,param_3,local_30), cVar1 != '\0')) break;
local_30 = local_30 + 1;
}
return 1;
}
| |
42,854 | 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 0x336871(%rip), %rax # 0x373058
movq (%rax), %rax
testq %rax, %rax
je 0x3c81a
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 0x3c940
movl 0x18(%rbp), %r11d
movl 0x10(%rbp), %r8d
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
cmpq %r12, %r13
je 0x3c936
movb (%r13), %al
movsbl %al, %ecx
cmpl %r11d, %ecx
sete %sil
cmpl %r8d, %ecx
sete %dl
orb %dl, %sil
je 0x3c897
testb %dl, %dl
je 0x3c88d
incq %r13
movq %r13, %rax
cmpq %rbx, %r14
je 0x3c940
movq %r14, %rcx
movq %rax, %r13
cmpq %r12, %rax
jae 0x3c87a
leaq 0x1(%rcx), %r14
movsbl (%r13), %edx
leaq 0x1(%r13), %rax
cmpl %r8d, %edx
je 0x3c854
incq %rcx
cmpq %r12, %r13
je 0x3c933
movb (%r13), %al
movq %rcx, %r14
movsbl %al, %eax
cmpl %r11d, %eax
jne 0x3c828
jmp 0x3c8f8
movl $0x1, %r15d
cmpq %rbx, %r14
je 0x3c940
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 0x3c940
incq %r14
incq %r13
cmpq %r12, %r13
je 0x3c936
movb (%r13), %al
movsbl %al, %ecx
cmpl %r8d, %ecx
sete %dl
cmpl %r11d, %ecx
je 0x3c84a
cmpl %r8d, %ecx
jne 0x3c897
jmp 0x3c84a
leaq 0x1(%r13), %rax
xorl %r15d, %r15d
cmpq %r12, %rax
je 0x3c940
addq $0x2, %r13
movb -0x1(%r13), %al
movsbl %al, %ecx
cmpl %r11d, %ecx
je 0x3c925
cmpl %r8d, %ecx
jne 0x3c952
cmpq %rbx, %r14
je 0x3c9fd
incq %r14
leaq 0x1(%r13), %rax
cmpq %r12, %r13
movq %rax, %r13
jne 0x3c908
jmp 0x3c940
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 0x3c940
movzbl %al, %ecx
leaq -0x1(%r13), %rdx
cmpl %r9d, %ecx
jne 0x3c975
cmpq %r12, %r13
je 0x3c975
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 0x3c940
movq 0x58(%rdi), %rax
movzbl (%r14), %ecx
cmpb %r13b, (%rax,%rcx)
je 0x3c9a3
incq %r14
cmpq %rbx, %r14
jne 0x3c98f
jmp 0x3c940
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 0x3c7bf
addq $0x20, %rsp
testl %eax, %eax
jle 0x3ca08
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 0x3c986
jmp 0x3c940
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
jmp 0x3c940
movl %eax, %r15d
jmp 0x3c940
| 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_3C81A
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_3C940
loc_3C81A:
mov r11d, [rbp+arg_8]
mov r8d, [rbp+arg_0]
mov r15d, 0FFFFFFFFh
loc_3C828:
cmp r13, r12
jz loc_3C936
mov al, [r13+0]
movsx ecx, al
cmp ecx, r11d
setz sil
cmp ecx, r8d
setz dl
or sil, dl
jz short loc_3C897
loc_3C84A:
test dl, dl
jz short loc_3C88D
inc r13
mov rax, r13
loc_3C854:
cmp r14, rbx
jz loc_3C940
mov rcx, r14
mov r13, rax
cmp rax, r12
jnb short loc_3C87A
lea r14, [rcx+1]
movsx edx, byte ptr [r13+0]
lea rax, [r13+1]
cmp edx, r8d
jz short loc_3C854
loc_3C87A:
inc rcx
cmp r13, r12
jz loc_3C933
mov al, [r13+0]
mov r14, rcx
loc_3C88D:
movsx eax, al
cmp eax, r11d
jnz short loc_3C828
jmp short loc_3C8F8
loc_3C897:
mov r15d, 1
cmp r14, rbx
jz loc_3C940
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_3C940
inc r14
inc r13
cmp r13, r12
jz short loc_3C936
mov al, [r13+0]
movsx ecx, al
cmp ecx, r8d
setz dl
cmp ecx, r11d
jz loc_3C84A
cmp ecx, r8d
jnz short loc_3C897
jmp loc_3C84A
loc_3C8F8:
lea rax, [r13+1]
xor r15d, r15d
cmp rax, r12
jz short loc_3C940
add r13, 2
loc_3C908:
mov al, [r13-1]
movsx ecx, al
cmp ecx, r11d
jz short loc_3C925
cmp ecx, r8d
jnz short loc_3C952
cmp r14, rbx
jz loc_3C9FD
inc r14
loc_3C925:
lea rax, [r13+1]
cmp r13, r12
mov r13, rax
jnz short loc_3C908
jmp short loc_3C940
loc_3C933:
mov r14, rcx
loc_3C936:
xor r15d, r15d
cmp r14, rbx
setnz r15b
loc_3C940:
mov eax, r15d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3C952:
mov r15d, 0FFFFFFFFh
cmp r14, rbx
jz short loc_3C940
movzx ecx, al
lea rdx, [r13-1]
cmp ecx, r9d
jnz short loc_3C975
cmp r13, r12
jz short loc_3C975
mov al, [r13+0]
mov rdx, r13
loc_3C975:
inc rdx
mov rcx, [rdi+58h]
movzx eax, al
mov r13b, [rcx+rax]
inc r10d
loc_3C986:
cmp r14, rbx
jz short loc_3C940
mov rax, [rdi+58h]
loc_3C98F:
movzx ecx, byte ptr [r14]
cmp [rax+rcx], r13b
jz short loc_3C9A3
inc r14
cmp r14, rbx
jnz short loc_3C98F
jmp short loc_3C940
loc_3C9A3:
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_3CA08
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_3C986
jmp loc_3C940
loc_3C9FD:
mov r15d, 0FFFFFFFFh
jmp loc_3C940
loc_3CA08:
mov r15d, eax
jmp loc_3C940
| 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,[0x473058]
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x0013c81a
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 0x0013c940
LAB_0013c81a:
MOV R11D,dword ptr [RBP + 0x18]
MOV R8D,dword ptr [RBP + 0x10]
MOV R15D,0xffffffff
LAB_0013c828:
CMP R13,R12
JZ 0x0013c936
MOV AL,byte ptr [R13]
MOVSX ECX,AL
CMP ECX,R11D
SETZ SIL
CMP ECX,R8D
SETZ DL
OR SIL,DL
JZ 0x0013c897
LAB_0013c84a:
TEST DL,DL
JZ 0x0013c88d
INC R13
MOV RAX,R13
LAB_0013c854:
CMP R14,RBX
JZ 0x0013c940
MOV RCX,R14
MOV R13,RAX
CMP RAX,R12
JNC 0x0013c87a
LEA R14,[RCX + 0x1]
MOVSX EDX,byte ptr [R13]
LEA RAX,[R13 + 0x1]
CMP EDX,R8D
JZ 0x0013c854
LAB_0013c87a:
INC RCX
CMP R13,R12
JZ 0x0013c933
MOV AL,byte ptr [R13]
MOV R14,RCX
LAB_0013c88d:
MOVSX EAX,AL
CMP EAX,R11D
JNZ 0x0013c828
JMP 0x0013c8f8
LAB_0013c897:
MOV R15D,0x1
CMP R14,RBX
JZ 0x0013c940
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 0x0013c940
INC R14
INC R13
CMP R13,R12
JZ 0x0013c936
MOV AL,byte ptr [R13]
MOVSX ECX,AL
CMP ECX,R8D
SETZ DL
CMP ECX,R11D
JZ 0x0013c84a
CMP ECX,R8D
JNZ 0x0013c897
JMP 0x0013c84a
LAB_0013c8f8:
LEA RAX,[R13 + 0x1]
XOR R15D,R15D
CMP RAX,R12
JZ 0x0013c940
ADD R13,0x2
LAB_0013c908:
MOV AL,byte ptr [R13 + -0x1]
MOVSX ECX,AL
CMP ECX,R11D
JZ 0x0013c925
CMP ECX,R8D
JNZ 0x0013c952
CMP R14,RBX
JZ 0x0013c9fd
INC R14
LAB_0013c925:
LEA RAX,[R13 + 0x1]
CMP R13,R12
MOV R13,RAX
JNZ 0x0013c908
JMP 0x0013c940
LAB_0013c933:
MOV R14,RCX
LAB_0013c936:
XOR R15D,R15D
CMP R14,RBX
SETNZ R15B
LAB_0013c940:
MOV EAX,R15D
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013c952:
MOV R15D,0xffffffff
CMP R14,RBX
JZ 0x0013c940
MOVZX ECX,AL
LEA RDX,[R13 + -0x1]
CMP ECX,R9D
JNZ 0x0013c975
CMP R13,R12
JZ 0x0013c975
MOV AL,byte ptr [R13]
MOV RDX,R13
LAB_0013c975:
INC RDX
MOV RCX,qword ptr [RDI + 0x58]
MOVZX EAX,AL
MOV R13B,byte ptr [RCX + RAX*0x1]
INC R10D
LAB_0013c986:
CMP R14,RBX
JZ 0x0013c940
MOV RAX,qword ptr [RDI + 0x58]
LAB_0013c98f:
MOVZX ECX,byte ptr [R14]
CMP byte ptr [RAX + RCX*0x1],R13B
JZ 0x0013c9a3
INC R14
CMP R14,RBX
JNZ 0x0013c98f
JMP 0x0013c940
LAB_0013c9a3:
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 0x0013c7bf
ADD RSP,0x20
TEST EAX,EAX
JLE 0x0013ca08
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 0x0013c986
JMP 0x0013c940
LAB_0013c9fd:
MOV R15D,0xffffffff
JMP 0x0013c940
LAB_0013ca08:
MOV R15D,EAX
JMP 0x0013c940
|
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_0013c936;
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_0013c936:
return (uint)(param_2 != param_3);
}
| |
42,855 | common_params_get_system_info[abi:cxx11](common_params const&) | monkey531[P]llama/common/common.cpp | std::string common_params_get_system_info(const common_params & params) {
std::ostringstream os;
os << "system_info: n_threads = " << params.cpuparams.n_threads;
if (params.cpuparams_batch.n_threads != -1) {
os << " (n_threads_batch = " << params.cpuparams_batch.n_threads << ")";
}
#if defined(_WIN32) && (_WIN32_WINNT >= 0x0601) && !defined(__MINGW64__) // windows 7 and later
// TODO: windows + arm64 + mingw64
DWORD logicalProcessorCount = GetActiveProcessorCount(ALL_PROCESSOR_GROUPS);
os << " / " << logicalProcessorCount << " | " << llama_print_system_info();
#else
os << " / " << std::thread::hardware_concurrency() << " | " << llama_print_system_info();
#endif
return os.str();
} | O3 | cpp | common_params_get_system_info[abi:cxx11](common_params const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x18880
leaq 0x8a881(%rip), %rsi # 0xa7e32
movl $0x19, %edx
movq %r15, %rdi
callq 0x18770
movl 0x274(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x18b50
cmpl $-0x1, 0x488(%r14)
je 0x1d614
leaq 0x8a86c(%rip), %rsi # 0xa7e4c
leaq 0x8(%rsp), %rdi
movl $0x14, %edx
callq 0x18770
movl 0x488(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x18b50
leaq 0x94408(%rip), %rsi # 0xb1a0f
movl $0x1, %edx
movq %rax, %rdi
callq 0x18770
leaq 0x8a846(%rip), %rsi # 0xa7e61
leaq 0x8(%rsp), %rdi
movl $0x3, %edx
callq 0x18770
callq 0x188d0
movl %eax, %esi
leaq 0x8(%rsp), %rdi
callq 0x18480
movq %rax, %r14
leaq 0x947ed(%rip), %rsi # 0xb1e32
movl $0x3, %edx
movq %rax, %rdi
callq 0x18770
callq 0x183e0
movq %rax, %r15
testq %rax, %rax
je 0x1d677
movq %r15, %rdi
callq 0x18300
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x18770
jmp 0x1d691
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x18b10
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x18a40
movq 0xbe8e3(%rip), %rsi # 0xdbf88
leaq 0x8(%rsp), %rdi
callq 0x183a0
leaq 0x78(%rsp), %rdi
callq 0x18200
movq %rbx, %rax
addq $0x180, %rsp # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0xbe8b5(%rip), %rsi # 0xdbf88
leaq 0x8(%rsp), %rdi
callq 0x183a0
leaq 0x78(%rsp), %rdi
callq 0x18200
movq %rbx, %rdi
callq 0x18bb0
| _Z29common_params_get_system_infoB5cxx11RK13common_params:
push r15
push r14
push rbx
sub rsp, 180h
mov r14, rsi
mov rbx, rdi
lea r15, [rsp+198h+var_190]
mov rdi, r15
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
lea rsi, aSystemInfoNThr; "system_info: n_threads = "
mov edx, 19h
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov esi, [r14+274h]
lea rdi, [rsp+198h+var_190]
call __ZNSolsEi; std::ostream::operator<<(int)
cmp dword ptr [r14+488h], 0FFFFFFFFh
jz short loc_1D614
lea rsi, aNThreadsBatch; " (n_threads_batch = "
lea rdi, [rsp+198h+var_190]
mov edx, 14h
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov esi, [r14+488h]
lea rdi, [rsp+198h+var_190]
call __ZNSolsEi; std::ostream::operator<<(int)
lea rsi, a09401910201912+51h; ")"
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)
loc_1D614:
lea rsi, asc_A7E61; " / "
lea rdi, [rsp+198h+var_190]; this
mov edx, 3
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
call __ZNSt6thread20hardware_concurrencyEv; std::thread::hardware_concurrency(void)
mov esi, eax
lea rdi, [rsp+198h+var_190]
call __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
mov r14, rax
lea rsi, asc_B1E31+1; " | "
mov edx, 3
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)
call _llama_print_system_info
mov r15, rax
test rax, rax
jz short loc_1D677
mov rdi, r15
call _strlen
mov rdi, r14
mov rsi, r15
mov rdx, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp short loc_1D691
loc_1D677:
mov rax, [r14]
mov rax, [rax-18h]
mov rdi, r14
add rdi, rax
mov esi, [r14+rax+20h]
or esi, 1
call __ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate; std::ios::clear(std::_Ios_Iostate)
loc_1D691:
lea rsi, [rsp+198h+var_188]
mov rdi, rbx
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+198h+var_190]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+198h+var_120]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rax, rbx
add rsp, 180h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+arg_0]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+arg_70]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rdi, rbx
call __Unwind_Resume
| long long common_params_get_system_info[abi:cxx11](long long a1, long long a2)
{
long long v2; // rax
unsigned int v3; // eax
_QWORD *v4; // r14
long long v5; // rax
long long v6; // r15
long long v7; // rax
_BYTE v9[8]; // [rsp+8h] [rbp-190h] BYREF
_BYTE v10[104]; // [rsp+10h] [rbp-188h] BYREF
_BYTE v11[288]; // [rsp+78h] [rbp-120h] BYREF
std::ostringstream::basic_ostringstream(v9);
std::__ostream_insert<char,std::char_traits<char>>(v9, "system_info: n_threads = ", 25LL);
std::ostream::operator<<(v9, *(unsigned int *)(a2 + 628));
if ( *(_DWORD *)(a2 + 1160) != -1 )
{
std::__ostream_insert<char,std::char_traits<char>>(v9, " (n_threads_batch = ", 20LL);
v2 = std::ostream::operator<<(v9, *(unsigned int *)(a2 + 1160));
std::__ostream_insert<char,std::char_traits<char>>(v2, ")", 1LL);
}
std::__ostream_insert<char,std::char_traits<char>>(v9, " / ", 3LL);
v3 = std::thread::hardware_concurrency((std::thread *)v9);
v4 = (_QWORD *)std::ostream::_M_insert<unsigned long>(v9, v3);
std::__ostream_insert<char,std::char_traits<char>>(v4, " | ", 3LL);
v5 = llama_print_system_info();
v6 = v5;
if ( v5 )
{
v7 = strlen(v5);
std::__ostream_insert<char,std::char_traits<char>>(v4, v6, v7);
}
else
{
std::ios::clear((char *)v4 + *(_QWORD *)(*v4 - 24LL), *(_DWORD *)((char *)v4 + *(_QWORD *)(*v4 - 24LL) + 32) | 1u);
}
std::stringbuf::str(a1, v10);
std::ostringstream::~ostringstream(v9, &`VTT for'std::ostringstream);
std::ios_base::~ios_base((std::ios_base *)v11);
return a1;
}
| common_params_get_system_info[abi:cxx11]:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x180
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSP + 0x8]
MOV RDI,R15
CALL 0x00118880
LAB_0011d5aa:
LEA RSI,[0x1a7e32]
MOV EDX,0x19
MOV RDI,R15
CALL 0x00118770
MOV ESI,dword ptr [R14 + 0x274]
LEA RDI,[RSP + 0x8]
CALL 0x00118b50
CMP dword ptr [R14 + 0x488],-0x1
JZ 0x0011d614
LEA RSI,[0x1a7e4c]
LEA RDI,[RSP + 0x8]
MOV EDX,0x14
CALL 0x00118770
MOV ESI,dword ptr [R14 + 0x488]
LEA RDI,[RSP + 0x8]
CALL 0x00118b50
LEA RSI,[0x1b1a0f]
MOV EDX,0x1
MOV RDI,RAX
CALL 0x00118770
LAB_0011d614:
LEA RSI,[0x1a7e61]
LEA RDI,[RSP + 0x8]
MOV EDX,0x3
CALL 0x00118770
CALL 0x001188d0
MOV ESI,EAX
LEA RDI,[RSP + 0x8]
CALL 0x00118480
MOV R14,RAX
LEA RSI,[0x1b1e32]
MOV EDX,0x3
MOV RDI,RAX
CALL 0x00118770
CALL 0x001183e0
MOV R15,RAX
TEST RAX,RAX
JZ 0x0011d677
MOV RDI,R15
CALL 0x00118300
MOV RDI,R14
MOV RSI,R15
MOV RDX,RAX
CALL 0x00118770
JMP 0x0011d691
LAB_0011d677:
MOV RAX,qword ptr [R14]
MOV RAX,qword ptr [RAX + -0x18]
MOV RDI,R14
ADD RDI,RAX
MOV ESI,dword ptr [R14 + RAX*0x1 + 0x20]
OR ESI,0x1
CALL 0x00118b10
LAB_0011d691:
LEA RSI,[RSP + 0x10]
MOV RDI,RBX
CALL 0x00118a40
LAB_0011d69e:
MOV RSI,qword ptr [0x001dbf88]
LEA RDI,[RSP + 0x8]
CALL 0x001183a0
LEA RDI,[RSP + 0x78]
CALL 0x00118200
MOV RAX,RBX
ADD RSP,0x180
POP RBX
POP R14
POP R15
RET
|
/* common_params_get_system_info[abi:cxx11](common_params const&) */
common_params * common_params_get_system_info_abi_cxx11_(common_params *param_1)
{
ostream *poVar1;
char *__s;
size_t sVar2;
long in_RSI;
ostringstream local_190 [112];
ios_base local_120 [264];
std::__cxx11::ostringstream::ostringstream(local_190);
/* try { // try from 0011d5aa to 0011d69d has its CatchHandler @ 0011d6c9 */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)local_190,"system_info: n_threads = ",0x19);
std::ostream::operator<<((ostream *)local_190,*(int *)(in_RSI + 0x274));
if (*(int *)(in_RSI + 0x488) != -1) {
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)local_190," (n_threads_batch = ",0x14);
poVar1 = (ostream *)std::ostream::operator<<((ostream *)local_190,*(int *)(in_RSI + 0x488));
std::__ostream_insert<char,std::char_traits<char>>(poVar1,")",1);
}
std::__ostream_insert<char,std::char_traits<char>>((ostream *)local_190," / ",3);
std::thread::hardware_concurrency();
poVar1 = std::ostream::_M_insert<unsigned_long>((ulong)local_190);
std::__ostream_insert<char,std::char_traits<char>>(poVar1," | ",3);
__s = (char *)llama_print_system_info();
if (__s == (char *)0x0) {
std::ios::clear(poVar1 + *(long *)(*(long *)poVar1 + -0x18),
*(uint *)(poVar1 + *(long *)(*(long *)poVar1 + -0x18) + 0x20) | 1);
}
else {
sVar2 = strlen(__s);
std::__ostream_insert<char,std::char_traits<char>>(poVar1,__s,sVar2);
}
std::__cxx11::stringbuf::str();
std::__cxx11::ostringstream::~ostringstream(local_190);
std::ios_base::~ios_base(local_120);
return param_1;
}
| |
42,856 | testing::internal::StreamingListener::AbstractSocketWriter::SendLn(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AlayaLite/build_O3/_deps/googletest-src/googletest/src/gtest-internal-inl.h | void SendLn(const std::string& message) { Send(message + "\n"); } | O3 | c | testing::internal::StreamingListener::AbstractSocketWriter::SendLn(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x18f38
leaq 0xc50c(%rip), %rsi # 0x87526
movq %r14, %rdi
callq 0x25290
movq (%rbx), %rax
movq %rsp, %rsi
movq %rbx, %rdi
callq *0x10(%rax)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7b044
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11120
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x7b050
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7b069
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11120
movq %rbx, %rdi
callq 0x11760
nop
| _ZN7testing8internal17StreamingListener20AbstractSocketWriter6SendLnERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push rbx
sub rsp, 20h
mov rbx, rdi
lea r15, [rsp+38h+var_28]
mov [r15-10h], r15
mov rax, [rsi]
mov rdx, [rsi+8]
add rdx, rax
mov r14, rsp
mov rdi, r14
mov rsi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rsi, aSFromSSMsTotal+19h; "\n"
mov rdi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rax, [rbx]
mov rsi, rsp
mov rdi, rbx
call qword ptr [rax+10h]
mov rdi, [rsp+38h+var_38]; void *
cmp rdi, r15
jz short loc_7B044
mov rsi, [rsp+38h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7B044:
add rsp, 20h
pop rbx
pop r14
pop r15
retn
jmp short $+2
loc_7B050:
mov rbx, rax
mov rdi, [rsp+0]; void *
cmp rdi, r15
jz short loc_7B069
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7B069:
mov rdi, rbx
call __Unwind_Resume
| void testing::internal::StreamingListener::AbstractSocketWriter::SendLn(long long a1, long long a2)
{
void *v2[2]; // [rsp+0h] [rbp-38h] BYREF
_QWORD v3[5]; // [rsp+10h] [rbp-28h] BYREF
v2[0] = v3;
std::string::_M_construct<char *>((long long)v2, *(_BYTE **)a2, *(_QWORD *)a2 + *(_QWORD *)(a2 + 8));
std::string::append((long long)v2, (long long)"\n");
(*(void ( **)(long long, void **))(*(_QWORD *)a1 + 16LL))(a1, v2);
if ( v2[0] != v3 )
operator delete(v2[0], v3[0] + 1LL);
}
| SendLn:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x20
MOV RBX,RDI
LEA R15,[RSP + 0x10]
MOV qword ptr [R15 + -0x10],R15
MOV RAX,qword ptr [RSI]
MOV RDX,qword ptr [RSI + 0x8]
ADD RDX,RAX
MOV R14,RSP
MOV RDI,R14
MOV RSI,RAX
CALL 0x00118f38
LAB_0017b013:
LEA RSI,[0x187526]
MOV RDI,R14
CALL 0x00125290
MOV RAX,qword ptr [RBX]
LAB_0017b025:
MOV RSI,RSP
MOV RDI,RBX
CALL qword ptr [RAX + 0x10]
LAB_0017b02e:
MOV RDI,qword ptr [RSP]
CMP RDI,R15
JZ 0x0017b044
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x00111120
LAB_0017b044:
ADD RSP,0x20
POP RBX
POP R14
POP R15
RET
|
/* testing::internal::StreamingListener::AbstractSocketWriter::SendLn(std::__cxx11::string const&)
*/
void __thiscall
testing::internal::StreamingListener::AbstractSocketWriter::SendLn
(AbstractSocketWriter *this,string *param_1)
{
long *local_38 [2];
long local_28 [2];
local_38[0] = local_28;
std::__cxx11::string::_M_construct<char*>
(local_38,*(long *)param_1,*(long *)(param_1 + 8) + *(long *)param_1);
/* try { // try from 0017b013 to 0017b021 has its CatchHandler @ 0017b050 */
std::__cxx11::string::append((string *)local_38,"\n");
/* try { // try from 0017b025 to 0017b02d has its CatchHandler @ 0017b04e */
(**(code **)(*(long *)this + 0x10))(this,local_38);
if (local_38[0] != local_28) {
operator_delete(local_38[0],local_28[0] + 1);
}
return;
}
| |
42,857 | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp) | monkey531[P]llama/common/json.hpp | static diyfp normalize(diyfp x) noexcept
{
JSON_ASSERT(x.f != 0);
while ((x.f >> 63u) == 0)
{
x.f <<= 1u;
x.e--;
}
return x;
} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp):
pushq %rax
testq %rdi, %rdi
jne 0x87f88
leaq 0x27e67(%rip), %rdi # 0xafdd0
leaq 0x27eaa(%rip), %rdx # 0xafe1a
leaq 0x2d649(%rip), %rcx # 0xb55c0
movl $0x42a1, %esi # imm = 0x42A1
xorl %eax, %eax
callq 0x23ef0
addq %rdi, %rdi
decl %esi
testq %rdi, %rdi
jns 0x87f83
movq %rdi, %rax
movl %esi, %edx
popq %rcx
retq
movq %rax, %rdi
callq 0x27925
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp9normalizeES3_:
push rax
test rdi, rdi
jnz short loc_87F88
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aXF0; "x.f != 0"
mov esi, 42A1h
xor eax, eax
call _ggml_abort
loc_87F83:
add rdi, rdi
dec esi
loc_87F88:
test rdi, rdi
jns short loc_87F83
mov rax, rdi
mov edx, esi
pop rcx
retn
mov rdi, rax
call __clang_call_terminate
| long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(long long a1, int a2)
{
if ( a1 )
goto LABEL_4;
a1 = (long long)"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp";
a2 = 17057;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17057LL,
"GGML_ASSERT(%s) failed",
"x.f != 0");
do
{
a1 *= 2LL;
--a2;
LABEL_4:
;
}
while ( a1 >= 0 );
return a1;
}
| normalize:
PUSH RAX
TEST RDI,RDI
JNZ 0x00187f88
LAB_00187f62:
LEA RDI,[0x1afdd0]
LEA RDX,[0x1afe1a]
LEA RCX,[0x1b55c0]
MOV ESI,0x42a1
XOR EAX,EAX
CALL 0x00123ef0
LAB_00187f83:
ADD RDI,RDI
DEC ESI
LAB_00187f88:
TEST RDI,RDI
JNS 0x00187f83
MOV RAX,RDI
MOV EDX,ESI
POP RCX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp)
*/
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(diyfp *this,int param_2)
{
int1 auVar1 [16];
if (this == (diyfp *)0x0) {
/* try { // try from 00187f62 to 00187f82 has its CatchHandler @ 00187f94 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x42a1,
"GGML_ASSERT(%s) failed","x.f != 0");
}
for (; -1 < (long)this; this = (diyfp *)((long)this * 2)) {
param_2 = param_2 + -1;
}
auVar1._8_4_ = param_2;
auVar1._0_8_ = this;
auVar1._12_4_ = 0;
return auVar1;
}
| |
42,858 | 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>>::key() const | llama.cpp/common/./json.hpp | const typename object_t::key_type& key() const
{
JSON_ASSERT(m_object != nullptr);
if (JSON_HEDLEY_LIKELY(m_object->is_object()))
{
return m_it.object_iterator->first;
}
JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", m_object));
} | 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>>::key() const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0x90a81
movq %rdi, %r14
cmpb $0x1, (%rax)
jne 0x90a23
movq 0x8(%r14), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x25790
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xe4951(%rip), %rsi # 0x175391
leaq 0xe4973(%rip), %rdx # 0x1753ba
leaq 0x8(%rsp), %rdi
callq 0x52736
movq (%r14), %rcx
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xcf, %esi
callq 0x811b0
xorl %ebp, %ebp
leaq 0x149fd6(%rip), %rsi # 0x1daa48
leaq -0xc817(%rip), %rdx # 0x84262
movq %rbx, %rdi
callq 0x25c00
leaq 0xe234d(%rip), %rdi # 0x172dd5
leaq 0xe2383(%rip), %rdx # 0x172e12
leaq 0xe48e7(%rip), %rcx # 0x17537d
movl $0x3519, %esi # imm = 0x3519
xorl %eax, %eax
callq 0x26090
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x90abc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x251b0
testb %bpl, %bpl
jne 0x90ac6
jmp 0x90ace
movq %rax, %r14
movq %rbx, %rdi
callq 0x26150
movq %r14, %rdi
callq 0x25ca0
| _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE3keyEv:
push rbp; void *
push r15; int
push r14; __int64
push rbx; int
sub rsp, 28h
mov rax, [rdi]
test rax, rax
jz short loc_90A81
mov r14, rdi
cmp byte ptr [rax], 1
jnz short loc_90A23
mov rax, [r14+8]
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_90A23:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+48h+var_30]
mov [r15-10h], r15
lea rsi, aCannotUseKeyFo; "cannot use key() for non-object iterato"...
lea rdx, aCannotUseKeyFo+29h; ""
lea rdi, [rsp+48h+var_40]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rcx, [r14]
mov bpl, 1
lea rdx, [rsp+48h+var_40]
mov rdi, rbx; this
mov esi, 0CFh; int
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPKNS0_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_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_90A81:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAnchorMObjectN+7; "m_object != nullptr"
mov esi, 3519h
xor eax, eax
call _ggml_abort
mov r14, rax
mov rdi, [rsp+48h+var_40]; void *
cmp rdi, r15
jz short loc_90ABC
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_90ABC:
test bpl, bpl
jnz short loc_90AC6
jmp short loc_90ACE
mov r14, rax
loc_90AC6:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_90ACE:
mov rdi, r14
call __Unwind_Resume
| 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>::key(
_QWORD *a1)
{
void *v1; // rbx
char v2; // bp
void *v3; // r15
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
long long v6; // rax
long long v7; // r14
void *v8[2]; // [rsp+8h] [rbp-40h] BYREF
long long v9; // [rsp+18h] [rbp-30h] BYREF
if ( !*a1 )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/./json.hpp",
13593LL,
"GGML_ASSERT(%s) failed",
"m_object != nullptr");
v7 = v6;
if ( v8[0] != v3 )
operator delete(v8[0], v9 + 1);
if ( v2 )
__cxa_free_exception(v1);
_Unwind_Resume(v7);
}
if ( *(_BYTE *)*a1 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v8[0] = &v9;
std::string::_M_construct<char const*>((long long)v8, "cannot use key() for non-object iterators", (long long)"");
ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
207,
v8);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::invalid_iterator,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return a1[1];
}
| key:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x00190a81
MOV R14,RDI
CMP byte ptr [RAX],0x1
JNZ 0x00190a23
MOV RAX,qword ptr [R14 + 0x8]
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00190a23:
MOV EDI,0x20
CALL 0x00125790
MOV RBX,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_00190a39:
LEA RSI,[0x275391]
LEA RDX,[0x2753ba]
LEA RDI,[RSP + 0x8]
CALL 0x00152736
MOV RCX,qword ptr [R14]
MOV BPL,0x1
LAB_00190a57:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0xcf
CALL 0x001811b0
XOR EBP,EBP
LEA RSI,[0x2daa48]
LEA RDX,[0x184262]
MOV RDI,RBX
CALL 0x00125c00
LAB_00190a81:
LEA RDI,[0x272dd5]
LEA RDX,[0x272e12]
LEA RCX,[0x27537d]
MOV ESI,0x3519
XOR EAX,EAX
CALL 0x00126090
|
/* nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const>::key() const */
int8 __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>
::key(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)
{
int8 uVar1;
int1 *local_40 [2];
int1 local_30 [16];
if (*(char **)this == (char *)0x0) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/./json.hpp",0x3519,
"GGML_ASSERT(%s) failed","m_object != nullptr");
}
if (**(char **)this == '\x01') {
return *(int8 *)(this + 8);
}
uVar1 = __cxa_allocate_exception(0x20);
local_40[0] = local_30;
/* try { // try from 00190a39 to 00190a50 has its CatchHandler @ 00190ac3 */
std::__cxx11::string::_M_construct<char_const*>
(local_40,"cannot use key() for non-object iterators","");
/* try { // try from 00190a57 to 00190a80 has its CatchHandler @ 00190aa2 */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar1,0xcf,local_40,*(int8 *)this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&invalid_iterator::typeinfo,exception::~exception);
}
| |
42,859 | my_fread | eloqsql/mysys/my_fstream.c | size_t my_fread(FILE *stream, uchar *Buffer, size_t Count, myf MyFlags)
{
size_t readbytes;
DBUG_ENTER("my_fread");
DBUG_PRINT("my",("stream: %p Buffer %p Count: %u MyFlags: %lu",
stream, Buffer, (uint) Count, MyFlags));
if ((readbytes= fread(Buffer, sizeof(char), Count, stream)) != Count)
{
DBUG_PRINT("error",("Read only %d bytes", (int) readbytes));
if (MyFlags & (MY_WME | MY_FAE | MY_FNABP))
{
if (ferror(stream))
my_error(EE_READ, MYF(ME_BELL),
my_filename(my_fileno(stream)),errno);
else
if (MyFlags & (MY_NABP | MY_FNABP))
my_error(EE_EOFERR, MYF(ME_BELL),
my_filename(my_fileno(stream)),errno);
}
my_errno=errno ? errno : -1;
if (ferror(stream) || MyFlags & (MY_NABP | MY_FNABP))
DBUG_RETURN((size_t) -1); /* Return with error */
}
if (MyFlags & (MY_NABP | MY_FNABP))
DBUG_RETURN(0); /* Read ok */
DBUG_RETURN(readbytes);
} | O3 | c | my_fread:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %rax
movq %rdi, %r15
movl $0x1, %esi
movq %rax, %rdi
movq %r15, %rcx
callq 0x2a450
movq %rax, %r14
cmpq %r12, %rax
jne 0xa636d
xorl %r12d, %r12d
testb $0x6, %bl
cmoveq %r14, %r12
jmp 0xa63fc
testb $0x1a, %bl
je 0xa63ba
movq %r15, %rdi
callq 0x2a660
movl $0x2, %r12d
testl %eax, %eax
jne 0xa638f
movl $0x9, %r12d
testb $0x6, %bl
je 0xa63ba
movq %r15, %rdi
callq 0x2a9a0
movl %eax, %edi
callq 0xb3eb8
movq %rax, %r13
callq 0x2a7f0
movl (%rax), %ecx
movl $0x4, %esi
movl %r12d, %edi
movq %r13, %rdx
xorl %eax, %eax
callq 0xa5c33
callq 0x2a7f0
movl (%rax), %eax
xorl %r12d, %r12d
cmpl $0x1, %eax
movl $0x0, %r13d
sbbl %r13d, %r13d
orl %eax, %r13d
callq 0xac2be
movl %r13d, (%rax)
movq %r15, %rdi
callq 0x2a660
andl $0x6, %ebx
negq %rbx
movl $0x0, %ecx
sbbq %rcx, %rcx
negl %eax
sbbq %r12, %r12
orq %r14, %r12
orq %rcx, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_fread:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rcx
mov r12, rdx
mov rax, rsi
mov r15, rdi
mov esi, 1
mov rdi, rax
mov rcx, r15
call _fread
mov r14, rax
cmp rax, r12
jnz short loc_A636D
xor r12d, r12d
test bl, 6
cmovz r12, r14
jmp loc_A63FC
loc_A636D:
test bl, 1Ah
jz short loc_A63BA
mov rdi, r15
call _ferror
mov r12d, 2
test eax, eax
jnz short loc_A638F
mov r12d, 9
test bl, 6
jz short loc_A63BA
loc_A638F:
mov rdi, r15
call _fileno
mov edi, eax
call my_filename
mov r13, rax
call ___errno_location
mov ecx, [rax]
mov esi, 4
mov edi, r12d
mov rdx, r13
xor eax, eax
call my_error
loc_A63BA:
call ___errno_location
mov eax, [rax]
xor r12d, r12d
cmp eax, 1
mov r13d, 0
sbb r13d, r13d
or r13d, eax
call _my_thread_var
mov [rax], r13d
mov rdi, r15
call _ferror
and ebx, 6
neg rbx
mov ecx, 0
sbb rcx, rcx
neg eax
sbb r12, r12
or r12, r14
or r12, rcx
loc_A63FC:
mov rax, r12
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_fread(long long a1, long long a2, long long a3, char a4)
{
long long v7; // rdi
long long v8; // rax
long long v9; // r14
long long v10; // r12
unsigned int v11; // r12d
long long v12; // rdi
long long v13; // r13
unsigned int *v14; // rax
_DWORD *v15; // rax
int v16; // r13d
v7 = a2;
v8 = fread(a2, 1LL, a3, a1);
v9 = v8;
if ( v8 == a3 )
{
v10 = 0LL;
if ( (a4 & 6) == 0 )
return v8;
}
else
{
if ( (a4 & 0x1A) != 0 )
{
v7 = a1;
v11 = 2;
if ( (unsigned int)ferror(a1) || (v11 = 9, (a4 & 6) != 0) )
{
v12 = (unsigned int)fileno(a1);
v13 = my_filename(v12);
v14 = (unsigned int *)__errno_location(v12);
v7 = v11;
my_error(v11, 4LL, v13, *v14);
}
}
v15 = (_DWORD *)__errno_location(v7);
v16 = *v15 == 0 ? -1 : *v15;
*(_DWORD *)my_thread_var(v7) = v16;
return -(long long)((a4 & 6) != 0LL) | v9 | -(long long)((unsigned int)ferror(a1) != 0);
}
return v10;
}
| my_fread:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R12,RDX
MOV RAX,RSI
MOV R15,RDI
MOV ESI,0x1
MOV RDI,RAX
MOV RCX,R15
CALL 0x0012a450
MOV R14,RAX
CMP RAX,R12
JNZ 0x001a636d
XOR R12D,R12D
TEST BL,0x6
CMOVZ R12,R14
JMP 0x001a63fc
LAB_001a636d:
TEST BL,0x1a
JZ 0x001a63ba
MOV RDI,R15
CALL 0x0012a660
MOV R12D,0x2
TEST EAX,EAX
JNZ 0x001a638f
MOV R12D,0x9
TEST BL,0x6
JZ 0x001a63ba
LAB_001a638f:
MOV RDI,R15
CALL 0x0012a9a0
MOV EDI,EAX
CALL 0x001b3eb8
MOV R13,RAX
CALL 0x0012a7f0
MOV ECX,dword ptr [RAX]
MOV ESI,0x4
MOV EDI,R12D
MOV RDX,R13
XOR EAX,EAX
CALL 0x001a5c33
LAB_001a63ba:
CALL 0x0012a7f0
MOV EAX,dword ptr [RAX]
XOR R12D,R12D
CMP EAX,0x1
MOV R13D,0x0
SBB R13D,R13D
OR R13D,EAX
CALL 0x001ac2be
MOV dword ptr [RAX],R13D
MOV RDI,R15
CALL 0x0012a660
AND EBX,0x6
NEG RBX
MOV ECX,0x0
SBB RCX,RCX
NEG EAX
SBB R12,R12
OR R12,R14
OR R12,RCX
LAB_001a63fc:
MOV RAX,R12
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
size_t my_fread(FILE *param_1,void *param_2,size_t param_3,ulong param_4)
{
uint uVar1;
int iVar2;
size_t sVar3;
int8 uVar4;
int *piVar5;
uint *puVar6;
int8 uVar7;
ulong uVar8;
sVar3 = fread(param_2,1,param_3,param_1);
if (sVar3 == param_3) {
uVar8 = 0;
if ((param_4 & 6) == 0) {
uVar8 = sVar3;
}
}
else {
if ((param_4 & 0x1a) != 0) {
iVar2 = ferror(param_1);
uVar7 = 2;
if ((iVar2 != 0) || (uVar7 = 9, (param_4 & 6) != 0)) {
iVar2 = fileno(param_1);
uVar4 = my_filename(iVar2);
piVar5 = __errno_location();
my_error(uVar7,4,uVar4,*piVar5);
}
}
puVar6 = (uint *)__errno_location();
uVar1 = *puVar6;
puVar6 = (uint *)_my_thread_var();
*puVar6 = -(uint)(uVar1 == 0) | uVar1;
iVar2 = ferror(param_1);
uVar8 = -(ulong)(iVar2 != 0) | sVar3 | -(ulong)((param_4 & 6) != 0);
}
return uVar8;
}
| |
42,860 | minja::Parser::parseNumber(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&) | monkey531[P]llama/common/minja.hpp | json parseNumber(CharIterator& it, const CharIterator& end) {
auto before = it;
consumeSpaces();
auto start = it;
bool hasDecimal = false;
bool hasExponent = false;
if (it != end && (*it == '-' || *it == '+')) ++it;
while (it != end) {
if (std::isdigit(*it)) {
++it;
} else if (*it == '.') {
if (hasDecimal) throw std::runtime_error("Multiple decimal points");
hasDecimal = true;
++it;
} else if (it != start && (*it == 'e' || *it == 'E')) {
if (hasExponent) throw std::runtime_error("Multiple exponents");
hasExponent = true;
++it;
} else {
break;
}
}
if (start == it) {
it = before;
return json(); // No valid characters found
}
std::string str(start, it);
try {
return json::parse(str);
} catch (json::parse_error& e) {
throw std::runtime_error("Failed to parse number: '" + str + "' (" + std::string(e.what()) + ")");
return json();
}
} | O3 | cpp | minja::Parser::parseNumber(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char const*, 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 $0xf8, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdx), %r9
movq 0x18(%rsi), %rbp
movq 0x20(%rsi), %r13
movq %r9, %rsi
cmpq %rbp, %r13
je 0xaf8d2
movq %rbx, 0x8(%rsp)
movq %r9, %rbx
movsbl (%r13), %edi
callq 0x1d0d0
testl %eax, %eax
je 0xaf8c7
incq %r13
movq %r13, 0x20(%r12)
cmpq %rbp, %r13
jne 0xaf8ac
movq (%r14), %rsi
movq %rbx, %r9
movq 0x8(%rsp), %rbx
movq (%r15), %rax
cmpq %rsi, %rax
je 0xaf9bc
movzbl (%rsi), %ecx
cmpl $0x2d, %ecx
je 0xaf8ee
movq %rsi, %rdx
cmpl $0x2b, %ecx
jne 0xaf8f8
leaq 0x1(%rsi), %rdx
movq %rdx, (%r14)
movq (%r15), %rax
cmpq %rax, %rdx
je 0xaf945
xorl %eax, %eax
xorl %ecx, %ecx
movsbl (%rdx), %edi
leal -0x30(%rdi), %r8d
cmpl $0xa, %r8d
jb 0xaf93a
movzbl %dil, %edi
cmpl $0x2e, %edi
jne 0xaf922
testb $0x1, %al
movb $0x1, %al
je 0xaf93a
jmp 0xaf9f9
cmpq %rsi, %rdx
je 0xaf945
orl $0x20, %edi
cmpl $0x65, %edi
jne 0xaf945
testb $0x1, %cl
movb $0x1, %cl
jne 0xafa17
incq %rdx
movq %rdx, (%r14)
cmpq (%r15), %rdx
jne 0xaf901
cmpq %rsi, %rdx
je 0xaf9bc
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x10(%rsp), %rdi
callq 0x94760
xorps %xmm0, %xmm0
leaq 0x90(%rsp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0xb0270
movq 0xa0(%rsp), %rax
testq %rax, %rax
je 0xaf9a3
leaq 0x90(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0xaf9e4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1dc50
jmp 0xaf9e4
movq %r9, (%r14)
movb $0x0, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x89876
movq %rbx, %rdi
movl $0x1, %esi
callq 0x89876
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1d5b0
movq %rax, %rbx
leaq 0x65cb9(%rip), %rsi # 0x1156c6
movq %rax, %rdi
callq 0x1d410
jmp 0xafa33
movl $0x10, %edi
callq 0x1d5b0
movq %rax, %rbx
leaq 0x65cb3(%rip), %rsi # 0x1156de
movq %rax, %rdi
callq 0x1d410
movq 0xa65ae(%rip), %rsi # 0x155fe8
movq 0xa6517(%rip), %rdx # 0x155f58
movq %rbx, %rdi
callq 0x1e5b0
jmp 0xafcbe
movq %rdx, %rbx
movq %rax, %r14
movq 0xa0(%rsp), %rax
testq %rax, %rax
je 0xafa73
leaq 0x90(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
cmpl $0x1, %ebx
jne 0xafca3
movq %r14, %rdi
callq 0x1d480
movq %rax, %r14
movl $0x10, %edi
callq 0x1d5b0
movq %rax, %rbx
leaq 0x65c56(%rip), %rsi # 0x1156f1
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x26b0d
leaq 0x65c5a(%rip), %rsi # 0x11570b
leaq 0x50(%rsp), %rdi
callq 0x1e870
leaq 0x40(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xafade
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0xafaeb
movq %rdx, 0x30(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x40(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x38(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
leaq 0xb8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x256d6
leaq 0xd8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0xb8(%rsp), %rdx
callq 0x9ce45
leaq 0x6a191(%rip), %rsi # 0x119cd3
leaq 0xd8(%rsp), %rdi
callq 0x1e870
leaq 0x80(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xafb74
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0xafb84
movq %rdx, 0x70(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x80(%rsp)
movq 0x8(%rax), %rdx
leaq 0x70(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x1e430
xorl %ebp, %ebp
movq 0xa6434(%rip), %rsi # 0x155fe8
movq 0xa639d(%rip), %rdx # 0x155f58
movq %rbx, %rdi
callq 0x1e5b0
movq %rax, %r14
movq 0x70(%rsp), %rdi
cmpq %r13, %rdi
je 0xafbe8
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x1dc50
jmp 0xafbe8
movq %rax, %r14
movb $0x1, %bpl
leaq 0xe8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xafc11
movq 0xe8(%rsp), %rsi
incq %rsi
callq 0x1dc50
jmp 0xafc11
movq %rax, %r14
movb $0x1, %bpl
leaq 0xc8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xafc3a
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x1dc50
jmp 0xafc3a
movq %rax, %r14
movb $0x1, %bpl
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0xafc51
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1dc50
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xafc6c
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1dc50
testb %bpl, %bpl
jne 0xafc96
jmp 0xafc9e
movq %rax, %r14
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xafc96
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1dc50
jmp 0xafc96
movq %rax, %r14
movq %rbx, %rdi
callq 0x1d8c0
callq 0x1e470
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0xafcd8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1dc50
jmp 0xafcd8
jmp 0xafcbe
movq %rax, %rdi
callq 0x26531
movq %rax, %r14
jmp 0xafcd8
jmp 0xafccd
movq %rax, %r14
movq %rbx, %rdi
callq 0x1d8c0
movq %r14, %rdi
callq 0x1e660
| _ZN5minja6Parser11parseNumberERN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERKSB_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0F8h
mov r15, rcx
mov r14, rdx
mov r12, rsi
mov rbx, rdi
mov r9, [rdx]
mov rbp, [rsi+18h]
mov r13, [rsi+20h]
mov rsi, r9
cmp r13, rbp
jz short loc_AF8D2
mov [rsp+128h+var_120], rbx
mov rbx, r9
loc_AF8AC:
movsx edi, byte ptr [r13+0]
call _isspace
test eax, eax
jz short loc_AF8C7
inc r13
mov [r12+20h], r13
cmp r13, rbp
jnz short loc_AF8AC
loc_AF8C7:
mov rsi, [r14]
mov r9, rbx
mov rbx, [rsp+128h+var_120]
loc_AF8D2:
mov rax, [r15]
cmp rax, rsi
jz loc_AF9BC
movzx ecx, byte ptr [rsi]
cmp ecx, 2Dh ; '-'
jz short loc_AF8EE
mov rdx, rsi
cmp ecx, 2Bh ; '+'
jnz short loc_AF8F8
loc_AF8EE:
lea rdx, [rsi+1]
mov [r14], rdx
mov rax, [r15]
loc_AF8F8:
cmp rdx, rax
jz short loc_AF945
xor eax, eax
xor ecx, ecx
loc_AF901:
movsx edi, byte ptr [rdx]
lea r8d, [rdi-30h]
cmp r8d, 0Ah
jb short loc_AF93A
movzx edi, dil
cmp edi, 2Eh ; '.'
jnz short loc_AF922
test al, 1
mov al, 1
jz short loc_AF93A
jmp loc_AF9F9
loc_AF922:
cmp rdx, rsi
jz short loc_AF945
or edi, 20h
cmp edi, 65h ; 'e'
jnz short loc_AF945
test cl, 1
mov cl, 1
jnz loc_AFA17
loc_AF93A:
inc rdx
mov [r14], rdx
cmp rdx, [r15]
jnz short loc_AF901
loc_AF945:
cmp rdx, rsi
jz short loc_AF9BC
lea r15, [rsp+128h+var_108]
mov [r15-10h], r15
lea rdi, [rsp+128h+var_118]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIN9__gnu_cxx17__normal_iteratorIPKcS4_EEEEvT_SB_St20forward_iterator_tag; std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::forward_iterator_tag)
xorps xmm0, xmm0
lea rdx, [rsp+128h+var_98]
movaps xmmword ptr [rdx+10h], xmm0
movaps xmmword ptr [rdx], xmm0
lea rsi, [rsp+128h+var_118]
mov rdi, rbx
mov ecx, 1
xor r8d, r8d
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5parseIRS9_EESD_OT_St8functionIFbiNS0_6detail13parse_event_tERSD_EEbb; 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>::parse<std::string&>(std::string&,std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)>,bool,bool)
mov rax, [rsp+128h+var_88]
test rax, rax
jz short loc_AF9A3
lea rdi, [rsp+128h+var_98]
mov rsi, rdi
mov edx, 3
call rax
loc_AF9A3:
mov rdi, [rsp+128h+var_118]; void *
cmp rdi, r15
jz short loc_AF9E4
mov rsi, [rsp+128h+var_108]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_AF9E4
loc_AF9BC:
mov [r14], r9
mov byte ptr [rbx], 0
mov qword ptr [rbx+8], 0
mov rdi, rbx
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
loc_AF9E4:
mov rax, rbx
add rsp, 0F8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_AF9F9:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aMultipleDecima; "Multiple decimal points"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_AFA33
loc_AFA17:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aMultipleExpone; "Multiple exponents"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_AFA33:
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp loc_AFCBE
mov rbx, rdx
mov r14, rax
mov rax, [rsp+128h+var_88]
test rax, rax
jz short loc_AFA73
lea rdi, [rsp+128h+var_98]
mov rsi, rdi
mov edx, 3
call rax
loc_AFA73:
cmp ebx, 1
jnz loc_AFCA3
mov rdi, r14; void *
call ___cxa_begin_catch
mov r14, rax
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aFailedToParseN; "Failed to parse number: '"
lea rdi, [rsp+128h+var_D8]
lea rdx, [rsp+128h+var_118]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
lea rsi, asc_11570B; "' ("
lea rdi, [rsp+128h+var_D8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea r12, [rsp+128h+var_E8]
mov [r12-10h], r12
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jnz short loc_AFADE
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r12], xmm0
jmp short loc_AFAEB
loc_AFADE:
mov [rsp+128h+var_F8], rdx
mov rdx, [rcx]
mov [rsp+128h+var_E8], rdx
loc_AFAEB:
mov rdx, [rax+8]
mov [rsp+128h+var_F0], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+10h]
lea rdi, [rsp+128h+var_70]
lea rdx, [rsp+128h+var_121]
mov rsi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rdi, [rsp+128h+var_50]
lea rsi, [rsp+128h+var_F8]
lea rdx, [rsp+128h+var_70]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
lea rsi, a09401910201912+51h; ")"
lea rdi, [rsp+128h+var_50]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea r13, [rsp+128h+var_A8]
mov [r13-10h], r13
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jnz short loc_AFB74
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r13+0], xmm0
jmp short loc_AFB84
loc_AFB74:
mov [rsp+128h+var_B8], rdx
mov rdx, [rcx]
mov [rsp+128h+var_A8], rdx
loc_AFB84:
mov rdx, [rax+8]
lea rsi, [rsp+128h+var_B8]
mov [rsi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov bpl, 1
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, [rsp+128h+var_B8]; void *
cmp rdi, r13
jz short loc_AFBE8
mov rsi, [rsp+128h+var_A8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_AFBE8
mov r14, rax
mov bpl, 1
loc_AFBE8:
lea rax, [rsp+128h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_AFC11
mov rsi, [rsp+128h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_AFC11
mov r14, rax
mov bpl, 1
loc_AFC11:
lea rax, [rsp+128h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_AFC3A
mov rsi, [rsp+128h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_AFC3A
mov r14, rax
mov bpl, 1
loc_AFC3A:
mov rdi, [rsp+128h+var_F8]; void *
cmp rdi, r12
jz short loc_AFC51
mov rsi, [rsp+128h+var_E8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AFC51:
lea rax, [rsp+128h+var_C8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_AFC6C
mov rsi, [rsp+128h+var_C8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AFC6C:
test bpl, bpl
jnz short loc_AFC96
jmp short loc_AFC9E
mov r14, rax
lea rax, [rsp+128h+var_C8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_AFC96
mov rsi, [rsp+128h+var_C8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_AFC96
mov r14, rax
loc_AFC96:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_AFC9E:
call ___cxa_end_catch
loc_AFCA3:
mov rdi, [rsp+128h+var_118]; void *
cmp rdi, r15
jz short loc_AFCD8
mov rsi, [rsp+128h+var_108]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_AFCD8
jmp short $+2
loc_AFCBE:
mov rdi, rax
call __clang_call_terminate
mov r14, rax
jmp short loc_AFCD8
jmp short $+2
loc_AFCCD:
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
loc_AFCD8:
mov rdi, r14
call __Unwind_Resume
| long long minja::Parser::parseNumber(long long a1, long long a2, char **a3, char **a4)
{
long long v7; // rbx
char *v8; // r9
char *v9; // rbp
char *v10; // r13
char *v11; // rsi
char *v12; // rbx
char *v13; // rax
int v14; // ecx
char *v15; // rdx
char v16; // al
char v17; // cl
int v18; // edi
bool v19; // zf
std::runtime_error *exception; // rbx
void *v22[2]; // [rsp+10h] [rbp-118h] BYREF
_QWORD v23[2]; // [rsp+20h] [rbp-108h] BYREF
__int128 v24; // [rsp+90h] [rbp-98h] BYREF
__int128 v25; // [rsp+A0h] [rbp-88h]
v7 = a1;
v8 = *a3;
v9 = *(char **)(a2 + 24);
v10 = *(char **)(a2 + 32);
v11 = *a3;
if ( v10 != v9 )
{
v12 = *a3;
do
{
if ( !(unsigned int)isspace((unsigned int)*v10) )
break;
*(_QWORD *)(a2 + 32) = ++v10;
}
while ( v10 != v9 );
v11 = *a3;
v8 = v12;
v7 = a1;
}
v13 = *a4;
if ( *a4 == v11 )
goto LABEL_25;
v14 = (unsigned __int8)*v11;
if ( v14 == 45 || (v15 = v11, v14 == 43) )
{
v15 = v11 + 1;
*a3 = v11 + 1;
v13 = *a4;
}
if ( v15 != v13 )
{
v16 = 0;
v17 = 0;
do
{
v18 = *v15;
if ( (unsigned int)(v18 - 48) >= 0xA )
{
if ( (unsigned __int8)v18 == 46 )
{
v19 = (v16 & 1) == 0;
v16 = 1;
if ( !v19 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Multiple decimal points");
goto LABEL_28;
}
}
else
{
if ( v15 == v11 || ((unsigned __int8)v18 | 0x20) != 0x65 )
break;
v19 = (v17 & 1) == 0;
v17 = 1;
if ( !v19 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Multiple exponents");
LABEL_28:
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
}
}
*a3 = ++v15;
}
while ( v15 != *a4 );
}
if ( v15 == v11 )
{
LABEL_25:
*a3 = v8;
*(_BYTE *)v7 = 0;
*(_QWORD *)(v7 + 8) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)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>::assert_invariant((char *)v7);
}
else
{
v22[0] = v23;
std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>((long long)v22, v11, (long long)v15);
v25 = 0LL;
v24 = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::parse<std::string&>(
v7,
v22,
&v24,
1LL,
0LL);
if ( (_QWORD)v25 )
((void ( *)(__int128 *, __int128 *, long long))v25)(&v24, &v24, 3LL);
if ( v22[0] != v23 )
operator delete(v22[0], v23[0] + 1LL);
}
return v7;
}
| parseNumber:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xf8
MOV R15,RCX
MOV R14,RDX
MOV R12,RSI
MOV RBX,RDI
MOV R9,qword ptr [RDX]
MOV RBP,qword ptr [RSI + 0x18]
MOV R13,qword ptr [RSI + 0x20]
MOV RSI,R9
CMP R13,RBP
JZ 0x001af8d2
MOV qword ptr [RSP + 0x8],RBX
MOV RBX,R9
LAB_001af8ac:
MOVSX EDI,byte ptr [R13]
CALL 0x0011d0d0
TEST EAX,EAX
JZ 0x001af8c7
INC R13
MOV qword ptr [R12 + 0x20],R13
CMP R13,RBP
JNZ 0x001af8ac
LAB_001af8c7:
MOV RSI,qword ptr [R14]
MOV R9,RBX
MOV RBX,qword ptr [RSP + 0x8]
LAB_001af8d2:
MOV RAX,qword ptr [R15]
CMP RAX,RSI
JZ 0x001af9bc
MOVZX ECX,byte ptr [RSI]
CMP ECX,0x2d
JZ 0x001af8ee
MOV RDX,RSI
CMP ECX,0x2b
JNZ 0x001af8f8
LAB_001af8ee:
LEA RDX,[RSI + 0x1]
MOV qword ptr [R14],RDX
MOV RAX,qword ptr [R15]
LAB_001af8f8:
CMP RDX,RAX
JZ 0x001af945
XOR EAX,EAX
XOR ECX,ECX
LAB_001af901:
MOVSX EDI,byte ptr [RDX]
LEA R8D,[RDI + -0x30]
CMP R8D,0xa
JC 0x001af93a
MOVZX EDI,DIL
CMP EDI,0x2e
JNZ 0x001af922
TEST AL,0x1
MOV AL,0x1
JZ 0x001af93a
JMP 0x001af9f9
LAB_001af922:
CMP RDX,RSI
JZ 0x001af945
OR EDI,0x20
CMP EDI,0x65
JNZ 0x001af945
TEST CL,0x1
MOV CL,0x1
JNZ 0x001afa17
LAB_001af93a:
INC RDX
MOV qword ptr [R14],RDX
CMP RDX,qword ptr [R15]
JNZ 0x001af901
LAB_001af945:
CMP RDX,RSI
JZ 0x001af9bc
LEA R15,[RSP + 0x20]
MOV qword ptr [R15 + -0x10],R15
LAB_001af953:
LEA RDI,[RSP + 0x10]
CALL 0x00194760
XORPS XMM0,XMM0
LEA RDX,[RSP + 0x90]
MOVAPS xmmword ptr [RDX + 0x10],XMM0
MOVAPS xmmword ptr [RDX],XMM0
LAB_001af96f:
LEA RSI,[RSP + 0x10]
MOV RDI,RBX
MOV ECX,0x1
XOR R8D,R8D
CALL 0x001b0270
MOV RAX,qword ptr [RSP + 0xa0]
TEST RAX,RAX
JZ 0x001af9a3
LAB_001af991:
LEA RDI,[RSP + 0x90]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001af9a3:
MOV RDI,qword ptr [RSP + 0x10]
CMP RDI,R15
JZ 0x001af9e4
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x0011dc50
JMP 0x001af9e4
LAB_001af9bc:
MOV qword ptr [R14],R9
MOV byte ptr [RBX],0x0
MOV qword ptr [RBX + 0x8],0x0
MOV RDI,RBX
MOV ESI,0x1
CALL 0x00189876
MOV RDI,RBX
MOV ESI,0x1
CALL 0x00189876
LAB_001af9e4:
MOV RAX,RBX
ADD RSP,0xf8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001af9f9:
MOV EDI,0x10
CALL 0x0011d5b0
MOV RBX,RAX
LAB_001afa06:
LEA RSI,[0x2156c6]
MOV RDI,RAX
CALL 0x0011d410
LAB_001afa15:
JMP 0x001afa33
LAB_001afa17:
MOV EDI,0x10
CALL 0x0011d5b0
MOV RBX,RAX
LAB_001afa24:
LEA RSI,[0x2156de]
MOV RDI,RAX
CALL 0x0011d410
LAB_001afa33:
MOV RSI,qword ptr [0x00255fe8]
MOV RDX,qword ptr [0x00255f58]
MOV RDI,RBX
CALL 0x0011e5b0
|
/* minja::Parser::parseNumber(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::string >&,
__gnu_cxx::__normal_iterator<char const*, std::__cxx11::string > const&) */
__normal_iterator *
minja::Parser::parseNumber(__normal_iterator *param_1,__normal_iterator *param_2)
{
byte bVar1;
byte *pbVar2;
char *pcVar3;
bool bVar4;
bool bVar5;
bool bVar6;
int iVar7;
byte *pbVar8;
runtime_error *this;
bool bVar9;
int8 *in_RCX;
long *in_RDX;
byte *pbVar10;
byte *pbVar11;
char *pcVar12;
long *local_118 [2];
long local_108 [14];
int8 local_98;
int8 uStack_90;
code *local_88;
int8 uStack_80;
pbVar2 = (byte *)*in_RDX;
pcVar3 = *(char **)(param_2 + 0x18);
pcVar12 = *(char **)(param_2 + 0x20);
pbVar11 = pbVar2;
if (pcVar12 != pcVar3) {
do {
iVar7 = isspace((int)*pcVar12);
if (iVar7 == 0) break;
pcVar12 = pcVar12 + 1;
*(char **)(param_2 + 0x20) = pcVar12;
} while (pcVar12 != pcVar3);
pbVar11 = (byte *)*in_RDX;
}
pbVar8 = (byte *)*in_RCX;
if (pbVar8 != pbVar11) {
if ((*pbVar11 == 0x2d) || (pbVar10 = pbVar11, *pbVar11 == 0x2b)) {
pbVar10 = pbVar11 + 1;
*in_RDX = (long)pbVar10;
pbVar8 = (byte *)*in_RCX;
}
if (pbVar10 != pbVar8) {
bVar6 = false;
bVar9 = false;
do {
bVar1 = *pbVar10;
bVar4 = bVar6;
bVar5 = bVar9;
if (9 < (int)(char)bVar1 - 0x30U) {
if (bVar1 == 0x2e) {
bVar4 = true;
if (bVar6) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001afa06 to 001afa14 has its CatchHandler @ 001afccd */
std::runtime_error::runtime_error(this,"Multiple decimal points");
LAB_001afa33:
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_00255fe8,PTR__runtime_error_00255f58);
}
}
else {
if ((pbVar10 == pbVar11) || ((bVar1 | 0x20) != 0x65)) break;
bVar5 = true;
if (bVar9) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001afa24 to 001afa32 has its CatchHandler @ 001afccb */
std::runtime_error::runtime_error(this,"Multiple exponents");
goto LAB_001afa33;
}
}
}
bVar9 = bVar5;
bVar6 = bVar4;
pbVar10 = pbVar10 + 1;
*in_RDX = (long)pbVar10;
} while (pbVar10 != (byte *)*in_RCX);
}
if (pbVar10 != pbVar11) {
/* try { // try from 001af953 to 001af95c has its CatchHandler @ 001afcc6 */
local_118[0] = local_108;
std::__cxx11::string::
_M_construct<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>(local_118);
local_88 = (code *)0x0;
uStack_80 = 0;
local_98 = 0;
uStack_90 = 0;
/* try { // try from 001af96f to 001af983 has its CatchHandler @ 001afa4e */
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>
::parse<std::__cxx11::string&>
((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1,local_118,&local_98,1,0);
if (local_88 != (code *)0x0) {
/* try { // try from 001af991 to 001af9a2 has its CatchHandler @ 001afa49 */
(*local_88)(&local_98,&local_98,3);
}
if (local_118[0] == local_108) {
return param_1;
}
operator_delete(local_118[0],local_108[0] + 1);
return param_1;
}
}
*in_RDX = (long)pbVar2;
*param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(param_1,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(param_1,0));
return param_1;
}
| |
42,861 | js_object_preventExtensions | bluesky950520[P]quickjs/quickjs.c | static JSValue js_object_preventExtensions(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int reflect)
{
JSValue obj;
int ret;
obj = argv[0];
if (JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT) {
if (reflect)
return JS_ThrowTypeErrorNotAnObject(ctx);
else
return js_dup(obj);
}
ret = JS_PreventExtensions(ctx, obj);
if (ret < 0)
return JS_EXCEPTION;
if (reflect) {
return js_bool(ret);
} else {
if (!ret)
return JS_ThrowTypeError(ctx, "proxy preventExtensions handler returned false");
return js_dup(obj);
}
} | O1 | c | js_object_preventExtensions:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %rdi, %r15
movq (%r8), %rbx
movq 0x8(%r8), %r14
cmpl $-0x1, %r14d
je 0x7056c
testl %ebp, %ebp
je 0x7053c
leaq 0x2eaff(%rip), %rsi # 0x9f025
xorl %ebx, %ebx
movq %r15, %rdi
xorl %eax, %eax
callq 0x22567
movl $0x6, %r14d
xorl %ecx, %ecx
jmp 0x70559
movq %rbx, (%rsp)
cmpl $-0x9, %r14d
jb 0x7054c
movq (%rsp), %rax
incl (%rax)
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rbx, %rcx
movl %ebx, %eax
orq %rcx, %rax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xf726
testl %eax, %eax
js 0x70591
testl %ebp, %ebp
je 0x7059d
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
movl $0x1, %r14d
jmp 0x70538
xorl %ebx, %ebx
xorl %ecx, %ecx
movl $0x6, %r14d
jmp 0x70559
testl %eax, %eax
je 0x705a5
incl (%rbx)
jmp 0x7054c
leaq 0x3133c(%rip), %rsi # 0xa18e8
xorl %ebx, %ebx
movq %r15, %rdi
xorl %eax, %eax
callq 0x22567
jmp 0x70593
| js_object_preventExtensions:
push rbp
push r15
push r14
push rbx
push rax
mov ebp, r9d
mov r15, rdi
mov rbx, [r8]
mov r14, [r8+8]
cmp r14d, 0FFFFFFFFh
jz short loc_7056C
test ebp, ebp
jz short loc_7053C
lea rsi, aOperandPrototy+20h; "not an object"
xor ebx, ebx
mov rdi, r15
xor eax, eax
call JS_ThrowTypeError
mov r14d, 6
loc_70538:
xor ecx, ecx
jmp short loc_70559
loc_7053C:
mov [rsp+28h+var_28], rbx
cmp r14d, 0FFFFFFF7h
jb short loc_7054C
mov rax, [rsp+28h+var_28]
inc dword ptr [rax]
loc_7054C:
mov rcx, 0FFFFFFFF00000000h
and rcx, rbx
loc_70559:
mov eax, ebx
or rax, rcx
mov rdx, r14
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_7056C:
mov rdi, r15
mov rsi, rbx
mov rdx, r14
call JS_PreventExtensions
test eax, eax
js short loc_70591
test ebp, ebp
jz short loc_7059D
xor ebx, ebx
test eax, eax
setnz bl
mov r14d, 1
jmp short loc_70538
loc_70591:
xor ebx, ebx
loc_70593:
xor ecx, ecx
mov r14d, 6
jmp short loc_70559
loc_7059D:
test eax, eax
jz short loc_705A5
inc dword ptr [rbx]
jmp short loc_7054C
loc_705A5:
lea rsi, aProxyPreventex; "proxy preventExtensions handler returne"...
xor ebx, ebx
mov rdi, r15
xor eax, eax
call JS_ThrowTypeError
jmp short loc_70593
| unsigned long long js_object_preventExtensions(
long long a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long *a13,
long long a14)
{
char v14; // al
int v15; // ebp
long long v16; // rbx
long long v17; // r14
unsigned long long v18; // rcx
int v20; // eax
long long v21; // rdx
long long v22; // rcx
long long v23; // r8
long long v24; // r9
__m128 v25; // xmm4
__m128 v26; // xmm5
char v27; // [rsp+0h] [rbp-28h]
v27 = v14;
v15 = a14;
v16 = *a13;
v17 = a13[1];
if ( (_DWORD)v17 == -1 )
{
v20 = JS_PreventExtensions(a1, *a13, -1);
if ( v20 < 0 )
{
LODWORD(v16) = 0;
}
else
{
if ( v15 )
{
LODWORD(v16) = v20 != 0;
goto LABEL_4;
}
if ( v20 )
{
++*(_DWORD *)v16;
LABEL_7:
v18 = v16 & 0xFFFFFFFF00000000LL;
return v18 | (unsigned int)v16;
}
LODWORD(v16) = 0;
JS_ThrowTypeError(
a1,
(long long)"proxy preventExtensions handler returned false",
v21,
v22,
v23,
v24,
a2,
a3,
a4,
a5,
v25,
v26,
a8,
a9,
v27);
}
v18 = 0LL;
return v18 | (unsigned int)v16;
}
if ( !(_DWORD)a14 )
{
if ( (unsigned int)v17 >= 0xFFFFFFF7 )
++*(_DWORD *)*a13;
goto LABEL_7;
}
LODWORD(v16) = 0;
JS_ThrowTypeError(a1, (long long)"not an object", a11, a12, (long long)a13, a14, a2, a3, a4, a5, a6, a7, a8, a9, v14);
LABEL_4:
v18 = 0LL;
return v18 | (unsigned int)v16;
}
| |||
42,862 | js_object_preventExtensions | bluesky950520[P]quickjs/quickjs.c | static JSValue js_object_preventExtensions(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int reflect)
{
JSValue obj;
int ret;
obj = argv[0];
if (JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT) {
if (reflect)
return JS_ThrowTypeErrorNotAnObject(ctx);
else
return js_dup(obj);
}
ret = JS_PreventExtensions(ctx, obj);
if (ret < 0)
return JS_EXCEPTION;
if (reflect) {
return js_bool(ret);
} else {
if (!ret)
return JS_ThrowTypeError(ctx, "proxy preventExtensions handler returned false");
return js_dup(obj);
}
} | O2 | c | js_object_preventExtensions:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r9d, %ebp
movq %rdi, %r15
movq (%r8), %rbx
movq 0x8(%r8), %r14
cmpl $-0x1, %r14d
jne 0x5e7e0
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1dedb
pushq $0x6
popq %r12
testl %eax, %eax
js 0x5e7f6
testl %ebp, %ebp
je 0x5e807
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
pushq $0x1
popq %r14
jmp 0x5e7f2
testl %ebp, %ebp
je 0x5e7ff
movq %r15, %rdi
callq 0x1d5e1
pushq $0x6
popq %r14
xorl %ebx, %ebx
xorl %ecx, %ecx
jmp 0x5e81a
xorl %ebx, %ebx
xorl %ecx, %ecx
movq %r12, %r14
jmp 0x5e81a
cmpl $-0x9, %r14d
jae 0x5e80b
jmp 0x5e80d
testl %eax, %eax
je 0x5e82b
incl (%rbx)
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rbx, %rcx
movl %ebx, %eax
orq %rcx, %rax
movq %r14, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x29ff0(%rip), %rsi # 0x88822
xorl %ebx, %ebx
movq %r15, %rdi
xorl %eax, %eax
callq 0x1c64d
jmp 0x5e7f8
| js_object_preventExtensions:
push rbp
push r15
push r14
push r12
push rbx
mov ebp, r9d
mov r15, rdi
mov rbx, [r8]
mov r14, [r8+8]
cmp r14d, 0FFFFFFFFh
jnz short loc_5E7E0
mov rdi, r15
mov rsi, rbx
mov rdx, r14
call JS_PreventExtensions
push 6
pop r12
test eax, eax
js short loc_5E7F6
test ebp, ebp
jz short loc_5E807
xor ebx, ebx
test eax, eax
setnz bl
push 1
pop r14
jmp short loc_5E7F2
loc_5E7E0:
test ebp, ebp
jz short loc_5E7FF
mov rdi, r15
call JS_ThrowTypeErrorNotAnObject
push 6
pop r14
xor ebx, ebx
loc_5E7F2:
xor ecx, ecx
jmp short loc_5E81A
loc_5E7F6:
xor ebx, ebx
loc_5E7F8:
xor ecx, ecx
mov r14, r12
jmp short loc_5E81A
loc_5E7FF:
cmp r14d, 0FFFFFFF7h
jnb short loc_5E80B
jmp short loc_5E80D
loc_5E807:
test eax, eax
jz short loc_5E82B
loc_5E80B:
inc dword ptr [rbx]
loc_5E80D:
mov rcx, 0FFFFFFFF00000000h
and rcx, rbx
loc_5E81A:
mov eax, ebx
or rax, rcx
mov rdx, r14
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_5E82B:
lea rsi, aProxyPreventex; "proxy preventExtensions handler returne"...
xor ebx, ebx
mov rdi, r15
xor eax, eax
call JS_ThrowTypeError
jmp short loc_5E7F8
| unsigned long long js_object_preventExtensions(
long long a1,
long long a2,
long long a3,
long long a4,
long long *a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
int v14; // ebp
long long v15; // rbx
long long v16; // r14
int v17; // eax
long long v18; // rdx
long long v19; // rcx
long long v20; // r8
long long v21; // r9
__m128 v22; // xmm4
__m128 v23; // xmm5
unsigned long long v24; // rcx
char v26; // [rsp+0h] [rbp-28h]
v14 = a6;
v15 = *a5;
v16 = a5[1];
if ( (_DWORD)v16 != -1 )
{
if ( (_DWORD)a6 )
{
JS_ThrowTypeErrorNotAnObject(a1, a7, a8, a9, a10, a11, a12, a13, a14, a2, a3, a4, (long long)a5, a6, v26);
LODWORD(v15) = 0;
goto LABEL_7;
}
if ( (unsigned int)v16 < 0xFFFFFFF7 )
{
LABEL_14:
v24 = v15 & 0xFFFFFFFF00000000LL;
return v24 | (unsigned int)v15;
}
LABEL_13:
++*(_DWORD *)v15;
goto LABEL_14;
}
v17 = JS_PreventExtensions(a1, *a5, v16, a7, a8, a9, a10, *(double *)a11.m128_u64, *(double *)a12.m128_u64, a13, a14);
if ( v17 < 0 )
{
LODWORD(v15) = 0;
goto LABEL_9;
}
if ( !v14 )
{
if ( v17 )
goto LABEL_13;
LODWORD(v15) = 0;
JS_ThrowTypeError(
a1,
(long long)"proxy preventExtensions handler returned false",
v18,
v19,
v20,
v21,
a7,
a8,
a9,
a10,
v22,
v23,
a13,
a14,
v26);
LABEL_9:
v24 = 0LL;
return v24 | (unsigned int)v15;
}
LODWORD(v15) = v17 != 0;
LABEL_7:
v24 = 0LL;
return v24 | (unsigned int)v15;
}
| js_object_preventExtensions:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV EBP,R9D
MOV R15,RDI
MOV RBX,qword ptr [R8]
MOV R14,qword ptr [R8 + 0x8]
CMP R14D,-0x1
JNZ 0x0015e7e0
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
CALL 0x0011dedb
PUSH 0x6
POP R12
TEST EAX,EAX
JS 0x0015e7f6
TEST EBP,EBP
JZ 0x0015e807
XOR EBX,EBX
TEST EAX,EAX
SETNZ BL
PUSH 0x1
POP R14
JMP 0x0015e7f2
LAB_0015e7e0:
TEST EBP,EBP
JZ 0x0015e7ff
MOV RDI,R15
CALL 0x0011d5e1
PUSH 0x6
POP R14
XOR EBX,EBX
LAB_0015e7f2:
XOR ECX,ECX
JMP 0x0015e81a
LAB_0015e7f6:
XOR EBX,EBX
LAB_0015e7f8:
XOR ECX,ECX
MOV R14,R12
JMP 0x0015e81a
LAB_0015e7ff:
CMP R14D,-0x9
JNC 0x0015e80b
JMP 0x0015e80d
LAB_0015e807:
TEST EAX,EAX
JZ 0x0015e82b
LAB_0015e80b:
INC dword ptr [RBX]
LAB_0015e80d:
MOV RCX,-0x100000000
AND RCX,RBX
LAB_0015e81a:
MOV EAX,EBX
OR RAX,RCX
MOV RDX,R14
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0015e82b:
LEA RSI,[0x188822]
XOR EBX,EBX
MOV RDI,R15
XOR EAX,EAX
CALL 0x0011c64d
JMP 0x0015e7f8
|
int1 [16] js_object_preventExtensions(int8 param_1)
{
int8 uVar1;
int iVar2;
ulong uVar3;
int *piVar4;
int8 *in_R8;
int in_R9D;
int8 uVar5;
int1 auVar6 [16];
piVar4 = (int *)*in_R8;
uVar1 = in_R8[1];
if ((uint)uVar1 == 0xffffffff) {
iVar2 = JS_PreventExtensions(param_1,piVar4,uVar1);
uVar5 = 6;
if (-1 < iVar2) {
if (in_R9D != 0) {
piVar4 = (int *)(ulong)(iVar2 != 0);
uVar5 = 1;
goto LAB_0015e7f2;
}
if (iVar2 != 0) goto LAB_0015e80b;
JS_ThrowTypeError(param_1,"proxy preventExtensions handler returned false");
}
piVar4 = (int *)0x0;
uVar3 = 0;
}
else {
if (in_R9D == 0) {
if (0xfffffff6 < (uint)uVar1) {
LAB_0015e80b:
*piVar4 = *piVar4 + 1;
}
uVar3 = (ulong)piVar4 & 0xffffffff00000000;
uVar5 = uVar1;
goto LAB_0015e81a;
}
JS_ThrowTypeErrorNotAnObject(param_1);
uVar5 = 6;
piVar4 = (int *)0x0;
LAB_0015e7f2:
uVar3 = 0;
}
LAB_0015e81a:
auVar6._0_8_ = (ulong)piVar4 & 0xffffffff | uVar3;
auVar6._8_8_ = uVar5;
return auVar6;
}
| |
42,863 | glfwWindowHintString | untodesu[P]riteg/build_O1/_deps/glfw-src/src/window.c | GLFWAPI void glfwWindowHintString(int hint, const char* value)
{
assert(value != NULL);
_GLFW_REQUIRE_INIT();
switch (hint)
{
case GLFW_COCOA_FRAME_NAME:
strncpy(_glfw.hints.window.ns.frameName, value,
sizeof(_glfw.hints.window.ns.frameName) - 1);
return;
case GLFW_X11_CLASS_NAME:
strncpy(_glfw.hints.window.x11.className, value,
sizeof(_glfw.hints.window.x11.className) - 1);
return;
case GLFW_X11_INSTANCE_NAME:
strncpy(_glfw.hints.window.x11.instanceName, value,
sizeof(_glfw.hints.window.x11.instanceName) - 1);
return;
}
_glfwInputError(GLFW_INVALID_ENUM, "Invalid window hint string 0x%08X", hint);
} | O1 | c | glfwWindowHintString:
testq %rsi, %rsi
je 0x1d321
leaq 0x8737b(%rip), %rax # 0xa4638
cmpl $0x0, (%rax)
je 0x1d2e3
movl %edi, %edx
cmpl $0x24002, %edi # imm = 0x24002
je 0x1d2f8
cmpl $0x24001, %edx # imm = 0x24001
je 0x1d2f1
cmpl $0x23002, %edx # imm = 0x23002
jne 0x1d30e
movl $0x9c, %edi
jmp 0x1d2fd
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x19081
movl $0x19c, %edi # imm = 0x19C
jmp 0x1d2fd
movl $0x29c, %edi # imm = 0x29C
addq 0x85cbc(%rip), %rdi # 0xa2fc0
movl $0xff, %edx
jmp 0xc440
leaq 0x63064(%rip), %rsi # 0x80379
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
jmp 0x19081
pushq %rax
leaq 0x63015(%rip), %rdi # 0x8033e
leaq 0x62f12(%rip), %rsi # 0x80242
leaq 0x63015(%rip), %rcx # 0x8034c
movl $0x1a0, %edx # imm = 0x1A0
callq 0xc540
| glfwWindowHintString:
test rsi, rsi
jz short loc_1D321
lea rax, _glfw
cmp dword ptr [rax], 0
jz short loc_1D2E3
mov edx, edi
cmp edi, offset loc_24002
jz short loc_1D2F8
cmp edx, 24001h
jz short loc_1D2F1
cmp edx, 23002h
jnz short loc_1D30E
mov edi, 9Ch
jmp short loc_1D2FD
loc_1D2E3:
mov edi, 10001h
xor esi, esi
xor eax, eax
jmp _glfwInputError
loc_1D2F1:
mov edi, 19Ch
jmp short loc_1D2FD
loc_1D2F8:
mov edi, 29Ch
loc_1D2FD:
add rdi, cs:_glfw_ptr
mov edx, 0FFh
jmp _strncpy
loc_1D30E:
lea rsi, aInvalidWindowH_0; "Invalid window hint string 0x%08X"
mov edi, offset loc_10003
xor eax, eax
jmp _glfwInputError
loc_1D321:
push rax
lea rdi, aValueNull; "value != NULL"
lea rsi, aWorkspaceLlm4b_15; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGlfwwindow; "void glfwWindowHintString(int, const ch"...
mov edx, 1A0h
call ___assert_fail
| long long ( * glfwWindowHintString(int a1, long long a2))(_QWORD, _QWORD)
{
long long v2; // rdi
if ( !a2 )
__assert_fail(
"value != NULL",
"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/build_O1/_deps/glfw-src/src/window.c",
416LL,
"void glfwWindowHintString(int, const char *)");
if ( !glfw[0] )
return glfwInputError(0x10001u, 0LL);
if ( a1 == (_DWORD)&loc_24002 )
{
v2 = 167LL;
return (long long ( *)(_QWORD, _QWORD))strncpy(&glfw[v2], a2, 255LL);
}
if ( a1 == 147457 )
{
v2 = 103LL;
return (long long ( *)(_QWORD, _QWORD))strncpy(&glfw[v2], a2, 255LL);
}
if ( a1 == 143362 )
{
v2 = 39LL;
return (long long ( *)(_QWORD, _QWORD))strncpy(&glfw[v2], a2, 255LL);
}
return glfwInputError((unsigned int)&loc_10003, (long long)"Invalid window hint string 0x%08X", a1);
}
| glfwWindowHintString:
TEST RSI,RSI
JZ 0x0011d321
LEA RAX,[0x1a4638]
CMP dword ptr [RAX],0x0
JZ 0x0011d2e3
MOV EDX,EDI
CMP EDI,0x24002
JZ 0x0011d2f8
CMP EDX,0x24001
JZ 0x0011d2f1
CMP EDX,0x23002
JNZ 0x0011d30e
MOV EDI,0x9c
JMP 0x0011d2fd
LAB_0011d2e3:
MOV EDI,0x10001
XOR ESI,ESI
XOR EAX,EAX
JMP 0x00119081
LAB_0011d2f1:
MOV EDI,0x19c
JMP 0x0011d2fd
LAB_0011d2f8:
MOV EDI,0x29c
LAB_0011d2fd:
ADD RDI,qword ptr [0x001a2fc0]
MOV EDX,0xff
JMP 0x0010c440
LAB_0011d30e:
LEA RSI,[0x180379]
MOV EDI,0x10003
XOR EAX,EAX
JMP 0x00119081
LAB_0011d321:
PUSH RAX
LEA RDI,[0x18033e]
LEA RSI,[0x180242]
LEA RCX,[0x18034c]
MOV EDX,0x1a0
CALL 0x0010c540
|
void glfwWindowHintString(int param_1,char *param_2)
{
long lVar1;
if (param_2 == (char *)0x0) {
/* WARNING: Subroutine does not return */
__assert_fail("value != NULL",
"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/build_O1/_deps/glfw-src/src/window.c"
,0x1a0,"void glfwWindowHintString(int, const char *)");
}
if (_glfw != 0) {
if (param_1 == 0x24002) {
lVar1 = 0x29c;
}
else if (param_1 == 0x24001) {
lVar1 = 0x19c;
}
else {
if (param_1 != 0x23002) {
_glfwInputError(0x10003,"Invalid window hint string 0x%08X");
return;
}
lVar1 = 0x9c;
}
strncpy(PTR__glfw_001a2fc0 + lVar1,param_2,0xff);
return;
}
_glfwInputError(0x10001,0);
return;
}
| |
42,864 | translog_scanner_init | eloqsql/storage/maria/ma_loghandler.c | my_bool translog_scanner_init(LSN lsn,
my_bool fixed_horizon,
TRANSLOG_SCANNER_DATA *scanner,
my_bool use_direct)
{
DBUG_ENTER("translog_scanner_init");
DBUG_PRINT("enter", ("Scanner: %p LSN: " LSN_FMT,
scanner, LSN_IN_PARTS(lsn)));
DBUG_ASSERT(translog_status == TRANSLOG_OK ||
translog_status == TRANSLOG_READONLY);
scanner->page_offset= LSN_OFFSET(lsn) % TRANSLOG_PAGE_SIZE;
scanner->fixed_horizon= fixed_horizon;
scanner->use_direct_link= use_direct;
scanner->direct_link= NULL;
scanner->horizon= translog_get_horizon();
DBUG_PRINT("info", ("horizon: " LSN_FMT, LSN_IN_PARTS(scanner->horizon)));
/* lsn < horizon */
DBUG_ASSERT(lsn <= scanner->horizon);
scanner->page_addr= lsn;
scanner->page_addr-= scanner->page_offset; /*decrease offset */
if (translog_scanner_set_last_page(scanner))
DBUG_RETURN(1);
if (translog_scanner_get_page(scanner))
DBUG_RETURN(1);
DBUG_RETURN(0);
} | O0 | c | translog_scanner_init:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movb %sil, %cl
movq %rdi, -0x10(%rbp)
movb %cl, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movb %al, -0x21(%rbp)
jmp 0x540ad
jmp 0x540af
jmp 0x540b1
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x10(%rbp), %rax
andq $0x1fff, %rax # imm = 0x1FFF
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x2028(%rax)
movb -0x11(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x202c(%rax)
movb -0x21(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x202d(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x2020(%rax)
callq 0x55f40
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x2008(%rax)
jmp 0x5410f
jmp 0x54111
jmp 0x54113
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x2000(%rax)
movq -0x20(%rbp), %rax
movl 0x2028(%rax), %eax
movl %eax, %edx
movq -0x20(%rbp), %rax
movq 0x2000(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x2000(%rax)
movq -0x20(%rbp), %rdi
callq 0x55f90
cmpb $0x0, %al
je 0x54158
jmp 0x54152
movb $0x1, -0x1(%rbp)
jmp 0x54173
movq -0x20(%rbp), %rdi
callq 0x56060
cmpb $0x0, %al
je 0x5416d
jmp 0x54167
movb $0x1, -0x1(%rbp)
jmp 0x54173
jmp 0x5416f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| translog_scanner_init:
push rbp
mov rbp, rsp
sub rsp, 30h
mov al, cl
mov cl, sil
mov [rbp+var_10], rdi
mov [rbp+var_11], cl
mov [rbp+var_20], rdx
mov [rbp+var_21], al
jmp short $+2
loc_540AD:
jmp short $+2
loc_540AF:
jmp short $+2
loc_540B1:
mov rax, 0FFFFFFFFh
and rax, [rbp+var_10]
and rax, 1FFFh
mov ecx, eax
mov rax, [rbp+var_20]
mov [rax+2028h], ecx
mov cl, [rbp+var_11]
mov rax, [rbp+var_20]
mov [rax+202Ch], cl
mov cl, [rbp+var_21]
mov rax, [rbp+var_20]
mov [rax+202Dh], cl
mov rax, [rbp+var_20]
mov qword ptr [rax+2020h], 0
call translog_get_horizon
mov rcx, rax
mov rax, [rbp+var_20]
mov [rax+2008h], rcx
jmp short $+2
loc_5410F:
jmp short $+2
loc_54111:
jmp short $+2
loc_54113:
mov rcx, [rbp+var_10]
mov rax, [rbp+var_20]
mov [rax+2000h], rcx
mov rax, [rbp+var_20]
mov eax, [rax+2028h]
mov edx, eax
mov rax, [rbp+var_20]
mov rcx, [rax+2000h]
sub rcx, rdx
mov [rax+2000h], rcx
mov rdi, [rbp+var_20]
call translog_scanner_set_last_page
cmp al, 0
jz short loc_54158
jmp short $+2
loc_54152:
mov [rbp+var_1], 1
jmp short loc_54173
loc_54158:
mov rdi, [rbp+var_20]
call translog_scanner_get_page
cmp al, 0
jz short loc_5416D
jmp short $+2
loc_54167:
mov [rbp+var_1], 1
jmp short loc_54173
loc_5416D:
jmp short $+2
loc_5416F:
mov [rbp+var_1], 0
loc_54173:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| bool translog_scanner_init(long long a1, char a2, long long a3, char a4)
{
*(_DWORD *)(a3 + 8232) = a1 & 0x1FFF;
*(_BYTE *)(a3 + 8236) = a2;
*(_BYTE *)(a3 + 8237) = a4;
*(_QWORD *)(a3 + 8224) = 0LL;
*(_QWORD *)(a3 + 8200) = translog_get_horizon();
*(_QWORD *)(a3 + 0x2000) = a1;
*(_QWORD *)(a3 + 0x2000) -= *(unsigned int *)(a3 + 8232);
return (unsigned __int8)translog_scanner_set_last_page(a3) || (unsigned __int8)translog_scanner_get_page(a3) != 0;
}
| translog_scanner_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV AL,CL
MOV CL,SIL
MOV qword ptr [RBP + -0x10],RDI
MOV byte ptr [RBP + -0x11],CL
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RBP + -0x21],AL
JMP 0x001540ad
LAB_001540ad:
JMP 0x001540af
LAB_001540af:
JMP 0x001540b1
LAB_001540b1:
MOV RAX,0xffffffff
AND RAX,qword ptr [RBP + -0x10]
AND RAX,0x1fff
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x2028],ECX
MOV CL,byte ptr [RBP + -0x11]
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x202c],CL
MOV CL,byte ptr [RBP + -0x21]
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x202d],CL
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x2020],0x0
CALL 0x00155f40
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x2008],RCX
JMP 0x0015410f
LAB_0015410f:
JMP 0x00154111
LAB_00154111:
JMP 0x00154113
LAB_00154113:
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x2000],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x2028]
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX + 0x2000]
SUB RCX,RDX
MOV qword ptr [RAX + 0x2000],RCX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00155f90
CMP AL,0x0
JZ 0x00154158
JMP 0x00154152
LAB_00154152:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00154173
LAB_00154158:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00156060
CMP AL,0x0
JZ 0x0015416d
JMP 0x00154167
LAB_00154167:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00154173
LAB_0015416d:
JMP 0x0015416f
LAB_0015416f:
MOV byte ptr [RBP + -0x1],0x0
LAB_00154173:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1
translog_scanner_init(int8 param_1,int1 param_2,long param_3,int1 param_4)
{
char cVar1;
int8 uVar2;
int1 local_9;
*(uint *)(param_3 + 0x2028) = (uint)param_1 & 0x1fff;
*(int1 *)(param_3 + 0x202c) = param_2;
*(int1 *)(param_3 + 0x202d) = param_4;
*(int8 *)(param_3 + 0x2020) = 0;
uVar2 = translog_get_horizon();
*(int8 *)(param_3 + 0x2008) = uVar2;
*(int8 *)(param_3 + 0x2000) = param_1;
*(ulong *)(param_3 + 0x2000) = *(long *)(param_3 + 0x2000) - (ulong)*(uint *)(param_3 + 0x2028);
cVar1 = translog_scanner_set_last_page(param_3);
if (cVar1 == '\0') {
cVar1 = translog_scanner_get_page(param_3);
if (cVar1 == '\0') {
local_9 = 0;
}
else {
local_9 = 1;
}
}
else {
local_9 = 1;
}
return local_9;
}
| |
42,865 | GetMonitorPosition | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/platforms/rcore_desktop_glfw.c | Vector2 GetMonitorPosition(int monitor)
{
int monitorCount = 0;
GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
if ((monitor >= 0) && (monitor < monitorCount))
{
int x, y;
glfwGetMonitorPos(monitors[monitor], &x, &y);
return (Vector2){ (float)x, (float)y };
}
else TRACELOG(LOG_WARNING, "GLFW: Failed to find selected monitor");
return (Vector2){ 0, 0 };
} | O2 | c | GetMonitorPosition:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
leaq 0xc(%rsp), %rdi
andl $0x0, (%rdi)
callq 0xa6017
testl %ebx, %ebx
js 0x5ecb2
cmpl %ebx, 0xc(%rsp)
jle 0x5ecb2
movl %ebx, %ecx
movq (%rax,%rcx,8), %rdi
leaq 0x14(%rsp), %rbx
leaq 0x10(%rsp), %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0xa60ac
movss (%r14), %xmm0
movss (%rbx), %xmm1
unpcklps %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
cvtdq2ps %xmm1, %xmm0
jmp 0x5ecc6
leaq 0x66dd1(%rip), %rsi # 0xc5a8a
pushq $0x4
popq %rdi
xorl %eax, %eax
callq 0xa128b
xorps %xmm0, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| GetMonitorPosition:
push r14
push rbx
sub rsp, 18h
mov ebx, edi
lea rdi, [rsp+28h+var_1C]
and dword ptr [rdi], 0
call glfwGetMonitors
test ebx, ebx
js short loc_5ECB2
cmp [rsp+28h+var_1C], ebx
jle short loc_5ECB2
mov ecx, ebx
mov rdi, [rax+rcx*8]
lea rbx, [rsp+28h+var_14]
lea r14, [rsp+28h+var_18]
mov rsi, rbx
mov rdx, r14
call glfwGetMonitorPos
movss xmm0, dword ptr [r14]
movss xmm1, dword ptr [rbx]
unpcklps xmm1, xmm0
cvtdq2ps xmm0, xmm1
jmp short loc_5ECC6
loc_5ECB2:
lea rsi, aGlfwFailedToFi_0; "GLFW: Failed to find selected monitor"
push 4
pop rdi
xor eax, eax
call TraceLog
xorps xmm0, xmm0
loc_5ECC6:
add rsp, 18h
pop rbx
pop r14
retn
| double GetMonitorPosition(int a1)
{
long long Monitors; // rax
int v2; // edx
int v3; // ecx
int v4; // r8d
int v5; // r9d
double result; // xmm0_8
int v7; // [rsp+Ch] [rbp-1Ch] BYREF
unsigned int v8; // [rsp+10h] [rbp-18h] BYREF
_DWORD v9[5]; // [rsp+14h] [rbp-14h] BYREF
v7 = 0;
Monitors = glfwGetMonitors(&v7);
if ( a1 < 0 || v7 <= a1 )
{
TraceLog(4, (unsigned int)"GLFW: Failed to find selected monitor", v2, v3, v4, v5);
return 0.0;
}
else
{
glfwGetMonitorPos(*(_QWORD *)(Monitors + 8LL * (unsigned int)a1), v9, &v8);
*(_QWORD *)&result = _mm_cvtepi32_ps((__m128i)_mm_unpacklo_ps((__m128)v9[0], (__m128)v8)).m128_u64[0];
}
return result;
}
| GetMonitorPosition:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV EBX,EDI
LEA RDI,[RSP + 0xc]
AND dword ptr [RDI],0x0
CALL 0x001a6017
TEST EBX,EBX
JS 0x0015ecb2
CMP dword ptr [RSP + 0xc],EBX
JLE 0x0015ecb2
MOV ECX,EBX
MOV RDI,qword ptr [RAX + RCX*0x8]
LEA RBX,[RSP + 0x14]
LEA R14,[RSP + 0x10]
MOV RSI,RBX
MOV RDX,R14
CALL 0x001a60ac
MOVSS XMM0,dword ptr [R14]
MOVSS XMM1,dword ptr [RBX]
UNPCKLPS XMM1,XMM0
CVTDQ2PS XMM0,XMM1
JMP 0x0015ecc6
LAB_0015ecb2:
LEA RSI,[0x1c5a8a]
PUSH 0x4
POP RDI
XOR EAX,EAX
CALL 0x001a128b
XORPS XMM0,XMM0
LAB_0015ecc6:
ADD RSP,0x18
POP RBX
POP R14
RET
|
int8 GetMonitorPosition(uint param_1)
{
long lVar1;
float fVar2;
float fVar3;
int local_18;
int local_14;
lVar1 = glfwGetMonitors();
if (((int)param_1 < 0) || (-1 < (int)param_1)) {
TraceLog(4,"GLFW: Failed to find selected monitor");
fVar2 = 0.0;
fVar3 = 0.0;
}
else {
glfwGetMonitorPos(*(int8 *)(lVar1 + (ulong)param_1 * 8),&local_14,&local_18);
fVar2 = (float)local_14;
fVar3 = (float)local_18;
}
return CONCAT44(fVar3,fVar2);
}
| |
42,866 | GetMonitorPosition | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/platforms/rcore_desktop_glfw.c | Vector2 GetMonitorPosition(int monitor)
{
int monitorCount = 0;
GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
if ((monitor >= 0) && (monitor < monitorCount))
{
int x, y;
glfwGetMonitorPos(monitors[monitor], &x, &y);
return (Vector2){ (float)x, (float)y };
}
else TRACELOG(LOG_WARNING, "GLFW: Failed to find selected monitor");
return (Vector2){ 0, 0 };
} | O3 | c | GetMonitorPosition:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
leaq 0xc(%rsp), %rdi
movl $0x0, (%rdi)
callq 0xbf07a
testl %ebx, %ebx
js 0x70283
cmpl %ebx, 0xc(%rsp)
jle 0x70283
movl %ebx, %ecx
movq (%rax,%rcx,8), %rdi
leaq 0x14(%rsp), %rbx
leaq 0x10(%rsp), %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0xbf112
movss (%r14), %xmm0
movss (%rbx), %xmm1
unpcklps %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
cvtdq2ps %xmm1, %xmm0
jmp 0x70299
leaq 0x6f678(%rip), %rsi # 0xdf902
movl $0x4, %edi
xorl %eax, %eax
callq 0xb9db7
xorps %xmm0, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| GetMonitorPosition:
push r14
push rbx
sub rsp, 18h
mov ebx, edi
lea rdi, [rsp+28h+var_1C]
mov dword ptr [rdi], 0
call glfwGetMonitors
test ebx, ebx
js short loc_70283
cmp [rsp+28h+var_1C], ebx
jle short loc_70283
mov ecx, ebx
mov rdi, [rax+rcx*8]
lea rbx, [rsp+28h+var_14]
lea r14, [rsp+28h+var_18]
mov rsi, rbx
mov rdx, r14
call glfwGetMonitorPos
movss xmm0, dword ptr [r14]
movss xmm1, dword ptr [rbx]
unpcklps xmm1, xmm0
cvtdq2ps xmm0, xmm1
jmp short loc_70299
loc_70283:
lea rsi, aGlfwFailedToFi_0; "GLFW: Failed to find selected monitor"
mov edi, 4
xor eax, eax
call TraceLog
xorps xmm0, xmm0
loc_70299:
add rsp, 18h
pop rbx
pop r14
retn
| double GetMonitorPosition(int a1)
{
long long Monitors; // rax
int v2; // edx
int v3; // ecx
int v4; // r8d
int v5; // r9d
double result; // xmm0_8
int v7; // [rsp+Ch] [rbp-1Ch] BYREF
unsigned int v8; // [rsp+10h] [rbp-18h] BYREF
_DWORD v9[5]; // [rsp+14h] [rbp-14h] BYREF
v7 = 0;
Monitors = glfwGetMonitors(&v7);
if ( a1 < 0 || v7 <= a1 )
{
TraceLog(4, (unsigned int)"GLFW: Failed to find selected monitor", v2, v3, v4, v5);
return 0.0;
}
else
{
glfwGetMonitorPos(*(_QWORD *)(Monitors + 8LL * (unsigned int)a1), v9, &v8);
*(_QWORD *)&result = _mm_cvtepi32_ps((__m128i)_mm_unpacklo_ps((__m128)v9[0], (__m128)v8)).m128_u64[0];
}
return result;
}
| GetMonitorPosition:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV EBX,EDI
LEA RDI,[RSP + 0xc]
MOV dword ptr [RDI],0x0
CALL 0x001bf07a
TEST EBX,EBX
JS 0x00170283
CMP dword ptr [RSP + 0xc],EBX
JLE 0x00170283
MOV ECX,EBX
MOV RDI,qword ptr [RAX + RCX*0x8]
LEA RBX,[RSP + 0x14]
LEA R14,[RSP + 0x10]
MOV RSI,RBX
MOV RDX,R14
CALL 0x001bf112
MOVSS XMM0,dword ptr [R14]
MOVSS XMM1,dword ptr [RBX]
UNPCKLPS XMM1,XMM0
CVTDQ2PS XMM0,XMM1
JMP 0x00170299
LAB_00170283:
LEA RSI,[0x1df902]
MOV EDI,0x4
XOR EAX,EAX
CALL 0x001b9db7
XORPS XMM0,XMM0
LAB_00170299:
ADD RSP,0x18
POP RBX
POP R14
RET
|
int8 GetMonitorPosition(uint param_1)
{
long lVar1;
float fVar2;
float fVar3;
int local_18;
int local_14;
lVar1 = glfwGetMonitors();
if (((int)param_1 < 0) || (-1 < (int)param_1)) {
TraceLog(4,"GLFW: Failed to find selected monitor");
fVar2 = 0.0;
fVar3 = 0.0;
}
else {
glfwGetMonitorPos(*(int8 *)(lVar1 + (ulong)param_1 * 8),&local_14,&local_18);
fVar2 = (float)local_14;
fVar3 = (float)local_18;
}
return CONCAT44(fVar3,fVar2);
}
| |
42,867 | plutovg_path_transform | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-path.c | void plutovg_path_transform(plutovg_path_t* path, const plutovg_matrix_t* matrix)
{
plutovg_path_element_t* elements = path->elements.data;
for(int i = 0; i < path->elements.size; i += elements[i].header.length) {
switch(elements[i].header.command) {
case PLUTOVG_PATH_COMMAND_MOVE_TO:
case PLUTOVG_PATH_COMMAND_LINE_TO:
case PLUTOVG_PATH_COMMAND_CLOSE:
plutovg_matrix_map_point(matrix, &elements[i + 1].point, &elements[i + 1].point);
break;
case PLUTOVG_PATH_COMMAND_CUBIC_TO:
plutovg_matrix_map_point(matrix, &elements[i + 1].point, &elements[i + 1].point);
plutovg_matrix_map_point(matrix, &elements[i + 2].point, &elements[i + 2].point);
plutovg_matrix_map_point(matrix, &elements[i + 3].point, &elements[i + 3].point);
break;
}
}
} | O1 | c | plutovg_path_transform:
cmpl $0x0, 0x20(%rdi)
jle 0xb434
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r15
xorl %ebp, %ebp
movslq %ebp, %rax
leaq (%r15,%rax,8), %r12
movl (%r12), %eax
movl $0x8, %edx
cmpl $0x2, %eax
jb 0xb413
cmpl $0x3, %eax
je 0xb413
cmpl $0x2, %eax
jne 0xb421
leaq 0x8(%r12), %rdx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x80c7
leaq 0x10(%r12), %rdx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x80c7
movl $0x18, %edx
addq %r12, %rdx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x80c7
addl 0x4(%r12), %ebp
cmpl 0x20(%r14), %ebp
jl 0xb3cf
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| plutovg_path_transform:
cmp dword ptr [rdi+20h], 0
jle short locret_B434
push rbp
push r15
push r14
push r12
push rbx
mov rbx, rsi
mov r14, rdi
mov r15, [rdi+18h]
xor ebp, ebp
loc_B3CF:
movsxd rax, ebp
lea r12, [r15+rax*8]
mov eax, [r12]
mov edx, 8
cmp eax, 2
jb short loc_B413
cmp eax, 3
jz short loc_B413
cmp eax, 2
jnz short loc_B421
lea rdx, [r12+8]
mov rdi, rbx
mov rsi, rdx
call plutovg_matrix_map_point
lea rdx, [r12+10h]
mov rdi, rbx
mov rsi, rdx
call plutovg_matrix_map_point
mov edx, 18h
loc_B413:
add rdx, r12
mov rdi, rbx
mov rsi, rdx
call plutovg_matrix_map_point
loc_B421:
add ebp, [r12+4]
cmp ebp, [r14+20h]
jl short loc_B3CF
pop rbx
pop r12
pop r14
pop r15
pop rbp
locret_B434:
retn
| void plutovg_path_transform(long long a1, float *a2)
{
long long v2; // r15
int v3; // ebp
float *v4; // r12
float v5; // eax
long long v6; // rdx
if ( *(int *)(a1 + 32) > 0 )
{
v2 = *(_QWORD *)(a1 + 24);
v3 = 0;
while ( 1 )
{
v4 = (float *)(v2 + 8LL * v3);
v5 = *v4;
v6 = 2LL;
if ( *(_DWORD *)v4 < 2u || LODWORD(v5) == 3 )
goto LABEL_7;
if ( LODWORD(v5) == 2 )
break;
LABEL_8:
v3 += *((_DWORD *)v4 + 1);
if ( v3 >= *(_DWORD *)(a1 + 32) )
return;
}
plutovg_matrix_map_point(a2, v4 + 2, v4 + 2);
plutovg_matrix_map_point(a2, v4 + 4, v4 + 4);
v6 = 6LL;
LABEL_7:
plutovg_matrix_map_point(a2, &v4[v6], &v4[v6]);
goto LABEL_8;
}
}
| plutovg_path_transform:
CMP dword ptr [RDI + 0x20],0x0
JLE 0x0010b434
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
MOV R15,qword ptr [RDI + 0x18]
XOR EBP,EBP
LAB_0010b3cf:
MOVSXD RAX,EBP
LEA R12,[R15 + RAX*0x8]
MOV EAX,dword ptr [R12]
MOV EDX,0x8
CMP EAX,0x2
JC 0x0010b413
CMP EAX,0x3
JZ 0x0010b413
CMP EAX,0x2
JNZ 0x0010b421
LEA RDX,[R12 + 0x8]
MOV RDI,RBX
MOV RSI,RDX
CALL 0x001080c7
LEA RDX,[R12 + 0x10]
MOV RDI,RBX
MOV RSI,RDX
CALL 0x001080c7
MOV EDX,0x18
LAB_0010b413:
ADD RDX,R12
MOV RDI,RBX
MOV RSI,RDX
CALL 0x001080c7
LAB_0010b421:
ADD EBP,dword ptr [R12 + 0x4]
CMP EBP,dword ptr [R14 + 0x20]
JL 0x0010b3cf
POP RBX
POP R12
POP R14
POP R15
POP RBP
LAB_0010b434:
RET
|
void plutovg_path_transform(long param_1,int8 param_2)
{
uint *puVar1;
uint uVar2;
long lVar3;
long lVar4;
int iVar5;
if (0 < *(int *)(param_1 + 0x20)) {
lVar3 = *(long *)(param_1 + 0x18);
iVar5 = 0;
do {
puVar1 = (uint *)(lVar3 + (long)iVar5 * 8);
uVar2 = *puVar1;
lVar4 = 8;
if ((uVar2 < 2) || (uVar2 == 3)) {
LAB_0010b413:
plutovg_matrix_map_point(param_2,lVar4 + (long)puVar1);
}
else if (uVar2 == 2) {
plutovg_matrix_map_point(param_2,puVar1 + 2);
plutovg_matrix_map_point(param_2,puVar1 + 4);
lVar4 = 0x18;
goto LAB_0010b413;
}
iVar5 = iVar5 + puVar1[1];
} while (iVar5 < *(int *)(param_1 + 0x20));
}
return;
}
| |
42,868 | mysql_stmt_send_long_data_start | eloqsql/libmariadb/libmariadb/mariadb_async.c | int STDCALL
mysql_stmt_send_long_data_start(my_bool *ret, MYSQL_STMT *stmt,
unsigned int param_number,
const char *data, unsigned long length)
{
MK_ASYNC_START_BODY(
mysql_stmt_send_long_data,
stmt->mysql,
{
WIN_SET_NONBLOCKING(stmt->mysql)
parms.stmt= stmt;
parms.param_number= param_number;
parms.data= data;
parms.length= length;
},
TRUE,
r_my_bool,
/* If stmt->mysql==NULL then we will not block so can call directly. */
if (!stmt->mysql)
{
*ret= mysql_stmt_send_long_data(stmt, param_number, data, length);
return 0;
})
} | O0 | c | mysql_stmt_send_long_data_start:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x3e07e
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x2c450
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x3e1a2
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movb $0x1, 0x14(%rax)
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
leaq 0xe6(%rip), %rsi # 0x3e1b0
leaq -0x60(%rbp), %rdx
callq 0x3f310
movl %eax, -0x34(%rbp)
movq -0x40(%rbp), %rax
movb $0x0, 0x15(%rax)
movq -0x40(%rbp), %rax
movb $0x0, 0x14(%rax)
cmpl $0x0, -0x34(%rbp)
jle 0x3e102
movq -0x40(%rbp), %rax
movb $0x1, 0x15(%rax)
movq -0x40(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x3e1a2
cmpl $0x0, -0x34(%rbp)
jge 0x3e18e
jmp 0x3e10e
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 0x21d4a(%rip), %rax # 0x5fe80
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 0x21d28(%rip), %rax # 0x5fe90
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 0x3e19b
movq -0x40(%rbp), %rax
movb 0x8(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| mysql_stmt_send_long_data_start:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov rax, [rbp+var_18]
cmp qword ptr [rax+38h], 0
jnz short loc_3E07E
mov rdi, [rbp+var_18]
mov esi, [rbp+var_1C]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
call mysql_stmt_send_long_data
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
mov [rbp+var_4], 0
jmp loc_3E1A2
loc_3E07E:
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
mov [rbp+var_60], rax
mov eax, [rbp+var_1C]
mov [rbp+var_58], eax
mov rax, [rbp+var_28]
mov [rbp+var_50], rax
mov rax, [rbp+var_30]
mov [rbp+var_48], rax
mov rax, [rbp+var_40]
mov byte ptr [rax+14h], 1
mov rdi, [rbp+var_40]
add rdi, 38h ; '8'
lea rsi, mysql_stmt_send_long_data_start_internal
lea rdx, [rbp+var_60]
call my_context_spawn
mov [rbp+var_34], eax
mov rax, [rbp+var_40]
mov byte ptr [rax+15h], 0
mov rax, [rbp+var_40]
mov byte ptr [rax+14h], 0
cmp [rbp+var_34], 0
jle short loc_3E102
mov rax, [rbp+var_40]
mov byte ptr [rax+15h], 1
mov rax, [rbp+var_40]
mov eax, [rax]
mov [rbp+var_4], eax
jmp loc_3E1A2
loc_3E102:
cmp [rbp+var_34], 0
jge loc_3E18E
jmp short $+2
loc_3E10E:
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_3E19B
loc_3E18E:
mov rax, [rbp+var_40]
mov cl, [rax+8]
mov rax, [rbp+var_10]
mov [rax], cl
loc_3E19B:
mov [rbp+var_4], 0
loc_3E1A2:
mov eax, [rbp+var_4]
add rsp, 60h
pop rbp
retn
| long long mysql_stmt_send_long_data_start(char *a1, long long a2, unsigned int a3, long long a4, long long a5)
{
long long v6; // [rsp+0h] [rbp-60h] BYREF
unsigned int v7; // [rsp+8h] [rbp-58h]
long long v8; // [rsp+10h] [rbp-50h]
long long v9; // [rsp+18h] [rbp-48h]
_BYTE *v10; // [rsp+20h] [rbp-40h]
int v11; // [rsp+2Ch] [rbp-34h]
long long v12; // [rsp+30h] [rbp-30h]
long long v13; // [rsp+38h] [rbp-28h]
unsigned int v14; // [rsp+44h] [rbp-1Ch]
long long v15; // [rsp+48h] [rbp-18h]
char *v16; // [rsp+50h] [rbp-10h]
v16 = a1;
v15 = a2;
v14 = a3;
v13 = a4;
v12 = a5;
if ( *(_QWORD *)(a2 + 56) )
{
v10 = *(_BYTE **)(*(_QWORD *)(*(_QWORD *)(v15 + 56) + 1152LL) + 40LL);
v6 = v15;
v7 = v14;
v8 = v13;
v9 = v12;
v10[20] = 1;
v11 = my_context_spawn(v10 + 56, mysql_stmt_send_long_data_start_internal, &v6);
v10[21] = 0;
v10[20] = 0;
if ( v11 <= 0 )
{
if ( v11 >= 0 )
{
*v16 = v10[8];
}
else
{
*(_DWORD *)(*(_QWORD *)(v15 + 56) + 144LL) = 2008;
strncpy(*(_QWORD *)(v15 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(*(_QWORD *)(v15 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(v15 + 56) + 151LL, client_errors[8], 511LL);
*(_BYTE *)(*(_QWORD *)(v15 + 56) + 662LL) = 0;
*v16 = 1;
}
return 0;
}
else
{
v10[21] = 1;
return *(unsigned int *)v10;
}
}
else
{
*v16 = mysql_stmt_send_long_data(v15, v14, v13, v12);
return 0;
}
}
| mysql_stmt_send_long_data_start:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x38],0x0
JNZ 0x0013e07e
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x1c]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x0012c450
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0013e1a2
LAB_0013e07e:
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 + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x60],RAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x58],EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV byte ptr [RAX + 0x14],0x1
MOV RDI,qword ptr [RBP + -0x40]
ADD RDI,0x38
LEA RSI,[0x13e1b0]
LEA RDX,[RBP + -0x60]
CALL 0x0013f310
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV byte ptr [RAX + 0x15],0x0
MOV RAX,qword ptr [RBP + -0x40]
MOV byte ptr [RAX + 0x14],0x0
CMP dword ptr [RBP + -0x34],0x0
JLE 0x0013e102
MOV RAX,qword ptr [RBP + -0x40]
MOV byte ptr [RAX + 0x15],0x1
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013e1a2
LAB_0013e102:
CMP dword ptr [RBP + -0x34],0x0
JGE 0x0013e18e
JMP 0x0013e10e
LAB_0013e10e:
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,[0x15fe80]
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,[0x15fe90]
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 0x0013e19b
LAB_0013e18e:
MOV RAX,qword ptr [RBP + -0x40]
MOV CL,byte ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
LAB_0013e19b:
MOV dword ptr [RBP + -0x4],0x0
LAB_0013e1a2:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x60
POP RBP
RET
|
int4
mysql_stmt_send_long_data_start
(int1 *param_1,long param_2,int4 param_3,int8 param_4,int8 param_5
)
{
int1 uVar1;
long local_68;
int4 local_60;
int8 local_58;
int8 local_50;
int4 *local_48;
int local_3c;
int8 local_38;
int8 local_30;
int4 local_24;
long local_20;
int1 *local_18;
int4 local_c;
local_38 = param_5;
local_30 = param_4;
local_24 = param_3;
local_20 = param_2;
local_18 = param_1;
if (*(long *)(param_2 + 0x38) == 0) {
uVar1 = mysql_stmt_send_long_data(param_2,param_3,param_4,param_5);
*local_18 = uVar1;
local_c = 0;
}
else {
local_48 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x38) + 0x480) + 0x28);
*(int1 *)(local_48 + 5) = 1;
local_68 = param_2;
local_60 = param_3;
local_58 = param_4;
local_50 = param_5;
local_3c = my_context_spawn(local_48 + 0xe,mysql_stmt_send_long_data_start_internal,&local_68);
*(int1 *)((long)local_48 + 0x15) = 0;
*(int1 *)(local_48 + 5) = 0;
if (local_3c < 1) {
if (local_3c < 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_0015fed0,
0x1ff);
*(int1 *)(*(long *)(local_20 + 0x38) + 0x296) = 0;
*local_18 = 1;
}
else {
*local_18 = *(int1 *)(local_48 + 2);
}
local_c = 0;
}
else {
*(int1 *)((long)local_48 + 0x15) = 1;
local_c = *local_48;
}
}
return local_c;
}
| |
42,869 | maria_versioning | eloqsql/storage/maria/ma_state.c | void maria_versioning(MARIA_HA *info, my_bool versioning)
{
MARIA_SHARE *share= info->s;
DBUG_ENTER("maria_versioning");
/* For now, this is a hack */
if (share->have_versioning)
{
enum thr_lock_type save_lock_type;
share->lock_key_trees= versioning;
/* Set up info->lock.type temporary for _ma_block_get_status() */
save_lock_type= info->lock.type;
info->lock.type= versioning ? TL_WRITE_CONCURRENT_INSERT : TL_WRITE;
_ma_block_get_status((void*) info, versioning);
info->lock.type= save_lock_type;
if (versioning)
info->state= &share->state.common;
else
info->state= &share->state.state; /* Change global values by default */
info->state_start= info->state; /* Initial values */
}
DBUG_VOID_RETURN;
} | O0 | c | maria_versioning:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x7e8(%rax)
je 0x4a528
movb -0x9(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x7e3(%rax)
movq -0x8(%rbp), %rax
movl 0x6d0(%rax), %eax
movl %eax, -0x1c(%rbp)
movsbl -0x9(%rbp), %edx
movl $0xd, %ecx
movl $0x8, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x6d0(%rax)
movq -0x8(%rbp), %rdi
movsbl -0x9(%rbp), %esi
callq 0x4a260
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x6d0(%rax)
cmpb $0x0, -0x9(%rbp)
je 0x4a508
movq -0x18(%rbp), %rcx
addq $0x50, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x4a518
movq -0x18(%rbp), %rcx
addq $0x18, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
jmp 0x4a52a
jmp 0x4a52c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| maria_versioning:
push rbp
mov rbp, rsp
sub rsp, 20h
mov al, sil
mov [rbp+var_8], rdi
mov [rbp+var_9], al
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
cmp byte ptr [rax+7E8h], 0
jz loc_4A528
mov cl, [rbp+var_9]
mov rax, [rbp+var_18]
mov [rax+7E3h], cl
mov rax, [rbp+var_8]
mov eax, [rax+6D0h]
mov [rbp+var_1C], eax
movsx edx, [rbp+var_9]
mov ecx, 0Dh
mov eax, 8
cmp edx, 0
cmovnz ecx, eax
mov rax, [rbp+var_8]
mov [rax+6D0h], ecx
mov rdi, [rbp+var_8]
movsx esi, [rbp+var_9]
call _ma_block_get_status
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_8]
mov [rax+6D0h], ecx
cmp [rbp+var_9], 0
jz short loc_4A508
mov rcx, [rbp+var_18]
add rcx, 50h ; 'P'
mov rax, [rbp+var_8]
mov [rax+20h], rcx
jmp short loc_4A518
loc_4A508:
mov rcx, [rbp+var_18]
add rcx, 18h
mov rax, [rbp+var_8]
mov [rax+20h], rcx
loc_4A518:
mov rax, [rbp+var_8]
mov rcx, [rax+20h]
mov rax, [rbp+var_8]
mov [rax+60h], rcx
loc_4A528:
jmp short $+2
loc_4A52A:
jmp short $+2
loc_4A52C:
add rsp, 20h
pop rbp
retn
| long long maria_versioning(long long a1, char a2)
{
long long result; // rax
int v3; // ecx
int v4; // [rsp+4h] [rbp-1Ch]
long long v5; // [rsp+8h] [rbp-18h]
v5 = *(_QWORD *)a1;
result = *(_QWORD *)a1;
if ( *(_BYTE *)(*(_QWORD *)a1 + 2024LL) )
{
*(_BYTE *)(v5 + 2019) = a2;
v4 = *(_DWORD *)(a1 + 1744);
v3 = 13;
if ( a2 )
v3 = 8;
*(_DWORD *)(a1 + 1744) = v3;
ma_block_get_status(a1, a2);
*(_DWORD *)(a1 + 1744) = v4;
if ( a2 )
*(_QWORD *)(a1 + 32) = v5 + 80;
else
*(_QWORD *)(a1 + 32) = v5 + 24;
result = a1;
*(_QWORD *)(a1 + 96) = *(_QWORD *)(a1 + 32);
}
return result;
}
| maria_versioning:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV AL,SIL
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP byte ptr [RAX + 0x7e8],0x0
JZ 0x0014a528
MOV CL,byte ptr [RBP + -0x9]
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x7e3],CL
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x6d0]
MOV dword ptr [RBP + -0x1c],EAX
MOVSX EDX,byte ptr [RBP + -0x9]
MOV ECX,0xd
MOV EAX,0x8
CMP EDX,0x0
CMOVNZ ECX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x6d0],ECX
MOV RDI,qword ptr [RBP + -0x8]
MOVSX ESI,byte ptr [RBP + -0x9]
CALL 0x0014a260
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x6d0],ECX
CMP byte ptr [RBP + -0x9],0x0
JZ 0x0014a508
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,0x50
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x20],RCX
JMP 0x0014a518
LAB_0014a508:
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,0x18
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x20],RCX
LAB_0014a518:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x60],RCX
LAB_0014a528:
JMP 0x0014a52a
LAB_0014a52a:
JMP 0x0014a52c
LAB_0014a52c:
ADD RSP,0x20
POP RBP
RET
|
void maria_versioning(long *param_1,char param_2)
{
long lVar1;
long lVar2;
int4 uVar3;
lVar1 = *param_1;
if (*(char *)(lVar1 + 0x7e8) != '\0') {
*(char *)(lVar1 + 0x7e3) = param_2;
lVar2 = param_1[0xda];
uVar3 = 0xd;
if (param_2 != '\0') {
uVar3 = 8;
}
*(int4 *)(param_1 + 0xda) = uVar3;
_ma_block_get_status(param_1,(int)param_2);
*(int *)(param_1 + 0xda) = (int)lVar2;
if (param_2 == '\0') {
param_1[4] = lVar1 + 0x18;
}
else {
param_1[4] = lVar1 + 0x50;
}
param_1[0xc] = param_1[4];
}
return;
}
| |
42,870 | pvio_socket_async_write | eloqsql/libmariadb/plugins/pvio/pvio_socket.c | ssize_t pvio_socket_async_write(MARIADB_PVIO *pvio, const uchar *buffer, size_t length)
{
ssize_t r= -1;
struct st_pvio_socket *csock= NULL;
#ifndef _WIN32
int write_flags= MSG_DONTWAIT;
#ifdef MSG_NOSIGNAL
write_flags|= MSG_NOSIGNAL;
#endif
#endif
if (!pvio || !pvio->data)
return -1;
csock= (struct st_pvio_socket *)pvio->data;
#ifndef WIN32
r= ma_send(csock->socket, buffer, length, write_flags);
#else
/* Windows doesn't support MSG_DONTWAIT, so we need to set
socket to non blocking */
pvio_socket_blocking(pvio, 0, 0);
r= send(csock->socket, (const char *)buffer, (int)length, 0);
#endif
return r;
} | O3 | c | pvio_socket_async_write:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2f463
movq (%rdi), %rax
testq %rax, %rax
je 0x2f463
movl (%rax), %edi
popq %rbp
jmp 0x2ffb3
movq $-0x1, %rax
popq %rbp
retq
| pvio_socket_async_write:
push rbp
mov rbp, rsp
test rdi, rdi
jz short loc_2F463
mov rax, [rdi]
test rax, rax
jz short loc_2F463
mov edi, [rax]
pop rbp
jmp ma_send
loc_2F463:
mov rax, 0FFFFFFFFFFFFFFFFh
pop rbp
retn
| long long pvio_socket_async_write(_QWORD *a1, long long a2, long long a3)
{
if ( a1 && *a1 )
return ma_send(*(unsigned int *)*a1, a2, a3);
else
return -1LL;
}
| pvio_socket_async_write:
PUSH RBP
MOV RBP,RSP
TEST RDI,RDI
JZ 0x0012f463
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x0012f463
MOV EDI,dword ptr [RAX]
POP RBP
JMP 0x0012ffb3
LAB_0012f463:
MOV RAX,-0x1
POP RBP
RET
|
int8 pvio_socket_async_write(int8 *param_1)
{
int8 uVar1;
if ((param_1 != (int8 *)0x0) && ((int4 *)*param_1 != (int4 *)0x0)) {
uVar1 = ma_send(*(int4 *)*param_1);
return uVar1;
}
return 0xffffffffffffffff;
}
| |
42,871 | 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 0x540f7
leaq 0x8(%rsp), %r14
pushq $0x2
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x23950
leaq 0x611a2(%rip), %rsi # 0xb527a
movq %r14, %rdi
callq 0x3a0ea
movl %eax, %ebp
movq %r14, %rdi
callq 0x241f8
movzbl %bpl, %r14d
addl %r14d, %r14d
movq 0x8(%rbx), %rax
jmp 0x540fa
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 0x541cf
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23a80
movsbl (%rax), %r15d
leal -0x30(%r15), %eax
cmpb $0xa, %al
jb 0x54154
leal -0x61(%r15), %eax
cmpb $0x5, %al
ja 0x54145
addb $-0x57, %r15b
jmp 0x54151
leal -0x41(%r15), %eax
cmpb $0x5, %al
ja 0x541a4
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 0x5e54a(%rip), %xmm2 # 0xb26c0
pand %xmm2, %xmm1
pcmpeqd %xmm2, %xmm1
por %xmm0, %xmm1
pand 0x5e546(%rip), %xmm1 # 0xb26d0
packuswb %xmm1, %xmm1
packuswb %xmm1, %xmm1
movd %xmm1, (%r13)
incq %r14
addq $-0x4, %r13
jmp 0x54117
leaq 0xab2ad(%rip), %rax # 0xff458
cmpl $0x0, (%rax)
js 0x541cf
callq 0x96e52
leaq 0x5e856(%rip), %rdx # 0xb2a12
pushq $0x4
popq %rsi
movq %rax, %rdi
movl %r15d, %ecx
movl %r14d, %r8d
xorl %eax, %eax
callq 0x96eea
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_540F7
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_540FA
loc_540F7:
xor r14d, r14d
loc_540FA:
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_54117:
cmp r14, r12
jnb loc_541CF
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_54154
lea eax, [r15-61h]
cmp al, 5
ja short loc_54145
add r15b, 0A9h
jmp short loc_54151
loc_54145:
lea eax, [r15-41h]
cmp al, 5
ja short loc_541A4
add r15b, 0C9h
loc_54151:
mov eax, r15d
loc_54154:
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_B26C0
pand xmm1, xmm2
pcmpeqd xmm1, xmm2
por xmm1, xmm0
pand xmm1, cs:xmmword_B26D0
packuswb xmm1, xmm1
packuswb xmm1, xmm1
movd dword ptr [r13+0], xmm1
inc r14
add r13, 0FFFFFFFFFFFFFFFCh
jmp loc_54117
loc_541A4:
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_541CF
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_541CF:
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_B26C0);
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_B26D0);
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 0x001540f7
LEA R14,[RSP + 0x8]
PUSH 0x2
POP RCX
MOV RDI,R14
MOV RSI,RBX
XOR EDX,EDX
CALL 0x00123950
LEA RSI,[0x1b527a]
MOV RDI,R14
CALL 0x0013a0ea
MOV EBP,EAX
MOV RDI,R14
CALL 0x001241f8
MOVZX R14D,BPL
ADD R14D,R14D
MOV RAX,qword ptr [RBX + 0x8]
JMP 0x001540fa
LAB_001540f7:
XOR R14D,R14D
LAB_001540fa:
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_00154117:
CMP R14,R12
JNC 0x001541cf
MOV RDI,RBX
MOV RSI,R14
CALL 0x00123a80
MOVSX R15D,byte ptr [RAX]
LEA EAX,[R15 + -0x30]
CMP AL,0xa
JC 0x00154154
LEA EAX,[R15 + -0x61]
CMP AL,0x5
JA 0x00154145
ADD R15B,0xa9
JMP 0x00154151
LAB_00154145:
LEA EAX,[R15 + -0x41]
CMP AL,0x5
JA 0x001541a4
ADD R15B,0xc9
LAB_00154151:
MOV EAX,R15D
LAB_00154154:
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 [0x001b26c0]
PAND XMM1,XMM2
PCMPEQD XMM1,XMM2
POR XMM1,XMM0
PAND XMM1,xmmword ptr [0x001b26d0]
PACKUSWB XMM1,XMM1
PACKUSWB XMM1,XMM1
MOVD dword ptr [R13],XMM1
INC R14
ADD R13,-0x4
JMP 0x00154117
LAB_001541a4:
LEA RAX,[0x1ff458]
CMP dword ptr [RAX],0x0
JS 0x001541cf
CALL 0x00196e52
LEA RDX,[0x1b2a12]
PUSH 0x4
POP RSI
MOV RDI,RAX
MOV ECX,R15D
MOV R8D,R14D
XOR EAX,EAX
CALL 0x00196eea
LAB_001541cf:
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_001541cf:
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_001541cf;
}
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_001b26c0;
auVar25._0_4_ = -(uint)(auVar24._0_4_ == SUB164(_DAT_001b26c0,0));
auVar25._4_4_ = -(uint)(auVar24._4_4_ == SUB164(_DAT_001b26c0,4));
auVar25._8_4_ = -(uint)(auVar24._8_4_ == SUB164(_DAT_001b26c0,8));
auVar25._12_4_ = -(uint)(auVar24._12_4_ == SUB164(_DAT_001b26c0,0xc));
auVar26 = (auVar25 | auVar26) & _DAT_001b26d0;
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 );
}
| |
42,872 | Binary_string::realloc_raw(unsigned long) | eloqsql/sql/sql_string.cc | bool Binary_string::realloc_raw(size_t alloc_length)
{
if (Alloced_length < alloc_length)
{
char *new_ptr;
uint32 len= ALIGN_SIZE(alloc_length+1);
DBUG_ASSERT(len > alloc_length);
if (len <= alloc_length)
return TRUE; /* Overflow */
if (alloced)
{
if (!(new_ptr= (char*) my_realloc(STRING_PSI_MEMORY_KEY, Ptr,len,
MYF(MY_WME |
(thread_specific ?
MY_THREAD_SPECIFIC : 0)))))
return TRUE; // Signal error
}
else if ((new_ptr= (char*) my_malloc(STRING_PSI_MEMORY_KEY, len,
MYF(MY_WME |
(thread_specific ?
MY_THREAD_SPECIFIC : 0)))))
{
DBUG_ASSERT(str_length < len);
if (str_length) // Avoid bugs in memcpy on AIX
memcpy(new_ptr,Ptr,str_length);
new_ptr[str_length]=0;
alloced=1;
}
else
return TRUE; // Signal error
Ptr= new_ptr;
DBUG_ASSERT(len < UINT_MAX32);
Alloced_length= (uint32)len;
}
return FALSE;
} | O0 | cpp | Binary_string::realloc_raw(unsigned long):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0xc(%rax), %eax
cmpq -0x18(%rbp), %rax
jae 0x272d3
movq -0x18(%rbp), %rax
addq $0x1, %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
movl %eax, -0x24(%rbp)
jmp 0x271ee
movl -0x24(%rbp), %eax
cmpq -0x18(%rbp), %rax
ja 0x27200
movb $0x1, -0x1(%rbp)
jmp 0x272d7
movq -0x30(%rbp), %rax
testb $0x1, 0x14(%rax)
je 0x2724b
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movl -0x24(%rbp), %ecx
movl %ecx, %edx
movb 0x15(%rax), %dil
xorl %eax, %eax
movl $0x10000, %ecx # imm = 0x10000
testb $0x1, %dil
cmovnel %ecx, %eax
orl $0x10, %eax
movl %eax, %eax
movl %eax, %ecx
xorl %edi, %edi
callq 0x37030
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x27249
movb $0x1, -0x1(%rbp)
jmp 0x272d7
jmp 0x272bc
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %esi
movb 0x15(%rax), %dl
xorl %eax, %eax
movl $0x10000, %ecx # imm = 0x10000
testb $0x1, %dl
cmovnel %ecx, %eax
orl $0x10, %eax
movl %eax, %eax
movl %eax, %edx
xorl %edi, %edi
callq 0x36e60
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x272b4
jmp 0x2727e
jmp 0x27280
movq -0x30(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x2729f
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rdi
movq (%rax), %rsi
movl 0x8(%rax), %eax
movl %eax, %edx
callq 0x25260
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0x8(%rax), %edx
movb $0x0, (%rcx,%rdx)
movb $0x1, 0x14(%rax)
jmp 0x272ba
movb $0x1, -0x1(%rbp)
jmp 0x272d7
jmp 0x272bc
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x272c9
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, 0xc(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN13Binary_string11realloc_rawEm:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov [rbp+var_30], rax
mov eax, [rax+0Ch]
cmp rax, [rbp+var_18]
jnb loc_272D3
mov rax, [rbp+var_18]
add rax, 1
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_24], eax
jmp short $+2
loc_271EE:
mov eax, [rbp+var_24]
cmp rax, [rbp+var_18]
ja short loc_27200
mov [rbp+var_1], 1
jmp loc_272D7
loc_27200:
mov rax, [rbp+var_30]
test byte ptr [rax+14h], 1
jz short loc_2724B
mov rax, [rbp+var_30]
mov rsi, [rax]
mov ecx, [rbp+var_24]
mov edx, ecx
mov dil, [rax+15h]
xor eax, eax
mov ecx, 10000h
test dil, 1
cmovnz eax, ecx
or eax, 10h
mov eax, eax
mov ecx, eax
xor edi, edi
call my_realloc
mov [rbp+var_20], rax
cmp rax, 0
jnz short loc_27249
mov [rbp+var_1], 1
jmp loc_272D7
loc_27249:
jmp short loc_272BC
loc_2724B:
mov rax, [rbp+var_30]
mov ecx, [rbp+var_24]
mov esi, ecx
mov dl, [rax+15h]
xor eax, eax
mov ecx, 10000h
test dl, 1
cmovnz eax, ecx
or eax, 10h
mov eax, eax
mov edx, eax
xor edi, edi
call my_malloc
mov [rbp+var_20], rax
cmp rax, 0
jz short loc_272B4
jmp short $+2
loc_2727E:
jmp short $+2
loc_27280:
mov rax, [rbp+var_30]
cmp dword ptr [rax+8], 0
jz short loc_2729F
mov rax, [rbp+var_30]
mov rdi, [rbp+var_20]
mov rsi, [rax]
mov eax, [rax+8]
mov edx, eax
call _memcpy
loc_2729F:
mov rax, [rbp+var_30]
mov rcx, [rbp+var_20]
mov edx, [rax+8]
mov byte ptr [rcx+rdx], 0
mov byte ptr [rax+14h], 1
jmp short loc_272BA
loc_272B4:
mov [rbp+var_1], 1
jmp short loc_272D7
loc_272BA:
jmp short $+2
loc_272BC:
mov rax, [rbp+var_30]
mov rcx, [rbp+var_20]
mov [rax], rcx
jmp short $+2
loc_272C9:
mov rax, [rbp+var_30]
mov ecx, [rbp+var_24]
mov [rax+0Ch], ecx
loc_272D3:
mov [rbp+var_1], 0
loc_272D7:
mov al, [rbp+var_1]
and al, 1
add rsp, 30h
pop rbp
retn
| char Binary_string::realloc_raw(Binary_string *this, unsigned long long a2)
{
int v2; // eax
int v3; // eax
unsigned int v5; // [rsp+Ch] [rbp-24h]
long long v6; // [rsp+10h] [rbp-20h]
if ( *((unsigned int *)this + 3) >= a2 )
return 0;
v5 = (a2 + 8) & 0xFFFFFFF8;
if ( v5 > a2 )
{
if ( (*((_BYTE *)this + 20) & 1) != 0 )
{
v2 = 0;
if ( (*((_BYTE *)this + 21) & 1) != 0 )
v2 = 0x10000;
v6 = my_realloc(0LL, *(_QWORD *)this, v5, v2 | 0x10u);
if ( !v6 )
return 1;
}
else
{
v3 = 0;
if ( (*((_BYTE *)this + 21) & 1) != 0 )
v3 = 0x10000;
v6 = my_malloc(0LL, v5, v3 | 0x10u);
if ( !v6 )
return 1;
if ( *((_DWORD *)this + 2) )
memcpy(v6, *(_QWORD *)this, *((unsigned int *)this + 2));
*(_BYTE *)(v6 + *((unsigned int *)this + 2)) = 0;
*((_BYTE *)this + 20) = 1;
}
*(_QWORD *)this = v6;
*((_DWORD *)this + 3) = v5;
return 0;
}
return 1;
}
| realloc_raw:
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 + -0x10]
MOV qword ptr [RBP + -0x30],RAX
MOV EAX,dword ptr [RAX + 0xc]
CMP RAX,qword ptr [RBP + -0x18]
JNC 0x001272d3
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
MOV dword ptr [RBP + -0x24],EAX
JMP 0x001271ee
LAB_001271ee:
MOV EAX,dword ptr [RBP + -0x24]
CMP RAX,qword ptr [RBP + -0x18]
JA 0x00127200
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001272d7
LAB_00127200:
MOV RAX,qword ptr [RBP + -0x30]
TEST byte ptr [RAX + 0x14],0x1
JZ 0x0012724b
MOV RAX,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x24]
MOV EDX,ECX
MOV DIL,byte ptr [RAX + 0x15]
XOR EAX,EAX
MOV ECX,0x10000
TEST DIL,0x1
CMOVNZ EAX,ECX
OR EAX,0x10
MOV EAX,EAX
MOV ECX,EAX
XOR EDI,EDI
CALL 0x00137030
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JNZ 0x00127249
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001272d7
LAB_00127249:
JMP 0x001272bc
LAB_0012724b:
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RBP + -0x24]
MOV ESI,ECX
MOV DL,byte ptr [RAX + 0x15]
XOR EAX,EAX
MOV ECX,0x10000
TEST DL,0x1
CMOVNZ EAX,ECX
OR EAX,0x10
MOV EAX,EAX
MOV EDX,EAX
XOR EDI,EDI
CALL 0x00136e60
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JZ 0x001272b4
JMP 0x0012727e
LAB_0012727e:
JMP 0x00127280
LAB_00127280:
MOV RAX,qword ptr [RBP + -0x30]
CMP dword ptr [RAX + 0x8],0x0
JZ 0x0012729f
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x8]
MOV EDX,EAX
CALL 0x00125260
LAB_0012729f:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RAX + 0x8]
MOV byte ptr [RCX + RDX*0x1],0x0
MOV byte ptr [RAX + 0x14],0x1
JMP 0x001272ba
LAB_001272b4:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001272d7
LAB_001272ba:
JMP 0x001272bc
LAB_001272bc:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
JMP 0x001272c9
LAB_001272c9:
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RBP + -0x24]
MOV dword ptr [RAX + 0xc],ECX
LAB_001272d3:
MOV byte ptr [RBP + -0x1],0x0
LAB_001272d7:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x30
POP RBP
RET
|
/* Binary_string::realloc_raw(unsigned long) */
int1 __thiscall Binary_string::realloc_raw(Binary_string *this,ulong param_1)
{
uint uVar1;
uint uVar2;
void *local_28;
if (*(uint *)(this + 0xc) < param_1) {
uVar1 = (int)param_1 + 8U & 0xfffffff8;
if (uVar1 <= param_1) {
return 1;
}
if (((byte)this[0x14] & 1) == 0) {
uVar2 = 0;
if (((byte)this[0x15] & 1) != 0) {
uVar2 = 0x10000;
}
local_28 = (void *)my_malloc(0,uVar1,uVar2 | 0x10);
if (local_28 == (void *)0x0) {
return 1;
}
if (*(int *)(this + 8) != 0) {
memcpy(local_28,*(void **)this,(ulong)*(uint *)(this + 8));
}
*(int1 *)((long)local_28 + (ulong)*(uint *)(this + 8)) = 0;
this[0x14] = (Binary_string)0x1;
}
else {
uVar2 = 0;
if (((byte)this[0x15] & 1) != 0) {
uVar2 = 0x10000;
}
local_28 = (void *)my_realloc(0,*(int8 *)this,uVar1,uVar2 | 0x10);
if (local_28 == (void *)0x0) {
return 1;
}
}
*(void **)this = local_28;
*(uint *)(this + 0xc) = uVar1;
}
return 0;
}
| |
42,873 | retrieve_auto_increment | eloqsql/storage/myisam/mi_key.c | ulonglong retrieve_auto_increment(MI_INFO *info,const uchar *record)
{
ulonglong value= 0; /* Store unsigned values here */
longlong s_value= 0; /* Store signed values here */
HA_KEYSEG *keyseg= info->s->keyinfo[info->s->base.auto_key-1].seg;
const uchar *key= (uchar*) record + keyseg->start;
switch (keyseg->type) {
case HA_KEYTYPE_INT8:
s_value= (longlong) *(const signed char*) key;
break;
case HA_KEYTYPE_BINARY:
value=(ulonglong) *(uchar*) key;
break;
case HA_KEYTYPE_SHORT_INT:
s_value= (longlong) sint2korr(key);
break;
case HA_KEYTYPE_USHORT_INT:
value=(ulonglong) uint2korr(key);
break;
case HA_KEYTYPE_LONG_INT:
s_value= (longlong) sint4korr(key);
break;
case HA_KEYTYPE_ULONG_INT:
value=(ulonglong) uint4korr(key);
break;
case HA_KEYTYPE_INT24:
s_value= (longlong) sint3korr(key);
break;
case HA_KEYTYPE_UINT24:
value=(ulonglong) uint3korr(key);
break;
case HA_KEYTYPE_FLOAT: /* This shouldn't be used */
{
float f_1;
float4get(f_1,key);
/* Ignore negative values */
value = (f_1 < (float) 0.0) ? 0 : (ulonglong) f_1;
break;
}
case HA_KEYTYPE_DOUBLE: /* This shouldn't be used */
{
double f_1;
float8get(f_1,key);
/* Ignore negative values */
value = (f_1 < 0.0) ? 0 : (ulonglong) f_1;
break;
}
case HA_KEYTYPE_LONGLONG:
s_value= sint8korr(key);
break;
case HA_KEYTYPE_ULONGLONG:
value= uint8korr(key);
break;
default:
DBUG_ASSERT(0);
value=0; /* Error */
break;
}
/*
The following code works because if s_value < 0 then value is 0
and if s_value == 0 then value will contain either s_value or the
correct value.
*/
return (s_value > 0) ? (ulonglong) s_value : value;
} | O0 | c | retrieve_auto_increment:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq 0x218(%rcx), %rax
movl 0x184(%rcx), %ecx
decl %ecx
imulq $0x70, %rcx, %rcx
movq 0x28(%rax,%rcx), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movl 0x8(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x18(%rax), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0x48(%rbp)
subl $0xc, %eax
ja 0xafeae
movq -0x48(%rbp), %rax
leaq 0xa979a(%rip), %rcx # 0x159480
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x30(%rbp), %rax
movsbq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xafeba
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
movq %rax, -0x18(%rbp)
jmp 0xafeba
movq -0x30(%rbp), %rax
movswq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xafeba
movq -0x30(%rbp), %rax
movzwl (%rax), %eax
movq %rax, -0x18(%rbp)
jmp 0xafeba
movq -0x30(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xafeba
movq -0x30(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x18(%rbp)
jmp 0xafeba
movq -0x30(%rbp), %rax
movzbl 0x2(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xafd8d
movq -0x30(%rbp), %rax
movzbl 0x2(%rax), %eax
shll $0x10, %eax
orl $0xff000000, %eax # imm = 0xFF000000
movq -0x30(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x30(%rbp), %rcx
movzbl (%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x4c(%rbp)
jmp 0xafdb1
movq -0x30(%rbp), %rax
movzbl 0x2(%rax), %eax
shll $0x10, %eax
movq -0x30(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x30(%rbp), %rcx
movzbl (%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cltq
movq %rax, -0x20(%rbp)
jmp 0xafeba
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
movq -0x30(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x30(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0xafeba
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x34(%rbp), %xmm0
jbe 0xafe05
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0xafe34
movss -0x34(%rbp), %xmm0
movss 0xa11f2(%rip), %xmm2 # 0x151004
movaps %xmm0, %xmm1
subss %xmm2, %xmm1
cvttss2si %xmm1, %rcx
cvttss2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xafeba
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x40(%rbp), %xmm0
jbe 0xafe5b
xorl %eax, %eax
movq %rax, -0x60(%rbp)
jmp 0xafe8a
movsd -0x40(%rbp), %xmm0
movsd 0xa8de8(%rip), %xmm2 # 0x158c50
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rcx
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xafeba
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xafeba
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xafeba
jmp 0xafeb0
jmp 0xafeb2
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x20(%rbp)
jle 0xafecb
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0xafed3
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
popq %rbp
retq
nopl (%rax)
| retrieve_auto_increment:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], 0
mov [rbp+var_20], 0
mov rax, [rbp+var_8]
mov rcx, [rax]
mov rax, [rcx+218h]
mov ecx, [rcx+184h]
dec ecx
imul rcx, 70h ; 'p'
mov rax, [rax+rcx+28h]
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov rcx, [rbp+var_28]
mov ecx, [rcx+8]
add rax, rcx
mov [rbp+var_30], rax
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax+18h]
add eax, 0FFFFFFFEh; switch 13 cases
mov ecx, eax
mov [rbp+var_48], rcx
sub eax, 0Ch
ja def_AFCED; jumptable 00000000000AFCED default case, case 7
mov rax, [rbp+var_48]
lea rcx, jpt_AFCED
movsxd rax, ds:(jpt_AFCED - 159480h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_AFCEF:
mov rax, [rbp+var_30]; jumptable 00000000000AFCED case 14
movsx rax, byte ptr [rax]
mov [rbp+var_20], rax
jmp loc_AFEBA
loc_AFD00:
mov rax, [rbp+var_30]; jumptable 00000000000AFCED case 2
movzx eax, byte ptr [rax]
mov [rbp+var_18], rax
jmp loc_AFEBA
loc_AFD10:
mov rax, [rbp+var_30]; jumptable 00000000000AFCED case 3
movsx rax, word ptr [rax]
mov [rbp+var_20], rax
jmp loc_AFEBA
loc_AFD21:
mov rax, [rbp+var_30]; jumptable 00000000000AFCED case 8
movzx eax, word ptr [rax]
mov [rbp+var_18], rax
jmp loc_AFEBA
loc_AFD31:
mov rax, [rbp+var_30]; jumptable 00000000000AFCED case 4
movsxd rax, dword ptr [rax]
mov [rbp+var_20], rax
jmp loc_AFEBA
loc_AFD41:
mov rax, [rbp+var_30]; jumptable 00000000000AFCED case 9
mov eax, [rax]
mov [rbp+var_18], rax
jmp loc_AFEBA
loc_AFD50:
mov rax, [rbp+var_30]; jumptable 00000000000AFCED case 12
movzx eax, byte ptr [rax+2]
and eax, 80h
cmp eax, 0
jz short loc_AFD8D
mov rax, [rbp+var_30]
movzx eax, byte ptr [rax+2]
shl eax, 10h
or eax, 0FF000000h
mov rcx, [rbp+var_30]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_30]
movzx ecx, byte ptr [rcx]
or eax, ecx
mov [rbp+var_4C], eax
jmp short loc_AFDB1
loc_AFD8D:
mov rax, [rbp+var_30]
movzx eax, byte ptr [rax+2]
shl eax, 10h
mov rcx, [rbp+var_30]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_30]
movzx ecx, byte ptr [rcx]
or eax, ecx
mov [rbp+var_4C], eax
loc_AFDB1:
mov eax, [rbp+var_4C]
cdqe
mov [rbp+var_20], rax
jmp loc_AFEBA
loc_AFDBF:
mov rax, [rbp+var_30]; jumptable 00000000000AFCED case 13
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_30]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_30]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
or eax, ecx
mov eax, eax
mov [rbp+var_18], rax
jmp loc_AFEBA
loc_AFDEB:
mov rax, [rbp+var_30]; jumptable 00000000000AFCED case 5
mov eax, [rax]
mov [rbp+var_34], eax
xorps xmm0, xmm0
ucomiss xmm0, [rbp+var_34]
jbe short loc_AFE05
xor eax, eax
mov [rbp+var_58], rax
jmp short loc_AFE34
loc_AFE05:
movss xmm0, [rbp+var_34]
movss xmm2, cs:dword_151004
movaps xmm1, xmm0
subss xmm1, xmm2
cvttss2si rcx, xmm1
cvttss2si rax, xmm0
mov rdx, rax
sar rdx, 3Fh
and rcx, rdx
or rax, rcx
mov [rbp+var_58], rax
loc_AFE34:
mov rax, [rbp+var_58]
mov [rbp+var_18], rax
jmp short loc_AFEBA
loc_AFE3E:
mov rax, [rbp+var_30]; jumptable 00000000000AFCED case 6
mov rax, [rax]
mov [rbp+var_40], rax
xorps xmm0, xmm0
ucomisd xmm0, [rbp+var_40]
jbe short loc_AFE5B
xor eax, eax
mov [rbp+var_60], rax
jmp short loc_AFE8A
loc_AFE5B:
movsd xmm0, [rbp+var_40]
movsd xmm2, cs:qword_158C50
movaps xmm1, xmm0
subsd xmm1, xmm2
cvttsd2si rcx, xmm1
cvttsd2si rax, xmm0
mov rdx, rax
sar rdx, 3Fh
and rcx, rdx
or rax, rcx
mov [rbp+var_60], rax
loc_AFE8A:
mov rax, [rbp+var_60]
mov [rbp+var_18], rax
jmp short loc_AFEBA
loc_AFE94:
mov rax, [rbp+var_30]; jumptable 00000000000AFCED case 10
mov rax, [rax]
mov [rbp+var_20], rax
jmp short loc_AFEBA
loc_AFEA1:
mov rax, [rbp+var_30]; jumptable 00000000000AFCED case 11
mov rax, [rax]
mov [rbp+var_18], rax
jmp short loc_AFEBA
def_AFCED:
jmp short $+2; jumptable 00000000000AFCED default case, case 7
loc_AFEB0:
jmp short $+2
loc_AFEB2:
mov [rbp+var_18], 0
loc_AFEBA:
cmp [rbp+var_20], 0
jle short loc_AFECB
mov rax, [rbp+var_20]
mov [rbp+var_68], rax
jmp short loc_AFED3
loc_AFECB:
mov rax, [rbp+var_18]
mov [rbp+var_68], rax
loc_AFED3:
mov rax, [rbp+var_68]
pop rbp
retn
| long long retrieve_auto_increment(long long a1, long long a2)
{
long long v4; // [rsp+8h] [rbp-60h]
long long v5; // [rsp+10h] [rbp-58h]
signed int v6; // [rsp+1Ch] [rbp-4Ch]
float *v7; // [rsp+38h] [rbp-30h]
long long v8; // [rsp+40h] [rbp-28h]
long long v9; // [rsp+48h] [rbp-20h]
long long v10; // [rsp+50h] [rbp-18h]
v10 = 0LL;
v9 = 0LL;
v8 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 536LL)
+ 112LL * (unsigned int)(*(_DWORD *)(*(_QWORD *)a1 + 388LL) - 1)
+ 40);
v7 = (float *)(*(unsigned int *)(v8 + 8) + a2);
switch ( *(_BYTE *)(v8 + 24) )
{
case 2:
v10 = *(unsigned __int8 *)v7;
break;
case 3:
v9 = *(__int16 *)v7;
break;
case 4:
v9 = *(int *)v7;
break;
case 5:
if ( *v7 >= 0.0 )
v5 = (unsigned int)(int)*v7;
else
v5 = 0LL;
v10 = v5;
break;
case 6:
if ( *(double *)v7 >= 0.0 )
v4 = (unsigned int)(int)*(double *)v7;
else
v4 = 0LL;
v10 = v4;
break;
case 8:
v10 = *(unsigned __int16 *)v7;
break;
case 9:
v10 = *(unsigned int *)v7;
break;
case 0xA:
v9 = *(_QWORD *)v7;
break;
case 0xB:
v10 = *(_QWORD *)v7;
break;
case 0xC:
if ( (*((_BYTE *)v7 + 2) & 0x80) != 0 )
v6 = *(unsigned __int8 *)v7 | (*((unsigned __int8 *)v7 + 1) << 8) | (*((unsigned __int8 *)v7 + 2) << 16) | 0xFF000000;
else
v6 = *(unsigned __int8 *)v7 | (*((unsigned __int8 *)v7 + 1) << 8) | (*((unsigned __int8 *)v7 + 2) << 16);
v9 = v6;
break;
case 0xD:
v10 = (*((unsigned __int8 *)v7 + 2) << 16) | (unsigned int)*(unsigned __int16 *)v7;
break;
case 0xE:
v9 = *(char *)v7;
break;
default:
v10 = 0LL;
break;
}
if ( v9 <= 0 )
return v10;
else
return v9;
}
| retrieve_auto_increment:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],0x0
MOV qword ptr [RBP + -0x20],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RCX + 0x218]
MOV ECX,dword ptr [RCX + 0x184]
DEC ECX
IMUL RCX,RCX,0x70
MOV RAX,qword ptr [RAX + RCX*0x1 + 0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RCX + 0x8]
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX + 0x18]
ADD EAX,-0x2
MOV ECX,EAX
MOV qword ptr [RBP + -0x48],RCX
SUB EAX,0xc
JA 0x001afeae
MOV RAX,qword ptr [RBP + -0x48]
LEA RCX,[0x259480]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_e:
MOV RAX,qword ptr [RBP + -0x30]
MOVSX RAX,byte ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001afeba
caseD_2:
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001afeba
caseD_3:
MOV RAX,qword ptr [RBP + -0x30]
MOVSX RAX,word ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001afeba
caseD_8:
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,word ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001afeba
caseD_4:
MOV RAX,qword ptr [RBP + -0x30]
MOVSXD RAX,dword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001afeba
caseD_9:
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001afeba
caseD_c:
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX + 0x2]
AND EAX,0x80
CMP EAX,0x0
JZ 0x001afd8d
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX + 0x2]
SHL EAX,0x10
OR EAX,0xff000000
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,byte ptr [RCX]
OR EAX,ECX
MOV dword ptr [RBP + -0x4c],EAX
JMP 0x001afdb1
LAB_001afd8d:
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX + 0x2]
SHL EAX,0x10
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,byte ptr [RCX]
OR EAX,ECX
MOV dword ptr [RBP + -0x4c],EAX
LAB_001afdb1:
MOV EAX,dword ptr [RBP + -0x4c]
CDQE
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001afeba
caseD_d:
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
OR EAX,ECX
MOV EAX,EAX
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001afeba
caseD_5:
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x34],EAX
XORPS XMM0,XMM0
UCOMISS XMM0,dword ptr [RBP + -0x34]
JBE 0x001afe05
XOR EAX,EAX
MOV qword ptr [RBP + -0x58],RAX
JMP 0x001afe34
LAB_001afe05:
MOVSS XMM0,dword ptr [RBP + -0x34]
MOVSS XMM2,dword ptr [0x00251004]
MOVAPS XMM1,XMM0
SUBSS XMM1,XMM2
CVTTSS2SI RCX,XMM1
CVTTSS2SI RAX,XMM0
MOV RDX,RAX
SAR RDX,0x3f
AND RCX,RDX
OR RAX,RCX
MOV qword ptr [RBP + -0x58],RAX
LAB_001afe34:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001afeba
caseD_6:
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
XORPS XMM0,XMM0
UCOMISD XMM0,qword ptr [RBP + -0x40]
JBE 0x001afe5b
XOR EAX,EAX
MOV qword ptr [RBP + -0x60],RAX
JMP 0x001afe8a
LAB_001afe5b:
MOVSD XMM0,qword ptr [RBP + -0x40]
MOVSD XMM2,qword ptr [0x00258c50]
MOVAPS XMM1,XMM0
SUBSD XMM1,XMM2
CVTTSD2SI RCX,XMM1
CVTTSD2SI RAX,XMM0
MOV RDX,RAX
SAR RDX,0x3f
AND RCX,RDX
OR RAX,RCX
MOV qword ptr [RBP + -0x60],RAX
LAB_001afe8a:
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001afeba
caseD_a:
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001afeba
caseD_b:
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001afeba
caseD_7:
JMP 0x001afeb0
LAB_001afeb0:
JMP 0x001afeb2
LAB_001afeb2:
MOV qword ptr [RBP + -0x18],0x0
LAB_001afeba:
CMP qword ptr [RBP + -0x20],0x0
JLE 0x001afecb
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x68],RAX
JMP 0x001afed3
LAB_001afecb:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x68],RAX
LAB_001afed3:
MOV RAX,qword ptr [RBP + -0x68]
POP RBP
RET
|
double retrieve_auto_increment(long *param_1,long param_2)
{
float fVar1;
long lVar2;
double dVar3;
double *pdVar4;
double local_70;
double local_68;
double local_60;
uint local_54;
double local_28;
double local_20;
local_20 = 0.0;
local_28 = 0.0;
lVar2 = *(long *)(*(long *)(*param_1 + 0x218) + 0x28 +
(ulong)(*(int *)(*param_1 + 0x184) - 1) * 0x70);
pdVar4 = (double *)(param_2 + (ulong)*(uint *)(lVar2 + 8));
switch(*(int1 *)(lVar2 + 0x18)) {
case 2:
local_20 = (double)(ulong)*(byte *)pdVar4;
break;
case 3:
local_28 = (double)(long)(short)*(ushort *)pdVar4;
break;
case 4:
local_28 = (double)(long)(int)*(float *)pdVar4;
break;
case 5:
fVar1 = *(float *)pdVar4;
if (0.0 <= fVar1) {
local_60 = (double)((long)fVar1 | (long)(fVar1 - DAT_00251004) & (long)fVar1 >> 0x3f);
}
else {
local_60 = 0.0;
}
local_20 = local_60;
break;
case 6:
dVar3 = *pdVar4;
if (0.0 <= dVar3) {
local_68 = (double)((long)dVar3 | (long)(dVar3 - DAT_00258c50) & (long)dVar3 >> 0x3f);
}
else {
local_68 = 0.0;
}
local_20 = local_68;
break;
default:
local_20 = 0.0;
break;
case 8:
local_20 = (double)(ulong)*(ushort *)pdVar4;
break;
case 9:
local_20 = (double)(ulong)(uint)*(float *)pdVar4;
break;
case 10:
local_28 = *pdVar4;
break;
case 0xb:
local_20 = *pdVar4;
break;
case 0xc:
if (((ulong)*pdVar4 & 0x800000) == 0) {
local_54 = (uint)*(byte *)((long)pdVar4 + 2) << 0x10 | (uint)*(byte *)((long)pdVar4 + 1) << 8
| (uint)*(byte *)pdVar4;
}
else {
local_54 = (uint)*(byte *)((long)pdVar4 + 2) << 0x10 | 0xff000000 |
(uint)*(byte *)((long)pdVar4 + 1) << 8 | (uint)*(byte *)pdVar4;
}
local_28 = (double)(long)(int)local_54;
break;
case 0xd:
local_20 = (double)(ulong)*(uint3 *)pdVar4;
break;
case 0xe:
local_28 = (double)(long)(char)*(byte *)pdVar4;
}
if ((long)local_28 < 1) {
local_70 = local_20;
}
else {
local_70 = local_28;
}
return local_70;
}
| |
42,874 | add_cfg_dir | eloqsql/libmariadb/libmariadb/ma_default.c | static int add_cfg_dir(char **cfg_dirs, const char *directory)
{
int i;
for (i = 0; i < MAX_CONFIG_DIRS && cfg_dirs[i]; i++)
if (!strcmp(cfg_dirs[i], directory)) /* already present */
return 0;
if (i < MAX_CONFIG_DIRS) {
cfg_dirs[i]= strdup(directory);
return 0;
}
return 1;
} | O0 | c | add_cfg_dir:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x6, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
jge 0x6c335
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x6c33e
jmp 0x6c36e
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x36850
cmpl $0x0, %eax
jne 0x6c361
movl $0x0, -0x4(%rbp)
jmp 0x6c39c
jmp 0x6c363
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6c317
cmpl $0x6, -0x1c(%rbp)
jge 0x6c395
movq -0x18(%rbp), %rdi
callq 0x36030
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x4(%rbp)
jmp 0x6c39c
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| add_cfg_dir:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], 0
loc_6C317:
xor eax, eax
cmp [rbp+var_1C], 6
mov [rbp+var_1D], al
jge short loc_6C335
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_1C]
cmp qword ptr [rax+rcx*8], 0
setnz al
mov [rbp+var_1D], al
loc_6C335:
mov al, [rbp+var_1D]
test al, 1
jnz short loc_6C33E
jmp short loc_6C36E
loc_6C33E:
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_1C]
mov rdi, [rax+rcx*8]
mov rsi, [rbp+var_18]
call _strcmp
cmp eax, 0
jnz short loc_6C361
mov [rbp+var_4], 0
jmp short loc_6C39C
loc_6C361:
jmp short $+2
loc_6C363:
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
jmp short loc_6C317
loc_6C36E:
cmp [rbp+var_1C], 6
jge short loc_6C395
mov rdi, [rbp+var_18]
call _strdup
mov rdx, rax
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_1C]
mov [rax+rcx*8], rdx
mov [rbp+var_4], 0
jmp short loc_6C39C
loc_6C395:
mov [rbp+var_4], 1
loc_6C39C:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long add_cfg_dir(long long a1, long long a2)
{
bool v3; // [rsp+3h] [rbp-1Dh]
int i; // [rsp+4h] [rbp-1Ch]
for ( i = 0; ; ++i )
{
v3 = 0;
if ( i < 6 )
v3 = *(_QWORD *)(a1 + 8LL * i) != 0LL;
if ( !v3 )
break;
if ( !(unsigned int)strcmp(*(_QWORD *)(a1 + 8LL * i), a2) )
return 0;
}
if ( i >= 6 )
{
return 1;
}
else
{
*(_QWORD *)(a1 + 8LL * i) = strdup(a2);
return 0;
}
}
| add_cfg_dir:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],0x0
LAB_0016c317:
XOR EAX,EAX
CMP dword ptr [RBP + -0x1c],0x6
MOV byte ptr [RBP + -0x1d],AL
JGE 0x0016c335
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x1c]
CMP qword ptr [RAX + RCX*0x8],0x0
SETNZ AL
MOV byte ptr [RBP + -0x1d],AL
LAB_0016c335:
MOV AL,byte ptr [RBP + -0x1d]
TEST AL,0x1
JNZ 0x0016c33e
JMP 0x0016c36e
LAB_0016c33e:
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x1c]
MOV RDI,qword ptr [RAX + RCX*0x8]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00136850
CMP EAX,0x0
JNZ 0x0016c361
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0016c39c
LAB_0016c361:
JMP 0x0016c363
LAB_0016c363:
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x0016c317
LAB_0016c36e:
CMP dword ptr [RBP + -0x1c],0x6
JGE 0x0016c395
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00136030
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x1c]
MOV qword ptr [RAX + RCX*0x8],RDX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0016c39c
LAB_0016c395:
MOV dword ptr [RBP + -0x4],0x1
LAB_0016c39c:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 add_cfg_dir(long param_1,char *param_2)
{
int iVar1;
char *pcVar2;
bool bVar3;
int local_24;
local_24 = 0;
while( true ) {
bVar3 = false;
if (local_24 < 6) {
bVar3 = *(long *)(param_1 + (long)local_24 * 8) != 0;
}
if (!bVar3) break;
iVar1 = strcmp(*(char **)(param_1 + (long)local_24 * 8),param_2);
if (iVar1 == 0) {
return 0;
}
local_24 = local_24 + 1;
}
if (local_24 < 6) {
pcVar2 = strdup(param_2);
*(char **)(param_1 + (long)local_24 * 8) = pcVar2;
return 0;
}
return 1;
}
| |
42,875 | ma_freeze_size | eloqsql/libmariadb/libmariadb/ma_array.c | void ma_freeze_size(DYNAMIC_ARRAY *array)
{
uint elements=max(array->elements,1);
if (array->buffer && array->max_element != elements)
{
array->buffer=(char*) realloc(array->buffer,
elements*array->size_of_element);
array->max_element=elements;
}
} | O0 | c | ma_freeze_size:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jbe 0x47502
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x10(%rbp)
jmp 0x4750c
movl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4750c
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x47557
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0xc(%rbp), %eax
je 0x47557
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x13710
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| ma_freeze_size:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
cmp dword ptr [rax+8], 1
jbe short loc_47502
mov rax, [rbp+var_8]
mov eax, [rax+8]
mov [rbp+var_10], eax
jmp short loc_4750C
loc_47502:
mov eax, 1
mov [rbp+var_10], eax
jmp short $+2
loc_4750C:
mov eax, [rbp+var_10]
mov [rbp+var_C], eax
mov rax, [rbp+var_8]
cmp qword ptr [rax], 0
jz short loc_47557
mov rax, [rbp+var_8]
mov eax, [rax+0Ch]
cmp eax, [rbp+var_C]
jz short loc_47557
mov rax, [rbp+var_8]
mov rdi, [rax]
mov eax, [rbp+var_C]
mov rcx, [rbp+var_8]
imul eax, [rcx+14h]
mov eax, eax
mov esi, eax
call _realloc
mov rcx, rax
mov rax, [rbp+var_8]
mov [rax], rcx
mov ecx, [rbp+var_C]
mov rax, [rbp+var_8]
mov [rax+0Ch], ecx
loc_47557:
add rsp, 10h
pop rbp
retn
| long long ma_freeze_size(long long a1)
{
long long result; // rax
int v2; // [rsp+0h] [rbp-10h]
if ( *(_DWORD *)(a1 + 8) <= 1u )
v2 = 1;
else
v2 = *(_DWORD *)(a1 + 8);
result = a1;
if ( *(_QWORD *)a1 )
{
result = *(unsigned int *)(a1 + 12);
if ( (_DWORD)result != v2 )
{
*(_QWORD *)a1 = realloc(*(_QWORD *)a1, (unsigned int)(*(_DWORD *)(a1 + 20) * v2));
result = a1;
*(_DWORD *)(a1 + 12) = v2;
}
}
return result;
}
| ma_freeze_size:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x8],0x1
JBE 0x00147502
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x10],EAX
JMP 0x0014750c
LAB_00147502:
MOV EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
JMP 0x0014750c
LAB_0014750c:
MOV EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0xc],EAX
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX],0x0
JZ 0x00147557
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0xc]
CMP EAX,dword ptr [RBP + -0xc]
JZ 0x00147557
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0xc]
MOV RCX,qword ptr [RBP + -0x8]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV ESI,EAX
CALL 0x00113710
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
MOV ECX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0xc],ECX
LAB_00147557:
ADD RSP,0x10
POP RBP
RET
|
void ma_freeze_size(long *param_1)
{
void *pvVar1;
int local_18;
if (*(uint *)(param_1 + 1) < 2) {
local_18 = 1;
}
else {
local_18 = (int)param_1[1];
}
if ((*param_1 != 0) && (*(int *)((long)param_1 + 0xc) != local_18)) {
pvVar1 = realloc((void *)*param_1,(ulong)(uint)(local_18 * *(int *)((long)param_1 + 0x14)));
*param_1 = (long)pvVar1;
*(int *)((long)param_1 + 0xc) = local_18;
}
return;
}
| |
42,876 | minja::Parser::consumeToken(std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>> const&, minja::SpaceHandling) | llama.cpp/common/minja/minja.hpp | std::string consumeToken(const std::regex & regex, SpaceHandling space_handling = SpaceHandling::Strip) {
auto start = it;
consumeSpaces(space_handling);
std::smatch match;
if (std::regex_search(it, end, match, regex) && match.position() == 0) {
it += match[0].length();
return match[0].str();
}
it = start;
return "";
} | O3 | cpp | minja::Parser::consumeToken(std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>> const&, minja::SpaceHandling):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %r12
movq %rsi, %rdi
movl %ecx, %esi
callq 0xdfe6c
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rdi
movl $0x0, (%rsp)
movq %r15, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x70b08
testb %al, %al
je 0xdeffc
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
je 0xdefe3
movq (%rax), %r8
cmpq $0x48, %rdx
jne 0xdeff4
cmpq %rsi, %r8
jne 0xdeffc
jmp 0xdefea
cmpq %rsi, -0x48(%rax,%rdx)
jne 0xdeffc
leaq (%rax,%rdx), %rdi
addq $-0x48, %rdi
jmp 0xdf03f
movq %rax, %rdi
cmpq %rsi, %r8
je 0xdf03f
movq %r12, 0x20(%r14)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x33842(%rip), %rdx # 0x112850
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x28ab0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xdf030
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x20180
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%rdi), %r8
subq %rsi, %r8
xorl %esi, %esi
cmpb $0x0, 0x10(%rdi)
cmovneq %r8, %rsi
addq %rsi, 0x20(%r14)
cmpq $0x48, %rdx
leaq -0x48(%rax,%rdx), %rdx
movq %rax, %rsi
cmoveq %rdx, %rsi
cmpq %rcx, %rax
cmoveq %rdx, %rsi
movq %rbx, %rdi
callq 0x663e0
jmp 0xdf019
jmp 0xdf077
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xdf091
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x20180
movq %rbx, %rdi
callq 0x20af0
nop
| _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE:
push r15
push r14
push r12
push rbx
sub rsp, 38h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
mov r12, [rsi+20h]
mov rdi, rsi
mov esi, ecx
call _ZN5minja6Parser13consumeSpacesENS_13SpaceHandlingE; minja::Parser::consumeSpaces(minja::SpaceHandling)
xorps xmm0, xmm0
lea rdx, [rsp+58h+var_48]
movaps xmmword ptr [rdx+10h], xmm0
movaps xmmword ptr [rdx], xmm0
mov rsi, [r14+18h]
mov rdi, [r14+20h]
mov [rsp+58h+var_58], 0
mov rcx, r15
xor r8d, r8d
xor r9d, r9d
call _ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEEEEbT_SH_RNS5_13match_resultsISH_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeENS_20_RegexExecutorPolicyEb; std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> &,std::basic_regex<char,std::regex_traits<char>> const&,std::regex_constants::match_flag_type,std::__detail::_RegexExecutorPolicy,bool)
test al, al
jz short loc_DEFFC
mov rsi, [rsp+58h+var_30]
mov rax, [rsp+58h+var_48]
mov rcx, [rsp+58h+var_40]
mov rdx, rcx
sub rdx, rax
jz short loc_DEFE3
mov r8, [rax]
cmp rdx, 48h ; 'H'
jnz short loc_DEFF4
cmp r8, rsi
jnz short loc_DEFFC
jmp short loc_DEFEA
loc_DEFE3:
cmp [rax+rdx-48h], rsi
jnz short loc_DEFFC
loc_DEFEA:
lea rdi, [rax+rdx]
add rdi, 0FFFFFFFFFFFFFFB8h
jmp short loc_DF03F
loc_DEFF4:
mov rdi, rax
cmp r8, rsi
jz short loc_DF03F
loc_DEFFC:
mov [r14+20h], r12
lea rax, [rbx+10h]
mov [rbx], rax
lea rdx, aProcessingRequ+19h; ""
mov rdi, rbx
mov rsi, rdx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
loc_DF019:
mov rdi, [rsp+58h+var_48]; void *
test rdi, rdi
jz short loc_DF030
mov rsi, [rsp+58h+var_38]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_DF030:
mov rax, rbx
add rsp, 38h
pop rbx
pop r12
pop r14
pop r15
retn
loc_DF03F:
mov r8, [rdi+8]
sub r8, rsi
xor esi, esi
cmp byte ptr [rdi+10h], 0
cmovnz rsi, r8
add [r14+20h], rsi
cmp rdx, 48h ; 'H'
lea rdx, [rax+rdx-48h]
mov rsi, rax
cmovz rsi, rdx
cmp rax, rcx
cmovz rsi, rdx
mov rdi, rbx
call _ZNKSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEE3strEv; std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>::str(void)
jmp short loc_DF019
jmp short $+2
loc_DF077:
mov rbx, rax
mov rdi, [rsp+arg_8]; void *
test rdi, rdi
jz short loc_DF091
mov rsi, [rsp+arg_18]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_DF091:
mov rdi, rbx
call __Unwind_Resume
| _QWORD * minja::Parser::consumeToken(_QWORD *a1, long long a2, long long a3, unsigned int a4)
{
long long v7; // r12
__int128 v8; // kr00_16
long long v9; // rdx
long long v10; // r8
long long v11; // rdi
long long v13; // rsi
bool v14; // zf
long long v15; // rdx
long long *v16; // rsi
__int128 v17; // [rsp+10h] [rbp-48h] BYREF
__int128 v18; // [rsp+20h] [rbp-38h]
v7 = *(_QWORD *)(a2 + 32);
minja::Parser::consumeSpaces(a2, a4);
v18 = 0LL;
v17 = 0LL;
if ( !std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(
*(long long **)(a2 + 32),
*(_QWORD *)(a2 + 24),
(char **)&v17,
a3,
0,
0,
0) )
goto LABEL_9;
v8 = v17;
v9 = *((_QWORD *)&v17 + 1) - v17;
if ( *((_QWORD *)&v17 + 1) != (_QWORD)v17 )
{
v10 = *(_QWORD *)v17;
if ( v9 == 72 )
{
if ( v10 == *((_QWORD *)&v18 + 1) )
goto LABEL_7;
}
else
{
v11 = v17;
if ( v10 == *((_QWORD *)&v18 + 1) )
goto LABEL_13;
}
LABEL_9:
*(_QWORD *)(a2 + 32) = v7;
*a1 = a1 + 2;
std::string::_M_construct<char const*>((long long)a1, "", (long long)"");
goto LABEL_10;
}
if ( *(_QWORD *)(*((_QWORD *)&v17 + 1) - 72LL) != *((_QWORD *)&v18 + 1) )
goto LABEL_9;
LABEL_7:
v11 = *((_QWORD *)&v17 + 1) - 72LL;
LABEL_13:
v13 = 0LL;
if ( *(_BYTE *)(v11 + 16) )
v13 = *(_QWORD *)(v11 + 8) - *((_QWORD *)&v18 + 1);
*(_QWORD *)(a2 + 32) += v13;
v14 = v9 == 72;
v15 = v8 + v9 - 72;
v16 = (long long *)v8;
if ( v14 )
v16 = (long long *)v15;
if ( (_QWORD)v8 == *((_QWORD *)&v8 + 1) )
v16 = (long long *)v15;
std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>::str((long long)a1, v16);
LABEL_10:
if ( (_QWORD)v17 )
operator delete((void *)v17, v18 - v17);
return a1;
}
| consumeToken:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
MOV R12,qword ptr [RSI + 0x20]
MOV RDI,RSI
MOV ESI,ECX
CALL 0x001dfe6c
XORPS XMM0,XMM0
LEA RDX,[RSP + 0x10]
MOVAPS xmmword ptr [RDX + 0x10],XMM0
MOVAPS xmmword ptr [RDX],XMM0
MOV RSI,qword ptr [R14 + 0x18]
MOV RDI,qword ptr [R14 + 0x20]
LAB_001defa3:
MOV dword ptr [RSP],0x0
MOV RCX,R15
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00170b08
TEST AL,AL
JZ 0x001deffc
MOV RSI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x18]
MOV RDX,RCX
SUB RDX,RAX
JZ 0x001defe3
MOV R8,qword ptr [RAX]
CMP RDX,0x48
JNZ 0x001deff4
CMP R8,RSI
JNZ 0x001deffc
JMP 0x001defea
LAB_001defe3:
CMP qword ptr [RAX + RDX*0x1 + -0x48],RSI
JNZ 0x001deffc
LAB_001defea:
LEA RDI,[RAX + RDX*0x1]
ADD RDI,-0x48
JMP 0x001df03f
LAB_001deff4:
MOV RDI,RAX
CMP R8,RSI
JZ 0x001df03f
LAB_001deffc:
MOV qword ptr [R14 + 0x20],R12
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LAB_001df007:
LEA RDX,[0x212850]
MOV RDI,RBX
MOV RSI,RDX
CALL 0x00128ab0
LAB_001df019:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x001df030
MOV RSI,qword ptr [RSP + 0x20]
SUB RSI,RDI
CALL 0x00120180
LAB_001df030:
MOV RAX,RBX
ADD RSP,0x38
POP RBX
POP R12
POP R14
POP R15
RET
LAB_001df03f:
MOV R8,qword ptr [RDI + 0x8]
SUB R8,RSI
XOR ESI,ESI
CMP byte ptr [RDI + 0x10],0x0
CMOVNZ RSI,R8
ADD qword ptr [R14 + 0x20],RSI
CMP RDX,0x48
LEA RDX,[RAX + RDX*0x1 + -0x48]
MOV RSI,RAX
CMOVZ RSI,RDX
CMP RAX,RCX
CMOVZ RSI,RDX
LAB_001df06b:
MOV RDI,RBX
CALL 0x001663e0
LAB_001df073:
JMP 0x001df019
|
/* minja::Parser::consumeToken(std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char> >
const&, minja::SpaceHandling) */
long * minja::Parser::consumeToken
(long *param_1,Parser *param_2,int8 param_3,int4 param_4)
{
int8 uVar1;
long lVar2;
bool bVar3;
long lVar4;
long *plVar5;
long *local_48;
long lStack_40;
long local_38;
long lStack_30;
uVar1 = *(int8 *)(param_2 + 0x20);
consumeSpaces(param_2,param_4);
local_38 = 0;
lStack_30 = 0;
local_48 = (long *)0x0;
lStack_40 = 0;
/* try { // try from 001defa3 to 001defb7 has its CatchHandler @ 001df077 */
bVar3 = std::__detail::
__regex_algo_impl<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>,char,std::__cxx11::regex_traits<char>>
(*(int8 *)(param_2 + 0x20),*(int8 *)(param_2 + 0x18),&local_48,
param_3,0,0,0);
if (bVar3) {
lVar4 = lStack_40 - (long)local_48;
if (lVar4 == 0) {
lVar2 = local_48[-9];
joined_r0x001defe8:
if (lVar2 != lStack_30) goto LAB_001deffc;
plVar5 = (long *)((long)local_48 + lVar4 + -0x48);
}
else {
lVar2 = *local_48;
if (lVar4 == 0x48) goto joined_r0x001defe8;
plVar5 = local_48;
if (lVar2 != lStack_30) goto LAB_001deffc;
}
lVar4 = 0;
if ((char)plVar5[2] != '\0') {
lVar4 = plVar5[1] - lStack_30;
}
*(long *)(param_2 + 0x20) = *(long *)(param_2 + 0x20) + lVar4;
/* try { // try from 001df06b to 001df072 has its CatchHandler @ 001df077 */
std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>::str();
}
else {
LAB_001deffc:
*(int8 *)(param_2 + 0x20) = uVar1;
*param_1 = (long)(param_1 + 2);
/* try { // try from 001df007 to 001df018 has its CatchHandler @ 001df075 */
std::__cxx11::string::_M_construct<char_const*>(param_1,"");
}
if (local_48 != (long *)0x0) {
operator_delete(local_48,local_38 - (long)local_48);
}
return param_1;
}
| |
42,877 | js_async_generator_mark | bluesky950520[P]quickjs/quickjs.c | static void js_async_generator_mark(JSRuntime *rt, JSValue val,
JS_MarkFunc *mark_func)
{
JSAsyncGeneratorData *s = JS_GetOpaque(val, JS_CLASS_ASYNC_GENERATOR);
struct list_head *el;
JSAsyncGeneratorRequest *req;
if (s) {
list_for_each(el, &s->queue) {
req = list_entry(el, JSAsyncGeneratorRequest, link);
JS_MarkValue(rt, req->result, mark_func);
JS_MarkValue(rt, req->promise, mark_func);
JS_MarkValue(rt, req->resolving_funcs[0], mark_func);
JS_MarkValue(rt, req->resolving_funcs[1], mark_func);
}
if (s->state != JS_ASYNC_GENERATOR_STATE_COMPLETED &&
s->state != JS_ASYNC_GENERATOR_STATE_AWAITING_RETURN) {
async_func_mark(rt, &s->func_state, mark_func);
}
}
} | O1 | c | js_async_generator_mark:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq %rsi, (%rsp)
cmpl $-0x1, %edx
jne 0x51e51
movq (%rsp), %rax
cmpw $0x39, 0x6(%rax)
jne 0x51e51
movq 0x30(%rax), %r15
jmp 0x51e54
xorl %r15d, %r15d
testq %r15, %r15
je 0x51f0b
leaq 0x78(%r15), %r12
movq 0x80(%r15), %r13
cmpq %r12, %r13
je 0x51eff
movl $0xfffffffe, %ebp # imm = 0xFFFFFFFE
movsd 0x18(%r13), %xmm0
movl 0x20(%r13), %eax
movsd %xmm0, (%rsp)
andl $-0x2, %eax
cmpl %ebp, %eax
jne 0x51e95
movq (%rsp), %rsi
movq %r14, %rdi
callq *%rbx
movsd 0x28(%r13), %xmm0
movl 0x30(%r13), %eax
movsd %xmm0, (%rsp)
andl $-0x2, %eax
cmpl %ebp, %eax
jne 0x51eb4
movq (%rsp), %rsi
movq %r14, %rdi
callq *%rbx
movsd 0x38(%r13), %xmm0
movl 0x40(%r13), %eax
movsd %xmm0, (%rsp)
andl $-0x2, %eax
cmpl %ebp, %eax
jne 0x51ed3
movq (%rsp), %rsi
movq %r14, %rdi
callq *%rbx
movsd 0x48(%r13), %xmm0
movl 0x50(%r13), %eax
movsd %xmm0, (%rsp)
andl $-0x2, %eax
cmpl %ebp, %eax
jne 0x51ef2
movq (%rsp), %rsi
movq %r14, %rdi
callq *%rbx
movq 0x8(%r13), %r13
cmpq %r12, %r13
jne 0x51e76
movl 0x8(%r15), %eax
andl $-0x2, %eax
cmpl $0x4, %eax
jne 0x51f1a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x10, %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a9bd
| js_async_generator_mark:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rcx
mov r14, rdi
mov [rsp+38h+var_38], rsi
cmp edx, 0FFFFFFFFh
jnz short loc_51E51
mov rax, [rsp+38h+var_38]
cmp word ptr [rax+6], 39h ; '9'
jnz short loc_51E51
mov r15, [rax+30h]
jmp short loc_51E54
loc_51E51:
xor r15d, r15d
loc_51E54:
test r15, r15
jz loc_51F0B
lea r12, [r15+78h]
mov r13, [r15+80h]
cmp r13, r12
jz loc_51EFF
mov ebp, 0FFFFFFFEh
loc_51E76:
movsd xmm0, qword ptr [r13+18h]
mov eax, [r13+20h]
movsd [rsp+38h+var_38], xmm0
and eax, 0FFFFFFFEh
cmp eax, ebp
jnz short loc_51E95
mov rsi, [rsp+38h+var_38]
mov rdi, r14
call rbx
loc_51E95:
movsd xmm0, qword ptr [r13+28h]
mov eax, [r13+30h]
movsd [rsp+38h+var_38], xmm0
and eax, 0FFFFFFFEh
cmp eax, ebp
jnz short loc_51EB4
mov rsi, [rsp+38h+var_38]
mov rdi, r14
call rbx
loc_51EB4:
movsd xmm0, qword ptr [r13+38h]
mov eax, [r13+40h]
movsd [rsp+38h+var_38], xmm0
and eax, 0FFFFFFFEh
cmp eax, ebp
jnz short loc_51ED3
mov rsi, [rsp+38h+var_38]
mov rdi, r14
call rbx
loc_51ED3:
movsd xmm0, qword ptr [r13+48h]
mov eax, [r13+50h]
movsd [rsp+38h+var_38], xmm0
and eax, 0FFFFFFFEh
cmp eax, ebp
jnz short loc_51EF2
mov rsi, [rsp+38h+var_38]
mov rdi, r14
call rbx
loc_51EF2:
mov r13, [r13+8]
cmp r13, r12
jnz loc_51E76
loc_51EFF:
mov eax, [r15+8]
and eax, 0FFFFFFFEh
cmp eax, 4
jnz short loc_51F1A
loc_51F0B:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_51F1A:
add r15, 10h
mov rdi, r14
mov rsi, r15
mov rdx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp async_func_mark
| long long js_async_generator_mark(long long a1, long long a2, int a3, void ( *a4)(long long, _QWORD))
{
long long result; // rax
long long v6; // r15
long long i; // r13
if ( a3 == -1 && (result = a2, *(_WORD *)(a2 + 6) == 57) )
v6 = *(_QWORD *)(a2 + 48);
else
v6 = 0LL;
if ( v6 )
{
for ( i = *(_QWORD *)(v6 + 128); i != v6 + 120; i = *(_QWORD *)(i + 8) )
{
if ( (*(_DWORD *)(i + 32) & 0xFFFFFFFE) == 0xFFFFFFFE )
a4(a1, *(_QWORD *)(i + 24));
if ( (*(_DWORD *)(i + 48) & 0xFFFFFFFE) == 0xFFFFFFFE )
a4(a1, *(_QWORD *)(i + 40));
if ( (*(_DWORD *)(i + 64) & 0xFFFFFFFE) == 0xFFFFFFFE )
a4(a1, *(_QWORD *)(i + 56));
if ( (*(_DWORD *)(i + 80) & 0xFFFFFFFE) == 0xFFFFFFFE )
a4(a1, *(_QWORD *)(i + 72));
}
result = *(_DWORD *)(v6 + 8) & 0xFFFFFFFE;
if ( (_DWORD)result != 4 )
return async_func_mark(a1, v6 + 16, a4);
}
return result;
}
| js_async_generator_mark:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R14,RDI
MOV qword ptr [RSP],RSI
CMP EDX,-0x1
JNZ 0x00151e51
MOV RAX,qword ptr [RSP]
CMP word ptr [RAX + 0x6],0x39
JNZ 0x00151e51
MOV R15,qword ptr [RAX + 0x30]
JMP 0x00151e54
LAB_00151e51:
XOR R15D,R15D
LAB_00151e54:
TEST R15,R15
JZ 0x00151f0b
LEA R12,[R15 + 0x78]
MOV R13,qword ptr [R15 + 0x80]
CMP R13,R12
JZ 0x00151eff
MOV EBP,0xfffffffe
LAB_00151e76:
MOVSD XMM0,qword ptr [R13 + 0x18]
MOV EAX,dword ptr [R13 + 0x20]
MOVSD qword ptr [RSP],XMM0
AND EAX,0xfffffffe
CMP EAX,EBP
JNZ 0x00151e95
MOV RSI,qword ptr [RSP]
MOV RDI,R14
CALL RBX
LAB_00151e95:
MOVSD XMM0,qword ptr [R13 + 0x28]
MOV EAX,dword ptr [R13 + 0x30]
MOVSD qword ptr [RSP],XMM0
AND EAX,0xfffffffe
CMP EAX,EBP
JNZ 0x00151eb4
MOV RSI,qword ptr [RSP]
MOV RDI,R14
CALL RBX
LAB_00151eb4:
MOVSD XMM0,qword ptr [R13 + 0x38]
MOV EAX,dword ptr [R13 + 0x40]
MOVSD qword ptr [RSP],XMM0
AND EAX,0xfffffffe
CMP EAX,EBP
JNZ 0x00151ed3
MOV RSI,qword ptr [RSP]
MOV RDI,R14
CALL RBX
LAB_00151ed3:
MOVSD XMM0,qword ptr [R13 + 0x48]
MOV EAX,dword ptr [R13 + 0x50]
MOVSD qword ptr [RSP],XMM0
AND EAX,0xfffffffe
CMP EAX,EBP
JNZ 0x00151ef2
MOV RSI,qword ptr [RSP]
MOV RDI,R14
CALL RBX
LAB_00151ef2:
MOV R13,qword ptr [R13 + 0x8]
CMP R13,R12
JNZ 0x00151e76
LAB_00151eff:
MOV EAX,dword ptr [R15 + 0x8]
AND EAX,0xfffffffe
CMP EAX,0x4
JNZ 0x00151f1a
LAB_00151f0b:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00151f1a:
ADD R15,0x10
MOV RDI,R14
MOV RSI,R15
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0013a9bd
|
void js_async_generator_mark(int8 param_1,long param_2,int param_3,code *param_4)
{
long lVar1;
long lVar2;
if ((param_3 == -1) && (*(short *)(param_2 + 6) == 0x39)) {
lVar2 = *(long *)(param_2 + 0x30);
}
else {
lVar2 = 0;
}
if (lVar2 != 0) {
for (lVar1 = *(long *)(lVar2 + 0x80); lVar1 != lVar2 + 0x78; lVar1 = *(long *)(lVar1 + 8)) {
if ((*(uint *)(lVar1 + 0x20) & 0xfffffffe) == 0xfffffffe) {
(*param_4)(param_1,*(int8 *)(lVar1 + 0x18));
}
if ((*(uint *)(lVar1 + 0x30) & 0xfffffffe) == 0xfffffffe) {
(*param_4)(param_1,*(int8 *)(lVar1 + 0x28));
}
if ((*(uint *)(lVar1 + 0x40) & 0xfffffffe) == 0xfffffffe) {
(*param_4)(param_1,*(int8 *)(lVar1 + 0x38));
}
if ((*(uint *)(lVar1 + 0x50) & 0xfffffffe) == 0xfffffffe) {
(*param_4)(param_1,*(int8 *)(lVar1 + 0x48));
}
}
if ((*(uint *)(lVar2 + 8) & 0xfffffffe) != 4) {
async_func_mark(param_1,lVar2 + 0x10,param_4);
return;
}
}
return;
}
| |
42,878 | js_async_generator_mark | bluesky950520[P]quickjs/quickjs.c | static void js_async_generator_mark(JSRuntime *rt, JSValue val,
JS_MarkFunc *mark_func)
{
JSAsyncGeneratorData *s = JS_GetOpaque(val, JS_CLASS_ASYNC_GENERATOR);
struct list_head *el;
JSAsyncGeneratorRequest *req;
if (s) {
list_for_each(el, &s->queue) {
req = list_entry(el, JSAsyncGeneratorRequest, link);
JS_MarkValue(rt, req->result, mark_func);
JS_MarkValue(rt, req->promise, mark_func);
JS_MarkValue(rt, req->resolving_funcs[0], mark_func);
JS_MarkValue(rt, req->resolving_funcs[1], mark_func);
}
if (s->state != JS_ASYNC_GENERATOR_STATE_COMPLETED &&
s->state != JS_ASYNC_GENERATOR_STATE_AWAITING_RETURN) {
async_func_mark(rt, &s->func_state, mark_func);
}
}
} | O3 | c | js_async_generator_mark:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $-0x1, %edx
jne 0x54933
cmpw $0x39, 0x6(%rsi)
jne 0x54933
movq 0x30(%rsi), %r15
testq %r15, %r15
je 0x54933
movq %rcx, %rbx
movq %rdi, %r14
leaq 0x78(%r15), %r12
movq 0x80(%r15), %r13
cmpq %r12, %r13
je 0x54927
movl $0xfffffffe, %ebp # imm = 0xFFFFFFFE
movl 0x20(%r13), %eax
andl $-0x2, %eax
cmpl %ebp, %eax
jne 0x548e2
movq 0x18(%r13), %rsi
movq %r14, %rdi
callq *%rbx
movl 0x30(%r13), %eax
andl $-0x2, %eax
cmpl %ebp, %eax
jne 0x548f6
movq 0x28(%r13), %rsi
movq %r14, %rdi
callq *%rbx
movl 0x40(%r13), %eax
andl $-0x2, %eax
cmpl %ebp, %eax
jne 0x5490a
movq 0x38(%r13), %rsi
movq %r14, %rdi
callq *%rbx
movl 0x50(%r13), %eax
andl $-0x2, %eax
cmpl %ebp, %eax
jne 0x5491e
movq 0x48(%r13), %rsi
movq %r14, %rdi
callq *%rbx
movq 0x8(%r13), %r13
cmpq %r12, %r13
jne 0x548ce
movl 0x8(%r15), %eax
andl $-0x2, %eax
cmpl $0x4, %eax
jne 0x54942
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x10, %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3bfd5
| js_async_generator_mark:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
cmp edx, 0FFFFFFFFh
jnz loc_54933
cmp word ptr [rsi+6], 39h ; '9'
jnz loc_54933
mov r15, [rsi+30h]
test r15, r15
jz loc_54933
mov rbx, rcx
mov r14, rdi
lea r12, [r15+78h]
mov r13, [r15+80h]
cmp r13, r12
jz short loc_54927
mov ebp, 0FFFFFFFEh
loc_548CE:
mov eax, [r13+20h]
and eax, 0FFFFFFFEh
cmp eax, ebp
jnz short loc_548E2
mov rsi, [r13+18h]
mov rdi, r14
call rbx
loc_548E2:
mov eax, [r13+30h]
and eax, 0FFFFFFFEh
cmp eax, ebp
jnz short loc_548F6
mov rsi, [r13+28h]
mov rdi, r14
call rbx
loc_548F6:
mov eax, [r13+40h]
and eax, 0FFFFFFFEh
cmp eax, ebp
jnz short loc_5490A
mov rsi, [r13+38h]
mov rdi, r14
call rbx
loc_5490A:
mov eax, [r13+50h]
and eax, 0FFFFFFFEh
cmp eax, ebp
jnz short loc_5491E
mov rsi, [r13+48h]
mov rdi, r14
call rbx
loc_5491E:
mov r13, [r13+8]
cmp r13, r12
jnz short loc_548CE
loc_54927:
mov eax, [r15+8]
and eax, 0FFFFFFFEh
cmp eax, 4
jnz short loc_54942
loc_54933:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_54942:
add r15, 10h
mov rdi, r14
mov rsi, r15
mov rdx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp async_func_mark
| unsigned long long js_async_generator_mark(
long long a1,
long long a2,
int a3,
void ( *a4)(long long, _QWORD))
{
long long v4; // r15
long long i; // r13
unsigned long long result; // rax
if ( a3 == -1 && *(_WORD *)(a2 + 6) == 57 )
{
v4 = *(_QWORD *)(a2 + 48);
if ( v4 )
{
for ( i = *(_QWORD *)(v4 + 128); i != v4 + 120; i = *(_QWORD *)(i + 8) )
{
if ( (*(_DWORD *)(i + 32) & 0xFFFFFFFE) == 0xFFFFFFFE )
a4(a1, *(_QWORD *)(i + 24));
if ( (*(_DWORD *)(i + 48) & 0xFFFFFFFE) == 0xFFFFFFFE )
a4(a1, *(_QWORD *)(i + 40));
if ( (*(_DWORD *)(i + 64) & 0xFFFFFFFE) == 0xFFFFFFFE )
a4(a1, *(_QWORD *)(i + 56));
if ( (*(_DWORD *)(i + 80) & 0xFFFFFFFE) == 0xFFFFFFFE )
a4(a1, *(_QWORD *)(i + 72));
}
result = *(_DWORD *)(v4 + 8) & 0xFFFFFFFE;
if ( (_DWORD)result != 4 )
return async_func_mark(a1, v4 + 16, a4);
}
}
return result;
}
| js_async_generator_mark:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
CMP EDX,-0x1
JNZ 0x00154933
CMP word ptr [RSI + 0x6],0x39
JNZ 0x00154933
MOV R15,qword ptr [RSI + 0x30]
TEST R15,R15
JZ 0x00154933
MOV RBX,RCX
MOV R14,RDI
LEA R12,[R15 + 0x78]
MOV R13,qword ptr [R15 + 0x80]
CMP R13,R12
JZ 0x00154927
MOV EBP,0xfffffffe
LAB_001548ce:
MOV EAX,dword ptr [R13 + 0x20]
AND EAX,0xfffffffe
CMP EAX,EBP
JNZ 0x001548e2
MOV RSI,qword ptr [R13 + 0x18]
MOV RDI,R14
CALL RBX
LAB_001548e2:
MOV EAX,dword ptr [R13 + 0x30]
AND EAX,0xfffffffe
CMP EAX,EBP
JNZ 0x001548f6
MOV RSI,qword ptr [R13 + 0x28]
MOV RDI,R14
CALL RBX
LAB_001548f6:
MOV EAX,dword ptr [R13 + 0x40]
AND EAX,0xfffffffe
CMP EAX,EBP
JNZ 0x0015490a
MOV RSI,qword ptr [R13 + 0x38]
MOV RDI,R14
CALL RBX
LAB_0015490a:
MOV EAX,dword ptr [R13 + 0x50]
AND EAX,0xfffffffe
CMP EAX,EBP
JNZ 0x0015491e
MOV RSI,qword ptr [R13 + 0x48]
MOV RDI,R14
CALL RBX
LAB_0015491e:
MOV R13,qword ptr [R13 + 0x8]
CMP R13,R12
JNZ 0x001548ce
LAB_00154927:
MOV EAX,dword ptr [R15 + 0x8]
AND EAX,0xfffffffe
CMP EAX,0x4
JNZ 0x00154942
LAB_00154933:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00154942:
ADD R15,0x10
MOV RDI,R14
MOV RSI,R15
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0013bfd5
|
void js_async_generator_mark(int8 param_1,long param_2,int param_3,code *param_4)
{
long lVar1;
long lVar2;
if (((param_3 == -1) && (*(short *)(param_2 + 6) == 0x39)) &&
(lVar1 = *(long *)(param_2 + 0x30), lVar1 != 0)) {
for (lVar2 = *(long *)(lVar1 + 0x80); lVar2 != lVar1 + 0x78; lVar2 = *(long *)(lVar2 + 8)) {
if ((*(uint *)(lVar2 + 0x20) & 0xfffffffe) == 0xfffffffe) {
(*param_4)(param_1,*(int8 *)(lVar2 + 0x18));
}
if ((*(uint *)(lVar2 + 0x30) & 0xfffffffe) == 0xfffffffe) {
(*param_4)(param_1,*(int8 *)(lVar2 + 0x28));
}
if ((*(uint *)(lVar2 + 0x40) & 0xfffffffe) == 0xfffffffe) {
(*param_4)(param_1,*(int8 *)(lVar2 + 0x38));
}
if ((*(uint *)(lVar2 + 0x50) & 0xfffffffe) == 0xfffffffe) {
(*param_4)(param_1,*(int8 *)(lVar2 + 0x48));
}
}
if ((*(uint *)(lVar1 + 8) & 0xfffffffe) != 4) {
async_func_mark(param_1,lVar1 + 0x10,param_4);
return;
}
}
return;
}
| |
42,879 | ma_ft_update | eloqsql/storage/maria/ma_ft_update.c | int _ma_ft_update(MARIA_HA *info, uint keynr, uchar *keybuf,
const uchar *oldrec, const uchar *newrec, my_off_t pos)
{
int error= -1;
FT_WORD *oldlist,*newlist, *old_word, *new_word;
CHARSET_INFO *cs=info->s->keyinfo[keynr].seg->charset;
int cmp, cmp2;
DBUG_ENTER("_ma_ft_update");
if (!(old_word=oldlist=_ma_ft_parserecord(info, keynr, oldrec,
&info->ft_memroot)) ||
!(new_word=newlist=_ma_ft_parserecord(info, keynr, newrec,
&info->ft_memroot)))
goto err;
error=0;
while(old_word->pos && new_word->pos)
{
cmp= ha_compare_text(cs, (uchar*) old_word->pos,old_word->len,
(uchar*) new_word->pos,new_word->len,0);
cmp2= cmp ? 0 : (fabs(old_word->weight - new_word->weight) > 1.e-5);
if (cmp < 0 || cmp2)
{
MARIA_KEY key;
_ma_ft_make_key(info, &key, keynr, keybuf, old_word, pos);
if (_ma_ck_delete(info, &key))
{
error= -1;
goto err;
}
}
if (cmp > 0 || cmp2)
{
MARIA_KEY key;
_ma_ft_make_key(info, &key, keynr, keybuf, new_word,pos);
if ((error= _ma_ck_write(info, &key)))
goto err;
}
if (cmp<=0) old_word++;
if (cmp>=0) new_word++;
}
if (old_word->pos)
error= _ma_ft_erase(info,keynr,keybuf,old_word,pos);
else if (new_word->pos)
error= _ma_ft_store(info,keynr,keybuf,new_word,pos);
err:
free_root(&info->ft_memroot, MYF(MY_MARK_BLOCKS_FREE));
DBUG_RETURN(error);
} | O3 | c | ma_ft_update:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, -0x48(%rbp)
movq %r8, %rbx
movq %rdx, -0x40(%rbp)
movl %esi, %r12d
movq %rdi, %r13
movq (%rdi), %rax
movq 0x570(%rax), %rax
movl %esi, %edx
imulq $0x118, %rdx, %rdx # imm = 0x118
movq 0xc0(%rax,%rdx), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
leaq 0x328(%rdi), %r15
movq %rcx, %rdx
movq %r15, %rcx
callq 0x6a5c4
testq %rax, %rax
je 0x6a8c7
movq %rax, %r14
movq %r13, %rdi
movl %r12d, %esi
movq %rbx, %rdx
movq %r15, -0x30(%rbp)
movq %r15, %rcx
callq 0x6a5c4
testq %rax, %rax
je 0x6a8c3
movq %rax, %r15
movq (%r14), %rsi
testq %rsi, %rsi
je 0x6a8a5
movl %r12d, -0x34(%rbp)
movq %r13, -0x50(%rbp)
movq (%r15), %rcx
testq %rcx, %rcx
je 0x6a8d2
movl 0x8(%r14), %edx
movl 0x8(%r15), %r8d
xorl %r12d, %r12d
movq -0x58(%rbp), %rdi
xorl %r9d, %r9d
callq 0x9e800
movl %eax, %ebx
testl %eax, %eax
jne 0x6a80e
movsd 0x10(%r14), %xmm0
subsd 0x10(%r15), %xmm0
andpd 0x6e8be(%rip), %xmm0 # 0xd90c0
ucomisd 0x767b6(%rip), %xmm0 # 0xe0fc0
seta %r12b
testl %ebx, %ebx
js 0x6a817
testb %r12b, %r12b
je 0x6a845
movq -0x50(%rbp), %r13
movq %r13, %rdi
leaq -0x78(%rbp), %rsi
movl -0x34(%rbp), %edx
movq -0x40(%rbp), %rcx
movq %r14, %r8
movq -0x48(%rbp), %r9
callq 0x6a911
movq %r13, %rdi
leaq -0x78(%rbp), %rsi
callq 0x6752d
testb %al, %al
jne 0x6a8c3
testl %ebx, %ebx
setg %al
orb %r12b, %al
testb $0x1, %al
movl -0x34(%rbp), %r12d
movq -0x50(%rbp), %r13
je 0x6a887
movq %r13, %rdi
leaq -0x78(%rbp), %rsi
movl %r12d, %edx
movq -0x40(%rbp), %rcx
movq %r15, %r8
movq -0x48(%rbp), %r9
callq 0x6a911
movq %r13, %rdi
leaq -0x78(%rbp), %rsi
callq 0x64830
testb %al, %al
jne 0x6a90c
leaq 0x18(%r14), %rax
leaq 0x18(%r15), %rcx
testl %ebx, %ebx
cmovleq %rax, %r14
cmovnsq %rcx, %r15
movq (%r14), %rsi
testq %rsi, %rsi
jne 0x6a7c5
cmpq $0x0, (%r15)
je 0x6a8ce
movq %r13, %rdi
movl %r12d, %esi
movq -0x40(%rbp), %rdx
movq %r15, %rcx
movq -0x48(%rbp), %r8
callq 0x6aa3e
jmp 0x6a8e8
movq -0x30(%rbp), %r15
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
jmp 0x6a8ee
xorl %ebx, %ebx
jmp 0x6a8ea
movq %r13, %rdi
movl %r12d, %esi
movq -0x40(%rbp), %rdx
movq %r14, %rcx
movq -0x48(%rbp), %r8
callq 0x6a9bf
movl %eax, %ebx
movq -0x30(%rbp), %r15
movl $0x2, %esi
movq %r15, %rdi
callq 0x9cf13
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movsbl %al, %ebx
jmp 0x6a8ea
| _ma_ft_update:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov [rbp+var_48], r9
mov rbx, r8
mov [rbp+var_40], rdx
mov r12d, esi
mov r13, rdi
mov rax, [rdi]
mov rax, [rax+570h]
mov edx, esi
imul rdx, 118h
mov rax, [rax+rdx+0C0h]
mov rax, [rax]
mov [rbp+var_58], rax
lea r15, [rdi+328h]
mov rdx, rcx
mov rcx, r15
call _ma_ft_parserecord
test rax, rax
jz loc_6A8C7
mov r14, rax
mov rdi, r13
mov esi, r12d
mov rdx, rbx
mov [rbp+var_30], r15
mov rcx, r15
call _ma_ft_parserecord
test rax, rax
jz loc_6A8C3
mov r15, rax
mov rsi, [r14]
test rsi, rsi
jz loc_6A8A5
mov [rbp+var_34], r12d
mov [rbp+var_50], r13
loc_6A7C5:
mov rcx, [r15]
test rcx, rcx
jz loc_6A8D2
mov edx, [r14+8]
mov r8d, [r15+8]
xor r12d, r12d
mov rdi, [rbp+var_58]
xor r9d, r9d
call ha_compare_text
mov ebx, eax
test eax, eax
jnz short loc_6A80E
movsd xmm0, qword ptr [r14+10h]
subsd xmm0, qword ptr [r15+10h]
andpd xmm0, cs:xmmword_D90C0
ucomisd xmm0, cs:qword_E0FC0
setnbe r12b
loc_6A80E:
test ebx, ebx
js short loc_6A817
test r12b, r12b
jz short loc_6A845
loc_6A817:
mov r13, [rbp+var_50]
mov rdi, r13
lea rsi, [rbp+var_78]
mov edx, [rbp+var_34]
mov rcx, [rbp+var_40]
mov r8, r14
mov r9, [rbp+var_48]
call _ma_ft_make_key
mov rdi, r13
lea rsi, [rbp+var_78]
call _ma_ck_delete
test al, al
jnz short loc_6A8C3
loc_6A845:
test ebx, ebx
setnle al
or al, r12b
test al, 1
mov r12d, [rbp+var_34]
mov r13, [rbp+var_50]
jz short loc_6A887
mov rdi, r13
lea rsi, [rbp+var_78]
mov edx, r12d
mov rcx, [rbp+var_40]
mov r8, r15
mov r9, [rbp+var_48]
call _ma_ft_make_key
mov rdi, r13
lea rsi, [rbp+var_78]
call _ma_ck_write
test al, al
jnz loc_6A90C
loc_6A887:
lea rax, [r14+18h]
lea rcx, [r15+18h]
test ebx, ebx
cmovle r14, rax
cmovns r15, rcx
mov rsi, [r14]
test rsi, rsi
jnz loc_6A7C5
loc_6A8A5:
cmp qword ptr [r15], 0
jz short loc_6A8CE
mov rdi, r13
mov esi, r12d
mov rdx, [rbp+var_40]
mov rcx, r15
mov r8, [rbp+var_48]
call _ma_ft_store
jmp short loc_6A8E8
loc_6A8C3:
mov r15, [rbp+var_30]
loc_6A8C7:
mov ebx, 0FFFFFFFFh
jmp short loc_6A8EE
loc_6A8CE:
xor ebx, ebx
jmp short loc_6A8EA
loc_6A8D2:
mov rdi, r13
mov esi, r12d
mov rdx, [rbp+var_40]
mov rcx, r14
mov r8, [rbp+var_48]
call _ma_ft_erase
loc_6A8E8:
mov ebx, eax
loc_6A8EA:
mov r15, [rbp+var_30]
loc_6A8EE:
mov esi, 2
mov rdi, r15
call free_root
mov eax, ebx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6A90C:
movsx ebx, al
jmp short loc_6A8EA
| long long ma_ft_update(_QWORD *a1, unsigned int a2, long long a3, long long a4, long long a5, long long a6)
{
unsigned int v7; // r12d
long long v8; // r13
_QWORD *v9; // r15
double *v10; // rax
double *v11; // r14
double *v12; // rax
double *v13; // r15
double v14; // rsi
bool v15; // r12
int v16; // ebx
_QWORD **v17; // r13
bool v18; // zf
char v19; // al
unsigned int v20; // eax
unsigned int v21; // ebx
long long v23[4]; // [rsp+8h] [rbp-78h] BYREF
long long v24; // [rsp+28h] [rbp-58h]
_QWORD **v25; // [rsp+30h] [rbp-50h]
long long v26; // [rsp+38h] [rbp-48h]
long long v27; // [rsp+40h] [rbp-40h]
unsigned int v28; // [rsp+4Ch] [rbp-34h]
_QWORD *v29; // [rsp+50h] [rbp-30h]
v26 = a6;
v27 = a3;
v7 = a2;
v8 = (long long)a1;
v24 = **(_QWORD **)(*(_QWORD *)(*a1 + 1392LL) + 280LL * a2 + 192);
v9 = a1 + 101;
v10 = (double *)ma_ft_parserecord(a1, a2, a4, (long long)(a1 + 101));
if ( !v10 )
goto LABEL_21;
v11 = v10;
v29 = a1 + 101;
v12 = (double *)ma_ft_parserecord(a1, a2, a5, (long long)(a1 + 101));
if ( !v12 )
{
LABEL_20:
v9 = v29;
LABEL_21:
v21 = -1;
goto LABEL_26;
}
v13 = v12;
v14 = *v11;
if ( *(_QWORD *)v11 )
{
v28 = v7;
v25 = (_QWORD **)a1;
while ( 1 )
{
if ( !*(_QWORD *)v13 )
{
v20 = ma_ft_erase(v8, v7, v27, v11, v26);
goto LABEL_24;
}
v15 = 0;
v16 = ha_compare_text(
v24,
*(_QWORD *)&v14,
*((unsigned int *)v11 + 2),
*(_QWORD *)v13,
*((unsigned int *)v13 + 2),
0LL);
if ( !v16 )
v15 = fabs(v11[2] - v13[2]) > 0.00001;
if ( v16 < 0 || v15 )
{
v17 = v25;
ma_ft_make_key(v25, v23, v28, v27, v11, v26);
if ( ma_ck_delete(v17, v23) )
goto LABEL_20;
}
v18 = !v15 && v16 <= 0;
v7 = v28;
v8 = (long long)v25;
if ( !v18 )
{
ma_ft_make_key(v25, v23, v28, v27, v13, v26);
v19 = ma_ck_write(v8, (long long)v23);
if ( v19 )
break;
}
if ( v16 <= 0 )
v11 += 3;
if ( v16 >= 0 )
v13 += 3;
v14 = *v11;
if ( !*(_QWORD *)v11 )
goto LABEL_18;
}
v21 = v19;
}
else
{
LABEL_18:
if ( *(_QWORD *)v13 )
{
v20 = ma_ft_store(v8, v7, v27, v13, v26);
LABEL_24:
v21 = v20;
}
else
{
v21 = 0;
}
}
v9 = v29;
LABEL_26:
free_root(v9, 2LL);
return v21;
}
| _ma_ft_update:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x48],R9
MOV RBX,R8
MOV qword ptr [RBP + -0x40],RDX
MOV R12D,ESI
MOV R13,RDI
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x570]
MOV EDX,ESI
IMUL RDX,RDX,0x118
MOV RAX,qword ptr [RAX + RDX*0x1 + 0xc0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
LEA R15,[RDI + 0x328]
MOV RDX,RCX
MOV RCX,R15
CALL 0x0016a5c4
TEST RAX,RAX
JZ 0x0016a8c7
MOV R14,RAX
MOV RDI,R13
MOV ESI,R12D
MOV RDX,RBX
MOV qword ptr [RBP + -0x30],R15
MOV RCX,R15
CALL 0x0016a5c4
TEST RAX,RAX
JZ 0x0016a8c3
MOV R15,RAX
MOV RSI,qword ptr [R14]
TEST RSI,RSI
JZ 0x0016a8a5
MOV dword ptr [RBP + -0x34],R12D
MOV qword ptr [RBP + -0x50],R13
LAB_0016a7c5:
MOV RCX,qword ptr [R15]
TEST RCX,RCX
JZ 0x0016a8d2
MOV EDX,dword ptr [R14 + 0x8]
MOV R8D,dword ptr [R15 + 0x8]
XOR R12D,R12D
MOV RDI,qword ptr [RBP + -0x58]
XOR R9D,R9D
CALL 0x0019e800
MOV EBX,EAX
TEST EAX,EAX
JNZ 0x0016a80e
MOVSD XMM0,qword ptr [R14 + 0x10]
SUBSD XMM0,qword ptr [R15 + 0x10]
ANDPD XMM0,xmmword ptr [0x001d90c0]
UCOMISD XMM0,qword ptr [0x001e0fc0]
SETA R12B
LAB_0016a80e:
TEST EBX,EBX
JS 0x0016a817
TEST R12B,R12B
JZ 0x0016a845
LAB_0016a817:
MOV R13,qword ptr [RBP + -0x50]
MOV RDI,R13
LEA RSI,[RBP + -0x78]
MOV EDX,dword ptr [RBP + -0x34]
MOV RCX,qword ptr [RBP + -0x40]
MOV R8,R14
MOV R9,qword ptr [RBP + -0x48]
CALL 0x0016a911
MOV RDI,R13
LEA RSI,[RBP + -0x78]
CALL 0x0016752d
TEST AL,AL
JNZ 0x0016a8c3
LAB_0016a845:
TEST EBX,EBX
SETG AL
OR AL,R12B
TEST AL,0x1
MOV R12D,dword ptr [RBP + -0x34]
MOV R13,qword ptr [RBP + -0x50]
JZ 0x0016a887
MOV RDI,R13
LEA RSI,[RBP + -0x78]
MOV EDX,R12D
MOV RCX,qword ptr [RBP + -0x40]
MOV R8,R15
MOV R9,qword ptr [RBP + -0x48]
CALL 0x0016a911
MOV RDI,R13
LEA RSI,[RBP + -0x78]
CALL 0x00164830
TEST AL,AL
JNZ 0x0016a90c
LAB_0016a887:
LEA RAX,[R14 + 0x18]
LEA RCX,[R15 + 0x18]
TEST EBX,EBX
CMOVLE R14,RAX
CMOVNS R15,RCX
MOV RSI,qword ptr [R14]
TEST RSI,RSI
JNZ 0x0016a7c5
LAB_0016a8a5:
CMP qword ptr [R15],0x0
JZ 0x0016a8ce
MOV RDI,R13
MOV ESI,R12D
MOV RDX,qword ptr [RBP + -0x40]
MOV RCX,R15
MOV R8,qword ptr [RBP + -0x48]
CALL 0x0016aa3e
JMP 0x0016a8e8
LAB_0016a8c3:
MOV R15,qword ptr [RBP + -0x30]
LAB_0016a8c7:
MOV EBX,0xffffffff
JMP 0x0016a8ee
LAB_0016a8ce:
XOR EBX,EBX
JMP 0x0016a8ea
LAB_0016a8d2:
MOV RDI,R13
MOV ESI,R12D
MOV RDX,qword ptr [RBP + -0x40]
MOV RCX,R14
MOV R8,qword ptr [RBP + -0x48]
CALL 0x0016a9bf
LAB_0016a8e8:
MOV EBX,EAX
LAB_0016a8ea:
MOV R15,qword ptr [RBP + -0x30]
LAB_0016a8ee:
MOV ESI,0x2
MOV RDI,R15
CALL 0x0019cf13
MOV EAX,EBX
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016a90c:
MOVSX EBX,AL
JMP 0x0016a8ea
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int _ma_ft_update(long *param_1,ulong param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6)
{
long lVar1;
bool bVar2;
uint uVar3;
uint uVar4;
long *plVar5;
char cVar6;
int iVar7;
long *plVar8;
long *plVar9;
ulong uVar10;
long *plVar11;
int1 local_80 [32];
int8 local_60;
long *local_58;
int8 local_50;
int8 local_48;
uint local_3c;
long *local_38;
uVar10 = param_2 & 0xffffffff;
local_60 = **(int8 **)(*(long *)(*param_1 + 0x570) + 0xc0 + (param_2 & 0xffffffff) * 0x118);
plVar11 = param_1 + 0x65;
local_50 = param_6;
local_48 = param_3;
plVar8 = (long *)_ma_ft_parserecord(param_1,param_2,param_4,plVar11);
if ((plVar8 == (long *)0x0) ||
(local_38 = plVar11, plVar9 = (long *)_ma_ft_parserecord(param_1,uVar10,param_5,plVar11),
plVar11 = local_38, plVar9 == (long *)0x0)) {
LAB_0016a8c7:
iVar7 = -1;
}
else {
lVar1 = *plVar8;
uVar4 = (uint)param_2;
plVar5 = param_1;
plVar11 = local_58;
uVar3 = local_3c;
while (local_58 = plVar5, local_3c = uVar4, lVar1 != 0) {
if (*plVar9 == 0) {
iVar7 = _ma_ft_erase(param_1,uVar10,local_48,plVar8,local_50);
plVar11 = local_38;
goto LAB_0016a8ee;
}
bVar2 = false;
iVar7 = ha_compare_text(local_60,lVar1,(int)plVar8[1],*plVar9,(int)plVar9[1],0);
plVar11 = local_58;
if (iVar7 == 0) {
bVar2 = _DAT_001e0fc0 <
(double)((ulong)((double)plVar8[2] - (double)plVar9[2]) & _DAT_001d90c0);
}
if ((iVar7 < 0) || (bVar2)) {
_ma_ft_make_key(local_58,local_80,local_3c,local_48,plVar8);
cVar6 = _ma_ck_delete(plVar11,local_80);
plVar11 = local_38;
if (cVar6 != '\0') goto LAB_0016a8c7;
}
param_1 = local_58;
uVar10 = (ulong)local_3c;
if (0 < iVar7 || bVar2) {
_ma_ft_make_key(local_58,local_80,uVar10,local_48,plVar9);
cVar6 = _ma_ck_write(param_1,local_80);
if (cVar6 != '\0') {
iVar7 = (int)cVar6;
plVar11 = local_38;
goto LAB_0016a8ee;
}
}
if (iVar7 < 1) {
plVar8 = plVar8 + 3;
}
if (-1 < iVar7) {
plVar9 = plVar9 + 3;
}
uVar4 = local_3c;
plVar5 = local_58;
plVar11 = local_58;
uVar3 = local_3c;
lVar1 = *plVar8;
}
local_58 = plVar11;
local_3c = uVar3;
if (*plVar9 == 0) {
iVar7 = 0;
plVar11 = local_38;
}
else {
iVar7 = _ma_ft_store(param_1,uVar10,local_48,plVar9,local_50);
plVar11 = local_38;
}
}
LAB_0016a8ee:
free_root(plVar11,2);
return iVar7;
}
| |
42,880 | maria_flush_log_for_page | eloqsql/storage/maria/ma_pagecrc.c | my_bool maria_flush_log_for_page(PAGECACHE_IO_HOOK_ARGS *args)
{
LSN lsn;
uchar *page= args->page;
MARIA_SHARE *share= (MARIA_SHARE *)args->data;
DBUG_ENTER("maria_flush_log_for_page");
/* share is 0 here only in unittest */
DBUG_ASSERT(!share || share->page_type == PAGECACHE_LSN_PAGE);
lsn= lsn_korr(page);
if (translog_flush(lsn))
DBUG_RETURN(1);
/*
Now when log is written, it's safe to incremented 'open' counter for
the table so that we know it was not closed properly.
*/
if (share && !share->global_changed)
_ma_mark_file_changed_now(share);
DBUG_RETURN(0);
} | O3 | c | maria_flush_log_for_page:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x10(%rdi), %rbx
movzwl (%rax), %ecx
shlq $0x20, %rcx
movzbl 0x2(%rax), %edx
shlq $0x30, %rdx
orq %rcx, %rdx
movl 0x3(%rax), %edi
orq %rdx, %rdi
callq 0x4cd3b
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x501e5
testq %rbx, %rbx
je 0x501e3
cmpb $0x0, 0x7df(%rbx)
jne 0x501e3
movq %rbx, %rdi
callq 0x37ac7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| maria_flush_log_for_page:
push rbp
mov rbp, rsp
push rbx
push rax
mov rax, [rdi]
mov rbx, [rdi+10h]
movzx ecx, word ptr [rax]
shl rcx, 20h
movzx edx, byte ptr [rax+2]
shl rdx, 30h
or rdx, rcx
mov edi, [rax+3]
or rdi, rdx
call translog_flush
mov ecx, eax
mov al, 1
test cl, cl
jnz short loc_501E5
test rbx, rbx
jz short loc_501E3
cmp byte ptr [rbx+7DFh], 0
jnz short loc_501E3
mov rdi, rbx
call _ma_mark_file_changed_now
loc_501E3:
xor eax, eax
loc_501E5:
add rsp, 8
pop rbx
pop rbp
retn
| char maria_flush_log_for_page(unsigned __int16 **a1)
{
long long v1; // rbx
char v2; // cl
char result; // al
v1 = (long long)a1[2];
v2 = translog_flush(((unsigned long long)**a1 << 32) | ((unsigned long long)*((unsigned __int8 *)*a1 + 2) << 48) | *(unsigned int *)((char *)*a1 + 3));
result = 1;
if ( !v2 )
{
if ( v1 )
{
if ( !*(_BYTE *)(v1 + 2015) )
ma_mark_file_changed_now(v1);
}
return 0;
}
return result;
}
| maria_flush_log_for_page:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RDI]
MOV RBX,qword ptr [RDI + 0x10]
MOVZX ECX,word ptr [RAX]
SHL RCX,0x20
MOVZX EDX,byte ptr [RAX + 0x2]
SHL RDX,0x30
OR RDX,RCX
MOV EDI,dword ptr [RAX + 0x3]
OR RDI,RDX
CALL 0x0014cd3b
MOV ECX,EAX
MOV AL,0x1
TEST CL,CL
JNZ 0x001501e5
TEST RBX,RBX
JZ 0x001501e3
CMP byte ptr [RBX + 0x7df],0x0
JNZ 0x001501e3
MOV RDI,RBX
CALL 0x00137ac7
LAB_001501e3:
XOR EAX,EAX
LAB_001501e5:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int8 maria_flush_log_for_page(int8 *param_1)
{
ushort *puVar1;
long lVar2;
char cVar3;
int8 uVar4;
puVar1 = (ushort *)*param_1;
lVar2 = param_1[2];
cVar3 = translog_flush((ulong)*(uint *)((long)puVar1 + 3) |
(ulong)(byte)puVar1[1] << 0x30 | (ulong)*puVar1 << 0x20);
uVar4 = 1;
if (cVar3 == '\0') {
if ((lVar2 != 0) && (*(char *)(lVar2 + 0x7df) == '\0')) {
_ma_mark_file_changed_now(lVar2);
}
uVar4 = 0;
}
return uVar4;
}
| |
42,881 | remove_reader | eloqsql/mysys/mf_keycache.c | static void remove_reader(BLOCK_LINK *block)
{
DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
DBUG_ASSERT(block->hash_link && block->hash_link->block == block);
DBUG_ASSERT(block->prev_changed && *block->prev_changed == block);
DBUG_ASSERT(!block->next_used);
DBUG_ASSERT(!block->prev_used);
DBUG_ASSERT(block->hash_link->requests);
if (! --block->hash_link->requests && block->condvar)
keycache_pthread_cond_signal(block->condvar);
} | O0 | c | remove_reader:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0xebd1e
jmp 0xebd20
jmp 0xebd22
jmp 0xebd24
jmp 0xebd26
jmp 0xebd28
jmp 0xebd2a
jmp 0xebd2c
jmp 0xebd2e
jmp 0xebd30
jmp 0xebd32
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movl 0x28(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x28(%rcx)
cmpl $0x0, %eax
jne 0xebd60
movq -0x8(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0xebd60
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0xed130
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| remove_reader_0:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
jmp short $+2
loc_EBD1E:
jmp short $+2
loc_EBD20:
jmp short $+2
loc_EBD22:
jmp short $+2
loc_EBD24:
jmp short $+2
loc_EBD26:
jmp short $+2
loc_EBD28:
jmp short $+2
loc_EBD2A:
jmp short $+2
loc_EBD2C:
jmp short $+2
loc_EBD2E:
jmp short $+2
loc_EBD30:
jmp short $+2
loc_EBD32:
mov rax, [rbp+var_8]
mov rcx, [rax+20h]
mov eax, [rcx+28h]
add eax, 0FFFFFFFFh
mov [rcx+28h], eax
cmp eax, 0
jnz short loc_EBD60
mov rax, [rbp+var_8]
cmp qword ptr [rax+68h], 0
jz short loc_EBD60
mov rax, [rbp+var_8]
mov rdi, [rax+68h]
call inline_mysql_cond_signal_2
loc_EBD60:
add rsp, 10h
pop rbp
retn
| long long remove_reader_0(long long a1)
{
long long v1; // rcx
long long result; // rax
v1 = *(_QWORD *)(a1 + 32);
result = (unsigned int)(*(_DWORD *)(v1 + 40) - 1);
*(_DWORD *)(v1 + 40) = result;
if ( !(_DWORD)result )
{
result = a1;
if ( *(_QWORD *)(a1 + 104) )
return inline_mysql_cond_signal_2(*(_QWORD *)(a1 + 104));
}
return result;
}
| remove_reader:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
JMP 0x001ebd1e
LAB_001ebd1e:
JMP 0x001ebd20
LAB_001ebd20:
JMP 0x001ebd22
LAB_001ebd22:
JMP 0x001ebd24
LAB_001ebd24:
JMP 0x001ebd26
LAB_001ebd26:
JMP 0x001ebd28
LAB_001ebd28:
JMP 0x001ebd2a
LAB_001ebd2a:
JMP 0x001ebd2c
LAB_001ebd2c:
JMP 0x001ebd2e
LAB_001ebd2e:
JMP 0x001ebd30
LAB_001ebd30:
JMP 0x001ebd32
LAB_001ebd32:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x20]
MOV EAX,dword ptr [RCX + 0x28]
ADD EAX,-0x1
MOV dword ptr [RCX + 0x28],EAX
CMP EAX,0x0
JNZ 0x001ebd60
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x68],0x0
JZ 0x001ebd60
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x68]
CALL 0x001ed130
LAB_001ebd60:
ADD RSP,0x10
POP RBP
RET
|
void remove_reader(long param_1)
{
int iVar1;
iVar1 = *(int *)(*(long *)(param_1 + 0x20) + 0x28) + -1;
*(int *)(*(long *)(param_1 + 0x20) + 0x28) = iVar1;
if ((iVar1 == 0) && (*(long *)(param_1 + 0x68) != 0)) {
inline_mysql_cond_signal(*(int8 *)(param_1 + 0x68));
}
return;
}
| |
42,882 | compare_record(TABLE*, Field**) | eloqsql/sql/sql_select.cc | static bool compare_record(TABLE *table, Field **ptr)
{
for (; *ptr ; ptr++)
{
Field *f= *ptr;
if (f->is_null() != f->is_null(table->s->rec_buff_length) ||
(!f->is_null() && f->cmp_offset(table->s->rec_buff_length)))
return 1;
}
return 0;
} | O0 | cpp | compare_record(TABLE*, Field**):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x97bf10
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7ecb10
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x39c(%rax), %eax
movl %eax, %esi
callq 0x7ecb10
movb %al, %cl
movl -0x24(%rbp), %eax
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x97bef7
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7ecb10
testb $0x1, %al
jne 0x97befd
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x39c(%rax), %eax
movl %eax, %esi
movq (%rdi), %rax
callq *0x200(%rax)
cmpl $0x0, %eax
je 0x97befd
movb $0x1, -0x1(%rbp)
jmp 0x97bf14
jmp 0x97beff
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x97be70
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
| _ZL14compare_recordP5TABLEPP5Field:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
loc_97BE70:
mov rax, [rbp+var_18]
cmp qword ptr [rax], 0
jz loc_97BF10
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_20], rax
mov rdi, [rbp+var_20]; this
xor eax, eax
mov esi, eax; __int64
call _ZNK5Field7is_nullEx; Field::is_null(long long)
and al, 1
movzx eax, al
mov [rbp+var_24], eax
mov rdi, [rbp+var_20]; this
mov rax, [rbp+var_10]
mov rax, [rax]
mov eax, [rax+39Ch]
mov esi, eax; __int64
call _ZNK5Field7is_nullEx; Field::is_null(long long)
mov cl, al
mov eax, [rbp+var_24]
and cl, 1
movzx ecx, cl
cmp eax, ecx
jnz short loc_97BEF7
mov rdi, [rbp+var_20]; this
xor eax, eax
mov esi, eax; __int64
call _ZNK5Field7is_nullEx; Field::is_null(long long)
test al, 1
jnz short loc_97BEFD
mov rdi, [rbp+var_20]
mov rax, [rbp+var_10]
mov rax, [rax]
mov eax, [rax+39Ch]
mov esi, eax
mov rax, [rdi]
call qword ptr [rax+200h]
cmp eax, 0
jz short loc_97BEFD
loc_97BEF7:
mov [rbp+var_1], 1
jmp short loc_97BF14
loc_97BEFD:
jmp short $+2
loc_97BEFF:
mov rax, [rbp+var_18]
add rax, 8
mov [rbp+var_18], rax
jmp loc_97BE70
loc_97BF10:
mov [rbp+var_1], 0
loc_97BF14:
mov al, [rbp+var_1]
and al, 1
add rsp, 30h
pop rbp
retn
| char compare_record(TABLE *a1, Field **a2)
{
BOOL is_null; // [rsp+Ch] [rbp-24h]
Field *v4; // [rsp+10h] [rbp-20h]
while ( *a2 )
{
v4 = *a2;
is_null = Field::is_null(*a2, 0LL);
if ( is_null != Field::is_null(v4, *(unsigned int *)(*(_QWORD *)a1 + 924LL))
|| !Field::is_null(v4, 0LL)
&& (*(unsigned int ( **)(Field *, _QWORD))(*(_QWORD *)v4 + 512LL))(
v4,
*(unsigned int *)(*(_QWORD *)a1 + 924LL)) )
{
return 1;
}
++a2;
}
return 0;
}
| ~Query_cache_wait_state:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RAX],0x0
JZ 0x0097bea1
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,RAX
ADD RSI,0x8
MOV RDI,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x20]
MOV R8,qword ptr [RAX + 0x28]
MOV R9D,dword ptr [RAX + 0x30]
LAB_0097be94:
XOR EAX,EAX
MOV EDX,EAX
CALL 0x0097ce70
JMP 0x0097be9f
LAB_0097be9f:
JMP 0x0097bea1
LAB_0097bea1:
ADD RSP,0x10
POP RBP
RET
|
/* Query_cache_wait_state::~Query_cache_wait_state() */
void __thiscall Query_cache_wait_state::~Query_cache_wait_state(Query_cache_wait_state *this)
{
if (*(long *)this != 0) {
/* try { // try from 0097be94 to 0097be9c has its CatchHandler @ 0097bea7 */
set_thd_stage_info(*(int8 *)this,this + 8,0,*(int8 *)(this + 0x20),
*(int8 *)(this + 0x28),*(int4 *)(this + 0x30));
}
return;
}
| |
42,883 | get_charset_number_internal | eloqsql/mysys/charset.c | static uint
get_charset_number_internal(const char *charset_name, uint cs_flags)
{
CHARSET_INFO **cs;
for (cs= all_charsets;
cs < all_charsets + array_elements(all_charsets);
cs++)
{
if ( cs[0] && cs[0]->cs_name.str && (cs[0]->state & cs_flags) &&
!my_strcasecmp(&my_charset_latin1, cs[0]->cs_name.str, charset_name))
return cs[0]->number;
}
return 0;
} | O0 | c | get_charset_number_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq 0x37f02a(%rip), %rax # 0x3f12a0
movq %rax, -0x20(%rbp)
leaq 0x37f01f(%rip), %rax # 0x3f12a0
addq $0x4000, %rax # imm = 0x4000
cmpq %rax, -0x20(%rbp)
jae 0x72307
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x722f4
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x722f4
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0xc(%rax), %eax
andl -0x14(%rbp), %eax
cmpl $0x0, %eax
je 0x722f4
leaq 0x26bfc2(%rip), %rax # 0x2de280
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movq 0x10(%rcx), %rsi
movq -0x10(%rbp), %rdx
leaq 0x26bfa1(%rip), %rdi # 0x2de280
callq *%rax
cmpl $0x0, %eax
jne 0x722f4
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x7230e
jmp 0x722f6
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0x7227a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| get_charset_number_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
lea rax, all_charsets
mov [rbp+var_20], rax
loc_7227A:
lea rax, all_charsets
add rax, 4000h
cmp [rbp+var_20], rax
jnb short loc_72307
mov rax, [rbp+var_20]
cmp qword ptr [rax], 0
jz short loc_722F4
mov rax, [rbp+var_20]
mov rax, [rax]
cmp qword ptr [rax+10h], 0
jz short loc_722F4
mov rax, [rbp+var_20]
mov rax, [rax]
mov eax, [rax+0Ch]
and eax, [rbp+var_14]
cmp eax, 0
jz short loc_722F4
lea rax, my_charset_latin1
mov rax, [rax+0C0h]
mov rax, [rax+40h]
mov rcx, [rbp+var_20]
mov rcx, [rcx]
mov rsi, [rcx+10h]
mov rdx, [rbp+var_10]
lea rdi, my_charset_latin1
call rax
cmp eax, 0
jnz short loc_722F4
mov rax, [rbp+var_20]
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_4], eax
jmp short loc_7230E
loc_722F4:
jmp short $+2
loc_722F6:
mov rax, [rbp+var_20]
add rax, 8
mov [rbp+var_20], rax
jmp loc_7227A
loc_72307:
mov [rbp+var_4], 0
loc_7230E:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long get_charset_number_internal(long long a1, int a2)
{
unsigned int **i; // [rsp+0h] [rbp-20h]
for ( i = (unsigned int **)all_charsets; i < &all_charsets[2048]; ++i )
{
if ( *i
&& *((_QWORD *)*i + 2)
&& (a2 & (*i)[3]) != 0
&& !(*(unsigned int ( **)(void *, _QWORD, long long))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
*((_QWORD *)*i + 2),
a1) )
{
return **i;
}
}
return 0;
}
| get_charset_number_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
LEA RAX,[0x4f12a0]
MOV qword ptr [RBP + -0x20],RAX
LAB_0017227a:
LEA RAX,[0x4f12a0]
ADD RAX,0x4000
CMP qword ptr [RBP + -0x20],RAX
JNC 0x00172307
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX],0x0
JZ 0x001722f4
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
CMP qword ptr [RAX + 0x10],0x0
JZ 0x001722f4
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0xc]
AND EAX,dword ptr [RBP + -0x14]
CMP EAX,0x0
JZ 0x001722f4
LEA RAX,[0x3de280]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RCX]
MOV RSI,qword ptr [RCX + 0x10]
MOV RDX,qword ptr [RBP + -0x10]
LEA RDI,[0x3de280]
CALL RAX
CMP EAX,0x0
JNZ 0x001722f4
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0017230e
LAB_001722f4:
JMP 0x001722f6
LAB_001722f6:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x8
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0017227a
LAB_00172307:
MOV dword ptr [RBP + -0x4],0x0
LAB_0017230e:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 get_charset_number_internal(int8 param_1,uint param_2)
{
int iVar1;
long *local_28;
local_28 = &all_charsets;
while( true ) {
if ((long *)0x4f529f < local_28) {
return 0;
}
if ((((*local_28 != 0) && (*(long *)(*local_28 + 0x10) != 0)) &&
((*(uint *)(*local_28 + 0xc) & param_2) != 0)) &&
(iVar1 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_003de340 + 0x40))
(&my_charset_latin1,*(int8 *)(*local_28 + 0x10),param_1), iVar1 == 0
)) break;
local_28 = local_28 + 1;
}
return *(int4 *)*local_28;
}
| |
42,884 | mujoco::plugin::sdf::Nut::RegisterPlugin() | aimrt_mujoco_sim/_deps/mujoco-src/plugin/sdf/nut.cc | void Nut::RegisterPlugin() {
mjpPlugin plugin;
mjp_defaultPlugin(&plugin);
plugin.name = "mujoco.sdf.nut";
plugin.capabilityflags |= mjPLUGIN_SDF;
plugin.nattribute = NutAttribute::nattribute;
plugin.attributes = NutAttribute::names;
plugin.nstate = +[](const mjModel* m, int instance) { return 0; };
plugin.init = +[](const mjModel* m, mjData* d, int instance) {
auto sdf_or_null = Nut::Create(m, d, instance);
if (!sdf_or_null.has_value()) {
return -1;
}
d->plugin_data[instance] = reinterpret_cast<uintptr_t>(
new Nut(std::move(*sdf_or_null)));
return 0;
};
plugin.destroy = +[](mjData* d, int instance) {
delete reinterpret_cast<Nut*>(d->plugin_data[instance]);
d->plugin_data[instance] = 0;
};
plugin.reset = +[](const mjModel* m, double* plugin_state, void* plugin_data,
int instance) {
auto sdf = reinterpret_cast<Nut*>(plugin_data);
sdf->Reset();
};
plugin.visualize = +[](const mjModel* m, mjData* d, const mjvOption* opt,
mjvScene* scn, int instance) {
auto* sdf = reinterpret_cast<Nut*>(d->plugin_data[instance]);
sdf->Visualize(m, d, opt, scn, instance);
};
plugin.compute =
+[](const mjModel* m, mjData* d, int instance, int capability_bit) {
auto* sdf = reinterpret_cast<Nut*>(d->plugin_data[instance]);
sdf->Compute(m, d, instance);
};
plugin.sdf_distance =
+[](const mjtNum point[3], const mjData* d, int instance) {
auto* sdf = reinterpret_cast<Nut*>(d->plugin_data[instance]);
return sdf->Distance(point);
};
plugin.sdf_gradient = +[](mjtNum gradient[3], const mjtNum point[3],
const mjData* d, int instance) {
auto* sdf = reinterpret_cast<Nut*>(d->plugin_data[instance]);
sdf->visualizer_.AddPoint(point);
sdf->Gradient(gradient, point);
};
plugin.sdf_staticdistance =
+[](const mjtNum point[3], const mjtNum* attributes) {
return distance(point, attributes);
};
plugin.sdf_aabb =
+[](mjtNum aabb[6], const mjtNum* attributes) {
aabb[0] = aabb[1] = aabb[2] = 0;
aabb[3] = aabb[4] = .6;
aabb[5] = 1;
};
plugin.sdf_attribute =
+[](mjtNum attribute[], const char* name[], const char* value[]) {
SdfDefault<NutAttribute> defattribute;
defattribute.GetDefaults(attribute, name, value);
};
mjp_registerPlugin(&plugin);
} | O0 | cpp | mujoco::plugin::sdf::Nut::RegisterPlugin():
subq $0xb8, %rsp
leaq 0x18(%rsp), %rdi
callq 0x1a330
leaq 0xeb931(%rip), %rax # 0x112529
movq %rax, 0x18(%rsp)
movl 0x30(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x30(%rsp)
movl $0x1, 0x20(%rsp)
leaq 0x1324e1(%rip), %rax # 0x1590f8
movq %rax, 0x28(%rsp)
leaq 0x17(%rsp), %rdi
callq 0x26cf0
movq %rax, 0x38(%rsp)
leaq 0x16(%rsp), %rdi
callq 0x26d00
movq %rax, 0x48(%rsp)
leaq 0x15(%rsp), %rdi
callq 0x26d10
movq %rax, 0x50(%rsp)
leaq 0x14(%rsp), %rdi
callq 0x26d20
movq %rax, 0x60(%rsp)
leaq 0x13(%rsp), %rdi
callq 0x26d30
movq %rax, 0x78(%rsp)
leaq 0x12(%rsp), %rdi
callq 0x26d40
movq %rax, 0x68(%rsp)
leaq 0x11(%rsp), %rdi
callq 0x26d50
movq %rax, 0x90(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x26d60
movq %rax, 0x98(%rsp)
leaq 0xf(%rsp), %rdi
callq 0x26d70
movq %rax, 0xa0(%rsp)
leaq 0xe(%rsp), %rdi
callq 0x26d80
movq %rax, 0xb0(%rsp)
leaq 0xd(%rsp), %rdi
callq 0x26d90
movq %rax, 0xa8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x1a340
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZN6mujoco6plugin3sdf3Nut14RegisterPluginEv:
sub rsp, 0B8h
lea rdi, [rsp+0B8h+var_A0]
call _mjp_defaultPlugin
lea rax, aMujocoSdfNut; "mujoco.sdf.nut"
mov [rsp+0B8h+var_A0], rax
mov eax, [rsp+0B8h+var_88]
or eax, 8
mov [rsp+0B8h+var_88], eax
mov [rsp+0B8h+var_98], 1
lea rax, _ZN6mujoco6plugin3sdf12NutAttribute5namesE; mujoco::plugin::sdf::NutAttribute::names
mov [rsp+0B8h+var_90], rax
lea rdi, [rsp+0B8h+var_A1]
call _ZZN6mujoco6plugin3sdf3Nut14RegisterPluginEvENK3$_0cvPFiPK8mjModel_iEEv; mujoco::plugin::sdf::Nut::RegisterPlugin(void)::$_0::operator int (*)(mjModel_ const*,int)(void)
mov [rsp+0B8h+var_80], rax
lea rdi, [rsp+0B8h+var_A2]
call _ZZN6mujoco6plugin3sdf3Nut14RegisterPluginEvENK3$_1cvPFiPK8mjModel_P7mjData_iEEv; mujoco::plugin::sdf::Nut::RegisterPlugin(void)::$_1::operator int (*)(mjModel_ const*,mjData_ *,int)(void)
mov [rsp+0B8h+var_70], rax
lea rdi, [rsp+0B8h+var_A3]
call _ZZN6mujoco6plugin3sdf3Nut14RegisterPluginEvENK3$_2cvPFvP7mjData_iEEv; mujoco::plugin::sdf::Nut::RegisterPlugin(void)::$_2::operator void (*)(mjData_ *,int)(void)
mov [rsp+0B8h+var_68], rax
lea rdi, [rsp+0B8h+var_A4]
call _ZZN6mujoco6plugin3sdf3Nut14RegisterPluginEvENK3$_3cvPFvPK8mjModel_PdPviEEv; mujoco::plugin::sdf::Nut::RegisterPlugin(void)::$_3::operator void (*)(mjModel_ const*,double *,void *,int)(void)
mov [rsp+0B8h+var_58], rax
lea rdi, [rsp+0B8h+var_A5]
call _ZZN6mujoco6plugin3sdf3Nut14RegisterPluginEvENK3$_4cvPFvPK8mjModel_P7mjData_PK10mjvOption_P9mjvScene_iEEv; mujoco::plugin::sdf::Nut::RegisterPlugin(void)::$_4::operator void (*)(mjModel_ const*,mjData_ *,mjvOption_ const*,mjvScene_ *,int)(void)
mov [rsp+0B8h+var_40], rax
lea rdi, [rsp+0B8h+var_A6]
call _ZZN6mujoco6plugin3sdf3Nut14RegisterPluginEvENK3$_5cvPFvPK8mjModel_P7mjData_iiEEv; mujoco::plugin::sdf::Nut::RegisterPlugin(void)::$_5::operator void (*)(mjModel_ const*,mjData_ *,int,int)(void)
mov [rsp+0B8h+var_50], rax
lea rdi, [rsp+0B8h+var_A7]
call _ZZN6mujoco6plugin3sdf3Nut14RegisterPluginEvENK3$_6cvPFdPKdPK7mjData_iEEv; mujoco::plugin::sdf::Nut::RegisterPlugin(void)::$_6::operator double (*)(double const*,mjData_ const*,int)(void)
mov [rsp+0B8h+var_28], rax
lea rdi, [rsp+0B8h+var_A8]
call _ZZN6mujoco6plugin3sdf3Nut14RegisterPluginEvENK3$_7cvPFvPdPKdPK7mjData_iEEv; mujoco::plugin::sdf::Nut::RegisterPlugin(void)::$_7::operator void (*)(double *,double const*,mjData_ const*,int)(void)
mov [rsp+0B8h+var_20], rax
lea rdi, [rsp+0B8h+var_A9]
call _ZZN6mujoco6plugin3sdf3Nut14RegisterPluginEvENK3$_8cvPFdPKdS5_EEv; mujoco::plugin::sdf::Nut::RegisterPlugin(void)::$_8::operator double (*)(double const*,double const*)(void)
mov [rsp+0B8h+var_18], rax
lea rdi, [rsp+0B8h+var_AA]
call _ZZN6mujoco6plugin3sdf3Nut14RegisterPluginEvENK3$_9cvPFvPdPKdEEv; mujoco::plugin::sdf::Nut::RegisterPlugin(void)::$_9::operator void (*)(double *,double const*)(void)
mov [rsp+0B8h+var_8], rax
lea rdi, [rsp+0B8h+var_AB]
call _ZZN6mujoco6plugin3sdf3Nut14RegisterPluginEvENK4$_10cvPFvPdPPKcS7_EEv; mujoco::plugin::sdf::Nut::RegisterPlugin(void)::$_10::operator void (*)(double *,char const**,char const**)(void)
mov [rsp+0B8h+var_10], rax
lea rdi, [rsp+0B8h+var_A0]
call _mjp_registerPlugin
add rsp, 0B8h
retn
| long long mujoco::plugin::sdf::Nut::RegisterPlugin(mujoco::plugin::sdf::Nut *this)
{
char v2; // [rsp+Dh] [rbp-ABh] BYREF
char v3; // [rsp+Eh] [rbp-AAh] BYREF
char v4; // [rsp+Fh] [rbp-A9h] BYREF
char v5; // [rsp+10h] [rbp-A8h] BYREF
char v6; // [rsp+11h] [rbp-A7h] BYREF
char v7; // [rsp+12h] [rbp-A6h] BYREF
char v8; // [rsp+13h] [rbp-A5h] BYREF
char v9; // [rsp+14h] [rbp-A4h] BYREF
char v10; // [rsp+15h] [rbp-A3h] BYREF
char v11; // [rsp+16h] [rbp-A2h] BYREF
char v12; // [rsp+17h] [rbp-A1h] BYREF
const char *v13; // [rsp+18h] [rbp-A0h] BYREF
int v14; // [rsp+20h] [rbp-98h]
char **v15; // [rsp+28h] [rbp-90h]
int v16; // [rsp+30h] [rbp-88h]
long long v17; // [rsp+38h] [rbp-80h]
long long v18; // [rsp+48h] [rbp-70h]
long long v19; // [rsp+50h] [rbp-68h]
long long v20; // [rsp+60h] [rbp-58h]
long long v21; // [rsp+68h] [rbp-50h]
long long v22; // [rsp+78h] [rbp-40h]
long long v23; // [rsp+90h] [rbp-28h]
long long v24; // [rsp+98h] [rbp-20h]
long long v25; // [rsp+A0h] [rbp-18h]
long long v26; // [rsp+A8h] [rbp-10h]
long long v27; // [rsp+B0h] [rbp-8h]
mjp_defaultPlugin(&v13);
v13 = "mujoco.sdf.nut";
v16 |= 8u;
v14 = 1;
v15 = mujoco::plugin::sdf::NutAttribute::names;
v17 = mujoco::plugin::sdf::Nut::RegisterPlugin(void)::$_0::operator int (*)(mjModel_ const*,int)(&v12);
v18 = mujoco::plugin::sdf::Nut::RegisterPlugin(void)::$_1::operator int (*)(mjModel_ const*,mjData_ *,int)(&v11);
v19 = mujoco::plugin::sdf::Nut::RegisterPlugin(void)::$_2::operator void (*)(mjData_ *,int)(&v10);
v20 = mujoco::plugin::sdf::Nut::RegisterPlugin(void)::$_3::operator void (*)(mjModel_ const*,double *,void *,int)(&v9);
v22 = mujoco::plugin::sdf::Nut::RegisterPlugin(void)::$_4::operator void (*)(mjModel_ const*,mjData_ *,mjvOption_ const*,mjvScene_ *,int)(&v8);
v21 = mujoco::plugin::sdf::Nut::RegisterPlugin(void)::$_5::operator void (*)(mjModel_ const*,mjData_ *,int,int)(&v7);
v23 = mujoco::plugin::sdf::Nut::RegisterPlugin(void)::$_6::operator double (*)(double const*,mjData_ const*,int)(&v6);
v24 = mujoco::plugin::sdf::Nut::RegisterPlugin(void)::$_7::operator void (*)(double *,double const*,mjData_ const*,int)(&v5);
v25 = mujoco::plugin::sdf::Nut::RegisterPlugin(void)::$_8::operator double (*)(double const*,double const*)(&v4);
v27 = mujoco::plugin::sdf::Nut::RegisterPlugin(void)::$_9::operator void (*)(double *,double const*)(&v3);
v26 = mujoco::plugin::sdf::Nut::RegisterPlugin(void)::$_10::operator void (*)(double *,char const**,char const**)(&v2);
return mjp_registerPlugin(&v13);
}
| RegisterPlugin:
SUB RSP,0xb8
LEA RDI,[RSP + 0x18]
CALL 0x0011a330
LEA RAX,[0x212529]
MOV qword ptr [RSP + 0x18],RAX
MOV EAX,dword ptr [RSP + 0x30]
OR EAX,0x8
MOV dword ptr [RSP + 0x30],EAX
MOV dword ptr [RSP + 0x20],0x1
LEA RAX,[0x2590f8]
MOV qword ptr [RSP + 0x28],RAX
LEA RDI,[RSP + 0x17]
CALL 0x00126cf0
MOV qword ptr [RSP + 0x38],RAX
LEA RDI,[RSP + 0x16]
CALL 0x00126d00
MOV qword ptr [RSP + 0x48],RAX
LEA RDI,[RSP + 0x15]
CALL 0x00126d10
MOV qword ptr [RSP + 0x50],RAX
LEA RDI,[RSP + 0x14]
CALL 0x00126d20
MOV qword ptr [RSP + 0x60],RAX
LEA RDI,[RSP + 0x13]
CALL 0x00126d30
MOV qword ptr [RSP + 0x78],RAX
LEA RDI,[RSP + 0x12]
CALL 0x00126d40
MOV qword ptr [RSP + 0x68],RAX
LEA RDI,[RSP + 0x11]
CALL 0x00126d50
MOV qword ptr [RSP + 0x90],RAX
LEA RDI,[RSP + 0x10]
CALL 0x00126d60
MOV qword ptr [RSP + 0x98],RAX
LEA RDI,[RSP + 0xf]
CALL 0x00126d70
MOV qword ptr [RSP + 0xa0],RAX
LEA RDI,[RSP + 0xe]
CALL 0x00126d80
MOV qword ptr [RSP + 0xb0],RAX
LEA RDI,[RSP + 0xd]
CALL 0x00126d90
MOV qword ptr [RSP + 0xa8],RAX
LEA RDI,[RSP + 0x18]
CALL 0x0011a340
ADD RSP,0xb8
RET
|
/* mujoco::plugin::sdf::Nut::RegisterPlugin() */
void mujoco::plugin::sdf::Nut::RegisterPlugin(void)
{
__10 local_ab;
__9 local_aa;
__8 local_a9;
__7 local_a8;
__6 local_a7;
__5 local_a6;
__4 local_a5;
__3 local_a4;
__2 local_a3;
__1 local_a2;
__0 local_a1;
char *local_a0;
int4 local_98;
int **local_90;
uint local_88;
_func_int_mjModel__ptr_int *local_80;
_func_int_mjModel__ptr_mjData__ptr_int *local_70;
_func_void_mjData__ptr_int *local_68;
_func_void_mjModel__ptr_double_ptr_void_ptr_int *local_58;
_func_void_mjModel__ptr_mjData__ptr_int_int *local_50;
_func_void_mjModel__ptr_mjData__ptr_mjvOption__ptr_mjvScene__ptr_int *local_40;
_func_double_double_ptr_mjData__ptr_int *local_28;
_func_void_double_ptr_double_ptr_mjData__ptr_int *local_20;
_func_double_double_ptr_double_ptr *local_18;
_func_void_double_ptr_char_ptr_ptr_char_ptr_ptr *local_10;
_func_void_double_ptr_double_ptr *local_8;
mjp_defaultPlugin(&local_a0);
local_a0 = "mujoco.sdf.nut";
local_88 = local_88 | 8;
local_98 = 1;
local_90 = &NutAttribute::names;
local_80 = RegisterPlugin()::$_0::operator_cast_to_function_pointer(&local_a1);
local_70 = RegisterPlugin()::$_1::operator_cast_to_function_pointer(&local_a2);
local_68 = RegisterPlugin()::$_2::operator_cast_to_function_pointer(&local_a3);
local_58 = RegisterPlugin()::$_3::operator_cast_to_function_pointer(&local_a4);
local_40 = RegisterPlugin()::$_4::operator_cast_to_function_pointer(&local_a5);
local_50 = RegisterPlugin()::$_5::operator_cast_to_function_pointer(&local_a6);
local_28 = RegisterPlugin()::$_6::operator_cast_to_function_pointer(&local_a7);
local_20 = RegisterPlugin()::$_7::operator_cast_to_function_pointer(&local_a8);
local_18 = RegisterPlugin()::$_8::operator_cast_to_function_pointer(&local_a9);
local_8 = RegisterPlugin()::$_9::operator_cast_to_function_pointer(&local_aa);
local_10 = RegisterPlugin()::$_10::operator_cast_to_function_pointer(&local_ab);
mjp_registerPlugin(&local_a0);
return;
}
| |
42,885 | compiler_add_rule_entry | alca/libalca/compiler.c | uint32_t compiler_add_rule_entry(ac_compiler *compiler, ac_rule_entry *entry)
{
uint32_t idx = compiler->nrules;
if (compiler->nrules == 0)
compiler->rule_table = ac_alloc(sizeof(ac_rule_entry));
else
compiler->rule_table = ac_realloc(compiler->rule_table, (compiler->nrules + 1) * sizeof(ac_rule_entry));
memcpy(compiler->rule_table + compiler->nrules++, entry, sizeof(ac_rule_entry));
return idx;
} | O0 | c | compiler_add_rule_entry:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x24(%rax)
jne 0x1220b
movl $0x14, %edi
callq 0x7890
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
jmp 0x12235
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
imulq $0x14, %rax, %rax
movl %eax, %esi
callq 0x79b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rdx
movl 0x24(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x24(%rdx)
movl %ecx, %ecx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| compiler_add_rule_entry:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov eax, [rax+24h]
mov [rbp+var_14], eax
mov rax, [rbp+var_8]
cmp dword ptr [rax+24h], 0
jnz short loc_1220B
mov edi, 14h
call _ac_alloc
mov rcx, rax
mov rax, [rbp+var_8]
mov [rax+48h], rcx
jmp short loc_12235
loc_1220B:
mov rax, [rbp+var_8]
mov rdi, [rax+48h]
mov rax, [rbp+var_8]
mov eax, [rax+24h]
add eax, 1
mov eax, eax
imul rax, 14h
mov esi, eax
call _ac_realloc
mov rcx, rax
mov rax, [rbp+var_8]
mov [rax+48h], rcx
loc_12235:
mov rax, [rbp+var_8]
mov rax, [rax+48h]
mov rdx, [rbp+var_8]
mov ecx, [rdx+24h]
mov esi, ecx
add esi, 1
mov [rdx+24h], esi
mov ecx, ecx
imul rcx, 14h
add rax, rcx
mov rcx, [rbp+var_10]
mov rdx, [rcx]
mov [rax], rdx
mov rdx, [rcx+8]
mov [rax+8], rdx
mov ecx, [rcx+10h]
mov [rax+10h], ecx
mov eax, [rbp+var_14]
add rsp, 20h
pop rbp
retn
| long long compiler_add_rule_entry(long long a1, long long a2)
{
long long v2; // rcx
long long v3; // rax
unsigned int v4; // ecx
long long v5; // rax
unsigned int v7; // [rsp+Ch] [rbp-14h]
v7 = *(_DWORD *)(a1 + 36);
if ( v7 )
v2 = ac_realloc(*(_QWORD *)(a1 + 72), (unsigned int)(20 * (*(_DWORD *)(a1 + 36) + 1)));
else
v2 = ac_alloc(20LL);
*(_QWORD *)(a1 + 72) = v2;
v3 = *(_QWORD *)(a1 + 72);
v4 = *(_DWORD *)(a1 + 36);
*(_DWORD *)(a1 + 36) = v4 + 1;
v5 = 20LL * v4 + v3;
*(_QWORD *)v5 = *(_QWORD *)a2;
*(_QWORD *)(v5 + 8) = *(_QWORD *)(a2 + 8);
*(_DWORD *)(v5 + 16) = *(_DWORD *)(a2 + 16);
return v7;
}
| compiler_add_rule_entry:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x24]
MOV dword ptr [RBP + -0x14],EAX
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x24],0x0
JNZ 0x0011220b
MOV EDI,0x14
CALL 0x00107890
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x48],RCX
JMP 0x00112235
LAB_0011220b:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x48]
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x24]
ADD EAX,0x1
MOV EAX,EAX
IMUL RAX,RAX,0x14
MOV ESI,EAX
CALL 0x001079b0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x48],RCX
LAB_00112235:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x48]
MOV RDX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RDX + 0x24]
MOV ESI,ECX
ADD ESI,0x1
MOV dword ptr [RDX + 0x24],ESI
MOV ECX,ECX
IMUL RCX,RCX,0x14
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RDX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RDX
MOV ECX,dword ptr [RCX + 0x10]
MOV dword ptr [RAX + 0x10],ECX
MOV EAX,dword ptr [RBP + -0x14]
ADD RSP,0x20
POP RBP
RET
|
int4 compiler_add_rule_entry(long param_1,int8 *param_2)
{
int4 uVar1;
uint uVar2;
int8 uVar3;
int8 *puVar4;
uVar1 = *(int4 *)(param_1 + 0x24);
if (*(int *)(param_1 + 0x24) == 0) {
uVar3 = ac_alloc(0x14);
*(int8 *)(param_1 + 0x48) = uVar3;
}
else {
uVar3 = ac_realloc(*(int8 *)(param_1 + 0x48),(*(int *)(param_1 + 0x24) + 1) * 0x14);
*(int8 *)(param_1 + 0x48) = uVar3;
}
uVar2 = *(uint *)(param_1 + 0x24);
*(uint *)(param_1 + 0x24) = uVar2 + 1;
puVar4 = (int8 *)(*(long *)(param_1 + 0x48) + (ulong)uVar2 * 0x14);
*puVar4 = *param_2;
puVar4[1] = param_2[1];
*(int4 *)(puVar4 + 2) = *(int4 *)(param_2 + 2);
return uVar1;
}
| |
42,886 | 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;
} | O0 | c | my_copy_8bit:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x59a36
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x59a38
jmp 0x59a3a
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x59a4c
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x59a4e
cmpq $0x0, -0x28(%rbp)
je 0x59a66
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x256b0
movq -0x20(%rbp), %rcx
addq -0x28(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
movq 0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_copy_8bit:
push rbp
mov rbp, rsp
sub rsp, 30h
mov rax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_28]
cmp rax, [rbp+var_18]
jbe short loc_59A36
mov rax, [rbp+var_18]
mov [rbp+var_28], rax
loc_59A36:
jmp short $+2
loc_59A38:
jmp short $+2
loc_59A3A:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jbe short loc_59A4C
mov rax, [rbp+var_30]
mov [rbp+var_28], rax
loc_59A4C:
jmp short $+2
loc_59A4E:
cmp [rbp+var_28], 0
jz short loc_59A66
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
call _memmove
loc_59A66:
mov rcx, [rbp+var_20]
add rcx, [rbp+var_28]
mov rax, [rbp+arg_0]
mov [rax], rcx
mov rax, [rbp+arg_0]
mov qword ptr [rax+8], 0
mov rax, [rbp+var_28]
add rsp, 30h
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; // [rsp+8h] [rbp-28h]
v8 = a5;
if ( a5 > a3 )
v8 = a3;
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
SUB RSP,0x30
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x18]
JBE 0x00159a36
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x28],RAX
LAB_00159a36:
JMP 0x00159a38
LAB_00159a38:
JMP 0x00159a3a
LAB_00159a3a:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JBE 0x00159a4c
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x28],RAX
LAB_00159a4c:
JMP 0x00159a4e
LAB_00159a4e:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x00159a66
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x001256b0
LAB_00159a66:
MOV RCX,qword ptr [RBP + -0x20]
ADD RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RBP + -0x28]
ADD RSP,0x30
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)
{
ulong local_30;
local_30 = param_5;
if (param_3 < param_5) {
local_30 = param_3;
}
if (param_6 < local_30) {
local_30 = param_6;
}
if (local_30 != 0) {
memmove(param_2,param_4,local_30);
}
*param_7 = (long)param_4 + local_30;
param_7[1] = 0;
return local_30;
}
| |
42,887 | ggml_are_same_shape | ngxson[P]ggml-easy/ggml/src/ggml.c | bool ggml_are_same_shape(const struct ggml_tensor * t0, const struct ggml_tensor * t1) {
static_assert(GGML_MAX_DIMS == 4, "GGML_MAX_DIMS is not 4 - update this function");
return
(t0->ne[0] == t1->ne[0]) &&
(t0->ne[1] == t1->ne[1]) &&
(t0->ne[2] == t1->ne[2]) &&
(t0->ne[3] == t1->ne[3]);
} | O1 | c | ggml_are_same_shape:
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x19911
movq 0x18(%rdi), %rax
cmpq 0x18(%rsi), %rax
jne 0x19911
movq 0x20(%rdi), %rax
cmpq 0x20(%rsi), %rax
jne 0x19911
movq 0x28(%rdi), %rax
cmpq 0x28(%rsi), %rax
sete %al
retq
xorl %eax, %eax
retq
| ggml_are_same_shape:
mov rax, [rdi+10h]
cmp rax, [rsi+10h]
jnz short loc_19911
mov rax, [rdi+18h]
cmp rax, [rsi+18h]
jnz short loc_19911
mov rax, [rdi+20h]
cmp rax, [rsi+20h]
jnz short loc_19911
mov rax, [rdi+28h]
cmp rax, [rsi+28h]
setz al
retn
loc_19911:
xor eax, eax
retn
| bool ggml_are_same_shape(_QWORD *a1, _QWORD *a2)
{
return a1[2] == a2[2] && a1[3] == a2[3] && a1[4] == a2[4] && a1[5] == a2[5];
}
| ggml_are_same_shape:
MOV RAX,qword ptr [RDI + 0x10]
CMP RAX,qword ptr [RSI + 0x10]
JNZ 0x00119911
MOV RAX,qword ptr [RDI + 0x18]
CMP RAX,qword ptr [RSI + 0x18]
JNZ 0x00119911
MOV RAX,qword ptr [RDI + 0x20]
CMP RAX,qword ptr [RSI + 0x20]
JNZ 0x00119911
MOV RAX,qword ptr [RDI + 0x28]
CMP RAX,qword ptr [RSI + 0x28]
SETZ AL
RET
LAB_00119911:
XOR EAX,EAX
RET
|
int8 ggml_are_same_shape(long param_1,long param_2)
{
if (((*(long *)(param_1 + 0x10) == *(long *)(param_2 + 0x10)) &&
(*(long *)(param_1 + 0x18) == *(long *)(param_2 + 0x18))) &&
(*(long *)(param_1 + 0x20) == *(long *)(param_2 + 0x20))) {
return CONCAT71((int7)((ulong)*(long *)(param_1 + 0x28) >> 8),
*(long *)(param_1 + 0x28) == *(long *)(param_2 + 0x28));
}
return 0;
}
| |
42,888 | ritegAPI_has_option(lua_State*) | untodesu[P]riteg/riteg/project.cc | static int ritegAPI_has_option(lua_State *L)
{
auto option = luaL_checkstring(L, 1);
riteg_force_assert(option != nullptr);
if(cmdline::contains(option))
lua_pushboolean(L, true);
else lua_pushboolean(L, false);
return 1;
} | O1 | cpp | ritegAPI_has_option(lua_State*):
pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x31dde
testq %rax, %rax
je 0x11c3b
movq %rax, %rdi
callq 0xe05b
movzbl %al, %esi
movq %rbx, %rdi
callq 0x2ff59
movl $0x1, %eax
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x913ae(%rip), %rdi # 0xa2ff0
leaq 0x504e4(%rip), %rsi # 0x6212d
movl $0x1, %edx
callq 0xc9e0
leaq 0x50a6e(%rip), %rsi # 0x626c8
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movl $0x2, %edx
callq 0xe194
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0xe21c
movq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xe3e0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x91346(%rip), %rdi # 0xa2ff0
callq 0xc9e0
movq %rax, %rbx
leaq 0x77752(%rip), %rsi # 0x8940b
movl $0x1, %edx
movq %rax, %rdi
callq 0xc9e0
movq %rbx, %rdi
movl $0x13, %esi
callq 0xceb0
movq %rax, %rbx
leaq 0x50452(%rip), %rsi # 0x6212f
movl $0x3, %edx
movq %rax, %rdi
callq 0xc9e0
leaq 0x50442(%rip), %rsi # 0x62133
movl $0x15, %edx
movq %rbx, %rdi
callq 0xc9e0
leaq 0x50639(%rip), %rsi # 0x6233e
movl $0x12, %edx
movq %rbx, %rdi
callq 0xc9e0
leaq 0x50487(%rip), %rsi # 0x621a0
movl $0x11, %edx
movq %rbx, %rdi
callq 0xc9e0
movq %rbx, %rdi
callq 0xc3f0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x11d44
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc8d0
leaq 0x28(%rsp), %rdi
callq 0xe29a
leaq 0x90(%rsp), %rdi
callq 0xe29a
movq 0x9128e(%rip), %rdi # 0xa2ff0
leaq 0x503c4(%rip), %rsi # 0x6212d
movl $0x1, %edx
callq 0xc9e0
leaq 0x5094e(%rip), %rsi # 0x626c8
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movl $0x2, %edx
callq 0xe194
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0xe21c
movq 0x28(%rsp), %rsi
leaq 0x80(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x70(%rsp), %rdi
callq 0xe3e0
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq 0x91220(%rip), %rdi # 0xa2ff0
callq 0xc9e0
movq %rax, %rbx
leaq 0x7762c(%rip), %rsi # 0x8940b
movl $0x1, %edx
movq %rax, %rdi
callq 0xc9e0
movq %rbx, %rdi
movl $0x13, %esi
callq 0xceb0
movq %rax, %rbx
leaq 0x5032c(%rip), %rsi # 0x6212f
movl $0x3, %edx
movq %rax, %rdi
callq 0xc9e0
leaq 0x5031c(%rip), %rsi # 0x62133
movl $0x15, %edx
movq %rbx, %rdi
callq 0xc9e0
leaq 0x5089d(%rip), %rsi # 0x626c8
leaq 0xb8(%rsp), %rdi
movl $0x2, %edx
callq 0xe194
movq %rsp, %rdi
leaq 0xb8(%rsp), %rsi
callq 0xe21c
movq (%rsp), %rsi
leaq 0x60(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x50(%rsp), %rdi
callq 0xe3e0
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq %rbx, %rdi
callq 0xc9e0
movq %rax, %rbx
leaq 0x77583(%rip), %rsi # 0x8940b
movl $0x1, %edx
movq %rax, %rdi
callq 0xc9e0
movq %rbx, %rdi
movl $0x13, %esi
callq 0xceb0
movq %rax, %rdi
callq 0xc3f0
leaq 0x50(%rsp), %rdi
callq 0xc3b0
movq %rsp, %rdi
callq 0xe29a
leaq 0xb8(%rsp), %rdi
callq 0xe29a
leaq 0x70(%rsp), %rdi
callq 0xc3b0
leaq 0x28(%rsp), %rdi
callq 0xe29a
leaq 0x90(%rsp), %rdi
callq 0xe29a
callq 0xc1e0
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x11f0e
movq 0x60(%rsp), %rsi
incq %rsi
callq 0xc8d0
jmp 0x11f0e
movq %rax, %rbx
movq %rsp, %rdi
callq 0xe29a
jmp 0x11f1b
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0xe29a
jmp 0x11f2f
jmp 0x11f2c
movq %rax, %rbx
movq 0x70(%rsp), %rdi
cmpq %r14, %rdi
je 0x11f65
movq 0x80(%rsp), %rsi
jmp 0x11f58
jmp 0x11f62
jmp 0x11f71
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x11f65
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc8d0
jmp 0x11f65
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xe29a
jmp 0x11f74
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xe29a
movq %rbx, %rdi
callq 0xcf00
| _ZL19ritegAPI_has_optionP9lua_State:
push r15
push r14
push rbx
sub rsp, 0E0h
mov rbx, rdi
mov esi, (offset dword_0+1); char *
xor edx, edx
call luaL_checklstring
test rax, rax
jz short loc_11C3B
mov rdi, rax; this
call _ZN7cmdline8containsEPKc; cmdline::contains(char const*)
movzx esi, al
mov rdi, rbx
call lua_pushboolean
mov eax, 1
add rsp, 0E0h
pop rbx
pop r14
pop r15
retn
loc_11C3B:
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, asc_6212D; "["
mov edx, 1
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aWorkspaceLlm4b_6; "/workspace/llm4binary/github/2025_star3"...
lea rbx, [rsp+0F8h+var_68]
mov rdi, rbx; this
mov edx, 2
call _ZNSt10filesystem7__cxx114pathC2IA74_cS1_EERKT_NS1_6formatE; std::filesystem::__cxx11::path::path<char [74],std::filesystem::__cxx11::path>(char [74] const&,std::filesystem::__cxx11::path::format)
lea rdi, [rsp+0F8h+var_D0]; this
mov rsi, rbx
call _ZNKSt10filesystem7__cxx114path8filenameEv; std::filesystem::__cxx11::path::filename(void)
mov rsi, [rsp+0F8h+var_D0]
lea r14, [rsp+0F8h+var_E8]
mov [r14-10h], r14
mov rdx, [rsp+0F8h+var_C8]
add rdx, rsi
mov rdi, rsp
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rsi, [rsp+0F8h+var_F8]
mov rdx, [rsp+0F8h+var_F0]
mov rdi, cs:_ZSt4cerr_ptr
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rbx, rax
lea rsi, asc_8940A+1; ":"
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, rbx
mov esi, 13h
call __ZNSolsEi; std::ostream::operator<<(int)
mov rbx, rax
lea rsi, asc_6212F; "]: "
mov edx, 3
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)
lea rsi, a13191mfatal0m; "\x1B[1;31;91mfatal:\x1B[0m "
mov edx, 15h
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aAssertionFaile_0; "assertion failed: "
mov edx, 12h
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aOptionNullptr; "option != nullptr"
mov edx, 11h
mov rdi, rbx
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, rbx
call __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_; std::endl<char,std::char_traits<char>>(std::ostream &)
mov rdi, [rsp+0F8h+var_F8]; void *
cmp rdi, r14
jz short loc_11D44
mov rsi, [rsp+0F8h+var_E8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_11D44:
lea rdi, [rsp+0F8h+var_D0]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
lea rdi, [rsp+0F8h+var_68]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, asc_6212D; "["
mov edx, 1
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aWorkspaceLlm4b_6; "/workspace/llm4binary/github/2025_star3"...
lea rbx, [rsp+0F8h+var_68]
mov rdi, rbx; this
mov edx, 2
call _ZNSt10filesystem7__cxx114pathC2IA74_cS1_EERKT_NS1_6formatE; std::filesystem::__cxx11::path::path<char [74],std::filesystem::__cxx11::path>(char [74] const&,std::filesystem::__cxx11::path::format)
lea rdi, [rsp+0F8h+var_D0]; this
mov rsi, rbx
call _ZNKSt10filesystem7__cxx114path8filenameEv; std::filesystem::__cxx11::path::filename(void)
mov rsi, [rsp+0F8h+var_D0]
lea r14, [rsp+0F8h+var_78]
mov [r14-10h], r14
mov rdx, [rsp+0F8h+var_C8]
add rdx, rsi
lea rdi, [rsp+0F8h+var_88]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rsi, [rsp+0F8h+var_88]
mov rdx, [rsp+0F8h+var_80]
mov rdi, cs:_ZSt4cerr_ptr
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rbx, rax
lea rsi, asc_8940A+1; ":"
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, rbx
mov esi, 13h
call __ZNSolsEi; std::ostream::operator<<(int)
mov rbx, rax
lea rsi, asc_6212F; "]: "
mov edx, 3
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)
lea rsi, a13191mfatal0m; "\x1B[1;31;91mfatal:\x1B[0m "
mov edx, 15h
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aWorkspaceLlm4b_6; "/workspace/llm4binary/github/2025_star3"...
lea rdi, [rsp+0F8h+var_40]; this
mov edx, 2
call _ZNSt10filesystem7__cxx114pathC2IA74_cS1_EERKT_NS1_6formatE; std::filesystem::__cxx11::path::path<char [74],std::filesystem::__cxx11::path>(char [74] const&,std::filesystem::__cxx11::path::format)
mov rdi, rsp; this
lea rsi, [rsp+0F8h+var_40]
call _ZNKSt10filesystem7__cxx114path8filenameEv; std::filesystem::__cxx11::path::filename(void)
mov rsi, [rsp+0F8h+var_F8]
lea r15, [rsp+0F8h+var_98]
mov [r15-10h], r15
mov rdx, [rsp+0F8h+var_F0]
add rdx, rsi
lea rdi, [rsp+0F8h+var_A8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rsi, [rsp+0F8h+var_A8]
mov rdx, [rsp+0F8h+var_A0]
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rbx, rax
lea rsi, asc_8940A+1; ":"
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, rbx
mov esi, 13h
call __ZNSolsEi; std::ostream::operator<<(int)
mov rdi, rax
call __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_; std::endl<char,std::char_traits<char>>(std::ostream &)
lea rdi, [rsp+0F8h+var_A8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rsp; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
lea rdi, [rsp+0F8h+var_40]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
lea rdi, [rsp+0F8h+var_88]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0F8h+var_D0]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
lea rdi, [rsp+0F8h+var_68]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
call __ZSt9terminatev; std::terminate(void)
mov rbx, rax
mov rdi, [rsp+0F8h+var_A8]; void *
cmp rdi, r15
jz short loc_11F0E
mov rsi, [rsp+0F8h+var_98]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_11F0E
mov rbx, rax
loc_11F0E:
mov rdi, rsp; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
jmp short loc_11F1B
mov rbx, rax
loc_11F1B:
lea rdi, [rsp+0F8h+var_40]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
jmp short loc_11F2F
jmp short $+2
loc_11F2C:
mov rbx, rax
loc_11F2F:
mov rdi, [rsp+0F8h+var_88]
cmp rdi, r14
jz short loc_11F65
mov rsi, [rsp+0F8h+var_78]
jmp short loc_11F58
jmp short loc_11F62
jmp short loc_11F71
mov rbx, rax
mov rdi, [rsp+0F8h+var_F8]; void *
cmp rdi, r14
jz short loc_11F65
mov rsi, [rsp+0F8h+var_E8]
loc_11F58:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_11F65
loc_11F62:
mov rbx, rax
loc_11F65:
lea rdi, [rsp+0F8h+var_D0]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
jmp short loc_11F74
loc_11F71:
mov rbx, rax
loc_11F74:
lea rdi, [rsp+0F8h+var_68]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
mov rdi, rbx
call __Unwind_Resume
| long long ritegAPI_has_option(long long a1)
{
cmdline *v1; // rax
unsigned __int8 v2; // al
long long v4; // rbx
long long v5; // rbx
long long v6; // rbx
long long v7; // rbx
long long v8; // rbx
long long v9; // rax
void *v10; // [rsp+0h] [rbp-F8h] BYREF
long long v11; // [rsp+8h] [rbp-F0h]
_QWORD v12[3]; // [rsp+10h] [rbp-E8h] BYREF
_BYTE *v13; // [rsp+28h] [rbp-D0h] BYREF
long long v14; // [rsp+30h] [rbp-C8h]
void *v15[2]; // [rsp+50h] [rbp-A8h] BYREF
long long v16; // [rsp+60h] [rbp-98h] BYREF
_QWORD v17[2]; // [rsp+70h] [rbp-88h] BYREF
long long v18; // [rsp+80h] [rbp-78h] BYREF
_QWORD v19[5]; // [rsp+90h] [rbp-68h] BYREF
_QWORD v20[8]; // [rsp+B8h] [rbp-40h] BYREF
v1 = (cmdline *)luaL_checklstring(a1, (char *)&dword_0 + 1, 0LL);
if ( !v1 )
{
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, "[", 1LL);
std::filesystem::__cxx11::path::path<char [74],std::filesystem::__cxx11::path>(
(std::filesystem::__cxx11::path *)v19,
(long long)"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/riteg/project.cc");
std::filesystem::__cxx11::path::filename((std::filesystem::__cxx11::path *)&v13, v19);
v10 = v12;
std::string::_M_construct<char const*>(&v10, v13, (long long)&v13[v14]);
v4 = std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, v10, v11);
std::__ostream_insert<char,std::char_traits<char>>(v4, ":", 1LL);
v5 = std::ostream::operator<<(v4, 19LL);
std::__ostream_insert<char,std::char_traits<char>>(v5, "]: ", 3LL);
std::__ostream_insert<char,std::char_traits<char>>(v5, "\x1B[1;31;91mfatal:\x1B[0m ", 21LL);
std::__ostream_insert<char,std::char_traits<char>>(v5, "assertion failed: ", 18LL);
std::__ostream_insert<char,std::char_traits<char>>(v5, "option != nullptr", 17LL);
std::endl<char,std::char_traits<char>>(v5);
if ( v10 != v12 )
operator delete(v10, v12[0] + 1LL);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)&v13);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)v19);
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, "[", 1LL);
std::filesystem::__cxx11::path::path<char [74],std::filesystem::__cxx11::path>(
(std::filesystem::__cxx11::path *)v19,
(long long)"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/riteg/project.cc");
std::filesystem::__cxx11::path::filename((std::filesystem::__cxx11::path *)&v13, v19);
v17[0] = &v18;
std::string::_M_construct<char const*>(v17, v13, (long long)&v13[v14]);
v6 = std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, v17[0], v17[1]);
std::__ostream_insert<char,std::char_traits<char>>(v6, ":", 1LL);
v7 = std::ostream::operator<<(v6, 19LL);
std::__ostream_insert<char,std::char_traits<char>>(v7, "]: ", 3LL);
std::__ostream_insert<char,std::char_traits<char>>(v7, "\x1B[1;31;91mfatal:\x1B[0m ", 21LL);
std::filesystem::__cxx11::path::path<char [74],std::filesystem::__cxx11::path>(
(std::filesystem::__cxx11::path *)v20,
(long long)"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/riteg/project.cc");
std::filesystem::__cxx11::path::filename((std::filesystem::__cxx11::path *)&v10, v20);
v15[0] = &v16;
std::string::_M_construct<char const*>(v15, v10, (long long)v10 + v11);
v8 = std::__ostream_insert<char,std::char_traits<char>>(v7, v15[0], v15[1]);
std::__ostream_insert<char,std::char_traits<char>>(v8, ":", 1LL);
v9 = std::ostream::operator<<(v8, 19LL);
std::endl<char,std::char_traits<char>>(v9);
std::string::~string(v15);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)&v10);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)v20);
std::string::~string(v17);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)&v13);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)v19);
std::terminate();
}
v2 = cmdline::contains(v1, (const char *)&dword_0 + 1);
lua_pushboolean(a1, v2);
return 1LL;
}
| ritegAPI_has_option:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xe0
MOV RBX,RDI
MOV ESI,0x1
XOR EDX,EDX
CALL 0x00131dde
TEST RAX,RAX
JZ 0x00111c3b
MOV RDI,RAX
CALL 0x0010e05b
MOVZX ESI,AL
MOV RDI,RBX
CALL 0x0012ff59
MOV EAX,0x1
ADD RSP,0xe0
POP RBX
POP R14
POP R15
RET
LAB_00111c3b:
MOV RDI,qword ptr [0x001a2ff0]
LEA RSI,[0x16212d]
MOV EDX,0x1
CALL 0x0010c9e0
LEA RSI,[0x1626c8]
LEA RBX,[RSP + 0x90]
MOV RDI,RBX
MOV EDX,0x2
CALL 0x0010e194
LAB_00111c6f:
LEA RDI,[RSP + 0x28]
MOV RSI,RBX
CALL 0x0010e21c
MOV RSI,qword ptr [RSP + 0x28]
LEA R14,[RSP + 0x10]
MOV qword ptr [R14 + -0x10],R14
MOV RDX,qword ptr [RSP + 0x30]
ADD RDX,RSI
LAB_00111c92:
MOV RDI,RSP
CALL 0x0010e3e0
MOV RSI,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x8]
LAB_00111ca3:
MOV RDI,qword ptr [0x001a2ff0]
CALL 0x0010c9e0
MOV RBX,RAX
LEA RSI,[0x18940b]
MOV EDX,0x1
MOV RDI,RAX
CALL 0x0010c9e0
MOV RDI,RBX
MOV ESI,0x13
CALL 0x0010ceb0
MOV RBX,RAX
LEA RSI,[0x16212f]
MOV EDX,0x3
MOV RDI,RAX
CALL 0x0010c9e0
LEA RSI,[0x162133]
MOV EDX,0x15
MOV RDI,RBX
CALL 0x0010c9e0
LEA RSI,[0x16233e]
MOV EDX,0x12
MOV RDI,RBX
CALL 0x0010c9e0
LEA RSI,[0x1621a0]
MOV EDX,0x11
MOV RDI,RBX
CALL 0x0010c9e0
MOV RDI,RBX
CALL 0x0010c3f0
LAB_00111d2e:
MOV RDI,qword ptr [RSP]
CMP RDI,R14
JZ 0x00111d44
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x0010c8d0
LAB_00111d44:
LEA RDI,[RSP + 0x28]
CALL 0x0010e29a
LEA RDI,[RSP + 0x90]
CALL 0x0010e29a
MOV RDI,qword ptr [0x001a2ff0]
LEA RSI,[0x16212d]
MOV EDX,0x1
CALL 0x0010c9e0
LEA RSI,[0x1626c8]
LEA RBX,[RSP + 0x90]
MOV RDI,RBX
MOV EDX,0x2
CALL 0x0010e194
LAB_00111d8f:
LEA RDI,[RSP + 0x28]
MOV RSI,RBX
CALL 0x0010e21c
MOV RSI,qword ptr [RSP + 0x28]
LEA R14,[RSP + 0x80]
MOV qword ptr [R14 + -0x10],R14
MOV RDX,qword ptr [RSP + 0x30]
ADD RDX,RSI
LAB_00111db5:
LEA RDI,[RSP + 0x70]
CALL 0x0010e3e0
MOV RSI,qword ptr [RSP + 0x70]
MOV RDX,qword ptr [RSP + 0x78]
LAB_00111dc9:
MOV RDI,qword ptr [0x001a2ff0]
CALL 0x0010c9e0
MOV RBX,RAX
LEA RSI,[0x18940b]
MOV EDX,0x1
MOV RDI,RAX
CALL 0x0010c9e0
MOV RDI,RBX
MOV ESI,0x13
CALL 0x0010ceb0
MOV RBX,RAX
LEA RSI,[0x16212f]
MOV EDX,0x3
MOV RDI,RAX
CALL 0x0010c9e0
LEA RSI,[0x162133]
MOV EDX,0x15
MOV RDI,RBX
CALL 0x0010c9e0
LAB_00111e24:
LEA RSI,[0x1626c8]
LEA RDI,[RSP + 0xb8]
MOV EDX,0x2
CALL 0x0010e194
LAB_00111e3d:
MOV RDI,RSP
LEA RSI,[RSP + 0xb8]
CALL 0x0010e21c
MOV RSI,qword ptr [RSP]
LEA R15,[RSP + 0x60]
MOV qword ptr [R15 + -0x10],R15
MOV RDX,qword ptr [RSP + 0x8]
ADD RDX,RSI
LAB_00111e62:
LEA RDI,[RSP + 0x50]
CALL 0x0010e3e0
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x58]
LAB_00111e76:
MOV RDI,RBX
CALL 0x0010c9e0
MOV RBX,RAX
LEA RSI,[0x18940b]
MOV EDX,0x1
MOV RDI,RAX
CALL 0x0010c9e0
MOV RDI,RBX
MOV ESI,0x13
CALL 0x0010ceb0
MOV RDI,RAX
CALL 0x0010c3f0
LAB_00111eaa:
LEA RDI,[RSP + 0x50]
CALL 0x0010c3b0
MOV RDI,RSP
CALL 0x0010e29a
LEA RDI,[RSP + 0xb8]
CALL 0x0010e29a
LEA RDI,[RSP + 0x70]
CALL 0x0010c3b0
LEA RDI,[RSP + 0x28]
CALL 0x0010e29a
LEA RDI,[RSP + 0x90]
CALL 0x0010e29a
CALL 0x0010c1e0
|
/* ritegAPI_has_option(lua_State*) */
int8 ritegAPI_has_option(lua_State *param_1)
{
int1 uVar1;
char *pcVar2;
ostream *poVar3;
long *local_f8;
long local_f0;
long local_e8 [3];
long local_d0;
long local_c8;
char *local_a8;
long local_a0;
char local_98 [16];
char *local_88;
long local_80;
char local_78 [16];
path local_68 [40];
path local_40 [40];
pcVar2 = (char *)luaL_checklstring(param_1,1,0);
if (pcVar2 != (char *)0x0) {
uVar1 = cmdline::contains(pcVar2);
lua_pushboolean(param_1,uVar1);
return 1;
}
std::__ostream_insert<char,std::char_traits<char>>((ostream *)PTR_cerr_001a2ff0,"[",1);
std::filesystem::__cxx11::path::path<char[74],std::filesystem::__cxx11::path>
(local_68,"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/riteg/project.cc",2)
;
/* try { // try from 00111c6f to 00111c7b has its CatchHandler @ 00111f71 */
std::filesystem::__cxx11::path::filename();
local_f8 = local_e8;
/* try { // try from 00111c92 to 00111c99 has its CatchHandler @ 00111f62 */
std::__cxx11::string::_M_construct<char_const*>(&local_f8,local_d0,local_c8 + local_d0);
/* try { // try from 00111ca3 to 00111d2d has its CatchHandler @ 00111f47 */
poVar3 = std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_001a2ff0,(char *)local_f8,local_f0);
std::__ostream_insert<char,std::char_traits<char>>(poVar3,":",1);
poVar3 = (ostream *)std::ostream::operator<<(poVar3,0x13);
std::__ostream_insert<char,std::char_traits<char>>(poVar3,"]: ",3);
std::__ostream_insert<char,std::char_traits<char>>(poVar3,"\x1b[1;31;91mfatal:\x1b[0m ",0x15);
std::__ostream_insert<char,std::char_traits<char>>(poVar3,"assertion failed: ",0x12);
std::__ostream_insert<char,std::char_traits<char>>(poVar3,"option != nullptr",0x11);
std::endl<char,std::char_traits<char>>(poVar3);
if (local_f8 != local_e8) {
operator_delete(local_f8,local_e8[0] + 1);
}
std::filesystem::__cxx11::path::~path((path *)&local_d0);
std::filesystem::__cxx11::path::~path(local_68);
std::__ostream_insert<char,std::char_traits<char>>((ostream *)PTR_cerr_001a2ff0,"[",1);
std::filesystem::__cxx11::path::path<char[74],std::filesystem::__cxx11::path>
(local_68,"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/riteg/project.cc",2)
;
/* try { // try from 00111d8f to 00111d9b has its CatchHandler @ 00111f45 */
std::filesystem::__cxx11::path::filename();
local_88 = local_78;
/* try { // try from 00111db5 to 00111dbe has its CatchHandler @ 00111f43 */
std::__cxx11::string::_M_construct<char_const*>(&local_88,local_d0,local_c8 + local_d0);
/* try { // try from 00111dc9 to 00111e23 has its CatchHandler @ 00111f2c */
poVar3 = std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_001a2ff0,local_88,local_80);
std::__ostream_insert<char,std::char_traits<char>>(poVar3,":",1);
poVar3 = (ostream *)std::ostream::operator<<(poVar3,0x13);
std::__ostream_insert<char,std::char_traits<char>>(poVar3,"]: ",3);
std::__ostream_insert<char,std::char_traits<char>>(poVar3,"\x1b[1;31;91mfatal:\x1b[0m ",0x15);
/* try { // try from 00111e24 to 00111e3c has its CatchHandler @ 00111f2a */
std::filesystem::__cxx11::path::path<char[74],std::filesystem::__cxx11::path>
(local_40,"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/riteg/project.cc",2)
;
/* try { // try from 00111e3d to 00111e4c has its CatchHandler @ 00111f18 */
std::filesystem::__cxx11::path::filename();
local_a8 = local_98;
/* try { // try from 00111e62 to 00111e6b has its CatchHandler @ 00111f0b */
std::__cxx11::string::_M_construct<char_const*>(&local_a8,local_f8,(long)local_f8 + local_f0);
/* try { // try from 00111e76 to 00111ea9 has its CatchHandler @ 00111eef */
poVar3 = std::__ostream_insert<char,std::char_traits<char>>(poVar3,local_a8,local_a0);
std::__ostream_insert<char,std::char_traits<char>>(poVar3,":",1);
poVar3 = (ostream *)std::ostream::operator<<(poVar3,0x13);
std::endl<char,std::char_traits<char>>(poVar3);
std::__cxx11::string::~string((string *)&local_a8);
std::filesystem::__cxx11::path::~path((path *)&local_f8);
std::filesystem::__cxx11::path::~path(local_40);
std::__cxx11::string::~string((string *)&local_88);
std::filesystem::__cxx11::path::~path((path *)&local_d0);
std::filesystem::__cxx11::path::~path(local_68);
/* WARNING: Subroutine does not return */
std::terminate();
}
| |
42,889 | ritegAPI_has_option(lua_State*) | untodesu[P]riteg/riteg/project.cc | static int ritegAPI_has_option(lua_State *L)
{
auto option = luaL_checkstring(L, 1);
riteg_force_assert(option != nullptr);
if(cmdline::contains(option))
lua_pushboolean(L, true);
else lua_pushboolean(L, false);
return 1;
} | O3 | cpp | ritegAPI_has_option(lua_State*):
pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x319fa
testq %rax, %rax
je 0x11b3f
movq %rax, %rdi
callq 0xdfeb
movzbl %al, %esi
movq %rbx, %rdi
callq 0x2fb80
movl $0x1, %eax
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x954aa(%rip), %rdi # 0xa6ff0
leaq 0x545e0(%rip), %rsi # 0x6612d
movl $0x1, %edx
callq 0xc9e0
leaq 0x54b6a(%rip), %rsi # 0x666c8
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movl $0x2, %edx
callq 0xe126
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0xe1ae
movq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xe36e
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x95442(%rip), %rdi # 0xa6ff0
callq 0xc9e0
movq %rax, %rbx
leaq 0x7b84e(%rip), %rsi # 0x8d40b
movl $0x1, %edx
movq %rax, %rdi
callq 0xc9e0
movq %rbx, %rdi
movl $0x13, %esi
callq 0xceb0
movq %rax, %rbx
leaq 0x5454e(%rip), %rsi # 0x6612f
movl $0x3, %edx
movq %rax, %rdi
callq 0xc9e0
leaq 0x5453e(%rip), %rsi # 0x66133
movl $0x15, %edx
movq %rbx, %rdi
callq 0xc9e0
leaq 0x54735(%rip), %rsi # 0x6633e
movl $0x12, %edx
movq %rbx, %rdi
callq 0xc9e0
leaq 0x54583(%rip), %rsi # 0x661a0
movl $0x11, %edx
movq %rbx, %rdi
callq 0xc9e0
movq %rbx, %rdi
callq 0xc3f0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x11c48
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc8d0
leaq 0x28(%rsp), %rdi
callq 0xe222
leaq 0x90(%rsp), %rdi
callq 0xe222
movq 0x9538a(%rip), %rdi # 0xa6ff0
leaq 0x544c0(%rip), %rsi # 0x6612d
movl $0x1, %edx
callq 0xc9e0
leaq 0x54a4a(%rip), %rsi # 0x666c8
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movl $0x2, %edx
callq 0xe126
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0xe1ae
movq 0x28(%rsp), %rsi
leaq 0x80(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x70(%rsp), %rdi
callq 0xe36e
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq 0x9531c(%rip), %rdi # 0xa6ff0
callq 0xc9e0
movq %rax, %rbx
leaq 0x7b728(%rip), %rsi # 0x8d40b
movl $0x1, %edx
movq %rax, %rdi
callq 0xc9e0
movq %rbx, %rdi
movl $0x13, %esi
callq 0xceb0
movq %rax, %rbx
leaq 0x54428(%rip), %rsi # 0x6612f
movl $0x3, %edx
movq %rax, %rdi
callq 0xc9e0
leaq 0x54418(%rip), %rsi # 0x66133
movl $0x15, %edx
movq %rbx, %rdi
callq 0xc9e0
leaq 0x54999(%rip), %rsi # 0x666c8
leaq 0xb8(%rsp), %rdi
movl $0x2, %edx
callq 0xe126
movq %rsp, %rdi
leaq 0xb8(%rsp), %rsi
callq 0xe1ae
movq (%rsp), %rsi
leaq 0x60(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x50(%rsp), %rdi
callq 0xe36e
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq %rbx, %rdi
callq 0xc9e0
movq %rax, %rbx
leaq 0x7b67f(%rip), %rsi # 0x8d40b
movl $0x1, %edx
movq %rax, %rdi
callq 0xc9e0
movq %rbx, %rdi
movl $0x13, %esi
callq 0xceb0
movq %rax, %rdi
callq 0xc3f0
leaq 0x50(%rsp), %rdi
callq 0xc3b0
movq %rsp, %rdi
callq 0xe222
leaq 0xb8(%rsp), %rdi
callq 0xe222
leaq 0x70(%rsp), %rdi
callq 0xc3b0
leaq 0x28(%rsp), %rdi
callq 0xe222
leaq 0x90(%rsp), %rdi
callq 0xe222
callq 0xc1e0
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x11e12
movq 0x60(%rsp), %rsi
incq %rsi
callq 0xc8d0
jmp 0x11e12
movq %rax, %rbx
movq %rsp, %rdi
callq 0xe222
jmp 0x11e1f
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0xe222
jmp 0x11e33
jmp 0x11e30
movq %rax, %rbx
movq 0x70(%rsp), %rdi
cmpq %r14, %rdi
je 0x11e69
movq 0x80(%rsp), %rsi
jmp 0x11e5c
jmp 0x11e66
jmp 0x11e75
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x11e69
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc8d0
jmp 0x11e69
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xe222
jmp 0x11e78
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xe222
movq %rbx, %rdi
callq 0xcf00
| _ZL19ritegAPI_has_optionP9lua_State:
push r15
push r14
push rbx
sub rsp, 0E0h
mov rbx, rdi
mov esi, (offset dword_0+1); char *
xor edx, edx
call luaL_checklstring
test rax, rax
jz short loc_11B3F
mov rdi, rax; this
call _ZN7cmdline8containsEPKc; cmdline::contains(char const*)
movzx esi, al
mov rdi, rbx
call lua_pushboolean
mov eax, 1
add rsp, 0E0h
pop rbx
pop r14
pop r15
retn
loc_11B3F:
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, asc_6612D; "["
mov edx, 1
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aWorkspaceLlm4b_6; "/workspace/llm4binary/github/2025_star3"...
lea rbx, [rsp+0F8h+var_68]
mov rdi, rbx; this
mov edx, 2
call _ZNSt10filesystem7__cxx114pathC2IA74_cS1_EERKT_NS1_6formatE; std::filesystem::__cxx11::path::path<char [74],std::filesystem::__cxx11::path>(char [74] const&,std::filesystem::__cxx11::path::format)
lea rdi, [rsp+0F8h+var_D0]; this
mov rsi, rbx
call _ZNKSt10filesystem7__cxx114path8filenameEv; std::filesystem::__cxx11::path::filename(void)
mov rsi, [rsp+0F8h+var_D0]
lea r14, [rsp+0F8h+var_E8]
mov [r14-10h], r14
mov rdx, [rsp+0F8h+var_C8]
add rdx, rsi
mov rdi, rsp
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rsi, [rsp+0F8h+var_F8]
mov rdx, [rsp+0F8h+var_F0]
mov rdi, cs:_ZSt4cerr_ptr
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rbx, rax
lea rsi, asc_8D40A+1; ":"
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, rbx
mov esi, 13h
call __ZNSolsEi; std::ostream::operator<<(int)
mov rbx, rax
lea rsi, asc_6612F; "]: "
mov edx, 3
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)
lea rsi, a13191mfatal0m; "\x1B[1;31;91mfatal:\x1B[0m "
mov edx, 15h
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aAssertionFaile_0; "assertion failed: "
mov edx, 12h
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aOptionNullptr; "option != nullptr"
mov edx, 11h
mov rdi, rbx
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, rbx
call __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_; std::endl<char,std::char_traits<char>>(std::ostream &)
mov rdi, [rsp+0F8h+var_F8]; void *
cmp rdi, r14
jz short loc_11C48
mov rsi, [rsp+0F8h+var_E8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_11C48:
lea rdi, [rsp+0F8h+var_D0]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
lea rdi, [rsp+0F8h+var_68]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, asc_6612D; "["
mov edx, 1
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aWorkspaceLlm4b_6; "/workspace/llm4binary/github/2025_star3"...
lea rbx, [rsp+0F8h+var_68]
mov rdi, rbx; this
mov edx, 2
call _ZNSt10filesystem7__cxx114pathC2IA74_cS1_EERKT_NS1_6formatE; std::filesystem::__cxx11::path::path<char [74],std::filesystem::__cxx11::path>(char [74] const&,std::filesystem::__cxx11::path::format)
lea rdi, [rsp+0F8h+var_D0]; this
mov rsi, rbx
call _ZNKSt10filesystem7__cxx114path8filenameEv; std::filesystem::__cxx11::path::filename(void)
mov rsi, [rsp+0F8h+var_D0]
lea r14, [rsp+0F8h+var_78]
mov [r14-10h], r14
mov rdx, [rsp+0F8h+var_C8]
add rdx, rsi
lea rdi, [rsp+0F8h+var_88]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rsi, [rsp+0F8h+var_88]
mov rdx, [rsp+0F8h+var_80]
mov rdi, cs:_ZSt4cerr_ptr
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rbx, rax
lea rsi, asc_8D40A+1; ":"
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, rbx
mov esi, 13h
call __ZNSolsEi; std::ostream::operator<<(int)
mov rbx, rax
lea rsi, asc_6612F; "]: "
mov edx, 3
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)
lea rsi, a13191mfatal0m; "\x1B[1;31;91mfatal:\x1B[0m "
mov edx, 15h
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aWorkspaceLlm4b_6; "/workspace/llm4binary/github/2025_star3"...
lea rdi, [rsp+0F8h+var_40]; this
mov edx, 2
call _ZNSt10filesystem7__cxx114pathC2IA74_cS1_EERKT_NS1_6formatE; std::filesystem::__cxx11::path::path<char [74],std::filesystem::__cxx11::path>(char [74] const&,std::filesystem::__cxx11::path::format)
mov rdi, rsp; this
lea rsi, [rsp+0F8h+var_40]
call _ZNKSt10filesystem7__cxx114path8filenameEv; std::filesystem::__cxx11::path::filename(void)
mov rsi, [rsp+0F8h+var_F8]
lea r15, [rsp+0F8h+var_98]
mov [r15-10h], r15
mov rdx, [rsp+0F8h+var_F0]
add rdx, rsi
lea rdi, [rsp+0F8h+var_A8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rsi, [rsp+0F8h+var_A8]
mov rdx, [rsp+0F8h+var_A0]
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rbx, rax
lea rsi, asc_8D40A+1; ":"
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, rbx
mov esi, 13h
call __ZNSolsEi; std::ostream::operator<<(int)
mov rdi, rax
call __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_; std::endl<char,std::char_traits<char>>(std::ostream &)
lea rdi, [rsp+0F8h+var_A8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rsp; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
lea rdi, [rsp+0F8h+var_40]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
lea rdi, [rsp+0F8h+var_88]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0F8h+var_D0]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
lea rdi, [rsp+0F8h+var_68]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
call __ZSt9terminatev; std::terminate(void)
mov rbx, rax
mov rdi, [rsp+0F8h+var_A8]; void *
cmp rdi, r15
jz short loc_11E12
mov rsi, [rsp+0F8h+var_98]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_11E12
mov rbx, rax
loc_11E12:
mov rdi, rsp; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
jmp short loc_11E1F
mov rbx, rax
loc_11E1F:
lea rdi, [rsp+0F8h+var_40]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
jmp short loc_11E33
jmp short $+2
loc_11E30:
mov rbx, rax
loc_11E33:
mov rdi, [rsp+0F8h+var_88]
cmp rdi, r14
jz short loc_11E69
mov rsi, [rsp+0F8h+var_78]
jmp short loc_11E5C
jmp short loc_11E66
jmp short loc_11E75
mov rbx, rax
mov rdi, [rsp+0F8h+var_F8]; void *
cmp rdi, r14
jz short loc_11E69
mov rsi, [rsp+0F8h+var_E8]
loc_11E5C:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_11E69
loc_11E66:
mov rbx, rax
loc_11E69:
lea rdi, [rsp+0F8h+var_D0]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
jmp short loc_11E78
loc_11E75:
mov rbx, rax
loc_11E78:
lea rdi, [rsp+0F8h+var_68]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
mov rdi, rbx
call __Unwind_Resume
| long long ritegAPI_has_option(long long a1)
{
cmdline *v1; // rax
unsigned __int8 v2; // al
long long v4; // rbx
long long v5; // rbx
long long v6; // rbx
long long v7; // rbx
long long v8; // rbx
long long v9; // rax
void *v10; // [rsp+0h] [rbp-F8h] BYREF
long long v11; // [rsp+8h] [rbp-F0h]
_QWORD v12[3]; // [rsp+10h] [rbp-E8h] BYREF
_BYTE *v13; // [rsp+28h] [rbp-D0h] BYREF
long long v14; // [rsp+30h] [rbp-C8h]
void *v15[2]; // [rsp+50h] [rbp-A8h] BYREF
long long v16; // [rsp+60h] [rbp-98h] BYREF
_QWORD v17[2]; // [rsp+70h] [rbp-88h] BYREF
long long v18; // [rsp+80h] [rbp-78h] BYREF
_QWORD v19[5]; // [rsp+90h] [rbp-68h] BYREF
_QWORD v20[8]; // [rsp+B8h] [rbp-40h] BYREF
v1 = (cmdline *)luaL_checklstring(a1, (char *)&dword_0 + 1, 0LL);
if ( !v1 )
{
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, "[", 1LL);
std::filesystem::__cxx11::path::path<char [74],std::filesystem::__cxx11::path>(
(std::filesystem::__cxx11::path *)v19,
(long long)"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/riteg/project.cc");
std::filesystem::__cxx11::path::filename((std::filesystem::__cxx11::path *)&v13, v19);
v10 = v12;
std::string::_M_construct<char const*>((long long)&v10, v13, (long long)&v13[v14]);
v4 = std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, v10, v11);
std::__ostream_insert<char,std::char_traits<char>>(v4, ":", 1LL);
v5 = std::ostream::operator<<(v4, 19LL);
std::__ostream_insert<char,std::char_traits<char>>(v5, "]: ", 3LL);
std::__ostream_insert<char,std::char_traits<char>>(v5, "\x1B[1;31;91mfatal:\x1B[0m ", 21LL);
std::__ostream_insert<char,std::char_traits<char>>(v5, "assertion failed: ", 18LL);
std::__ostream_insert<char,std::char_traits<char>>(v5, "option != nullptr", 17LL);
std::endl<char,std::char_traits<char>>(v5);
if ( v10 != v12 )
operator delete(v10, v12[0] + 1LL);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)&v13);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)v19);
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, "[", 1LL);
std::filesystem::__cxx11::path::path<char [74],std::filesystem::__cxx11::path>(
(std::filesystem::__cxx11::path *)v19,
(long long)"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/riteg/project.cc");
std::filesystem::__cxx11::path::filename((std::filesystem::__cxx11::path *)&v13, v19);
v17[0] = &v18;
std::string::_M_construct<char const*>((long long)v17, v13, (long long)&v13[v14]);
v6 = std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, v17[0], v17[1]);
std::__ostream_insert<char,std::char_traits<char>>(v6, ":", 1LL);
v7 = std::ostream::operator<<(v6, 19LL);
std::__ostream_insert<char,std::char_traits<char>>(v7, "]: ", 3LL);
std::__ostream_insert<char,std::char_traits<char>>(v7, "\x1B[1;31;91mfatal:\x1B[0m ", 21LL);
std::filesystem::__cxx11::path::path<char [74],std::filesystem::__cxx11::path>(
(std::filesystem::__cxx11::path *)v20,
(long long)"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/riteg/project.cc");
std::filesystem::__cxx11::path::filename((std::filesystem::__cxx11::path *)&v10, v20);
v15[0] = &v16;
std::string::_M_construct<char const*>((long long)v15, v10, (long long)v10 + v11);
v8 = std::__ostream_insert<char,std::char_traits<char>>(v7, v15[0], v15[1]);
std::__ostream_insert<char,std::char_traits<char>>(v8, ":", 1LL);
v9 = std::ostream::operator<<(v8, 19LL);
std::endl<char,std::char_traits<char>>(v9);
std::string::~string(v15);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)&v10);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)v20);
std::string::~string(v17);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)&v13);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)v19);
std::terminate();
}
v2 = cmdline::contains(v1, (const char *)&dword_0 + 1);
lua_pushboolean(a1, v2);
return 1LL;
}
| ritegAPI_has_option:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xe0
MOV RBX,RDI
MOV ESI,0x1
XOR EDX,EDX
CALL 0x001319fa
TEST RAX,RAX
JZ 0x00111b3f
MOV RDI,RAX
CALL 0x0010dfeb
MOVZX ESI,AL
MOV RDI,RBX
CALL 0x0012fb80
MOV EAX,0x1
ADD RSP,0xe0
POP RBX
POP R14
POP R15
RET
LAB_00111b3f:
MOV RDI,qword ptr [0x001a6ff0]
LEA RSI,[0x16612d]
MOV EDX,0x1
CALL 0x0010c9e0
LEA RSI,[0x1666c8]
LEA RBX,[RSP + 0x90]
MOV RDI,RBX
MOV EDX,0x2
CALL 0x0010e126
LAB_00111b73:
LEA RDI,[RSP + 0x28]
MOV RSI,RBX
CALL 0x0010e1ae
MOV RSI,qword ptr [RSP + 0x28]
LEA R14,[RSP + 0x10]
MOV qword ptr [R14 + -0x10],R14
MOV RDX,qword ptr [RSP + 0x30]
ADD RDX,RSI
LAB_00111b96:
MOV RDI,RSP
CALL 0x0010e36e
MOV RSI,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x8]
LAB_00111ba7:
MOV RDI,qword ptr [0x001a6ff0]
CALL 0x0010c9e0
MOV RBX,RAX
LEA RSI,[0x18d40b]
MOV EDX,0x1
MOV RDI,RAX
CALL 0x0010c9e0
MOV RDI,RBX
MOV ESI,0x13
CALL 0x0010ceb0
MOV RBX,RAX
LEA RSI,[0x16612f]
MOV EDX,0x3
MOV RDI,RAX
CALL 0x0010c9e0
LEA RSI,[0x166133]
MOV EDX,0x15
MOV RDI,RBX
CALL 0x0010c9e0
LEA RSI,[0x16633e]
MOV EDX,0x12
MOV RDI,RBX
CALL 0x0010c9e0
LEA RSI,[0x1661a0]
MOV EDX,0x11
MOV RDI,RBX
CALL 0x0010c9e0
MOV RDI,RBX
CALL 0x0010c3f0
LAB_00111c32:
MOV RDI,qword ptr [RSP]
CMP RDI,R14
JZ 0x00111c48
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x0010c8d0
LAB_00111c48:
LEA RDI,[RSP + 0x28]
CALL 0x0010e222
LEA RDI,[RSP + 0x90]
CALL 0x0010e222
MOV RDI,qword ptr [0x001a6ff0]
LEA RSI,[0x16612d]
MOV EDX,0x1
CALL 0x0010c9e0
LEA RSI,[0x1666c8]
LEA RBX,[RSP + 0x90]
MOV RDI,RBX
MOV EDX,0x2
CALL 0x0010e126
LAB_00111c93:
LEA RDI,[RSP + 0x28]
MOV RSI,RBX
CALL 0x0010e1ae
MOV RSI,qword ptr [RSP + 0x28]
LEA R14,[RSP + 0x80]
MOV qword ptr [R14 + -0x10],R14
MOV RDX,qword ptr [RSP + 0x30]
ADD RDX,RSI
LAB_00111cb9:
LEA RDI,[RSP + 0x70]
CALL 0x0010e36e
MOV RSI,qword ptr [RSP + 0x70]
MOV RDX,qword ptr [RSP + 0x78]
LAB_00111ccd:
MOV RDI,qword ptr [0x001a6ff0]
CALL 0x0010c9e0
MOV RBX,RAX
LEA RSI,[0x18d40b]
MOV EDX,0x1
MOV RDI,RAX
CALL 0x0010c9e0
MOV RDI,RBX
MOV ESI,0x13
CALL 0x0010ceb0
MOV RBX,RAX
LEA RSI,[0x16612f]
MOV EDX,0x3
MOV RDI,RAX
CALL 0x0010c9e0
LEA RSI,[0x166133]
MOV EDX,0x15
MOV RDI,RBX
CALL 0x0010c9e0
LAB_00111d28:
LEA RSI,[0x1666c8]
LEA RDI,[RSP + 0xb8]
MOV EDX,0x2
CALL 0x0010e126
LAB_00111d41:
MOV RDI,RSP
LEA RSI,[RSP + 0xb8]
CALL 0x0010e1ae
MOV RSI,qword ptr [RSP]
LEA R15,[RSP + 0x60]
MOV qword ptr [R15 + -0x10],R15
MOV RDX,qword ptr [RSP + 0x8]
ADD RDX,RSI
LAB_00111d66:
LEA RDI,[RSP + 0x50]
CALL 0x0010e36e
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x58]
LAB_00111d7a:
MOV RDI,RBX
CALL 0x0010c9e0
MOV RBX,RAX
LEA RSI,[0x18d40b]
MOV EDX,0x1
MOV RDI,RAX
CALL 0x0010c9e0
MOV RDI,RBX
MOV ESI,0x13
CALL 0x0010ceb0
MOV RDI,RAX
CALL 0x0010c3f0
LAB_00111dae:
LEA RDI,[RSP + 0x50]
CALL 0x0010c3b0
MOV RDI,RSP
CALL 0x0010e222
LEA RDI,[RSP + 0xb8]
CALL 0x0010e222
LEA RDI,[RSP + 0x70]
CALL 0x0010c3b0
LEA RDI,[RSP + 0x28]
CALL 0x0010e222
LEA RDI,[RSP + 0x90]
CALL 0x0010e222
CALL 0x0010c1e0
|
/* ritegAPI_has_option(lua_State*) */
int8 ritegAPI_has_option(lua_State *param_1)
{
int1 uVar1;
char *pcVar2;
ostream *poVar3;
long *local_f8;
long local_f0;
long local_e8 [3];
long local_d0;
long local_c8;
char *local_a8;
long local_a0;
char local_98 [16];
char *local_88;
long local_80;
char local_78 [16];
path local_68 [40];
path local_40 [40];
pcVar2 = (char *)luaL_checklstring(param_1,1,0);
if (pcVar2 != (char *)0x0) {
uVar1 = cmdline::contains(pcVar2);
lua_pushboolean(param_1,uVar1);
return 1;
}
std::__ostream_insert<char,std::char_traits<char>>((ostream *)PTR_cerr_001a6ff0,"[",1);
std::filesystem::__cxx11::path::path<char[74],std::filesystem::__cxx11::path>
(local_68,"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/riteg/project.cc",2)
;
/* try { // try from 00111b73 to 00111b7f has its CatchHandler @ 00111e75 */
std::filesystem::__cxx11::path::filename();
local_f8 = local_e8;
/* try { // try from 00111b96 to 00111b9d has its CatchHandler @ 00111e66 */
std::__cxx11::string::_M_construct<char_const*>(&local_f8,local_d0,local_c8 + local_d0);
/* try { // try from 00111ba7 to 00111c31 has its CatchHandler @ 00111e4b */
poVar3 = std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_001a6ff0,(char *)local_f8,local_f0);
std::__ostream_insert<char,std::char_traits<char>>(poVar3,":",1);
poVar3 = (ostream *)std::ostream::operator<<(poVar3,0x13);
std::__ostream_insert<char,std::char_traits<char>>(poVar3,"]: ",3);
std::__ostream_insert<char,std::char_traits<char>>(poVar3,"\x1b[1;31;91mfatal:\x1b[0m ",0x15);
std::__ostream_insert<char,std::char_traits<char>>(poVar3,"assertion failed: ",0x12);
std::__ostream_insert<char,std::char_traits<char>>(poVar3,"option != nullptr",0x11);
std::endl<char,std::char_traits<char>>(poVar3);
if (local_f8 != local_e8) {
operator_delete(local_f8,local_e8[0] + 1);
}
std::filesystem::__cxx11::path::~path((path *)&local_d0);
std::filesystem::__cxx11::path::~path(local_68);
std::__ostream_insert<char,std::char_traits<char>>((ostream *)PTR_cerr_001a6ff0,"[",1);
std::filesystem::__cxx11::path::path<char[74],std::filesystem::__cxx11::path>
(local_68,"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/riteg/project.cc",2)
;
/* try { // try from 00111c93 to 00111c9f has its CatchHandler @ 00111e49 */
std::filesystem::__cxx11::path::filename();
local_88 = local_78;
/* try { // try from 00111cb9 to 00111cc2 has its CatchHandler @ 00111e47 */
std::__cxx11::string::_M_construct<char_const*>(&local_88,local_d0,local_c8 + local_d0);
/* try { // try from 00111ccd to 00111d27 has its CatchHandler @ 00111e30 */
poVar3 = std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_001a6ff0,local_88,local_80);
std::__ostream_insert<char,std::char_traits<char>>(poVar3,":",1);
poVar3 = (ostream *)std::ostream::operator<<(poVar3,0x13);
std::__ostream_insert<char,std::char_traits<char>>(poVar3,"]: ",3);
std::__ostream_insert<char,std::char_traits<char>>(poVar3,"\x1b[1;31;91mfatal:\x1b[0m ",0x15);
/* try { // try from 00111d28 to 00111d40 has its CatchHandler @ 00111e2e */
std::filesystem::__cxx11::path::path<char[74],std::filesystem::__cxx11::path>
(local_40,"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/riteg/project.cc",2)
;
/* try { // try from 00111d41 to 00111d50 has its CatchHandler @ 00111e1c */
std::filesystem::__cxx11::path::filename();
local_a8 = local_98;
/* try { // try from 00111d66 to 00111d6f has its CatchHandler @ 00111e0f */
std::__cxx11::string::_M_construct<char_const*>(&local_a8,local_f8,(long)local_f8 + local_f0);
/* try { // try from 00111d7a to 00111dad has its CatchHandler @ 00111df3 */
poVar3 = std::__ostream_insert<char,std::char_traits<char>>(poVar3,local_a8,local_a0);
std::__ostream_insert<char,std::char_traits<char>>(poVar3,":",1);
poVar3 = (ostream *)std::ostream::operator<<(poVar3,0x13);
std::endl<char,std::char_traits<char>>(poVar3);
std::__cxx11::string::~string((string *)&local_a8);
std::filesystem::__cxx11::path::~path((path *)&local_f8);
std::filesystem::__cxx11::path::~path(local_40);
std::__cxx11::string::~string((string *)&local_88);
std::filesystem::__cxx11::path::~path((path *)&local_d0);
std::filesystem::__cxx11::path::~path(local_68);
/* WARNING: Subroutine does not return */
std::terminate();
}
| |
42,890 | 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);
} | O0 | c | init_default_directories:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl $0x40, %esi
callq 0x96e00
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x835eb
jmp 0x835de
movq $0x0, -0x8(%rbp)
jmp 0x836df
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2a1f0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x7b48c(%rip), %rsi # 0xfea96
callq 0x852f0
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x7b478(%rip), %rsi # 0xfea9c
callq 0x852f0
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
leaq 0x7b472(%rip), %rdi # 0xfeaa8
callq 0x2a4f0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x8365e
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x852f0
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x8368d
leaq 0x7b450(%rip), %rdi # 0xfeab5
callq 0x2a4f0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x8368b
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x852f0
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x8368d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x79093(%rip), %rsi # 0xfc72f
callq 0x852f0
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x7b40a(%rip), %rsi # 0xfeac0
callq 0x852f0
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x836cf
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x836d7
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| init_default_directories:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_24], 0
mov rdi, [rbp+var_10]
mov esi, 40h ; '@'
call alloc_root
mov [rbp+var_18], rax
cmp [rbp+var_18], 0
jnz short loc_835EB
jmp short $+2
loc_835DE:
mov [rbp+var_8], 0
jmp loc_836DF
loc_835EB:
mov rdi, [rbp+var_18]
xor esi, esi
mov edx, 40h ; '@'
call _memset
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
lea rsi, aEtc; "/etc/"
call add_directory
add eax, [rbp+var_24]
mov [rbp+var_24], eax
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
lea rsi, aEtcMysql; "/etc/mysql/"
call add_directory
add eax, [rbp+var_24]
mov [rbp+var_24], eax
lea rdi, aMariadbHome; "MARIADB_HOME"
call _getenv
mov [rbp+var_20], rax
cmp rax, 0
jz short loc_8365E
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_18]
call add_directory
add eax, [rbp+var_24]
mov [rbp+var_24], eax
jmp short loc_8368D
loc_8365E:
lea rdi, aMysqlHome; "MYSQL_HOME"
call _getenv
mov [rbp+var_20], rax
cmp rax, 0
jz short loc_8368B
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_18]
call add_directory
add eax, [rbp+var_24]
mov [rbp+var_24], eax
loc_8368B:
jmp short $+2
loc_8368D:
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
lea rsi, aTotalKeyblocks+30h; ""
call add_directory
add eax, [rbp+var_24]
mov [rbp+var_24], eax
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
lea rsi, asc_FEAC0; "~/"
call add_directory
add eax, [rbp+var_24]
mov [rbp+var_24], eax
cmp [rbp+var_24], 0
jle short loc_836CF
xor eax, eax
mov [rbp+var_30], rax
jmp short loc_836D7
loc_836CF:
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
loc_836D7:
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
loc_836DF:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| long long init_default_directories(long long a1)
{
int v3; // [rsp+Ch] [rbp-24h]
int v4; // [rsp+Ch] [rbp-24h]
int v5; // [rsp+Ch] [rbp-24h]
long long v6; // [rsp+10h] [rbp-20h]
long long v7; // [rsp+18h] [rbp-18h]
v7 = alloc_root(a1, 64LL);
if ( !v7 )
return 0LL;
memset(v7, 0LL, 64LL);
v3 = add_directory(a1, "/etc/", v7);
v4 = v3 + add_directory(a1, "/etc/mysql/", v7);
v6 = getenv("MARIADB_HOME");
if ( v6 || (v6 = getenv("MYSQL_HOME")) != 0 )
v4 += add_directory(a1, v6, v7);
v5 = v4 + add_directory(a1, "", v7);
if ( (int)(v5 + add_directory(a1, "~/", v7)) <= 0 )
return v7;
else
return 0LL;
}
| init_default_directories:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x24],0x0
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x40
CALL 0x00196e00
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x001835eb
JMP 0x001835de
LAB_001835de:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001836df
LAB_001835eb:
MOV RDI,qword ptr [RBP + -0x18]
XOR ESI,ESI
MOV EDX,0x40
CALL 0x0012a1f0
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
LEA RSI,[0x1fea96]
CALL 0x001852f0
ADD EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x24],EAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
LEA RSI,[0x1fea9c]
CALL 0x001852f0
ADD EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x24],EAX
LEA RDI,[0x1feaa8]
CALL 0x0012a4f0
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JZ 0x0018365e
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x001852f0
ADD EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x24],EAX
JMP 0x0018368d
LAB_0018365e:
LEA RDI,[0x1feab5]
CALL 0x0012a4f0
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JZ 0x0018368b
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x001852f0
ADD EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x24],EAX
LAB_0018368b:
JMP 0x0018368d
LAB_0018368d:
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
LEA RSI,[0x1fc72f]
CALL 0x001852f0
ADD EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x24],EAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
LEA RSI,[0x1feac0]
CALL 0x001852f0
ADD EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x24],EAX
CMP dword ptr [RBP + -0x24],0x0
JLE 0x001836cf
XOR EAX,EAX
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001836d7
LAB_001836cf:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
LAB_001836d7:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
LAB_001836df:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
void * init_default_directories(int8 param_1)
{
int iVar1;
int iVar2;
char *pcVar3;
void *local_38;
int local_2c;
void *local_10;
local_38 = (void *)alloc_root(param_1);
if (local_38 == (void *)0x0) {
local_10 = (void *)0x0;
}
else {
memset(local_38,0,0x40);
iVar1 = add_directory(param_1,"/etc/",local_38);
local_2c = add_directory(param_1,"/etc/mysql/",local_38);
local_2c = local_2c + iVar1;
pcVar3 = getenv("MARIADB_HOME");
if (pcVar3 == (char *)0x0) {
pcVar3 = getenv("MYSQL_HOME");
if (pcVar3 != (char *)0x0) {
iVar1 = add_directory(param_1,pcVar3,local_38);
local_2c = iVar1 + local_2c;
}
}
else {
iVar1 = add_directory(param_1,pcVar3,local_38);
local_2c = iVar1 + local_2c;
}
iVar1 = add_directory(param_1,"",local_38);
iVar2 = add_directory(param_1,&DAT_001feac0,local_38);
if (0 < iVar2 + iVar1 + local_2c) {
local_38 = (void *)0x0;
}
local_10 = local_38;
}
return local_10;
}
| |
42,891 | my_realpath | eloqsql/mysys/my_symlink.c | int my_realpath(char *to, const char *filename, myf MyFlags)
{
#if defined(HAVE_REALPATH) && !defined(HAVE_BROKEN_REALPATH)
int result=0;
char buff[BUFF_LEN];
char *ptr;
DBUG_ENTER("my_realpath");
DBUG_PRINT("info",("executing realpath"));
if ((ptr=realpath(filename,buff)))
strmake(to, ptr, FN_REFLEN-1);
else
{
/*
Realpath didn't work; Use my_load_path() which is a poor substitute
original name but will at least be able to resolve paths that starts
with '.'.
*/
if (MyFlags)
DBUG_PRINT("error",("realpath failed with errno: %d", errno));
my_errno=errno;
if (MyFlags & MY_WME)
my_error(EE_REALPATH, MYF(0), filename, my_errno);
my_load_path(to, filename, NullS);
if (my_errno == ENOENT)
result= 1;
else
result= -1;
}
DBUG_RETURN(result);
#elif defined(_WIN32)
int ret= GetFullPathName(filename,FN_REFLEN, to, NULL);
if (ret == 0 || ret > FN_REFLEN)
{
my_errno= (ret > FN_REFLEN) ? ENAMETOOLONG : GetLastError();
if (MyFlags & MY_WME)
my_error(EE_REALPATH, MYF(0), filename, my_errno);
/*
GetFullPathName didn't work : use my_load_path() which is a poor
substitute original name but will at least be able to resolve
paths that starts with '.'.
*/
my_load_path(to, filename, NullS);
return -1;
}
#else
my_load_path(to, filename, NullS);
#endif
return 0;
} | O0 | c | my_realpath:
pushq %rbp
movq %rsp, %rbp
subq $0x1060, %rsp # imm = 0x1060
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x1020(%rbp)
movq %rsi, -0x1028(%rbp)
movq %rdx, -0x1030(%rbp)
movl $0x0, -0x1034(%rbp)
jmp 0x36269
movq -0x1028(%rbp), %rdi
leaq -0x1010(%rbp), %rsi
callq 0x240e0
movq %rax, -0x1040(%rbp)
cmpq $0x0, %rax
je 0x362a6
movq -0x1020(%rbp), %rdi
movq -0x1040(%rbp), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x7de10
jmp 0x36346
cmpq $0x0, -0x1030(%rbp)
je 0x362b6
jmp 0x362b2
jmp 0x362b4
jmp 0x362b6
callq 0x24050
movl (%rax), %eax
movl %eax, -0x1044(%rbp)
callq 0x26810
movl -0x1044(%rbp), %ecx
movl %ecx, (%rax)
movq -0x1030(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0x3630d
movq -0x1028(%rbp), %rax
movq %rax, -0x1050(%rbp)
callq 0x26810
movq -0x1050(%rbp), %rdx
movl (%rax), %ecx
movl $0x1a, %edi
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x34540
movq -0x1020(%rbp), %rdi
movq -0x1028(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x38530
callq 0x26810
cmpl $0x2, (%rax)
jne 0x3633a
movl $0x1, -0x1034(%rbp)
jmp 0x36344
movl $0xffffffff, -0x1034(%rbp) # imm = 0xFFFFFFFF
jmp 0x36346
jmp 0x36348
movl -0x1034(%rbp), %eax
movl %eax, -0x1014(%rbp)
movl -0x1014(%rbp), %eax
movl %eax, -0x1054(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x36381
movl -0x1054(%rbp), %eax
addq $0x1060, %rsp # imm = 0x1060
popq %rbp
retq
callq 0x242e0
nopw %cs:(%rax,%rax)
| my_realpath:
push rbp
mov rbp, rsp
sub rsp, 1060h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_1020], rdi
mov [rbp+var_1028], rsi
mov [rbp+var_1030], rdx
mov [rbp+var_1034], 0
jmp short $+2
loc_36269:
mov rdi, [rbp+var_1028]
lea rsi, [rbp+var_1010]
call _realpath
mov [rbp+var_1040], rax
cmp rax, 0
jz short loc_362A6
mov rdi, [rbp+var_1020]
mov rsi, [rbp+var_1040]
mov edx, 1FFh
call strmake
jmp loc_36346
loc_362A6:
cmp [rbp+var_1030], 0
jz short loc_362B6
jmp short $+2
loc_362B2:
jmp short $+2
loc_362B4:
jmp short $+2
loc_362B6:
call ___errno_location
mov eax, [rax]
mov [rbp+var_1044], eax
call _my_thread_var
mov ecx, [rbp+var_1044]
mov [rax], ecx
mov rax, [rbp+var_1030]
and rax, 10h
cmp rax, 0
jz short loc_3630D
mov rax, [rbp+var_1028]
mov [rbp+var_1050], rax
call _my_thread_var
mov rdx, [rbp+var_1050]
mov ecx, [rax]
mov edi, 1Ah
xor eax, eax
mov esi, eax
mov al, 0
call my_error
loc_3630D:
mov rdi, [rbp+var_1020]
mov rsi, [rbp+var_1028]
xor eax, eax
mov edx, eax
call my_load_path
call _my_thread_var
cmp dword ptr [rax], 2
jnz short loc_3633A
mov [rbp+var_1034], 1
jmp short loc_36344
loc_3633A:
mov [rbp+var_1034], 0FFFFFFFFh
loc_36344:
jmp short $+2
loc_36346:
jmp short $+2
loc_36348:
mov eax, [rbp+var_1034]
mov [rbp+var_1014], eax
mov eax, [rbp+var_1014]
mov [rbp+var_1054], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_36381
mov eax, [rbp+var_1054]
add rsp, 1060h
pop rbp
retn
loc_36381:
call ___stack_chk_fail
| long long my_realpath(long long a1, long long a2, char a3)
{
unsigned int *v3; // rax
long long v5; // [rsp+1Ch] [rbp-1044h]
long long v6; // [rsp+20h] [rbp-1040h]
unsigned int v7; // [rsp+2Ch] [rbp-1034h]
_BYTE v9[4104]; // [rsp+50h] [rbp-1010h] BYREF
unsigned long long v10; // [rsp+1058h] [rbp-8h]
v10 = __readfsqword(0x28u);
v7 = 0;
v6 = realpath(a2, v9);
if ( v6 )
{
strmake(a1, v6, 511LL);
}
else
{
v5 = *(unsigned int *)__errno_location();
*(_DWORD *)my_thread_var() = v5;
if ( (a3 & 0x10) != 0 )
{
v3 = (unsigned int *)my_thread_var();
my_error(0x1Au, 0LL, a2, *v3);
}
my_load_path(a1, a2, 0LL);
if ( *(_DWORD *)my_thread_var() == 2 )
return 1;
else
return (unsigned int)-1;
}
return v7;
}
| my_realpath:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1060
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x1020],RDI
MOV qword ptr [RBP + -0x1028],RSI
MOV qword ptr [RBP + -0x1030],RDX
MOV dword ptr [RBP + -0x1034],0x0
JMP 0x00136269
LAB_00136269:
MOV RDI,qword ptr [RBP + -0x1028]
LEA RSI,[RBP + -0x1010]
CALL 0x001240e0
MOV qword ptr [RBP + -0x1040],RAX
CMP RAX,0x0
JZ 0x001362a6
MOV RDI,qword ptr [RBP + -0x1020]
MOV RSI,qword ptr [RBP + -0x1040]
MOV EDX,0x1ff
CALL 0x0017de10
JMP 0x00136346
LAB_001362a6:
CMP qword ptr [RBP + -0x1030],0x0
JZ 0x001362b6
JMP 0x001362b2
LAB_001362b2:
JMP 0x001362b4
LAB_001362b4:
JMP 0x001362b6
LAB_001362b6:
CALL 0x00124050
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x1044],EAX
CALL 0x00126810
MOV ECX,dword ptr [RBP + -0x1044]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x1030]
AND RAX,0x10
CMP RAX,0x0
JZ 0x0013630d
MOV RAX,qword ptr [RBP + -0x1028]
MOV qword ptr [RBP + -0x1050],RAX
CALL 0x00126810
MOV RDX,qword ptr [RBP + -0x1050]
MOV ECX,dword ptr [RAX]
MOV EDI,0x1a
XOR EAX,EAX
MOV ESI,EAX
MOV AL,0x0
CALL 0x00134540
LAB_0013630d:
MOV RDI,qword ptr [RBP + -0x1020]
MOV RSI,qword ptr [RBP + -0x1028]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x00138530
CALL 0x00126810
CMP dword ptr [RAX],0x2
JNZ 0x0013633a
MOV dword ptr [RBP + -0x1034],0x1
JMP 0x00136344
LAB_0013633a:
MOV dword ptr [RBP + -0x1034],0xffffffff
LAB_00136344:
JMP 0x00136346
LAB_00136346:
JMP 0x00136348
LAB_00136348:
MOV EAX,dword ptr [RBP + -0x1034]
MOV dword ptr [RBP + -0x1014],EAX
MOV EAX,dword ptr [RBP + -0x1014]
MOV dword ptr [RBP + -0x1054],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00136381
MOV EAX,dword ptr [RBP + -0x1054]
ADD RSP,0x1060
POP RBP
RET
LAB_00136381:
CALL 0x001242e0
|
int4 my_realpath(int8 param_1,char *param_2,ulong param_3)
{
int iVar1;
char *pcVar2;
int *piVar3;
int4 *puVar4;
long in_FS_OFFSET;
int4 local_103c;
char local_1018 [4104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_103c = 0;
pcVar2 = realpath(param_2,local_1018);
if (pcVar2 == (char *)0x0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar3 = (int *)_my_thread_var();
*piVar3 = iVar1;
if ((param_3 & 0x10) != 0) {
puVar4 = (int4 *)_my_thread_var();
my_error(0x1a,0,param_2,*puVar4);
}
my_load_path(param_1,param_2,0);
piVar3 = (int *)_my_thread_var();
if (*piVar3 == 2) {
local_103c = 1;
}
else {
local_103c = 0xffffffff;
}
}
else {
strmake(param_1,pcVar2,0x1ff);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_103c;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
42,892 | u32toa | bluesky950520[P]quickjs/cutils.c | size_t u32toa(char buf[minimum_length(11)], uint32_t n)
{
#ifdef USE_SINGLE_CASE_FAST /* 10% */
if (n < 10) {
buf[0] = (char)('0' + n);
buf[1] = '\0';
return 1;
}
#endif
#define TEN_POW_7 10000000
if (n >= TEN_POW_7) {
uint32_t quo = n / TEN_POW_7;
n %= TEN_POW_7;
size_t len = u7toa_shift(buf, quo);
return u07toa_shift(buf, n, len);
}
return u7toa_shift(buf, n);
} | O0 | c | u32toa:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
cmpl $0xa, 0x14(%rsp)
jae 0x1f748
movl 0x14(%rsp), %eax
addl $0x30, %eax
movb %al, %cl
movq 0x18(%rsp), %rax
movb %cl, (%rax)
movq 0x18(%rsp), %rax
movb $0x0, 0x1(%rax)
movq $0x1, 0x20(%rsp)
jmp 0x1f7b4
cmpl $0x989680, 0x14(%rsp) # imm = 0x989680
jb 0x1f7a1
movl 0x14(%rsp), %eax
movl $0x989680, %ecx # imm = 0x989680
xorl %edx, %edx
divl %ecx
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
movl $0x989680, %ecx # imm = 0x989680
xorl %edx, %edx
divl %ecx
movl %edx, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x1f7c0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x8(%rsp), %rdx
callq 0x1f8c0
movq %rax, 0x20(%rsp)
jmp 0x1f7b4
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x1f7c0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
| u32toa:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_14], esi
cmp [rsp+28h+var_14], 0Ah
jnb short loc_1F748
mov eax, [rsp+28h+var_14]
add eax, 30h ; '0'
mov cl, al
mov rax, [rsp+28h+var_10]
mov [rax], cl
mov rax, [rsp+28h+var_10]
mov byte ptr [rax+1], 0
mov [rsp+28h+var_8], 1
jmp short loc_1F7B4
loc_1F748:
cmp [rsp+28h+var_14], 989680h
jb short loc_1F7A1
mov eax, [rsp+28h+var_14]
mov ecx, 989680h
xor edx, edx
div ecx
mov [rsp+28h+var_18], eax
mov eax, [rsp+28h+var_14]
mov ecx, 989680h
xor edx, edx
div ecx
mov [rsp+28h+var_14], edx
mov rdi, [rsp+28h+var_10]
mov esi, [rsp+28h+var_18]
call u7toa_shift
mov [rsp+28h+var_20], rax
mov rdi, [rsp+28h+var_10]
mov esi, [rsp+28h+var_14]
mov rdx, [rsp+28h+var_20]
call u07toa_shift
mov [rsp+28h+var_8], rax
jmp short loc_1F7B4
loc_1F7A1:
mov rdi, [rsp+28h+var_10]
mov esi, [rsp+28h+var_14]
call u7toa_shift
mov [rsp+28h+var_8], rax
loc_1F7B4:
mov rax, [rsp+28h+var_8]
add rsp, 28h
retn
| long long u32toa(_BYTE *a1, unsigned int a2)
{
long long v3; // [rsp+8h] [rbp-20h]
if ( a2 >= 0xA )
{
if ( a2 < 0x989680 )
{
return u7toa_shift(a1, a2);
}
else
{
v3 = u7toa_shift(a1, a2 / 0x989680);
return u07toa_shift(a1, a2 % 0x989680, v3);
}
}
else
{
*a1 = a2 + 48;
a1[1] = 0;
return 1LL;
}
}
| u32toa:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV dword ptr [RSP + 0x14],ESI
CMP dword ptr [RSP + 0x14],0xa
JNC 0x0011f748
MOV EAX,dword ptr [RSP + 0x14]
ADD EAX,0x30
MOV CL,AL
MOV RAX,qword ptr [RSP + 0x18]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RSP + 0x18]
MOV byte ptr [RAX + 0x1],0x0
MOV qword ptr [RSP + 0x20],0x1
JMP 0x0011f7b4
LAB_0011f748:
CMP dword ptr [RSP + 0x14],0x989680
JC 0x0011f7a1
MOV EAX,dword ptr [RSP + 0x14]
MOV ECX,0x989680
XOR EDX,EDX
DIV ECX
MOV dword ptr [RSP + 0x10],EAX
MOV EAX,dword ptr [RSP + 0x14]
MOV ECX,0x989680
XOR EDX,EDX
DIV ECX
MOV dword ptr [RSP + 0x14],EDX
MOV RDI,qword ptr [RSP + 0x18]
MOV ESI,dword ptr [RSP + 0x10]
CALL 0x0011f7c0
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x18]
MOV ESI,dword ptr [RSP + 0x14]
MOV RDX,qword ptr [RSP + 0x8]
CALL 0x0011f8c0
MOV qword ptr [RSP + 0x20],RAX
JMP 0x0011f7b4
LAB_0011f7a1:
MOV RDI,qword ptr [RSP + 0x18]
MOV ESI,dword ptr [RSP + 0x14]
CALL 0x0011f7c0
MOV qword ptr [RSP + 0x20],RAX
LAB_0011f7b4:
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x28
RET
|
int8 u32toa(char *param_1,uint param_2)
{
int8 uVar1;
int8 local_8;
if (param_2 < 10) {
*param_1 = (char)param_2 + '0';
param_1[1] = '\0';
local_8 = 1;
}
else if (param_2 < 10000000) {
local_8 = u7toa_shift(param_1,param_2);
}
else {
uVar1 = u7toa_shift(param_1,param_2 / 10000000);
local_8 = u07toa_shift(param_1,param_2 % 10000000,uVar1);
}
return local_8;
}
| |
42,893 | u32toa | bluesky950520[P]quickjs/cutils.c | size_t u32toa(char buf[minimum_length(11)], uint32_t n)
{
#ifdef USE_SINGLE_CASE_FAST /* 10% */
if (n < 10) {
buf[0] = (char)('0' + n);
buf[1] = '\0';
return 1;
}
#endif
#define TEN_POW_7 10000000
if (n >= TEN_POW_7) {
uint32_t quo = n / TEN_POW_7;
n %= TEN_POW_7;
size_t len = u7toa_shift(buf, quo);
return u07toa_shift(buf, n, len);
}
return u7toa_shift(buf, n);
} | O1 | c | u32toa:
cmpl $0x9, %esi
ja 0x1bca2
orb $0x30, %sil
movb %sil, (%rdi)
movb $0x0, 0x1(%rdi)
movl $0x1, %eax
retq
cmpl $0x98967f, %esi # imm = 0x98967F
jbe 0x1bd0e
movl %esi, %eax
imulq $0x6b5fca6b, %rax, %rcx # imm = 0x6B5FCA6B
shrq $0x36, %rcx
imull $0x989680, %ecx, %edx # imm = 0x989680
cmpl $0x5f5e100, %esi # imm = 0x5F5E100
jb 0x1bd5a
pushq %rbx
movl $0x1, %eax
xorl %r8d, %r8d
movl $0xcccccccd, %r9d # imm = 0xCCCCCCCD
movl %ecx, %r10d
movl %ecx, %ecx
imulq %r9, %rcx
shrq $0x23, %rcx
shlq $0x8, %r8
leal (%rcx,%rcx), %r11d
leal (%r11,%r11,4), %r11d
movl %r10d, %ebx
subl %r11d, %ebx
addq %rbx, %r8
addq $0x30, %r8
incq %rax
cmpl $0x63, %r10d
ja 0x1bcd8
shlq $0x8, %r8
popq %rbx
jmp 0x1bd62
movl $0x1, %eax
xorl %ecx, %ecx
movl $0xcccccccd, %edx # imm = 0xCCCCCCCD
movl %esi, %r8d
movl %esi, %esi
imulq %rdx, %rsi
shrq $0x23, %rsi
shlq $0x8, %rcx
leal (%rsi,%rsi), %r9d
leal (%r9,%r9,4), %r9d
movl %r8d, %r10d
subl %r9d, %r10d
addq %r10, %rcx
addq $0x30, %rcx
incq %rax
cmpl $0x63, %r8d
ja 0x1bd1a
shlq $0x8, %rcx
movl %esi, %edx
addq %rdx, %rcx
addq $0x30, %rcx
movq %rcx, (%rdi)
retq
movl $0x1, %eax
xorl %r8d, %r8d
subl %edx, %esi
movl %ecx, %ecx
addq %r8, %rcx
addq $0x30, %rcx
movq %rcx, (%rdi)
movb $0x0, 0x7(%rdi,%rax)
addq %rax, %rdi
movl $0x7, %ecx
movl $0xcccccccd, %edx # imm = 0xCCCCCCCD
movl %esi, %r8d
movl %esi, %esi
imulq %rdx, %rsi
shrq $0x23, %rsi
leal (%rsi,%rsi), %r9d
leal (%r9,%r9,4), %r9d
subl %r9d, %r8d
orb $0x30, %r8b
movb %r8b, -0x1(%rdi,%rcx)
decq %rcx
cmpq $0x1, %rcx
ja 0x1bd82
addb $0x30, %sil
movb %sil, (%rdi)
addq $0x7, %rax
retq
| u32toa:
cmp esi, 9
ja short loc_1BCA2
or sil, 30h
mov [rdi], sil
mov byte ptr [rdi+1], 0
mov eax, 1
retn
loc_1BCA2:
cmp esi, 98967Fh
jbe short loc_1BD0E
mov eax, esi
imul rcx, rax, 6B5FCA6Bh
shr rcx, 36h
imul edx, ecx, 989680h
cmp esi, 5F5E100h
jb loc_1BD5A
push rbx
mov eax, 1
xor r8d, r8d
mov r9d, 0CCCCCCCDh
loc_1BCD8:
mov r10d, ecx
mov ecx, ecx
imul rcx, r9
shr rcx, 23h
shl r8, 8
lea r11d, [rcx+rcx]
lea r11d, [r11+r11*4]
mov ebx, r10d
sub ebx, r11d
add r8, rbx
add r8, 30h ; '0'
inc rax
cmp r10d, 63h ; 'c'
ja short loc_1BCD8
shl r8, 8
pop rbx
jmp short loc_1BD62
loc_1BD0E:
mov eax, 1
xor ecx, ecx
mov edx, 0CCCCCCCDh
loc_1BD1A:
mov r8d, esi
mov esi, esi
imul rsi, rdx
shr rsi, 23h
shl rcx, 8
lea r9d, [rsi+rsi]
lea r9d, [r9+r9*4]
mov r10d, r8d
sub r10d, r9d
add rcx, r10
add rcx, 30h ; '0'
inc rax
cmp r8d, 63h ; 'c'
ja short loc_1BD1A
shl rcx, 8
mov edx, esi
add rcx, rdx
add rcx, 30h ; '0'
mov [rdi], rcx
retn
loc_1BD5A:
mov eax, 1
xor r8d, r8d
loc_1BD62:
sub esi, edx
mov ecx, ecx
add rcx, r8
add rcx, 30h ; '0'
mov [rdi], rcx
mov byte ptr [rdi+rax+7], 0
add rdi, rax
mov ecx, 7
mov edx, 0CCCCCCCDh
loc_1BD82:
mov r8d, esi
mov esi, esi
imul rsi, rdx
shr rsi, 23h
lea r9d, [rsi+rsi]
lea r9d, [r9+r9*4]
sub r8d, r9d
or r8b, 30h
mov [rdi+rcx-1], r8b
dec rcx
cmp rcx, 1
ja short loc_1BD82
add sil, 30h ; '0'
mov [rdi], sil
add rax, 7
retn
| long long u32toa(long long a1, unsigned int a2)
{
long long result; // rax
unsigned int v3; // ecx
long long v4; // rax
long long v5; // r8
unsigned int v6; // r10d
long long v7; // r8
long long v8; // rcx
unsigned int v9; // r8d
unsigned int v10; // esi
_BYTE *v11; // rdi
long long v12; // rcx
char v13; // r8
bool v14; // cf
if ( a2 > 9 )
{
if ( a2 <= 0x98967F )
{
result = 1LL;
v8 = 0LL;
do
{
v9 = a2;
a2 /= 0xAu;
v8 = v9 - 10 * a2 + (v8 << 8) + 48;
++result;
}
while ( v9 > 0x63 );
*(_QWORD *)a1 = a2 + (v8 << 8) + 48;
}
else
{
v3 = a2 / 0x989680;
if ( a2 < 0x5F5E100 )
{
v4 = 1LL;
v7 = 0LL;
}
else
{
v4 = 1LL;
v5 = 0LL;
do
{
v6 = v3;
v3 /= 0xAu;
v5 = v6 - 10 * v3 + (v5 << 8) + 48;
++v4;
}
while ( v6 > 0x63 );
v7 = v5 << 8;
}
v10 = a2 % 0x989680;
*(_QWORD *)a1 = v7 + v3 + 48;
*(_BYTE *)(a1 + v4 + 7) = 0;
v11 = (_BYTE *)(v4 + a1);
v12 = 7LL;
do
{
v13 = v10;
v10 /= 0xAu;
v11[v12 - 1] = (v13 - 10 * v10) | 0x30;
v14 = v12-- == 1;
}
while ( !v14 && v12 != 1 );
*v11 = v10 + 48;
return v4 + 7;
}
}
else
{
*(_BYTE *)a1 = a2 | 0x30;
*(_BYTE *)(a1 + 1) = 0;
return 1LL;
}
return result;
}
| u32toa:
CMP ESI,0x9
JA 0x0011bca2
OR SIL,0x30
MOV byte ptr [RDI],SIL
MOV byte ptr [RDI + 0x1],0x0
MOV EAX,0x1
RET
LAB_0011bca2:
CMP ESI,0x98967f
JBE 0x0011bd0e
MOV EAX,ESI
IMUL RCX,RAX,0x6b5fca6b
SHR RCX,0x36
IMUL EDX,ECX,0x989680
CMP ESI,0x5f5e100
JC 0x0011bd5a
PUSH RBX
MOV EAX,0x1
XOR R8D,R8D
MOV R9D,0xcccccccd
LAB_0011bcd8:
MOV R10D,ECX
MOV ECX,ECX
IMUL RCX,R9
SHR RCX,0x23
SHL R8,0x8
LEA R11D,[RCX + RCX*0x1]
LEA R11D,[R11 + R11*0x4]
MOV EBX,R10D
SUB EBX,R11D
ADD R8,RBX
ADD R8,0x30
INC RAX
CMP R10D,0x63
JA 0x0011bcd8
SHL R8,0x8
POP RBX
JMP 0x0011bd62
LAB_0011bd0e:
MOV EAX,0x1
XOR ECX,ECX
MOV EDX,0xcccccccd
LAB_0011bd1a:
MOV R8D,ESI
MOV ESI,ESI
IMUL RSI,RDX
SHR RSI,0x23
SHL RCX,0x8
LEA R9D,[RSI + RSI*0x1]
LEA R9D,[R9 + R9*0x4]
MOV R10D,R8D
SUB R10D,R9D
ADD RCX,R10
ADD RCX,0x30
INC RAX
CMP R8D,0x63
JA 0x0011bd1a
SHL RCX,0x8
MOV EDX,ESI
ADD RCX,RDX
ADD RCX,0x30
MOV qword ptr [RDI],RCX
RET
LAB_0011bd5a:
MOV EAX,0x1
XOR R8D,R8D
LAB_0011bd62:
SUB ESI,EDX
MOV ECX,ECX
ADD RCX,R8
ADD RCX,0x30
MOV qword ptr [RDI],RCX
MOV byte ptr [RDI + RAX*0x1 + 0x7],0x0
ADD RDI,RAX
MOV ECX,0x7
MOV EDX,0xcccccccd
LAB_0011bd82:
MOV R8D,ESI
MOV ESI,ESI
IMUL RSI,RDX
SHR RSI,0x23
LEA R9D,[RSI + RSI*0x1]
LEA R9D,[R9 + R9*0x4]
SUB R8D,R9D
OR R8B,0x30
MOV byte ptr [RDI + RCX*0x1 + -0x1],R8B
DEC RCX
CMP RCX,0x1
JA 0x0011bd82
ADD SIL,0x30
MOV byte ptr [RDI],SIL
ADD RAX,0x7
RET
|
long u32toa(byte *param_1,ulong param_2)
{
long lVar1;
uint uVar2;
uint uVar3;
ulong uVar4;
uint uVar5;
long lVar6;
uVar5 = (uint)param_2;
if (uVar5 < 10) {
*param_1 = (byte)param_2 | 0x30;
param_1[1] = 0;
return 1;
}
if (9999999 < uVar5) {
uVar4 = (param_2 & 0xffffffff) / 10000000;
uVar3 = (uint)uVar4;
if (uVar5 < 100000000) {
lVar1 = 1;
lVar6 = 0;
}
else {
lVar1 = 1;
lVar6 = 0;
do {
uVar2 = (uint)uVar4;
uVar3 = (uint)(uVar4 / 10);
lVar6 = lVar6 * 0x100 + (ulong)(uVar2 + (int)(uVar4 / 10) * -10) + 0x30;
lVar1 = lVar1 + 1;
uVar4 = uVar4 / 10;
} while (99 < uVar2);
lVar6 = lVar6 * 0x100;
}
*(ulong *)param_1 = (ulong)uVar3 + lVar6 + 0x30;
param_1[lVar1 + 7] = 0;
uVar4 = 7;
uVar5 = uVar5 + (int)((param_2 & 0xffffffff) / 10000000) * -10000000;
do {
uVar3 = uVar5 / 10;
(param_1 + lVar1)[uVar4 - 1] = (char)uVar5 + (char)(uVar5 / 10) * -10 | 0x30;
uVar4 = uVar4 - 1;
uVar5 = uVar3;
} while (1 < uVar4);
param_1[lVar1] = (char)uVar3 + 0x30;
return lVar1 + 7;
}
lVar1 = 1;
lVar6 = 0;
do {
uVar5 = (uint)param_2;
uVar4 = param_2 & 0xffffffff;
param_2 = uVar4 / 10;
lVar6 = lVar6 * 0x100 + (ulong)(uVar5 + (int)(uVar4 / 10) * -10) + 0x30;
lVar1 = lVar1 + 1;
} while (99 < uVar5);
*(ulong *)param_1 = lVar6 * 0x100 + param_2 + 0x30;
return lVar1;
}
| |
42,894 | u32toa | bluesky950520[P]quickjs/cutils.c | size_t u32toa(char buf[minimum_length(11)], uint32_t n)
{
#ifdef USE_SINGLE_CASE_FAST /* 10% */
if (n < 10) {
buf[0] = (char)('0' + n);
buf[1] = '\0';
return 1;
}
#endif
#define TEN_POW_7 10000000
if (n >= TEN_POW_7) {
uint32_t quo = n / TEN_POW_7;
n %= TEN_POW_7;
size_t len = u7toa_shift(buf, quo);
return u07toa_shift(buf, n, len);
}
return u7toa_shift(buf, n);
} | O2 | c | u32toa:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x9, %esi
ja 0x164a2
orb $0x30, %sil
movb %sil, (%rbx)
movb $0x0, 0x1(%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpl $0x989680, %esi # imm = 0x989680
jb 0x164d1
movl $0x989680, %ecx # imm = 0x989680
movl %esi, %eax
xorl %edx, %edx
divl %ecx
movl %edx, %ebp
movq %rbx, %rdi
movl %eax, %esi
callq 0x164dc
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x16515
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x164dc
| u32toa:
push rbp
push rbx
push rax
mov rbx, rdi
cmp esi, 9
ja short loc_164A2
or sil, 30h
mov [rbx], sil
mov byte ptr [rbx+1], 0
push 1
pop rax
add rsp, 8
pop rbx
pop rbp
retn
loc_164A2:
cmp esi, 989680h
jb short loc_164D1
mov ecx, 989680h
mov eax, esi
xor edx, edx
div ecx
mov ebp, edx
mov rdi, rbx
mov esi, eax
call u7toa_shift
mov rdi, rbx
mov esi, ebp
mov rdx, rax
add rsp, 8
pop rbx
pop rbp
jmp short u07toa_shift
loc_164D1:
mov rdi, rbx
add rsp, 8
pop rbx
pop rbp
jmp short $+2
| long long u32toa(_BYTE *a1, unsigned int a2)
{
long long v3; // rax
if ( a2 > 9 )
{
if ( a2 < 0x989680 )
{
return u7toa_shift(a1);
}
else
{
v3 = u7toa_shift(a1);
return u07toa_shift(a1, a2 % 0x989680, v3);
}
}
else
{
*a1 = a2 | 0x30;
a1[1] = 0;
return 1LL;
}
}
| u32toa:
PUSH RBP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CMP ESI,0x9
JA 0x001164a2
OR SIL,0x30
MOV byte ptr [RBX],SIL
MOV byte ptr [RBX + 0x1],0x0
PUSH 0x1
POP RAX
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001164a2:
CMP ESI,0x989680
JC 0x001164d1
MOV ECX,0x989680
MOV EAX,ESI
XOR EDX,EDX
DIV ECX
MOV EBP,EDX
MOV RDI,RBX
MOV ESI,EAX
CALL 0x001164dc
MOV RDI,RBX
MOV ESI,EBP
MOV RDX,RAX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x00116515
LAB_001164d1:
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x001164dc
|
int8 u32toa(byte *param_1,uint param_2)
{
int8 uVar1;
if (param_2 < 10) {
*param_1 = (byte)param_2 | 0x30;
param_1[1] = 0;
return 1;
}
if (9999999 < param_2) {
uVar1 = u7toa_shift(param_1,(ulong)param_2 / 10000000);
uVar1 = u07toa_shift(param_1,(ulong)param_2 % 10000000,uVar1);
return uVar1;
}
uVar1 = u7toa_shift(param_1);
return uVar1;
}
| |
42,895 | asio::detail::io_object_impl<asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock, asio::wait_traits<std::chrono::_V2::system_clock>>>, asio::any_io_executor>::io_object_impl<asio::io_context>(int, int, asio::io_context&) | aimrt_mujoco_sim/_deps/asio-src/asio/include/asio/detail/io_object_impl.hpp | explicit io_object_impl(int, int, ExecutionContext& context)
: service_(&asio::use_service<IoObjectService>(context)),
executor_(context.get_executor())
{
service_->construct(implementation_);
} | O0 | cpp | asio::detail::io_object_impl<asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock, asio::wait_traits<std::chrono::_V2::system_clock>>>, asio::any_io_executor>::io_object_impl<asio::io_context>(int, int, asio::io_context&):
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl %edx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0x199390
movq 0x10(%rsp), %rdi
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x8(%rsp)
callq 0x1924a0
movq 0x10(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x1a6200
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
xorl %edx, %edx
callq 0x18bfb0
jmp 0x2e8f05
leaq 0x38(%rsp), %rdi
callq 0x190cf0
movq 0x10(%rsp), %rsi
movq (%rsi), %rdi
addq $0x8, %rsi
callq 0x194750
jmp 0x2e8f22
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x190cf0
jmp 0x2e8f59
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x196c60
movq 0x8(%rsp), %rdi
callq 0x19aa10
movq 0x30(%rsp), %rdi
callq 0x198ce0
nopl (%rax)
| _ZN4asio6detail14io_object_implINS0_22deadline_timer_serviceINS0_18chrono_time_traitsINSt6chrono3_V212system_clockENS_11wait_traitsIS6_EEEEEENS_15any_io_executorEEC2INS_10io_contextEEEiiRT_:
sub rsp, 58h
mov [rsp+58h+var_8], rdi
mov [rsp+58h+var_C], esi
mov [rsp+58h+var_10], edx
mov [rsp+58h+var_18], rcx
mov rax, [rsp+58h+var_8]
mov [rsp+58h+var_48], rax; __int64
mov rdi, [rsp+58h+var_18]
call __ZN4asio11use_serviceINS_6detail22deadline_timer_serviceINS1_18chrono_time_traitsINSt6chrono3_V212system_clockENS_11wait_traitsIS6_EEEEEEEERT_RNS_10io_contextE; asio::use_service<asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,asio::wait_traits<std::chrono::_V2::system_clock>>>>(asio::io_context &)
mov rdi, [rsp+58h+var_48]
mov [rdi], rax
add rdi, 8; int
mov qword ptr [rsp+58h+var_50], rdi; int
call __ZN4asio6detail22deadline_timer_serviceINS0_18chrono_time_traitsINSt6chrono3_V212system_clockENS_11wait_traitsIS5_EEEEE19implementation_typeC2Ev; asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,asio::wait_traits<std::chrono::_V2::system_clock>>>::implementation_type::implementation_type(void)
mov rax, [rsp+58h+var_48]
add rax, 40h ; '@'
mov [rsp+58h+var_40], rax
mov rsi, [rsp+58h+var_18]
lea rdi, [rsp+58h+var_20]; this
mov [rsp+58h+var_38], rdi
call __ZN4asio10io_context12get_executorEv; asio::io_context::get_executor(void)
mov rdi, [rsp+58h+var_40]
mov rsi, [rsp+58h+var_38]
xor edx, edx
call __ZN4asio15any_io_executorC2ITkNS_9execution8executorENS_10io_context19basic_executor_typeISaIvELm0EEEEET_NS_10constraintIXsr13conditional_tIXaantsr7is_sameIS7_S0_EE5valuentsr10is_base_ofINS2_6detail17any_executor_baseES7_EE5valueENS9_24is_valid_target_executorIS7_FvNS2_12context_as_tIRNS_17execution_contextEEENS9_8blocking7never_tILi0EEENS2_11prefer_onlyINSG_10possibly_tILi0EEEEENSJ_INS9_16outstanding_work9tracked_tILi0EEEEENSJ_INSN_11untracked_tILi0EEEEENSJ_INS9_12relationship6fork_tILi0EEEEENSJ_INSU_14continuation_tILi0EEEEEEEESt17integral_constantIbLb0EEEE5valueEiE4typeE
jmp short $+2
loc_2E8F05:
lea rdi, [rsp+58h+var_20]
call __ZN4asio10io_context19basic_executor_typeISaIvELm0EED2Ev; asio::io_context::basic_executor_type<std::allocator<void>,0ul>::~basic_executor_type()
mov rsi, [rsp+58h+var_48]
mov rdi, [rsi]
add rsi, 8
call __ZN4asio6detail22deadline_timer_serviceINS0_18chrono_time_traitsINSt6chrono3_V212system_clockENS_11wait_traitsIS5_EEEEE9constructERNS9_19implementation_typeE; asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,asio::wait_traits<std::chrono::_V2::system_clock>>>::construct(asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,asio::wait_traits<std::chrono::_V2::system_clock>>>::implementation_type &)
jmp short $+2
loc_2E8F22:
add rsp, 58h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
lea rdi, [rsp+arg_30]
call __ZN4asio10io_context19basic_executor_typeISaIvELm0EED2Ev; asio::io_context::basic_executor_type<std::allocator<void>,0ul>::~basic_executor_type()
jmp short loc_2E8F59
mov rdi, [rsp+arg_10]; this
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
call __ZN4asio15any_io_executorD2Ev; asio::any_io_executor::~any_io_executor()
loc_2E8F59:
mov rdi, [rsp+arg_0]
call __ZN4asio6detail22deadline_timer_serviceINS0_18chrono_time_traitsINSt6chrono3_V212system_clockENS_11wait_traitsIS5_EEEEE19implementation_typeD2Ev; asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,asio::wait_traits<std::chrono::_V2::system_clock>>>::implementation_type::~implementation_type()
mov rdi, [rsp+arg_28]
call __Unwind_Resume
| long long asio::detail::io_object_impl<asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,asio::wait_traits<std::chrono::_V2::system_clock>>>,asio::any_io_executor>::io_object_impl<asio::io_context>(
_QWORD *a1,
int a2,
int a3,
long long a4)
{
int v4; // edx
int v5; // ecx
int v6; // r8d
int v7; // r9d
int v8; // ecx
int v9; // r8d
int v10; // r9d
asio::detail::noncopyable *v12; // [rsp+0h] [rbp-58h]
int v13; // [rsp+0h] [rbp-58h]
int v14; // [rsp+8h] [rbp-50h]
long long v15; // [rsp+10h] [rbp-48h]
_QWORD *v16; // [rsp+10h] [rbp-48h]
_BYTE v17[8]; // [rsp+38h] [rbp-20h] BYREF
long long v18; // [rsp+40h] [rbp-18h]
int v19; // [rsp+48h] [rbp-10h]
int v20; // [rsp+4Ch] [rbp-Ch]
long long v21; // [rsp+50h] [rbp-8h]
v21 = (long long)a1;
v20 = a2;
v19 = a3;
v18 = a4;
*a1 = asio::use_service<asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,asio::wait_traits<std::chrono::_V2::system_clock>>>>(a4);
asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,asio::wait_traits<std::chrono::_V2::system_clock>>>::implementation_type::implementation_type(
(_DWORD)a1 + 8,
a2,
v4,
v5,
v6,
v7,
v12,
(_DWORD)a1 + 8,
(long long)a1);
asio::io_context::get_executor((asio::io_context *)v17);
_ZN4asio15any_io_executorC2ITkNS_9execution8executorENS_10io_context19basic_executor_typeISaIvELm0EEEEET_NS_10constraintIXsr13conditional_tIXaantsr7is_sameIS7_S0_EE5valuentsr10is_base_ofINS2_6detail17any_executor_baseES7_EE5valueENS9_24is_valid_target_executorIS7_FvNS2_12context_as_tIRNS_17execution_contextEEENS9_8blocking7never_tILi0EEENS2_11prefer_onlyINSG_10possibly_tILi0EEEEENSJ_INS9_16outstanding_work9tracked_tILi0EEEEENSJ_INSN_11untracked_tILi0EEEEENSJ_INS9_12relationship6fork_tILi0EEEEENSJ_INSU_14continuation_tILi0EEEEEEEESt17integral_constantIbLb0EEEE5valueEiE4typeE(
v15 + 64,
(unsigned int)v17,
0,
v8,
v9,
v10,
v13,
v14,
v15,
v15 + 64,
(char)v17);
asio::io_context::basic_executor_type<std::allocator<void>,0ul>::~basic_executor_type(v17);
return asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,asio::wait_traits<std::chrono::_V2::system_clock>>>::construct(
*v16,
v16 + 1);
}
| |||
42,896 | asio::detail::io_object_impl<asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock, asio::wait_traits<std::chrono::_V2::system_clock>>>, asio::any_io_executor>::io_object_impl<asio::io_context>(int, int, asio::io_context&) | aimrt_mujoco_sim/_deps/asio-src/asio/include/asio/detail/io_object_impl.hpp | explicit io_object_impl(int, int, ExecutionContext& context)
: service_(&asio::use_service<IoObjectService>(context)),
executor_(context.get_executor())
{
service_->construct(implementation_);
} | O3 | cpp | asio::detail::io_object_impl<asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock, asio::wait_traits<std::chrono::_V2::system_clock>>>, asio::any_io_executor>::io_object_impl<asio::io_context>(int, int, asio::io_context&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdi, %rbx
movq (%rcx), %rdi
movq 0x1a7515(%rip), %rax # 0x2a0a10
movq %rsp, %rsi
movq %rax, (%rsi)
xorl %r15d, %r15d
movq %r15, 0x8(%rsi)
movq 0x1a79d1(%rip), %rdx # 0x2a0ee0
callq 0x83930
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movq $-0x1, 0x28(%rbx)
movups %xmm0, 0x30(%rbx)
leaq 0x40(%rbx), %rax
movq 0x1a77ab(%rip), %rcx # 0x2a0ce0
movq %rcx, 0x68(%rbx)
movq 0x1a74a8(%rip), %rcx # 0x2a09e8
movq %rcx, 0x58(%rbx)
movq %r14, 0x40(%rbx)
movq %rax, 0x60(%rbx)
movq 0x1a7a85(%rip), %rax # 0x2a0fd8
movq %rax, 0x70(%rbx)
movq %r15, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| _ZN4asio6detail14io_object_implINS0_22deadline_timer_serviceINS0_18chrono_time_traitsINSt6chrono3_V212system_clockENS_11wait_traitsIS6_EEEEEENS_15any_io_executorEEC2INS_10io_contextEEEiiRT_:
push r15
push r14
push rbx
sub rsp, 10h
mov r14, rcx
mov rbx, rdi
mov rdi, [rcx]
mov rax, cs:_ZTIN4asio6detail14typeid_wrapperINS0_22deadline_timer_serviceINS0_18chrono_time_traitsINSt6chrono3_V212system_clockENS_11wait_traitsIS6_EEEEEEEE_ptr
mov rsi, rsp
mov [rsi], rax
xor r15d, r15d
mov [rsi+8], r15
mov rdx, cs:_ZN4asio6detail16service_registry6createINS0_22deadline_timer_serviceINS0_18chrono_time_traitsINSt6chrono3_V212system_clockENS_11wait_traitsIS7_EEEEEENS_10io_contextEEEPNS_17execution_context7serviceEPv_ptr
call __ZN4asio6detail16service_registry14do_use_serviceERKNS_17execution_context7service3keyEPFPS3_PvES8_; asio::detail::service_registry::do_use_service(asio::execution_context::service::key const&,asio::execution_context::service* (*)(void *),void *)
mov [rbx], rax
xorps xmm0, xmm0
movups xmmword ptr [rbx+18h], xmm0
mov qword ptr [rbx+28h], 0FFFFFFFFFFFFFFFFh
movups xmmword ptr [rbx+30h], xmm0
lea rax, [rbx+40h]
mov rcx, cs:_ZZN4asio9execution6detail17any_executor_base16target_fns_tableINS_10io_context19basic_executor_typeISaIvELm0EEEEEPKNS2_10target_fnsEbPNSt9enable_ifIXntsr7is_sameIT_vEE5valueEvE4typeEE16fns_with_execute_ptr
mov [rbx+68h], rcx
mov rcx, cs:_ZZN4asio9execution6detail17any_executor_base16object_fns_tableINS_10io_context19basic_executor_typeISaIvELm0EEEEEPKNS2_10object_fnsEPNSt9enable_ifIXaantsr7is_sameIT_vEE5valuentsr7is_sameISC_NS1_22shared_target_executorEEE5valueEvE4typeEE3fns_ptr
mov [rbx+58h], rcx
mov [rbx+40h], r14
mov [rbx+60h], rax
mov rax, cs:_ZZN4asio9execution12any_executorIJNS0_12context_as_tIRNS_17execution_contextEEENS0_6detail8blocking7never_tILi0EEENS0_11prefer_onlyINS7_10possibly_tILi0EEEEENSA_INS6_16outstanding_work9tracked_tILi0EEEEENSA_INSE_11untracked_tILi0EEEEENSA_INS6_12relationship6fork_tILi0EEEEENSA_INSL_14continuation_tILi0EEEEEEE14prop_fns_tableINS_10io_context19basic_executor_typeISaIvELm0EEEEEPKNS6_17any_executor_base8prop_fnsISS_EEvE3fns_ptr
mov [rbx+70h], rax
mov [rbx+8], r15
mov byte ptr [rbx+10h], 0
add rsp, 10h
pop rbx
pop r14
pop r15
retn
| long long ( ** asio::detail::io_object_impl<asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,asio::wait_traits<std::chrono::_V2::system_clock>>>,asio::any_io_executor>::io_object_impl<asio::io_context>(
long long a1,
long long a2,
long long a3,
long long *a4))()
{
long long v6; // rdi
long long ( **result)(); // rax
_QWORD v8[5]; // [rsp+0h] [rbp-28h] BYREF
v6 = *a4;
v8[0] = &`typeinfo for'asio::detail::typeid_wrapper<asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,asio::wait_traits<std::chrono::_V2::system_clock>>>>;
v8[1] = 0LL;
*(_QWORD *)a1 = asio::detail::service_registry::do_use_service(
v6,
v8,
asio::detail::service_registry::create<asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,asio::wait_traits<std::chrono::_V2::system_clock>>>,asio::io_context>);
*(_OWORD *)(a1 + 24) = 0LL;
*(_QWORD *)(a1 + 40) = -1LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_QWORD *)(a1 + 104) = ZZN4asio9execution6detail17any_executor_base16target_fns_tableINS_10io_context19basic_executor_typeISaIvELm0EEEEEPKNS2_10target_fnsEbPNSt9enable_ifIXntsr7is_sameIT_vEE5valueEvE4typeEE16fns_with_execute;
*(_QWORD *)(a1 + 88) = ZZN4asio9execution6detail17any_executor_base16object_fns_tableINS_10io_context19basic_executor_typeISaIvELm0EEEEEPKNS2_10object_fnsEPNSt9enable_ifIXaantsr7is_sameIT_vEE5valuentsr7is_sameISC_NS1_22shared_target_executorEEE5valueEvE4typeEE3fns;
*(_QWORD *)(a1 + 64) = a4;
*(_QWORD *)(a1 + 96) = a1 + 64;
result = asio::execution::any_executor<asio::execution::context_as_t<asio::execution_context &>,asio::execution::detail::blocking::never_t<0>,asio::execution::prefer_only<asio::execution::detail::blocking::possibly_t<0>>,asio::execution::prefer_only<asio::execution::detail::outstanding_work::tracked_t<0>>,asio::execution::prefer_only<asio::execution::detail::outstanding_work::untracked_t<0>>,asio::execution::prefer_only<asio::execution::detail::relationship::fork_t<0>>,asio::execution::prefer_only<asio::execution::detail::relationship::continuation_t<0>>>::prop_fns_table<asio::io_context::basic_executor_type<std::allocator<void>,0ul>>(void)::fns;
*(_QWORD *)(a1 + 112) = asio::execution::any_executor<asio::execution::context_as_t<asio::execution_context &>,asio::execution::detail::blocking::never_t<0>,asio::execution::prefer_only<asio::execution::detail::blocking::possibly_t<0>>,asio::execution::prefer_only<asio::execution::detail::outstanding_work::tracked_t<0>>,asio::execution::prefer_only<asio::execution::detail::outstanding_work::untracked_t<0>>,asio::execution::prefer_only<asio::execution::detail::relationship::fork_t<0>>,asio::execution::prefer_only<asio::execution::detail::relationship::continuation_t<0>>>::prop_fns_table<asio::io_context::basic_executor_type<std::allocator<void>,0ul>>(void)::fns;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
return result;
}
| io_object_impl<asio::io_context>:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV R14,RCX
MOV RBX,RDI
MOV RDI,qword ptr [RCX]
MOV RAX,qword ptr [0x003a0a10]
MOV RSI,RSP
MOV qword ptr [RSI],RAX
XOR R15D,R15D
MOV qword ptr [RSI + 0x8],R15
MOV RDX,qword ptr [0x003a0ee0]
CALL 0x00183930
MOV qword ptr [RBX],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x18],XMM0
MOV qword ptr [RBX + 0x28],-0x1
MOVUPS xmmword ptr [RBX + 0x30],XMM0
LEA RAX,[RBX + 0x40]
MOV RCX,qword ptr [0x003a0ce0]
MOV qword ptr [RBX + 0x68],RCX
MOV RCX,qword ptr [0x003a09e8]
MOV qword ptr [RBX + 0x58],RCX
MOV qword ptr [RBX + 0x40],R14
MOV qword ptr [RBX + 0x60],RAX
MOV RAX,qword ptr [0x003a0fd8]
MOV qword ptr [RBX + 0x70],RAX
MOV qword ptr [RBX + 0x8],R15
MOV byte ptr [RBX + 0x10],0x0
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* asio::detail::io_object_impl<asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,
asio::wait_traits<std::chrono::_V2::system_clock> > >,
asio::any_io_executor>::io_object_impl<asio::io_context>(int, int, asio::io_context&) */
void __thiscall
asio::detail::
io_object_impl<asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,asio::wait_traits<std::chrono::_V2::system_clock>>>,asio::any_io_executor>
::io_object_impl<asio::io_context>
(io_object_impl<asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,asio::wait_traits<std::chrono::_V2::system_clock>>>,asio::any_io_executor>
*this,int param_1,int param_2,io_context *param_3)
{
int8 uVar1;
int *local_28;
int8 local_20;
local_28 = PTR_typeinfo_003a0a10;
local_20 = 0;
uVar1 = service_registry::do_use_service
(*(service_registry **)param_3,(key *)&local_28,
(_func_service_ptr_void_ptr *)
PTR_create<asio_detail_deadline_timer_service<asio_detail_chrono_time_traits<std_chrono__V2_system_clock,asio_wait_traits<std_chrono__V2_system_clock>>>,asio_io_context>_003a0ee0
,param_3);
*(int8 *)this = uVar1;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0xffffffffffffffff;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int **)(this + 0x68) = PTR_fns_with_execute_003a0ce0;
*(int **)(this + 0x58) = PTR_fns_003a09e8;
*(io_context **)(this + 0x40) = param_3;
*(io_object_impl<asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,asio::wait_traits<std::chrono::_V2::system_clock>>>,asio::any_io_executor>
**)(this + 0x60) = this + 0x40;
*(int **)(this + 0x70) = PTR_fns_003a0fd8;
*(int8 *)(this + 8) = 0;
this[0x10] = (io_object_impl<asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::system_clock,asio::wait_traits<std::chrono::_V2::system_clock>>>,asio::any_io_executor>
)0x0;
return;
}
| |
42,897 | my_char_weight_put | eloqsql/strings/ctype-uca.c | static my_bool
my_char_weight_put(MY_UCA_WEIGHT_LEVEL *dst,
uint16 *to, size_t to_length, size_t *nweights,
my_wc_t *str, size_t len)
{
size_t count;
int rc= FALSE;
if (!to_length)
{
*nweights= 0;
return len > 0;
}
to_length--; /* Without trailing zero */
for (count= 0; len; )
{
size_t chlen;
const uint16 *from= NULL;
uint16 implicit_weights[3];
for (chlen= len; chlen > 1; chlen--)
{
const MY_CONTRACTION *cnt;
if (chlen <= MY_UCA_MAX_CONTRACTION &&
(cnt= my_uca_contraction_find(&dst->contractions, str, chlen)))
{
from= cnt->weight;
str+= chlen;
len-= chlen;
break;
}
}
if (!from)
{
from= my_char_weight_addr(dst, *str);
if (!from)
{
from= implicit_weights;
my_uca_implicit_weight_put(implicit_weights, *str, dst->levelno);
}
str++;
len--;
}
for ( ; from && *from && count < to_length; )
{
*to++= *from++;
count++;
}
if (count == to_length && from && * from)
rc= TRUE; /* All weights did not fit */
}
*to= 0;
*nweights= count;
return rc;
} | O3 | c | my_char_weight_put:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, -0x30(%rbp)
testq %rdx, %rdx
je 0x497cc
movq %rcx, -0x68(%rbp)
testq %r9, %r9
je 0x497db
movq %rdi, -0x60(%rbp)
decq %rdx
xorl %ecx, %ecx
xorl %r13d, %r13d
movq %rdx, -0x48(%rbp)
movq %rcx, -0x50(%rbp)
movq %rsi, -0x58(%rbp)
movq %r9, -0x40(%rbp)
cmpq $0x2, %r9
jb 0x496b0
movq -0x40(%rbp), %rbx
leaq (,%rbx,8), %r12
cmpq $0x6, %rbx
ja 0x496a3
movq -0x60(%rbp), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
jle 0x496a3
movq -0x60(%rbp), %rcx
movq 0x20(%rcx), %r15
imulq $0x58, %rax, %r14
addq %r15, %r14
leaq (,%rbx,8), %rax
movq %rax, -0x70(%rbp)
cmpq $0x6, %rbx
je 0x4967b
cmpq $0x0, (%r15,%r12)
jne 0x4969a
cmpb $0x0, 0x52(%r15)
jne 0x4969a
movq %r15, %rdi
movq -0x30(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x24360
testl %eax, %eax
je 0x49753
addq $0x58, %r15
cmpq %r14, %r15
jb 0x4966e
decq %rbx
addq $-0x8, %r12
cmpq $0x1, %rbx
ja 0x49640
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl %eax, %ecx
movq -0x60(%rbp), %rsi
cmpq %rcx, (%rsi)
jb 0x496e8
movq 0x10(%rsi), %rcx
movl %eax, %edx
shrl $0x8, %edx
movq (%rcx,%rdx,8), %rcx
testq %rcx, %rcx
je 0x496e8
movzbl %al, %eax
movq 0x8(%rsi), %rsi
movzbl (%rsi,%rdx), %edx
imull %eax, %edx
leaq (%rcx,%rdx,2), %r15
jmp 0x49739
leaq -0x3400(%rax), %rcx
leaq -0x4e00(%rax), %rdx
xorl %esi, %esi
cmpq $0x51a6, %rdx # imm = 0x51A6
setae %sil
shll $0x7, %esi
orl $0xfffffb40, %esi # imm = 0xFFFFFB40
cmpq $0x19b6, %rcx # imm = 0x19B6
movl $0xfb80, %ecx # imm = 0xFB80
cmovbl %ecx, %esi
movl %eax, %ecx
shrl $0xf, %ecx
addl %esi, %ecx
movw %cx, -0x36(%rbp)
orl $0x8000, %eax # imm = 0x8000
movw %ax, -0x34(%rbp)
movw $0x0, -0x32(%rbp)
leaq -0x36(%rbp), %r15
movq -0x58(%rbp), %rsi
movq -0x40(%rbp), %r9
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
addq $0x8, -0x30(%rbp)
decq %r9
jmp 0x49776
addq $0x30, %r15
movq -0x30(%rbp), %rax
leaq (%rax,%rbx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %r9
subq %rbx, %r9
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
movzwl (%r15), %eax
testw %ax, %ax
sete %cl
cmpq %rdx, %r13
setae %r8b
orb %cl, %r8b
jne 0x497ac
addq $0x2, %r15
movw %ax, (%rsi)
addq $0x2, %rsi
incq %r13
movzwl (%r15), %eax
testw %ax, %ax
je 0x497ac
addq $0x2, %r15
cmpq %rdx, %r13
jb 0x49790
testw %ax, %ax
movzbl %dil, %eax
movl $0x1, %ecx
cmovel %eax, %ecx
cmpq %rdx, %r13
cmovnel %eax, %ecx
testq %r9, %r9
jne 0x49622
jmp 0x497e0
movq $0x0, (%rcx)
testq %r9, %r9
setne %cl
jmp 0x497ec
xorl %r13d, %r13d
xorl %ecx, %ecx
movw $0x0, (%rsi)
movq -0x68(%rbp), %rax
movq %r13, (%rax)
movl %ecx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_char_weight_put:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov [rbp+var_30], r8
test rdx, rdx
jz loc_497CC
mov [rbp+var_68], rcx
test r9, r9
jz loc_497DB
mov [rbp+var_60], rdi
dec rdx
xor ecx, ecx
xor r13d, r13d
mov [rbp+var_48], rdx
loc_49622:
mov [rbp+var_50], rcx
mov [rbp+var_58], rsi
mov [rbp+var_40], r9
cmp r9, 2
jb short loc_496B0
mov rbx, [rbp+var_40]
lea r12, ds:0[rbx*8]
loc_49640:
cmp rbx, 6
ja short loc_496A3
mov rax, [rbp+var_60]
mov rax, [rax+18h]
test rax, rax
jle short loc_496A3
mov rcx, [rbp+var_60]
mov r15, [rcx+20h]
imul r14, rax, 58h ; 'X'
add r14, r15
lea rax, ds:0[rbx*8]
mov [rbp+var_70], rax
loc_4966E:
cmp rbx, 6
jz short loc_4967B
cmp qword ptr [r15+r12], 0
jnz short loc_4969A
loc_4967B:
cmp byte ptr [r15+52h], 0
jnz short loc_4969A
mov rdi, r15
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_70]
call _bcmp
test eax, eax
jz loc_49753
loc_4969A:
add r15, 58h ; 'X'
cmp r15, r14
jb short loc_4966E
loc_496A3:
dec rbx
add r12, 0FFFFFFFFFFFFFFF8h
cmp rbx, 1
ja short loc_49640
loc_496B0:
mov rax, [rbp+var_30]
mov rax, [rax]
mov ecx, eax
mov rsi, [rbp+var_60]
cmp [rsi], rcx
jb short loc_496E8
mov rcx, [rsi+10h]
mov edx, eax
shr edx, 8
mov rcx, [rcx+rdx*8]
test rcx, rcx
jz short loc_496E8
movzx eax, al
mov rsi, [rsi+8]
movzx edx, byte ptr [rsi+rdx]
imul edx, eax
lea r15, [rcx+rdx*2]
jmp short loc_49739
loc_496E8:
lea rcx, [rax-3400h]
lea rdx, [rax-4E00h]
xor esi, esi
cmp rdx, 51A6h
setnb sil
shl esi, 7
or esi, 0FFFFFB40h
cmp rcx, 19B6h
mov ecx, 0FB80h
cmovb esi, ecx
mov ecx, eax
shr ecx, 0Fh
add ecx, esi
mov [rbp+var_36], cx
or eax, 8000h
mov [rbp+var_34], ax
mov [rbp+var_32], 0
lea r15, [rbp+var_36]
loc_49739:
mov rsi, [rbp+var_58]
mov r9, [rbp+var_40]
mov rdi, [rbp+var_50]
mov rdx, [rbp+var_48]
add [rbp+var_30], 8
dec r9
jmp short loc_49776
loc_49753:
add r15, 30h ; '0'
mov rax, [rbp+var_30]
lea rax, [rax+rbx*8]
mov [rbp+var_30], rax
mov r9, [rbp+var_40]
sub r9, rbx
mov rsi, [rbp+var_58]
mov rdi, [rbp+var_50]
mov rdx, [rbp+var_48]
loc_49776:
movzx eax, word ptr [r15]
test ax, ax
setz cl
cmp r13, rdx
setnb r8b
or r8b, cl
jnz short loc_497AC
add r15, 2
loc_49790:
mov [rsi], ax
add rsi, 2
inc r13
movzx eax, word ptr [r15]
test ax, ax
jz short loc_497AC
add r15, 2
cmp r13, rdx
jb short loc_49790
loc_497AC:
test ax, ax
movzx eax, dil
mov ecx, 1
cmovz ecx, eax
cmp r13, rdx
cmovnz ecx, eax
test r9, r9
jnz loc_49622
jmp short loc_497E0
loc_497CC:
mov qword ptr [rcx], 0
test r9, r9
setnz cl
jmp short loc_497EC
loc_497DB:
xor r13d, r13d
xor ecx, ecx
loc_497E0:
mov word ptr [rsi], 0
mov rax, [rbp+var_68]
mov [rax], r13
loc_497EC:
mov eax, ecx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_char_weight_put(
_QWORD *a1,
_WORD *a2,
long long a3,
unsigned long long *a4,
long long *a5,
unsigned long long a6)
{
unsigned long long v6; // r13
unsigned long long v7; // rbx
long long v8; // r12
long long v9; // rax
unsigned long long v10; // r15
unsigned long long v11; // r14
long long v12; // rax
long long v13; // rdx
long long v14; // rcx
__int16 *v15; // r15
__int16 v16; // si
unsigned __int8 v17; // di
unsigned long long v18; // rdx
__int16 v19; // ax
__int16 *v20; // r15
unsigned long long *v22; // [rsp+8h] [rbp-68h]
_WORD *v24; // [rsp+18h] [rbp-58h]
unsigned __int8 v25; // [rsp+20h] [rbp-50h]
unsigned long long v26; // [rsp+28h] [rbp-48h]
unsigned long long v27; // [rsp+30h] [rbp-40h]
_WORD v28[3]; // [rsp+3Ah] [rbp-36h] BYREF
long long *v29; // [rsp+40h] [rbp-30h]
v29 = a5;
if ( a3 )
{
v22 = a4;
if ( a6 )
{
LOBYTE(a4) = 0;
v6 = 0LL;
v26 = a3 - 1;
do
{
v25 = (unsigned __int8)a4;
v24 = a2;
v27 = a6;
if ( a6 < 2 )
{
LABEL_15:
v12 = *v29;
if ( *a1 >= (unsigned long long)(unsigned int)*v29
&& (v13 = (unsigned int)v12 >> 8, (v14 = *(_QWORD *)(a1[2] + 8 * v13)) != 0) )
{
v15 = (__int16 *)(v14 + 2LL * (unsigned __int8)v12 * (unsigned int)*(unsigned __int8 *)(a1[1] + v13));
}
else
{
v16 = (((unsigned long long)(v12 - 19968) >= 0x51A6) << 7) | 0xFB40;
if ( (unsigned long long)(v12 - 13312) < 0x19B6 )
v16 = -1152;
v28[0] = v16 + ((unsigned int)v12 >> 15);
v28[1] = v12 | 0x8000;
v28[2] = 0;
v15 = v28;
}
a2 = v24;
v17 = v25;
v18 = v26;
++v29;
a6 = v27 - 1;
}
else
{
v7 = a6;
v8 = 8 * a6;
while ( 1 )
{
if ( v7 <= 6 )
{
v9 = a1[3];
if ( v9 > 0 )
break;
}
LABEL_14:
--v7;
v8 -= 8LL;
if ( v7 <= 1 )
goto LABEL_15;
}
v10 = a1[4];
v11 = v10 + 88 * v9;
while ( v7 != 6 && *(_QWORD *)(v10 + v8) || *(_BYTE *)(v10 + 82) || (unsigned int)bcmp(v10, v29, 8 * v7) )
{
v10 += 88LL;
if ( v10 >= v11 )
goto LABEL_14;
}
v15 = (__int16 *)(v10 + 48);
v29 += v7;
a6 = v27 - v7;
v17 = v25;
v18 = v26;
}
v19 = *v15;
if ( *v15 != 0 && v6 < v18 )
{
v20 = v15 + 1;
do
{
*a2++ = v19;
++v6;
v19 = *v20;
if ( !*v20 )
break;
++v20;
}
while ( v6 < v18 );
}
LODWORD(a4) = 1;
if ( !v19 )
LODWORD(a4) = v17;
if ( v6 != v18 )
LODWORD(a4) = v17;
}
while ( a6 );
}
else
{
v6 = 0LL;
LODWORD(a4) = 0;
}
*a2 = 0;
*v22 = v6;
}
else
{
*a4 = 0LL;
LOBYTE(a4) = a6 != 0;
}
return (unsigned int)a4;
}
| my_char_weight_put:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x30],R8
TEST RDX,RDX
JZ 0x001497cc
MOV qword ptr [RBP + -0x68],RCX
TEST R9,R9
JZ 0x001497db
MOV qword ptr [RBP + -0x60],RDI
DEC RDX
XOR ECX,ECX
XOR R13D,R13D
MOV qword ptr [RBP + -0x48],RDX
LAB_00149622:
MOV qword ptr [RBP + -0x50],RCX
MOV qword ptr [RBP + -0x58],RSI
MOV qword ptr [RBP + -0x40],R9
CMP R9,0x2
JC 0x001496b0
MOV RBX,qword ptr [RBP + -0x40]
LEA R12,[RBX*0x8]
LAB_00149640:
CMP RBX,0x6
JA 0x001496a3
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x18]
TEST RAX,RAX
JLE 0x001496a3
MOV RCX,qword ptr [RBP + -0x60]
MOV R15,qword ptr [RCX + 0x20]
IMUL R14,RAX,0x58
ADD R14,R15
LEA RAX,[RBX*0x8]
MOV qword ptr [RBP + -0x70],RAX
LAB_0014966e:
CMP RBX,0x6
JZ 0x0014967b
CMP qword ptr [R15 + R12*0x1],0x0
JNZ 0x0014969a
LAB_0014967b:
CMP byte ptr [R15 + 0x52],0x0
JNZ 0x0014969a
MOV RDI,R15
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x70]
CALL 0x00124360
TEST EAX,EAX
JZ 0x00149753
LAB_0014969a:
ADD R15,0x58
CMP R15,R14
JC 0x0014966e
LAB_001496a3:
DEC RBX
ADD R12,-0x8
CMP RBX,0x1
JA 0x00149640
LAB_001496b0:
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV ECX,EAX
MOV RSI,qword ptr [RBP + -0x60]
CMP qword ptr [RSI],RCX
JC 0x001496e8
MOV RCX,qword ptr [RSI + 0x10]
MOV EDX,EAX
SHR EDX,0x8
MOV RCX,qword ptr [RCX + RDX*0x8]
TEST RCX,RCX
JZ 0x001496e8
MOVZX EAX,AL
MOV RSI,qword ptr [RSI + 0x8]
MOVZX EDX,byte ptr [RSI + RDX*0x1]
IMUL EDX,EAX
LEA R15,[RCX + RDX*0x2]
JMP 0x00149739
LAB_001496e8:
LEA RCX,[RAX + -0x3400]
LEA RDX,[RAX + -0x4e00]
XOR ESI,ESI
CMP RDX,0x51a6
SETNC SIL
SHL ESI,0x7
OR ESI,0xfffffb40
CMP RCX,0x19b6
MOV ECX,0xfb80
CMOVC ESI,ECX
MOV ECX,EAX
SHR ECX,0xf
ADD ECX,ESI
MOV word ptr [RBP + -0x36],CX
OR EAX,0x8000
MOV word ptr [RBP + -0x34],AX
MOV word ptr [RBP + -0x32],0x0
LEA R15,[RBP + -0x36]
LAB_00149739:
MOV RSI,qword ptr [RBP + -0x58]
MOV R9,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x48]
ADD qword ptr [RBP + -0x30],0x8
DEC R9
JMP 0x00149776
LAB_00149753:
ADD R15,0x30
MOV RAX,qword ptr [RBP + -0x30]
LEA RAX,[RAX + RBX*0x8]
MOV qword ptr [RBP + -0x30],RAX
MOV R9,qword ptr [RBP + -0x40]
SUB R9,RBX
MOV RSI,qword ptr [RBP + -0x58]
MOV RDI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x48]
LAB_00149776:
MOVZX EAX,word ptr [R15]
TEST AX,AX
SETZ CL
CMP R13,RDX
SETNC R8B
OR R8B,CL
JNZ 0x001497ac
ADD R15,0x2
LAB_00149790:
MOV word ptr [RSI],AX
ADD RSI,0x2
INC R13
MOVZX EAX,word ptr [R15]
TEST AX,AX
JZ 0x001497ac
ADD R15,0x2
CMP R13,RDX
JC 0x00149790
LAB_001497ac:
TEST AX,AX
MOVZX EAX,DIL
MOV ECX,0x1
CMOVZ ECX,EAX
CMP R13,RDX
CMOVNZ ECX,EAX
TEST R9,R9
JNZ 0x00149622
JMP 0x001497e0
LAB_001497cc:
MOV qword ptr [RCX],0x0
TEST R9,R9
SETNZ CL
JMP 0x001497ec
LAB_001497db:
XOR R13D,R13D
XOR ECX,ECX
LAB_001497e0:
MOV word ptr [RSI],0x0
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RAX],R13
LAB_001497ec:
MOV EAX,ECX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong my_char_weight_put(ulong *param_1,short *param_2,long param_3,ulong *param_4,ulong *param_5,
ulong param_6)
{
ushort uVar1;
short sVar2;
int iVar3;
ulong uVar4;
ulong uVar5;
ulong uVar6;
ulong uVar7;
long lVar8;
ulong uVar9;
void *pvVar10;
void *__s1;
short *psVar11;
short local_3e;
ushort local_3c;
int2 local_3a;
ulong *local_38;
if (param_3 == 0) {
*param_4 = 0;
uVar7 = CONCAT71((int7)((ulong)param_4 >> 8),param_6 != 0);
}
else {
if (param_6 == 0) {
uVar9 = 0;
uVar7 = 0;
}
else {
uVar5 = param_3 - 1;
uVar9 = 0;
uVar4 = 0;
local_38 = param_5;
do {
if (1 < param_6) {
lVar8 = param_6 * 8;
uVar7 = param_6;
do {
if ((uVar7 < 7) && (0 < (long)param_1[3])) {
__s1 = (void *)param_1[4];
pvVar10 = (void *)(param_1[3] * 0x58 + (long)__s1);
do {
if ((((uVar7 == 6) || (*(long *)((long)__s1 + lVar8) == 0)) &&
(*(char *)((long)__s1 + 0x52) == '\0')) &&
(iVar3 = bcmp(__s1,local_38,uVar7 * 8), iVar3 == 0)) {
psVar11 = (short *)((long)__s1 + 0x30);
local_38 = local_38 + uVar7;
param_6 = param_6 - uVar7;
goto LAB_00149776;
}
__s1 = (void *)((long)__s1 + 0x58);
} while (__s1 < pvVar10);
}
uVar7 = uVar7 - 1;
lVar8 = lVar8 + -8;
} while (1 < uVar7);
}
uVar7 = *local_38;
if (*param_1 < (uVar7 & 0xffffffff)) {
LAB_001496e8:
uVar1 = (ushort)(0x51a5 < uVar7 - 0x4e00) << 7 | 0xfb40;
if (uVar7 - 0x3400 < 0x19b6) {
uVar1 = 0xfb80;
}
local_3e = (short)(uVar7 >> 0xf) + uVar1;
local_3c = (ushort)uVar7 | 0x8000;
local_3a = 0;
psVar11 = &local_3e;
}
else {
uVar6 = uVar7 >> 8 & 0xffffff;
lVar8 = *(long *)(param_1[2] + uVar6 * 8);
if (lVar8 == 0) goto LAB_001496e8;
psVar11 = (short *)(lVar8 + (ulong)((uint)*(byte *)(param_1[1] + uVar6) *
((uint)uVar7 & 0xff)) * 2);
}
local_38 = local_38 + 1;
param_6 = param_6 - 1;
LAB_00149776:
sVar2 = *psVar11;
if (uVar9 < uVar5 && sVar2 != 0) {
do {
psVar11 = psVar11 + 1;
*param_2 = sVar2;
param_2 = param_2 + 1;
uVar9 = uVar9 + 1;
sVar2 = *psVar11;
if (sVar2 == 0) break;
} while (uVar9 < uVar5);
}
uVar7 = 1;
if (sVar2 == 0) {
uVar7 = uVar4;
}
if (uVar9 != uVar5) {
uVar7 = uVar4;
}
uVar4 = uVar7;
} while (param_6 != 0);
}
*param_2 = 0;
*param_4 = uVar9;
}
return uVar7 & 0xffffffff;
}
| |
42,898 | ma_log_key_middle | eloqsql/storage/maria/ma_write.c | static my_bool _ma_log_key_middle(MARIA_PAGE *ma_page,
uint new_length,
uint data_added_first,
uint data_changed_first,
uint data_deleted_last,
const uchar *key_pos,
uint key_length, int move_length)
{
LSN lsn;
uchar log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE + 2 + 2 + 3+5+3+3+3 + 7];
uchar *log_pos;
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 6];
uint key_offset;
uint translog_parts, extra_length;
MARIA_HA *info= ma_page->info;
my_off_t page= ma_page->pos / info->s->block_size;
DBUG_ENTER("_ma_log_key_middle");
DBUG_PRINT("enter", ("page: %lu", (ulong) page));
DBUG_ASSERT(ma_page->size == new_length);
/* new place of key after changes */
key_pos+= data_added_first;
key_offset= (uint) (key_pos - ma_page->buff);
if (key_offset < new_length)
{
/* key is on page; Calculate how much of the key is there */
uint max_key_length= new_length - key_offset;
if (max_key_length < key_length)
{
/* Key is last on page */
key_length= max_key_length;
move_length= 0;
}
/*
Take into account that new data was added as part of original key
that also needs to be removed from page
*/
data_deleted_last+= move_length;
}
/* First log changes to page */
log_pos= log_data + FILEID_STORE_SIZE;
page_store(log_pos, page);
log_pos+= PAGE_STORE_SIZE;
#ifdef EXTRA_DEBUG_KEY_CHANGES
*log_pos++= KEY_OP_DEBUG;
*log_pos++= KEY_OP_DEBUG_LOG_MIDDLE;
#endif
/* Store keypage_flag */
*log_pos++= KEY_OP_SET_PAGEFLAG;
*log_pos++= _ma_get_keypage_flag(info->s, ma_page->buff);
log_pos[0]= KEY_OP_DEL_SUFFIX;
int2store(log_pos+1, data_deleted_last);
log_pos+= 3;
log_pos[0]= KEY_OP_ADD_PREFIX;
int2store(log_pos+1, data_added_first);
int2store(log_pos+3, data_changed_first);
log_pos+= 5;
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= (uint) (log_pos -
log_data);
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= (ma_page->buff +
info->s->keypage_header);
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= data_changed_first;
translog_parts= 2;
extra_length= data_changed_first;
/* If changed key is on page, log those changes too */
if (key_offset < new_length)
{
uchar *start_log_pos= log_pos;
log_pos[0]= KEY_OP_OFFSET;
int2store(log_pos+1, key_offset);
log_pos+= 3;
if (move_length)
{
log_pos[0]= KEY_OP_SHIFT;
int2store(log_pos+1, move_length);
log_pos+= 3;
}
log_pos[0]= KEY_OP_CHANGE;
int2store(log_pos+1, key_length);
log_pos+= 3;
log_array[TRANSLOG_INTERNAL_PARTS + 2].str= start_log_pos;
log_array[TRANSLOG_INTERNAL_PARTS + 2].length= (uint) (log_pos -
start_log_pos);
log_array[TRANSLOG_INTERNAL_PARTS + 3].str= key_pos;
log_array[TRANSLOG_INTERNAL_PARTS + 3].length= key_length;
translog_parts+=2;
extra_length+= (uint) (log_array[TRANSLOG_INTERNAL_PARTS + 2].length +
key_length);
}
_ma_log_key_changes(ma_page,
log_array + TRANSLOG_INTERNAL_PARTS + translog_parts,
log_pos, &extra_length, &translog_parts);
/* Remember new page length for future log entires for same page */
ma_page->org_size= ma_page->size;
DBUG_RETURN(translog_write_record(&lsn, LOGREC_REDO_INDEX,
info->trn, info,
(translog_size_t)
(log_array[TRANSLOG_INTERNAL_PARTS +
0].length + extra_length),
TRANSLOG_INTERNAL_PARTS + translog_parts,
log_array, log_data, NULL));
} | O0 | c | ma_log_key_middle:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x38(%rbp)
movl %esi, -0x3c(%rbp)
movl %edx, -0x40(%rbp)
movl %ecx, -0x44(%rbp)
movl %r8d, -0x48(%rbp)
movq %r9, -0x50(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xf8(%rbp)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq -0xf8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x7bc(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x100(%rbp)
jmp 0x86567
jmp 0x86569
jmp 0x8656b
movl -0x40(%rbp), %ecx
movq -0x50(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq -0x38(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0xe4(%rbp)
movl -0xe4(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jae 0x865ce
movl -0x3c(%rbp), %eax
subl -0xe4(%rbp), %eax
movl %eax, -0x104(%rbp)
movl -0x104(%rbp), %eax
cmpl 0x10(%rbp), %eax
jae 0x865c5
movl -0x104(%rbp), %eax
movl %eax, 0x10(%rbp)
movl $0x0, 0x18(%rbp)
movl 0x18(%rbp), %eax
addl -0x48(%rbp), %eax
movl %eax, -0x48(%rbp)
leaq -0x30(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x110(%rbp)
movq -0x100(%rbp), %rax
movl %eax, %ecx
movq -0x110(%rbp), %rax
movl %ecx, (%rax)
movq -0x100(%rbp), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0x110(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x60(%rbp), %rax
addq $0x5, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x60(%rbp)
movb $0xa, (%rax)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq -0xf8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x744(%rcx), %ecx
subl $0x2, %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %cl
movq -0x60(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x60(%rbp)
movb %cl, (%rax)
movq -0x60(%rbp), %rax
movb $0x7, (%rax)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x118(%rbp)
movl -0x48(%rbp), %eax
movw %ax, %cx
movq -0x118(%rbp), %rax
movw %cx, (%rax)
movq -0x60(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movb $0x4, (%rax)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x120(%rbp)
movl -0x40(%rbp), %eax
movw %ax, %cx
movq -0x120(%rbp), %rax
movw %cx, (%rax)
jmp 0x866ba
movq -0x60(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x128(%rbp)
movl -0x44(%rbp), %eax
movw %ax, %cx
movq -0x128(%rbp), %rax
movw %cx, (%rax)
movq -0x60(%rbp), %rax
addq $0x5, %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x60(%rbp), %rax
leaq -0x30(%rbp), %rcx
subq %rcx, %rax
movl %eax, %eax
movq %rax, -0xb8(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq -0xf8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x744(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0xb0(%rbp)
movl -0x44(%rbp), %eax
movq %rax, -0xa8(%rbp)
movl $0x2, -0xe8(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0xec(%rbp)
movl -0xe4(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jae 0x8685e
movq -0x60(%rbp), %rax
movq %rax, -0x130(%rbp)
movq -0x60(%rbp), %rax
movb $0x1, (%rax)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x138(%rbp)
movl -0xe4(%rbp), %eax
movw %ax, %cx
movq -0x138(%rbp), %rax
movw %cx, (%rax)
movq -0x60(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x60(%rbp)
cmpl $0x0, 0x18(%rbp)
je 0x867ca
movq -0x60(%rbp), %rax
movb $0x2, (%rax)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x140(%rbp)
movl 0x18(%rbp), %eax
movw %ax, %cx
movq -0x140(%rbp), %rax
movw %cx, (%rax)
movq -0x60(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movb $0x3, (%rax)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x148(%rbp)
movl 0x10(%rbp), %eax
movw %ax, %cx
movq -0x148(%rbp), %rax
movw %cx, (%rax)
movq -0x60(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x60(%rbp)
movq -0x130(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x60(%rbp), %rax
movq -0x130(%rbp), %rcx
subq %rcx, %rax
movl %eax, %eax
movq %rax, -0x98(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x90(%rbp)
movl 0x10(%rbp), %eax
movq %rax, -0x88(%rbp)
movl -0xe8(%rbp), %eax
addl $0x2, %eax
movl %eax, -0xe8(%rbp)
movq -0x98(%rbp), %rax
movl 0x10(%rbp), %ecx
addq %rcx, %rax
addl -0xec(%rbp), %eax
movl %eax, -0xec(%rbp)
movq -0x38(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0xf8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0xf8(%rbp), %rcx
movq -0xb8(%rbp), %rax
movl -0xec(%rbp), %esi
addq %rsi, %rax
movl %eax, %r8d
movl -0xe8(%rbp), %r9d
addl $0x2, %r9d
leaq -0xe0(%rbp), %r10
leaq -0x30(%rbp), %rax
leaq -0x58(%rbp), %rdi
movl $0xc, %esi
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0x4d7f0
movb %al, -0x149(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x868f1
movb -0x149(%rbp), %al
addq $0x170, %rsp # imm = 0x170
popq %rbp
retq
callq 0x2a260
nopw %cs:(%rax,%rax)
| _ma_log_key_middle:
push rbp
mov rbp, rsp
sub rsp, 170h
mov eax, [rbp+arg_8]
mov eax, [rbp+arg_0]
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_40], edx
mov [rbp+var_44], ecx
mov [rbp+var_48], r8d
mov [rbp+var_50], r9
mov rax, [rbp+var_38]
mov rax, [rax]
mov [rbp+var_F8], rax
mov rax, [rbp+var_38]
mov rax, [rax+18h]
mov rcx, [rbp+var_F8]
mov rcx, [rcx]
mov ecx, [rcx+7BCh]
xor edx, edx
div rcx
mov [rbp+var_100], rax
jmp short $+2
loc_86567:
jmp short $+2
loc_86569:
jmp short $+2
loc_8656B:
mov ecx, [rbp+var_40]
mov rax, [rbp+var_50]
mov ecx, ecx
add rax, rcx
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
mov rcx, [rbp+var_38]
mov rcx, [rcx+10h]
sub rax, rcx
mov [rbp+var_E4], eax
mov eax, [rbp+var_E4]
cmp eax, [rbp+var_3C]
jnb short loc_865CE
mov eax, [rbp+var_3C]
sub eax, [rbp+var_E4]
mov [rbp+var_104], eax
mov eax, [rbp+var_104]
cmp eax, [rbp+arg_0]
jnb short loc_865C5
mov eax, [rbp+var_104]
mov [rbp+arg_0], eax
mov [rbp+arg_8], 0
loc_865C5:
mov eax, [rbp+arg_8]
add eax, [rbp+var_48]
mov [rbp+var_48], eax
loc_865CE:
lea rax, [rbp+var_30]
add rax, 2
mov [rbp+var_60], rax
mov rax, [rbp+var_60]
mov [rbp+var_110], rax
mov rax, [rbp+var_100]
mov ecx, eax
mov rax, [rbp+var_110]
mov [rax], ecx
mov rax, [rbp+var_100]
shr rax, 20h
mov cl, al
mov rax, [rbp+var_110]
mov [rax+4], cl
mov rax, [rbp+var_60]
add rax, 5
mov [rbp+var_60], rax
mov rax, [rbp+var_60]
mov rcx, rax
add rcx, 1
mov [rbp+var_60], rcx
mov byte ptr [rax], 0Ah
mov rax, [rbp+var_38]
mov rax, [rax+10h]
mov rcx, [rbp+var_F8]
mov rcx, [rcx]
mov ecx, [rcx+744h]
sub ecx, 2
sub ecx, 1
mov ecx, ecx
mov cl, [rax+rcx]
mov rax, [rbp+var_60]
mov rdx, rax
add rdx, 1
mov [rbp+var_60], rdx
mov [rax], cl
mov rax, [rbp+var_60]
mov byte ptr [rax], 7
mov rax, [rbp+var_60]
add rax, 1
mov [rbp+var_118], rax
mov eax, [rbp+var_48]
mov cx, ax
mov rax, [rbp+var_118]
mov [rax], cx
mov rax, [rbp+var_60]
add rax, 3
mov [rbp+var_60], rax
mov rax, [rbp+var_60]
mov byte ptr [rax], 4
mov rax, [rbp+var_60]
add rax, 1
mov [rbp+var_120], rax
mov eax, [rbp+var_40]
mov cx, ax
mov rax, [rbp+var_120]
mov [rax], cx
jmp short $+2
loc_866BA:
mov rax, [rbp+var_60]
add rax, 3
mov [rbp+var_128], rax
mov eax, [rbp+var_44]
mov cx, ax
mov rax, [rbp+var_128]
mov [rax], cx
mov rax, [rbp+var_60]
add rax, 5
mov [rbp+var_60], rax
lea rax, [rbp+var_30]
mov [rbp+var_C0], rax
mov rax, [rbp+var_60]
lea rcx, [rbp+var_30]
sub rax, rcx
mov eax, eax
mov [rbp+var_B8], rax
mov rax, [rbp+var_38]
mov rax, [rax+10h]
mov rcx, [rbp+var_F8]
mov rcx, [rcx]
mov ecx, [rcx+744h]
add rax, rcx
mov [rbp+var_B0], rax
mov eax, [rbp+var_44]
mov [rbp+var_A8], rax
mov [rbp+var_E8], 2
mov eax, [rbp+var_44]
mov [rbp+var_EC], eax
mov eax, [rbp+var_E4]
cmp eax, [rbp+var_3C]
jnb loc_8685E
mov rax, [rbp+var_60]
mov [rbp+var_130], rax
mov rax, [rbp+var_60]
mov byte ptr [rax], 1
mov rax, [rbp+var_60]
add rax, 1
mov [rbp+var_138], rax
mov eax, [rbp+var_E4]
mov cx, ax
mov rax, [rbp+var_138]
mov [rax], cx
mov rax, [rbp+var_60]
add rax, 3
mov [rbp+var_60], rax
cmp [rbp+arg_8], 0
jz short loc_867CA
mov rax, [rbp+var_60]
mov byte ptr [rax], 2
mov rax, [rbp+var_60]
add rax, 1
mov [rbp+var_140], rax
mov eax, [rbp+arg_8]
mov cx, ax
mov rax, [rbp+var_140]
mov [rax], cx
mov rax, [rbp+var_60]
add rax, 3
mov [rbp+var_60], rax
loc_867CA:
mov rax, [rbp+var_60]
mov byte ptr [rax], 3
mov rax, [rbp+var_60]
add rax, 1
mov [rbp+var_148], rax
mov eax, [rbp+arg_0]
mov cx, ax
mov rax, [rbp+var_148]
mov [rax], cx
mov rax, [rbp+var_60]
add rax, 3
mov [rbp+var_60], rax
mov rax, [rbp+var_130]
mov [rbp+var_A0], rax
mov rax, [rbp+var_60]
mov rcx, [rbp+var_130]
sub rax, rcx
mov eax, eax
mov [rbp+var_98], rax
mov rax, [rbp+var_50]
mov [rbp+var_90], rax
mov eax, [rbp+arg_0]
mov [rbp+var_88], rax
mov eax, [rbp+var_E8]
add eax, 2
mov [rbp+var_E8], eax
mov rax, [rbp+var_98]
mov ecx, [rbp+arg_0]
add rax, rcx
add eax, [rbp+var_EC]
mov [rbp+var_EC], eax
loc_8685E:
mov rax, [rbp+var_38]
mov ecx, [rax+20h]
mov rax, [rbp+var_38]
mov [rax+24h], ecx
mov rax, [rbp+var_F8]
mov rdx, [rax+8]
mov rcx, [rbp+var_F8]
mov rax, [rbp+var_B8]
mov esi, [rbp+var_EC]
add rax, rsi
mov r8d, eax
mov r9d, [rbp+var_E8]
add r9d, 2
lea r10, [rbp+var_E0]
lea rax, [rbp+var_30]
lea rdi, [rbp+var_58]
mov esi, 0Ch
xor r11d, r11d
mov [rsp+170h+var_170], r10
mov [rsp+170h+var_168], rax
mov [rsp+170h+var_160], 0
call translog_write_record
mov [rbp+var_149], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_868F1
mov al, [rbp+var_149]
add rsp, 170h
pop rbp
retn
loc_868F1:
call ___stack_chk_fail
| char ma_log_key_middle(
long long **a1,
unsigned int a2,
unsigned int a3,
unsigned int a4,
int a5,
long long a6,
unsigned int a7,
int a8)
{
_BYTE *v9; // [rsp+40h] [rbp-130h]
unsigned long long v10; // [rsp+70h] [rbp-100h]
long long *v11; // [rsp+78h] [rbp-F8h]
unsigned int v12; // [rsp+84h] [rbp-ECh]
int v13; // [rsp+88h] [rbp-E8h]
unsigned int v14; // [rsp+8Ch] [rbp-E4h]
_QWORD v15[5]; // [rsp+90h] [rbp-E0h] BYREF
long long v16; // [rsp+B8h] [rbp-B8h]
char *v17; // [rsp+C0h] [rbp-B0h]
long long v18; // [rsp+C8h] [rbp-A8h]
_BYTE *v19; // [rsp+D0h] [rbp-A0h]
long long v20; // [rsp+D8h] [rbp-98h]
long long v21; // [rsp+E0h] [rbp-90h]
long long v22; // [rsp+E8h] [rbp-88h]
_BYTE *v23; // [rsp+110h] [rbp-60h]
char v24[8]; // [rsp+118h] [rbp-58h] BYREF
long long v25; // [rsp+120h] [rbp-50h]
int v26; // [rsp+128h] [rbp-48h]
unsigned int v27; // [rsp+12Ch] [rbp-44h]
unsigned int v28; // [rsp+130h] [rbp-40h]
unsigned int v29; // [rsp+134h] [rbp-3Ch]
long long **v30; // [rsp+138h] [rbp-38h]
__int16 v31; // [rsp+140h] [rbp-30h] BYREF
int v32; // [rsp+142h] [rbp-2Eh]
char v33; // [rsp+146h] [rbp-2Ah]
char v34; // [rsp+147h] [rbp-29h]
_BYTE v35[2]; // [rsp+148h] [rbp-28h] BYREF
__int16 v36; // [rsp+14Ah] [rbp-26h]
char v37; // [rsp+14Ch] [rbp-24h]
__int16 v38; // [rsp+14Dh] [rbp-23h]
__int16 v39; // [rsp+14Fh] [rbp-21h]
_BYTE v40[31]; // [rsp+151h] [rbp-1Fh] BYREF
long long savedregs; // [rsp+170h] [rbp+0h] BYREF
*(_QWORD *)&v40[23] = __readfsqword(0x28u);
v30 = a1;
v29 = a2;
v28 = a3;
v27 = a4;
v26 = a5;
v25 = a6;
v11 = *a1;
v10 = (unsigned long long)a1[3] / *(unsigned int *)(**a1 + 1980);
v25 = a3 + a6;
v14 = v25 - (unsigned int)a1[2];
if ( v14 < a2 )
{
if ( v29 - v14 < a7 )
{
a7 = v29 - v14;
a8 = 0;
}
v26 += a8;
}
v32 = v10;
v33 = BYTE4(v10);
v23 = v35;
v34 = 10;
v35[0] = *((_BYTE *)v30[2] + (unsigned int)(*(_DWORD *)(*v11 + 1860) - 3));
v35[1] = 7;
v36 = v26;
v37 = 4;
v38 = v28;
v39 = v27;
v23 = v40;
v15[4] = &v31;
v16 = (unsigned int)v40 - ((unsigned int)&savedregs - 48);
v17 = (char *)v30[2] + *(unsigned int *)(*v11 + 1860);
v18 = v27;
v13 = 2;
v12 = v27;
if ( v14 < v29 )
{
v9 = v23;
*v23 = 1;
*(_WORD *)(v23 + 1) = v14;
v23 += 3;
if ( a8 )
{
*v23 = 2;
*(_WORD *)(v23 + 1) = a8;
v23 += 3;
}
*v23 = 3;
*(_WORD *)(v23 + 1) = a7;
v23 += 3;
v19 = v9;
v20 = (unsigned int)((_DWORD)v23 - (_DWORD)v9);
v21 = v25;
v22 = a7;
v13 = 4;
v12 += a7 + (_DWORD)v23 - (_DWORD)v9;
}
*((_DWORD *)v30 + 9) = *((_DWORD *)v30 + 8);
return translog_write_record((long long)v24, 0xCu, v11[1], v11, v12 + v16, v13 + 2, v15, &v31, 0LL);
}
| _ma_log_key_middle:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x170
MOV EAX,dword ptr [RBP + 0x18]
MOV EAX,dword ptr [RBP + 0x10]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV dword ptr [RBP + -0x40],EDX
MOV dword ptr [RBP + -0x44],ECX
MOV dword ptr [RBP + -0x48],R8D
MOV qword ptr [RBP + -0x50],R9
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0xf8],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RBP + -0xf8]
MOV RCX,qword ptr [RCX]
MOV ECX,dword ptr [RCX + 0x7bc]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x100],RAX
JMP 0x00186567
LAB_00186567:
JMP 0x00186569
LAB_00186569:
JMP 0x0018656b
LAB_0018656b:
MOV ECX,dword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x50]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RCX + 0x10]
SUB RAX,RCX
MOV dword ptr [RBP + -0xe4],EAX
MOV EAX,dword ptr [RBP + -0xe4]
CMP EAX,dword ptr [RBP + -0x3c]
JNC 0x001865ce
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,dword ptr [RBP + -0xe4]
MOV dword ptr [RBP + -0x104],EAX
MOV EAX,dword ptr [RBP + -0x104]
CMP EAX,dword ptr [RBP + 0x10]
JNC 0x001865c5
MOV EAX,dword ptr [RBP + -0x104]
MOV dword ptr [RBP + 0x10],EAX
MOV dword ptr [RBP + 0x18],0x0
LAB_001865c5:
MOV EAX,dword ptr [RBP + 0x18]
ADD EAX,dword ptr [RBP + -0x48]
MOV dword ptr [RBP + -0x48],EAX
LAB_001865ce:
LEA RAX,[RBP + -0x30]
ADD RAX,0x2
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x110],RAX
MOV RAX,qword ptr [RBP + -0x100]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x110]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x100]
SHR RAX,0x20
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x110]
MOV byte ptr [RAX + 0x4],CL
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x5
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x60],RCX
MOV byte ptr [RAX],0xa
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0xf8]
MOV RCX,qword ptr [RCX]
MOV ECX,dword ptr [RCX + 0x744]
SUB ECX,0x2
SUB ECX,0x1
MOV ECX,ECX
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x60]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x60],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x60]
MOV byte ptr [RAX],0x7
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
MOV qword ptr [RBP + -0x118],RAX
MOV EAX,dword ptr [RBP + -0x48]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x118]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x3
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV byte ptr [RAX],0x4
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
MOV qword ptr [RBP + -0x120],RAX
MOV EAX,dword ptr [RBP + -0x40]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x120]
MOV word ptr [RAX],CX
JMP 0x001866ba
LAB_001866ba:
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x3
MOV qword ptr [RBP + -0x128],RAX
MOV EAX,dword ptr [RBP + -0x44]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x128]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x5
MOV qword ptr [RBP + -0x60],RAX
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0xc0],RAX
MOV RAX,qword ptr [RBP + -0x60]
LEA RCX,[RBP + -0x30]
SUB RAX,RCX
MOV EAX,EAX
MOV qword ptr [RBP + -0xb8],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0xf8]
MOV RCX,qword ptr [RCX]
MOV ECX,dword ptr [RCX + 0x744]
ADD RAX,RCX
MOV qword ptr [RBP + -0xb0],RAX
MOV EAX,dword ptr [RBP + -0x44]
MOV qword ptr [RBP + -0xa8],RAX
MOV dword ptr [RBP + -0xe8],0x2
MOV EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RBP + -0xec],EAX
MOV EAX,dword ptr [RBP + -0xe4]
CMP EAX,dword ptr [RBP + -0x3c]
JNC 0x0018685e
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x130],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV byte ptr [RAX],0x1
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
MOV qword ptr [RBP + -0x138],RAX
MOV EAX,dword ptr [RBP + -0xe4]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x138]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x3
MOV qword ptr [RBP + -0x60],RAX
CMP dword ptr [RBP + 0x18],0x0
JZ 0x001867ca
MOV RAX,qword ptr [RBP + -0x60]
MOV byte ptr [RAX],0x2
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
MOV qword ptr [RBP + -0x140],RAX
MOV EAX,dword ptr [RBP + 0x18]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x140]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x3
MOV qword ptr [RBP + -0x60],RAX
LAB_001867ca:
MOV RAX,qword ptr [RBP + -0x60]
MOV byte ptr [RAX],0x3
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
MOV qword ptr [RBP + -0x148],RAX
MOV EAX,dword ptr [RBP + 0x10]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x148]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x3
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x130]
MOV qword ptr [RBP + -0xa0],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x130]
SUB RAX,RCX
MOV EAX,EAX
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x90],RAX
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x88],RAX
MOV EAX,dword ptr [RBP + -0xe8]
ADD EAX,0x2
MOV dword ptr [RBP + -0xe8],EAX
MOV RAX,qword ptr [RBP + -0x98]
MOV ECX,dword ptr [RBP + 0x10]
ADD RAX,RCX
ADD EAX,dword ptr [RBP + -0xec]
MOV dword ptr [RBP + -0xec],EAX
LAB_0018685e:
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x24],ECX
MOV RAX,qword ptr [RBP + -0xf8]
MOV RDX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0xf8]
MOV RAX,qword ptr [RBP + -0xb8]
MOV ESI,dword ptr [RBP + -0xec]
ADD RAX,RSI
MOV R8D,EAX
MOV R9D,dword ptr [RBP + -0xe8]
ADD R9D,0x2
LEA R10,[RBP + -0xe0]
LEA RAX,[RBP + -0x30]
LEA RDI,[RBP + -0x58]
MOV ESI,0xc
XOR R11D,R11D
MOV qword ptr [RSP],R10
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],0x0
CALL 0x0014d7f0
MOV byte ptr [RBP + -0x149],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001868f1
MOV AL,byte ptr [RBP + -0x149]
ADD RSP,0x170
POP RBP
RET
LAB_001868f1:
CALL 0x0012a260
|
int8
_ma_log_key_middle(long *param_1,uint param_2,uint param_3,uint param_4,int param_5,long param_6,
uint param_7,int param_8)
{
long *plVar1;
int iVar2;
int1 uVar3;
uint uVar4;
uint uVar5;
ulong uVar6;
long in_FS_OFFSET;
uint local_f4;
int local_f0;
int1 local_e8 [32];
int1 *local_c8;
ulong local_c0;
long local_b8;
ulong local_b0;
int1 *local_a8;
ulong local_a0;
long local_98;
ulong local_90;
int1 *local_68;
int1 local_60 [8];
long local_58;
int local_50;
uint local_4c;
uint local_48;
uint local_44;
long *local_40;
int1 local_38 [2];
int4 local_36;
int1 local_32;
int1 local_31;
int1 local_30;
int1 local_2f;
int2 local_2e;
int1 local_2c;
int2 local_2b;
int2 local_29;
int1 local_27;
int2 local_26;
int1 local_24;
int2 local_23;
int1 local_21 [17];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
plVar1 = (long *)*param_1;
uVar6 = (ulong)param_1[3] / (ulong)*(uint *)(*plVar1 + 0x7bc);
local_58 = param_6 + (ulong)param_3;
uVar4 = (int)local_58 - (int)param_1[2];
local_50 = param_5;
if (uVar4 < param_2) {
if (param_2 - uVar4 < param_7) {
param_8 = 0;
param_7 = param_2 - uVar4;
}
local_50 = param_8 + param_5;
}
local_36 = (int4)uVar6;
local_32 = (int1)(uVar6 >> 0x20);
local_31 = 10;
local_30 = *(int1 *)(param_1[2] + (ulong)(*(int *)(*plVar1 + 0x744) - 3));
local_2f = 7;
local_2e = (int2)local_50;
local_2c = 4;
local_2b = (int2)param_3;
local_29 = (int2)param_4;
local_c8 = local_38;
iVar2 = (int)&local_27;
uVar5 = iVar2 - (int)local_38;
local_c0 = (ulong)uVar5;
local_b8 = param_1[2] + (ulong)*(uint *)(*plVar1 + 0x744);
local_b0 = (ulong)param_4;
local_f0 = 2;
local_f4 = param_4;
local_68 = &local_27;
if (uVar4 < param_2) {
local_27 = 1;
local_26 = (int2)uVar4;
local_68 = &local_24;
if (param_8 != 0) {
local_24 = 2;
local_23 = (int2)param_8;
local_68 = local_21;
}
*local_68 = 3;
*(short *)(local_68 + 1) = (short)param_7;
local_68 = local_68 + 3;
uVar4 = (int)local_68 - iVar2;
local_a0 = (ulong)uVar4;
local_90 = (ulong)param_7;
local_f0 = 4;
local_f4 = uVar4 + param_7 + param_4;
local_a8 = &local_27;
local_98 = local_58;
}
*(int *)((long)param_1 + 0x24) = (int)param_1[4];
local_4c = param_4;
local_48 = param_3;
local_44 = param_2;
local_40 = param_1;
uVar3 = translog_write_record
(local_60,0xc,plVar1[1],plVar1,uVar5 + local_f4,local_f0 + 2,local_e8,local_38,0
);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),uVar3);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
42,899 | String::append_with_prefill(char const*, unsigned int, unsigned int, char) | eloqsql/sql/sql_string.cc | bool String::append_with_prefill(const char *s,uint32 arg_length,
uint32 full_length, char fill_char)
{
int t_length= arg_length > full_length ? arg_length : full_length;
if (realloc_with_extra_if_needed(str_length + t_length))
return TRUE;
t_length= full_length - arg_length;
if (t_length > 0)
{
bfill(Ptr+str_length, t_length, fill_char);
str_length=str_length + t_length;
}
append(s, arg_length);
return FALSE;
} | O3 | cpp | String::append_with_prefill(char const*, unsigned int, unsigned int, char):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r13d
movl %ecx, %r12d
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
cmpl %ecx, %edx
movl %ecx, %esi
cmoval %edx, %esi
addq $0x8, %rdi
addl 0x10(%r14), %esi
cmpl %esi, 0x14(%r14)
jbe 0x273c1
movq (%rdi), %rax
movb $0x0, (%rax,%rsi)
jmp 0x273ce
callq 0x27da8
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x273fe
subl %r15d, %r12d
testl %r12d, %r12d
jle 0x273ee
movl 0x10(%r14), %edi
addq 0x8(%r14), %rdi
movl %r12d, %edx
movzbl %r13b, %esi
callq 0x241e0
addl %r12d, 0x10(%r14)
movl %r15d, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26f62
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| _ZN6String19append_with_prefillEPKcjjc:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r13d, r8d
mov r12d, ecx
mov r15d, edx
mov rbx, rsi
mov r14, rdi
cmp edx, ecx
mov esi, ecx
cmova esi, edx
add rdi, 8; this
add esi, [r14+10h]; unsigned __int64
cmp [r14+14h], esi
jbe short loc_273C1
mov rax, [rdi]
mov byte ptr [rax+rsi], 0
jmp short loc_273CE
loc_273C1:
call _ZN13Binary_string18realloc_with_extraEm; Binary_string::realloc_with_extra(ulong)
mov ecx, eax
mov al, 1
test cl, cl
jnz short loc_273FE
loc_273CE:
sub r12d, r15d
test r12d, r12d
jle short loc_273EE
mov edi, [r14+10h]
add rdi, [r14+8]
mov edx, r12d
movzx esi, r13b
call _memset
add [r14+10h], r12d
loc_273EE:
mov edx, r15d; unsigned __int64
mov rdi, r14; this
mov rsi, rbx; char *
call _ZN6String6appendEPKcm; String::append(char const*,ulong)
xor eax, eax
loc_273FE:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| char String::append_with_prefill(
String *this,
const char *a2,
unsigned int a3,
unsigned int a4,
unsigned __int8 a5)
{
unsigned int v10; // esi
Binary_string *v11; // rdi
unsigned long long v12; // rsi
char v13; // cl
char result; // al
int v15; // r12d
v10 = a4;
if ( a3 > a4 )
v10 = a3;
v11 = (String *)((char *)this + 8);
v12 = *((_DWORD *)this + 4) + v10;
if ( *((_DWORD *)this + 5) <= (unsigned int)v12 )
{
v13 = Binary_string::realloc_with_extra(v11, v12);
result = 1;
if ( v13 )
return result;
}
else
{
*(_BYTE *)(*(_QWORD *)v11 + v12) = 0;
}
v15 = a4 - a3;
if ( v15 > 0 )
{
memset(*((_QWORD *)this + 1) + *((unsigned int *)this + 4), a5, (unsigned int)v15);
*((_DWORD *)this + 4) += v15;
}
String::append(this, a2, a3);
return 0;
}
| append_with_prefill:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R13D,R8D
MOV R12D,ECX
MOV R15D,EDX
MOV RBX,RSI
MOV R14,RDI
CMP EDX,ECX
MOV ESI,ECX
CMOVA ESI,EDX
ADD RDI,0x8
ADD ESI,dword ptr [R14 + 0x10]
CMP dword ptr [R14 + 0x14],ESI
JBE 0x001273c1
MOV RAX,qword ptr [RDI]
MOV byte ptr [RAX + RSI*0x1],0x0
JMP 0x001273ce
LAB_001273c1:
CALL 0x00127da8
MOV ECX,EAX
MOV AL,0x1
TEST CL,CL
JNZ 0x001273fe
LAB_001273ce:
SUB R12D,R15D
TEST R12D,R12D
JLE 0x001273ee
MOV EDI,dword ptr [R14 + 0x10]
ADD RDI,qword ptr [R14 + 0x8]
MOV EDX,R12D
MOVZX ESI,R13B
CALL 0x001241e0
ADD dword ptr [R14 + 0x10],R12D
LAB_001273ee:
MOV EDX,R15D
MOV RDI,R14
MOV RSI,RBX
CALL 0x00126f62
XOR EAX,EAX
LAB_001273fe:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* String::append_with_prefill(char const*, unsigned int, unsigned int, char) */
int8 __thiscall
String::append_with_prefill(String *this,char *param_1,uint param_2,uint param_3,char param_4)
{
char cVar1;
uint uVar2;
uVar2 = param_3;
if (param_3 < param_2) {
uVar2 = param_2;
}
uVar2 = uVar2 + *(int *)(this + 0x10);
if (uVar2 < *(uint *)(this + 0x14)) {
*(int1 *)(*(long *)(this + 8) + (ulong)uVar2) = 0;
}
else {
cVar1 = Binary_string::realloc_with_extra((Binary_string *)(this + 8),(ulong)uVar2);
if (cVar1 != '\0') {
return 1;
}
}
uVar2 = param_3 - param_2;
if (0 < (int)uVar2) {
memset((void *)((ulong)*(uint *)(this + 0x10) + *(long *)(this + 8)),(uint)(byte)param_4,
(ulong)uVar2);
*(uint *)(this + 0x10) = *(int *)(this + 0x10) + uVar2;
}
append(this,param_1,(ulong)param_2);
return 0;
}
|
Subsets and Splits
C++ Functions With Standard Library Dependencies
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.