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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
54,100 | bc_get_buf | bluesky950520[P]quickjs/quickjs.c | static int bc_get_buf(BCReaderState *s, void *buf, uint32_t buf_len)
{
if (buf_len != 0) {
if (unlikely(!buf || s->buf_end - s->ptr < buf_len))
return bc_read_error_end(s);
memcpy(buf, s->ptr, buf_len);
s->ptr += buf_len;
}
return 0;
} | O2 | c | bc_get_buf:
pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
testl %edx, %edx
je 0x40f6b
movq %rdi, %r14
testq %rsi, %rsi
je 0x40f73
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
movl %edx, %r15d
cmpq %r15, %rcx
jl 0x40f73
movq %rsi, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xe630
addq %r15, 0x10(%r14)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x40e2c
pushq $-0x1
popq %rbx
jmp 0x40f6b
| bc_get_buf:
push r15
push r14
push rbx
xor ebx, ebx
test edx, edx
jz short loc_40F6B
mov r14, rdi
test rsi, rsi
jz short loc_40F73
mov rax, [r14+10h]
mov rcx, [r14+18h]
sub rcx, rax
mov r15d, edx
cmp rcx, r15
jl short loc_40F73
mov rdi, rsi
mov rsi, rax
mov rdx, r15
call _memcpy
add [r14+10h], r15
loc_40F6B:
mov eax, ebx
pop rbx
pop r14
pop r15
retn
loc_40F73:
mov rdi, r14
call bc_read_error_end
push 0FFFFFFFFFFFFFFFFh
pop rbx
jmp short loc_40F6B
| long long bc_get_buf(
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)
{
unsigned int v14; // ebx
long long v15; // r15
v14 = 0;
if ( (_DWORD)a3 )
{
if ( a2 && (a4 = *(_QWORD *)(a1 + 24) - *(_QWORD *)(a1 + 16), v15 = (unsigned int)a3, a4 >= (unsigned int)a3) )
{
memcpy(a2, *(_QWORD *)(a1 + 16), (unsigned int)a3);
*(_QWORD *)(a1 + 16) += v15;
}
else
{
bc_read_error_end(a1, a7, a8, a9, a10, a11, a12, a13, a14, a2, a3, a4, a5, a6);
return (unsigned int)-1;
}
}
return v14;
}
| bc_get_buf:
PUSH R15
PUSH R14
PUSH RBX
XOR EBX,EBX
TEST EDX,EDX
JZ 0x00140f6b
MOV R14,RDI
TEST RSI,RSI
JZ 0x00140f73
MOV RAX,qword ptr [R14 + 0x10]
MOV RCX,qword ptr [R14 + 0x18]
SUB RCX,RAX
MOV R15D,EDX
CMP RCX,R15
JL 0x00140f73
MOV RDI,RSI
MOV RSI,RAX
MOV RDX,R15
CALL 0x0010e630
ADD qword ptr [R14 + 0x10],R15
LAB_00140f6b:
MOV EAX,EBX
POP RBX
POP R14
POP R15
RET
LAB_00140f73:
MOV RDI,R14
CALL 0x00140e2c
PUSH -0x1
POP RBX
JMP 0x00140f6b
|
int4 bc_get_buf(long param_1,void *param_2,uint param_3)
{
int4 uVar1;
ulong __n;
uVar1 = 0;
if (param_3 != 0) {
if (param_2 != (void *)0x0) {
__n = (ulong)param_3;
if ((long)__n <= *(long *)(param_1 + 0x18) - (long)*(void **)(param_1 + 0x10)) {
memcpy(param_2,*(void **)(param_1 + 0x10),__n);
*(long *)(param_1 + 0x10) = *(long *)(param_1 + 0x10) + __n;
return 0;
}
}
bc_read_error_end(param_1);
uVar1 = 0xffffffff;
}
return uVar1;
}
| |
54,101 | my_charset_get_by_name | eloqsql/mysys/charset.c | CHARSET_INFO *
my_charset_get_by_name(MY_CHARSET_LOADER *loader,
const char *cs_name, uint cs_flags, myf flags)
{
uint cs_number;
CHARSET_INFO *cs;
DBUG_ENTER("get_charset_by_csname");
DBUG_PRINT("enter",("name: '%s'", cs_name));
my_pthread_once(&charsets_initialized, init_available_charsets);
cs_number= get_charset_number(cs_name, cs_flags, flags);
cs= cs_number ? get_internal_charset(loader, cs_number, flags) : NULL;
if (!cs && (flags & MY_WME))
{
char index_file[FN_REFLEN + sizeof(MY_CHARSET_INDEX)];
strmov(get_charsets_dir(index_file),MY_CHARSET_INDEX);
my_error(EE_UNKNOWN_CHARSET, MYF(ME_BELL), cs_name, index_file);
}
DBUG_RETURN(cs);
} | O3 | c | my_charset_get_by_name:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x220, %rsp # imm = 0x220
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
leaq 0x324aee(%rip), %rdi # 0x3729d0
leaq -0x9ae(%rip), %rsi # 0x4d53b
callq 0x252a0
movq %rbx, %rdi
movl %r12d, %esi
movq %r15, %rdx
callq 0x4d726
testl %eax, %eax
je 0x4df12
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
callq 0x4d9ca
movq %rax, %r14
jmp 0x4df15
xorl %r14d, %r14d
testq %r14, %r14
setne %al
testb $0x10, %r15b
sete %cl
orb %al, %cl
jne 0x4df5f
leaq -0x240(%rbp), %r15
movq %r15, %rdi
callq 0x4d2fb
movabsq $0x6d782e7865646e49, %rcx # imm = 0x6D782E7865646E49
movq %rcx, (%rax)
movw $0x6c, 0x8(%rax)
movl $0x4, %esi
movl $0x16, %edi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x4c22b
movq %fs:0x28, %rax
cmpq -0x28(%rbp), %rax
jne 0x4df81
movq %r14, %rax
addq $0x220, %rsp # imm = 0x220
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x25320
| my_charset_get_by_name:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 220h
mov r15, rcx
mov r12d, edx
mov rbx, rsi
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_28], rax
lea rdi, charsets_initialized
lea rsi, init_available_charsets
call _pthread_once
mov rdi, rbx
mov esi, r12d
mov rdx, r15
call get_charset_number
test eax, eax
jz short loc_4DF12
mov rdi, r14
mov esi, eax
mov rdx, r15
call get_internal_charset
mov r14, rax
jmp short loc_4DF15
loc_4DF12:
xor r14d, r14d
loc_4DF15:
test r14, r14
setnz al
test r15b, 10h
setz cl
or cl, al
jnz short loc_4DF5F
lea r15, [rbp+var_240]
mov rdi, r15
call get_charsets_dir
mov rcx, 6D782E7865646E49h
mov [rax], rcx
mov word ptr [rax+8], 6Ch ; 'l'
mov esi, 4
mov edi, 16h
mov rdx, rbx
mov rcx, r15
xor eax, eax
call my_error
loc_4DF5F:
mov rax, fs:28h
cmp rax, [rbp+var_28]
jnz short loc_4DF81
mov rax, r14
add rsp, 220h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_4DF81:
call ___stack_chk_fail
| long long my_charset_get_by_name(
long long a1,
long long a2,
unsigned int a3,
long long a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
unsigned int charset_number; // eax
double v15; // xmm4_8
double v16; // xmm5_8
long long internal_charset; // r14
_BYTE v19[536]; // [rsp+0h] [rbp-240h] BYREF
unsigned long long v20; // [rsp+218h] [rbp-28h]
v20 = __readfsqword(0x28u);
pthread_once(&charsets_initialized, init_available_charsets);
charset_number = get_charset_number(a2, a3, a4);
if ( charset_number )
internal_charset = get_internal_charset(a1, charset_number, a4, a5, a6, a7, a8, v15, v16, a11, a12);
else
internal_charset = 0LL;
if ( internal_charset == 0 && (a4 & 0x10) != 0 )
{
strcpy((char *)get_charsets_dir((long long)v19), "Index.xml");
my_error(0x16u, 4LL, a2, v19);
}
return internal_charset;
}
| my_charset_get_by_name:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x220
MOV R15,RCX
MOV R12D,EDX
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
LEA RDI,[0x4729d0]
LEA RSI,[0x14d53b]
CALL 0x001252a0
MOV RDI,RBX
MOV ESI,R12D
MOV RDX,R15
CALL 0x0014d726
TEST EAX,EAX
JZ 0x0014df12
MOV RDI,R14
MOV ESI,EAX
MOV RDX,R15
CALL 0x0014d9ca
MOV R14,RAX
JMP 0x0014df15
LAB_0014df12:
XOR R14D,R14D
LAB_0014df15:
TEST R14,R14
SETNZ AL
TEST R15B,0x10
SETZ CL
OR CL,AL
JNZ 0x0014df5f
LEA R15,[RBP + -0x240]
MOV RDI,R15
CALL 0x0014d2fb
MOV RCX,0x6d782e7865646e49
MOV qword ptr [RAX],RCX
MOV word ptr [RAX + 0x8],0x6c
MOV ESI,0x4
MOV EDI,0x16
MOV RDX,RBX
MOV RCX,R15
XOR EAX,EAX
CALL 0x0014c22b
LAB_0014df5f:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x28]
JNZ 0x0014df81
MOV RAX,R14
ADD RSP,0x220
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0014df81:
CALL 0x00125320
|
long my_charset_get_by_name(int8 param_1,int8 param_2,int4 param_3,ulong param_4)
{
int iVar1;
long lVar2;
int8 *puVar3;
long in_FS_OFFSET;
int1 local_248 [536];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
pthread_once(&charsets_initialized,init_available_charsets);
iVar1 = get_charset_number(param_2,param_3,param_4);
if (iVar1 == 0) {
lVar2 = 0;
}
else {
lVar2 = get_internal_charset(param_1,iVar1,param_4);
}
if ((param_4 & 0x10) != 0 && lVar2 == 0) {
puVar3 = (int8 *)get_charsets_dir(local_248);
*puVar3 = 0x6d782e7865646e49;
*(int2 *)(puVar3 + 1) = 0x6c;
my_error(0x16,4,param_2,local_248);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
return lVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
54,102 | quantize_row_q8_1_reference | 7CodeWizard[P]stablediffusion/ggml/src/ggml-quants.c | void quantize_row_q8_1_reference(const float * restrict x, block_q8_1 * restrict y, int k) {
assert(QK8_1 == 32);
assert(k % QK8_1 == 0);
const int nb = k / QK8_1;
for (int i = 0; i < nb; i++) {
float amax = 0.0f; // absolute max
for (int j = 0; j < QK8_1; j++) {
const float v = x[i*QK8_1 + j];
amax = MAX(amax, fabsf(v));
}
const float d = amax / ((1 << 7) - 1);
const float id = d ? 1.0f/d : 0.0f;
y[i].d = d;
int sum = 0;
for (int j = 0; j < QK8_1/2; ++j) {
const float v0 = x[i*QK8_1 + j]*id;
const float v1 = x[i*QK8_1 + QK8_1/2 + j]*id;
y[i].qs[ j] = roundf(v0);
y[i].qs[QK8_1/2 + j] = roundf(v1);
sum += y[i].qs[ j];
sum += y[i].qs[QK8_1/2 + j];
}
y[i].s = sum*d;
}
} | O0 | c | quantize_row_q8_1_reference:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl -0x14(%rsp), %eax
movl $0x20, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
cmpl -0x18(%rsp), %eax
jge 0x16cba8
vxorps %xmm0, %xmm0, %xmm0
vmovss %xmm0, -0x20(%rsp)
movl $0x0, -0x24(%rsp)
cmpl $0x20, -0x24(%rsp)
jge 0x16c9a1
movq -0x8(%rsp), %rax
movl -0x1c(%rsp), %ecx
shll $0x5, %ecx
addl -0x24(%rsp), %ecx
movslq %ecx, %rcx
vmovss (%rax,%rcx,4), %xmm0
vmovss %xmm0, -0x28(%rsp)
vmovss -0x20(%rsp), %xmm0
vmovss -0x28(%rsp), %xmm1
vpbroadcastd 0x1cc74(%rip), %xmm2 # 0x1895c8
vpand %xmm2, %xmm1, %xmm1
vucomiss %xmm1, %xmm0
jbe 0x16c96c
vmovss -0x20(%rsp), %xmm0
vmovss %xmm0, -0x44(%rsp)
jmp 0x16c985
vmovss -0x28(%rsp), %xmm0
vpbroadcastd 0x1cc4d(%rip), %xmm1 # 0x1895c8
vpand %xmm1, %xmm0, %xmm0
vmovss %xmm0, -0x44(%rsp)
vmovss -0x44(%rsp), %xmm0
vmovss %xmm0, -0x20(%rsp)
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x16c916
vmovss -0x20(%rsp), %xmm0
vmovss 0x203a5(%rip), %xmm1 # 0x18cd54
vdivss %xmm1, %xmm0, %xmm0
vmovss %xmm0, -0x2c(%rsp)
vmovss -0x2c(%rsp), %xmm0
vxorps %xmm1, %xmm1, %xmm1
vucomiss %xmm1, %xmm0
jne 0x16c9cd
jp 0x16c9cd
jmp 0x16c9e3
vmovss 0x1062f(%rip), %xmm0 # 0x17d004
vdivss -0x2c(%rsp), %xmm0, %xmm0
vmovss %xmm0, -0x48(%rsp)
jmp 0x16c9ef
vxorps %xmm0, %xmm0, %xmm0
vmovss %xmm0, -0x48(%rsp)
jmp 0x16c9ef
vmovss -0x48(%rsp), %xmm0
vmovss %xmm0, -0x30(%rsp)
vmovss -0x2c(%rsp), %xmm0
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
vmovss %xmm0, (%rax)
movl $0x0, -0x34(%rsp)
movl $0x0, -0x38(%rsp)
cmpl $0x10, -0x38(%rsp)
jge 0x16cb76
movq -0x8(%rsp), %rax
movl -0x1c(%rsp), %ecx
shll $0x5, %ecx
movl -0x38(%rsp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
vmovss (%rax,%rcx,4), %xmm0
vmovss -0x30(%rsp), %xmm1
vmulss %xmm1, %xmm0, %xmm0
vmovss %xmm0, -0x3c(%rsp)
movq -0x8(%rsp), %rax
movl -0x1c(%rsp), %esi
shll $0x5, %esi
movl -0x38(%rsp), %ecx
movl %ecx, %edx
movl %esi, %ecx
leal 0x10(%rcx,%rdx), %ecx
movslq %ecx, %rcx
vmovss (%rax,%rcx,4), %xmm0
vmovss -0x30(%rsp), %xmm1
vmulss %xmm1, %xmm0, %xmm0
vmovss %xmm0, -0x40(%rsp)
vmovss -0x3c(%rsp), %xmm0
vmovaps %xmm0, %xmm1
vbroadcastss 0x1cb3a(%rip), %xmm3 # 0x1895d8
vpand %xmm3, %xmm1, %xmm1
vbroadcastss 0x202ad(%rip), %xmm2 # 0x18cd58
vpor %xmm2, %xmm1, %xmm1
vaddss %xmm1, %xmm0, %xmm1
vroundss $0xb, %xmm1, %xmm0, %xmm0
vcvttss2si %xmm0, %eax
movb %al, %dl
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
leaq (%rcx,%rcx,4), %rcx
leaq (%rax,%rcx,8), %rcx
movslq -0x38(%rsp), %rax
movb %dl, 0x8(%rax,%rcx)
vmovss -0x40(%rsp), %xmm0
vmovaps %xmm0, %xmm1
vpand %xmm3, %xmm1, %xmm1
vpor %xmm2, %xmm1, %xmm1
vaddss %xmm1, %xmm0, %xmm1
vroundss $0xb, %xmm1, %xmm0, %xmm0
vcvttss2si %xmm0, %eax
movb %al, %dl
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl -0x38(%rsp), %ecx
addl $0x10, %ecx
movslq %ecx, %rcx
movb %dl, 0x8(%rax,%rcx)
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movslq -0x38(%rsp), %rcx
movsbl 0x8(%rax,%rcx), %eax
addl -0x34(%rsp), %eax
movl %eax, -0x34(%rsp)
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl -0x38(%rsp), %ecx
addl $0x10, %ecx
movslq %ecx, %rcx
movsbl 0x8(%rax,%rcx), %eax
addl -0x34(%rsp), %eax
movl %eax, -0x34(%rsp)
movl -0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rsp)
jmp 0x16ca26
vcvtsi2ssl -0x34(%rsp), %xmm0, %xmm0
vmulss -0x2c(%rsp), %xmm0, %xmm0
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
vmovss %xmm0, 0x4(%rax)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x16c8f6
retq
nopl (%rax)
| quantize_row_q8_1_reference:
mov [rsp+var_8], rdi
mov [rsp+var_10], rsi
mov [rsp+var_14], edx
mov eax, [rsp+var_14]
mov ecx, 20h ; ' '
cdq
idiv ecx
mov [rsp+var_18], eax
mov [rsp+var_1C], 0
loc_16C8F6:
mov eax, [rsp+var_1C]
cmp eax, [rsp+var_18]
jge locret_16CBA8
vxorps xmm0, xmm0, xmm0
vmovss [rsp+var_20], xmm0
mov [rsp+var_24], 0
loc_16C916:
cmp [rsp+var_24], 20h ; ' '
jge loc_16C9A1
mov rax, [rsp+var_8]
mov ecx, [rsp+var_1C]
shl ecx, 5
add ecx, [rsp+var_24]
movsxd rcx, ecx
vmovss xmm0, dword ptr [rax+rcx*4]
vmovss [rsp+var_28], xmm0
vmovss xmm0, [rsp+var_20]
vmovss xmm1, [rsp+var_28]
vpbroadcastd xmm2, cs:dword_1895C8
vpand xmm1, xmm1, xmm2
vucomiss xmm0, xmm1
jbe short loc_16C96C
vmovss xmm0, [rsp+var_20]
vmovss [rsp+var_44], xmm0
jmp short loc_16C985
loc_16C96C:
vmovss xmm0, [rsp+var_28]
vpbroadcastd xmm1, cs:dword_1895C8
vpand xmm0, xmm0, xmm1
vmovss [rsp+var_44], xmm0
loc_16C985:
vmovss xmm0, [rsp+var_44]
vmovss [rsp+var_20], xmm0
mov eax, [rsp+var_24]
add eax, 1
mov [rsp+var_24], eax
jmp loc_16C916
loc_16C9A1:
vmovss xmm0, [rsp+var_20]
vmovss xmm1, cs:dword_18CD54
vdivss xmm0, xmm0, xmm1
vmovss [rsp+var_2C], xmm0
vmovss xmm0, [rsp+var_2C]
vxorps xmm1, xmm1, xmm1
vucomiss xmm0, xmm1
jnz short loc_16C9CD
jp short loc_16C9CD
jmp short loc_16C9E3
loc_16C9CD:
vmovss xmm0, cs:flt_17D004
vdivss xmm0, xmm0, [rsp+var_2C]
vmovss [rsp+var_48], xmm0
jmp short loc_16C9EF
loc_16C9E3:
vxorps xmm0, xmm0, xmm0
vmovss [rsp+var_48], xmm0
jmp short $+2
loc_16C9EF:
vmovss xmm0, [rsp+var_48]
vmovss [rsp+var_30], xmm0
vmovss xmm0, [rsp+var_2C]
mov rax, [rsp+var_10]
movsxd rcx, [rsp+var_1C]
imul rcx, 28h ; '('
add rax, rcx
vmovss dword ptr [rax], xmm0
mov [rsp+var_34], 0
mov [rsp+var_38], 0
loc_16CA26:
cmp [rsp+var_38], 10h
jge loc_16CB76
mov rax, [rsp+var_8]
mov ecx, [rsp+var_1C]
shl ecx, 5
mov edx, [rsp+var_38]
add ecx, edx
movsxd rcx, ecx
vmovss xmm0, dword ptr [rax+rcx*4]
vmovss xmm1, [rsp+var_30]
vmulss xmm0, xmm0, xmm1
vmovss [rsp+var_3C], xmm0
mov rax, [rsp+var_8]
mov esi, [rsp+var_1C]
shl esi, 5
mov ecx, [rsp+var_38]
mov edx, ecx
mov ecx, esi
lea ecx, [rcx+rdx+10h]
movsxd rcx, ecx
vmovss xmm0, dword ptr [rax+rcx*4]
vmovss xmm1, [rsp+var_30]
vmulss xmm0, xmm0, xmm1
vmovss [rsp+var_40], xmm0
vmovss xmm0, [rsp+var_3C]
vmovaps xmm1, xmm0
vbroadcastss xmm3, cs:dword_1895D8
vpand xmm1, xmm1, xmm3
vbroadcastss xmm2, cs:dword_18CD58
vpor xmm1, xmm1, xmm2
vaddss xmm1, xmm0, xmm1
vroundss xmm0, xmm0, xmm1, 0Bh
vcvttss2si eax, xmm0
mov dl, al
mov rax, [rsp+var_10]
movsxd rcx, [rsp+var_1C]
lea rcx, [rcx+rcx*4]
lea rcx, [rax+rcx*8]
movsxd rax, [rsp+var_38]
mov [rax+rcx+8], dl
vmovss xmm0, [rsp+var_40]
vmovaps xmm1, xmm0
vpand xmm1, xmm1, xmm3
vpor xmm1, xmm1, xmm2
vaddss xmm1, xmm0, xmm1
vroundss xmm0, xmm0, xmm1, 0Bh
vcvttss2si eax, xmm0
mov dl, al
mov rax, [rsp+var_10]
movsxd rcx, [rsp+var_1C]
imul rcx, 28h ; '('
add rax, rcx
mov ecx, [rsp+var_38]
add ecx, 10h
movsxd rcx, ecx
mov [rax+rcx+8], dl
mov rax, [rsp+var_10]
movsxd rcx, [rsp+var_1C]
imul rcx, 28h ; '('
add rax, rcx
movsxd rcx, [rsp+var_38]
movsx eax, byte ptr [rax+rcx+8]
add eax, [rsp+var_34]
mov [rsp+var_34], eax
mov rax, [rsp+var_10]
movsxd rcx, [rsp+var_1C]
imul rcx, 28h ; '('
add rax, rcx
mov ecx, [rsp+var_38]
add ecx, 10h
movsxd rcx, ecx
movsx eax, byte ptr [rax+rcx+8]
add eax, [rsp+var_34]
mov [rsp+var_34], eax
mov eax, [rsp+var_38]
add eax, 1
mov [rsp+var_38], eax
jmp loc_16CA26
loc_16CB76:
vcvtsi2ss xmm0, xmm0, [rsp+var_34]
vmulss xmm0, xmm0, [rsp+var_2C]
mov rax, [rsp+var_10]
movsxd rcx, [rsp+var_1C]
imul rcx, 28h ; '('
add rax, rcx
vmovss dword ptr [rax+4], xmm0
mov eax, [rsp+var_1C]
add eax, 1
mov [rsp+var_1C], eax
jmp loc_16C8F6
locret_16CBA8:
retn
| long long quantize_row_q8_1_reference(long long a1, long long a2, int a3, __m128 _XMM0)
{
long long result; // rax
bool v6; // zf
bool v7; // pf
bool v9; // cf
int k; // [rsp+10h] [rbp-38h]
int v62; // [rsp+14h] [rbp-34h]
int j; // [rsp+24h] [rbp-24h]
int i; // [rsp+2Ch] [rbp-1Ch]
int v69; // [rsp+30h] [rbp-18h]
int v70; // [rsp+34h] [rbp-14h]
long long v71; // [rsp+38h] [rbp-10h]
long long v72; // [rsp+40h] [rbp-8h]
v72 = a1;
v71 = a2;
v70 = a3;
v69 = a3 / 32;
for ( i = 0; ; ++i )
{
result = (unsigned int)i;
if ( i >= v69 )
break;
__asm
{
vxorps xmm0, xmm0, xmm0
vmovss [rsp+var_20], xmm0
}
for ( j = 0; ; ++j )
{
v6 = j == 32;
v7 = __SETP__(j, 32);
if ( j >= 32 )
break;
_RAX = v72;
v9 = __CFADD__(j, 32 * i);
v6 = j + 32 * i == 0;
_RCX = j + 32 * i;
__asm
{
vmovss xmm0, dword ptr [rax+rcx*4]
vmovss [rsp+var_28], xmm0
vmovss xmm0, [rsp+var_20]
vmovss xmm1, [rsp+var_28]
vpbroadcastd xmm2, cs:dword_1895C8
vpand xmm1, xmm1, xmm2
vucomiss xmm0, xmm1
}
if ( v9 || v6 )
{
__asm
{
vmovss xmm0, [rsp+var_28]
vpbroadcastd xmm1, cs:dword_1895C8
vpand xmm0, xmm0, xmm1
vmovss [rsp+var_44], xmm0
}
}
else
{
__asm
{
vmovss xmm0, [rsp+var_20]
vmovss [rsp+var_44], xmm0
}
}
__asm
{
vmovss xmm0, [rsp+var_44]
vmovss [rsp+var_20], xmm0
}
}
__asm
{
vmovss xmm0, [rsp+var_20]
vmovss xmm1, cs:dword_18CD54
vdivss xmm0, xmm0, xmm1
vmovss [rsp+var_2C], xmm0
vmovss xmm0, [rsp+var_2C]
vxorps xmm1, xmm1, xmm1
vucomiss xmm0, xmm1
}
if ( !v6 || v7 )
{
__asm
{
vmovss xmm0, cs:flt_17D004
vdivss xmm0, xmm0, [rsp+var_2C]
vmovss [rsp+var_48], xmm0
}
}
else
{
__asm
{
vxorps xmm0, xmm0, xmm0
vmovss [rsp+var_48], xmm0
}
}
__asm
{
vmovss xmm0, [rsp+var_48]
vmovss [rsp+var_30], xmm0
vmovss xmm0, [rsp+var_2C]
}
_RAX = 40LL * i + v71;
__asm { vmovss dword ptr [rax], xmm0 }
v62 = 0;
for ( k = 0; k < 16; ++k )
{
_RAX = v72;
_RCX = k + 32 * i;
__asm
{
vmovss xmm0, dword ptr [rax+rcx*4]
vmovss xmm1, [rsp+var_30]
vmulss xmm0, xmm0, xmm1
vmovss [rsp+var_3C], xmm0
}
_RAX = v72;
_RCX = 32 * i + k + 16;
__asm
{
vmovss xmm0, dword ptr [rax+rcx*4]
vmovss xmm1, [rsp+var_30]
vmulss xmm0, xmm0, xmm1
vmovss [rsp+var_40], xmm0
vmovss xmm0, [rsp+var_3C]
vmovaps xmm1, xmm0
vbroadcastss xmm3, cs:dword_1895D8
vpand xmm1, xmm1, xmm3
vbroadcastss xmm2, cs:dword_18CD58
vpor xmm1, xmm1, xmm2
vaddss xmm1, xmm0, xmm1
vroundss xmm0, xmm0, xmm1, 0Bh
vcvttss2si eax, xmm0
}
*(_BYTE *)(k + v71 + 40LL * i + 8) = _RAX;
__asm
{
vmovss xmm0, [rsp+var_40]
vmovaps xmm1, xmm0
vpand xmm1, xmm1, xmm3
vpor xmm1, xmm1, xmm2
vaddss xmm1, xmm0, xmm1
vroundss xmm0, xmm0, xmm1, 0Bh
vcvttss2si eax, xmm0
}
*(_BYTE *)(40LL * i + v71 + k + 16 + 8) = _RAX;
v62 += *(char *)(40LL * i + v71 + k + 8);
v62 += *(char *)(40LL * i + v71 + k + 16 + 8);
}
__asm
{
vcvtsi2ss xmm0, xmm0, [rsp+var_34]
vmulss xmm0, xmm0, [rsp+var_2C]
}
_RAX = 40LL * i + v71;
__asm { vmovss dword ptr [rax+4], xmm0 }
}
return result;
}
| |||
54,103 | quantize_row_q8_1_reference | 7CodeWizard[P]stablediffusion/ggml/src/ggml-quants.c | void quantize_row_q8_1_reference(const float * restrict x, block_q8_1 * restrict y, int k) {
assert(QK8_1 == 32);
assert(k % QK8_1 == 0);
const int nb = k / QK8_1;
for (int i = 0; i < nb; i++) {
float amax = 0.0f; // absolute max
for (int j = 0; j < QK8_1; j++) {
const float v = x[i*QK8_1 + j];
amax = MAX(amax, fabsf(v));
}
const float d = amax / ((1 << 7) - 1);
const float id = d ? 1.0f/d : 0.0f;
y[i].d = d;
int sum = 0;
for (int j = 0; j < QK8_1/2; ++j) {
const float v0 = x[i*QK8_1 + j]*id;
const float v1 = x[i*QK8_1 + QK8_1/2 + j]*id;
y[i].qs[ j] = roundf(v0);
y[i].qs[QK8_1/2 + j] = roundf(v1);
sum += y[i].qs[ j];
sum += y[i].qs[QK8_1/2 + j];
}
y[i].s = sum*d;
}
} | O1 | c | quantize_row_q8_1_reference:
cmpl $0x20, %edx
jl 0xb6994
shrl $0x5, %edx
leaq 0x18(%rsi), %rax
vbroadcastss 0xea0d(%rip), %xmm0 # 0xc5270
xorl %ecx, %ecx
vmovss 0x1273f(%rip), %xmm1 # 0xc8fac
vmovss 0x4793(%rip), %xmm2 # 0xbb008
vxorps %xmm3, %xmm3, %xmm3
vbroadcastss 0xe9ce(%rip), %ymm4 # 0xc5250
vbroadcastss 0x12725(%rip), %ymm5 # 0xc8fb0
xorl %r8d, %r8d
vxorps %xmm6, %xmm6, %xmm6
vmovss (%rdi,%r8,4), %xmm7
vandps %xmm0, %xmm7, %xmm7
vmaxss %xmm7, %xmm6, %xmm6
incq %r8
cmpq $0x20, %r8
jne 0xb6892
vdivss %xmm1, %xmm6, %xmm6
leaq (%rcx,%rcx,4), %r8
leaq (%rsi,%r8,8), %r8
vmovss %xmm6, (%r8)
vdivss %xmm6, %xmm2, %xmm7
vcmpneqss %xmm3, %xmm6, %xmm8
vandps %xmm7, %xmm8, %xmm7
vbroadcastss %xmm7, %ymm8
vxorps %xmm7, %xmm7, %xmm7
xorl %r9d, %r9d
vmulps (%rdi,%r9,4), %ymm8, %ymm9
vmulps 0x40(%rdi,%r9,4), %ymm8, %ymm10
vandps %ymm4, %ymm9, %ymm11
vorps %ymm5, %ymm11, %ymm11
vaddps %ymm11, %ymm9, %ymm9
vroundps $0xb, %ymm9, %ymm9
vcvttps2dq %ymm9, %ymm9
vextracti128 $0x1, %ymm9, %xmm11
vpackssdw %xmm11, %xmm9, %xmm9
vpacksswb %xmm9, %xmm9, %xmm9
vmovq %xmm9, -0x10(%rax,%r9)
vandps %ymm4, %ymm10, %ymm11
vorps %ymm5, %ymm11, %ymm11
vaddps %ymm11, %ymm10, %ymm10
vroundps $0xb, %ymm10, %ymm10
vcvttps2dq %ymm10, %ymm10
vextracti128 $0x1, %ymm10, %xmm11
vpackssdw %xmm11, %xmm10, %xmm10
vpacksswb %xmm10, %xmm10, %xmm10
vmovq %xmm10, (%rax,%r9)
vpmovsxbd %xmm9, %ymm9
vpaddd %ymm7, %ymm9, %ymm7
vpmovsxbd %xmm10, %ymm9
vpaddd %ymm7, %ymm9, %ymm7
addq $0x8, %r9
cmpq $0x10, %r9
jne 0xb68d3
vextracti128 $0x1, %ymm7, %xmm8
vphaddd %xmm7, %xmm8, %xmm7
vphaddd %xmm7, %xmm7, %xmm7
vphaddd %xmm7, %xmm7, %xmm7
vcvtdq2ps %xmm7, %xmm7
vmulss %xmm7, %xmm6, %xmm6
vmovss %xmm6, 0x4(%r8)
incq %rcx
subq $-0x80, %rdi
addq $0x28, %rax
cmpq %rdx, %rcx
jne 0xb688b
vzeroupper
retq
| quantize_row_q8_1_reference:
cmp edx, 20h ; ' '
jl loc_B6994
shr edx, 5
lea rax, [rsi+18h]
vbroadcastss xmm0, cs:dword_C5270
xor ecx, ecx
vmovss xmm1, cs:dword_C8FAC
vmovss xmm2, cs:dword_BB008
vxorps xmm3, xmm3, xmm3
vbroadcastss ymm4, cs:dword_C5250
vbroadcastss ymm5, cs:dword_C8FB0
loc_B688B:
xor r8d, r8d
vxorps xmm6, xmm6, xmm6
loc_B6892:
vmovss xmm7, dword ptr [rdi+r8*4]
vandps xmm7, xmm7, xmm0
vmaxss xmm6, xmm6, xmm7
inc r8
cmp r8, 20h ; ' '
jnz short loc_B6892
vdivss xmm6, xmm6, xmm1
lea r8, [rcx+rcx*4]
lea r8, [rsi+r8*8]
vmovss dword ptr [r8], xmm6
vdivss xmm7, xmm2, xmm6
vcmpneqss xmm8, xmm6, xmm3
vandps xmm7, xmm8, xmm7
vbroadcastss ymm8, xmm7
vxorps xmm7, xmm7, xmm7
xor r9d, r9d
loc_B68D3:
vmulps ymm9, ymm8, ymmword ptr [rdi+r9*4]
vmulps ymm10, ymm8, ymmword ptr [rdi+r9*4+40h]
vandps ymm11, ymm9, ymm4
vorps ymm11, ymm11, ymm5
vaddps ymm9, ymm9, ymm11
vroundps ymm9, ymm9, 0Bh
vcvttps2dq ymm9, ymm9
vextracti128 xmm11, ymm9, 1
vpackssdw xmm9, xmm9, xmm11
vpacksswb xmm9, xmm9, xmm9
vmovq qword ptr [rax+r9-10h], xmm9
vandps ymm11, ymm10, ymm4
vorps ymm11, ymm11, ymm5
vaddps ymm10, ymm10, ymm11
vroundps ymm10, ymm10, 0Bh
vcvttps2dq ymm10, ymm10
vextracti128 xmm11, ymm10, 1
vpackssdw xmm10, xmm10, xmm11
vpacksswb xmm10, xmm10, xmm10
vmovq qword ptr [rax+r9], xmm10
vpmovsxbd ymm9, xmm9
vpaddd ymm7, ymm9, ymm7
vpmovsxbd ymm9, xmm10
vpaddd ymm7, ymm9, ymm7
add r9, 8
cmp r9, 10h
jnz loc_B68D3
vextracti128 xmm8, ymm7, 1
vphaddd xmm7, xmm8, xmm7
vphaddd xmm7, xmm7, xmm7
vphaddd xmm7, xmm7, xmm7
vcvtdq2ps xmm7, xmm7
vmulss xmm6, xmm6, xmm7
vmovss dword ptr [r8+4], xmm6
inc rcx
sub rdi, 0FFFFFFFFFFFFFF80h
add rax, 28h ; '('
cmp rcx, rdx
jnz loc_B688B
loc_B6994:
vzeroupper
retn
| void quantize_row_q8_1_reference(
long long _RDI,
long long a2,
int a3,
double a4,
double a5,
double a6,
__m128 _XMM3,
double a8,
double a9,
__m128 _XMM6)
{
long long v12; // rdx
long long v15; // rcx
if ( a3 >= 32 )
{
v12 = (unsigned int)a3 >> 5;
_RAX = a2 + 24;
__asm { vbroadcastss xmm0, cs:dword_C5270 }
v15 = 0LL;
__asm
{
vmovss xmm1, cs:dword_C8FAC
vmovss xmm2, cs:dword_BB008
vxorps xmm3, xmm3, xmm3
vbroadcastss ymm4, cs:dword_C5250
vbroadcastss ymm5, cs:dword_C8FB0
}
do
{
_R8 = 0LL;
__asm { vxorps xmm6, xmm6, xmm6 }
do
{
__asm
{
vmovss xmm7, dword ptr [rdi+r8*4]
vandps xmm7, xmm7, xmm0
vmaxss xmm6, xmm6, xmm7
}
++_R8;
}
while ( _R8 != 32 );
__asm { vdivss xmm6, xmm6, xmm1 }
_R8 = a2 + 40 * v15;
__asm
{
vmovss dword ptr [r8], xmm6
vdivss xmm7, xmm2, xmm6
vcmpneqss xmm8, xmm6, xmm3
vandps xmm7, xmm8, xmm7
vbroadcastss ymm8, xmm7
vxorps xmm7, xmm7, xmm7
}
for ( _R9 = 0LL; _R9 != 16; _R9 += 8LL )
{
__asm
{
vmulps ymm9, ymm8, ymmword ptr [rdi+r9*4]
vmulps ymm10, ymm8, ymmword ptr [rdi+r9*4+40h]
vandps ymm11, ymm9, ymm4
vorps ymm11, ymm11, ymm5
vaddps ymm9, ymm9, ymm11
vroundps ymm9, ymm9, 0Bh
vcvttps2dq ymm9, ymm9
vextracti128 xmm11, ymm9, 1
vpackssdw xmm9, xmm9, xmm11
vpacksswb xmm9, xmm9, xmm9
vmovq qword ptr [rax+r9-10h], xmm9
vandps ymm11, ymm10, ymm4
vorps ymm11, ymm11, ymm5
vaddps ymm10, ymm10, ymm11
vroundps ymm10, ymm10, 0Bh
vcvttps2dq ymm10, ymm10
vextracti128 xmm11, ymm10, 1
vpackssdw xmm10, xmm10, xmm11
vpacksswb xmm10, xmm10, xmm10
vmovq qword ptr [rax+r9], xmm10
vpmovsxbd ymm9, xmm9
vpaddd ymm7, ymm9, ymm7
vpmovsxbd ymm9, xmm10
vpaddd ymm7, ymm9, ymm7
}
}
__asm
{
vextracti128 xmm8, ymm7, 1
vphaddd xmm7, xmm8, xmm7
vphaddd xmm7, xmm7, xmm7
vphaddd xmm7, xmm7, xmm7
vcvtdq2ps xmm7, xmm7
vmulss xmm6, xmm6, xmm7
vmovss dword ptr [r8+4], xmm6
}
++v15;
_RDI += 128LL;
_RAX += 40LL;
}
while ( v15 != v12 );
}
__asm { vzeroupper }
}
| |||
54,104 | quantize_row_q8_1_reference | 7CodeWizard[P]stablediffusion/ggml/src/ggml-quants.c | void quantize_row_q8_1_reference(const float * restrict x, block_q8_1 * restrict y, int k) {
assert(QK8_1 == 32);
assert(k % QK8_1 == 0);
const int nb = k / QK8_1;
for (int i = 0; i < nb; i++) {
float amax = 0.0f; // absolute max
for (int j = 0; j < QK8_1; j++) {
const float v = x[i*QK8_1 + j];
amax = MAX(amax, fabsf(v));
}
const float d = amax / ((1 << 7) - 1);
const float id = d ? 1.0f/d : 0.0f;
y[i].d = d;
int sum = 0;
for (int j = 0; j < QK8_1/2; ++j) {
const float v0 = x[i*QK8_1 + j]*id;
const float v1 = x[i*QK8_1 + QK8_1/2 + j]*id;
y[i].qs[ j] = roundf(v0);
y[i].qs[QK8_1/2 + j] = roundf(v1);
sum += y[i].qs[ j];
sum += y[i].qs[QK8_1/2 + j];
}
y[i].s = sum*d;
}
} | O2 | c | quantize_row_q8_1_reference:
pushq %rbx
movl %edx, %eax
movl $0x20, %ecx
cltd
idivl %ecx
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
leaq 0x18(%rsi), %rdx
vmovss 0x12459(%rip), %xmm0 # 0xa4d58
vmovss 0x4701(%rip), %xmm1 # 0x97008
vxorps %xmm2, %xmm2, %xmm2
vbroadcastss 0xe768(%rip), %xmm3 # 0xa107c
vbroadcastss 0x1243f(%rip), %xmm4 # 0xa4d5c
vbroadcastss 0xe766(%rip), %xmm5 # 0xa108c
cmpq %rax, %rcx
je 0x929f2
vxorps %xmm6, %xmm6, %xmm6
xorl %r8d, %r8d
cmpq $0x20, %r8
je 0x9294f
vmovss (%rdi,%r8,4), %xmm7
vandps %xmm5, %xmm7, %xmm7
vmaxss %xmm7, %xmm6, %xmm6
incq %r8
jmp 0x92936
vdivss %xmm0, %xmm6, %xmm6
vdivss %xmm6, %xmm1, %xmm7
vcmpneqss %xmm2, %xmm6, %xmm8
vandps %xmm7, %xmm8, %xmm7
imulq $0x28, %rcx, %r9
leaq (%rsi,%r9), %r8
vmovss %xmm6, (%rsi,%r9)
xorl %r9d, %r9d
xorl %r10d, %r10d
cmpq $0x10, %r9
je 0x929d3
vmulss (%rdi,%r9,4), %xmm7, %xmm8
vmulss 0x40(%rdi,%r9,4), %xmm7, %xmm9
vandps %xmm3, %xmm8, %xmm10
vorps %xmm4, %xmm10, %xmm10
vaddss %xmm10, %xmm8, %xmm8
vroundss $0xb, %xmm8, %xmm8, %xmm8
vcvttss2si %xmm8, %r11d
movb %r11b, -0x10(%rdx,%r9)
vandps %xmm3, %xmm9, %xmm8
vorps %xmm4, %xmm8, %xmm8
vaddss %xmm8, %xmm9, %xmm8
vroundss $0xb, %xmm8, %xmm8, %xmm8
vcvttss2si %xmm8, %ebx
movb %bl, (%rdx,%r9)
movsbl %r11b, %r11d
addl %r11d, %r10d
movsbl %bl, %r11d
addl %r11d, %r10d
incq %r9
jmp 0x92974
vcvtsi2ss %r10d, %xmm11, %xmm7
vmulss %xmm7, %xmm6, %xmm6
vmovss %xmm6, 0x4(%r8)
incq %rcx
subq $-0x80, %rdi
addq $0x28, %rdx
jmp 0x92926
popq %rbx
retq
| quantize_row_q8_1_reference:
push rbx
mov eax, edx
mov ecx, 20h ; ' '
cdq
idiv ecx
xor ecx, ecx
test eax, eax
cmovle eax, ecx
lea rdx, [rsi+18h]
vmovss xmm0, cs:dword_A4D58
vmovss xmm1, cs:dword_97008
vxorps xmm2, xmm2, xmm2
vbroadcastss xmm3, cs:dword_A107C
vbroadcastss xmm4, cs:dword_A4D5C
vbroadcastss xmm5, cs:dword_A108C
loc_92926:
cmp rcx, rax
jz loc_929F2
vxorps xmm6, xmm6, xmm6
xor r8d, r8d
loc_92936:
cmp r8, 20h ; ' '
jz short loc_9294F
vmovss xmm7, dword ptr [rdi+r8*4]
vandps xmm7, xmm7, xmm5
vmaxss xmm6, xmm6, xmm7
inc r8
jmp short loc_92936
loc_9294F:
vdivss xmm6, xmm6, xmm0
vdivss xmm7, xmm1, xmm6
vcmpneqss xmm8, xmm6, xmm2
vandps xmm7, xmm8, xmm7
imul r9, rcx, 28h ; '('
lea r8, [rsi+r9]
vmovss dword ptr [rsi+r9], xmm6
xor r9d, r9d
xor r10d, r10d
loc_92974:
cmp r9, 10h
jz short loc_929D3
vmulss xmm8, xmm7, dword ptr [rdi+r9*4]
vmulss xmm9, xmm7, dword ptr [rdi+r9*4+40h]
vandps xmm10, xmm8, xmm3
vorps xmm10, xmm10, xmm4
vaddss xmm8, xmm8, xmm10
vroundss xmm8, xmm8, xmm8, 0Bh
vcvttss2si r11d, xmm8
mov [rdx+r9-10h], r11b
vandps xmm8, xmm9, xmm3
vorps xmm8, xmm8, xmm4
vaddss xmm8, xmm9, xmm8
vroundss xmm8, xmm8, xmm8, 0Bh
vcvttss2si ebx, xmm8
mov [rdx+r9], bl
movsx r11d, r11b
add r10d, r11d
movsx r11d, bl
add r10d, r11d
inc r9
jmp short loc_92974
loc_929D3:
vcvtsi2ss xmm7, xmm11, r10d
vmulss xmm6, xmm6, xmm7
vmovss dword ptr [r8+4], xmm6
inc rcx
sub rdi, 0FFFFFFFFFFFFFF80h
add rdx, 28h ; '('
jmp loc_92926
loc_929F2:
pop rbx
retn
| long long quantize_row_q8_1_reference(
long long _RDI,
long long a2,
int a3,
double a4,
double a5,
__m128 _XMM2,
double a7,
double a8,
double a9,
__m128 _XMM6)
{
long long result; // rax
long long v12; // rcx
long long v13; // rdx
long long v29; // r9
int v30; // r10d
result = (unsigned int)(a3 / 32);
v12 = 0LL;
if ( (int)result <= 0 )
result = 0LL;
v13 = a2 + 24;
__asm
{
vmovss xmm0, cs:dword_A4D58
vmovss xmm1, cs:dword_97008
vxorps xmm2, xmm2, xmm2
vbroadcastss xmm3, cs:dword_A107C
vbroadcastss xmm4, cs:dword_A4D5C
vbroadcastss xmm5, cs:dword_A108C
}
while ( v12 != result )
{
__asm { vxorps xmm6, xmm6, xmm6 }
for ( _R8 = 0LL; _R8 != 32; ++_R8 )
{
__asm
{
vmovss xmm7, dword ptr [rdi+r8*4]
vandps xmm7, xmm7, xmm5
vmaxss xmm6, xmm6, xmm7
}
}
__asm
{
vdivss xmm6, xmm6, xmm0
vdivss xmm7, xmm1, xmm6
vcmpneqss xmm8, xmm6, xmm2
vandps xmm7, xmm8, xmm7
}
_R8 = a2 + 40 * v12;
__asm { vmovss dword ptr [rsi+r9], xmm6 }
v29 = 0LL;
v30 = 0;
while ( v29 != 16 )
{
__asm
{
vmulss xmm8, xmm7, dword ptr [rdi+r9*4]
vmulss xmm9, xmm7, dword ptr [rdi+r9*4+40h]
vandps xmm10, xmm8, xmm3
vorps xmm10, xmm10, xmm4
vaddss xmm8, xmm8, xmm10
vroundss xmm8, xmm8, xmm8, 0Bh
vcvttss2si r11d, xmm8
}
*(_BYTE *)(v13 + v29 - 16) = _R11D;
__asm
{
vandps xmm8, xmm9, xmm3
vorps xmm8, xmm8, xmm4
vaddss xmm8, xmm9, xmm8
vroundss xmm8, xmm8, xmm8, 0Bh
vcvttss2si ebx, xmm8
}
*(_BYTE *)(v13 + v29) = _EBX;
v30 += (char)_EBX + (char)_R11D;
++v29;
}
__asm
{
vcvtsi2ss xmm7, xmm11, r10d
vmulss xmm6, xmm6, xmm7
vmovss dword ptr [r8+4], xmm6
}
++v12;
_RDI += 128LL;
v13 += 40LL;
}
return result;
}
| quantize_row_q8_1_reference:
PUSH RBX
MOV EAX,EDX
MOV ECX,0x20
CDQ
IDIV ECX
XOR ECX,ECX
TEST EAX,EAX
CMOVLE EAX,ECX
LEA RDX,[RSI + 0x18]
VMOVSS XMM0,dword ptr [0x001a4d58]
VMOVSS XMM1,dword ptr [0x00197008]
VXORPS XMM2,XMM2,XMM2
VBROADCASTSS XMM3,dword ptr [0x001a107c]
VBROADCASTSS XMM4,dword ptr [0x001a4d5c]
VBROADCASTSS XMM5,dword ptr [0x001a108c]
LAB_00192926:
CMP RCX,RAX
JZ 0x001929f2
VXORPS XMM6,XMM6,XMM6
XOR R8D,R8D
LAB_00192936:
CMP R8,0x20
JZ 0x0019294f
VMOVSS XMM7,dword ptr [RDI + R8*0x4]
VANDPS XMM7,XMM7,XMM5
VMAXSS XMM6,XMM6,XMM7
INC R8
JMP 0x00192936
LAB_0019294f:
VDIVSS XMM6,XMM6,XMM0
VDIVSS XMM7,XMM1,XMM6
VCMPNEQSS XMM8,XMM6,XMM2
VANDPS XMM7,XMM8,XMM7
IMUL R9,RCX,0x28
LEA R8,[RSI + R9*0x1]
VMOVSS dword ptr [RSI + R9*0x1],XMM6
XOR R9D,R9D
XOR R10D,R10D
LAB_00192974:
CMP R9,0x10
JZ 0x001929d3
VMULSS XMM8,XMM7,dword ptr [RDI + R9*0x4]
VMULSS XMM9,XMM7,dword ptr [RDI + R9*0x4 + 0x40]
VANDPS XMM10,XMM8,XMM3
VORPS XMM10,XMM10,XMM4
VADDSS XMM8,XMM8,XMM10
VROUNDSS XMM8,XMM8,XMM8,0xb
VCVTTSS2SI R11D,XMM8
MOV byte ptr [RDX + R9*0x1 + -0x10],R11B
VANDPS XMM8,XMM9,XMM3
VORPS XMM8,XMM8,XMM4
VADDSS XMM8,XMM9,XMM8
VROUNDSS XMM8,XMM8,XMM8,0xb
VCVTTSS2SI EBX,XMM8
MOV byte ptr [RDX + R9*0x1],BL
MOVSX R11D,R11B
ADD R10D,R11D
MOVSX R11D,BL
ADD R10D,R11D
INC R9
JMP 0x00192974
LAB_001929d3:
VCVTSI2SS XMM7,XMM11,R10D
VMULSS XMM6,XMM6,XMM7
VMOVSS dword ptr [R8 + 0x4],XMM6
INC RCX
SUB RDI,-0x80
ADD RDX,0x28
JMP 0x00192926
LAB_001929f2:
POP RBX
RET
|
void quantize_row_q8_1_reference(long param_1,long param_2,int param_3)
{
float fVar1;
float fVar2;
float fVar3;
float fVar4;
ulong uVar5;
ulong uVar6;
long lVar7;
char cVar8;
long lVar9;
int iVar10;
char cVar11;
int1 auVar12 [16];
int1 auVar13 [16];
int1 auVar14 [16];
int1 auVar15 [16];
int1 auVar16 [16];
int1 auVar17 [16];
fVar4 = DAT_001a4d58;
fVar3 = DAT_00197008;
uVar5 = (long)param_3 / 0x20 & 0xffffffff;
uVar6 = 0;
if ((int)((long)param_3 / 0x20) < 1) {
uVar5 = 0;
}
lVar7 = param_2 + 0x18;
auVar12._4_4_ = DAT_001a107c;
auVar12._0_4_ = DAT_001a107c;
auVar12._8_4_ = DAT_001a107c;
auVar12._12_4_ = DAT_001a107c;
auVar13._4_4_ = DAT_001a4d5c;
auVar13._0_4_ = DAT_001a4d5c;
auVar13._8_4_ = DAT_001a4d5c;
auVar13._12_4_ = DAT_001a4d5c;
auVar14._4_4_ = DAT_001a108c;
auVar14._0_4_ = DAT_001a108c;
auVar14._8_4_ = DAT_001a108c;
auVar14._12_4_ = DAT_001a108c;
for (; uVar6 != uVar5; uVar6 = uVar6 + 1) {
auVar15 = ZEXT816(0) << 0x40;
for (lVar9 = 0; lVar9 != 0x20; lVar9 = lVar9 + 1) {
auVar16 = vandps_avx(ZEXT416(*(uint *)(param_1 + lVar9 * 4)),auVar14);
auVar15 = vmaxss_avx(auVar15,auVar16);
}
auVar16._0_4_ = auVar15._0_4_ / fVar4;
auVar16._4_12_ = auVar15._4_12_;
auVar15 = vcmpss_avx(auVar16,ZEXT816(0) << 0x40,4);
auVar15 = vandps_avx(auVar15,ZEXT416((uint)(fVar3 / auVar16._0_4_)));
*(float *)(param_2 + uVar6 * 0x28) = auVar16._0_4_;
iVar10 = 0;
for (lVar9 = 0; lVar9 != 0x10; lVar9 = lVar9 + 1) {
fVar1 = auVar15._0_4_ * *(float *)(param_1 + lVar9 * 4);
fVar2 = auVar15._0_4_ * *(float *)(param_1 + 0x40 + lVar9 * 4);
auVar17 = vandps_avx(ZEXT416((uint)fVar1),auVar12);
auVar17 = vorps_avx(auVar17,auVar13);
auVar17 = ZEXT416((uint)(fVar1 + auVar17._0_4_));
auVar17 = vroundss_avx(auVar17,auVar17,0xb);
cVar11 = (char)(int)auVar17._0_4_;
*(char *)(lVar7 + -0x10 + lVar9) = cVar11;
auVar17 = vandps_avx(ZEXT416((uint)fVar2),auVar12);
auVar17 = vorps_avx(auVar17,auVar13);
auVar17 = ZEXT416((uint)(fVar2 + auVar17._0_4_));
auVar17 = vroundss_avx(auVar17,auVar17,0xb);
cVar8 = (char)(int)auVar17._0_4_;
*(char *)(lVar7 + lVar9) = cVar8;
iVar10 = iVar10 + cVar11 + (int)cVar8;
}
*(float *)(param_2 + uVar6 * 0x28 + 4) = auVar16._0_4_ * (float)iVar10;
param_1 = param_1 + 0x80;
lVar7 = lVar7 + 0x28;
}
return;
}
| |
54,105 | add_reloc | bluesky950520[P]quickjs/quickjs.c | static RelocEntry *add_reloc(JSContext *ctx, LabelSlot *ls, uint32_t addr, int size)
{
RelocEntry *re;
re = js_malloc(ctx, sizeof(*re));
if (!re)
return NULL;
re->addr = addr;
re->size = size;
re->next = ls->first_reloc;
ls->first_reloc = re;
return re;
} | O2 | c | add_reloc:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
pushq $0x10
popq %rsi
callq 0x17214
testq %rax, %rax
je 0x5db60
movl %r14d, 0x8(%rax)
movl %ebp, 0xc(%rax)
movq 0x10(%rbx), %rcx
movq %rcx, (%rax)
movq %rax, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
| add_reloc:
push rbp
push r14
push rbx
mov ebp, ecx
mov r14d, edx
mov rbx, rsi
push 10h
pop rsi
call js_malloc
test rax, rax
jz short loc_5DB60
mov [rax+8], r14d
mov [rax+0Ch], ebp
mov rcx, [rbx+10h]
mov [rax], rcx
mov [rbx+10h], rax
loc_5DB60:
pop rbx
pop r14
pop rbp
retn
| long long add_reloc(long long a1, long long a2, int a3, int a4)
{
long long result; // rax
result = js_malloc(a1, 16LL);
if ( result )
{
*(_DWORD *)(result + 8) = a3;
*(_DWORD *)(result + 12) = a4;
*(_QWORD *)result = *(_QWORD *)(a2 + 16);
*(_QWORD *)(a2 + 16) = result;
}
return result;
}
| add_reloc:
PUSH RBP
PUSH R14
PUSH RBX
MOV EBP,ECX
MOV R14D,EDX
MOV RBX,RSI
PUSH 0x10
POP RSI
CALL 0x00117214
TEST RAX,RAX
JZ 0x0015db60
MOV dword ptr [RAX + 0x8],R14D
MOV dword ptr [RAX + 0xc],EBP
MOV RCX,qword ptr [RBX + 0x10]
MOV qword ptr [RAX],RCX
MOV qword ptr [RBX + 0x10],RAX
LAB_0015db60:
POP RBX
POP R14
POP RBP
RET
|
void add_reloc(int8 param_1,long param_2,int4 param_3,int4 param_4)
{
int8 *puVar1;
puVar1 = (int8 *)js_malloc(param_1,0x10);
if (puVar1 != (int8 *)0x0) {
*(int4 *)(puVar1 + 1) = param_3;
*(int4 *)((long)puVar1 + 0xc) = param_4;
*puVar1 = *(int8 *)(param_2 + 0x10);
*(int8 **)(param_2 + 0x10) = puVar1;
}
return;
}
| |
54,106 | Modbus::availableParity[abi:cxx11]() | serhmarch[P]ModbusBridge/modbus/src/Modbus.cpp | List<Parity> availableParity()
{
List<Parity> ls;
ls.push_back(NoParity );
ls.push_back(EvenParity );
ls.push_back(OddParity );
ls.push_back(SpaceParity);
ls.push_back(MarkParity );
return ls;
} | O0 | cpp | Modbus::availableParity[abi:cxx11]():
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0xb890
movq -0x38(%rbp), %rdi
movl $0x0, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0xb8b0
jmp 0xb296
movq -0x38(%rbp), %rdi
movl $0x1, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0xb8b0
jmp 0xb2ac
movq -0x38(%rbp), %rdi
movl $0x2, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0xb8b0
jmp 0xb2c2
movq -0x38(%rbp), %rdi
movl $0x3, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0xb8b0
jmp 0xb2d8
movq -0x38(%rbp), %rdi
movl $0x4, -0x2c(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0xb8b0
jmp 0xb2ee
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0xb31a
jmp 0xb311
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xb8f0
jmp 0xb324
movq -0x38(%rbp), %rdi
callq 0xb8f0
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x6710
nopl (%rax)
| _ZN6Modbus15availableParityB5cxx11Ev:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov rax, rdi
mov [rbp+var_40], rax
mov [rbp+var_8], rdi
mov [rbp+var_9], 0
call _ZNSt7__cxx114listIN6Modbus6ParityESaIS2_EEC2Ev; std::list<Modbus::Parity>::list(void)
mov rdi, [rbp+var_38]
mov [rbp+var_10], 0
lea rsi, [rbp+var_10]
call _ZNSt7__cxx114listIN6Modbus6ParityESaIS2_EE9push_backEOS2_; std::list<Modbus::Parity>::push_back(Modbus::Parity&&)
jmp short $+2
loc_B296:
mov rdi, [rbp+var_38]
mov [rbp+var_20], 1
lea rsi, [rbp+var_20]
call _ZNSt7__cxx114listIN6Modbus6ParityESaIS2_EE9push_backEOS2_; std::list<Modbus::Parity>::push_back(Modbus::Parity&&)
jmp short $+2
loc_B2AC:
mov rdi, [rbp+var_38]
mov [rbp+var_24], 2
lea rsi, [rbp+var_24]
call _ZNSt7__cxx114listIN6Modbus6ParityESaIS2_EE9push_backEOS2_; std::list<Modbus::Parity>::push_back(Modbus::Parity&&)
jmp short $+2
loc_B2C2:
mov rdi, [rbp+var_38]
mov [rbp+var_28], 3
lea rsi, [rbp+var_28]
call _ZNSt7__cxx114listIN6Modbus6ParityESaIS2_EE9push_backEOS2_; std::list<Modbus::Parity>::push_back(Modbus::Parity&&)
jmp short $+2
loc_B2D8:
mov rdi, [rbp+var_38]
mov [rbp+var_2C], 4
lea rsi, [rbp+var_2C]
call _ZNSt7__cxx114listIN6Modbus6ParityESaIS2_EE9push_backEOS2_; std::list<Modbus::Parity>::push_back(Modbus::Parity&&)
jmp short $+2
loc_B2EE:
mov [rbp+var_9], 1
test [rbp+var_9], 1
jnz short loc_B31A
jmp short loc_B311
mov rdi, [rbp+var_38]
mov rcx, rax
mov eax, edx
mov [rbp+var_18], rcx
mov [rbp+var_1C], eax
call _ZNSt7__cxx114listIN6Modbus6ParityESaIS2_EED2Ev; std::list<Modbus::Parity>::~list()
jmp short loc_B324
loc_B311:
mov rdi, [rbp+var_38]
call _ZNSt7__cxx114listIN6Modbus6ParityESaIS2_EED2Ev; std::list<Modbus::Parity>::~list()
loc_B31A:
mov rax, [rbp+var_40]
add rsp, 40h
pop rbp
retn
loc_B324:
mov rdi, [rbp+var_18]
call __Unwind_Resume
| long long Modbus::availableParity[abi:cxx11](long long a1)
{
int v2; // [rsp+14h] [rbp-2Ch] BYREF
int v3; // [rsp+18h] [rbp-28h] BYREF
int v4; // [rsp+1Ch] [rbp-24h] BYREF
int v5; // [rsp+20h] [rbp-20h] BYREF
int v6; // [rsp+30h] [rbp-10h] BYREF
char v7; // [rsp+37h] [rbp-9h]
long long v8; // [rsp+38h] [rbp-8h]
v8 = a1;
v7 = 0;
std::list<Modbus::Parity>::list();
v6 = 0;
std::list<Modbus::Parity>::push_back(a1, &v6);
v5 = 1;
std::list<Modbus::Parity>::push_back(a1, &v5);
v4 = 2;
std::list<Modbus::Parity>::push_back(a1, &v4);
v3 = 3;
std::list<Modbus::Parity>::push_back(a1, &v3);
v2 = 4;
std::list<Modbus::Parity>::push_back(a1, &v2);
return a1;
}
| availableParity[abi:cxx11]:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0x40],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],0x0
CALL 0x0010b890
MOV RDI,qword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x10],0x0
LAB_0010b28b:
LEA RSI,[RBP + -0x10]
CALL 0x0010b8b0
JMP 0x0010b296
LAB_0010b296:
MOV RDI,qword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x20],0x1
LEA RSI,[RBP + -0x20]
CALL 0x0010b8b0
JMP 0x0010b2ac
LAB_0010b2ac:
MOV RDI,qword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x24],0x2
LEA RSI,[RBP + -0x24]
CALL 0x0010b8b0
JMP 0x0010b2c2
LAB_0010b2c2:
MOV RDI,qword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x28],0x3
LEA RSI,[RBP + -0x28]
CALL 0x0010b8b0
JMP 0x0010b2d8
LAB_0010b2d8:
MOV RDI,qword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x2c],0x4
LEA RSI,[RBP + -0x2c]
CALL 0x0010b8b0
LAB_0010b2ec:
JMP 0x0010b2ee
LAB_0010b2ee:
MOV byte ptr [RBP + -0x9],0x1
TEST byte ptr [RBP + -0x9],0x1
JNZ 0x0010b31a
JMP 0x0010b311
LAB_0010b311:
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x0010b8f0
LAB_0010b31a:
MOV RAX,qword ptr [RBP + -0x40]
ADD RSP,0x40
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x0010b2f8) */
/* Modbus::availableParity[abi:cxx11]() */
Modbus * __thiscall Modbus::availableParity_abi_cxx11_(Modbus *this)
{
int4 local_34;
int4 local_30;
int4 local_2c;
int4 local_28 [4];
int4 local_18;
int1 local_11;
Modbus *local_10;
local_11 = 0;
local_10 = this;
std::__cxx11::list<Modbus::Parity,std::allocator<Modbus::Parity>>::list
((list<Modbus::Parity,std::allocator<Modbus::Parity>> *)this);
local_18 = 0;
/* try { // try from 0010b28b to 0010b2eb has its CatchHandler @ 0010b2fa */
std::__cxx11::list<Modbus::Parity,std::allocator<Modbus::Parity>>::push_back
((list<Modbus::Parity,std::allocator<Modbus::Parity>> *)this,(Parity *)&local_18);
local_28[0] = 1;
std::__cxx11::list<Modbus::Parity,std::allocator<Modbus::Parity>>::push_back
((list<Modbus::Parity,std::allocator<Modbus::Parity>> *)this,(Parity *)local_28);
local_2c = 2;
std::__cxx11::list<Modbus::Parity,std::allocator<Modbus::Parity>>::push_back
((list<Modbus::Parity,std::allocator<Modbus::Parity>> *)this,(Parity *)&local_2c);
local_30 = 3;
std::__cxx11::list<Modbus::Parity,std::allocator<Modbus::Parity>>::push_back
((list<Modbus::Parity,std::allocator<Modbus::Parity>> *)this,(Parity *)&local_30);
local_34 = 4;
std::__cxx11::list<Modbus::Parity,std::allocator<Modbus::Parity>>::push_back
((list<Modbus::Parity,std::allocator<Modbus::Parity>> *)this,(Parity *)&local_34);
return this;
}
| |
54,107 | Modbus::availableParity[abi:cxx11]() | serhmarch[P]ModbusBridge/modbus/src/Modbus.cpp | List<Parity> availableParity()
{
List<Parity> ls;
ls.push_back(NoParity );
ls.push_back(EvenParity );
ls.push_back(OddParity );
ls.push_back(SpaceParity);
ls.push_back(MarkParity );
return ls;
} | O2 | cpp | Modbus::availableParity[abi:cxx11]():
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x4(%rsp), %rsi
andl $0x0, (%rsi)
callq 0x7a6a
leaq 0x4(%rsp), %rsi
movl $0x1, (%rsi)
movq %rbx, %rdi
callq 0x7a6a
leaq 0x4(%rsp), %rsi
movl $0x2, (%rsi)
movq %rbx, %rdi
callq 0x7a6a
leaq 0x4(%rsp), %rsi
movl $0x3, (%rsi)
movq %rbx, %rdi
callq 0x7a6a
leaq 0x4(%rsp), %rsi
movl $0x4, (%rsi)
movq %rbx, %rdi
callq 0x7a6a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x7908
jmp 0x7908
jmp 0x7908
jmp 0x7908
movq %rax, %r14
movq %rbx, %rdi
callq 0x7ae2
movq %r14, %rdi
callq 0x5570
| _ZN6Modbus15availableParityB5cxx11Ev:
push r14
push rbx
push rax
mov rbx, rdi
mov [rdi+8], rdi
mov [rdi], rdi
and qword ptr [rdi+10h], 0
lea rsi, [rsp+18h+var_14]
and dword ptr [rsi], 0
call _ZNSt7__cxx114listIN6Modbus6ParityESaIS2_EE9push_backEOS2_; std::list<Modbus::Parity>::push_back(Modbus::Parity&&)
lea rsi, [rsp+18h+var_14]
mov dword ptr [rsi], 1
mov rdi, rbx
call _ZNSt7__cxx114listIN6Modbus6ParityESaIS2_EE9push_backEOS2_; std::list<Modbus::Parity>::push_back(Modbus::Parity&&)
lea rsi, [rsp+18h+var_14]
mov dword ptr [rsi], 2
mov rdi, rbx
call _ZNSt7__cxx114listIN6Modbus6ParityESaIS2_EE9push_backEOS2_; std::list<Modbus::Parity>::push_back(Modbus::Parity&&)
lea rsi, [rsp+18h+var_14]
mov dword ptr [rsi], 3
mov rdi, rbx
call _ZNSt7__cxx114listIN6Modbus6ParityESaIS2_EE9push_backEOS2_; std::list<Modbus::Parity>::push_back(Modbus::Parity&&)
lea rsi, [rsp+18h+var_14]
mov dword ptr [rsi], 4
mov rdi, rbx
call _ZNSt7__cxx114listIN6Modbus6ParityESaIS2_EE9push_backEOS2_; std::list<Modbus::Parity>::push_back(Modbus::Parity&&)
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
jmp short loc_7908
jmp short loc_7908
jmp short loc_7908
jmp short $+2
loc_7908:
mov r14, rax
mov rdi, rbx
call _ZNSt7__cxx1110_List_baseIN6Modbus6ParityESaIS2_EE8_M_clearEv; std::_List_base<Modbus::Parity>::_M_clear(void)
mov rdi, r14
call __Unwind_Resume
| _QWORD * Modbus::availableParity[abi:cxx11](_QWORD *a1)
{
_DWORD v2[5]; // [rsp+0h] [rbp-14h] BYREF
a1[1] = a1;
*a1 = a1;
a1[2] = 0LL;
v2[0] = 0;
std::list<Modbus::Parity>::push_back(a1, v2);
v2[0] = 1;
std::list<Modbus::Parity>::push_back(a1, v2);
v2[0] = 2;
std::list<Modbus::Parity>::push_back(a1, v2);
v2[0] = 3;
std::list<Modbus::Parity>::push_back(a1, v2);
v2[0] = 4;
std::list<Modbus::Parity>::push_back(a1, v2);
return a1;
}
| availableParity[abi:cxx11]:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV qword ptr [RDI + 0x8],RDI
MOV qword ptr [RDI],RDI
AND qword ptr [RDI + 0x10],0x0
LEA RSI,[RSP + 0x4]
AND dword ptr [RSI],0x0
LAB_001078a4:
CALL 0x00107a6a
LEA RSI,[RSP + 0x4]
MOV dword ptr [RSI],0x1
LAB_001078b4:
MOV RDI,RBX
CALL 0x00107a6a
LEA RSI,[RSP + 0x4]
MOV dword ptr [RSI],0x2
LAB_001078c7:
MOV RDI,RBX
CALL 0x00107a6a
LEA RSI,[RSP + 0x4]
MOV dword ptr [RSI],0x3
LAB_001078da:
MOV RDI,RBX
CALL 0x00107a6a
LEA RSI,[RSP + 0x4]
MOV dword ptr [RSI],0x4
LAB_001078ed:
MOV RDI,RBX
CALL 0x00107a6a
LAB_001078f5:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* Modbus::availableParity[abi:cxx11]() */
Modbus * __thiscall Modbus::availableParity_abi_cxx11_(Modbus *this)
{
uint in_EAX;
int8 uStack_18;
*(Modbus **)(this + 8) = this;
*(Modbus **)this = this;
*(int8 *)(this + 0x10) = 0;
uStack_18 = (ulong)in_EAX;
/* try { // try from 001078a4 to 001078a8 has its CatchHandler @ 00107908 */
std::__cxx11::list<Modbus::Parity,std::allocator<Modbus::Parity>>::push_back
((list<Modbus::Parity,std::allocator<Modbus::Parity>> *)this,
(Parity *)((long)&uStack_18 + 4));
uStack_18 = CONCAT44(1,(int4)uStack_18);
/* try { // try from 001078b4 to 001078bb has its CatchHandler @ 00107906 */
std::__cxx11::list<Modbus::Parity,std::allocator<Modbus::Parity>>::push_back
((list<Modbus::Parity,std::allocator<Modbus::Parity>> *)this,
(Parity *)((long)&uStack_18 + 4));
uStack_18 = CONCAT44(2,(int4)uStack_18);
/* try { // try from 001078c7 to 001078ce has its CatchHandler @ 00107904 */
std::__cxx11::list<Modbus::Parity,std::allocator<Modbus::Parity>>::push_back
((list<Modbus::Parity,std::allocator<Modbus::Parity>> *)this,
(Parity *)((long)&uStack_18 + 4));
uStack_18 = CONCAT44(3,(int4)uStack_18);
/* try { // try from 001078da to 001078e1 has its CatchHandler @ 00107902 */
std::__cxx11::list<Modbus::Parity,std::allocator<Modbus::Parity>>::push_back
((list<Modbus::Parity,std::allocator<Modbus::Parity>> *)this,
(Parity *)((long)&uStack_18 + 4));
uStack_18 = CONCAT44(4,(int4)uStack_18);
/* try { // try from 001078ed to 001078f4 has its CatchHandler @ 00107900 */
std::__cxx11::list<Modbus::Parity,std::allocator<Modbus::Parity>>::push_back
((list<Modbus::Parity,std::allocator<Modbus::Parity>> *)this,
(Parity *)((long)&uStack_18 + 4));
return this;
}
| |
54,108 | Modbus::availableParity[abi:cxx11]() | serhmarch[P]ModbusBridge/modbus/src/Modbus.cpp | List<Parity> availableParity()
{
List<Parity> ls;
ls.push_back(NoParity );
ls.push_back(EvenParity );
ls.push_back(OddParity );
ls.push_back(SpaceParity);
ls.push_back(MarkParity );
return ls;
} | O3 | cpp | Modbus::availableParity[abi:cxx11]():
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x18, %edi
callq 0x5300
movl $0x0, 0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5080
incq 0x10(%rbx)
movl $0x18, %edi
callq 0x5300
movl $0x1, 0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5080
incq 0x10(%rbx)
movl $0x18, %edi
callq 0x5300
movl $0x2, 0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5080
incq 0x10(%rbx)
movl $0x18, %edi
callq 0x5300
movl $0x3, 0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5080
incq 0x10(%rbx)
movl $0x18, %edi
callq 0x5300
movl $0x4, 0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5080
incq 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x86cf
jmp 0x86cf
jmp 0x86cf
jmp 0x86cf
movq %rax, %r14
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x86ef
movq (%rdi), %r15
movl $0x18, %esi
callq 0x5310
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x86da
movq %r14, %rdi
callq 0x5550
| _ZN6Modbus15availableParityB5cxx11Ev:
push r15
push r14
push rbx
mov rbx, rdi
mov [rdi+8], rdi
mov [rdi], rdi
mov qword ptr [rdi+10h], 0
mov edi, 18h; unsigned __int64
call __Znwm; operator new(ulong)
mov dword ptr [rax+10h], 0
mov rdi, rax; this
mov rsi, rbx; std::__detail::_List_node_base *
call __ZNSt8__detail15_List_node_base7_M_hookEPS0_; std::__detail::_List_node_base::_M_hook(std::__detail::_List_node_base*)
inc qword ptr [rbx+10h]
mov edi, 18h; unsigned __int64
call __Znwm; operator new(ulong)
mov dword ptr [rax+10h], 1
mov rdi, rax; this
mov rsi, rbx; std::__detail::_List_node_base *
call __ZNSt8__detail15_List_node_base7_M_hookEPS0_; std::__detail::_List_node_base::_M_hook(std::__detail::_List_node_base*)
inc qword ptr [rbx+10h]
mov edi, 18h; unsigned __int64
call __Znwm; operator new(ulong)
mov dword ptr [rax+10h], 2
mov rdi, rax; this
mov rsi, rbx; std::__detail::_List_node_base *
call __ZNSt8__detail15_List_node_base7_M_hookEPS0_; std::__detail::_List_node_base::_M_hook(std::__detail::_List_node_base*)
inc qword ptr [rbx+10h]
mov edi, 18h; unsigned __int64
call __Znwm; operator new(ulong)
mov dword ptr [rax+10h], 3
mov rdi, rax; this
mov rsi, rbx; std::__detail::_List_node_base *
call __ZNSt8__detail15_List_node_base7_M_hookEPS0_; std::__detail::_List_node_base::_M_hook(std::__detail::_List_node_base*)
inc qword ptr [rbx+10h]
mov edi, 18h; unsigned __int64
call __Znwm; operator new(ulong)
mov dword ptr [rax+10h], 4
mov rdi, rax; this
mov rsi, rbx; std::__detail::_List_node_base *
call __ZNSt8__detail15_List_node_base7_M_hookEPS0_; std::__detail::_List_node_base::_M_hook(std::__detail::_List_node_base*)
inc qword ptr [rbx+10h]
mov rax, rbx
pop rbx
pop r14
pop r15
retn
jmp short loc_86CF
jmp short loc_86CF
jmp short loc_86CF
jmp short $+2
loc_86CF:
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, rbx
jz short loc_86EF
loc_86DA:
mov r15, [rdi]
mov esi, 18h; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, r15
cmp r15, rbx
jnz short loc_86DA
loc_86EF:
mov rdi, r14
call __Unwind_Resume
| std::__detail::_List_node_base * Modbus::availableParity[abi:cxx11](std::__detail::_List_node_base *a1)
{
std::__detail::_List_node_base *v1; // rax
std::__detail::_List_node_base *v2; // rax
std::__detail::_List_node_base *v3; // rax
std::__detail::_List_node_base *v4; // rax
std::__detail::_List_node_base *v5; // rax
*((_QWORD *)a1 + 1) = a1;
*(_QWORD *)a1 = a1;
*((_QWORD *)a1 + 2) = 0LL;
v1 = (std::__detail::_List_node_base *)operator new(0x18uLL);
*((_DWORD *)v1 + 4) = 0;
std::__detail::_List_node_base::_M_hook(v1, a1);
++*((_QWORD *)a1 + 2);
v2 = (std::__detail::_List_node_base *)operator new(0x18uLL);
*((_DWORD *)v2 + 4) = 1;
std::__detail::_List_node_base::_M_hook(v2, a1);
++*((_QWORD *)a1 + 2);
v3 = (std::__detail::_List_node_base *)operator new(0x18uLL);
*((_DWORD *)v3 + 4) = 2;
std::__detail::_List_node_base::_M_hook(v3, a1);
++*((_QWORD *)a1 + 2);
v4 = (std::__detail::_List_node_base *)operator new(0x18uLL);
*((_DWORD *)v4 + 4) = 3;
std::__detail::_List_node_base::_M_hook(v4, a1);
++*((_QWORD *)a1 + 2);
v5 = (std::__detail::_List_node_base *)operator new(0x18uLL);
*((_DWORD *)v5 + 4) = 4;
std::__detail::_List_node_base::_M_hook(v5, a1);
++*((_QWORD *)a1 + 2);
return a1;
}
| availableParity[abi:cxx11]:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV qword ptr [RDI + 0x8],RDI
MOV qword ptr [RDI],RDI
MOV qword ptr [RDI + 0x10],0x0
LAB_0010861e:
MOV EDI,0x18
CALL 0x00105300
MOV dword ptr [RAX + 0x10],0x0
MOV RDI,RAX
MOV RSI,RBX
CALL 0x00105080
INC qword ptr [RBX + 0x10]
LAB_0010863e:
MOV EDI,0x18
CALL 0x00105300
MOV dword ptr [RAX + 0x10],0x1
MOV RDI,RAX
MOV RSI,RBX
CALL 0x00105080
INC qword ptr [RBX + 0x10]
LAB_0010865e:
MOV EDI,0x18
CALL 0x00105300
MOV dword ptr [RAX + 0x10],0x2
MOV RDI,RAX
MOV RSI,RBX
CALL 0x00105080
INC qword ptr [RBX + 0x10]
LAB_0010867e:
MOV EDI,0x18
CALL 0x00105300
MOV dword ptr [RAX + 0x10],0x3
MOV RDI,RAX
MOV RSI,RBX
CALL 0x00105080
INC qword ptr [RBX + 0x10]
LAB_0010869e:
MOV EDI,0x18
CALL 0x00105300
LAB_001086a8:
MOV dword ptr [RAX + 0x10],0x4
MOV RDI,RAX
MOV RSI,RBX
CALL 0x00105080
INC qword ptr [RBX + 0x10]
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
|
/* Modbus::availableParity[abi:cxx11]() */
Modbus * __thiscall Modbus::availableParity_abi_cxx11_(Modbus *this)
{
_List_node_base *p_Var1;
*(Modbus **)(this + 8) = this;
*(Modbus **)this = this;
*(int8 *)(this + 0x10) = 0;
/* try { // try from 0010861e to 00108627 has its CatchHandler @ 001086cf */
p_Var1 = (_List_node_base *)operator_new(0x18);
*(int4 *)(p_Var1 + 0x10) = 0;
std::__detail::_List_node_base::_M_hook(p_Var1);
*(long *)(this + 0x10) = *(long *)(this + 0x10) + 1;
/* try { // try from 0010863e to 00108647 has its CatchHandler @ 001086cd */
p_Var1 = (_List_node_base *)operator_new(0x18);
*(int4 *)(p_Var1 + 0x10) = 1;
std::__detail::_List_node_base::_M_hook(p_Var1);
*(long *)(this + 0x10) = *(long *)(this + 0x10) + 1;
/* try { // try from 0010865e to 00108667 has its CatchHandler @ 001086cb */
p_Var1 = (_List_node_base *)operator_new(0x18);
*(int4 *)(p_Var1 + 0x10) = 2;
std::__detail::_List_node_base::_M_hook(p_Var1);
*(long *)(this + 0x10) = *(long *)(this + 0x10) + 1;
/* try { // try from 0010867e to 00108687 has its CatchHandler @ 001086c9 */
p_Var1 = (_List_node_base *)operator_new(0x18);
*(int4 *)(p_Var1 + 0x10) = 3;
std::__detail::_List_node_base::_M_hook(p_Var1);
*(long *)(this + 0x10) = *(long *)(this + 0x10) + 1;
/* try { // try from 0010869e to 001086a7 has its CatchHandler @ 001086c7 */
p_Var1 = (_List_node_base *)operator_new(0x18);
*(int4 *)(p_Var1 + 0x10) = 4;
std::__detail::_List_node_base::_M_hook(p_Var1);
*(long *)(this + 0x10) = *(long *)(this + 0x10) + 1;
return this;
}
| |
54,109 | bitmap_union_is_set_all | eloqsql/mysys/my_bitmap.c | my_bool bitmap_union_is_set_all(const MY_BITMAP *map1, const MY_BITMAP *map2)
{
my_bitmap_map *m1= map1->bitmap, *m2= map2->bitmap, *end;
DBUG_ASSERT(map1->bitmap);
DBUG_ASSERT(map2->bitmap);
DBUG_ASSERT(map1->n_bits==map2->n_bits);
end= map1->last_word_ptr;
while ( m1 < end)
if ((*m1++ | *m2++) != 0xFFFFFFFF)
return FALSE;
/* here both maps have the same number of bits - see assert above */
return ((*m1 | *m2 | map1->last_word_mask) != 0xFFFFFFFF);
} | O0 | c | bitmap_union_is_set_all:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xeec84
jmp 0xeec86
jmp 0xeec88
jmp 0xeec8a
jmp 0xeec8c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0xeecd1
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x20(%rbp)
movl (%rax), %eax
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $0x4, %rdx
movq %rdx, -0x28(%rbp)
orl (%rcx), %eax
cmpl $-0x1, %eax
je 0xeeccf
movb $0x0, -0x1(%rbp)
jmp 0xeecf2
jmp 0xeec98
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
orl (%rcx), %eax
movq -0x10(%rbp), %rcx
orl 0x18(%rcx), %eax
cmpl $-0x1, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw (%rax,%rax)
| bitmap_union_is_set_all:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_28], rax
jmp short $+2
loc_EEC84:
jmp short $+2
loc_EEC86:
jmp short $+2
loc_EEC88:
jmp short $+2
loc_EEC8A:
jmp short $+2
loc_EEC8C:
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_30], rax
loc_EEC98:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_30]
jnb short loc_EECD1
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 4
mov [rbp+var_20], rcx
mov eax, [rax]
mov rcx, [rbp+var_28]
mov rdx, rcx
add rdx, 4
mov [rbp+var_28], rdx
or eax, [rcx]
cmp eax, 0FFFFFFFFh
jz short loc_EECCF
mov [rbp+var_1], 0
jmp short loc_EECF2
loc_EECCF:
jmp short loc_EEC98
loc_EECD1:
mov rax, [rbp+var_20]
mov eax, [rax]
mov rcx, [rbp+var_28]
or eax, [rcx]
mov rcx, [rbp+var_10]
or eax, [rcx+18h]
cmp eax, 0FFFFFFFFh
setnz al
and al, 1
movzx eax, al
mov [rbp+var_1], al
loc_EECF2:
mov al, [rbp+var_1]
pop rbp
retn
| bool bitmap_union_is_set_all(long long a1, _DWORD **a2)
{
_DWORD *v2; // rax
_DWORD *v3; // rcx
_DWORD *v5; // [rsp+8h] [rbp-28h]
_DWORD *v6; // [rsp+10h] [rbp-20h]
v6 = *(_DWORD **)a1;
v5 = *a2;
while ( (unsigned long long)v6 < *(_QWORD *)(a1 + 8) )
{
v2 = v6++;
v3 = v5++;
if ( (*v3 | *v2) != -1 )
return 0;
}
return (*(_DWORD *)(a1 + 24) | *v5 | *v6) != -1;
}
| bitmap_union_is_set_all:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001eec84
LAB_001eec84:
JMP 0x001eec86
LAB_001eec86:
JMP 0x001eec88
LAB_001eec88:
JMP 0x001eec8a
LAB_001eec8a:
JMP 0x001eec8c
LAB_001eec8c:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x30],RAX
LAB_001eec98:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x001eecd1
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x20],RCX
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x28]
MOV RDX,RCX
ADD RDX,0x4
MOV qword ptr [RBP + -0x28],RDX
OR EAX,dword ptr [RCX]
CMP EAX,-0x1
JZ 0x001eeccf
MOV byte ptr [RBP + -0x1],0x0
JMP 0x001eecf2
LAB_001eeccf:
JMP 0x001eec98
LAB_001eecd1:
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x28]
OR EAX,dword ptr [RCX]
MOV RCX,qword ptr [RBP + -0x10]
OR EAX,dword ptr [RCX + 0x18]
CMP EAX,-0x1
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x1],AL
LAB_001eecf2:
MOV AL,byte ptr [RBP + -0x1]
POP RBP
RET
|
int8 bitmap_union_is_set_all(int8 *param_1,int8 *param_2)
{
uint uVar1;
uint uVar2;
ulong uVar3;
uint *local_30;
uint *local_28;
bool local_9;
local_30 = (uint *)*param_2;
local_28 = (uint *)*param_1;
do {
if ((uint *)param_1[1] <= local_28) {
local_9 = (*local_28 | *local_30 | *(uint *)(param_1 + 3)) != 0xffffffff;
uVar3 = 0;
goto LAB_001eecf2;
}
uVar1 = *local_28;
uVar2 = *local_30;
uVar3 = (ulong)(uVar1 | uVar2);
local_30 = local_30 + 1;
local_28 = local_28 + 1;
} while ((uVar1 | uVar2) == 0xffffffff);
local_9 = false;
LAB_001eecf2:
return CONCAT71((int7)(uVar3 >> 8),local_9);
}
| |
54,110 | bitmap_union_is_set_all | eloqsql/mysys/my_bitmap.c | my_bool bitmap_union_is_set_all(const MY_BITMAP *map1, const MY_BITMAP *map2)
{
my_bitmap_map *m1= map1->bitmap, *m2= map2->bitmap, *end;
DBUG_ASSERT(map1->bitmap);
DBUG_ASSERT(map2->bitmap);
DBUG_ASSERT(map1->n_bits==map2->n_bits);
end= map1->last_word_ptr;
while ( m1 < end)
if ((*m1++ | *m2++) != 0xFFFFFFFF)
return FALSE;
/* here both maps have the same number of bits - see assert above */
return ((*m1 | *m2 | map1->last_word_mask) != 0xFFFFFFFF);
} | O3 | c | bitmap_union_is_set_all:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
movq (%rsi), %rcx
cmpq %rdx, %rax
jae 0x9d8c4
movl (%rcx), %esi
addq $0x4, %rcx
orl (%rax), %esi
addq $0x4, %rax
cmpl $-0x1, %esi
je 0x9d8aa
xorl %eax, %eax
jmp 0x9d8d1
movl (%rcx), %ecx
orl (%rax), %ecx
orl 0x18(%rdi), %ecx
cmpl $-0x1, %ecx
setne %al
popq %rbp
retq
| bitmap_union_is_set_all:
push rbp
mov rbp, rsp
mov rax, [rdi]
mov rdx, [rdi+8]
mov rcx, [rsi]
loc_9D8AA:
cmp rax, rdx
jnb short loc_9D8C4
mov esi, [rcx]
add rcx, 4
or esi, [rax]
add rax, 4
cmp esi, 0FFFFFFFFh
jz short loc_9D8AA
xor eax, eax
jmp short loc_9D8D1
loc_9D8C4:
mov ecx, [rcx]
or ecx, [rax]
or ecx, [rdi+18h]
cmp ecx, 0FFFFFFFFh
setnz al
loc_9D8D1:
pop rbp
retn
| bool bitmap_union_is_set_all(long long a1, int **a2)
{
_DWORD *v2; // rax
int *v3; // rcx
int v4; // esi
int v5; // esi
v2 = *(_DWORD **)a1;
v3 = *a2;
while ( (unsigned long long)v2 < *(_QWORD *)(a1 + 8) )
{
v4 = *v3++;
v5 = *v2++ | v4;
if ( v5 != -1 )
return 0;
}
return (*(_DWORD *)(a1 + 24) | *v2 | *v3) != -1;
}
| bitmap_union_is_set_all:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RSI]
LAB_0019d8aa:
CMP RAX,RDX
JNC 0x0019d8c4
MOV ESI,dword ptr [RCX]
ADD RCX,0x4
OR ESI,dword ptr [RAX]
ADD RAX,0x4
CMP ESI,-0x1
JZ 0x0019d8aa
XOR EAX,EAX
JMP 0x0019d8d1
LAB_0019d8c4:
MOV ECX,dword ptr [RCX]
OR ECX,dword ptr [RAX]
OR ECX,dword ptr [RDI + 0x18]
CMP ECX,-0x1
SETNZ AL
LAB_0019d8d1:
POP RBP
RET
|
int8 bitmap_union_is_set_all(int8 *param_1,int8 *param_2)
{
uint uVar1;
uint uVar2;
uint *puVar3;
uint *puVar4;
puVar3 = (uint *)*param_1;
puVar4 = (uint *)*param_2;
do {
if ((uint *)param_1[1] <= puVar3) {
return CONCAT71((int7)((ulong)puVar3 >> 8),
(*puVar4 | *puVar3 | *(uint *)(param_1 + 3)) != 0xffffffff);
}
uVar1 = *puVar4;
puVar4 = puVar4 + 1;
uVar2 = *puVar3;
puVar3 = puVar3 + 1;
} while ((uVar1 | uVar2) == 0xffffffff);
return 0;
}
| |
54,111 | mi_get_key | eloqsql/storage/myisam/mi_search.c | uchar *_mi_get_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
uchar *key, uchar *keypos, uint *return_key_length)
{
uint nod_flag;
DBUG_ENTER("_mi_get_key");
nod_flag=mi_test_if_nod(page);
if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
{
bmove((uchar*) key,(uchar*) keypos,keyinfo->keylength+nod_flag);
DBUG_RETURN(keypos+keyinfo->keylength+nod_flag);
}
else
{
page+=2+nod_flag;
key[0]=0; /* safety */
while (page <= keypos)
{
*return_key_length=(*keyinfo->get_key)(keyinfo,nod_flag,&page,key);
if (*return_key_length == 0)
{
mi_print_error(info->s, HA_ERR_CRASHED);
my_errno=HA_ERR_CRASHED;
DBUG_RETURN(0);
}
}
}
DBUG_PRINT("exit",("page: %p length: %u", page,
*return_key_length));
DBUG_RETURN(page);
} | O3 | c | mi_get_key:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r13
movq %r8, %rbx
movq %rcx, %r12
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
xorl %r15d, %r15d
cmpb $0x0, (%rdx)
jns 0x88b7b
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl 0x17c(%rax), %r15d
testb $0x28, 0xa(%r14)
je 0x88bde
leal 0x2(%r15), %eax
addq %rax, %rdx
leaq -0x38(%rbp), %rax
movq %rdx, (%rax)
movb $0x0, (%r12)
movq -0x38(%rbp), %rax
cmpq %rbx, %rax
ja 0x88bff
movq %r14, %rdi
movl %r15d, %esi
leaq -0x38(%rbp), %rdx
movq %r12, %rcx
callq *0x48(%r14)
movl %eax, (%r13)
testl %eax, %eax
jne 0x88b95
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0x268(%rax), %rsi
movl $0x7e, %edi
callq 0x7e01a
callq 0xa48d6
movl $0x7e, (%rax)
xorl %eax, %eax
jmp 0x88bff
movzwl 0x12(%r14), %edx
addl %r15d, %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x29120
movzwl 0x12(%r14), %ecx
movl %r15d, %eax
addq %rbx, %rax
addq %rcx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _mi_get_key:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r13, r9
mov rbx, r8
mov r12, rcx
mov r14, rsi
mov [rbp+var_30], rdi
xor r15d, r15d
cmp byte ptr [rdx], 0
jns short loc_88B7B
mov rax, [rbp+var_30]
mov rax, [rax]
mov r15d, [rax+17Ch]
loc_88B7B:
test byte ptr [r14+0Ah], 28h
jz short loc_88BDE
lea eax, [r15+2]
add rdx, rax
lea rax, [rbp+var_38]
mov [rax], rdx
mov byte ptr [r12], 0
loc_88B95:
mov rax, [rbp+var_38]
cmp rax, rbx
ja short loc_88BFF
mov rdi, r14
mov esi, r15d
lea rdx, [rbp+var_38]
mov rcx, r12
call qword ptr [r14+48h]
mov [r13+0], eax
test eax, eax
jnz short loc_88B95
mov rax, [rbp+var_30]
mov rax, [rax]
mov rsi, [rax+268h]
mov edi, 7Eh ; '~'
call mi_report_error
call _my_thread_var
mov dword ptr [rax], 7Eh ; '~'
xor eax, eax
jmp short loc_88BFF
loc_88BDE:
movzx edx, word ptr [r14+12h]
add edx, r15d
mov rdi, r12
mov rsi, rbx
call _memmove
movzx ecx, word ptr [r14+12h]
mov eax, r15d
add rax, rbx
add rax, rcx
loc_88BFF:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| char * mi_get_key(long long a1, long long a2, char *a3, _BYTE *a4, unsigned long long a5, _DWORD *a6)
{
unsigned int v9; // r15d
char *result; // rax
int v11; // eax
char *v12; // [rsp+8h] [rbp-38h] BYREF
long long v13; // [rsp+10h] [rbp-30h]
v13 = a1;
v9 = 0;
if ( *a3 < 0 )
v9 = *(_DWORD *)(*(_QWORD *)v13 + 380LL);
if ( (*(_BYTE *)(a2 + 10) & 0x28) != 0 )
{
v12 = &a3[v9 + 2];
*a4 = 0;
while ( 1 )
{
result = v12;
if ( (unsigned long long)v12 > a5 )
break;
v11 = (*(long long ( **)(long long, _QWORD, char **, _BYTE *))(a2 + 72))(a2, v9, &v12, a4);
*a6 = v11;
if ( !v11 )
{
mi_report_error(126, *(_QWORD *)(*(_QWORD *)v13 + 616LL));
*(_DWORD *)my_thread_var(126LL) = 126;
return 0LL;
}
}
}
else
{
memmove(a4, a5, v9 + *(unsigned __int16 *)(a2 + 18));
return (char *)(*(unsigned __int16 *)(a2 + 18) + a5 + v9);
}
return result;
}
| _mi_get_key:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R13,R9
MOV RBX,R8
MOV R12,RCX
MOV R14,RSI
MOV qword ptr [RBP + -0x30],RDI
XOR R15D,R15D
CMP byte ptr [RDX],0x0
JNS 0x00188b7b
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV R15D,dword ptr [RAX + 0x17c]
LAB_00188b7b:
TEST byte ptr [R14 + 0xa],0x28
JZ 0x00188bde
LEA EAX,[R15 + 0x2]
ADD RDX,RAX
LEA RAX,[RBP + -0x38]
MOV qword ptr [RAX],RDX
MOV byte ptr [R12],0x0
LAB_00188b95:
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,RBX
JA 0x00188bff
MOV RDI,R14
MOV ESI,R15D
LEA RDX,[RBP + -0x38]
MOV RCX,R12
CALL qword ptr [R14 + 0x48]
MOV dword ptr [R13],EAX
TEST EAX,EAX
JNZ 0x00188b95
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x268]
MOV EDI,0x7e
CALL 0x0017e01a
CALL 0x001a48d6
MOV dword ptr [RAX],0x7e
XOR EAX,EAX
JMP 0x00188bff
LAB_00188bde:
MOVZX EDX,word ptr [R14 + 0x12]
ADD EDX,R15D
MOV RDI,R12
MOV RSI,RBX
CALL 0x00129120
MOVZX ECX,word ptr [R14 + 0x12]
MOV EAX,R15D
ADD RAX,RBX
ADD RAX,RCX
LAB_00188bff:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
char * _mi_get_key(long *param_1,long param_2,char *param_3,int1 *param_4,char *param_5,
int *param_6)
{
int iVar1;
int4 *puVar2;
uint uVar3;
char *local_40;
long *local_38;
uVar3 = 0;
if (*param_3 < '\0') {
uVar3 = *(uint *)(*param_1 + 0x17c);
}
local_38 = param_1;
if ((*(byte *)(param_2 + 10) & 0x28) == 0) {
memmove(param_4,param_5,(ulong)(*(ushort *)(param_2 + 0x12) + uVar3));
param_5 = param_5 + (ulong)*(ushort *)(param_2 + 0x12) + (ulong)uVar3;
}
else {
local_40 = param_3 + (uVar3 + 2);
*param_4 = 0;
do {
if (param_5 < local_40) {
return local_40;
}
iVar1 = (**(code **)(param_2 + 0x48))(param_2,uVar3,&local_40,param_4);
*param_6 = iVar1;
} while (iVar1 != 0);
mi_report_error(0x7e,*(int8 *)(*local_38 + 0x268));
puVar2 = (int4 *)_my_thread_var();
*puVar2 = 0x7e;
param_5 = (char *)0x0;
}
return param_5;
}
| |
54,112 | flatbuffers::FlatBufferBuilder::NotNested() | mnn-tts/MNN/3rd_party/flatbuffers/include/flatbuffers/flatbuffers.h | void NotNested() {
// If you hit this, you're trying to construct a Table/Vector/String
// during the construction of its parent table (between the MyTableBuilder
// and table.Finish().
// Move the creation of these sub-objects to above the MyTableBuilder to
// not get this assert.
// Ignoring this assert may appear to work in simple cases, but the reason
// it is here is that storing objects in-line may cause vtable offsets
// to not fit anymore. It also leads to vtable duplication.
FLATBUFFERS_ASSERT(!nested);
// If you hit this, fields were added outside the scope of a table.
FLATBUFFERS_ASSERT(!num_field_loc);
} | O0 | c | flatbuffers::FlatBufferBuilder::NotNested():
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movb 0x46(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xa65e
jmp 0xa660
jmp 0xa67f
leaq 0x32f87(%rip), %rdi # 0x3d5ee
leaq 0x32efb(%rip), %rsi # 0x3d569
movl $0x47d, %edx # imm = 0x47D
leaq 0x32f7c(%rip), %rcx # 0x3d5f6
callq 0x30c0
movq 0x8(%rsp), %rax
cmpl $0x0, 0x40(%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xa693
jmp 0xa695
jmp 0xa6b4
leaq 0x32f8b(%rip), %rdi # 0x3d627
leaq 0x32ec6(%rip), %rsi # 0x3d569
movl $0x47f, %edx # imm = 0x47F
leaq 0x32f47(%rip), %rcx # 0x3d5f6
callq 0x30c0
addq $0x18, %rsp
retq
nopl (%rax)
| _ZN11flatbuffers17FlatBufferBuilder9NotNestedEv:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov rax, [rsp+18h+var_8]
mov [rsp+18h+var_10], rax
mov al, [rax+46h]
xor al, 0FFh
test al, 1
jnz short loc_A65E
jmp short loc_A660
loc_A65E:
jmp short loc_A67F
loc_A660:
lea rdi, aNested; "!nested"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github2025/mnn-tt"...
mov edx, 47Dh
lea rcx, aVoidFlatbuffer_0; "void flatbuffers::FlatBufferBuilder::No"...
call ___assert_fail
loc_A67F:
mov rax, [rsp+18h+var_10]
cmp dword ptr [rax+40h], 0
setnz al
xor al, 0FFh
test al, 1
jnz short loc_A693
jmp short loc_A695
loc_A693:
jmp short loc_A6B4
loc_A695:
lea rdi, aNumFieldLoc; "!num_field_loc"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github2025/mnn-tt"...
mov edx, 47Fh
lea rcx, aVoidFlatbuffer_0; "void flatbuffers::FlatBufferBuilder::No"...
call ___assert_fail
loc_A6B4:
add rsp, 18h
retn
| char flatbuffers::FlatBufferBuilder::NotNested(flatbuffers::FlatBufferBuilder *this)
{
char result; // al
if ( (*((_BYTE *)this + 70) & 1) != 0 )
__assert_fail(
"!nested",
"/workspace/llm4binary/github2025/mnn-tts/MNN/3rd_party/flatbuffers/include/flatbuffers/flatbuffers.h",
1149LL,
"void flatbuffers::FlatBufferBuilder::NotNested()");
result = ~(*((_DWORD *)this + 16) != 0);
if ( *((_DWORD *)this + 16) )
__assert_fail(
"!num_field_loc",
"/workspace/llm4binary/github2025/mnn-tts/MNN/3rd_party/flatbuffers/include/flatbuffers/flatbuffers.h",
1151LL,
"void flatbuffers::FlatBufferBuilder::NotNested()");
return result;
}
| NotNested:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RAX
MOV AL,byte ptr [RAX + 0x46]
XOR AL,0xff
TEST AL,0x1
JNZ 0x0010a65e
JMP 0x0010a660
LAB_0010a65e:
JMP 0x0010a67f
LAB_0010a660:
LEA RDI,[0x13d5ee]
LEA RSI,[0x13d569]
MOV EDX,0x47d
LEA RCX,[0x13d5f6]
CALL 0x001030c0
LAB_0010a67f:
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RAX + 0x40],0x0
SETNZ AL
XOR AL,0xff
TEST AL,0x1
JNZ 0x0010a693
JMP 0x0010a695
LAB_0010a693:
JMP 0x0010a6b4
LAB_0010a695:
LEA RDI,[0x13d627]
LEA RSI,[0x13d569]
MOV EDX,0x47f
LEA RCX,[0x13d5f6]
CALL 0x001030c0
LAB_0010a6b4:
ADD RSP,0x18
RET
|
/* flatbuffers::FlatBufferBuilder::NotNested() */
void __thiscall flatbuffers::FlatBufferBuilder::NotNested(FlatBufferBuilder *this)
{
if ((((byte)this[0x46] ^ 0xff) & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("!nested",
"/workspace/llm4binary/github2025/mnn-tts/MNN/3rd_party/flatbuffers/include/flatbuffers/flatbuffers.h"
,0x47d,"void flatbuffers::FlatBufferBuilder::NotNested()");
}
if (*(int *)(this + 0x40) != 0) {
/* WARNING: Subroutine does not return */
__assert_fail("!num_field_loc",
"/workspace/llm4binary/github2025/mnn-tts/MNN/3rd_party/flatbuffers/include/flatbuffers/flatbuffers.h"
,0x47f,"void flatbuffers::FlatBufferBuilder::NotNested()");
}
return;
}
| |
54,113 | set_result_format_version(unsigned long) | eloqsql/client/mysqltest.cc | static void
set_result_format_version(ulong new_version)
{
switch (new_version){
case 1:
/* The first format */
break;
case 2:
/* New format that also writes comments and empty lines
from test file to result */
break;
default:
die("Version format %lu has not yet been implemented", new_version);
break;
}
opt_result_format_version= new_version;
} | O0 | cpp | set_result_format_version(unsigned long):
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
subq $0x1, %rax
je 0x766f8
jmp 0x766ec
movq -0x10(%rbp), %rax
subq $0x2, %rax
je 0x766fa
jmp 0x766fc
jmp 0x7670e
jmp 0x7670e
movq -0x8(%rbp), %rsi
leaq 0xf2e2e(%rip), %rdi # 0x169535
movb $0x0, %al
callq 0x62b40
movq -0x8(%rbp), %rax
movl %eax, 0x4446d8(%rip) # 0x4badf0
addq $0x10, %rsp
popq %rbp
retq
nop
| _ZL25set_result_format_versionm:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
sub rax, 1
jz short loc_766F8
jmp short $+2
loc_766EC:
mov rax, [rbp+var_10]
sub rax, 2
jz short loc_766FA
jmp short loc_766FC
loc_766F8:
jmp short loc_7670E
loc_766FA:
jmp short loc_7670E
loc_766FC:
mov rsi, [rbp+var_8]
lea rdi, aVersionFormatL; "Version format %lu has not yet been imp"...
mov al, 0
call _ZL3diePKcz; die(char const*,...)
loc_7670E:
mov rax, [rbp+var_8]
mov cs:_ZL25opt_result_format_version, eax; opt_result_format_version
add rsp, 10h
pop rbp
retn
| long long set_result_format_version(long long a1)
{
long long result; // rax
if ( a1 != 1 && a1 != 2 )
die("Version format %lu has not yet been implemented", a1);
result = a1;
opt_result_format_version = a1;
return result;
}
| set_result_format_version:
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
SUB RAX,0x1
JZ 0x001766f8
JMP 0x001766ec
LAB_001766ec:
MOV RAX,qword ptr [RBP + -0x10]
SUB RAX,0x2
JZ 0x001766fa
JMP 0x001766fc
LAB_001766f8:
JMP 0x0017670e
LAB_001766fa:
JMP 0x0017670e
LAB_001766fc:
MOV RSI,qword ptr [RBP + -0x8]
LEA RDI,[0x269535]
MOV AL,0x0
CALL 0x00162b40
LAB_0017670e:
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [0x005badf0],EAX
ADD RSP,0x10
POP RBP
RET
|
/* set_result_format_version(unsigned long) */
void set_result_format_version(ulong param_1)
{
if ((param_1 != 1) && (param_1 != 2)) {
die("Version format %lu has not yet been implemented",param_1);
}
opt_result_format_version = (int)param_1;
return;
}
| |
54,114 | ma_bitmap_create_first | eloqsql/storage/maria/ma_bitmap.c | int _ma_bitmap_create_first(MARIA_SHARE *share)
{
uint block_size= share->bitmap.block_size;
File file= share->bitmap.file.file;
uchar marker[CRC_SIZE];
/*
Next write operation of the page will write correct CRC
if it is needed
*/
int4store(marker, MARIA_NO_CRC_BITMAP_PAGE);
if (mysql_file_chsize(file, block_size - sizeof(marker),
0, MYF(MY_WME)) ||
my_pwrite(file, marker, sizeof(marker),
block_size - sizeof(marker),
MYF(MY_NABP | MY_WME)))
return 1;
share->state.state.data_file_length= block_size;
_ma_bitmap_delete_all(share);
return 0;
} | O0 | c | ma_bitmap_create_first:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0xb44(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0xa60(%rax), %eax
movl %eax, -0x20(%rbp)
leaq -0xc(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0xfffffffe, (%rax) # imm = 0xFFFFFFFE
movl -0x20(%rbp), %edx
movl -0x1c(%rbp), %eax
movl %eax, %ecx
subq $0x4, %rcx
leaq 0x10d3c4(%rip), %rdi # 0x15168c
movl $0xc0f, %esi # imm = 0xC0F
xorl %r8d, %r8d
movl $0x10, %r9d
callq 0x44360
cmpl $0x0, %eax
jne 0x44306
movl -0x20(%rbp), %edi
leaq -0xc(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %ecx
subq $0x4, %rcx
movl $0x4, %edx
movl $0x14, %r8d
callq 0xf4890
cmpq $0x0, %rax
je 0x4430f
movl $0x1, -0x10(%rbp)
jmp 0x4432c
movl -0x1c(%rbp), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rdi
callq 0x42460
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x4434d
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
callq 0x2a270
nopw %cs:(%rax,%rax)
| _ma_bitmap_create_first:
push rbp
mov rbp, rsp
sub rsp, 30h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_18], rdi
mov rax, [rbp+var_18]
mov eax, [rax+0B44h]
mov [rbp+var_1C], eax
mov rax, [rbp+var_18]
mov eax, [rax+0A60h]
mov [rbp+var_20], eax
lea rax, [rbp+var_C]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov dword ptr [rax], 0FFFFFFFEh
mov edx, [rbp+var_20]
mov eax, [rbp+var_1C]
mov ecx, eax
sub rcx, 4
lea rdi, aWorkspaceLlm4b_6; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 0C0Fh
xor r8d, r8d
mov r9d, 10h
call inline_mysql_file_chsize
cmp eax, 0
jnz short loc_44306
mov edi, [rbp+var_20]
lea rsi, [rbp+var_C]
mov eax, [rbp+var_1C]
mov ecx, eax
sub rcx, 4
mov edx, 4
mov r8d, 14h
call my_pwrite
cmp rax, 0
jz short loc_4430F
loc_44306:
mov [rbp+var_10], 1
jmp short loc_4432C
loc_4430F:
mov eax, [rbp+var_1C]
mov ecx, eax
mov rax, [rbp+var_18]
mov [rax+40h], rcx
mov rdi, [rbp+var_18]
call _ma_bitmap_delete_all
mov [rbp+var_10], 0
loc_4432C:
mov eax, [rbp+var_10]
mov [rbp+var_2C], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_4434D
mov eax, [rbp+var_2C]
add rsp, 30h
pop rbp
retn
loc_4434D:
call ___stack_chk_fail
| long long ma_bitmap_create_first(long long a1)
{
unsigned int v2; // [rsp+10h] [rbp-20h]
unsigned int v3; // [rsp+14h] [rbp-1Ch]
int v5; // [rsp+24h] [rbp-Ch] BYREF
unsigned long long v6; // [rsp+28h] [rbp-8h]
v6 = __readfsqword(0x28u);
v3 = *(_DWORD *)(a1 + 2884);
v2 = *(_DWORD *)(a1 + 2656);
v5 = -2;
if ( (unsigned int)inline_mysql_file_chsize(
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",
3087LL,
v2,
v3 - 4LL,
0LL,
16LL)
|| my_pwrite(v2, &v5, 4LL, v3 - 4LL) )
{
return 1;
}
else
{
*(_QWORD *)(a1 + 64) = v3;
ma_bitmap_delete_all(a1);
return 0;
}
}
| _ma_bitmap_create_first:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0xb44]
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0xa60]
MOV dword ptr [RBP + -0x20],EAX
LEA RAX,[RBP + -0xc]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],0xfffffffe
MOV EDX,dword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x1c]
MOV ECX,EAX
SUB RCX,0x4
LEA RDI,[0x25168c]
MOV ESI,0xc0f
XOR R8D,R8D
MOV R9D,0x10
CALL 0x00144360
CMP EAX,0x0
JNZ 0x00144306
MOV EDI,dword ptr [RBP + -0x20]
LEA RSI,[RBP + -0xc]
MOV EAX,dword ptr [RBP + -0x1c]
MOV ECX,EAX
SUB RCX,0x4
MOV EDX,0x4
MOV R8D,0x14
CALL 0x001f4890
CMP RAX,0x0
JZ 0x0014430f
LAB_00144306:
MOV dword ptr [RBP + -0x10],0x1
JMP 0x0014432c
LAB_0014430f:
MOV EAX,dword ptr [RBP + -0x1c]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x40],RCX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00142460
MOV dword ptr [RBP + -0x10],0x0
LAB_0014432c:
MOV EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0014434d
MOV EAX,dword ptr [RBP + -0x2c]
ADD RSP,0x30
POP RBP
RET
LAB_0014434d:
CALL 0x0012a270
|
int4 _ma_bitmap_create_first(long param_1)
{
uint uVar1;
int4 uVar2;
int iVar3;
long lVar4;
long in_FS_OFFSET;
int4 local_18;
int4 local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar1 = *(uint *)(param_1 + 0xb44);
uVar2 = *(int4 *)(param_1 + 0xa60);
local_14 = 0xfffffffe;
iVar3 = inline_mysql_file_chsize
("/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",0xc0f,
uVar2,(ulong)uVar1 - 4,0,0x10);
if (iVar3 == 0) {
lVar4 = my_pwrite(uVar2,&local_14,4,(ulong)uVar1 - 4,0x14);
if (lVar4 == 0) {
*(ulong *)(param_1 + 0x40) = (ulong)uVar1;
_ma_bitmap_delete_all(param_1);
local_18 = 0;
goto LAB_0014432c;
}
}
local_18 = 1;
LAB_0014432c:
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_18;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
54,115 | ma_bitmap_create_first | eloqsql/storage/maria/ma_bitmap.c | int _ma_bitmap_create_first(MARIA_SHARE *share)
{
uint block_size= share->bitmap.block_size;
File file= share->bitmap.file.file;
uchar marker[CRC_SIZE];
/*
Next write operation of the page will write correct CRC
if it is needed
*/
int4store(marker, MARIA_NO_CRC_BITMAP_PAGE);
if (mysql_file_chsize(file, block_size - sizeof(marker),
0, MYF(MY_WME)) ||
my_pwrite(file, marker, sizeof(marker),
block_size - sizeof(marker),
MYF(MY_NABP | MY_WME)))
return 1;
share->state.state.data_file_length= block_size;
_ma_bitmap_delete_all(share);
return 0;
} | O3 | c | ma_bitmap_create_first:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movl 0xa60(%rdi), %r14d
movl 0xb44(%rdi), %r13d
movl $0xfffffffe, -0x34(%rbp) # imm = 0xFFFFFFFE
leaq -0x4(%r13), %r15
leaq 0x344156(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x80(%rbp), %rdi
movl %r14d, %esi
movl $0xd, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x41f3f
movl $0x10, %ecx
movl %r14d, %edi
movq %r15, %rsi
xorl %edx, %edx
callq 0x9dda8
movl $0x1, %r12d
testl %eax, %eax
jne 0x41f1e
leaq -0x34(%rbp), %rsi
movl $0x4, %edx
movl $0x14, %r8d
movl %r14d, %edi
movq %r15, %rcx
callq 0xa07ee
testq %rax, %rax
jne 0x41f1e
movq %r13, 0x40(%rbx)
movq %rbx, %rdi
callq 0x4022c
xorl %r12d, %r12d
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x41f5a
movl %r12d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x38(%rbp), %r12
movq %rax, %rdi
movq %r15, %rsi
movl %r14d, %edx
movq %r12, %rcx
callq 0x29e17
movl (%r12), %eax
jmp 0x41ee6
callq 0x29270
| _ma_bitmap_create_first:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov r14d, [rdi+0A60h]
mov r13d, [rdi+0B44h]
mov [rbp+var_34], 0FFFFFFFEh
lea r15, [r13-4]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_80]
mov esi, r14d
mov edx, 0Dh
call qword ptr [rax+158h]
test rax, rax
jnz short loc_41F3F
mov ecx, 10h
mov edi, r14d
mov rsi, r15
xor edx, edx
call my_chsize
loc_41EE6:
mov r12d, 1
test eax, eax
jnz short loc_41F1E
lea rsi, [rbp+var_34]
mov edx, 4
mov r8d, 14h
mov edi, r14d
mov rcx, r15
call my_pwrite
test rax, rax
jnz short loc_41F1E
mov [rbx+40h], r13
mov rdi, rbx
call _ma_bitmap_delete_all
xor r12d, r12d
loc_41F1E:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_41F5A
mov eax, r12d
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_41F3F:
lea r12, [rbp+var_38]
mov rdi, rax
mov rsi, r15
mov edx, r14d
mov rcx, r12
call _ma_bitmap_create_first_cold_1
mov eax, [r12]
jmp short loc_41EE6
loc_41F5A:
call ___stack_chk_fail
| long long ma_bitmap_create_first(long long a1)
{
unsigned int v1; // r14d
long long v2; // r13
long long v3; // rax
int v4; // eax
unsigned int v5; // r12d
_BYTE v7[72]; // [rsp+0h] [rbp-80h] BYREF
int v8; // [rsp+48h] [rbp-38h] BYREF
int v9; // [rsp+4Ch] [rbp-34h] BYREF
unsigned long long v10; // [rsp+50h] [rbp-30h]
v10 = __readfsqword(0x28u);
v1 = *(_DWORD *)(a1 + 2656);
v2 = *(unsigned int *)(a1 + 2884);
v9 = -2;
v3 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v7, v1, 13LL);
if ( v3 )
{
ma_bitmap_create_first_cold_1(v3, v2 - 4, v1, &v8);
v4 = v8;
}
else
{
v4 = my_chsize(v1, v2 - 4, 0LL, 16LL);
}
v5 = 1;
if ( !v4 && !my_pwrite(v1, &v9, 4LL, v2 - 4, 20LL) )
{
*(_QWORD *)(a1 + 64) = v2;
ma_bitmap_delete_all(a1);
return 0;
}
return v5;
}
| _ma_bitmap_create_first:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R14D,dword ptr [RDI + 0xa60]
MOV R13D,dword ptr [RDI + 0xb44]
MOV dword ptr [RBP + -0x34],0xfffffffe
LEA R15,[R13 + -0x4]
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x80]
MOV ESI,R14D
MOV EDX,0xd
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00141f3f
MOV ECX,0x10
MOV EDI,R14D
MOV RSI,R15
XOR EDX,EDX
CALL 0x0019dda8
LAB_00141ee6:
MOV R12D,0x1
TEST EAX,EAX
JNZ 0x00141f1e
LEA RSI,[RBP + -0x34]
MOV EDX,0x4
MOV R8D,0x14
MOV EDI,R14D
MOV RCX,R15
CALL 0x001a07ee
TEST RAX,RAX
JNZ 0x00141f1e
MOV qword ptr [RBX + 0x40],R13
MOV RDI,RBX
CALL 0x0014022c
XOR R12D,R12D
LAB_00141f1e:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00141f5a
MOV EAX,R12D
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00141f3f:
LEA R12,[RBP + -0x38]
MOV RDI,RAX
MOV RSI,R15
MOV EDX,R14D
MOV RCX,R12
CALL 0x00129e17
MOV EAX,dword ptr [R12]
JMP 0x00141ee6
LAB_00141f5a:
CALL 0x00129270
|
/* WARNING: Type propagation algorithm not settling */
int8 _ma_bitmap_create_first(long param_1)
{
int4 uVar1;
uint uVar2;
long lVar3;
long lVar4;
int8 uVar5;
long in_FS_OFFSET;
int1 local_88 [72];
int local_40 [2];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar1 = *(int4 *)(param_1 + 0xa60);
uVar2 = *(uint *)(param_1 + 0xb44);
local_40[1] = 0xfffffffe;
lVar4 = (ulong)uVar2 - 4;
lVar3 = (**(code **)(PSI_server + 0x158))(local_88,uVar1,0xd);
if (lVar3 == 0) {
local_40[0] = my_chsize(uVar1,lVar4,0,0x10);
}
else {
_ma_bitmap_create_first_cold_1(lVar3,lVar4,uVar1,local_40);
}
uVar5 = 1;
if (local_40[0] == 0) {
lVar4 = my_pwrite(uVar1,local_40 + 1,4,lVar4,0x14);
if (lVar4 == 0) {
*(ulong *)(param_1 + 0x40) = (ulong)uVar2;
_ma_bitmap_delete_all(param_1);
uVar5 = 0;
}
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return uVar5;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
54,116 | open_cached_file | eloqsql/mysys/mf_cache.c | my_bool open_cached_file(IO_CACHE *cache, const char* dir, const char *prefix,
size_t cache_size, myf cache_myflags)
{
DBUG_ENTER("open_cached_file");
cache->dir= dir;
if (prefix)
{
DBUG_ASSERT(strlen(prefix) == 2);
memcpy(cache->prefix, prefix, 3);
}
else
cache->prefix[0]= 0;
cache->file_name=0;
cache->buffer=0; /* Mark that not open */
if (!init_io_cache(cache, -1, cache_size, WRITE_CACHE, 0L, 0,
MYF(cache_myflags | MY_NABP)))
{
DBUG_RETURN(0);
}
DBUG_RETURN(1);
} | O3 | c | open_cached_file:
movq %rsi, 0xc8(%rdi)
leaq 0xd0(%rdi), %rax
testq %rdx, %rdx
je 0xaf71f
movb 0x2(%rdx), %sil
movb %sil, 0x2(%rax)
movzwl (%rdx), %edx
movw %dx, (%rax)
jmp 0xaf722
movb $0x0, (%rax)
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %eax, %eax
movq %rax, 0xc0(%rdi)
movq %rax, 0x20(%rdi)
orq $0x4, %r8
movq %r8, (%rsp)
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movq %rcx, %rdx
movl $0x2, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x98c3a
testl %eax, %eax
setne %al
addq $0x10, %rsp
popq %rbp
retq
| open_cached_file:
mov [rdi+0C8h], rsi
lea rax, [rdi+0D0h]
test rdx, rdx
jz short loc_AF71F
mov sil, [rdx+2]
mov [rax+2], sil
movzx edx, word ptr [rdx]
mov [rax], dx
jmp short loc_AF722
loc_AF71F:
mov byte ptr [rax], 0
loc_AF722:
push rbp
mov rbp, rsp
sub rsp, 10h
xor eax, eax
mov [rdi+0C0h], rax
mov [rdi+20h], rax
or r8, 4
mov [rsp+18h+var_18], r8
mov esi, 0FFFFFFFFh
mov rdx, rcx
mov ecx, 2
xor r8d, r8d
xor r9d, r9d
call init_io_cache
test eax, eax
setnz al
add rsp, 10h
pop rbp
retn
| bool open_cached_file(long long a1, long long a2, long long a3, unsigned long long a4, long long a5)
{
_WORD *v5; // rax
*(_QWORD *)(a1 + 200) = a2;
v5 = (_WORD *)(a1 + 208);
if ( a3 )
{
*(_BYTE *)(a1 + 210) = *(_BYTE *)(a3 + 2);
*v5 = *(_WORD *)a3;
}
else
{
*(_BYTE *)v5 = 0;
}
*(_QWORD *)(a1 + 192) = 0LL;
*(_QWORD *)(a1 + 32) = 0LL;
return (unsigned int)init_io_cache(a1, 0xFFFFFFFF, a4, 2, 0LL, 0, a5 | 4) != 0;
}
| open_cached_file:
MOV qword ptr [RDI + 0xc8],RSI
LEA RAX,[RDI + 0xd0]
TEST RDX,RDX
JZ 0x001af71f
MOV SIL,byte ptr [RDX + 0x2]
MOV byte ptr [RAX + 0x2],SIL
MOVZX EDX,word ptr [RDX]
MOV word ptr [RAX],DX
JMP 0x001af722
LAB_001af71f:
MOV byte ptr [RAX],0x0
LAB_001af722:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
XOR EAX,EAX
MOV qword ptr [RDI + 0xc0],RAX
MOV qword ptr [RDI + 0x20],RAX
OR R8,0x4
MOV qword ptr [RSP],R8
MOV ESI,0xffffffff
MOV RDX,RCX
MOV ECX,0x2
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00198c3a
TEST EAX,EAX
SETNZ AL
ADD RSP,0x10
POP RBP
RET
|
bool open_cached_file(long param_1,int8 param_2,int2 *param_3,int8 param_4,
ulong param_5)
{
int iVar1;
*(int8 *)(param_1 + 200) = param_2;
if (param_3 == (int2 *)0x0) {
*(int1 *)(param_1 + 0xd0) = 0;
}
else {
*(int1 *)(param_1 + 0xd2) = *(int1 *)(param_3 + 1);
*(int2 *)(param_1 + 0xd0) = *param_3;
}
*(int8 *)(param_1 + 0xc0) = 0;
*(int8 *)(param_1 + 0x20) = 0;
iVar1 = init_io_cache(param_1,0xffffffff,param_4,2,0,0,param_5 | 4);
return iVar1 != 0;
}
| |
54,117 | minja::TemplateNode::render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/minja.hpp | void render(std::ostringstream & out, const std::shared_ptr<Context> & context) const {
try {
do_render(out, context);
} catch (const LoopControlException & e) {
// TODO: make stack creation lazy. Only needed if it was thrown outside of a loop.
std::ostringstream err;
err << e.what();
if (location_.source) err << error_location_suffix(*location_.source, location_.pos);
throw LoopControlException(err.str(), e.control_type);
} catch (const std::exception & e) {
std::ostringstream err;
err << e.what();
if (location_.source) err << error_location_suffix(*location_.source, location_.pos);
throw std::runtime_error(err.str());
}
} | O3 | cpp | minja::TemplateNode::render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, %r14
movq (%rdi), %rax
callq *(%rax)
addq $0x1a0, %rsp # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
cmpl $0x2, %edx
jne 0x99f71
movq %rbx, %rdi
callq 0x1b380
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1bb70
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x1b870
movq 0x8(%r14), %rsi
testq %rsi, %rsi
jne 0x99ff6
movl $0x18, %edi
callq 0x1b440
movq %rax, %r14
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1bd90
movl 0x10(%rbx), %ebx
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x1ba90
leaq 0x930af(%rip), %rax # 0x12cff8
addq $0x10, %rax
movq %rax, (%r14)
movl %ebx, 0x10(%r14)
xorl %ebp, %ebp
leaq 0x93083(%rip), %rsi # 0x12cfe0
movq 0x9400c(%rip), %rdx # 0x12df70
movq %r14, %rdi
callq 0x1bef0
jmp 0x99ff6
cmpl $0x1, %edx
jne 0x9a193
movq %rbx, %rdi
callq 0x1b380
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1bb70
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x1b870
movq 0x8(%r14), %rsi
testq %rsi, %rsi
jne 0x9a03c
movl $0x10, %edi
callq 0x1b440
movq %rax, %r14
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1bd90
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x1be00
xorl %ebp, %ebp
movq 0x94001(%rip), %rsi # 0x12dfe8
movq 0x93f62(%rip), %rdx # 0x12df50
movq %r14, %rdi
callq 0x1bef0
movq 0x18(%r14), %rdx
leaq 0x8(%rsp), %rdi
callq 0x778b0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x1b9c0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x99f13
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8b0
jmp 0x99f13
movq 0x18(%r14), %rdx
leaq 0x8(%rsp), %rdi
callq 0x778b0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x1b9c0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x99fb2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8b0
jmp 0x99fb2
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9a13e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8b0
jmp 0x9a13e
jmp 0x9a13b
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9a16b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8b0
jmp 0x9a16b
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9a0f3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8b0
testb %bpl, %bpl
jne 0x9a0fd
jmp 0x9a13e
movq %rax, %rbx
movq %r14, %rdi
callq 0x1b650
jmp 0x9a13e
jmp 0x9a168
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9a127
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8b0
testb %bpl, %bpl
jne 0x9a131
jmp 0x9a16b
movq %rax, %rbx
movq %r14, %rdi
callq 0x1b650
jmp 0x9a16b
movq %rax, %rbx
movq 0x93e23(%rip), %rsi # 0x12df68
leaq 0x28(%rsp), %rdi
callq 0x1b490
leaq 0x98(%rsp), %rdi
callq 0x1b2b0
jmp 0x9a161
movq %rax, %rbx
callq 0x1be30
jmp 0x9a193
movq %rax, %rbx
movq 0x93df6(%rip), %rsi # 0x12df68
leaq 0x28(%rsp), %rdi
callq 0x1b490
leaq 0x98(%rsp), %rdi
callq 0x1b2b0
jmp 0x9a18e
movq %rax, %rbx
callq 0x1be30
movq %rbx, %rdi
callq 0x1bf70
movq %rax, %rdi
callq 0x21ae5
nop
| _ZNK5minja12TemplateNode6renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS_7ContextEE:
push rbp
push r14
push rbx
sub rsp, 1A0h
mov r14, rdi
mov rax, [rdi]
call qword ptr [rax]
add rsp, 1A0h
pop rbx
pop r14
pop rbp
retn
mov rbx, rax
cmp edx, 2
jnz loc_99F71
mov rdi, rbx; void *
call ___cxa_begin_catch
mov rbx, rax
lea rdi, [rsp+arg_20]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+10h]
lea rdi, [rsp+arg_20]
mov rsi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rsi, [r14+8]; int
test rsi, rsi
jnz loc_99FF6
loc_99F13:
mov edi, 18h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, [rsp+arg_28]
lea rdi, [rsp+arg_0]
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov ebx, [rbx+10h]
mov bpl, 1
lea rsi, [rsp+arg_0]
mov rdi, r14
call __ZNSt13runtime_errorC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
lea rax, _ZTVN5minja20LoopControlExceptionE; `vtable for'minja::LoopControlException
add rax, 10h
mov [r14], rax
mov [r14+10h], ebx
xor ebp, ebp
lea rsi, _ZTIN5minja20LoopControlExceptionE; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD2Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
| long long minja::TemplateNode::render(long long ( ***a1)(_QWORD))
{
return (**a1)(a1);
}
| render:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x1a0
MOV R14,RDI
MOV RAX,qword ptr [RDI]
LAB_00199ec1:
CALL qword ptr [RAX]
LAB_00199ec3:
ADD RSP,0x1a0
POP RBX
POP R14
POP RBP
RET
|
/* minja::TemplateNode::render(std::__cxx11::ostringstream&, std::shared_ptr<minja::Context> const&)
const */
void minja::TemplateNode::render(ostringstream *param_1,shared_ptr *param_2)
{
/* try { // try from 00199ec1 to 00199ec2 has its CatchHandler @ 00199ecf */
(*(code *)**(int8 **)param_1)();
return;
}
| |
54,118 | ma_tls_start | eloqsql/libmariadb/libmariadb/secure/openssl.c | int ma_tls_start(char *errmsg __attribute__((unused)), size_t errmsg_len __attribute__((unused)))
{
int rc= 1;
char *p;
if (ma_tls_initialized)
return 0;
/* lock mutex to prevent multiple initialization */
pthread_mutex_init(&LOCK_openssl_config, NULL);
pthread_mutex_lock(&LOCK_openssl_config);
#ifdef HAVE_OPENSSL_1_1_API
if (!OPENSSL_init_ssl(OPENSSL_INIT_LOAD_CONFIG, NULL))
goto end;
#else
if (ssl_thread_init())
{
strncpy(errmsg, "Not enough memory", errmsg_len);
goto end;
}
SSL_library_init();
#if SSLEAY_VERSION_NUMBER >= 0x00907000L
OPENSSL_config(NULL);
#endif
#endif
#ifndef HAVE_OPENSSL_1_1_API
/* load errors */
SSL_load_error_strings();
/* digests and ciphers */
OpenSSL_add_all_algorithms();
#endif
disable_sigpipe();
#ifdef OPENSSL_USE_BIOMETHOD
memcpy(&ma_BIO_method, BIO_s_socket(), sizeof(BIO_METHOD));
ma_BIO_method.bread= ma_bio_read;
ma_BIO_method.bwrite= ma_bio_write;
#endif
snprintf(tls_library_version, TLS_VERSION_LENGTH - 1, "%s",
#if defined(LIBRESSL_VERSION_NUMBER) || !defined(HAVE_OPENSSL_1_1_API)
SSLeay_version(SSLEAY_VERSION));
#else
OpenSSL_version(OPENSSL_VERSION));
#endif
/* remove date from version */
if ((p= strstr(tls_library_version, " ")))
*p= 0;
rc= 0;
ma_tls_initialized= TRUE;
end:
pthread_mutex_unlock(&LOCK_openssl_config);
return rc;
} | O3 | c | ma_tls_start:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x23ebf(%rip), %r15 # 0x50530
xorl %ebx, %ebx
cmpb $0x0, (%r15)
jne 0x2c707
leaq 0x2578c(%rip), %rbx # 0x51e10
movq %rbx, %rdi
xorl %esi, %esi
callq 0x136d0
movq %rbx, %rdi
callq 0x136c0
movl $0x40, %edi
xorl %esi, %esi
callq 0x133d0
testl %eax, %eax
je 0x2c6f6
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x13880
leaq 0x2578a(%rip), %r14 # 0x51e40
leaq 0xccbe(%rip), %r8 # 0x3937b
movl $0x3f, %esi
movl $0x40, %ecx
movq %r14, %rdi
movl $0x1, %edx
movq %rax, %r9
xorl %eax, %eax
callq 0x132d0
leaq 0xef19(%rip), %rsi # 0x3b5f9
movq %r14, %rdi
callq 0x13100
testq %rax, %rax
je 0x2c6f0
movb $0x0, (%rax)
movb $0x1, (%r15)
jmp 0x2c6fb
movl $0x1, %ebx
leaq 0x2570e(%rip), %rdi # 0x51e10
callq 0x13340
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| ma_tls_start:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
lea r15, ma_tls_initialized
xor ebx, ebx
cmp byte ptr [r15], 0
jnz loc_2C707
lea rbx, LOCK_openssl_config
mov rdi, rbx
xor esi, esi
call _pthread_mutex_init
mov rdi, rbx
call _pthread_mutex_lock
mov edi, 40h ; '@'
xor esi, esi
call _OPENSSL_init_ssl
test eax, eax
jz short loc_2C6F6
xor ebx, ebx
xor edi, edi
call _OpenSSL_version
lea r14, tls_library_version
lea r8, aCouldnTSetOpti+23h; "%s"
mov esi, 3Fh ; '?'
mov ecx, 40h ; '@'
mov rdi, r14
mov edx, 1
mov r9, rax
xor eax, eax
call ___snprintf_chk
lea rsi, asc_3B5F9; " "
mov rdi, r14
call _strstr
test rax, rax
jz short loc_2C6F0
mov byte ptr [rax], 0
loc_2C6F0:
mov byte ptr [r15], 1
jmp short loc_2C6FB
loc_2C6F6:
mov ebx, 1
loc_2C6FB:
lea rdi, LOCK_openssl_config
call _pthread_mutex_unlock
loc_2C707:
mov eax, ebx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long ma_tls_start()
{
unsigned int v0; // ebx
const char *v1; // rax
_BYTE *v2; // rax
v0 = 0;
if ( !ma_tls_initialized )
{
pthread_mutex_init(&LOCK_openssl_config, 0LL);
pthread_mutex_lock(&LOCK_openssl_config);
if ( (unsigned int)OPENSSL_init_ssl(64LL, 0LL) )
{
v0 = 0;
v1 = (const char *)OpenSSL_version(0LL);
__snprintf_chk(&tls_library_version, 63LL, 1LL, 64LL, "%s", v1);
v2 = (_BYTE *)strstr(&tls_library_version, " ");
if ( v2 )
*v2 = 0;
ma_tls_initialized = 1;
}
else
{
v0 = 1;
}
pthread_mutex_unlock(&LOCK_openssl_config);
}
return v0;
}
| ma_tls_start:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
LEA R15,[0x150530]
XOR EBX,EBX
CMP byte ptr [R15],0x0
JNZ 0x0012c707
LEA RBX,[0x151e10]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x001136d0
MOV RDI,RBX
CALL 0x001136c0
MOV EDI,0x40
XOR ESI,ESI
CALL 0x001133d0
TEST EAX,EAX
JZ 0x0012c6f6
XOR EBX,EBX
XOR EDI,EDI
CALL 0x00113880
LEA R14,[0x151e40]
LEA R8,[0x13937b]
MOV ESI,0x3f
MOV ECX,0x40
MOV RDI,R14
MOV EDX,0x1
MOV R9,RAX
XOR EAX,EAX
CALL 0x001132d0
LEA RSI,[0x13b5f9]
MOV RDI,R14
CALL 0x00113100
TEST RAX,RAX
JZ 0x0012c6f0
MOV byte ptr [RAX],0x0
LAB_0012c6f0:
MOV byte ptr [R15],0x1
JMP 0x0012c6fb
LAB_0012c6f6:
MOV EBX,0x1
LAB_0012c6fb:
LEA RDI,[0x151e10]
CALL 0x00113340
LAB_0012c707:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int8 ma_tls_start(void)
{
int iVar1;
int8 uVar2;
char *pcVar3;
int8 uVar4;
uVar4 = 0;
if (ma_tls_initialized == '\0') {
pthread_mutex_init((pthread_mutex_t *)LOCK_openssl_config,(pthread_mutexattr_t *)0x0);
pthread_mutex_lock((pthread_mutex_t *)LOCK_openssl_config);
iVar1 = OPENSSL_init_ssl(0x40,0);
if (iVar1 == 0) {
uVar4 = 1;
}
else {
uVar4 = 0;
uVar2 = OpenSSL_version(0);
__snprintf_chk(tls_library_version,0x3f,1,0x40,"%s",uVar2);
pcVar3 = strstr(tls_library_version," ");
if (pcVar3 != (char *)0x0) {
*pcVar3 = '\0';
}
ma_tls_initialized = '\x01';
}
pthread_mutex_unlock((pthread_mutex_t *)LOCK_openssl_config);
}
return uVar4;
}
| |
54,119 | my_mb_wc_gbk | eloqsql/strings/ctype-gbk.c | static int
my_mb_wc_gbk(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e)
{
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
hi=s[0];
if (hi<0x80)
{
pwc[0]=hi;
return 1;
}
if (s+2>e)
return MY_CS_TOOSMALL2;
if (!IS_MB2_CHAR(hi, s[1]))
return MY_CS_ILSEQ;
if (!(pwc[0]=func_gbk_uni_onechar( (hi<<8) + s[1])))
return -2;
return 2;
} | O3 | c | my_mb_wc_gbk:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x3aed9
movsbq (%rdx), %rdi
testq %rdi, %rdi
js 0x3ae5d
movq %rdi, (%rsi)
movl $0x1, %eax
jmp 0x3aed9
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0x3aed9
movzbl %dil, %ecx
xorl %eax, %eax
cmpl $0x80, %ecx
je 0x3aed9
cmpl $0xff, %ecx
je 0x3aed9
movzbl 0x1(%rdx), %edx
leal -0x7f(%rdx), %edi
cmpb $-0x3f, %dil
setb %dil
cmpb $-0x1, %dl
setge %r8b
testb %dil, %r8b
jne 0x3aed9
shll $0x8, %ecx
leal (%rcx,%rdx), %eax
addl $0xffff7ec0, %eax # imm = 0xFFFF7EC0
cmpl $0x7d10, %eax # imm = 0x7D10
jae 0x3aecd
movl %eax, %eax
leaq 0x145409(%rip), %rcx # 0x1802c0
movzwl (%rcx,%rax,2), %eax
movzwl %ax, %ecx
movq %rcx, (%rsi)
movl $0x2, %eax
testw %cx, %cx
jne 0x3aed9
jmp 0x3aed4
movq $0x0, (%rsi)
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
popq %rbp
retq
| my_mb_wc_gbk:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb loc_3AED9
movsx rdi, byte ptr [rdx]
test rdi, rdi
js short loc_3AE5D
mov [rsi], rdi
mov eax, 1
jmp short loc_3AED9
loc_3AE5D:
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short loc_3AED9
movzx ecx, dil
xor eax, eax
cmp ecx, 80h
jz short loc_3AED9
cmp ecx, 0FFh
jz short loc_3AED9
movzx edx, byte ptr [rdx+1]
lea edi, [rdx-7Fh]
cmp dil, 0C1h
setb dil
cmp dl, 0FFh
setnl r8b
test r8b, dil
jnz short loc_3AED9
shl ecx, 8
lea eax, [rcx+rdx]
add eax, 0FFFF7EC0h
cmp eax, 7D10h
jnb short loc_3AECD
mov eax, eax
lea rcx, tab_gbk_uni0
movzx eax, word ptr [rcx+rax*2]
movzx ecx, ax
mov [rsi], rcx
mov eax, 2
test cx, cx
jnz short loc_3AED9
jmp short loc_3AED4
loc_3AECD:
mov qword ptr [rsi], 0
loc_3AED4:
mov eax, 0FFFFFFFEh
loc_3AED9:
pop rbp
retn
| long long my_mb_wc_gbk(long long a1, long long *a2, char *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rdi
int v6; // edx
unsigned int v7; // eax
long long v8; // rcx
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
v5 = *a3;
if ( v5 >= 0 )
{
*a2 = v5;
return 1LL;
}
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
result = 0LL;
if ( (unsigned __int8)v5 != 128 && (unsigned __int8)v5 != 255 )
{
v6 = (unsigned __int8)a3[1];
if ( (unsigned __int8)(v6 - 127) >= 0xC1u || (char)v6 < -1 )
{
v7 = ((unsigned __int8)v5 << 8) + v6 - 33088;
if ( v7 >= 0x7D10 )
{
*a2 = 0LL;
}
else
{
v8 = tab_gbk_uni0[v7];
*a2 = v8;
result = 2LL;
if ( (_WORD)v8 )
return result;
}
return 4294967294LL;
}
}
}
}
return result;
}
| my_mb_wc_gbk:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x0013aed9
MOVSX RDI,byte ptr [RDX]
TEST RDI,RDI
JS 0x0013ae5d
MOV qword ptr [RSI],RDI
MOV EAX,0x1
JMP 0x0013aed9
LAB_0013ae5d:
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x0013aed9
MOVZX ECX,DIL
XOR EAX,EAX
CMP ECX,0x80
JZ 0x0013aed9
CMP ECX,0xff
JZ 0x0013aed9
MOVZX EDX,byte ptr [RDX + 0x1]
LEA EDI,[RDX + -0x7f]
CMP DIL,0xc1
SETC DIL
CMP DL,0xff
SETGE R8B
TEST R8B,DIL
JNZ 0x0013aed9
SHL ECX,0x8
LEA EAX,[RCX + RDX*0x1]
ADD EAX,0xffff7ec0
CMP EAX,0x7d10
JNC 0x0013aecd
MOV EAX,EAX
LEA RCX,[0x2802c0]
MOVZX EAX,word ptr [RCX + RAX*0x2]
MOVZX ECX,AX
MOV qword ptr [RSI],RCX
MOV EAX,0x2
TEST CX,CX
JNZ 0x0013aed9
JMP 0x0013aed4
LAB_0013aecd:
MOV qword ptr [RSI],0x0
LAB_0013aed4:
MOV EAX,0xfffffffe
LAB_0013aed9:
POP RBP
RET
|
int8 my_mb_wc_gbk(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
byte bVar2;
ushort uVar3;
uint uVar4;
int8 uVar5;
uVar5 = 0xffffff9b;
if (param_3 < param_4) {
bVar1 = *param_3;
if ((long)(char)bVar1 < 0) {
uVar5 = 0xffffff9a;
if ((((param_3 + 2 <= param_4) && (uVar5 = 0, bVar1 != 0x80)) && (bVar1 != 0xff)) &&
(bVar2 = param_3[1], (char)bVar2 < -1 || 0xc0 < (byte)(bVar2 + 0x81))) {
uVar4 = ((uint)bVar1 * 0x100 + (uint)bVar2) - 0x8140;
if (uVar4 < 0x7d10) {
uVar3 = *(ushort *)(&tab_gbk_uni0 + (ulong)uVar4 * 2);
*param_2 = (ulong)uVar3;
if (uVar3 != 0) {
return 2;
}
}
else {
*param_2 = 0;
}
uVar5 = 0xfffffffe;
}
}
else {
*param_2 = (long)(char)bVar1;
uVar5 = 1;
}
}
return uVar5;
}
| |
54,120 | check_mb_gb18030_valid | eloqsql/libmariadb/libmariadb/ma_charset.c | static unsigned int check_mb_gb18030_valid(const char * start, const char * end)
{
if (end - start <= 1 || !is_gb18030_odd(start[0])) {
return 0;
}
if (is_gb18030_even_2(start[1])) {
return 2;
} else if (end - start > 3 && is_gb18030_even_4(start[1]) && is_gb18030_odd(start[2]) && is_gb18030_even_4(start[3])) {
return 4;
}
return 0;
} | O0 | c | check_mb_gb18030_valid:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0x1, %rax
jle 0x43e7b
movq -0x10(%rbp), %rax
movzbl (%rax), %ecx
movl $0x81, %eax
cmpl %ecx, %eax
jg 0x43e7b
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xfe, %eax
jle 0x43e87
movl $0x0, -0x4(%rbp)
jmp 0x43f4d
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %ecx
movl $0x40, %eax
cmpl %ecx, %eax
jg 0x43ea5
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x7e, %eax
jle 0x43ec5
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %ecx
movl $0x80, %eax
cmpl %ecx, %eax
jg 0x43ece
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xfe, %eax
jg 0x43ece
movl $0x2, -0x4(%rbp)
jmp 0x43f4d
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0x3, %rax
jle 0x43f44
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jg 0x43f44
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x39, %eax
jg 0x43f44
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %ecx
movl $0x81, %eax
cmpl %ecx, %eax
jg 0x43f44
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0xfe, %eax
jg 0x43f44
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jg 0x43f44
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
cmpl $0x39, %eax
jg 0x43f44
movl $0x4, -0x4(%rbp)
jmp 0x43f4d
jmp 0x43f46
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| check_mb_gb18030_valid:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
sub rax, rcx
cmp rax, 1
jle short loc_43E7B
mov rax, [rbp+var_10]
movzx ecx, byte ptr [rax]
mov eax, 81h
cmp eax, ecx
jg short loc_43E7B
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
cmp eax, 0FEh
jle short loc_43E87
loc_43E7B:
mov [rbp+var_4], 0
jmp loc_43F4D
loc_43E87:
mov rax, [rbp+var_10]
movzx ecx, byte ptr [rax+1]
mov eax, 40h ; '@'
cmp eax, ecx
jg short loc_43EA5
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+1]
cmp eax, 7Eh ; '~'
jle short loc_43EC5
loc_43EA5:
mov rax, [rbp+var_10]
movzx ecx, byte ptr [rax+1]
mov eax, 80h
cmp eax, ecx
jg short loc_43ECE
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+1]
cmp eax, 0FEh
jg short loc_43ECE
loc_43EC5:
mov [rbp+var_4], 2
jmp short loc_43F4D
loc_43ECE:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
sub rax, rcx
cmp rax, 3
jle short loc_43F44
mov rax, [rbp+var_10]
movzx ecx, byte ptr [rax+1]
mov eax, 30h ; '0'
cmp eax, ecx
jg short loc_43F44
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+1]
cmp eax, 39h ; '9'
jg short loc_43F44
mov rax, [rbp+var_10]
movzx ecx, byte ptr [rax+2]
mov eax, 81h
cmp eax, ecx
jg short loc_43F44
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+2]
cmp eax, 0FEh
jg short loc_43F44
mov rax, [rbp+var_10]
movzx ecx, byte ptr [rax+3]
mov eax, 30h ; '0'
cmp eax, ecx
jg short loc_43F44
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+3]
cmp eax, 39h ; '9'
jg short loc_43F44
mov [rbp+var_4], 4
jmp short loc_43F4D
loc_43F44:
jmp short $+2
loc_43F46:
mov [rbp+var_4], 0
loc_43F4D:
mov eax, [rbp+var_4]
pop rbp
retn
| long long check_mb_gb18030_valid(unsigned __int8 *a1, long long a2)
{
if ( a2 - (long long)a1 <= 1 || *a1 < 0x81u || *a1 == 255 )
{
return 0;
}
else if ( (a1[1] < 0x40u || a1[1] > 0x7Eu) && (a1[1] < 0x80u || a1[1] == 255) )
{
if ( a2 - (long long)a1 <= 3
|| a1[1] < 0x30u
|| a1[1] > 0x39u
|| a1[2] < 0x81u
|| a1[2] == 255
|| a1[3] < 0x30u
|| a1[3] > 0x39u )
{
return 0;
}
else
{
return 4;
}
}
else
{
return 2;
}
}
| check_mb_gb18030_valid:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,RCX
CMP RAX,0x1
JLE 0x00143e7b
MOV RAX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RAX]
MOV EAX,0x81
CMP EAX,ECX
JG 0x00143e7b
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xfe
JLE 0x00143e87
LAB_00143e7b:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00143f4d
LAB_00143e87:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RAX + 0x1]
MOV EAX,0x40
CMP EAX,ECX
JG 0x00143ea5
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x7e
JLE 0x00143ec5
LAB_00143ea5:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RAX + 0x1]
MOV EAX,0x80
CMP EAX,ECX
JG 0x00143ece
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xfe
JG 0x00143ece
LAB_00143ec5:
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00143f4d
LAB_00143ece:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,RCX
CMP RAX,0x3
JLE 0x00143f44
MOV RAX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RAX + 0x1]
MOV EAX,0x30
CMP EAX,ECX
JG 0x00143f44
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x39
JG 0x00143f44
MOV RAX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RAX + 0x2]
MOV EAX,0x81
CMP EAX,ECX
JG 0x00143f44
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x2]
CMP EAX,0xfe
JG 0x00143f44
MOV RAX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RAX + 0x3]
MOV EAX,0x30
CMP EAX,ECX
JG 0x00143f44
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x3]
CMP EAX,0x39
JG 0x00143f44
MOV dword ptr [RBP + -0x4],0x4
JMP 0x00143f4d
LAB_00143f44:
JMP 0x00143f46
LAB_00143f46:
MOV dword ptr [RBP + -0x4],0x0
LAB_00143f4d:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 check_mb_gb18030_valid(byte *param_1,long param_2)
{
int4 local_c;
if (((param_2 - (long)param_1 < 2) || (*param_1 < 0x81)) || (*param_1 == 0xff)) {
local_c = 0;
}
else if (((param_1[1] < 0x40) || (0x7e < param_1[1])) &&
((param_1[1] < 0x80 || (param_1[1] == 0xff)))) {
if (((param_2 - (long)param_1 < 4) || (param_1[1] < 0x30)) ||
((0x39 < param_1[1] ||
((((param_1[2] < 0x81 || (0xfe < param_1[2])) || (param_1[3] < 0x30)) || (0x39 < param_1[3])
))))) {
local_c = 0;
}
else {
local_c = 4;
}
}
else {
local_c = 2;
}
return local_c;
}
| |
54,121 | ggml_gallocr_init_tensor | llama.cpp/ggml/src/ggml-alloc.c | static void ggml_gallocr_init_tensor(ggml_gallocr_t galloc, struct ggml_tensor * tensor, struct tensor_alloc * tensor_alloc) {
int buffer_id = tensor_alloc->buffer_id;
assert(tensor->data || tensor->view_src || ggml_backend_buffer_get_alloc_size(galloc->buffers[buffer_id], tensor) <= tensor_alloc->size_max);
if (tensor->view_src != NULL) {
if (tensor->buffer == NULL) {
assert(tensor_alloc->offset == SIZE_MAX);
if (tensor->view_src->buffer == NULL) {
// this tensor was allocated without ggml-backend
return;
}
ggml_backend_view_init(tensor);
}
} else {
if (tensor->data == NULL) {
assert(tensor_alloc->offset != SIZE_MAX);
assert(ggml_backend_buffer_get_alloc_size(galloc->buffers[buffer_id], tensor) <= tensor_alloc->size_max);
void * base = ggml_backend_buffer_get_base(galloc->buffers[buffer_id]);
void * addr = (char *)base + tensor_alloc->offset;
ggml_backend_tensor_alloc(galloc->buffers[buffer_id], tensor, addr);
} else {
if (tensor->buffer == NULL) {
// this tensor was allocated without ggml-backend
return;
}
}
}
} | O3 | c | ggml_gallocr_init_tensor:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0xe8(%rsi), %rax
testq %rax, %rax
je 0x2475f
cmpq $0x0, 0x8(%rbx)
jne 0x24769
cmpq $0x0, 0x8(%rax)
je 0x24769
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x178b0
cmpq $0x0, 0xf8(%rbx)
je 0x24775
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %r14
movq %rdi, %r15
movslq (%rdx), %r12
movq 0x8(%rdi), %rax
movq (%rax,%r12,8), %rdi
callq 0x17510
addq 0x8(%r14), %rax
movq 0x8(%r15), %rcx
movq (%rcx,%r12,8), %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x17720
| ggml_gallocr_init_tensor:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rsi
mov rax, [rsi+0E8h]
test rax, rax
jz short loc_2475F
cmp qword ptr [rbx+8], 0
jnz short loc_24769
cmp qword ptr [rax+8], 0
jz short loc_24769
mov rdi, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
jmp _ggml_backend_view_init
loc_2475F:
cmp qword ptr [rbx+0F8h], 0
jz short loc_24775
loc_24769:
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
loc_24775:
mov r14, rdx
mov r15, rdi
movsxd r12, dword ptr [rdx]
mov rax, [rdi+8]
mov rdi, [rax+r12*8]
call _ggml_backend_buffer_get_base
add rax, [r14+8]
mov rcx, [r15+8]
mov rdi, [rcx+r12*8]
mov rsi, rbx
mov rdx, rax
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
jmp _ggml_backend_tensor_alloc
| long long ggml_gallocr_init_tensor(long long a1, _QWORD *a2, int *a3)
{
long long result; // rax
long long v5; // r12
long long base; // rax
result = a2[29];
if ( result )
{
if ( !a2[1] )
{
if ( *(_QWORD *)(result + 8) )
return ggml_backend_view_init(a2);
}
}
else if ( !a2[31] )
{
v5 = *a3;
base = ggml_backend_buffer_get_base(*(_QWORD *)(*(_QWORD *)(a1 + 8) + 8 * v5));
return ggml_backend_tensor_alloc(*(_QWORD *)(*(_QWORD *)(a1 + 8) + 8 * v5), a2, *((_QWORD *)a3 + 1) + base);
}
return result;
}
| ggml_gallocr_init_tensor:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV RAX,qword ptr [RSI + 0xe8]
TEST RAX,RAX
JZ 0x0012475f
CMP qword ptr [RBX + 0x8],0x0
JNZ 0x00124769
CMP qword ptr [RAX + 0x8],0x0
JZ 0x00124769
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
JMP 0x001178b0
LAB_0012475f:
CMP qword ptr [RBX + 0xf8],0x0
JZ 0x00124775
LAB_00124769:
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
LAB_00124775:
MOV R14,RDX
MOV R15,RDI
MOVSXD R12,dword ptr [RDX]
MOV RAX,qword ptr [RDI + 0x8]
MOV RDI,qword ptr [RAX + R12*0x8]
CALL 0x00117510
ADD RAX,qword ptr [R14 + 0x8]
MOV RCX,qword ptr [R15 + 0x8]
MOV RDI,qword ptr [RCX + R12*0x8]
MOV RSI,RBX
MOV RDX,RAX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
JMP 0x00117720
|
void ggml_gallocr_init_tensor(long param_1,long param_2,int *param_3)
{
int iVar1;
long lVar2;
if (*(long *)(param_2 + 0xe8) == 0) {
if (*(long *)(param_2 + 0xf8) == 0) {
iVar1 = *param_3;
lVar2 = ggml_backend_buffer_get_base
(*(int8 *)(*(long *)(param_1 + 8) + (long)iVar1 * 8));
ggml_backend_tensor_alloc
(*(int8 *)(*(long *)(param_1 + 8) + (long)iVar1 * 8),param_2,
lVar2 + *(long *)(param_3 + 2));
return;
}
}
else if ((*(long *)(param_2 + 8) == 0) && (*(long *)(*(long *)(param_2 + 0xe8) + 8) != 0)) {
ggml_backend_view_init(param_2);
return;
}
return;
}
| |
54,122 | OpenSubdiv::v3_6_0::Bfr::quad::GetSegmentedFacets(int const*, bool, OpenSubdiv::v3_6_0::Bfr::(anonymous namespace)::FacetArray) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/tessellation.cpp | int
quad::GetSegmentedFacets(int const innerRes[], bool triangulate,
FacetArray facets) {
// WIP - may extend later to handle different opposing outer rates
// resulting in a non-uniform strip between the opposing edges
int uRes = innerRes[0];
int vRes = innerRes[1];
assert((uRes == 1) || (vRes == 1));
return getSingleStripFacets(uRes, vRes, 0, triangulate, facets);
} | O0 | cpp | OpenSubdiv::v3_6_0::Bfr::quad::GetSegmentedFacets(int const*, bool, OpenSubdiv::v3_6_0::Bfr::(anonymous namespace)::FacetArray):
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x48(%rbp)
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x20(%rbp)
movb $0x1, %al
cmpl $0x1, -0x1c(%rbp)
movb %al, -0x3d(%rbp)
je 0x1bf6c4
cmpl $0x1, -0x20(%rbp)
sete %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x1bf6cd
jmp 0x1bf6cf
jmp 0x1bf6ee
leaq 0x3bf0e(%rip), %rdi # 0x1fb5e4
leaq 0x3b873(%rip), %rsi # 0x1faf50
movl $0x4d3, %edx # imm = 0x4D3
leaq 0x3bffb(%rip), %rcx # 0x1fb6e4
callq 0xc9440
movq -0x48(%rbp), %rax
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
movzbl -0x9(%rbp), %ecx
movups (%rax), %xmm0
movaps %xmm0, -0x30(%rbp)
andl $0x1, %ecx
xorl %edx, %edx
leaq -0x30(%rbp), %r8
callq 0x1c0850
movl %eax, -0x4c(%rbp)
jmp 0x1bf716
leaq -0x30(%rbp), %rdi
callq 0x1bf330
movl -0x4c(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1bf330
movq -0x38(%rbp), %rdi
callq 0xd58b0
nopw %cs:(%rax,%rax)
| _ZN10OpenSubdiv6v3_6_03Bfr4quad18GetSegmentedFacetsEPKibNS1_12_GLOBAL__N_110FacetArrayE:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_48], rdx
mov al, sil
mov [rbp+var_8], rdi
and al, 1
mov [rbp+var_9], al
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov eax, [rax]
mov [rbp+var_1C], eax
mov rax, [rbp+var_8]
mov eax, [rax+4]
mov [rbp+var_20], eax
mov al, 1
cmp [rbp+var_1C], 1
mov [rbp+var_3D], al
jz short loc_1BF6C4
cmp [rbp+var_20], 1
setz al
mov [rbp+var_3D], al
loc_1BF6C4:
mov al, [rbp+var_3D]
test al, 1
jnz short loc_1BF6CD
jmp short loc_1BF6CF
loc_1BF6CD:
jmp short loc_1BF6EE
loc_1BF6CF:
lea rdi, aUres1Vres1_0; "(uRes == 1) || (vRes == 1)"
lea rsi, aWorkspaceLlm4b_42; "/workspace/llm4binary/github/2025_star3"...
mov edx, 4D3h
lea rcx, aStaticIntOpens_3; "static int OpenSubdiv::v3_6_0::Bfr::qua"...
call ___assert_fail
loc_1BF6EE:
mov rax, [rbp+var_48]
mov edi, [rbp+var_1C]
mov esi, [rbp+var_20]
movzx ecx, [rbp+var_9]
movups xmm0, xmmword ptr [rax]
movaps [rbp+var_30], xmm0
and ecx, 1
xor edx, edx
lea r8, [rbp+var_30]
call _ZN10OpenSubdiv6v3_6_03Bfr4quad20getSingleStripFacetsEiiibNS1_12_GLOBAL__N_110FacetArrayE; OpenSubdiv::v3_6_0::Bfr::quad::getSingleStripFacets(int,int,int,bool,OpenSubdiv::v3_6_0::Bfr::`anonymous namespace'::FacetArray)
mov [rbp+var_4C], eax
jmp short $+2
loc_1BF716:
lea rdi, [rbp+var_30]; this
call _ZN10OpenSubdiv6v3_6_03Bfr12_GLOBAL__N_110FacetArrayD2Ev; OpenSubdiv::v3_6_0::Bfr::`anonymous namespace'::FacetArray::~FacetArray()
mov eax, [rbp+var_4C]
add rsp, 50h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_38], rcx
mov [rbp+var_3C], eax
lea rdi, [rbp+var_30]; this
call _ZN10OpenSubdiv6v3_6_03Bfr12_GLOBAL__N_110FacetArrayD2Ev; OpenSubdiv::v3_6_0::Bfr::`anonymous namespace'::FacetArray::~FacetArray()
mov rdi, [rbp+var_38]
call __Unwind_Resume
| long long OpenSubdiv::v3_6_0::Bfr::quad::GetSegmentedFacets(_DWORD *a1, char a2, _OWORD *a3)
{
unsigned int SingleStripFacets; // [rsp+4h] [rbp-4Ch]
bool v5; // [rsp+13h] [rbp-3Dh]
__int128 v6; // [rsp+20h] [rbp-30h] BYREF
unsigned int v7; // [rsp+30h] [rbp-20h]
unsigned int v8; // [rsp+34h] [rbp-1Ch]
_OWORD *v9; // [rsp+38h] [rbp-18h]
char v10; // [rsp+47h] [rbp-9h]
_DWORD *v11; // [rsp+48h] [rbp-8h]
v11 = a1;
v10 = a2 & 1;
v9 = a3;
v8 = *a1;
v7 = a1[1];
v5 = 1;
if ( v8 != 1 )
v5 = v7 == 1;
if ( !v5 )
__assert_fail(
"(uRes == 1) || (vRes == 1)",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/tessellation.cpp",
1235LL,
"static int OpenSubdiv::v3_6_0::Bfr::quad::GetSegmentedFacets(const int *, bool, FacetArray)");
v6 = *a3;
SingleStripFacets = OpenSubdiv::v3_6_0::Bfr::quad::getSingleStripFacets(v8, v7, 0LL, v10 & 1, &v6);
OpenSubdiv::v3_6_0::Bfr::`anonymous namespace'::FacetArray::~FacetArray((OpenSubdiv::v3_6_0::Bfr::_anonymous_namespace_::FacetArray *)&v6);
return SingleStripFacets;
}
| |||
54,123 | OpenSubdiv::v3_6_0::Bfr::quad::GetSegmentedFacets(int const*, bool, OpenSubdiv::v3_6_0::Bfr::(anonymous namespace)::FacetArray) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/tessellation.cpp | int
quad::GetSegmentedFacets(int const innerRes[], bool triangulate,
FacetArray facets) {
// WIP - may extend later to handle different opposing outer rates
// resulting in a non-uniform strip between the opposing edges
int uRes = innerRes[0];
int vRes = innerRes[1];
assert((uRes == 1) || (vRes == 1));
return getSingleStripFacets(uRes, vRes, 0, triangulate, facets);
} | O1 | cpp | OpenSubdiv::v3_6_0::Bfr::quad::GetSegmentedFacets(int const*, bool, OpenSubdiv::v3_6_0::Bfr::(anonymous namespace)::FacetArray):
subq $0x18, %rsp
movq %rdi, %rax
movl (%rdi), %edi
movl 0x4(%rax), %eax
cmpl $0x1, %edi
sete %cl
cmpl $0x1, %eax
sete %r8b
orb %cl, %r8b
je 0x9ff22
movups (%rdx), %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
movzbl %sil, %ecx
movl %eax, %esi
xorl %edx, %edx
callq 0xa08a6
addq $0x18, %rsp
retq
leaq 0x222d6(%rip), %rdi # 0xc21ff
leaq 0x21d60(%rip), %rsi # 0xc1c90
leaq 0x223c8(%rip), %rcx # 0xc22ff
movl $0x4d3, %edx # imm = 0x4D3
callq 0x39560
nop
| _ZN10OpenSubdiv6v3_6_03Bfr4quad18GetSegmentedFacetsEPKibNS1_12_GLOBAL__N_110FacetArrayE:
sub rsp, 18h
mov rax, rdi
mov edi, [rdi]
mov eax, [rax+4]
cmp edi, 1
setz cl
cmp eax, 1
setz r8b
or r8b, cl
jz short loc_9FF22
movups xmm0, xmmword ptr [rdx]
mov r8, rsp
movaps xmmword ptr [r8], xmm0
movzx ecx, sil
mov esi, eax
xor edx, edx
call _ZN10OpenSubdiv6v3_6_03Bfr4quad20getSingleStripFacetsEiiibNS1_12_GLOBAL__N_110FacetArrayE; OpenSubdiv::v3_6_0::Bfr::quad::getSingleStripFacets(int,int,int,bool,OpenSubdiv::v3_6_0::Bfr::`anonymous namespace'::FacetArray)
add rsp, 18h
retn
loc_9FF22:
lea rdi, aUres1Vres1_0; "(uRes == 1) || (vRes == 1)"
lea rsi, aWorkspaceLlm4b_47; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStaticIntOpens_5; "static int OpenSubdiv::v3_6_0::Bfr::qua"...
mov edx, 4D3h
call ___assert_fail
| long long OpenSubdiv::v3_6_0::Bfr::quad::GetSegmentedFacets(unsigned int *a1, unsigned __int8 a2)
{
long long v3; // rdi
unsigned int v4; // eax
v3 = *a1;
v4 = a1[1];
if ( (_DWORD)v3 != 1 && v4 != 1 )
__assert_fail(
"(uRes == 1) || (vRes == 1)",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/tessellation.cpp",
1235LL,
"static int OpenSubdiv::v3_6_0::Bfr::quad::GetSegmentedFacets(const int *, bool, FacetArray)");
return OpenSubdiv::v3_6_0::Bfr::quad::getSingleStripFacets(v3, v4, 0LL, a2);
}
| GetSegmentedFacets:
SUB RSP,0x18
MOV RAX,RDI
MOV EDI,dword ptr [RDI]
MOV EAX,dword ptr [RAX + 0x4]
CMP EDI,0x1
SETZ CL
CMP EAX,0x1
SETZ R8B
OR R8B,CL
JZ 0x0019ff22
MOVUPS XMM0,xmmword ptr [RDX]
MOV R8,RSP
MOVAPS xmmword ptr [R8],XMM0
MOVZX ECX,SIL
MOV ESI,EAX
XOR EDX,EDX
CALL 0x001a08a6
ADD RSP,0x18
RET
LAB_0019ff22:
LEA RDI,[0x1c21ff]
LEA RSI,[0x1c1c90]
LEA RCX,[0x1c22ff]
MOV EDX,0x4d3
CALL 0x00139560
|
/* OpenSubdiv::v3_6_0::Bfr::quad::GetSegmentedFacets(int const*, bool,
OpenSubdiv::v3_6_0::Bfr::(anonymous namespace)::FacetArray) */
void OpenSubdiv::v3_6_0::Bfr::quad::GetSegmentedFacets(int *param_1,int1 param_2)
{
if (param_1[1] == 1 || *param_1 == 1) {
getSingleStripFacets(*param_1,param_1[1],0,param_2);
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("(uRes == 1) || (vRes == 1)",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/tessellation.cpp"
,0x4d3,
"static int OpenSubdiv::v3_6_0::Bfr::quad::GetSegmentedFacets(const int *, bool, FacetArray)"
);
}
| |
54,124 | mi_ft_segiterator_dummy_init | eloqsql/storage/myisam/ft_update.c | void _mi_ft_segiterator_dummy_init(const uchar *record, uint len,
FT_SEG_ITERATOR *ftsi)
{
DBUG_ENTER("_mi_ft_segiterator_dummy_init");
ftsi->num=1;
ftsi->seg=0;
ftsi->pos=record;
ftsi->len=len;
DBUG_VOID_RETURN;
} | O3 | c | mi_ft_segiterator_dummy_init:
pushq %rbp
movq %rsp, %rbp
movl $0x1, (%rdx)
movq $0x0, 0x8(%rdx)
movq %rdi, 0x18(%rdx)
movl %esi, 0x4(%rdx)
popq %rbp
retq
| _mi_ft_segiterator_dummy_init:
push rbp
mov rbp, rsp
mov dword ptr [rdx], 1
mov qword ptr [rdx+8], 0
mov [rdx+18h], rdi
mov [rdx+4], esi
pop rbp
retn
| void mi_ft_segiterator_dummy_init(long long a1, int a2, long long a3)
{
*(_DWORD *)a3 = 1;
*(_QWORD *)(a3 + 8) = 0LL;
*(_QWORD *)(a3 + 24) = a1;
*(_DWORD *)(a3 + 4) = a2;
}
| _mi_ft_segiterator_dummy_init:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RDX],0x1
MOV qword ptr [RDX + 0x8],0x0
MOV qword ptr [RDX + 0x18],RDI
MOV dword ptr [RDX + 0x4],ESI
POP RBP
RET
|
void _mi_ft_segiterator_dummy_init(int8 param_1,int4 param_2,int4 *param_3)
{
*param_3 = 1;
*(int8 *)(param_3 + 2) = 0;
*(int8 *)(param_3 + 6) = param_1;
param_3[1] = param_2;
return;
}
| |
54,125 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::get_ref_impl<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(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>&) | monkey531[P]llama/common/json.hpp | static ReferenceType get_ref_impl(ThisType& obj)
{
// delegate the call to get_ptr<>()
auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
if (JSON_HEDLEY_LIKELY(ptr != nullptr))
{
return *ptr;
}
JSON_THROW(type_error::create(303, detail::concat("incompatible ReferenceType for get_ref, actual type is ", obj.type_name()), &obj));
} | O1 | cpp | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::get_ref_impl<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x3, (%rdi)
jne 0x9a6fe
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x9a6fe
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x19370
movq %rax, %rbx
movq %r14, %rdi
callq 0x2f7ce
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x24be5(%rip), %rsi # 0xbf307
leaq 0x10(%rsp), %rdi
callq 0x95fa3
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12f, %esi # imm = 0x12F
movq %r14, %rcx
callq 0x2f57a
xorl %ebp, %ebp
leaq 0x527d3(%rip), %rsi # 0xecf20
leaq -0x6ee06(%rip), %rdx # 0x2b94e
movq %rbx, %rdi
callq 0x19b70
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9a782
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x196b0
jmp 0x9a782
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x9a78f
movq %rbx, %rdi
callq 0x19510
movq %r14, %rdi
callq 0x19be0
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12get_ref_implIRS9_SD_EET_RT0_:
push rbp; char
push r14; int
push rbx; __int64
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 3
jnz short loc_9A6FE
mov rax, [r14+8]
test rax, rax
jz short loc_9A6FE
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_9A6FE:
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, aIncompatibleRe; "incompatible ReferenceType for get_ref,"...
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA56_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[56],char const*>(char const(&)[56],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 12Fh; 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_9A782
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_9A782
mov r14, rax
mov bpl, 1
loc_9A782:
test bpl, bpl
jz short loc_9A78F
mov rdi, rbx; void *
call ___cxa_free_exception
loc_9A78F:
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_ref_impl<std::string&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
long long a1)
{
long long result; // rax
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
const char *v3; // [rsp+8h] [rbp-40h] BYREF
_QWORD v4[2]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 != 3 || (result = *(_QWORD *)(a1 + 8)) == 0 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__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(&)[56],char const*>(
(long long)v4,
(long long)"incompatible ReferenceType for get_ref, actual type is ",
&v3);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
303,
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 result;
}
| get_ref_impl<std::__cxx11::string&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x3
JNZ 0x0019a6fe
MOV RAX,qword ptr [R14 + 0x8]
TEST RAX,RAX
JZ 0x0019a6fe
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_0019a6fe:
MOV EDI,0x20
CALL 0x00119370
MOV RBX,RAX
MOV RDI,R14
CALL 0x0012f7ce
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_0019a71b:
LEA RSI,[0x1bf307]
LEA RDI,[RSP + 0x10]
CALL 0x00195fa3
MOV BPL,0x1
LAB_0019a72f:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12f
MOV RCX,R14
CALL 0x0012f57a
XOR EBP,EBP
LEA RSI,[0x1ecf20]
LEA RDX,[0x12b94e]
MOV RDI,RBX
CALL 0x00119b70
|
/* std::__cxx11::string&
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::get_ref_impl<std::__cxx11::string&,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >(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>&) */
string * nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::
get_ref_impl<std::__cxx11::string&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(basic_json *param_1)
{
int8 uVar1;
char *local_40;
detail local_38 [32];
if ((*param_1 == (basic_json)0x3) && (*(string **)(param_1 + 8) != (string *)0x0)) {
return *(string **)(param_1 + 8);
}
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name((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);
/* try { // try from 0019a71b to 0019a72b has its CatchHandler @ 0019a77c */
detail::concat<std::__cxx11::string,char_const(&)[56],char_const*>
(local_38,"incompatible ReferenceType for get_ref, actual type is ",&local_40);
/* try { // try from 0019a72f to 0019a75b has its CatchHandler @ 0019a75c */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0x12f,local_38,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
| |
54,126 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::get_ref_impl<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(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>&) | monkey531[P]llama/common/json.hpp | static ReferenceType get_ref_impl(ThisType& obj)
{
// delegate the call to get_ptr<>()
auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
if (JSON_HEDLEY_LIKELY(ptr != nullptr))
{
return *ptr;
}
JSON_THROW(type_error::create(303, detail::concat("incompatible ReferenceType for get_ref, actual type is ", obj.type_name()), &obj));
} | O2 | cpp | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::get_ref_impl<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x3, (%rdi)
jne 0x8159e
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x8159e
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x213a0
movq %rax, %rbx
movq %r14, %rdi
callq 0x30c70
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x1cd87(%rip), %rsi # 0x9e347
leaq 0x10(%rsp), %rdi
callq 0x7db27
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12f, %esi # imm = 0x12F
movq %r14, %rcx
callq 0x30b24
xorl %ebp, %ebp
leaq 0x58965(%rip), %rsi # 0xd9f50
leaq -0x53de6(%rip), %rdx # 0x2d80c
movq %rbx, %rdi
callq 0x21b70
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x21dc8
testb %bpl, %bpl
jne 0x81611
jmp 0x81619
movq %rax, %r14
movq %rbx, %rdi
callq 0x21530
movq %r14, %rdi
callq 0x21be0
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12get_ref_implIRS9_SD_EET_RT0_:
push rbp; char
push r14; int
push rbx; int
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 3
jnz short loc_8159E
mov rax, [r14+8]
test rax, rax
jz short loc_8159E
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_8159E:
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, aIncompatibleRe; "incompatible ReferenceType for get_ref,"...
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA56_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[56],char const*>(char const(&)[56],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 12Fh; 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 rdi, [rsp+48h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_81611
jmp short loc_81619
mov r14, rax
loc_81611:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_81619:
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_ref_impl<std::string&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
long long a1)
{
long long result; // rax
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 != 3 || (result = *(_QWORD *)(a1 + 8)) == 0 )
{
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(&)[56],char const*>(
(long long)v4,
(long long)"incompatible ReferenceType for get_ref, actual type is ",
&v3);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
303,
(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 result;
}
| get_ref_impl<std::__cxx11::string&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x3
JNZ 0x0018159e
MOV RAX,qword ptr [R14 + 0x8]
TEST RAX,RAX
JZ 0x0018159e
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_0018159e:
PUSH 0x20
POP RDI
CALL 0x001213a0
MOV RBX,RAX
MOV RDI,R14
CALL 0x00130c70
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001815b9:
LEA RSI,[0x19e347]
LEA RDI,[RSP + 0x10]
CALL 0x0017db27
MOV BPL,0x1
LAB_001815cd:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12f
MOV RCX,R14
CALL 0x00130b24
XOR EBP,EBP
LEA RSI,[0x1d9f50]
LEA RDX,[0x12d80c]
MOV RDI,RBX
CALL 0x00121b70
|
/* std::__cxx11::string&
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::get_ref_impl<std::__cxx11::string&,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >(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>&) */
string * nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::
get_ref_impl<std::__cxx11::string&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(basic_json *param_1)
{
int8 uVar1;
char *local_40;
detail local_38 [32];
if ((*param_1 == '\x03') && (*(string **)(param_1 + 8) != (string *)0x0)) {
return *(string **)(param_1 + 8);
}
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name((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);
/* try { // try from 001815b9 to 001815c9 has its CatchHandler @ 0018160e */
detail::concat<std::__cxx11::string,char_const(&)[56],char_const*>
(local_38,"incompatible ReferenceType for get_ref, actual type is ",&local_40);
/* try { // try from 001815cd to 001815f9 has its CatchHandler @ 001815fa */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0x12f,local_38,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
| |
54,127 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::get_ref_impl<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(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>&) | monkey531[P]llama/common/json.hpp | static ReferenceType get_ref_impl(ThisType& obj)
{
// delegate the call to get_ptr<>()
auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
if (JSON_HEDLEY_LIKELY(ptr != nullptr))
{
return *ptr;
}
JSON_THROW(type_error::create(303, detail::concat("incompatible ReferenceType for get_ref, actual type is ", obj.type_name()), &obj));
} | O3 | cpp | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::get_ref_impl<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x3, (%rdi)
jne 0x986c8
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x986c8
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x19370
movq %rax, %rbx
movq %r14, %rdi
callq 0x2e9dc
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x23c0b(%rip), %rsi # 0xbc2f7
leaq 0x10(%rsp), %rdi
callq 0x93ec4
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12f, %esi # imm = 0x12F
movq %r14, %rcx
callq 0x2e788
xorl %ebp, %ebp
leaq 0x51839(%rip), %rsi # 0xe9f50
leaq -0x6dace(%rip), %rdx # 0x2ac50
movq %rbx, %rdi
callq 0x19b70
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x98744
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x196b0
testb %bpl, %bpl
jne 0x9874e
jmp 0x98756
movq %rax, %r14
movq %rbx, %rdi
callq 0x19510
movq %r14, %rdi
callq 0x19be0
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12get_ref_implIRS9_SD_EET_RT0_:
push rbp; char
push r14; int
push rbx; __int64
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 3
jnz short loc_986C8
mov rax, [r14+8]
test rax, rax
jz short loc_986C8
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_986C8:
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, aIncompatibleRe; "incompatible ReferenceType for get_ref,"...
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA56_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[56],char const*>(char const(&)[56],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 12Fh; 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_98744
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_98744:
test bpl, bpl
jnz short loc_9874E
jmp short loc_98756
mov r14, rax
loc_9874E:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_98756:
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_ref_impl<std::string&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
long long a1)
{
long long result; // rax
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
const char *v3; // [rsp+8h] [rbp-40h] BYREF
_QWORD v4[2]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 != 3 || (result = *(_QWORD *)(a1 + 8)) == 0 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__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(&)[56],char const*>(
(long long)v4,
(long long)"incompatible ReferenceType for get_ref, actual type is ",
&v3);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
303,
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 result;
}
| get_ref_impl<std::__cxx11::string&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x3
JNZ 0x001986c8
MOV RAX,qword ptr [R14 + 0x8]
TEST RAX,RAX
JZ 0x001986c8
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_001986c8:
MOV EDI,0x20
CALL 0x00119370
MOV RBX,RAX
MOV RDI,R14
CALL 0x0012e9dc
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001986e5:
LEA RSI,[0x1bc2f7]
LEA RDI,[RSP + 0x10]
CALL 0x00193ec4
MOV BPL,0x1
LAB_001986f9:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12f
MOV RCX,R14
CALL 0x0012e788
XOR EBP,EBP
LEA RSI,[0x1e9f50]
LEA RDX,[0x12ac50]
MOV RDI,RBX
CALL 0x00119b70
|
/* std::__cxx11::string&
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::get_ref_impl<std::__cxx11::string&,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >(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>&) */
string * nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::
get_ref_impl<std::__cxx11::string&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(basic_json *param_1)
{
int8 uVar1;
char *local_40;
detail local_38 [32];
if ((*param_1 == (basic_json)0x3) && (*(string **)(param_1 + 8) != (string *)0x0)) {
return *(string **)(param_1 + 8);
}
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name((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);
/* try { // try from 001986e5 to 001986f5 has its CatchHandler @ 0019874b */
detail::concat<std::__cxx11::string,char_const(&)[56],char_const*>
(local_38,"incompatible ReferenceType for get_ref, actual type is ",&local_40);
/* try { // try from 001986f9 to 00198725 has its CatchHandler @ 00198726 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0x12f,local_38,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
| |
54,128 | setup_key_functions | eloqsql/storage/maria/ma_open.c | static void setup_key_functions(register MARIA_KEYDEF *keyinfo)
{
if (keyinfo->key_alg == HA_KEY_ALG_RTREE)
{
#ifdef HAVE_RTREE_KEYS
keyinfo->ck_insert = maria_rtree_insert;
keyinfo->ck_delete = maria_rtree_delete;
#else
DBUG_ASSERT(0); /* maria_open should check it never happens */
#endif
}
else
{
keyinfo->ck_insert = _ma_ck_write;
keyinfo->ck_delete = _ma_ck_delete;
}
if (keyinfo->flag & HA_SPATIAL)
keyinfo->make_key= _ma_sp_make_key;
else
keyinfo->make_key= _ma_make_key;
if (keyinfo->flag & HA_BINARY_PACK_KEY)
{ /* Simple prefix compression */
keyinfo->bin_search= _ma_seq_search;
keyinfo->get_key= _ma_get_binary_pack_key;
keyinfo->skip_key= _ma_skip_binary_pack_key;
keyinfo->pack_key= _ma_calc_bin_pack_key_length;
keyinfo->store_key= _ma_store_bin_pack_key;
}
else if (keyinfo->flag & HA_VAR_LENGTH_KEY)
{
keyinfo->get_key= _ma_get_pack_key;
keyinfo->skip_key= _ma_skip_pack_key;
if (keyinfo->seg[0].flag & HA_PACK_KEY)
{ /* Prefix compression */
/*
_ma_prefix_search() compares end-space against ASCII blank (' ').
It cannot be used for character sets, that do not encode the
blank character like ASCII does. UCS2 is an example. All
character sets with a fixed width > 1 or a mimimum width > 1
cannot represent blank like ASCII does. In these cases we have
to use _ma_seq_search() for the search.
*/
if (!keyinfo->seg->charset || use_strnxfrm(keyinfo->seg->charset) ||
(keyinfo->seg->flag & HA_NULL_PART) ||
keyinfo->seg->charset->mbminlen > 1)
keyinfo->bin_search= _ma_seq_search;
else
keyinfo->bin_search= _ma_prefix_search;
keyinfo->pack_key= _ma_calc_var_pack_key_length;
keyinfo->store_key= _ma_store_var_pack_key;
}
else
{
keyinfo->bin_search= _ma_seq_search;
keyinfo->pack_key= _ma_calc_var_key_length; /* Variable length key */
keyinfo->store_key= _ma_store_static_key;
}
}
else
{
keyinfo->bin_search= _ma_bin_search;
keyinfo->get_key= _ma_get_static_key;
keyinfo->skip_key= _ma_skip_static_key;
keyinfo->pack_key= _ma_calc_static_key_length;
keyinfo->store_key= _ma_store_static_key;
}
/* set keyinfo->write_comp_flag */
if (keyinfo->flag & HA_SORT_ALLOWS_SAME)
keyinfo->write_comp_flag=SEARCH_BIGGER; /* Put after same key */
else if (keyinfo->flag & ( HA_NOSAME | HA_FULLTEXT))
{
keyinfo->write_comp_flag= SEARCH_FIND | SEARCH_UPDATE; /* No duplicates */
if (keyinfo->flag & HA_NULL_ARE_EQUAL)
keyinfo->write_comp_flag|= SEARCH_NULL_ARE_EQUAL;
}
else
keyinfo->write_comp_flag= SEARCH_SAME; /* Keys in rec-pos order */
keyinfo->write_comp_flag|= SEARCH_INSERT;
return;
} | O0 | c | setup_key_functions:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0xa4(%rax), %eax
cmpl $0x2, %eax
jne 0x8ff1e
movq -0x8(%rbp), %rax
leaq -0x129d3(%rip), %rcx # 0x7d530
movq %rcx, 0x100(%rax)
movq -0x8(%rbp), %rax
leaq -0x12885(%rip), %rcx # 0x7d690
movq %rcx, 0x108(%rax)
jmp 0x8ff42
movq -0x8(%rbp), %rax
leaq -0x270f9(%rip), %rcx # 0x68e30
movq %rcx, 0x100(%rax)
movq -0x8(%rbp), %rax
leaq -0x2160b(%rip), %rcx # 0x6e930
movq %rcx, 0x108(%rax)
movq -0x8(%rbp), %rax
movzwl 0xa2(%rax), %eax
andl $0x400, %eax # imm = 0x400
cmpl $0x0, %eax
je 0x8ff6b
movq -0x8(%rbp), %rax
leaq 0xd80e(%rip), %rcx # 0x9d770
movq %rcx, 0x110(%rax)
jmp 0x8ff7d
movq -0x8(%rbp), %rax
leaq -0x47986(%rip), %rcx # 0x485f0
movq %rcx, 0x110(%rax)
movq -0x8(%rbp), %rax
movzwl 0xa2(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x8ffef
movq -0x8(%rbp), %rax
leaq 0x5e65(%rip), %rcx # 0x95e00
movq %rcx, 0xd8(%rax)
movq -0x8(%rbp), %rax
leaq 0x86a3(%rip), %rcx # 0x98650
movq %rcx, 0xe0(%rax)
movq -0x8(%rbp), %rax
leaq 0x8ae1(%rip), %rcx # 0x98aa0
movq %rcx, 0xe8(%rax)
movq -0x8(%rbp), %rax
leaq 0xa51f(%rip), %rcx # 0x9a4f0
movq %rcx, 0xf0(%rax)
movq -0x8(%rbp), %rax
leaq 0xad4d(%rip), %rcx # 0x9ad30
movq %rcx, 0xf8(%rax)
jmp 0x9017d
movq -0x8(%rbp), %rax
movzwl 0xa2(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x90121
movq -0x8(%rbp), %rax
leaq 0x7d0f(%rip), %rcx # 0x97d20
movq %rcx, 0xe0(%rax)
movq -0x8(%rbp), %rax
leaq 0x838d(%rip), %rcx # 0x983b0
movq %rcx, 0xe8(%rax)
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rax
movzwl 0x12(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x900e9
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rax
cmpq $0x0, (%rax)
je 0x9009d
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rax
movq (%rax), %rax
movl 0xc(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x9009d
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rax
movzwl 0x12(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x9009d
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rax
movq (%rax), %rax
cmpl $0x1, 0x98(%rax)
jbe 0x900b1
movq -0x8(%rbp), %rax
leaq 0x5d58(%rip), %rcx # 0x95e00
movq %rcx, 0xd8(%rax)
jmp 0x900c3
movq -0x8(%rbp), %rax
leaq 0x6004(%rip), %rcx # 0x960c0
movq %rcx, 0xd8(%rax)
movq -0x8(%rbp), %rax
leaq 0x9892(%rip), %rcx # 0x99960
movq %rcx, 0xf0(%rax)
movq -0x8(%rbp), %rax
leaq 0xa7a0(%rip), %rcx # 0x9a880
movq %rcx, 0xf8(%rax)
jmp 0x9011f
movq -0x8(%rbp), %rax
leaq 0x5d0c(%rip), %rcx # 0x95e00
movq %rcx, 0xd8(%rax)
movq -0x8(%rbp), %rax
leaq 0x980a(%rip), %rcx # 0x99910
movq %rcx, 0xf0(%rax)
movq -0x8(%rbp), %rax
leaq 0xa728(%rip), %rcx # 0x9a840
movq %rcx, 0xf8(%rax)
jmp 0x9017b
movq -0x8(%rbp), %rax
leaq 0x5ae4(%rip), %rcx # 0x95c10
movq %rcx, 0xd8(%rax)
movq -0x8(%rbp), %rax
leaq 0x7a22(%rip), %rcx # 0x97b60
movq %rcx, 0xe0(%rax)
movq -0x8(%rbp), %rax
leaq 0x7b40(%rip), %rcx # 0x97c90
movq %rcx, 0xe8(%rax)
movq -0x8(%rbp), %rax
leaq 0x975e(%rip), %rcx # 0x998c0
movq %rcx, 0xf0(%rax)
movq -0x8(%rbp), %rax
leaq 0xa6cc(%rip), %rcx # 0x9a840
movq %rcx, 0xf8(%rax)
jmp 0x9017d
movq -0x8(%rbp), %rax
movzwl 0xa2(%rax), %eax
andl $0x200, %eax # imm = 0x200
cmpl $0x0, %eax
je 0x901a2
movq -0x8(%rbp), %rax
movl $0x8, 0xb4(%rax)
jmp 0x90202
movq -0x8(%rbp), %rax
movzwl 0xa2(%rax), %eax
andl $0x81, %eax
cmpl $0x0, %eax
je 0x901f2
movq -0x8(%rbp), %rax
movl $0x41, 0xb4(%rax)
movq -0x8(%rbp), %rax
movzwl 0xa2(%rax), %eax
andl $0x800, %eax # imm = 0x800
cmpl $0x0, %eax
je 0x901f0
movq -0x8(%rbp), %rax
movl 0xb4(%rax), %ecx
orl $0x8000, %ecx # imm = 0x8000
movl %ecx, 0xb4(%rax)
jmp 0x90200
movq -0x8(%rbp), %rax
movl $0x4, 0xb4(%rax)
jmp 0x90202
movq -0x8(%rbp), %rax
movl 0xb4(%rax), %ecx
orl $0x20000, %ecx # imm = 0x20000
movl %ecx, 0xb4(%rax)
popq %rbp
retq
nopw (%rax,%rax)
| setup_key_functions:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
movzx eax, byte ptr [rax+0A4h]
cmp eax, 2
jnz short loc_8FF1E
mov rax, [rbp+var_8]
lea rcx, maria_rtree_insert
mov [rax+100h], rcx
mov rax, [rbp+var_8]
lea rcx, maria_rtree_delete
mov [rax+108h], rcx
jmp short loc_8FF42
loc_8FF1E:
mov rax, [rbp+var_8]
lea rcx, _ma_ck_write
mov [rax+100h], rcx
mov rax, [rbp+var_8]
lea rcx, _ma_ck_delete
mov [rax+108h], rcx
loc_8FF42:
mov rax, [rbp+var_8]
movzx eax, word ptr [rax+0A2h]
and eax, 400h
cmp eax, 0
jz short loc_8FF6B
mov rax, [rbp+var_8]
lea rcx, _ma_sp_make_key
mov [rax+110h], rcx
jmp short loc_8FF7D
loc_8FF6B:
mov rax, [rbp+var_8]
lea rcx, _ma_make_key
mov [rax+110h], rcx
loc_8FF7D:
mov rax, [rbp+var_8]
movzx eax, word ptr [rax+0A2h]
and eax, 20h
cmp eax, 0
jz short loc_8FFEF
mov rax, [rbp+var_8]
lea rcx, _ma_seq_search
mov [rax+0D8h], rcx
mov rax, [rbp+var_8]
lea rcx, _ma_get_binary_pack_key
mov [rax+0E0h], rcx
mov rax, [rbp+var_8]
lea rcx, _ma_skip_binary_pack_key
mov [rax+0E8h], rcx
mov rax, [rbp+var_8]
lea rcx, _ma_calc_bin_pack_key_length
mov [rax+0F0h], rcx
mov rax, [rbp+var_8]
lea rcx, _ma_store_bin_pack_key
mov [rax+0F8h], rcx
jmp loc_9017D
loc_8FFEF:
mov rax, [rbp+var_8]
movzx eax, word ptr [rax+0A2h]
and eax, 8
cmp eax, 0
jz loc_90121
mov rax, [rbp+var_8]
lea rcx, _ma_get_pack_key
mov [rax+0E0h], rcx
mov rax, [rbp+var_8]
lea rcx, _ma_skip_pack_key
mov [rax+0E8h], rcx
mov rax, [rbp+var_8]
mov rax, [rax+0C0h]
movzx eax, word ptr [rax+12h]
and eax, 2
cmp eax, 0
jz loc_900E9
mov rax, [rbp+var_8]
mov rax, [rax+0C0h]
cmp qword ptr [rax], 0
jz short loc_9009D
mov rax, [rbp+var_8]
mov rax, [rax+0C0h]
mov rax, [rax]
mov eax, [rax+0Ch]
and eax, 40h
cmp eax, 0
jnz short loc_9009D
mov rax, [rbp+var_8]
mov rax, [rax+0C0h]
movzx eax, word ptr [rax+12h]
and eax, 10h
cmp eax, 0
jnz short loc_9009D
mov rax, [rbp+var_8]
mov rax, [rax+0C0h]
mov rax, [rax]
cmp dword ptr [rax+98h], 1
jbe short loc_900B1
loc_9009D:
mov rax, [rbp+var_8]
lea rcx, _ma_seq_search
mov [rax+0D8h], rcx
jmp short loc_900C3
loc_900B1:
mov rax, [rbp+var_8]
lea rcx, _ma_prefix_search
mov [rax+0D8h], rcx
loc_900C3:
mov rax, [rbp+var_8]
lea rcx, _ma_calc_var_pack_key_length
mov [rax+0F0h], rcx
mov rax, [rbp+var_8]
lea rcx, _ma_store_var_pack_key
mov [rax+0F8h], rcx
jmp short loc_9011F
loc_900E9:
mov rax, [rbp+var_8]
lea rcx, _ma_seq_search
mov [rax+0D8h], rcx
mov rax, [rbp+var_8]
lea rcx, _ma_calc_var_key_length
mov [rax+0F0h], rcx
mov rax, [rbp+var_8]
lea rcx, _ma_store_static_key
mov [rax+0F8h], rcx
loc_9011F:
jmp short loc_9017B
loc_90121:
mov rax, [rbp+var_8]
lea rcx, _ma_bin_search
mov [rax+0D8h], rcx
mov rax, [rbp+var_8]
lea rcx, _ma_get_static_key
mov [rax+0E0h], rcx
mov rax, [rbp+var_8]
lea rcx, _ma_skip_static_key
mov [rax+0E8h], rcx
mov rax, [rbp+var_8]
lea rcx, _ma_calc_static_key_length
mov [rax+0F0h], rcx
mov rax, [rbp+var_8]
lea rcx, _ma_store_static_key
mov [rax+0F8h], rcx
loc_9017B:
jmp short $+2
loc_9017D:
mov rax, [rbp+var_8]
movzx eax, word ptr [rax+0A2h]
and eax, 200h
cmp eax, 0
jz short loc_901A2
mov rax, [rbp+var_8]
mov dword ptr [rax+0B4h], 8
jmp short loc_90202
loc_901A2:
mov rax, [rbp+var_8]
movzx eax, word ptr [rax+0A2h]
and eax, 81h
cmp eax, 0
jz short loc_901F2
mov rax, [rbp+var_8]
mov dword ptr [rax+0B4h], 41h ; 'A'
mov rax, [rbp+var_8]
movzx eax, word ptr [rax+0A2h]
and eax, 800h
cmp eax, 0
jz short loc_901F0
mov rax, [rbp+var_8]
mov ecx, [rax+0B4h]
or ecx, 8000h
mov [rax+0B4h], ecx
loc_901F0:
jmp short loc_90200
loc_901F2:
mov rax, [rbp+var_8]
mov dword ptr [rax+0B4h], 4
loc_90200:
jmp short $+2
loc_90202:
mov rax, [rbp+var_8]
mov ecx, [rax+0B4h]
or ecx, 20000h
mov [rax+0B4h], ecx
pop rbp
retn
| long long setup_key_functions(long long a1)
{
long long result; // rax
if ( *(_BYTE *)(a1 + 164) == 2 )
{
*(_QWORD *)(a1 + 256) = maria_rtree_insert;
*(_QWORD *)(a1 + 264) = maria_rtree_delete;
}
else
{
*(_QWORD *)(a1 + 256) = ma_ck_write;
*(_QWORD *)(a1 + 264) = ma_ck_delete;
}
if ( (*(_WORD *)(a1 + 162) & 0x400) != 0 )
*(_QWORD *)(a1 + 272) = ma_sp_make_key;
else
*(_QWORD *)(a1 + 272) = ma_make_key;
if ( (*(_WORD *)(a1 + 162) & 0x20) != 0 )
{
*(_QWORD *)(a1 + 216) = ma_seq_search;
*(_QWORD *)(a1 + 224) = ma_get_binary_pack_key;
*(_QWORD *)(a1 + 232) = ma_skip_binary_pack_key;
*(_QWORD *)(a1 + 240) = ma_calc_bin_pack_key_length;
*(_QWORD *)(a1 + 248) = ma_store_bin_pack_key;
}
else if ( (*(_WORD *)(a1 + 162) & 8) != 0 )
{
*(_QWORD *)(a1 + 224) = ma_get_pack_key;
*(_QWORD *)(a1 + 232) = ma_skip_pack_key;
if ( (*(_WORD *)(*(_QWORD *)(a1 + 192) + 18LL) & 2) != 0 )
{
if ( !**(_QWORD **)(a1 + 192)
|| (*(_DWORD *)(**(_QWORD **)(a1 + 192) + 12LL) & 0x40) != 0
|| (*(_WORD *)(*(_QWORD *)(a1 + 192) + 18LL) & 0x10) != 0
|| *(_DWORD *)(**(_QWORD **)(a1 + 192) + 152LL) > 1u )
{
*(_QWORD *)(a1 + 216) = ma_seq_search;
}
else
{
*(_QWORD *)(a1 + 216) = ma_prefix_search;
}
*(_QWORD *)(a1 + 240) = ma_calc_var_pack_key_length;
*(_QWORD *)(a1 + 248) = ma_store_var_pack_key;
}
else
{
*(_QWORD *)(a1 + 216) = ma_seq_search;
*(_QWORD *)(a1 + 240) = ma_calc_var_key_length;
*(_QWORD *)(a1 + 248) = ma_store_static_key;
}
}
else
{
*(_QWORD *)(a1 + 216) = ma_bin_search;
*(_QWORD *)(a1 + 224) = ma_get_static_key;
*(_QWORD *)(a1 + 232) = ma_skip_static_key;
*(_QWORD *)(a1 + 240) = ma_calc_static_key_length;
*(_QWORD *)(a1 + 248) = ma_store_static_key;
}
if ( (*(_WORD *)(a1 + 162) & 0x200) != 0 )
{
*(_DWORD *)(a1 + 180) = 8;
}
else if ( (*(_WORD *)(a1 + 162) & 0x81) != 0 )
{
*(_DWORD *)(a1 + 180) = 65;
if ( (*(_WORD *)(a1 + 162) & 0x800) != 0 )
*(_DWORD *)(a1 + 180) |= 0x8000u;
}
else
{
*(_DWORD *)(a1 + 180) = 4;
}
result = a1;
*(_DWORD *)(a1 + 180) |= 0x20000u;
return result;
}
| setup_key_functions:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,byte ptr [RAX + 0xa4]
CMP EAX,0x2
JNZ 0x0018ff1e
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x17d530]
MOV qword ptr [RAX + 0x100],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x17d690]
MOV qword ptr [RAX + 0x108],RCX
JMP 0x0018ff42
LAB_0018ff1e:
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x168e30]
MOV qword ptr [RAX + 0x100],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x16e930]
MOV qword ptr [RAX + 0x108],RCX
LAB_0018ff42:
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,word ptr [RAX + 0xa2]
AND EAX,0x400
CMP EAX,0x0
JZ 0x0018ff6b
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x19d770]
MOV qword ptr [RAX + 0x110],RCX
JMP 0x0018ff7d
LAB_0018ff6b:
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x1485f0]
MOV qword ptr [RAX + 0x110],RCX
LAB_0018ff7d:
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,word ptr [RAX + 0xa2]
AND EAX,0x20
CMP EAX,0x0
JZ 0x0018ffef
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x195e00]
MOV qword ptr [RAX + 0xd8],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x198650]
MOV qword ptr [RAX + 0xe0],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x198aa0]
MOV qword ptr [RAX + 0xe8],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x19a4f0]
MOV qword ptr [RAX + 0xf0],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x19ad30]
MOV qword ptr [RAX + 0xf8],RCX
JMP 0x0019017d
LAB_0018ffef:
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,word ptr [RAX + 0xa2]
AND EAX,0x8
CMP EAX,0x0
JZ 0x00190121
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x197d20]
MOV qword ptr [RAX + 0xe0],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x1983b0]
MOV qword ptr [RAX + 0xe8],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xc0]
MOVZX EAX,word ptr [RAX + 0x12]
AND EAX,0x2
CMP EAX,0x0
JZ 0x001900e9
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xc0]
CMP qword ptr [RAX],0x0
JZ 0x0019009d
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0xc]
AND EAX,0x40
CMP EAX,0x0
JNZ 0x0019009d
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xc0]
MOVZX EAX,word ptr [RAX + 0x12]
AND EAX,0x10
CMP EAX,0x0
JNZ 0x0019009d
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX + 0x98],0x1
JBE 0x001900b1
LAB_0019009d:
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x195e00]
MOV qword ptr [RAX + 0xd8],RCX
JMP 0x001900c3
LAB_001900b1:
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x1960c0]
MOV qword ptr [RAX + 0xd8],RCX
LAB_001900c3:
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x199960]
MOV qword ptr [RAX + 0xf0],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x19a880]
MOV qword ptr [RAX + 0xf8],RCX
JMP 0x0019011f
LAB_001900e9:
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x195e00]
MOV qword ptr [RAX + 0xd8],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x199910]
MOV qword ptr [RAX + 0xf0],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x19a840]
MOV qword ptr [RAX + 0xf8],RCX
LAB_0019011f:
JMP 0x0019017b
LAB_00190121:
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x195c10]
MOV qword ptr [RAX + 0xd8],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x197b60]
MOV qword ptr [RAX + 0xe0],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x197c90]
MOV qword ptr [RAX + 0xe8],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x1998c0]
MOV qword ptr [RAX + 0xf0],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x19a840]
MOV qword ptr [RAX + 0xf8],RCX
LAB_0019017b:
JMP 0x0019017d
LAB_0019017d:
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,word ptr [RAX + 0xa2]
AND EAX,0x200
CMP EAX,0x0
JZ 0x001901a2
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0xb4],0x8
JMP 0x00190202
LAB_001901a2:
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,word ptr [RAX + 0xa2]
AND EAX,0x81
CMP EAX,0x0
JZ 0x001901f2
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0xb4],0x41
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,word ptr [RAX + 0xa2]
AND EAX,0x800
CMP EAX,0x0
JZ 0x001901f0
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0xb4]
OR ECX,0x8000
MOV dword ptr [RAX + 0xb4],ECX
LAB_001901f0:
JMP 0x00190200
LAB_001901f2:
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0xb4],0x4
LAB_00190200:
JMP 0x00190202
LAB_00190202:
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0xb4]
OR ECX,0x20000
MOV dword ptr [RAX + 0xb4],ECX
POP RBP
RET
|
void setup_key_functions(long param_1)
{
if (*(char *)(param_1 + 0xa4) == '\x02') {
*(code **)(param_1 + 0x100) = maria_rtree_insert;
*(code **)(param_1 + 0x108) = maria_rtree_delete;
}
else {
*(code **)(param_1 + 0x100) = _ma_ck_write;
*(code **)(param_1 + 0x108) = _ma_ck_delete;
}
if ((*(ushort *)(param_1 + 0xa2) & 0x400) == 0) {
*(code **)(param_1 + 0x110) = _ma_make_key;
}
else {
*(code **)(param_1 + 0x110) = _ma_sp_make_key;
}
if ((*(ushort *)(param_1 + 0xa2) & 0x20) == 0) {
if ((*(ushort *)(param_1 + 0xa2) & 8) == 0) {
*(code **)(param_1 + 0xd8) = _ma_bin_search;
*(code **)(param_1 + 0xe0) = _ma_get_static_key;
*(code **)(param_1 + 0xe8) = _ma_skip_static_key;
*(code **)(param_1 + 0xf0) = _ma_calc_static_key_length;
*(code **)(param_1 + 0xf8) = _ma_store_static_key;
}
else {
*(code **)(param_1 + 0xe0) = _ma_get_pack_key;
*(code **)(param_1 + 0xe8) = _ma_skip_pack_key;
if ((*(ushort *)(*(long *)(param_1 + 0xc0) + 0x12) & 2) == 0) {
*(code **)(param_1 + 0xd8) = _ma_seq_search;
*(code **)(param_1 + 0xf0) = _ma_calc_var_key_length;
*(code **)(param_1 + 0xf8) = _ma_store_static_key;
}
else {
if ((((**(long **)(param_1 + 0xc0) == 0) ||
((*(uint *)(**(long **)(param_1 + 0xc0) + 0xc) & 0x40) != 0)) ||
((*(ushort *)(*(long *)(param_1 + 0xc0) + 0x12) & 0x10) != 0)) ||
(1 < *(uint *)(**(long **)(param_1 + 0xc0) + 0x98))) {
*(code **)(param_1 + 0xd8) = _ma_seq_search;
}
else {
*(code **)(param_1 + 0xd8) = _ma_prefix_search;
}
*(code **)(param_1 + 0xf0) = _ma_calc_var_pack_key_length;
*(code **)(param_1 + 0xf8) = _ma_store_var_pack_key;
}
}
}
else {
*(code **)(param_1 + 0xd8) = _ma_seq_search;
*(code **)(param_1 + 0xe0) = _ma_get_binary_pack_key;
*(code **)(param_1 + 0xe8) = _ma_skip_binary_pack_key;
*(code **)(param_1 + 0xf0) = _ma_calc_bin_pack_key_length;
*(code **)(param_1 + 0xf8) = _ma_store_bin_pack_key;
}
if ((*(ushort *)(param_1 + 0xa2) & 0x200) == 0) {
if ((*(ushort *)(param_1 + 0xa2) & 0x81) == 0) {
*(int4 *)(param_1 + 0xb4) = 4;
}
else {
*(int4 *)(param_1 + 0xb4) = 0x41;
if ((*(ushort *)(param_1 + 0xa2) & 0x800) != 0) {
*(uint *)(param_1 + 0xb4) = *(uint *)(param_1 + 0xb4) | 0x8000;
}
}
}
else {
*(int4 *)(param_1 + 0xb4) = 8;
}
*(uint *)(param_1 + 0xb4) = *(uint *)(param_1 + 0xb4) | 0x20000;
return;
}
| |
54,129 | rtc_get_jday | navaro[P]qoraal-tictactoe/build_O3/_deps/qoraal-src/src/common/rtclib.c | int32_t
rtc_get_jday (RTCLIB_DATE_T d) /* convert date to day number */
{
int32_t I,J,K;
// http://aa.usno.navy.mil/faq/docs/JD_Formula.php
I = d.year ;
J = d.month ;
K = d.day ;
return K-32075+1461*(I+4800+(J-14)/12)/4+
367*(J-2-(J-14)/12*12)/12-
3*((I+4900+(J-14)/12)/100)/4 ;
} | O3 | c | rtc_get_jday:
pushq %rbp
movq %rsp, %rbp
movl %edi, %edx
shrl $0x8, %edx
movl %edi, %eax
shrl $0x10, %eax
movl $0xff, %ecx
andl %ecx, %edx
andl %ecx, %edi
imull $0x2aab, %edx, %ecx # imm = 0x2AAB
addl $0xfffdaaa6, %ecx # imm = 0xFFFDAAA6
movl %ecx, %esi
shrl $0x1f, %esi
sarl $0x11, %ecx
addl %esi, %ecx
movswl %cx, %esi
leal (%rax,%rsi), %ecx
imull $0x5b5, %ecx, %ecx # imm = 0x5B5
addl $0x6b01c0, %ecx # imm = 0x6B01C0
shrl $0x2, %ecx
addl %edi, %ecx
leal (,%rsi,4), %edi
leal (%rdi,%rdi,2), %edi
subl %edi, %edx
imull $0x16f, %edx, %edx # imm = 0x16F
addl $0xfffffd22, %edx # imm = 0xFFFFFD22
movslq %edx, %rdx
imulq $0x2aaaaaab, %rdx, %rdx # imm = 0x2AAAAAAB
movq %rdx, %rdi
shrq $0x3f, %rdi
sarq $0x21, %rdx
addl %edi, %edx
addl %esi, %eax
addl $0x1324, %eax # imm = 0x1324
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
shrq $0x25, %rax
leal (%rax,%rax,2), %eax
shrl $0x2, %eax
subl %eax, %ecx
leal (%rcx,%rdx), %eax
addl $0xffff82b5, %eax # imm = 0xFFFF82B5
popq %rbp
retq
| rtc_get_jday:
push rbp
mov rbp, rsp
mov edx, edi
shr edx, 8
mov eax, edi
shr eax, 10h
mov ecx, 0FFh
and edx, ecx
and edi, ecx
imul ecx, edx, 2AABh
add ecx, 0FFFDAAA6h
mov esi, ecx
shr esi, 1Fh
sar ecx, 11h
add ecx, esi
movsx esi, cx
lea ecx, [rax+rsi]
imul ecx, 5B5h
add ecx, 6B01C0h
shr ecx, 2
add ecx, edi
lea edi, ds:0[rsi*4]
lea edi, [rdi+rdi*2]
sub edx, edi
imul edx, 16Fh
add edx, 0FFFFFD22h
movsxd rdx, edx
imul rdx, 2AAAAAABh
mov rdi, rdx
shr rdi, 3Fh
sar rdx, 21h
add edx, edi
add eax, esi
add eax, 1324h
imul rax, 51EB851Fh
shr rax, 25h
lea eax, [rax+rax*2]
shr eax, 2
sub ecx, eax
lea eax, [rcx+rdx]
add eax, 0FFFF82B5h
pop rbp
retn
| long long rtc_get_jday(unsigned int a1)
{
int v1; // esi
v1 = (__int16)(((10923 * (unsigned int)BYTE1(a1) - 152922) >> 31) + ((10923 * BYTE1(a1) - 152922) >> 17));
return (unsigned __int8)a1
+ ((unsigned int)(1461 * (HIWORD(a1) + v1) + 7012800) >> 2)
- ((3 * ((v1 + HIWORD(a1) + 4900) / 0x64u)) >> 2)
+ (367 * (BYTE1(a1) - 12 * v1) - 734) / 12
- 32075;
}
| rtc_get_jday:
PUSH RBP
MOV RBP,RSP
MOV EDX,EDI
SHR EDX,0x8
MOV EAX,EDI
SHR EAX,0x10
MOV ECX,0xff
AND EDX,ECX
AND EDI,ECX
IMUL ECX,EDX,0x2aab
ADD ECX,0xfffdaaa6
MOV ESI,ECX
SHR ESI,0x1f
SAR ECX,0x11
ADD ECX,ESI
MOVSX ESI,CX
LEA ECX,[RAX + RSI*0x1]
IMUL ECX,ECX,0x5b5
ADD ECX,0x6b01c0
SHR ECX,0x2
ADD ECX,EDI
LEA EDI,[RSI*0x4]
LEA EDI,[RDI + RDI*0x2]
SUB EDX,EDI
IMUL EDX,EDX,0x16f
ADD EDX,0xfffffd22
MOVSXD RDX,EDX
IMUL RDX,RDX,0x2aaaaaab
MOV RDI,RDX
SHR RDI,0x3f
SAR RDX,0x21
ADD EDX,EDI
ADD EAX,ESI
ADD EAX,0x1324
IMUL RAX,RAX,0x51eb851f
SHR RAX,0x25
LEA EAX,[RAX + RAX*0x2]
SHR EAX,0x2
SUB ECX,EAX
LEA EAX,[RCX + RDX*0x1]
ADD EAX,0xffff82b5
POP RBP
RET
|
int rtc_get_jday(uint param_1)
{
short sVar1;
uint uVar2;
int iVar3;
uVar2 = param_1 >> 8 & 0xff;
sVar1 = (short)(uVar2 * 0x2aab + -0x2555a >> 0x10);
iVar3 = (int)(short)((sVar1 >> 1) - (sVar1 >> 0xf));
return (((((param_1 >> 0x10) + iVar3) * 0x5b5 + 0x6b01c0 >> 2) + (param_1 & 0xff)) -
((((param_1 >> 0x10) + iVar3 + 0x1324) / 100) * 3 >> 2)) +
(int)((uVar2 + iVar3 * -0xc) * 0x16f + -0x2de) / 0xc + -0x7d4b;
}
| |
54,130 | SchemaConverter::check_errors() | llama.cpp/common/json-schema-to-grammar.cpp | void check_errors() {
if (!_errors.empty()) {
throw std::runtime_error("JSON schema conversion failed:\n" + string_join(_errors, "\n"));
}
if (!_warnings.empty()) {
fprintf(stderr, "WARNING: JSON schema conversion was incomplete: %s\n", string_join(_warnings, "; ").c_str());
}
} | O3 | cpp | SchemaConverter::check_errors():
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq 0xc8(%rdi), %rax
cmpq 0xd0(%rdi), %rax
jne 0xbaac5
movq 0xe0(%r14), %rax
cmpq 0xe8(%r14), %rax
jne 0xbaa6a
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x504cf(%rip), %rax # 0x10af40
movq (%rax), %r15
leaq 0x18(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x1f655(%rip), %rsi # 0xda0d9
leaq 0x1f650(%rip), %rdx # 0xda0db
leaq 0x8(%rsp), %rdi
callq 0x237c2
addq $0xe0, %r14
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
callq 0xb1917
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r15, %rsi
movq %rbx, %rcx
callq 0x1f2e2
jmp 0xbaa5f
movl $0x10, %edi
callq 0x1d520
movq %rax, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x17aad(%rip), %rsi # 0xd258f
leaq 0x17aa7(%rip), %rdx # 0xd2590
leaq 0x28(%rsp), %rdi
callq 0x237c2
addq $0xc8, %r14
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %r14, %rsi
callq 0xb1917
leaq 0x1f572(%rip), %rsi # 0xda085
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x53e90
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x1d380
xorl %ebp, %ebp
movq 0x5047d(%rip), %rsi # 0x10afb8
movq 0x5042e(%rip), %rdx # 0x10af70
movq %rbx, %rdi
callq 0x1d890
movq %rax, %r14
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbab70
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1d160
jmp 0xbab70
movq %rax, %r14
movb $0x1, %bpl
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbab8b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d160
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xbaba2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1d160
testb %bpl, %bpl
jne 0xbabc8
jmp 0xbabf1
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xbabc8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1d160
jmp 0xbabc8
movq %rax, %r14
movq %rbx, %rdi
callq 0x1dc90
jmp 0xbabf1
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0xbabf1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d160
jmp 0xbabf1
movq %rax, %r14
movq %r14, %rdi
callq 0x1d8e0
nop
| _ZN15SchemaConverter12check_errorsEv:
push rbp
push r15
push r14
push rbx
sub rsp, 68h
mov r14, rdi
mov rax, [rdi+0C8h]
cmp rax, [rdi+0D0h]
jnz short loc_BAAC5
mov rax, [r14+0E0h]
cmp rax, [r14+0E8h]
jnz short loc_BAA6A
loc_BAA5F:
add rsp, 68h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_BAA6A:
mov rax, cs:stderr_ptr
mov r15, [rax]
lea rbx, [rsp+88h+var_70]
mov [rbx-10h], rbx
lea rsi, asc_DA0D9; "; "
lea rdx, asc_DA0D9+2; ""
lea rdi, [rsp+88h+var_80]
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)
add r14, 0E0h
lea rdi, [rsp+88h+var_40]
lea rdx, [rsp+88h+var_80]
mov rsi, r14
call _Z11string_joinRKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_; string_join(std::vector<std::string> const&,std::string const&)
lea rdi, [rsp+88h+var_40]
lea rdx, [rsp+88h+var_80]
mov rsi, r15
mov rcx, rbx
call _ZN15SchemaConverter12check_errorsEv_cold_1; SchemaConverter::check_errors(void) [clone]
jmp short loc_BAA5F
loc_BAAC5:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+88h+var_50]
mov [r15-10h], r15
lea rsi, aExampleToolCal+1Ch; "\n"
lea rdx, aExampleToolCal+1Dh; ""
lea rdi, [rsp+88h+var_60]
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)
add r14, 0C8h
lea rdi, [rsp+88h+var_80]
lea rdx, [rsp+88h+var_60]
mov rsi, r14
call _Z11string_joinRKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_; string_join(std::vector<std::string> const&,std::string const&)
lea rsi, aJsonSchemaConv; "JSON schema conversion failed:\n"
lea rdi, [rsp+88h+var_40]
lea rdx, [rsp+88h+var_80]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+88h+var_40]
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:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+88h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BAB70
mov rsi, [rsp+88h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_BAB70
mov r14, rax
mov bpl, 1
loc_BAB70:
lea rax, [rsp+88h+var_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BAB8B
mov rsi, [rsp+88h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_BAB8B:
mov rdi, [rsp+88h+var_60]; void *
cmp rdi, r15
jz short loc_BABA2
mov rsi, [rsp+88h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_BABA2:
test bpl, bpl
jnz short loc_BABC8
jmp short loc_BABF1
mov r14, rax
mov rdi, [rsp+88h+var_60]; void *
cmp rdi, r15
jz short loc_BABC8
mov rsi, [rsp+88h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_BABC8
mov r14, rax
loc_BABC8:
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_BABF1
mov r14, rax
mov rdi, [rsp+88h+var_80]; void *
cmp rdi, rbx
jz short loc_BABF1
mov rsi, [rsp+88h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_BABF1
mov r14, rax
loc_BABF1:
mov rdi, r14
call __Unwind_Resume
| void SchemaConverter::check_errors(SchemaConverter *this)
{
long long v1; // r15
void *exception; // rbx
void *v3[2]; // [rsp+8h] [rbp-80h] BYREF
void *v4[2]; // [rsp+18h] [rbp-70h] BYREF
void *v5[2]; // [rsp+28h] [rbp-60h] BYREF
long long v6; // [rsp+38h] [rbp-50h] BYREF
const char *v7[2]; // [rsp+48h] [rbp-40h] BYREF
if ( *((_QWORD *)this + 25) != *((_QWORD *)this + 26) )
{
exception = __cxa_allocate_exception(0x10uLL);
v5[0] = &v6;
std::string::_M_construct<char const*>((long long)v5, "\n", (long long)"");
string_join((long long)v3, (long long *)this + 25, v5);
std::operator+<char>(v7, (long long)"JSON schema conversion failed:\n", (long long)v3);
std::runtime_error::runtime_error(exception, v7);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( *((_QWORD *)this + 28) != *((_QWORD *)this + 29) )
{
v1 = stderr;
v3[0] = v4;
std::string::_M_construct<char const*>((long long)v3, "; ", (long long)"");
string_join((long long)v7, (long long *)this + 28, v3);
SchemaConverter::check_errors(v7, v1, v3, v4);
}
}
| check_errors:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x68
MOV R14,RDI
MOV RAX,qword ptr [RDI + 0xc8]
CMP RAX,qword ptr [RDI + 0xd0]
JNZ 0x001baac5
MOV RAX,qword ptr [R14 + 0xe0]
CMP RAX,qword ptr [R14 + 0xe8]
JNZ 0x001baa6a
LAB_001baa5f:
ADD RSP,0x68
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001baa6a:
MOV RAX,qword ptr [0x0020af40]
MOV R15,qword ptr [RAX]
LEA RBX,[RSP + 0x18]
MOV qword ptr [RBX + -0x10],RBX
LAB_001baa7d:
LEA RSI,[0x1da0d9]
LEA RDX,[0x1da0db]
LEA RDI,[RSP + 0x8]
CALL 0x001237c2
LAB_001baa95:
ADD R14,0xe0
LEA RDI,[RSP + 0x48]
LEA RDX,[RSP + 0x8]
MOV RSI,R14
CALL 0x001b1917
LAB_001baaae:
LEA RDI,[RSP + 0x48]
LEA RDX,[RSP + 0x8]
MOV RSI,R15
MOV RCX,RBX
CALL 0x0011f2e2
JMP 0x001baa5f
LAB_001baac5:
MOV EDI,0x10
CALL 0x0011d520
MOV RBX,RAX
LEA R15,[RSP + 0x38]
MOV qword ptr [R15 + -0x10],R15
LAB_001baadb:
LEA RSI,[0x1d258f]
LEA RDX,[0x1d2590]
LEA RDI,[RSP + 0x28]
CALL 0x001237c2
LAB_001baaf3:
ADD R14,0xc8
LEA RDI,[RSP + 0x8]
LEA RDX,[RSP + 0x28]
MOV RSI,R14
CALL 0x001b1917
LAB_001bab0c:
LEA RSI,[0x1da085]
LEA RDI,[RSP + 0x48]
LEA RDX,[RSP + 0x8]
CALL 0x00153e90
MOV BPL,0x1
LAB_001bab25:
LEA RSI,[RSP + 0x48]
MOV RDI,RBX
CALL 0x0011d380
XOR EBP,EBP
MOV RSI,qword ptr [0x0020afb8]
MOV RDX,qword ptr [0x0020af70]
MOV RDI,RBX
CALL 0x0011d890
|
/* SchemaConverter::check_errors() */
void __thiscall SchemaConverter::check_errors(SchemaConverter *this)
{
runtime_error *this_00;
int1 *local_80 [2];
int1 local_70 [16];
int1 *local_60 [2];
int1 local_50 [16];
vector local_40 [32];
if (*(long *)(this + 200) == *(long *)(this + 0xd0)) {
if (*(long *)(this + 0xe0) != *(long *)(this + 0xe8)) {
local_80[0] = local_70;
/* try { // try from 001baa7d to 001baa94 has its CatchHandler @ 001babee */
std::__cxx11::string::_M_construct<char_const*>(local_80,&DAT_001da0d9,&DAT_001da0db);
/* try { // try from 001baa95 to 001baaad has its CatchHandler @ 001babd2 */
string_join(local_40,(string *)(this + 0xe0));
check_errors();
}
return;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
local_60[0] = local_50;
/* try { // try from 001baadb to 001baaf2 has its CatchHandler @ 001babc5 */
std::__cxx11::string::_M_construct<char_const*>(local_60,"\n","");
/* try { // try from 001baaf3 to 001bab0b has its CatchHandler @ 001baba9 */
string_join((vector *)local_80,(string *)(this + 200));
/* try { // try from 001bab0c to 001bab21 has its CatchHandler @ 001bab6a */
std::operator+((char *)local_40,(string *)"JSON schema conversion failed:\n");
/* try { // try from 001bab25 to 001bab49 has its CatchHandler @ 001bab4a */
std::runtime_error::runtime_error(this_00,(string *)local_40);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_0020afb8,PTR__runtime_error_0020af70);
}
| |
54,131 | my_getwd | eloqsql/mysys/my_getwd.c | int my_getwd(char * buf, size_t size, myf MyFlags)
{
char * pos;
DBUG_ENTER("my_getwd");
DBUG_PRINT("my",("buf:%p size: %u MyFlags %lu",
buf, (uint) size, MyFlags));
if (size < 1)
DBUG_RETURN(-1);
if (curr_dir[0]) /* Current pos is saved here */
(void) strmake(buf,&curr_dir[0],size-1);
else
{
#if defined(HAVE_GETCWD)
if (size < 2)
DBUG_RETURN(-1);
if (!getcwd(buf,(uint) (size-2)) && MyFlags & MY_WME)
{
my_errno=errno;
my_error(EE_GETWD,MYF(ME_BELL),errno);
DBUG_RETURN(-1);
}
#elif defined(HAVE_GETWD)
{
char pathname[MAXPATHLEN];
getwd(pathname);
strmake(buf,pathname,size-1);
}
#else
#error "No way to get current directory"
#endif
if (*((pos=strend(buf))-1) != FN_LIBCHAR) /* End with FN_LIBCHAR */
{
pos[0]= FN_LIBCHAR;
pos[1]=0;
}
(void) strmake(&curr_dir[0],buf, (size_t) (FN_REFLEN-1));
}
DBUG_RETURN(0);
} | O0 | c | my_getwd:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
jmp 0x2ec26
cmpq $0x1, -0x18(%rbp)
jae 0x2ec3b
jmp 0x2ec2f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2ed1a
leaq 0x3570be(%rip), %rax # 0x385d00
cmpb $0x0, (%rax)
je 0x2ec64
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
leaq 0x3570a6(%rip), %rsi # 0x385d00
callq 0x774f0
jmp 0x2ed11
cmpq $0x2, -0x18(%rbp)
jae 0x2ec79
jmp 0x2ec6d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2ed1a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
subq $0x2, %rax
movl %eax, %eax
movl %eax, %esi
callq 0x24170
cmpq $0x0, %rax
jne 0x2ecd7
movq -0x20(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0x2ecd7
callq 0x24050
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
callq 0x26770
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
callq 0x24050
movl (%rax), %edx
movl $0x10, %edi
movl $0x4, %esi
movb $0x0, %al
callq 0x2e6e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2ed1a
movq -0x10(%rbp), %rdi
callq 0x77470
movq %rax, -0x28(%rbp)
movsbl -0x1(%rax), %eax
cmpl $0x2f, %eax
je 0x2ecfc
movq -0x28(%rbp), %rax
movb $0x2f, (%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x10(%rbp), %rsi
leaq 0x356ff9(%rip), %rdi # 0x385d00
movl $0x1ff, %edx # imm = 0x1FF
callq 0x774f0
jmp 0x2ed13
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_getwd:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
jmp short $+2
loc_2EC26:
cmp [rbp+var_18], 1
jnb short loc_2EC3B
jmp short $+2
loc_2EC2F:
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_2ED1A
loc_2EC3B:
lea rax, curr_dir
cmp byte ptr [rax], 0
jz short loc_2EC64
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
sub rdx, 1
lea rsi, curr_dir
call strmake
jmp loc_2ED11
loc_2EC64:
cmp [rbp+var_18], 2
jnb short loc_2EC79
jmp short $+2
loc_2EC6D:
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_2ED1A
loc_2EC79:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_18]
sub rax, 2
mov eax, eax
mov esi, eax
call _getcwd
cmp rax, 0
jnz short loc_2ECD7
mov rax, [rbp+var_20]
and rax, 10h
cmp rax, 0
jz short loc_2ECD7
call ___errno_location
mov eax, [rax]
mov [rbp+var_2C], eax
call _my_thread_var
mov ecx, [rbp+var_2C]
mov [rax], ecx
call ___errno_location
mov edx, [rax]
mov edi, 10h
mov esi, 4
mov al, 0
call my_error
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_2ED1A
loc_2ECD7:
mov rdi, [rbp+var_10]
call strend
mov [rbp+var_28], rax
movsx eax, byte ptr [rax-1]
cmp eax, 2Fh ; '/'
jz short loc_2ECFC
mov rax, [rbp+var_28]
mov byte ptr [rax], 2Fh ; '/'
mov rax, [rbp+var_28]
mov byte ptr [rax+1], 0
loc_2ECFC:
mov rsi, [rbp+var_10]
lea rdi, curr_dir
mov edx, 1FFh
call strmake
loc_2ED11:
jmp short $+2
loc_2ED13:
mov [rbp+var_4], 0
loc_2ED1A:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long my_getwd(long long a1, unsigned long long a2, char a3)
{
unsigned int *v3; // rax
int v5; // [rsp+4h] [rbp-2Ch]
_BYTE *v6; // [rsp+8h] [rbp-28h]
if ( a2 )
{
if ( curr_dir[0] )
{
strmake(a1, curr_dir, a2 - 1);
}
else
{
if ( a2 < 2 )
return (unsigned int)-1;
if ( !getcwd(a1, (unsigned int)(a2 - 2)) && (a3 & 0x10) != 0 )
{
v5 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var() = v5;
v3 = (unsigned int *)__errno_location();
my_error(0x10u, 4LL, *v3);
return (unsigned int)-1;
}
v6 = (_BYTE *)strend(a1);
if ( *(v6 - 1) != 47 )
{
*v6 = 47;
v6[1] = 0;
}
strmake(curr_dir, a1, 511LL);
}
return 0;
}
return (unsigned int)-1;
}
| my_getwd:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
JMP 0x0012ec26
LAB_0012ec26:
CMP qword ptr [RBP + -0x18],0x1
JNC 0x0012ec3b
JMP 0x0012ec2f
LAB_0012ec2f:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0012ed1a
LAB_0012ec3b:
LEA RAX,[0x485d00]
CMP byte ptr [RAX],0x0
JZ 0x0012ec64
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,0x1
LEA RSI,[0x485d00]
CALL 0x001774f0
JMP 0x0012ed11
LAB_0012ec64:
CMP qword ptr [RBP + -0x18],0x2
JNC 0x0012ec79
JMP 0x0012ec6d
LAB_0012ec6d:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0012ed1a
LAB_0012ec79:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,0x2
MOV EAX,EAX
MOV ESI,EAX
CALL 0x00124170
CMP RAX,0x0
JNZ 0x0012ecd7
MOV RAX,qword ptr [RBP + -0x20]
AND RAX,0x10
CMP RAX,0x0
JZ 0x0012ecd7
CALL 0x00124050
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
CALL 0x00126770
MOV ECX,dword ptr [RBP + -0x2c]
MOV dword ptr [RAX],ECX
CALL 0x00124050
MOV EDX,dword ptr [RAX]
MOV EDI,0x10
MOV ESI,0x4
MOV AL,0x0
CALL 0x0012e6e0
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0012ed1a
LAB_0012ecd7:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00177470
MOV qword ptr [RBP + -0x28],RAX
MOVSX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x2f
JZ 0x0012ecfc
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX],0x2f
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x1],0x0
LAB_0012ecfc:
MOV RSI,qword ptr [RBP + -0x10]
LEA RDI,[0x485d00]
MOV EDX,0x1ff
CALL 0x001774f0
LAB_0012ed11:
JMP 0x0012ed13
LAB_0012ed13:
MOV dword ptr [RBP + -0x4],0x0
LAB_0012ed1a:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 my_getwd(char *param_1,ulong param_2,ulong param_3)
{
int iVar1;
char *pcVar2;
int *piVar3;
int1 *puVar4;
if (param_2 == 0) {
return 0xffffffff;
}
if (curr_dir == '\0') {
if (param_2 < 2) {
return 0xffffffff;
}
pcVar2 = getcwd(param_1,(ulong)((int)param_2 - 2));
if ((pcVar2 == (char *)0x0) && ((param_3 & 0x10) != 0)) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar3 = (int *)_my_thread_var();
*piVar3 = iVar1;
piVar3 = __errno_location();
my_error(0x10,4,*piVar3);
return 0xffffffff;
}
puVar4 = (int1 *)strend(param_1);
if (puVar4[-1] != '/') {
*puVar4 = 0x2f;
puVar4[1] = 0;
}
strmake(&curr_dir,param_1,0x1ff);
}
else {
strmake(param_1,&curr_dir,param_2 - 1);
}
return 0;
}
| |
54,132 | my_getwd | eloqsql/mysys/my_getwd.c | int my_getwd(char * buf, size_t size, myf MyFlags)
{
char * pos;
DBUG_ENTER("my_getwd");
DBUG_PRINT("my",("buf:%p size: %u MyFlags %lu",
buf, (uint) size, MyFlags));
if (size < 1)
DBUG_RETURN(-1);
if (curr_dir[0]) /* Current pos is saved here */
(void) strmake(buf,&curr_dir[0],size-1);
else
{
#if defined(HAVE_GETCWD)
if (size < 2)
DBUG_RETURN(-1);
if (!getcwd(buf,(uint) (size-2)) && MyFlags & MY_WME)
{
my_errno=errno;
my_error(EE_GETWD,MYF(ME_BELL),errno);
DBUG_RETURN(-1);
}
#elif defined(HAVE_GETWD)
{
char pathname[MAXPATHLEN];
getwd(pathname);
strmake(buf,pathname,size-1);
}
#else
#error "No way to get current directory"
#endif
if (*((pos=strend(buf))-1) != FN_LIBCHAR) /* End with FN_LIBCHAR */
{
pos[0]= FN_LIBCHAR;
pos[1]=0;
}
(void) strmake(&curr_dir[0],buf, (size_t) (FN_REFLEN-1));
}
DBUG_RETURN(0);
} | O3 | c | my_getwd:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0x2b05d
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %r14
leaq 0x33b0e4(%rip), %rax # 0x3660e0
cmpb $0x0, (%rax)
je 0x2b017
decq %rdx
leaq 0x33b0d5(%rip), %rsi # 0x3660e0
movq %r14, %rdi
callq 0x5a5f0
xorl %ebx, %ebx
jmp 0x2b05d
cmpq $0x1, %rdx
je 0x2b05d
addl $-0x2, %edx
movq %r14, %rdi
movq %rdx, %rsi
callq 0x24170
testb $0x10, %r15b
je 0x2b06a
testq %rax, %rax
jne 0x2b06a
callq 0x24060
movq %rax, %r14
movl (%rax), %r15d
callq 0x26776
movl %r15d, (%rax)
movl (%r14), %edx
movl $0x4, %esi
movl $0x10, %edi
xorl %eax, %eax
callq 0x2ac53
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x5a5a8
cmpb $0x2f, -0x1(%rax)
je 0x2b07d
movw $0x2f, (%rax)
leaq 0x33b05c(%rip), %rdi # 0x3660e0
movl $0x1ff, %edx # imm = 0x1FF
movq %r14, %rsi
jmp 0x2b00e
| my_getwd:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov ebx, 0FFFFFFFFh
test rsi, rsi
jz short loc_2B05D
mov r15, rdx
mov rdx, rsi
mov r14, rdi
lea rax, curr_dir
cmp byte ptr [rax], 0
jz short loc_2B017
dec rdx
lea rsi, curr_dir
mov rdi, r14
loc_2B00E:
call strmake
xor ebx, ebx
jmp short loc_2B05D
loc_2B017:
cmp rdx, 1
jz short loc_2B05D
add edx, 0FFFFFFFEh
mov rdi, r14
mov rsi, rdx
call _getcwd
test r15b, 10h
jz short loc_2B06A
test rax, rax
jnz short loc_2B06A
call ___errno_location
mov r14, rax
mov r15d, [rax]
call _my_thread_var
mov [rax], r15d
mov edx, [r14]
mov esi, 4
mov edi, 10h
xor eax, eax
call my_error
loc_2B05D:
mov eax, ebx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_2B06A:
mov rdi, r14
call strend
cmp byte ptr [rax-1], 2Fh ; '/'
jz short loc_2B07D
mov word ptr [rax], 2Fh ; '/'
loc_2B07D:
lea rdi, curr_dir
mov edx, 1FFh
mov rsi, r14
jmp short loc_2B00E
| long long my_getwd(_BYTE *a1, long long a2, char a3)
{
unsigned int v3; // ebx
_BYTE *v5; // r14
long long v6; // rdx
_BYTE *v7; // rsi
long long v8; // rax
unsigned int *v9; // r14
unsigned int v10; // r15d
_WORD *v12; // rax
v3 = -1;
if ( a2 )
{
v5 = a1;
if ( curr_dir[0] )
{
v6 = a2 - 1;
v7 = curr_dir;
}
else
{
if ( a2 == 1 )
return v3;
v8 = getcwd(a1, (unsigned int)(a2 - 2));
if ( (a3 & 0x10) != 0 && !v8 )
{
v9 = (unsigned int *)__errno_location(a1);
v10 = *v9;
*(_DWORD *)my_thread_var(a1) = v10;
my_error(0x10u, 4, *v9);
return v3;
}
v12 = (_WORD *)strend(a1);
if ( *((_BYTE *)v12 - 1) != 47 )
*v12 = 47;
a1 = curr_dir;
v6 = 511LL;
v7 = v5;
}
strmake(a1, v7, v6);
return 0;
}
return v3;
}
| my_getwd:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,0xffffffff
TEST RSI,RSI
JZ 0x0012b05d
MOV R15,RDX
MOV RDX,RSI
MOV R14,RDI
LEA RAX,[0x4660e0]
CMP byte ptr [RAX],0x0
JZ 0x0012b017
DEC RDX
LEA RSI,[0x4660e0]
MOV RDI,R14
LAB_0012b00e:
CALL 0x0015a5f0
XOR EBX,EBX
JMP 0x0012b05d
LAB_0012b017:
CMP RDX,0x1
JZ 0x0012b05d
ADD EDX,-0x2
MOV RDI,R14
MOV RSI,RDX
CALL 0x00124170
TEST R15B,0x10
JZ 0x0012b06a
TEST RAX,RAX
JNZ 0x0012b06a
CALL 0x00124060
MOV R14,RAX
MOV R15D,dword ptr [RAX]
CALL 0x00126776
MOV dword ptr [RAX],R15D
MOV EDX,dword ptr [R14]
MOV ESI,0x4
MOV EDI,0x10
XOR EAX,EAX
CALL 0x0012ac53
LAB_0012b05d:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0012b06a:
MOV RDI,R14
CALL 0x0015a5a8
CMP byte ptr [RAX + -0x1],0x2f
JZ 0x0012b07d
MOV word ptr [RAX],0x2f
LAB_0012b07d:
LEA RDI,[0x4660e0]
MOV EDX,0x1ff
MOV RSI,R14
JMP 0x0012b00e
|
int8 my_getwd(char *param_1,long param_2,ulong param_3)
{
int iVar1;
char *pcVar2;
int *piVar3;
int *piVar4;
int2 *puVar5;
char *pcVar6;
if (param_2 == 0) {
return 0xffffffff;
}
if (curr_dir == '\0') {
if (param_2 == 1) {
return 0xffffffff;
}
pcVar2 = getcwd(param_1,(ulong)((int)param_2 - 2));
if (((param_3 & 0x10) != 0) && (pcVar2 == (char *)0x0)) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar1;
my_error(0x10,4,*piVar3);
return 0xffffffff;
}
puVar5 = (int2 *)strend(param_1);
if (*(char *)((long)puVar5 + -1) != '/') {
*puVar5 = 0x2f;
}
pcVar6 = &curr_dir;
param_2 = 0x1ff;
pcVar2 = param_1;
}
else {
param_2 = param_2 + -1;
pcVar2 = &curr_dir;
pcVar6 = param_1;
}
strmake(pcVar6,pcVar2,param_2);
return 0;
}
| |
54,133 | my_strdup | eloqsql/mysys/my_malloc.c | char *my_strdup(PSI_memory_key key, const char *from, myf my_flags)
{
char *ptr;
size_t length= strlen(from)+1;
DBUG_ENTER("my_strdup");
if ((ptr= (char*) my_malloc(key, length, my_flags)))
memcpy(ptr, from, length);
DBUG_RETURN(ptr);
} | O0 | c | my_strdup:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x24120
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %edi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x354b0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x3597f
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x24230
jmp 0x35981
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_strdup:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rdi, [rbp+var_10]
call _strlen
add rax, 1
mov [rbp+var_28], rax
mov edi, [rbp+var_4]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_18]
call my_malloc
mov [rbp+var_20], rax
cmp rax, 0
jz short loc_3597F
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_28]
call _memcpy
loc_3597F:
jmp short $+2
loc_35981:
mov rax, [rbp+var_20]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
add rsp, 30h
pop rbp
retn
| long long my_strdup(unsigned int a1, long long a2, int a3)
{
unsigned long long v4; // [rsp+8h] [rbp-28h]
long long v5; // [rsp+10h] [rbp-20h]
v4 = strlen(a2) + 1;
v5 = my_malloc(a1, v4, a3);
if ( v5 )
memcpy(v5, a2, v4);
return v5;
}
| my_strdup:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00124120
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x001354b0
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JZ 0x0013597f
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x00124230
LAB_0013597f:
JMP 0x00135981
LAB_00135981:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x30
POP RBP
RET
|
void * my_strdup(int4 param_1,char *param_2,int8 param_3)
{
size_t sVar1;
void *__dest;
sVar1 = strlen(param_2);
__dest = (void *)my_malloc(param_1,sVar1 + 1,param_3);
if (__dest != (void *)0x0) {
memcpy(__dest,param_2,sVar1 + 1);
}
return __dest;
}
| |
54,134 | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::lexer(nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&&, bool) | llama.cpp/common/./json.hpp | explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
: ia(std::move(adapter))
, ignore_comments(ignore_comments_)
, decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
{} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::lexer(nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&&, bool):
pushq %rbx
movq %rdi, %rbx
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movb %dl, 0x10(%rdi)
movl $0xffffffff, 0x14(%rdi) # imm = 0xFFFFFFFF
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x60(%rdi), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movq %rcx, 0x50(%rdi)
movq %rax, 0x58(%rdi)
movb %al, 0x60(%rdi)
leaq 0x921c1(%rip), %rcx # 0xc8119
movq %rcx, 0x70(%rdi)
movups %xmm0, 0x78(%rdi)
movq %rax, 0x88(%rdi)
callq 0x1c0c0
movq (%rax), %rax
testq %rax, %rax
je 0x35f79
movsbl (%rax), %eax
jmp 0x35f7e
movl $0x2e, %eax
movl %eax, 0x90(%rbx)
popq %rbx
retq
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIPKcEEEC2EOSJ_b:
push rbx
mov rbx, rdi
movups xmm0, xmmword ptr [rsi]
movups xmmword ptr [rdi], xmm0
mov [rdi+10h], dl
mov dword ptr [rdi+14h], 0FFFFFFFFh
xor eax, eax
mov [rdi+18h], al
lea rcx, [rdi+60h]
xorps xmm0, xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+30h], xmm0
movups xmmword ptr [rdi+40h], xmm0
mov [rdi+50h], rcx
mov [rdi+58h], rax
mov [rdi+60h], al
lea rcx, aFailedToMatchD+28h; ""
mov [rdi+70h], rcx
movups xmmword ptr [rdi+78h], xmm0
mov [rdi+88h], rax
call _localeconv
mov rax, [rax]
test rax, rax
jz short loc_35F79
movsx eax, byte ptr [rax]
jmp short loc_35F7E
loc_35F79:
mov eax, 2Eh ; '.'
loc_35F7E:
mov [rbx+90h], eax
pop rbx
retn
| long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<char const*>>::lexer(
long long a1,
_OWORD *a2,
char a3)
{
char *v3; // rax
long long result; // rax
*(_OWORD *)a1 = *a2;
*(_BYTE *)(a1 + 16) = a3;
*(_DWORD *)(a1 + 20) = -1;
*(_BYTE *)(a1 + 24) = 0;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
*(_QWORD *)(a1 + 80) = a1 + 96;
*(_QWORD *)(a1 + 88) = 0LL;
*(_BYTE *)(a1 + 96) = 0;
*(_QWORD *)(a1 + 112) = "";
*(_OWORD *)(a1 + 120) = 0LL;
*(_QWORD *)(a1 + 136) = 0LL;
v3 = *(char **)localeconv(a1);
if ( v3 )
result = (unsigned int)*v3;
else
result = 46LL;
*(_DWORD *)(a1 + 144) = result;
return result;
}
| lexer:
PUSH RBX
MOV RBX,RDI
MOVUPS XMM0,xmmword ptr [RSI]
MOVUPS xmmword ptr [RDI],XMM0
MOV byte ptr [RDI + 0x10],DL
MOV dword ptr [RDI + 0x14],0xffffffff
XOR EAX,EAX
MOV byte ptr [RDI + 0x18],AL
LEA RCX,[RDI + 0x60]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOV qword ptr [RDI + 0x50],RCX
MOV qword ptr [RDI + 0x58],RAX
MOV byte ptr [RDI + 0x60],AL
LEA RCX,[0x1c8119]
MOV qword ptr [RDI + 0x70],RCX
MOVUPS xmmword ptr [RDI + 0x78],XMM0
MOV qword ptr [RDI + 0x88],RAX
CALL 0x0011c0c0
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x00135f79
MOVSX EAX,byte ptr [RAX]
JMP 0x00135f7e
LAB_00135f79:
MOV EAX,0x2e
LAB_00135f7e:
MOV dword ptr [RBX + 0x90],EAX
POP RBX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<char const*>
>::lexer(nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<char const*>&&, bool) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<char_const*>>
::lexer(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<char_const*>>
*this,iterator_input_adapter *param_1,bool param_2)
{
int8 uVar1;
int iVar2;
lconv *plVar3;
uVar1 = *(int8 *)(param_1 + 8);
*(int8 *)this = *(int8 *)param_1;
*(int8 *)(this + 8) = uVar1;
this[0x10] = (lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<char_const*>>
)param_2;
*(int4 *)(this + 0x14) = 0xffffffff;
this[0x18] = (lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<char_const*>>
)0x0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<char_const*>>
**)(this + 0x50) = this + 0x60;
*(int8 *)(this + 0x58) = 0;
this[0x60] = (lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<char_const*>>
)0x0;
*(char **)(this + 0x70) = "";
*(int8 *)(this + 0x78) = 0;
*(int8 *)(this + 0x80) = 0;
*(int8 *)(this + 0x88) = 0;
plVar3 = localeconv();
if (plVar3->decimal_point == (char *)0x0) {
iVar2 = 0x2e;
}
else {
iVar2 = (int)*plVar3->decimal_point;
}
*(int *)(this + 0x90) = iVar2;
return;
}
| |
54,135 | blst_p2_on_curve | corpus-core[P]colibri-stateless/build_O3/_deps/blst-src/src/e2.c | int blst_p2_on_curve(const POINTonE2 *p)
{ return (int)POINTonE2_on_curve(p); } | O3 | c | blst_p2_on_curve:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdi, %r14
leaq 0xc0(%rdi), %r13
movl $0x60, %esi
movq %r13, %rdi
callq 0x6e900
movq %rax, -0x30(%rbp)
leaq 0x304dd(%rip), %r15 # 0x8a910
leaq -0xf0(%rbp), %rbx
movabsq $-0x760c000300030003, %r12 # imm = 0x89F3FFFCFFFCFFFD
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x71ca0
movq %rbx, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x71b60
leaq -0x90(%rbp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x71ca0
leaq -0x60(%rbp), %rdx
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rcx
callq 0x6dd60
leaq -0xc0(%rbp), %r12
movq %r12, %rdi
movq %r13, %rsi
leaq -0x60(%rbp), %rdx
movq %r15, %rcx
callq 0x6d600
movl $0x2, %edx
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x6d900
movl $0x2, %edx
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rcx
callq 0x6d900
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
movabsq $-0x760c000300030003, %r12 # imm = 0x89F3FFFCFFFCFFFD
movq %r12, %rcx
callq 0x71ca0
movq %r13, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x71b60
movq %r13, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x6d6e0
addq $0x60, %r14
leaq -0x150(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x71ca0
movl $0x60, %edx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x6e940
orl -0x30(%rbp), %eax
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| blst_p2_on_curve:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 128h
mov r14, rdi
lea r13, [rdi+0C0h]
mov esi, 60h ; '`'
mov rdi, r13
call vec_is_zero_16x
mov [rbp+var_30], rax
lea r15, BLS12_381_P
lea rbx, [rbp+var_F0]
mov r12, 89F3FFFCFFFCFFFDh
mov rdi, rbx
mov rsi, r13
mov rdx, r15
mov rcx, r12
call sqr_mont_384x
mov rdi, rbx
mov rsi, rbx
mov rdx, r13
mov rcx, r15
mov r8, r12
call mul_mont_384x
lea r13, [rbp+var_90]
mov rdi, r13
mov rsi, rbx
mov rdx, r15
mov rcx, r12
call sqr_mont_384x
lea rdx, [rbp+var_60]
mov rdi, rbx
mov rsi, r13
mov rcx, r15
call _sub_mod_384
lea r12, [rbp+var_C0]
mov rdi, r12
mov rsi, r13
lea rdx, [rbp+var_60]
mov rcx, r15
call add_mod_384
mov edx, 2
mov rdi, rbx
mov rsi, rbx
mov rcx, r15
call lshift_mod_384
mov edx, 2
mov rdi, r12
mov rsi, r12
mov rcx, r15
call lshift_mod_384
mov rdi, r13
mov rsi, r14
mov rdx, r15
mov r12, 89F3FFFCFFFCFFFDh
mov rcx, r12
call sqr_mont_384x
mov rdi, r13
mov rsi, r13
mov rdx, r14
mov rcx, r15
mov r8, r12
call mul_mont_384x
mov rdi, r13
mov rsi, r13
mov rdx, rbx
mov rcx, r15
call add_mod_384x
add r14, 60h ; '`'
lea rbx, [rbp+var_150]
mov rdi, rbx
mov rsi, r14
mov rdx, r15
mov rcx, r12
call sqr_mont_384x
mov edx, 60h ; '`'
mov rdi, r13
mov rsi, rbx
call vec_is_equal_16x
or eax, dword ptr [rbp+var_30]
add rsp, 128h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long blst_p2_on_curve(long long a1)
{
int is_equal_16x; // eax
_BYTE v3[96]; // [rsp+0h] [rbp-150h] BYREF
_BYTE v4[48]; // [rsp+60h] [rbp-F0h] BYREF
_BYTE v5[48]; // [rsp+90h] [rbp-C0h] BYREF
_BYTE v6[48]; // [rsp+C0h] [rbp-90h] BYREF
_BYTE v7[48]; // [rsp+F0h] [rbp-60h] BYREF
long long is_zero_16x; // [rsp+120h] [rbp-30h]
is_zero_16x = vec_is_zero_16x(a1 + 192, 96LL);
sqr_mont_384x(v4, a1 + 192, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
mul_mont_384x(v4, v4, a1 + 192, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
sqr_mont_384x(v6, v4, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
sub_mod_384(v4, v6, v7, &BLS12_381_P);
add_mod_384(v5, v6, v7, &BLS12_381_P);
lshift_mod_384(v4, v4, 2LL, &BLS12_381_P);
lshift_mod_384(v5, v5, 2LL, &BLS12_381_P);
sqr_mont_384x(v6, a1, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
mul_mont_384x(v6, v6, a1, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
add_mod_384x(v6, v6, v4, &BLS12_381_P);
sqr_mont_384x(v3, a1 + 96, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
is_equal_16x = vec_is_equal_16x(v6, v3, 96LL);
return (unsigned int)is_zero_16x | is_equal_16x;
}
| blst_p2_on_curve:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x128
MOV R14,RDI
LEA R13,[RDI + 0xc0]
MOV ESI,0x60
MOV RDI,R13
CALL 0x0016e900
MOV qword ptr [RBP + -0x30],RAX
LEA R15,[0x18a910]
LEA RBX,[RBP + -0xf0]
MOV R12,-0x760c000300030003
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R15
MOV RCX,R12
CALL 0x00171ca0
MOV RDI,RBX
MOV RSI,RBX
MOV RDX,R13
MOV RCX,R15
MOV R8,R12
CALL 0x00171b60
LEA R13,[RBP + -0x90]
MOV RDI,R13
MOV RSI,RBX
MOV RDX,R15
MOV RCX,R12
CALL 0x00171ca0
LEA RDX,[RBP + -0x60]
MOV RDI,RBX
MOV RSI,R13
MOV RCX,R15
CALL 0x0016dd60
LEA R12,[RBP + -0xc0]
MOV RDI,R12
MOV RSI,R13
LEA RDX,[RBP + -0x60]
MOV RCX,R15
CALL 0x0016d600
MOV EDX,0x2
MOV RDI,RBX
MOV RSI,RBX
MOV RCX,R15
CALL 0x0016d900
MOV EDX,0x2
MOV RDI,R12
MOV RSI,R12
MOV RCX,R15
CALL 0x0016d900
MOV RDI,R13
MOV RSI,R14
MOV RDX,R15
MOV R12,-0x760c000300030003
MOV RCX,R12
CALL 0x00171ca0
MOV RDI,R13
MOV RSI,R13
MOV RDX,R14
MOV RCX,R15
MOV R8,R12
CALL 0x00171b60
MOV RDI,R13
MOV RSI,R13
MOV RDX,RBX
MOV RCX,R15
CALL 0x0016d6e0
ADD R14,0x60
LEA RBX,[RBP + -0x150]
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
MOV RCX,R12
CALL 0x00171ca0
MOV EDX,0x60
MOV RDI,R13
MOV RSI,RBX
CALL 0x0016e940
OR EAX,dword ptr [RBP + -0x30]
ADD RSP,0x128
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
uint blst_p2_on_curve(long param_1)
{
long lVar1;
uint uVar2;
int1 local_158 [96];
int1 local_f8 [48];
int1 local_c8 [48];
int1 local_98 [48];
int1 local_68 [48];
int8 local_38;
lVar1 = param_1 + 0xc0;
local_38 = vec_is_zero_16x(lVar1,0x60);
sqr_mont_384x(local_f8,lVar1,BLS12_381_P,0x89f3fffcfffcfffd);
mul_mont_384x(local_f8,local_f8,lVar1,BLS12_381_P,0x89f3fffcfffcfffd);
sqr_mont_384x(local_98,local_f8,BLS12_381_P,0x89f3fffcfffcfffd);
sub_mod_384(local_f8,local_98,local_68,BLS12_381_P);
add_mod_384(local_c8,local_98,local_68,BLS12_381_P);
lshift_mod_384(local_f8,local_f8,2,BLS12_381_P);
lshift_mod_384(local_c8,local_c8,2,BLS12_381_P);
sqr_mont_384x(local_98,param_1,BLS12_381_P,0x89f3fffcfffcfffd);
mul_mont_384x(local_98,local_98,param_1,BLS12_381_P,0x89f3fffcfffcfffd);
add_mod_384x(local_98,local_98,local_f8,BLS12_381_P);
sqr_mont_384x(local_158,param_1 + 0x60,BLS12_381_P,0x89f3fffcfffcfffd);
uVar2 = vec_is_equal_16x(local_98,local_158,0x60);
return uVar2 | (uint)local_38;
}
| |
54,136 | my_hash_free | eloqsql/mysys/hash.c | void my_hash_free(HASH *hash)
{
DBUG_ENTER("my_hash_free");
DBUG_PRINT("enter",("hash:%p elements: %ld",
hash, hash->records));
my_hash_free_elements(hash);
hash->free= 0;
delete_dynamic(&hash->array);
hash->blength= 0;
DBUG_VOID_RETURN;
} | O3 | c | my_hash_free:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x18(%rdi), %r14d
testq %r14, %r14
je 0x4efa5
movq $0x0, 0x18(%rbx)
cmpq $0x0, 0x60(%rbx)
je 0x4efa5
movq 0x28(%rbx), %r15
shlq $0x4, %r14
addq %r15, %r14
movq 0x8(%r15), %rdi
addq $0x10, %r15
callq *0x60(%rbx)
cmpq %r14, %r15
jb 0x4ef95
xorl %r14d, %r14d
movq %r14, 0x60(%rbx)
leaq 0x28(%rbx), %rdi
callq 0x4d194
movq %r14, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| my_hash_free:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
mov r14d, [rdi+18h]
test r14, r14
jz short loc_4EFA5
mov qword ptr [rbx+18h], 0
cmp qword ptr [rbx+60h], 0
jz short loc_4EFA5
mov r15, [rbx+28h]
shl r14, 4
add r14, r15
loc_4EF95:
mov rdi, [r15+8]
add r15, 10h
call qword ptr [rbx+60h]
cmp r15, r14
jb short loc_4EF95
loc_4EFA5:
xor r14d, r14d
mov [rbx+60h], r14
lea rdi, [rbx+28h]
call delete_dynamic
mov [rbx+10h], r14
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long my_hash_free(long long a1)
{
long long v2; // r14
unsigned long long v3; // r15
unsigned long long v4; // r14
long long v5; // rdi
long long result; // rax
v2 = *(unsigned int *)(a1 + 24);
if ( *(_DWORD *)(a1 + 24) )
{
*(_QWORD *)(a1 + 24) = 0LL;
if ( *(_QWORD *)(a1 + 96) )
{
v3 = *(_QWORD *)(a1 + 40);
v4 = v3 + 16 * v2;
do
{
v5 = *(_QWORD *)(v3 + 8);
v3 += 16LL;
(*(void ( **)(long long))(a1 + 96))(v5);
}
while ( v3 < v4 );
}
}
*(_QWORD *)(a1 + 96) = 0LL;
result = delete_dynamic((long long *)(a1 + 40));
*(_QWORD *)(a1 + 16) = 0LL;
return result;
}
| my_hash_free:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R14D,dword ptr [RDI + 0x18]
TEST R14,R14
JZ 0x0014efa5
MOV qword ptr [RBX + 0x18],0x0
CMP qword ptr [RBX + 0x60],0x0
JZ 0x0014efa5
MOV R15,qword ptr [RBX + 0x28]
SHL R14,0x4
ADD R14,R15
LAB_0014ef95:
MOV RDI,qword ptr [R15 + 0x8]
ADD R15,0x10
CALL qword ptr [RBX + 0x60]
CMP R15,R14
JC 0x0014ef95
LAB_0014efa5:
XOR R14D,R14D
MOV qword ptr [RBX + 0x60],R14
LEA RDI,[RBX + 0x28]
CALL 0x0014d194
MOV qword ptr [RBX + 0x10],R14
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void my_hash_free(long param_1)
{
int8 *puVar1;
uint uVar2;
ulong uVar3;
ulong uVar4;
uVar2 = *(uint *)(param_1 + 0x18);
if (((ulong)uVar2 != 0) && (*(int8 *)(param_1 + 0x18) = 0, *(long *)(param_1 + 0x60) != 0))
{
uVar4 = *(ulong *)(param_1 + 0x28);
uVar3 = (ulong)uVar2 * 0x10 + uVar4;
do {
puVar1 = (int8 *)(uVar4 + 8);
uVar4 = uVar4 + 0x10;
(**(code **)(param_1 + 0x60))(*puVar1);
} while (uVar4 < uVar3);
}
*(int8 *)(param_1 + 0x60) = 0;
delete_dynamic(param_1 + 0x28);
*(int8 *)(param_1 + 0x10) = 0;
return;
}
| |
54,137 | psi_rwlock_wrlock | eloqsql/mysys/my_thr_init.c | ATTRIBUTE_COLD
int psi_rwlock_wrlock(mysql_rwlock_t *that, const char *file, uint line)
{
PSI_rwlock_locker_state state;
PSI_rwlock_locker *locker= PSI_RWLOCK_CALL(start_rwlock_wrwait)
(&state, that->m_psi, PSI_RWLOCK_WRITELOCK, file, line);
int result= rw_wrlock(&that->m_rwlock);
if (locker)
PSI_RWLOCK_CALL(end_rwlock_wrwait)(locker, result);
return result;
} | O0 | c | psi_rwlock_wrlock:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x1b162e(%rip), %rax # 0x1e4ca8
movq (%rax), %rax
movq 0x1b0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x90(%rcx), %rsi
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
leaq -0x48(%rbp), %rdi
movl $0x1, %edx
callq *%rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x33e10
movl %eax, -0x54(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x336d3
leaq 0x1b15e8(%rip), %rax # 0x1e4ca8
movq (%rax), %rax
movq 0x1b8(%rax), %rax
movq -0x50(%rbp), %rdi
movl -0x54(%rbp), %esi
callq *%rax
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| psi_rwlock_wrlock:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1B0h]
mov rcx, [rbp+var_8]
mov rsi, [rcx+90h]
mov rcx, [rbp+var_10]
mov r8d, [rbp+var_14]
lea rdi, [rbp+var_48]
mov edx, 1
call rax
mov [rbp+var_50], rax
mov rdi, [rbp+var_8]
call my_rw_wrlock
mov [rbp+var_54], eax
cmp [rbp+var_50], 0
jz short loc_336D3
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1B8h]
mov rdi, [rbp+var_50]
mov esi, [rbp+var_54]
call rax
loc_336D3:
mov eax, [rbp+var_54]
add rsp, 60h
pop rbp
retn
| long long psi_rwlock_wrlock(long long a1, long long a2, unsigned int a3)
{
unsigned int v4; // [rsp+Ch] [rbp-54h]
long long v5; // [rsp+10h] [rbp-50h]
_BYTE v6[52]; // [rsp+18h] [rbp-48h] BYREF
unsigned int v7; // [rsp+4Ch] [rbp-14h]
long long v8; // [rsp+50h] [rbp-10h]
long long v9; // [rsp+58h] [rbp-8h]
v9 = a1;
v8 = a2;
v7 = a3;
v5 = (*((long long ( **)(_BYTE *, _QWORD, long long, long long, _QWORD))PSI_server[0] + 54))(
v6,
*(_QWORD *)(a1 + 144),
1LL,
a2,
a3);
v4 = my_rw_wrlock(v9);
if ( v5 )
(*((void ( **)(long long, _QWORD))PSI_server[0] + 55))(v5, v4);
return v4;
}
| psi_rwlock_wrlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
LEA RAX,[0x2e4ca8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1b0]
MOV RCX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RCX + 0x90]
MOV RCX,qword ptr [RBP + -0x10]
MOV R8D,dword ptr [RBP + -0x14]
LEA RDI,[RBP + -0x48]
MOV EDX,0x1
CALL RAX
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00133e10
MOV dword ptr [RBP + -0x54],EAX
CMP qword ptr [RBP + -0x50],0x0
JZ 0x001336d3
LEA RAX,[0x2e4ca8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1b8]
MOV RDI,qword ptr [RBP + -0x50]
MOV ESI,dword ptr [RBP + -0x54]
CALL RAX
LAB_001336d3:
MOV EAX,dword ptr [RBP + -0x54]
ADD RSP,0x60
POP RBP
RET
|
int4 psi_rwlock_wrlock(long param_1,int8 param_2,int4 param_3)
{
int4 uVar1;
long lVar2;
int1 local_50 [52];
int4 local_1c;
int8 local_18;
long local_10;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
lVar2 = (**(code **)(PSI_server + 0x1b0))
(local_50,*(int8 *)(param_1 + 0x90),1,param_2,param_3);
uVar1 = my_rw_wrlock(local_10);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x1b8))(lVar2,uVar1);
}
return uVar1;
}
| |
54,138 | save_index(Sort_param*, unsigned int, SORT_INFO*) | eloqsql/sql/filesort.cc | static bool save_index(Sort_param *param, uint count,
SORT_INFO *table_sort)
{
uint offset,res_length, length;
uchar *to;
DBUG_ENTER("save_index");
DBUG_ASSERT(table_sort->record_pointers == 0);
table_sort->sort_buffer(param, count);
if (param->using_addon_fields())
{
table_sort->sorted_result_in_fsbuf= TRUE;
table_sort->set_sort_length(param->sort_length);
DBUG_RETURN(0);
}
bool using_packed_sortkeys= param->using_packed_sortkeys();
res_length= param->res_length;
offset= param->rec_length-res_length;
if (!(to= table_sort->record_pointers=
(uchar*) my_malloc(key_memory_Filesort_info_record_pointers,
res_length*count, MYF(MY_WME | MY_THREAD_SPECIFIC))))
DBUG_RETURN(1); /* purecov: inspected */
for (uint ix= 0; ix < count; ++ix)
{
uchar *record= table_sort->get_sorted_record(ix);
length= using_packed_sortkeys ?
Sort_keys::read_sortkey_length(record) : offset;
memcpy(to, record + length, res_length);
to+= res_length;
}
DBUG_RETURN(0);
} | O0 | cpp | save_index(Sort_param*, unsigned int, SORT_INFO*):
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
jmp 0x8d3195
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x8d85b0
movq -0x10(%rbp), %rdi
callq 0x8d7430
testb $0x1, %al
jne 0x8d31b4
jmp 0x8d31d8
movq -0x20(%rbp), %rax
movb $0x1, 0x170(%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x8d8850
movb $0x0, -0x1(%rbp)
jmp 0x8d32af
movq -0x10(%rbp), %rdi
callq 0x8d77e0
andb $0x1, %al
movb %al, -0x39(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
subl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
leaq 0xcf03a5(%rip), %rax # 0x15c35a8
movl (%rax), %edi
movl -0x28(%rbp), %eax
imull -0x14(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
movl $0x10010, %edx # imm = 0x10010
callq 0xc1ab00
movq -0x20(%rbp), %rcx
movq %rax, 0x160(%rcx)
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x8d3237
jmp 0x8d3231
movb $0x1, -0x1(%rbp)
jmp 0x8d32af
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x8d32a9
movq -0x20(%rbp), %rdi
movl -0x40(%rbp), %esi
callq 0x8d85e0
movq %rax, -0x48(%rbp)
testb $0x1, -0x39(%rbp)
je 0x8d326a
movq -0x48(%rbp), %rdi
callq 0x8d7c20
movl %eax, -0x4c(%rbp)
jmp 0x8d3270
movl -0x24(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl -0x2c(%rbp), %eax
addq %rax, %rsi
movl -0x28(%rbp), %eax
movl %eax, %edx
callq 0x4331a0
movl -0x28(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x8d323e
jmp 0x8d32ab
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ZL10save_indexP10Sort_paramjP9SORT_INFO:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
jmp short $+2
loc_8D3195:
mov rdi, [rbp+var_20]; this
mov rsi, [rbp+var_10]; Sort_param *
mov edx, [rbp+var_14]; unsigned int
call _ZN9SORT_INFO11sort_bufferEP10Sort_paramj; SORT_INFO::sort_buffer(Sort_param *,uint)
mov rdi, [rbp+var_10]; this
call _ZNK10Sort_param18using_addon_fieldsEv; Sort_param::using_addon_fields(void)
test al, 1
jnz short loc_8D31B4
jmp short loc_8D31D8
loc_8D31B4:
mov rax, [rbp+var_20]
mov byte ptr [rax+170h], 1
mov rdi, [rbp+var_20]; this
mov rax, [rbp+var_10]
mov esi, [rax+4]; unsigned int
call _ZN9SORT_INFO15set_sort_lengthEj; SORT_INFO::set_sort_length(uint)
mov [rbp+var_1], 0
jmp loc_8D32AF
loc_8D31D8:
mov rdi, [rbp+var_10]; this
call _ZNK10Sort_param21using_packed_sortkeysEv; Sort_param::using_packed_sortkeys(void)
and al, 1
mov byte ptr [rbp+var_40+7], al
mov rax, [rbp+var_10]
mov eax, [rax+10h]
mov [rbp+var_28], eax
mov rax, [rbp+var_10]
mov eax, [rax]
sub eax, [rbp+var_28]
mov [rbp+var_24], eax
lea rax, key_memory_Filesort_info_record_pointers
mov edi, [rax]
mov eax, [rbp+var_28]
imul eax, [rbp+var_14]
mov eax, eax
mov esi, eax
mov edx, offset stru_10010
call my_malloc
mov rcx, [rbp+var_20]
mov [rcx+160h], rax
mov [rbp+var_38], rax
cmp rax, 0
jnz short loc_8D3237
jmp short $+2
loc_8D3231:
mov [rbp+var_1], 1
jmp short loc_8D32AF
loc_8D3237:
mov dword ptr [rbp+var_40], 0
loc_8D323E:
mov eax, dword ptr [rbp+var_40]
cmp eax, [rbp+var_14]
jnb short loc_8D32A9
mov rdi, [rbp+var_20]; this
mov esi, dword ptr [rbp+var_40]; unsigned __int8 *
call _ZN9SORT_INFO17get_sorted_recordEj; SORT_INFO::get_sorted_record(uint)
mov [rbp+var_48], rax
test byte ptr [rbp+var_40+7], 1
jz short loc_8D326A
mov rdi, [rbp+var_48]; this
call _ZN9Sort_keys19read_sortkey_lengthEPh; Sort_keys::read_sortkey_length(uchar *)
mov [rbp+var_4C], eax
jmp short loc_8D3270
loc_8D326A:
mov eax, [rbp+var_24]
mov [rbp+var_4C], eax
loc_8D3270:
mov eax, [rbp+var_4C]
mov [rbp+var_2C], eax
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_48]
mov eax, [rbp+var_2C]
add rsi, rax
mov eax, [rbp+var_28]
mov edx, eax
call _memcpy
mov ecx, [rbp+var_28]
mov rax, [rbp+var_38]
mov ecx, ecx
add rax, rcx
mov [rbp+var_38], rax
mov eax, dword ptr [rbp+var_40]
add eax, 1
mov dword ptr [rbp+var_40], eax
jmp short loc_8D323E
loc_8D32A9:
jmp short $+2
loc_8D32AB:
mov [rbp+var_1], 0
loc_8D32AF:
mov al, [rbp+var_1]
and al, 1
add rsp, 50h
pop rbp
retn
| char save_index(Sort_param *a1, unsigned int a2, SORT_INFO *a3)
{
long long v3; // rax
unsigned int sortkey_length; // [rsp+4h] [rbp-4Ch]
Sort_keys *sorted_record; // [rsp+8h] [rbp-48h]
unsigned int i; // [rsp+10h] [rbp-40h]
char v8; // [rsp+17h] [rbp-39h]
long long v9; // [rsp+18h] [rbp-38h]
unsigned int v10; // [rsp+28h] [rbp-28h]
unsigned int v11; // [rsp+2Ch] [rbp-24h]
SORT_INFO::sort_buffer(a3, a1, a2);
if ( (Sort_param::using_addon_fields(a1) & 1) != 0 )
{
*((_BYTE *)a3 + 368) = 1;
SORT_INFO::set_sort_length(a3, *((_DWORD *)a1 + 1));
return 0;
}
else
{
v8 = Sort_param::using_packed_sortkeys(a1) & 1;
v10 = *((_DWORD *)a1 + 4);
v11 = *(_DWORD *)a1 - v10;
v3 = my_malloc(key_memory_Filesort_info_record_pointers, a2 * v10, &stru_10010);
*((_QWORD *)a3 + 44) = v3;
v9 = v3;
if ( v3 )
{
for ( i = 0; i < a2; ++i )
{
sorted_record = (Sort_keys *)SORT_INFO::get_sorted_record(a3, i);
if ( (v8 & 1) != 0 )
sortkey_length = Sort_keys::read_sortkey_length(sorted_record, (unsigned __int8 *)i);
else
sortkey_length = v11;
memcpy(v9, (char *)sorted_record + sortkey_length, v10);
v9 += v10;
}
return 0;
}
else
{
return 1;
}
}
}
| Named_type_handler:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x40],RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
CALL 0x008d3fe0
MOV RAX,qword ptr [RBP + -0x40]
LEA RCX,[0x13cff28]
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RDI
CALL 0x00533950
MOV RSI,qword ptr [RBP + -0x38]
MOV EDX,EAX
LAB_008d31cc:
LEA RDI,[RBP + -0x20]
CALL 0x008c6710
LAB_008d31d5:
JMP 0x008d31d7
LAB_008d31d7:
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x008cb100
ADD RSP,0x40
POP RBP
RET
|
/* Named_type_handler<Type_handler_medium_blob_json>::Named_type_handler(char const*) */
void __thiscall
Named_type_handler<Type_handler_medium_blob_json>::Named_type_handler
(Named_type_handler<Type_handler_medium_blob_json> *this,char *param_1)
{
char *pcVar1;
size_t sVar2;
int8 local_28;
int8 local_20;
char *local_18;
Named_type_handler<Type_handler_medium_blob_json> *local_10;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
local_18 = param_1;
local_10 = this;
Type_handler_medium_blob_json::Type_handler_medium_blob_json
((Type_handler_medium_blob_json *)this);
pcVar1 = local_18;
*(int ***)this = &PTR_type_collection_013cff28;
sVar2 = strlen(local_18);
/* try { // try from 008d31cc to 008d31d4 has its CatchHandler @ 008d31ee */
Name::Name((Name *)&local_28,pcVar1,(uint)sVar2);
Type_handler::set_name(this,local_28,local_20);
return;
}
| |
54,139 | mi_cmp_buffer | eloqsql/storage/myisam/mi_dynrec.c | static int _mi_cmp_buffer(File file, const uchar *buff, my_off_t filepos,
uint length)
{
uint next_length;
uchar temp_buff[IO_SIZE*2];
DBUG_ENTER("_mi_cmp_buffer");
next_length= IO_SIZE*2 - (uint) (filepos & (IO_SIZE-1));
while (length > IO_SIZE*2)
{
if (mysql_file_pread(file, temp_buff, next_length, filepos, MYF(MY_NABP)) ||
memcmp(buff, temp_buff, next_length))
goto err;
filepos+=next_length;
buff+=next_length;
length-= next_length;
next_length=IO_SIZE*2;
}
if (mysql_file_pread(file, temp_buff, length, filepos, MYF(MY_NABP)))
goto err;
DBUG_RETURN(memcmp(buff,temp_buff,length));
err:
DBUG_RETURN(1);
} | O0 | c | mi_cmp_buffer:
pushq %rbp
movq %rsp, %rbp
subq $0x2040, %rsp # imm = 0x2040
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x2018(%rbp)
movq %rsi, -0x2020(%rbp)
movq %rdx, -0x2028(%rbp)
movl %ecx, -0x202c(%rbp)
movq -0x2028(%rbp), %rax
andq $0xfff, %rax # imm = 0xFFF
movl %eax, %ecx
movl $0x2000, %eax # imm = 0x2000
subl %ecx, %eax
movl %eax, -0x2030(%rbp)
cmpl $0x2000, -0x202c(%rbp) # imm = 0x2000
jbe 0xabe3f
movl -0x2018(%rbp), %edx
leaq -0x2010(%rbp), %rcx
movl -0x2030(%rbp), %eax
movl %eax, %r8d
movq -0x2028(%rbp), %r9
leaq 0xa7a6b(%rip), %rdi # 0x15381d
movl $0x67e, %esi # imm = 0x67E
movq $0x4, (%rsp)
callq 0xa7350
cmpq $0x0, %rax
jne 0xabdea
movq -0x2020(%rbp), %rdi
leaq -0x2010(%rbp), %rsi
movl -0x2030(%rbp), %eax
movl %eax, %edx
callq 0x2a810
cmpl $0x0, %eax
je 0xabdef
jmp 0xabea2
movl -0x2030(%rbp), %eax
addq -0x2028(%rbp), %rax
movq %rax, -0x2028(%rbp)
movl -0x2030(%rbp), %ecx
movq -0x2020(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x2020(%rbp)
movl -0x2030(%rbp), %ecx
movl -0x202c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x202c(%rbp)
movl $0x2000, -0x2030(%rbp) # imm = 0x2000
jmp 0xabd7e
movl -0x2018(%rbp), %edx
leaq -0x2010(%rbp), %rcx
movl -0x202c(%rbp), %eax
movl %eax, %r8d
movq -0x2028(%rbp), %r9
leaq 0xa79ba(%rip), %rdi # 0x15381d
movl $0x686, %esi # imm = 0x686
movq $0x4, (%rsp)
callq 0xa7350
cmpq $0x0, %rax
je 0xabe7d
jmp 0xabea2
jmp 0xabe7f
movq -0x2020(%rbp), %rdi
leaq -0x2010(%rbp), %rsi
movl -0x202c(%rbp), %eax
movl %eax, %edx
callq 0x2a810
movl %eax, -0x2014(%rbp)
jmp 0xabeae
jmp 0xabea4
movl $0x1, -0x2014(%rbp)
movl -0x2014(%rbp), %eax
movl %eax, -0x2034(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xabedb
movl -0x2034(%rbp), %eax
addq $0x2040, %rsp # imm = 0x2040
popq %rbp
retq
callq 0x2a250
| _mi_cmp_buffer:
push rbp
mov rbp, rsp
sub rsp, 2040h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_2018], edi
mov [rbp+var_2020], rsi
mov [rbp+var_2028], rdx
mov [rbp+var_202C], ecx
mov rax, [rbp+var_2028]
and rax, 0FFFh
mov ecx, eax
mov eax, 2000h
sub eax, ecx
mov [rbp+var_2030], eax
loc_ABD7E:
cmp [rbp+var_202C], 2000h
jbe loc_ABE3F
mov edx, [rbp+var_2018]
lea rcx, [rbp+var_2010]
mov eax, [rbp+var_2030]
mov r8d, eax
mov r9, [rbp+var_2028]
lea rdi, aWorkspaceLlm4b_24; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 67Eh
mov [rsp+2040h+var_2040], 4
call inline_mysql_file_pread_6
cmp rax, 0
jnz short loc_ABDEA
mov rdi, [rbp+var_2020]
lea rsi, [rbp+var_2010]
mov eax, [rbp+var_2030]
mov edx, eax
call _memcmp
cmp eax, 0
jz short loc_ABDEF
loc_ABDEA:
jmp loc_ABEA2
loc_ABDEF:
mov eax, [rbp+var_2030]
add rax, [rbp+var_2028]
mov [rbp+var_2028], rax
mov ecx, [rbp+var_2030]
mov rax, [rbp+var_2020]
mov ecx, ecx
add rax, rcx
mov [rbp+var_2020], rax
mov ecx, [rbp+var_2030]
mov eax, [rbp+var_202C]
sub eax, ecx
mov [rbp+var_202C], eax
mov [rbp+var_2030], 2000h
jmp loc_ABD7E
loc_ABE3F:
mov edx, [rbp+var_2018]
lea rcx, [rbp+var_2010]
mov eax, [rbp+var_202C]
mov r8d, eax
mov r9, [rbp+var_2028]
lea rdi, aWorkspaceLlm4b_24; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 686h
mov [rsp+2040h+var_2040], 4
call inline_mysql_file_pread_6
cmp rax, 0
jz short loc_ABE7D
jmp short loc_ABEA2
loc_ABE7D:
jmp short $+2
loc_ABE7F:
mov rdi, [rbp+var_2020]
lea rsi, [rbp+var_2010]
mov eax, [rbp+var_202C]
mov edx, eax
call _memcmp
mov [rbp+var_2014], eax
jmp short loc_ABEAE
loc_ABEA2:
jmp short $+2
loc_ABEA4:
mov [rbp+var_2014], 1
loc_ABEAE:
mov eax, [rbp+var_2014]
mov [rbp+var_2034], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_ABEDB
mov eax, [rbp+var_2034]
add rsp, 2040h
pop rbp
retn
loc_ABEDB:
call ___stack_chk_fail
| long long mi_cmp_buffer(unsigned int a1, long long a2, long long a3, unsigned int a4)
{
unsigned int v5; // [rsp+10h] [rbp-2030h]
long long v7; // [rsp+18h] [rbp-2028h]
_BYTE v10[8200]; // [rsp+30h] [rbp-2010h] BYREF
unsigned long long v11; // [rsp+2038h] [rbp-8h]
v11 = __readfsqword(0x28u);
v7 = a3;
v5 = 0x2000 - (a3 & 0xFFF);
while ( a4 > 0x2000 )
{
if ( inline_mysql_file_pread_6(
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c",
0x67Eu,
a1,
(long long)v10,
v5,
v7,
4LL)
|| (unsigned int)memcmp(a2, v10, v5) )
{
return 1;
}
v7 += v5;
a2 += v5;
a4 -= v5;
v5 = 0x2000;
}
if ( !inline_mysql_file_pread_6(
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c",
0x686u,
a1,
(long long)v10,
a4,
v7,
4LL) )
return (unsigned int)memcmp(a2, v10, a4);
return 1;
}
| _mi_cmp_buffer:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x2040
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x2018],EDI
MOV qword ptr [RBP + -0x2020],RSI
MOV qword ptr [RBP + -0x2028],RDX
MOV dword ptr [RBP + -0x202c],ECX
MOV RAX,qword ptr [RBP + -0x2028]
AND RAX,0xfff
MOV ECX,EAX
MOV EAX,0x2000
SUB EAX,ECX
MOV dword ptr [RBP + -0x2030],EAX
LAB_001abd7e:
CMP dword ptr [RBP + -0x202c],0x2000
JBE 0x001abe3f
MOV EDX,dword ptr [RBP + -0x2018]
LEA RCX,[RBP + -0x2010]
MOV EAX,dword ptr [RBP + -0x2030]
MOV R8D,EAX
MOV R9,qword ptr [RBP + -0x2028]
LEA RDI,[0x25381d]
MOV ESI,0x67e
MOV qword ptr [RSP],0x4
CALL 0x001a7350
CMP RAX,0x0
JNZ 0x001abdea
MOV RDI,qword ptr [RBP + -0x2020]
LEA RSI,[RBP + -0x2010]
MOV EAX,dword ptr [RBP + -0x2030]
MOV EDX,EAX
CALL 0x0012a810
CMP EAX,0x0
JZ 0x001abdef
LAB_001abdea:
JMP 0x001abea2
LAB_001abdef:
MOV EAX,dword ptr [RBP + -0x2030]
ADD RAX,qword ptr [RBP + -0x2028]
MOV qword ptr [RBP + -0x2028],RAX
MOV ECX,dword ptr [RBP + -0x2030]
MOV RAX,qword ptr [RBP + -0x2020]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x2020],RAX
MOV ECX,dword ptr [RBP + -0x2030]
MOV EAX,dword ptr [RBP + -0x202c]
SUB EAX,ECX
MOV dword ptr [RBP + -0x202c],EAX
MOV dword ptr [RBP + -0x2030],0x2000
JMP 0x001abd7e
LAB_001abe3f:
MOV EDX,dword ptr [RBP + -0x2018]
LEA RCX,[RBP + -0x2010]
MOV EAX,dword ptr [RBP + -0x202c]
MOV R8D,EAX
MOV R9,qword ptr [RBP + -0x2028]
LEA RDI,[0x25381d]
MOV ESI,0x686
MOV qword ptr [RSP],0x4
CALL 0x001a7350
CMP RAX,0x0
JZ 0x001abe7d
JMP 0x001abea2
LAB_001abe7d:
JMP 0x001abe7f
LAB_001abe7f:
MOV RDI,qword ptr [RBP + -0x2020]
LEA RSI,[RBP + -0x2010]
MOV EAX,dword ptr [RBP + -0x202c]
MOV EDX,EAX
CALL 0x0012a810
MOV dword ptr [RBP + -0x2014],EAX
JMP 0x001abeae
LAB_001abea2:
JMP 0x001abea4
LAB_001abea4:
MOV dword ptr [RBP + -0x2014],0x1
LAB_001abeae:
MOV EAX,dword ptr [RBP + -0x2014]
MOV dword ptr [RBP + -0x2034],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001abedb
MOV EAX,dword ptr [RBP + -0x2034]
ADD RSP,0x2040
POP RBP
RET
LAB_001abedb:
CALL 0x0012a250
|
int _mi_cmp_buffer(int4 param_1,void *param_2,long param_3,uint param_4)
{
int iVar1;
long lVar2;
long in_FS_OFFSET;
uint local_2038;
uint local_2034;
long local_2030;
void *local_2028;
int local_201c;
int1 local_2018 [8200];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_2038 = 0x2000 - ((uint)param_3 & 0xfff);
local_2034 = param_4;
local_2030 = param_3;
local_2028 = param_2;
while (0x2000 < local_2034) {
lVar2 = inline_mysql_file_pread
("/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c",0x67e,
param_1,local_2018,local_2038,local_2030,4);
if ((lVar2 != 0) || (iVar1 = memcmp(local_2028,local_2018,(ulong)local_2038), iVar1 != 0))
goto LAB_001abea2;
local_2030 = (ulong)local_2038 + local_2030;
local_2028 = (void *)((long)local_2028 + (ulong)local_2038);
local_2034 = local_2034 - local_2038;
local_2038 = 0x2000;
}
lVar2 = inline_mysql_file_pread
("/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c",0x686,
param_1,local_2018,local_2034,local_2030,4);
if (lVar2 == 0) {
local_201c = memcmp(local_2028,local_2018,(ulong)local_2034);
}
else {
LAB_001abea2:
local_201c = 1;
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_201c;
}
| |
54,140 | translog_next_LSN | eloqsql/storage/maria/ma_loghandler.c | LSN translog_next_LSN(TRANSLOG_ADDRESS addr, TRANSLOG_ADDRESS horizon)
{
TRANSLOG_SCANNER_DATA scanner;
LSN result;
DBUG_ENTER("translog_next_LSN");
if (horizon == LSN_IMPOSSIBLE)
horizon= translog_get_horizon();
if (addr == horizon)
DBUG_RETURN(LSN_IMPOSSIBLE);
translog_scanner_init(addr, 0, &scanner, 1);
/*
addr can point not to a chunk beginning but page end so next
page beginning.
*/
if (addr % TRANSLOG_PAGE_SIZE == 0)
{
/*
We are emulating the page end which cased such horizon value to
trigger translog_scanner_eop().
We can't just increase addr on page header overhead because it
can be file end so we allow translog_get_next_chunk() to skip
to the next page in correct way
*/
scanner.page_addr-= TRANSLOG_PAGE_SIZE;
scanner.page_offset= TRANSLOG_PAGE_SIZE;
#ifndef DBUG_OFF
scanner.page= NULL; /* prevent using incorrect page content */
#endif
}
/* addr can point not to a chunk beginning but to a page end */
if (translog_scanner_eop(&scanner))
{
if (translog_get_next_chunk(&scanner))
{
result= LSN_ERROR;
goto out;
}
if (scanner.page == END_OF_LOG)
{
result= LSN_IMPOSSIBLE;
goto out;
}
}
while (!translog_is_LSN_chunk(scanner.page[scanner.page_offset]) &&
scanner.page[scanner.page_offset] != TRANSLOG_FILLER)
{
if (translog_get_next_chunk(&scanner))
{
result= LSN_ERROR;
goto out;
}
if (scanner.page == END_OF_LOG)
{
result= LSN_IMPOSSIBLE;
goto out;
}
}
if (scanner.page[scanner.page_offset] == TRANSLOG_FILLER)
result= LSN_IMPOSSIBLE; /* reached page filler */
else
result= scanner.page_addr + scanner.page_offset;
out:
translog_destroy_scanner(&scanner);
DBUG_RETURN(result);
} | O3 | c | translog_next_LSN:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x2038, %rsp # imm = 0x2038
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
testq %rsi, %rsi
jne 0x4e850
callq 0x4cea8
movq %rax, %rsi
cmpq %rbx, %rsi
jne 0x4e85c
xorl %ebx, %ebx
jmp 0x4e942
leaq -0x2050(%rbp), %rdx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %ecx
callq 0x4bbaf
testl $0x1fff, %ebx # imm = 0x1FFF
je 0x4e891
movl -0x28(%rbp), %eax
cmpq $0x1fff, %rax # imm = 0x1FFF
ja 0x4e8a0
movq -0x38(%rbp), %rcx
cmpb $-0x1, (%rcx,%rax)
jne 0x4e8c9
jmp 0x4e8a0
addq $-0x2000, -0x50(%rbp) # imm = 0xE000
movl $0x2000, -0x28(%rbp) # imm = 0x2000
leaq -0x2050(%rbp), %rdi
callq 0x4bc56
movl $0x1, %ebx
testb %al, %al
jne 0x4e939
movq -0x38(%rbp), %rcx
leaq 0xbb30cc(%rip), %rax # 0xc01990
cmpq %rax, %rcx
je 0x4e930
xorl %ebx, %ebx
leaq -0x2050(%rbp), %r14
leaq 0xbb30b7(%rip), %r15 # 0xc01990
movl -0x28(%rbp), %eax
movzbl (%rcx,%rax), %ecx
movl %ecx, %edx
andl $-0x40, %edx
cmpl $0x40, %edx
je 0x4e91f
testl %edx, %edx
sete %dl
movl %ecx, %esi
notl %esi
testb $0x3f, %sil
setne %sil
testb %sil, %dl
jne 0x4e91f
cmpl $0xff, %ecx
je 0x4e939
movq %r14, %rdi
callq 0x4bc56
testb %al, %al
jne 0x4e934
movq -0x38(%rbp), %rcx
cmpq %r15, %rcx
jne 0x4e8d9
jmp 0x4e939
cmpl $0xff, %ecx
je 0x4e930
addq -0x50(%rbp), %rax
movq %rax, %rbx
jmp 0x4e939
xorl %ebx, %ebx
jmp 0x4e939
movl $0x1, %ebx
movq -0x30(%rbp), %rdi
callq 0x4cf62
movq %fs:0x28, %rax
cmpq -0x20(%rbp), %rax
jne 0x4e962
movq %rbx, %rax
addq $0x2038, %rsp # imm = 0x2038
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x29270
| translog_next_LSN:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 2038h
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_20], rax
test rsi, rsi
jnz short loc_4E850
call translog_get_horizon
mov rsi, rax
loc_4E850:
cmp rsi, rbx
jnz short loc_4E85C
xor ebx, ebx
jmp loc_4E942
loc_4E85C:
lea rdx, [rbp+var_2050]
mov rdi, rbx
xor esi, esi
mov ecx, 1
call translog_scanner_init
test ebx, 1FFFh
jz short loc_4E891
mov eax, [rbp+var_28]
cmp rax, 1FFFh
ja short loc_4E8A0
mov rcx, [rbp+var_38]
cmp byte ptr [rcx+rax], 0FFh
jnz short loc_4E8C9
jmp short loc_4E8A0
loc_4E891:
add [rbp+var_50], 0FFFFFFFFFFFFE000h
mov [rbp+var_28], 2000h
loc_4E8A0:
lea rdi, [rbp+var_2050]
call translog_get_next_chunk
mov ebx, 1
test al, al
jnz loc_4E939
mov rcx, [rbp+var_38]
lea rax, end_of_log
cmp rcx, rax
jz short loc_4E930
loc_4E8C9:
xor ebx, ebx
lea r14, [rbp+var_2050]
lea r15, end_of_log
loc_4E8D9:
mov eax, [rbp+var_28]
movzx ecx, byte ptr [rcx+rax]
mov edx, ecx
and edx, 0FFFFFFC0h
cmp edx, 40h ; '@'
jz short loc_4E91F
test edx, edx
setz dl
mov esi, ecx
not esi
test sil, 3Fh
setnz sil
test dl, sil
jnz short loc_4E91F
cmp ecx, 0FFh
jz short loc_4E939
mov rdi, r14
call translog_get_next_chunk
test al, al
jnz short loc_4E934
mov rcx, [rbp+var_38]
cmp rcx, r15
jnz short loc_4E8D9
jmp short loc_4E939
loc_4E91F:
cmp ecx, 0FFh
jz short loc_4E930
add rax, [rbp+var_50]
mov rbx, rax
jmp short loc_4E939
loc_4E930:
xor ebx, ebx
jmp short loc_4E939
loc_4E934:
mov ebx, 1
loc_4E939:
mov rdi, [rbp+var_30]
call translog_free_link
loc_4E942:
mov rax, fs:28h
cmp rax, [rbp+var_20]
jnz short loc_4E962
mov rax, rbx
add rsp, 2038h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_4E962:
call ___stack_chk_fail
| long long translog_next_LSN(long long a1, long long horizon)
{
long long v2; // rbx
_BYTE *v3; // rcx
int v4; // ecx
_BYTE v6[8192]; // [rsp+0h] [rbp-2050h] BYREF
long long v7; // [rsp+2000h] [rbp-50h]
_BYTE *v8; // [rsp+2018h] [rbp-38h]
long long v9; // [rsp+2020h] [rbp-30h]
unsigned int v10; // [rsp+2028h] [rbp-28h]
unsigned long long v11; // [rsp+2030h] [rbp-20h]
v11 = __readfsqword(0x28u);
if ( !horizon )
horizon = translog_get_horizon();
if ( horizon != a1 )
{
translog_scanner_init(a1, 0, (long long)v6, 1);
if ( (a1 & 0x1FFF) != 0 )
{
if ( v10 <= 0x1FFFuLL )
{
v3 = v8;
if ( v8[v10] != 0xFF )
{
LABEL_12:
v2 = 0LL;
while ( 1 )
{
v4 = (unsigned __int8)v3[v10];
if ( (v4 & 0xFFFFFFC0) == 0x40 || (~(_BYTE)v4 & 0x3F) != 0 && (v4 & 0xFFFFFFC0) == 0 )
break;
if ( v4 == 255 )
goto LABEL_23;
if ( translog_get_next_chunk((long long)v6) )
{
v2 = 1LL;
goto LABEL_23;
}
v3 = v8;
if ( v8 == (_BYTE *)&end_of_log )
goto LABEL_23;
}
if ( v4 == 255 )
goto LABEL_21;
v2 = v7 + v10;
goto LABEL_23;
}
}
}
else
{
v7 -= 0x2000LL;
v10 = 0x2000;
}
v2 = 1LL;
if ( !translog_get_next_chunk((long long)v6) )
{
v3 = v8;
if ( v8 != (_BYTE *)&end_of_log )
goto LABEL_12;
LABEL_21:
v2 = 0LL;
}
LABEL_23:
translog_free_link(v9);
return v2;
}
return 0LL;
}
| translog_next_LSN:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x2038
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
TEST RSI,RSI
JNZ 0x0014e850
CALL 0x0014cea8
MOV RSI,RAX
LAB_0014e850:
CMP RSI,RBX
JNZ 0x0014e85c
XOR EBX,EBX
JMP 0x0014e942
LAB_0014e85c:
LEA RDX,[RBP + -0x2050]
MOV RDI,RBX
XOR ESI,ESI
MOV ECX,0x1
CALL 0x0014bbaf
TEST EBX,0x1fff
JZ 0x0014e891
MOV EAX,dword ptr [RBP + -0x28]
CMP RAX,0x1fff
JA 0x0014e8a0
MOV RCX,qword ptr [RBP + -0x38]
CMP byte ptr [RCX + RAX*0x1],0xff
JNZ 0x0014e8c9
JMP 0x0014e8a0
LAB_0014e891:
ADD qword ptr [RBP + -0x50],-0x2000
MOV dword ptr [RBP + -0x28],0x2000
LAB_0014e8a0:
LEA RDI,[RBP + -0x2050]
CALL 0x0014bc56
MOV EBX,0x1
TEST AL,AL
JNZ 0x0014e939
MOV RCX,qword ptr [RBP + -0x38]
LEA RAX,[0xd01990]
CMP RCX,RAX
JZ 0x0014e930
LAB_0014e8c9:
XOR EBX,EBX
LEA R14,[RBP + -0x2050]
LEA R15,[0xd01990]
LAB_0014e8d9:
MOV EAX,dword ptr [RBP + -0x28]
MOVZX ECX,byte ptr [RCX + RAX*0x1]
MOV EDX,ECX
AND EDX,0xffffffc0
CMP EDX,0x40
JZ 0x0014e91f
TEST EDX,EDX
SETZ DL
MOV ESI,ECX
NOT ESI
TEST SIL,0x3f
SETNZ SIL
TEST DL,SIL
JNZ 0x0014e91f
CMP ECX,0xff
JZ 0x0014e939
MOV RDI,R14
CALL 0x0014bc56
TEST AL,AL
JNZ 0x0014e934
MOV RCX,qword ptr [RBP + -0x38]
CMP RCX,R15
JNZ 0x0014e8d9
JMP 0x0014e939
LAB_0014e91f:
CMP ECX,0xff
JZ 0x0014e930
ADD RAX,qword ptr [RBP + -0x50]
MOV RBX,RAX
JMP 0x0014e939
LAB_0014e930:
XOR EBX,EBX
JMP 0x0014e939
LAB_0014e934:
MOV EBX,0x1
LAB_0014e939:
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x0014cf62
LAB_0014e942:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x0014e962
MOV RAX,RBX
ADD RSP,0x2038
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0014e962:
CALL 0x00129270
|
long translog_next_LSN(ulong param_1,ulong param_2)
{
byte bVar1;
char cVar2;
long lVar3;
long in_FS_OFFSET;
int1 local_2058 [8192];
long local_58;
int1 *local_40;
int8 local_38;
uint local_30;
long local_28;
local_28 = *(long *)(in_FS_OFFSET + 0x28);
if (param_2 == 0) {
param_2 = translog_get_horizon();
}
if (param_2 == param_1) {
lVar3 = 0;
goto LAB_0014e942;
}
translog_scanner_init(param_1,0,local_2058,1);
if ((param_1 & 0x1fff) == 0) {
local_58 = local_58 + -0x2000;
local_30 = 0x2000;
LAB_0014e8a0:
cVar2 = translog_get_next_chunk(local_2058);
lVar3 = 1;
if (cVar2 == '\0') {
if (local_40 != &end_of_log) goto LAB_0014e8c9;
LAB_0014e930:
lVar3 = 0;
}
}
else {
if ((0x1fff < (ulong)local_30) || (local_40[local_30] == -1)) goto LAB_0014e8a0;
LAB_0014e8c9:
lVar3 = 0;
do {
bVar1 = local_40[local_30];
if (((bVar1 & 0xc0) == 0x40) || ((bVar1 & 0xc0) == 0 && (~bVar1 & 0x3f) != 0)) {
if (bVar1 == 0xff) goto LAB_0014e930;
lVar3 = (ulong)local_30 + local_58;
break;
}
if (bVar1 == 0xff) break;
cVar2 = translog_get_next_chunk(local_2058);
if (cVar2 != '\0') {
lVar3 = 1;
break;
}
} while (local_40 != &end_of_log);
}
translog_free_link(local_38);
LAB_0014e942:
if (*(long *)(in_FS_OFFSET + 0x28) != local_28) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return lVar3;
}
| |
54,141 | my_mb_wc_eucjpms | eloqsql/strings/ctype-eucjpms.c | static int
my_mb_wc_eucjpms(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e)
{
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
if ((hi= s[0]) < 0x80) /* ASCII code set: [00..7F] -> [U+0000..U+007F] */
{
*pwc= hi;
return 1;
}
if (hi >= 0xA1 && hi <= 0xFE) /* JIS X 0208 code set: [A1..FE][A1..FE] */
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
return (*pwc= jisx0208_eucjpms_to_unicode[(hi << 8) + s[1]]) ? 2 :
(s[1] < 0xA1 || s[1] > 0xFE) ? MY_CS_ILSEQ : -2;
}
/* JIS-X-0201 HALF WIDTH KATAKANA: [8E][A1..DF] -> [U+FF61..U+FF9F] */
if (hi == 0x8E)
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
if (s[1] < 0xA1 || s[1] > 0xDF)
return MY_CS_ILSEQ;
*pwc= 0xFEC0 + s[1]; /* 0xFFC0 = 0xFF61 - 0xA1 */
return 2;
}
if (hi == 0x8F) /* JIS X 0212 code set: [8F][A1..FE][A1..FE] */
{
if (s + 3 > e)
return MY_CS_TOOSMALL3;
return (*pwc= jisx0212_eucjpms_to_unicode[(((int) s[1]) << 8) + s[2]]) ?
3 :
(s[1] < 0xA1 || s[1] > 0xFE || s[2] < 0xA1 || s[2] > 0xFE) ?
MY_CS_ILSEQ : -3;
}
return MY_CS_ILSEQ;
} | O3 | c | my_mb_wc_eucjpms:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0xaf37e
movzbl (%rdx), %edi
testb %dil, %dil
js 0xaf380
movq %rdi, (%rsi)
movl $0x1, %eax
popq %rbp
retq
leal 0x5f(%rdi), %eax
cmpb $0x5d, %al
ja 0xaf3cc
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0xaf37e
movzbl 0x1(%rdx), %eax
shll $0x9, %edi
leal (%rdi,%rax,2), %eax
leaq 0xaccfa(%rip), %rcx # 0x15c0a0
movzwl (%rax,%rcx), %ecx
movq %rcx, (%rsi)
movl $0x2, %eax
testq %rcx, %rcx
jne 0xaf37e
movb 0x1(%rdx), %al
incb %al
xorl %ecx, %ecx
cmpb $-0x5e, %al
setb %cl
leal -0x2(,%rcx,2), %eax
jmp 0xaf37e
cmpq $0x8f, %rdi
je 0xaf410
cmpl $0x8e, %edi
jne 0xaf452
leaq 0x2(%rdx), %rdi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rdi
ja 0xaf37e
movzbl 0x1(%rdx), %ecx
leal 0x20(%rcx), %edx
movl $0x0, %eax
cmpb $-0x3f, %dl
jb 0xaf37e
addq $0xfec0, %rcx # imm = 0xFEC0
movq %rcx, (%rsi)
movl $0x2, %eax
jmp 0xaf37e
leaq 0x3(%rdx), %rdi
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rcx, %rdi
ja 0xaf37e
movzwl 0x1(%rdx), %eax
rolw $0x8, %ax
movzwl %ax, %eax
leaq 0xccc6c(%rip), %rcx # 0x17c0a0
movzwl (%rcx,%rax,2), %ecx
movq %rcx, (%rsi)
movl $0x3, %eax
testq %rcx, %rcx
jne 0xaf37e
movb 0x1(%rdx), %al
incb %al
cmpb $-0x5e, %al
jae 0xaf459
xorl %eax, %eax
jmp 0xaf37e
movb 0x2(%rdx), %cl
movl $0x0, %eax
cmpb $-0x5f, %cl
jb 0xaf37e
xorl %eax, %eax
cmpb $-0x1, %cl
sete %al
leal (%rax,%rax,2), %eax
addl $-0x3, %eax
jmp 0xaf37e
| my_mb_wc_eucjpms:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_AF37E
movzx edi, byte ptr [rdx]
test dil, dil
js short loc_AF380
mov [rsi], rdi
mov eax, 1
loc_AF37E:
pop rbp
retn
loc_AF380:
lea eax, [rdi+5Fh]
cmp al, 5Dh ; ']'
ja short loc_AF3CC
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short loc_AF37E
movzx eax, byte ptr [rdx+1]
shl edi, 9
lea eax, [rdi+rax*2]
lea rcx, jisx0208_eucjpms_to_unicode
movzx ecx, word ptr [rax+rcx]
mov [rsi], rcx
mov eax, 2
test rcx, rcx
jnz short loc_AF37E
mov al, [rdx+1]
inc al
xor ecx, ecx
cmp al, 0A2h
setb cl
lea eax, ds:0FFFFFFFFFFFFFFFEh[rcx*2]
jmp short loc_AF37E
loc_AF3CC:
cmp rdi, 8Fh
jz short loc_AF410
cmp edi, 8Eh
jnz short loc_AF452
lea rdi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rdi, rcx
ja short loc_AF37E
movzx ecx, byte ptr [rdx+1]
lea edx, [rcx+20h]
mov eax, 0
cmp dl, 0C1h
jb short loc_AF37E
add rcx, 0FEC0h
mov [rsi], rcx
mov eax, 2
jmp loc_AF37E
loc_AF410:
lea rdi, [rdx+3]
mov eax, 0FFFFFF99h
cmp rdi, rcx
ja loc_AF37E
movzx eax, word ptr [rdx+1]
rol ax, 8
movzx eax, ax
lea rcx, jisx0212_eucjpms_to_unicode
movzx ecx, word ptr [rcx+rax*2]
mov [rsi], rcx
mov eax, 3
test rcx, rcx
jnz loc_AF37E
mov al, [rdx+1]
inc al
cmp al, 0A2h
jnb short loc_AF459
loc_AF452:
xor eax, eax
jmp loc_AF37E
loc_AF459:
mov cl, [rdx+2]
mov eax, 0
cmp cl, 0A1h
jb loc_AF37E
xor eax, eax
cmp cl, 0FFh
setz al
lea eax, [rax+rax*2]
add eax, 0FFFFFFFDh
jmp loc_AF37E
| long long my_mb_wc_eucjpms(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rdi
long long v6; // rcx
long long v7; // rcx
long long v8; // rcx
unsigned __int8 v9; // cl
result = 4294967195LL;
if ( (unsigned long long)a3 >= a4 )
return result;
v5 = *a3;
if ( (v5 & 0x80u) == 0LL )
{
*a2 = v5;
return 1LL;
}
if ( (unsigned __int8)(v5 + 95) <= 0x5Du )
{
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v6 = jisx0208_eucjpms_to_unicode[256 * (_DWORD)v5 + a3[1]];
*a2 = v6;
result = 2LL;
if ( !v6 )
return 2 * (unsigned int)((unsigned __int8)(a3[1] + 1) < 0xA2u) - 2;
}
return result;
}
if ( v5 != 143 )
{
if ( (_DWORD)v5 == 142 )
{
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v7 = a3[1];
result = 0LL;
if ( (unsigned __int8)(v7 + 32) >= 0xC1u )
{
*a2 = v7 + 65216;
return 2LL;
}
}
return result;
}
return 0LL;
}
result = 4294967193LL;
if ( (unsigned long long)(a3 + 3) > a4 )
return result;
v8 = jisx0212_eucjpms_to_unicode[(unsigned __int16)__ROL2__(*(_WORD *)(a3 + 1), 8)];
*a2 = v8;
result = 3LL;
if ( v8 )
return result;
if ( (unsigned __int8)(a3[1] + 1) < 0xA2u )
return 0LL;
v9 = a3[2];
result = 0LL;
if ( v9 >= 0xA1u )
return 3 * (unsigned int)(v9 == 0xFF) - 3;
return result;
}
| my_mb_wc_eucjpms:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001af37e
MOVZX EDI,byte ptr [RDX]
TEST DIL,DIL
JS 0x001af380
MOV qword ptr [RSI],RDI
MOV EAX,0x1
LAB_001af37e:
POP RBP
RET
LAB_001af380:
LEA EAX,[RDI + 0x5f]
CMP AL,0x5d
JA 0x001af3cc
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x001af37e
MOVZX EAX,byte ptr [RDX + 0x1]
SHL EDI,0x9
LEA EAX,[RDI + RAX*0x2]
LEA RCX,[0x25c0a0]
MOVZX ECX,word ptr [RAX + RCX*0x1]
MOV qword ptr [RSI],RCX
MOV EAX,0x2
TEST RCX,RCX
JNZ 0x001af37e
MOV AL,byte ptr [RDX + 0x1]
INC AL
XOR ECX,ECX
CMP AL,0xa2
SETC CL
LEA EAX,[-0x2 + RCX*0x2]
JMP 0x001af37e
LAB_001af3cc:
CMP RDI,0x8f
JZ 0x001af410
CMP EDI,0x8e
JNZ 0x001af452
LEA RDI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RDI,RCX
JA 0x001af37e
MOVZX ECX,byte ptr [RDX + 0x1]
LEA EDX,[RCX + 0x20]
MOV EAX,0x0
CMP DL,0xc1
JC 0x001af37e
ADD RCX,0xfec0
MOV qword ptr [RSI],RCX
MOV EAX,0x2
JMP 0x001af37e
LAB_001af410:
LEA RDI,[RDX + 0x3]
MOV EAX,0xffffff99
CMP RDI,RCX
JA 0x001af37e
MOVZX EAX,word ptr [RDX + 0x1]
ROL AX,0x8
MOVZX EAX,AX
LEA RCX,[0x27c0a0]
MOVZX ECX,word ptr [RCX + RAX*0x2]
MOV qword ptr [RSI],RCX
MOV EAX,0x3
TEST RCX,RCX
JNZ 0x001af37e
MOV AL,byte ptr [RDX + 0x1]
INC AL
CMP AL,0xa2
JNC 0x001af459
LAB_001af452:
XOR EAX,EAX
JMP 0x001af37e
LAB_001af459:
MOV CL,byte ptr [RDX + 0x2]
MOV EAX,0x0
CMP CL,0xa1
JC 0x001af37e
XOR EAX,EAX
CMP CL,0xff
SETZ AL
LEA EAX,[RAX + RAX*0x2]
ADD EAX,-0x3
JMP 0x001af37e
|
int my_mb_wc_eucjpms(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
ushort uVar2;
int iVar3;
iVar3 = -0x65;
if (param_3 < param_4) {
bVar1 = *param_3;
if ((char)bVar1 < '\0') {
if ((byte)(bVar1 + 0x5f) < 0x5e) {
iVar3 = -0x66;
if (param_3 + 2 <= param_4) {
uVar2 = *(ushort *)
(jisx0208_eucjpms_to_unicode + ((uint)bVar1 * 0x200 + (uint)param_3[1] * 2));
*param_2 = (ulong)uVar2;
iVar3 = 2;
if ((ulong)uVar2 == 0) {
iVar3 = (uint)((byte)(param_3[1] + 1) < 0xa2) * 2 + -2;
}
}
}
else {
if ((ulong)bVar1 == 0x8f) {
if (param_4 < param_3 + 3) {
return -0x67;
}
uVar2 = *(ushort *)
(&jisx0212_eucjpms_to_unicode +
(ulong)(ushort)(*(ushort *)(param_3 + 1) << 8 | *(ushort *)(param_3 + 1) >> 8) *
2);
*param_2 = (ulong)uVar2;
if ((ulong)uVar2 != 0) {
return 3;
}
if (0xa1 < (byte)(param_3[1] + 1)) {
if (param_3[2] < 0xa1) {
return 0;
}
return (uint)(param_3[2] == 0xff) * 3 + -3;
}
}
else if (bVar1 == 0x8e) {
if (param_4 < param_3 + 2) {
return -0x66;
}
if ((byte)(param_3[1] + 0x20) < 0xc1) {
return 0;
}
*param_2 = (ulong)param_3[1] + 0xfec0;
return 2;
}
iVar3 = 0;
}
}
else {
*param_2 = (ulong)bVar1;
iVar3 = 1;
}
}
return iVar3;
}
| |
54,142 | mi_indexes_are_disabled | eloqsql/storage/myisam/mi_open.c | int mi_indexes_are_disabled(MI_INFO *info)
{
MYISAM_SHARE *share= info->s;
/*
No keys or all are enabled. keys is the number of keys. Left shifted
gives us only one bit set. When decreased by one, gives us all all bits
up to this one set and it gets unset.
*/
if (!share->base.keys ||
(mi_is_all_keys_active(share->state.key_map, share->base.keys)))
return 0;
/* All are disabled */
if (mi_is_any_key_active(share->state.key_map))
return 1;
/*
We have keys. Some enabled, some disabled.
Don't check for any non-unique disabled but return directly 2
*/
return 2;
} | O0 | c | mi_indexes_are_disabled:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x180(%rax)
je 0x12d8ce4
movq -0x18(%rbp), %rax
movq 0xc0(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x40, 0x180(%rax)
jae 0x12d8cca
movq -0x18(%rbp), %rax
movl 0x180(%rax), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x12d8cd7
movq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x12d8cd7
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq %rcx, %rax
jne 0x12d8ced
movl $0x0, -0x4(%rbp)
jmp 0x12d8d1b
movq -0x18(%rbp), %rax
cmpq $0x0, 0xc0(%rax)
je 0x12d8d03
movb $0x1, %al
testb $0x1, %al
jne 0x12d8d0b
jmp 0x12d8d14
xorl %eax, %eax
testb $0x1, %al
jne 0x12d8d0b
jmp 0x12d8d14
movl $0x1, -0x4(%rbp)
jmp 0x12d8d1b
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
| mi_indexes_are_disabled:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
cmp dword ptr [rax+180h], 0
jz short loc_12D8CE4
mov rax, [rbp+var_18]
mov rax, [rax+0C0h]
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
cmp dword ptr [rax+180h], 40h ; '@'
jnb short loc_12D8CCA
mov rax, [rbp+var_18]
mov eax, [rax+180h]
mov ecx, eax
mov eax, 1
shl rax, cl
sub rax, 1
mov [rbp+var_28], rax
jmp short loc_12D8CD7
loc_12D8CCA:
mov rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_28], rax
jmp short $+2
loc_12D8CD7:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_28]
cmp rax, rcx
jnz short loc_12D8CED
loc_12D8CE4:
mov [rbp+var_4], 0
jmp short loc_12D8D1B
loc_12D8CED:
mov rax, [rbp+var_18]
cmp qword ptr [rax+0C0h], 0
jz short loc_12D8D03
mov al, 1
test al, 1
jnz short loc_12D8D0B
jmp short loc_12D8D14
loc_12D8D03:
xor eax, eax
test al, 1
jnz short loc_12D8D0B
jmp short loc_12D8D14
loc_12D8D0B:
mov [rbp+var_4], 1
jmp short loc_12D8D1B
loc_12D8D14:
mov [rbp+var_4], 2
loc_12D8D1B:
mov eax, [rbp+var_4]
pop rbp
retn
| long long mi_indexes_are_disabled(long long *a1)
{
long long v2; // [rsp+0h] [rbp-28h]
long long v3; // [rsp+10h] [rbp-18h]
v3 = *a1;
if ( *(_DWORD *)(*a1 + 384)
&& (*(_DWORD *)(v3 + 384) >= 0x40u ? (v2 = -1LL) : (v2 = (1LL << *(_DWORD *)(v3 + 384)) - 1),
*(_QWORD *)(v3 + 192) != v2) )
{
if ( *(_QWORD *)(v3 + 192) )
return 1;
else
return 2;
}
else
{
return 0;
}
}
| row_sel_fetch_columns:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
JMP 0x012d8c8a
LAB_012d8c8a:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x011072b0
TEST AL,0x1
JNZ 0x012d8c99
JMP 0x012d8ca3
LAB_012d8c99:
MOV qword ptr [RBP + -0x30],0x0
JMP 0x012d8cab
LAB_012d8ca3:
MOV qword ptr [RBP + -0x30],0x1
LAB_012d8cab:
JMP 0x012d8cad
LAB_012d8cad:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x012d8e32
MOV qword ptr [RBP + -0x50],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + RCX*0x8 + 0x60]
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],-0x1
JZ 0x012d8e21
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x01190530
CMP RAX,0x0
JZ 0x012d8dae
MOV EDI,0x1
XOR EAX,EAX
MOV ESI,EAX
CALL 0x012d7280
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x18]
MOV RDI,qword ptr [RAX + 0x30]
CALL 0x00914270
MOV RDI,qword ptr [RBP + -0x68]
MOV RSI,qword ptr [RBP + -0x60]
MOV EAX,EAX
MOV EDX,EAX
MOV RCX,qword ptr [RBP + -0x38]
MOV R9,qword ptr [RBP + -0x50]
LEA R8,[RBP + -0x48]
CALL 0x0134f260
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,0x0
SETNZ AL
XOR AL,0xff
TEST AL,0x1
JNZ 0x012d8d5a
JMP 0x012d8d72
LAB_012d8d5a:
LEA RDI,[0x14e57f3]
LEA RSI,[0x1592c6e]
MOV EDX,0x260
CALL 0x01329220
LAB_012d8d72:
JMP 0x012d8d74
LAB_012d8d74:
JMP 0x012d8d76
LAB_012d8d76:
MOV EAX,0xffffffff
CMP qword ptr [RBP + -0x48],RAX
SETNZ AL
XOR AL,0xff
TEST AL,0x1
JNZ 0x012d8d8a
JMP 0x012d8da2
LAB_012d8d8a:
LEA RDI,[0x157fc4d]
LEA RSI,[0x1592c6e]
MOV EDX,0x261
CALL 0x01329220
LAB_012d8da2:
JMP 0x012d8da4
LAB_012d8da4:
MOV qword ptr [RBP + -0x58],0x1
JMP 0x012d8dd7
LAB_012d8dae:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x38]
LEA R8,[RBP + -0x48]
CALL 0x011e3cf0
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x58]
MOV qword ptr [RBP + -0x58],RAX
LAB_012d8dd7:
CMP qword ptr [RBP + -0x58],0x0
JZ 0x012d8df1
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x48]
CALL 0x012d83d0
JMP 0x012d8e0f
LAB_012d8df1:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x012cff90
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x48]
CALL 0x012d07c0
LAB_012d8e0f:
CMP qword ptr [RBP + -0x50],0x0
JZ 0x012d8e1f
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x012ce560
LAB_012d8e1f:
JMP 0x012d8e21
LAB_012d8e21:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x50]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x012d8cad
LAB_012d8e32:
ADD RSP,0x70
POP RBP
RET
|
/* row_sel_fetch_columns(dict_index_t*, unsigned char const*, unsigned short const*, sym_node_t*) */
void row_sel_fetch_columns(dict_index_t *param_1,uchar *param_2,ushort *param_3,sym_node_t *param_4)
{
ushort *puVar1;
uchar *puVar2;
uint uVar3;
ulong uVar4;
long lVar5;
long local_60;
mem_block_info_t *local_58;
ulong local_50;
uchar *local_48;
ulong local_40;
ulong local_38;
dfield_t *local_30;
sym_node_t *local_28;
ushort *local_20;
uchar *local_18;
dict_index_t *local_10;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
uVar4 = dict_index_t::is_clust(param_1);
local_38 = (ulong)((uVar4 & 1) == 0);
do {
if (local_28 == (sym_node_t *)0x0) {
return;
}
local_58 = (mem_block_info_t *)0x0;
local_40 = *(ulong *)(local_28 + local_38 * 8 + 0x60);
if (local_40 != 0xffffffffffffffff) {
lVar5 = rec_offs_nth_extern(local_20,local_40);
if (lVar5 == 0) {
local_48 = (uchar *)rec_get_nth_cfield(local_18,local_10,local_20,local_40,&local_50);
local_60 = *(long *)(local_28 + 0x58);
}
else {
local_58 = (mem_block_info_t *)mem_heap_create_func(1,0);
puVar2 = local_18;
puVar1 = local_20;
uVar3 = fil_space_t::zip_size(*(fil_space_t **)(*(long *)(local_10 + 0x18) + 0x30));
local_48 = (uchar *)btr_rec_copy_externally_stored_field
(puVar2,puVar1,(ulong)uVar3,local_40,&local_50,local_58);
if (local_48 == (uchar *)0x0) {
/* WARNING: Subroutine does not return */
ut_dbg_assertion_failed
("data",
"/workspace/llm4binary/github2025/eloqsql/storage/innobase/row/row0sel.cc",
0x260);
}
if (local_50 == 0xffffffff) {
/* WARNING: Subroutine does not return */
ut_dbg_assertion_failed
("len != UNIV_SQL_NULL",
"/workspace/llm4binary/github2025/eloqsql/storage/innobase/row/row0sel.cc",
0x261);
}
local_60 = 1;
}
if (local_60 == 0) {
local_30 = (dfield_t *)que_node_get_val(local_28);
dfield_set_data(local_30,local_48,local_50);
}
else {
eval_node_copy_and_alloc_val(local_28,local_48,local_50);
}
if (local_58 != (mem_block_info_t *)0x0) {
mem_heap_free(local_58);
}
}
local_28 = *(sym_node_t **)(local_28 + 0x50);
} while( true );
}
| |
54,143 | my_connect_async | eloqsql/libmariadb/libmariadb/mariadb_async.c | int
my_connect_async(MARIADB_PVIO *pvio,
const struct sockaddr *name, uint namelen, int vio_timeout)
{
int res;
size_socket s_err_size;
struct mysql_async_context *b= pvio->mysql->options.extension->async_context;
my_socket sock;
ma_pvio_get_handle(pvio, &sock);
/* Make the socket non-blocking. */
ma_pvio_blocking(pvio, 0, 0);
b->events_to_wait_for= 0;
/*
Start to connect asynchronously.
If this will block, we suspend the call and return control to the
application context. The application will then resume us when the socket
polls ready for write, indicating that the connection attempt completed.
*/
res= connect(sock, name, namelen);
if (res != 0)
{
#ifdef _WIN32
int wsa_err= WSAGetLastError();
if (wsa_err != WSAEWOULDBLOCK)
return res;
b->events_to_wait_for|= MYSQL_WAIT_EXCEPT;
#else
int err= errno;
if (err != EINPROGRESS && err != EALREADY && err != EAGAIN)
return res;
#endif
b->events_to_wait_for|= MYSQL_WAIT_WRITE;
if (vio_timeout >= 0)
{
b->timeout_value= vio_timeout;
b->events_to_wait_for|= MYSQL_WAIT_TIMEOUT;
}
else
b->timeout_value= 0;
if (b->suspend_resume_hook)
(*b->suspend_resume_hook)(TRUE, b->suspend_resume_hook_user_data);
my_context_yield(&b->async_context);
if (b->suspend_resume_hook)
(*b->suspend_resume_hook)(FALSE, b->suspend_resume_hook_user_data);
if (b->events_occurred & MYSQL_WAIT_TIMEOUT)
return -1;
s_err_size= sizeof(res);
if (getsockopt(sock, SOL_SOCKET, SO_ERROR, (char*) &res, &s_err_size) != 0)
return -1;
if (res)
{
errno= res;
return -1;
}
}
return res;
} | O0 | c | my_connect_async:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x55800
movq -0x10(%rbp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x55270
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movl -0x34(%rbp), %edi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x383f0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x6989f
callq 0x389e0
movl (%rax), %eax
movl %eax, -0x38(%rbp)
cmpl $0x73, -0x38(%rbp)
je 0x697b6
cmpl $0x72, -0x38(%rbp)
je 0x697b6
cmpl $0xb, -0x38(%rbp)
je 0x697b6
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x698a5
movq -0x30(%rbp), %rax
movl (%rax), %ecx
orl $0x2, %ecx
movl %ecx, (%rax)
cmpl $0x0, -0x20(%rbp)
jl 0x697de
movl -0x20(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x30(%rbp), %rax
movl (%rax), %ecx
orl $0x8, %ecx
movl %ecx, (%rax)
jmp 0x697e9
movq -0x30(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x6980b
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x30(%rbp), %rcx
movq 0x28(%rcx), %rsi
movl $0x1, %edi
callq *%rax
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
callq 0x71030
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x69837
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x30(%rbp), %rcx
movq 0x28(%rcx), %rsi
xorl %edi, %edi
callq *%rax
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x6984f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x698a5
movl $0x4, -0x28(%rbp)
movl -0x34(%rbp), %edi
movl $0x1, %esi
movl $0x4, %edx
leaq -0x24(%rbp), %rcx
leaq -0x28(%rbp), %r8
callq 0x387b0
cmpl $0x0, %eax
je 0x6987e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x698a5
cmpl $0x0, -0x24(%rbp)
je 0x6989d
movl -0x24(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0x389e0
movl -0x3c(%rbp), %ecx
movl %ecx, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x698a5
jmp 0x6989f
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
| my_connect_async:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_20], ecx
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_30], rax
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_34]
call ma_pvio_get_handle
mov rdi, [rbp+var_10]
xor esi, esi
xor eax, eax
mov edx, eax
call ma_pvio_blocking
mov rax, [rbp+var_30]
mov dword ptr [rax], 0
mov edi, [rbp+var_34]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
call _connect
mov [rbp+var_24], eax
cmp [rbp+var_24], 0
jz loc_6989F
call ___errno_location
mov eax, [rax]
mov [rbp+var_38], eax
cmp [rbp+var_38], 73h ; 's'
jz short loc_697B6
cmp [rbp+var_38], 72h ; 'r'
jz short loc_697B6
cmp [rbp+var_38], 0Bh
jz short loc_697B6
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
jmp loc_698A5
loc_697B6:
mov rax, [rbp+var_30]
mov ecx, [rax]
or ecx, 2
mov [rax], ecx
cmp [rbp+var_20], 0
jl short loc_697DE
mov ecx, [rbp+var_20]
mov rax, [rbp+var_30]
mov [rax+10h], ecx
mov rax, [rbp+var_30]
mov ecx, [rax]
or ecx, 8
mov [rax], ecx
jmp short loc_697E9
loc_697DE:
mov rax, [rbp+var_30]
mov dword ptr [rax+10h], 0
loc_697E9:
mov rax, [rbp+var_30]
cmp qword ptr [rax+20h], 0
jz short loc_6980B
mov rax, [rbp+var_30]
mov rax, [rax+20h]
mov rcx, [rbp+var_30]
mov rsi, [rcx+28h]
mov edi, 1
call rax
loc_6980B:
mov rdi, [rbp+var_30]
add rdi, 38h ; '8'
call my_context_yield
mov rax, [rbp+var_30]
cmp qword ptr [rax+20h], 0
jz short loc_69837
mov rax, [rbp+var_30]
mov rax, [rax+20h]
mov rcx, [rbp+var_30]
mov rsi, [rcx+28h]
xor edi, edi
call rax
loc_69837:
mov rax, [rbp+var_30]
mov eax, [rax+4]
and eax, 8
cmp eax, 0
jz short loc_6984F
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_698A5
loc_6984F:
mov [rbp+var_28], 4
mov edi, [rbp+var_34]
mov esi, 1
mov edx, 4
lea rcx, [rbp+var_24]
lea r8, [rbp+var_28]
call _getsockopt
cmp eax, 0
jz short loc_6987E
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_698A5
loc_6987E:
cmp [rbp+var_24], 0
jz short loc_6989D
mov eax, [rbp+var_24]
mov [rbp+var_3C], eax
call ___errno_location
mov ecx, [rbp+var_3C]
mov [rax], ecx
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_698A5
loc_6989D:
jmp short $+2
loc_6989F:
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
loc_698A5:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
| long long my_connect_async(long long a1, long long a2, unsigned int a3, int a4)
{
unsigned int v5; // [rsp+4h] [rbp-3Ch]
int v6; // [rsp+8h] [rbp-38h]
unsigned int v7; // [rsp+Ch] [rbp-34h] BYREF
long long v8; // [rsp+10h] [rbp-30h]
int v9; // [rsp+18h] [rbp-28h] BYREF
unsigned int v10; // [rsp+1Ch] [rbp-24h] BYREF
int v11; // [rsp+20h] [rbp-20h]
unsigned int v12; // [rsp+24h] [rbp-1Ch]
long long v13; // [rsp+28h] [rbp-18h]
long long v14; // [rsp+30h] [rbp-10h]
v14 = a1;
v13 = a2;
v12 = a3;
v11 = a4;
v8 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 64) + 1152LL) + 40LL);
ma_pvio_get_handle(a1, (long long)&v7);
ma_pvio_blocking(v14, 0, 0LL);
*(_DWORD *)v8 = 0;
v10 = connect(v7, v13, v12);
if ( !v10 )
return v10;
v6 = *(_DWORD *)__errno_location();
if ( v6 == 115 || v6 == 114 || v6 == 11 )
{
*(_DWORD *)v8 |= 2u;
if ( v11 < 0 )
{
*(_DWORD *)(v8 + 16) = 0;
}
else
{
*(_DWORD *)(v8 + 16) = v11;
*(_DWORD *)v8 |= 8u;
}
if ( *(_QWORD *)(v8 + 32) )
(*(void ( **)(long long, _QWORD))(v8 + 32))(1LL, *(_QWORD *)(v8 + 40));
my_context_yield(v8 + 56);
if ( *(_QWORD *)(v8 + 32) )
(*(void ( **)(_QWORD, _QWORD))(v8 + 32))(0LL, *(_QWORD *)(v8 + 40));
if ( (*(_DWORD *)(v8 + 4) & 8) != 0 )
return (unsigned int)-1;
v9 = 4;
if ( (unsigned int)getsockopt(v7, 1LL, 4LL, &v10, &v9) )
return (unsigned int)-1;
if ( v10 )
{
v5 = v10;
*(_DWORD *)__errno_location() = v5;
return (unsigned int)-1;
}
return v10;
}
return v10;
}
| my_connect_async:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV dword ptr [RBP + -0x20],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x34]
CALL 0x00155800
MOV RDI,qword ptr [RBP + -0x10]
XOR ESI,ESI
XOR EAX,EAX
MOV EDX,EAX
CALL 0x00155270
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],0x0
MOV EDI,dword ptr [RBP + -0x34]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
CALL 0x001383f0
MOV dword ptr [RBP + -0x24],EAX
CMP dword ptr [RBP + -0x24],0x0
JZ 0x0016989f
CALL 0x001389e0
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x38],EAX
CMP dword ptr [RBP + -0x38],0x73
JZ 0x001697b6
CMP dword ptr [RBP + -0x38],0x72
JZ 0x001697b6
CMP dword ptr [RBP + -0x38],0xb
JZ 0x001697b6
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001698a5
LAB_001697b6:
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RAX]
OR ECX,0x2
MOV dword ptr [RAX],ECX
CMP dword ptr [RBP + -0x20],0x0
JL 0x001697de
MOV ECX,dword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RAX]
OR ECX,0x8
MOV dword ptr [RAX],ECX
JMP 0x001697e9
LAB_001697de:
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x10],0x0
LAB_001697e9:
MOV RAX,qword ptr [RBP + -0x30]
CMP qword ptr [RAX + 0x20],0x0
JZ 0x0016980b
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RCX + 0x28]
MOV EDI,0x1
CALL RAX
LAB_0016980b:
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x38
CALL 0x00171030
MOV RAX,qword ptr [RBP + -0x30]
CMP qword ptr [RAX + 0x20],0x0
JZ 0x00169837
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RCX + 0x28]
XOR EDI,EDI
CALL RAX
LAB_00169837:
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX + 0x4]
AND EAX,0x8
CMP EAX,0x0
JZ 0x0016984f
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001698a5
LAB_0016984f:
MOV dword ptr [RBP + -0x28],0x4
MOV EDI,dword ptr [RBP + -0x34]
MOV ESI,0x1
MOV EDX,0x4
LEA RCX,[RBP + -0x24]
LEA R8,[RBP + -0x28]
CALL 0x001387b0
CMP EAX,0x0
JZ 0x0016987e
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001698a5
LAB_0016987e:
CMP dword ptr [RBP + -0x24],0x0
JZ 0x0016989d
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x3c],EAX
CALL 0x001389e0
MOV ECX,dword ptr [RBP + -0x3c]
MOV dword ptr [RAX],ECX
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001698a5
LAB_0016989d:
JMP 0x0016989f
LAB_0016989f:
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
LAB_001698a5:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int my_connect_async(long param_1,sockaddr *param_2,socklen_t param_3,uint param_4)
{
int iVar1;
int iVar2;
int *piVar3;
int local_3c;
uint *local_38;
socklen_t local_30;
int local_2c;
uint local_28;
socklen_t local_24;
sockaddr *local_20;
long local_18;
local_38 = *(uint **)(*(long *)(*(long *)(param_1 + 0x40) + 0x480) + 0x28);
local_28 = param_4;
local_24 = param_3;
local_20 = param_2;
local_18 = param_1;
ma_pvio_get_handle(param_1,&local_3c);
ma_pvio_blocking(local_18,0,0);
*local_38 = 0;
local_2c = connect(local_3c,local_20,local_24);
if (local_2c != 0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
if (((iVar1 != 0x73) && (iVar1 != 0x72)) && (iVar1 != 0xb)) {
return local_2c;
}
*local_38 = *local_38 | 2;
if ((int)local_28 < 0) {
local_38[4] = 0;
}
else {
local_38[4] = local_28;
*local_38 = *local_38 | 8;
}
if (*(long *)(local_38 + 8) != 0) {
(**(code **)(local_38 + 8))(1,*(int8 *)(local_38 + 10));
}
my_context_yield(local_38 + 0xe);
if (*(long *)(local_38 + 8) != 0) {
(**(code **)(local_38 + 8))(0,*(int8 *)(local_38 + 10));
}
if ((local_38[1] & 8) != 0) {
return -1;
}
local_30 = 4;
iVar2 = getsockopt(local_3c,1,4,&local_2c,&local_30);
iVar1 = local_2c;
if (iVar2 != 0) {
return -1;
}
if (local_2c != 0) {
piVar3 = __errno_location();
*piVar3 = iVar1;
return -1;
}
}
return local_2c;
}
| |
54,144 | google::protobuf::compiler::CodeGeneratorRequest::ByteSizeLong() const | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/plugin.pb.cc | size_t CodeGeneratorRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.protobuf.compiler.CodeGeneratorRequest)
size_t total_size = 0;
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
// repeated string file_to_generate = 1;
total_size += 1 *
::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.file_to_generate_.size());
for (int i = 0, n = _impl_.file_to_generate_.size(); i < n; i++) {
total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
_impl_.file_to_generate_.Get(i));
}
// repeated .google.protobuf.FileDescriptorProto proto_file = 15;
total_size += 1UL * this->_internal_proto_file_size();
for (const auto& msg : this->_impl_.proto_file_) {
total_size +=
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
}
cached_has_bits = _impl_._has_bits_[0];
if (cached_has_bits & 0x00000003u) {
// optional string parameter = 2;
if (cached_has_bits & 0x00000001u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
this->_internal_parameter());
}
// optional .google.protobuf.compiler.Version compiler_version = 3;
if (cached_has_bits & 0x00000002u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
*_impl_.compiler_version_);
}
}
return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
} | O3 | cpp | google::protobuf::compiler::CodeGeneratorRequest::ByteSizeLong() const:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x20(%rdi), %eax
testl %eax, %eax
jle 0xae19e
movq 0x28(%rbx), %rcx
xorl %edx, %edx
movq %rax, %r14
movq 0x8(%rcx,%rdx,8), %rsi
movq 0x8(%rsi), %rsi
addq %rsi, %r14
orl $0x1, %esi
bsrl %esi, %esi
leal (%rsi,%rsi,8), %esi
addl $0x49, %esi
shrl $0x6, %esi
addq %rsi, %r14
incq %rdx
cmpq %rdx, %rax
jne 0xae176
jmp 0xae1a1
movq %rax, %r14
movslq 0x38(%rbx), %r15
addq %r15, %r14
movq 0x40(%rbx), %rax
leaq 0x8(%rax), %r12
testq %rax, %rax
cmoveq %rax, %r12
testq %r15, %r15
je 0xae1ea
shlq $0x3, %r15
xorl %r13d, %r13d
movq (%r12,%r13), %rdi
callq 0x4909a
addq %rax, %r14
orl $0x1, %eax
bsrl %eax, %eax
leal (%rax,%rax,8), %eax
addl $0x49, %eax
shrl $0x6, %eax
addq %rax, %r14
addq $0x8, %r13
cmpq %r13, %r15
jne 0xae1c3
movl 0x10(%rbx), %eax
testb $0x3, %al
je 0xae23e
testb $0x1, %al
je 0xae219
movq 0x48(%rbx), %rcx
andq $-0x4, %rcx
movq 0x8(%rcx), %rcx
addq %rcx, %r14
orl $0x1, %ecx
bsrl %ecx, %ecx
leal (%rcx,%rcx,8), %ecx
addl $0x49, %ecx
shrl $0x6, %ecx
addq %rcx, %r14
incq %r14
testb $0x2, %al
je 0xae23e
movq 0x50(%rbx), %rdi
callq 0xad8a0
addq %rax, %r14
orl $0x1, %eax
bsrl %eax, %eax
leal (%rax,%rax,8), %eax
addl $0x49, %eax
shrl $0x6, %eax
addq %rax, %r14
incq %r14
leaq 0x14(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x77d4a
| _ZNK6google8protobuf8compiler20CodeGeneratorRequest12ByteSizeLongEv:
push r15
push r14
push r13
push r12
push rbx
mov rbx, rdi
mov eax, [rdi+20h]
test eax, eax
jle short loc_AE19E
mov rcx, [rbx+28h]
xor edx, edx
mov r14, rax
loc_AE176:
mov rsi, [rcx+rdx*8+8]
mov rsi, [rsi+8]
add r14, rsi
or esi, 1
bsr esi, esi
lea esi, [rsi+rsi*8]
add esi, 49h ; 'I'
shr esi, 6
add r14, rsi
inc rdx
cmp rax, rdx
jnz short loc_AE176
jmp short loc_AE1A1
loc_AE19E:
mov r14, rax
loc_AE1A1:
movsxd r15, dword ptr [rbx+38h]
add r14, r15
mov rax, [rbx+40h]
lea r12, [rax+8]
test rax, rax
cmovz r12, rax
test r15, r15
jz short loc_AE1EA
shl r15, 3
xor r13d, r13d
loc_AE1C3:
mov rdi, [r12+r13]; this
call _ZNK6google8protobuf19FileDescriptorProto12ByteSizeLongEv; google::protobuf::FileDescriptorProto::ByteSizeLong(void)
add r14, rax
or eax, 1
bsr eax, eax
lea eax, [rax+rax*8]
add eax, 49h ; 'I'
shr eax, 6
add r14, rax
add r13, 8
cmp r15, r13
jnz short loc_AE1C3
loc_AE1EA:
mov eax, [rbx+10h]
test al, 3
jz short loc_AE23E
test al, 1
jz short loc_AE219
mov rcx, [rbx+48h]
and rcx, 0FFFFFFFFFFFFFFFCh
mov rcx, [rcx+8]
add r14, rcx
or ecx, 1
bsr ecx, ecx
lea ecx, [rcx+rcx*8]
add ecx, 49h ; 'I'
shr ecx, 6
add r14, rcx
inc r14
loc_AE219:
test al, 2
jz short loc_AE23E
mov rdi, [rbx+50h]; this
call _ZNK6google8protobuf8compiler7Version12ByteSizeLongEv; google::protobuf::compiler::Version::ByteSizeLong(void)
add r14, rax
or eax, 1
bsr eax, eax
lea eax, [rax+rax*8]
add eax, 49h ; 'I'
shr eax, 6
add r14, rax
inc r14
loc_AE23E:
lea rdx, [rbx+14h]
mov rdi, rbx
mov rsi, r14
pop rbx
pop r12
pop r13
pop r14
pop r15
jmp _ZNK6google8protobuf7Message29MaybeComputeUnknownFieldsSizeEmPNS0_8internal10CachedSizeE; google::protobuf::Message::MaybeComputeUnknownFieldsSize(ulong,google::protobuf::internal::CachedSize *)
| char * google::protobuf::compiler::CodeGeneratorRequest::ByteSizeLong(
google::protobuf::compiler::CodeGeneratorRequest *this)
{
long long v1; // rax
long long v2; // rdx
long long v3; // r14
long long v4; // rsi
long long v5; // r14
long long v6; // r15
const google::protobuf::UnknownFieldSet *v7; // r14
long long v8; // rax
long long v9; // r12
long long v10; // r15
long long v11; // r13
long long v12; // rax
char *v13; // r14
int v14; // eax
long long v15; // rcx
char *v16; // r14
char *v17; // rax
char *v18; // r14
v1 = *((unsigned int *)this + 8);
if ( (int)v1 <= 0 )
{
v3 = *((unsigned int *)this + 8);
}
else
{
v2 = 0LL;
v3 = *((unsigned int *)this + 8);
do
{
v4 = *(_QWORD *)(*(_QWORD *)(*((_QWORD *)this + 5) + 8 * v2 + 8) + 8LL);
v5 = v4 + v3;
_BitScanReverse((unsigned int *)&v4, v4 | 1);
v3 = ((unsigned int)(9 * v4 + 73) >> 6) + v5;
++v2;
}
while ( v1 != v2 );
}
v6 = *((int *)this + 14);
v7 = (const google::protobuf::UnknownFieldSet *)(v6 + v3);
v8 = *((_QWORD *)this + 8);
v9 = v8 + 8;
if ( !v8 )
v9 = 0LL;
if ( *((_DWORD *)this + 14) )
{
v10 = 8 * v6;
v11 = 0LL;
do
{
v12 = google::protobuf::FileDescriptorProto::ByteSizeLong(*(google::protobuf::FileDescriptorProto **)(v9 + v11));
v13 = (char *)v7 + v12;
_BitScanReverse((unsigned int *)&v12, v12 | 1);
v7 = (const google::protobuf::UnknownFieldSet *)&v13[(unsigned int)(9 * v12 + 73) >> 6];
v11 += 8LL;
}
while ( v10 != v11 );
}
v14 = *((_DWORD *)this + 4);
if ( (v14 & 3) != 0 )
{
if ( (v14 & 1) != 0 )
{
v15 = *(_QWORD *)((*((_QWORD *)this + 9) & 0xFFFFFFFFFFFFFFFCLL) + 8);
v16 = (char *)v7 + v15;
_BitScanReverse((unsigned int *)&v15, v15 | 1);
v7 = (const google::protobuf::UnknownFieldSet *)&v16[((unsigned int)(9 * v15 + 73) >> 6) + 1];
}
if ( (v14 & 2) != 0 )
{
v17 = google::protobuf::compiler::Version::ByteSizeLong(*((google::protobuf::compiler::Version **)this + 10));
v18 = (char *)v7 + (_QWORD)v17;
_BitScanReverse((unsigned int *)&v17, (unsigned int)v17 | 1);
v7 = (const google::protobuf::UnknownFieldSet *)&v18[((unsigned int)(9 * (_DWORD)v17 + 73) >> 6) + 1];
}
}
return google::protobuf::Message::MaybeComputeUnknownFieldsSize((long long)this, v7, (_DWORD *)this + 5);
}
| ByteSizeLong:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV RBX,RDI
MOV EAX,dword ptr [RDI + 0x20]
TEST EAX,EAX
JLE 0x001ae19e
MOV RCX,qword ptr [RBX + 0x28]
XOR EDX,EDX
MOV R14,RAX
LAB_001ae176:
MOV RSI,qword ptr [RCX + RDX*0x8 + 0x8]
MOV RSI,qword ptr [RSI + 0x8]
ADD R14,RSI
OR ESI,0x1
BSR ESI,ESI
LEA ESI,[RSI + RSI*0x8]
ADD ESI,0x49
SHR ESI,0x6
ADD R14,RSI
INC RDX
CMP RAX,RDX
JNZ 0x001ae176
JMP 0x001ae1a1
LAB_001ae19e:
MOV R14,RAX
LAB_001ae1a1:
MOVSXD R15,dword ptr [RBX + 0x38]
ADD R14,R15
MOV RAX,qword ptr [RBX + 0x40]
LEA R12,[RAX + 0x8]
TEST RAX,RAX
CMOVZ R12,RAX
TEST R15,R15
JZ 0x001ae1ea
SHL R15,0x3
XOR R13D,R13D
LAB_001ae1c3:
MOV RDI,qword ptr [R12 + R13*0x1]
CALL 0x0014909a
ADD R14,RAX
OR EAX,0x1
BSR EAX,EAX
LEA EAX,[RAX + RAX*0x8]
ADD EAX,0x49
SHR EAX,0x6
ADD R14,RAX
ADD R13,0x8
CMP R15,R13
JNZ 0x001ae1c3
LAB_001ae1ea:
MOV EAX,dword ptr [RBX + 0x10]
TEST AL,0x3
JZ 0x001ae23e
TEST AL,0x1
JZ 0x001ae219
MOV RCX,qword ptr [RBX + 0x48]
AND RCX,-0x4
MOV RCX,qword ptr [RCX + 0x8]
ADD R14,RCX
OR ECX,0x1
BSR ECX,ECX
LEA ECX,[RCX + RCX*0x8]
ADD ECX,0x49
SHR ECX,0x6
ADD R14,RCX
INC R14
LAB_001ae219:
TEST AL,0x2
JZ 0x001ae23e
MOV RDI,qword ptr [RBX + 0x50]
CALL 0x001ad8a0
ADD R14,RAX
OR EAX,0x1
BSR EAX,EAX
LEA EAX,[RAX + RAX*0x8]
ADD EAX,0x49
SHR EAX,0x6
ADD R14,RAX
INC R14
LAB_001ae23e:
LEA RDX,[RBX + 0x14]
MOV RDI,RBX
MOV RSI,R14
POP RBX
POP R12
POP R13
POP R14
POP R15
JMP 0x00177d4a
|
/* google::protobuf::compiler::CodeGeneratorRequest::ByteSizeLong() const */
void __thiscall
google::protobuf::compiler::CodeGeneratorRequest::ByteSizeLong(CodeGeneratorRequest *this)
{
int iVar1;
ulong uVar2;
long lVar3;
long lVar4;
uint uVar5;
ulong uVar6;
uint uVar7;
long lVar8;
ulong uVar9;
long lVar10;
uVar2 = (ulong)*(uint *)(this + 0x20);
uVar9 = uVar2;
if (0 < (int)*(uint *)(this + 0x20)) {
uVar6 = 0;
do {
lVar4 = *(long *)(*(long *)(*(long *)(this + 0x28) + 8 + uVar6 * 8) + 8);
uVar7 = (uint)lVar4 | 1;
iVar1 = 0x1f;
if (uVar7 != 0) {
for (; uVar7 >> iVar1 == 0; iVar1 = iVar1 + -1) {
}
}
uVar9 = uVar9 + lVar4 + (ulong)(iVar1 * 9 + 0x49U >> 6);
uVar6 = uVar6 + 1;
} while (uVar2 != uVar6);
}
lVar10 = (long)*(int *)(this + 0x38);
uVar9 = uVar9 + lVar10;
lVar4 = *(long *)(this + 0x40) + 8;
if (*(long *)(this + 0x40) == 0) {
lVar4 = 0;
}
if (lVar10 != 0) {
lVar8 = 0;
do {
lVar3 = FileDescriptorProto::ByteSizeLong(*(FileDescriptorProto **)(lVar4 + lVar8));
uVar7 = (uint)lVar3 | 1;
iVar1 = 0x1f;
if (uVar7 != 0) {
for (; uVar7 >> iVar1 == 0; iVar1 = iVar1 + -1) {
}
}
uVar9 = uVar9 + lVar3 + (ulong)(iVar1 * 9 + 0x49U >> 6);
lVar8 = lVar8 + 8;
} while (lVar10 * 8 != lVar8);
}
uVar7 = *(uint *)(this + 0x10);
if ((uVar7 & 3) != 0) {
if ((uVar7 & 1) != 0) {
lVar4 = *(long *)((*(ulong *)(this + 0x48) & 0xfffffffffffffffc) + 8);
uVar5 = (uint)lVar4 | 1;
iVar1 = 0x1f;
if (uVar5 != 0) {
for (; uVar5 >> iVar1 == 0; iVar1 = iVar1 + -1) {
}
}
uVar9 = uVar9 + lVar4 + (ulong)(iVar1 * 9 + 0x49U >> 6) + 1;
}
if ((uVar7 & 2) != 0) {
lVar4 = Version::ByteSizeLong(*(Version **)(this + 0x50));
uVar7 = (uint)lVar4 | 1;
iVar1 = 0x1f;
if (uVar7 != 0) {
for (; uVar7 >> iVar1 == 0; iVar1 = iVar1 + -1) {
}
}
uVar9 = uVar9 + lVar4 + (ulong)(iVar1 * 9 + 0x49U >> 6) + 1;
}
}
Message::MaybeComputeUnknownFieldsSize((Message *)this,uVar9,(CachedSize *)(this + 0x14));
return;
}
| |
54,145 | my_strndup | eloqsql/mysys/my_malloc.c | char *my_strndup(PSI_memory_key key, const char *from, size_t length, myf my_flags)
{
char *ptr;
DBUG_ENTER("my_strndup");
if ((ptr= (char*) my_malloc(key, length+1, my_flags)))
{
memcpy(ptr, from, length);
ptr[length]= 0;
}
DBUG_RETURN(ptr);
} | O3 | c | my_strndup:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x1(%rdx), %rsi
movq %rcx, %rdx
callq 0xa0c8d
movq %rax, %r15
testq %rax, %rax
je 0xa0fdb
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x29080
movb $0x0, (%r15,%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
| my_strndup:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdx
mov r14, rsi
lea rsi, [rdx+1]
mov rdx, rcx
call my_malloc
mov r15, rax
test rax, rax
jz short loc_A0FDB
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call _memcpy
mov byte ptr [r15+rbx], 0
loc_A0FDB:
mov rax, r15
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long my_strndup(unsigned int a1, long long a2, long long a3, int a4)
{
long long v5; // rax
long long v6; // r15
v5 = my_malloc(a1, (const char *)(a3 + 1), a4);
v6 = v5;
if ( v5 )
{
memcpy(v5, a2, a3);
*(_BYTE *)(v6 + a3) = 0;
}
return v6;
}
| my_strndup:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
LEA RSI,[RDX + 0x1]
MOV RDX,RCX
CALL 0x001a0c8d
MOV R15,RAX
TEST RAX,RAX
JZ 0x001a0fdb
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x00129080
MOV byte ptr [R15 + RBX*0x1],0x0
LAB_001a0fdb:
MOV RAX,R15
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void * my_strndup(int8 param_1,void *param_2,size_t param_3,int8 param_4)
{
void *__dest;
__dest = (void *)my_malloc(param_1,param_3 + 1,param_4);
if (__dest != (void *)0x0) {
memcpy(__dest,param_2,param_3);
*(int1 *)((long)__dest + param_3) = 0;
}
return __dest;
}
| |
54,146 | change_simple_key_cache_param | eloqsql/mysys/mf_keycache.c | static
void change_simple_key_cache_param(SIMPLE_KEY_CACHE_CB *keycache, uint division_limit,
uint age_threshold)
{
DBUG_ENTER("change_simple_key_cache_param");
keycache_pthread_mutex_lock(&keycache->cache_lock);
if (division_limit)
keycache->min_warm_blocks= (keycache->disk_blocks *
division_limit / 100 + 1);
if (age_threshold)
keycache->age_threshold= (keycache->disk_blocks *
age_threshold / 100);
keycache_pthread_mutex_unlock(&keycache->cache_lock);
DBUG_VOID_RETURN;
} | O0 | c | change_simple_key_cache_param:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0xc0, %rdi
leaq 0x6e126(%rip), %rsi # 0x1541ea
movl $0x399, %edx # imm = 0x399
callq 0xe3620
cmpl $0x0, -0xc(%rbp)
je 0xe60f7
movq -0x8(%rbp), %rax
movl 0x48(%rax), %eax
imull -0xc(%rbp), %eax
movl $0x64, %ecx
xorl %edx, %edx
divl %ecx
addl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpl $0x0, -0x10(%rbp)
je 0xe611d
movq -0x8(%rbp), %rax
movl 0x48(%rax), %eax
imull -0x10(%rbp), %eax
movl $0x64, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rdi
addq $0xc0, %rdi
callq 0xe4040
jmp 0xe612f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| change_simple_key_cache_param:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
mov rdi, [rbp+var_8]
add rdi, 0C0h
lea rsi, aWorkspaceLlm4b_36; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 399h
call inline_mysql_mutex_lock_24
cmp [rbp+var_C], 0
jz short loc_E60F7
mov rax, [rbp+var_8]
mov eax, [rax+48h]
imul eax, [rbp+var_C]
mov ecx, 64h ; 'd'
xor edx, edx
div ecx
add eax, 1
mov eax, eax
mov ecx, eax
mov rax, [rbp+var_8]
mov [rax+20h], rcx
loc_E60F7:
cmp [rbp+var_10], 0
jz short loc_E611D
mov rax, [rbp+var_8]
mov eax, [rax+48h]
imul eax, [rbp+var_10]
mov ecx, 64h ; 'd'
xor edx, edx
div ecx
mov eax, eax
mov ecx, eax
mov rax, [rbp+var_8]
mov [rax+28h], rcx
loc_E611D:
mov rdi, [rbp+var_8]
add rdi, 0C0h
call inline_mysql_mutex_unlock_25
jmp short $+2
loc_E612F:
add rsp, 10h
pop rbp
retn
| long long change_simple_key_cache_param(long long a1, int a2, int a3)
{
inline_mysql_mutex_lock_24(a1 + 192, (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c", 0x399u);
if ( a2 )
*(_QWORD *)(a1 + 32) = a2 * *(_DWORD *)(a1 + 72) / 0x64u + 1;
if ( a3 )
*(_QWORD *)(a1 + 40) = a3 * *(_DWORD *)(a1 + 72) / 0x64u;
return inline_mysql_mutex_unlock_25(a1 + 192);
}
| change_simple_key_cache_param:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc0
LEA RSI,[0x2541ea]
MOV EDX,0x399
CALL 0x001e3620
CMP dword ptr [RBP + -0xc],0x0
JZ 0x001e60f7
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x48]
IMUL EAX,dword ptr [RBP + -0xc]
MOV ECX,0x64
XOR EDX,EDX
DIV ECX
ADD EAX,0x1
MOV EAX,EAX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x20],RCX
LAB_001e60f7:
CMP dword ptr [RBP + -0x10],0x0
JZ 0x001e611d
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x48]
IMUL EAX,dword ptr [RBP + -0x10]
MOV ECX,0x64
XOR EDX,EDX
DIV ECX
MOV EAX,EAX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x28],RCX
LAB_001e611d:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc0
CALL 0x001e4040
JMP 0x001e612f
LAB_001e612f:
ADD RSP,0x10
POP RBP
RET
|
void change_simple_key_cache_param(long param_1,int param_2,int param_3)
{
inline_mysql_mutex_lock
(param_1 + 0xc0,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",0x399);
if (param_2 != 0) {
*(ulong *)(param_1 + 0x20) = (ulong)((uint)(*(int *)(param_1 + 0x48) * param_2) / 100 + 1);
}
if (param_3 != 0) {
*(ulong *)(param_1 + 0x28) = (ulong)(uint)(*(int *)(param_1 + 0x48) * param_3) / 100;
}
inline_mysql_mutex_unlock(param_1 + 0xc0);
return;
}
| |
54,147 | js_malloc | bluesky950520[P]quickjs/quickjs.c | void *js_malloc(JSContext *ctx, size_t size)
{
void *ptr;
ptr = js_malloc_rt(ctx->rt, size);
if (unlikely(!ptr)) {
JS_ThrowOutOfMemory(ctx);
return NULL;
}
return ptr;
} | O1 | c | js_malloc:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xed69
testq %rax, %rax
je 0xedfa
popq %rbx
retq
movq %rbx, %rdi
callq 0x1cb63
xorl %eax, %eax
jmp 0xedf8
| js_malloc:
push rbx
mov rbx, rdi
mov rdi, [rdi+18h]
call js_malloc_rt
test rax, rax
jz short loc_EDFA
loc_EDF8:
pop rbx
retn
loc_EDFA:
mov rdi, rbx
call JS_ThrowOutOfMemory
xor eax, eax
jmp short loc_EDF8
| long long js_malloc(long long a1, long long a2)
{
long long result; // rax
result = js_malloc_rt(*(_QWORD *)(a1 + 24), a2);
if ( !result )
{
JS_ThrowOutOfMemory(a1);
return 0LL;
}
return result;
}
| delete_map_weak_ref:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOVSD XMM0,qword ptr [RSI + 0x30]
MOV EAX,dword ptr [RSI + 0x38]
MOVSD qword ptr [RSP],XMM0
CMP EAX,-0x8
JZ 0x0013ee0e
CMP EAX,-0x1
JNZ 0x0013ee62
MOV RAX,qword ptr [RSP]
ADD RAX,0x28
JMP 0x0013ee1f
LAB_0013ee0e:
MOV RAX,qword ptr [RSP]
ADD RAX,0x10
JMP 0x0013ee1f
LAB_0013ee18:
ADD R14,0x8
MOV RAX,R14
LAB_0013ee1f:
MOV R14,qword ptr [RAX]
CMP dword ptr [R14],0x0
JNZ 0x0013ee18
CMP qword ptr [R14 + 0x10],RSI
JNZ 0x0013ee18
MOV RCX,qword ptr [R14 + 0x8]
MOV qword ptr [RAX],RCX
DEC qword ptr [RBX + 0x28]
MOV RDI,R14
CALL qword ptr [RBX + 0x20]
MOV RCX,qword ptr [RBX + 0x10]
MOV RDX,qword ptr [RBX + 0x30]
SUB RDX,RAX
ADD RDX,-0x8
MOV qword ptr [RBX + 0x30],RDX
MOV RDI,qword ptr [RBX + 0x40]
MOV RSI,R14
ADD RSP,0x8
POP RBX
POP R14
JMP RCX
LAB_0013ee62:
CALL 0x00111090
|
void delete_map_weak_ref(long param_1,long param_2)
{
int *piVar1;
int *piVar2;
long lVar3;
if (*(int *)(param_2 + 0x38) == -8) {
piVar2 = (int *)(*(long *)(param_2 + 0x30) + 0x10);
}
else {
if (*(int *)(param_2 + 0x38) != -1) {
/* WARNING: Subroutine does not return */
abort();
}
piVar2 = (int *)(*(long *)(param_2 + 0x30) + 0x28);
}
while ((piVar1 = *(int **)piVar2, *piVar1 != 0 || (*(long *)(piVar1 + 4) != param_2))) {
piVar2 = piVar1 + 2;
}
*(int8 *)piVar2 = *(int8 *)(piVar1 + 2);
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + -1;
lVar3 = (**(code **)(param_1 + 0x20))(piVar1);
lVar3 = (*(long *)(param_1 + 0x30) - lVar3) + -8;
*(long *)(param_1 + 0x30) = lVar3;
/* WARNING: Could not recover jumptable at 0x0013ee60. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(param_1 + 0x10))
(*(int8 *)(param_1 + 0x40),piVar1,lVar3,*(code **)(param_1 + 0x10));
return;
}
| |
54,148 | js_malloc | bluesky950520[P]quickjs/quickjs.c | void *js_malloc(JSContext *ctx, size_t size)
{
void *ptr;
ptr = js_malloc_rt(ctx->rt, size);
if (unlikely(!ptr)) {
JS_ThrowOutOfMemory(ctx);
return NULL;
}
return ptr;
} | O2 | c | js_malloc:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x17079
movq %rax, %r14
testq %rax, %rax
je 0x17237
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x171e0
jmp 0x1722c
| js_malloc:
push r14
push rbx
push rax
mov rbx, rdi
mov rdi, [rdi+18h]
call js_malloc_rt
mov r14, rax
test rax, rax
jz short loc_17237
loc_1722C:
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
loc_17237:
mov rdi, rbx
call JS_ThrowOutOfMemory
jmp short loc_1722C
| long long js_malloc(long long a1, long long a2)
{
int v2; // edx
int v3; // ecx
int v4; // r8d
int v5; // r9d
long long v6; // r14
v6 = js_malloc_rt(*(_QWORD *)(a1 + 24), a2);
if ( !v6 )
JS_ThrowOutOfMemory(a1, a2, v2, v3, v4, v5);
return v6;
}
| js_malloc:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x18]
CALL 0x00117079
MOV R14,RAX
TEST RAX,RAX
JZ 0x00117237
LAB_0011722c:
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_00117237:
MOV RDI,RBX
CALL 0x001171e0
JMP 0x0011722c
|
long js_malloc(long param_1)
{
long lVar1;
lVar1 = js_malloc_rt(*(int8 *)(param_1 + 0x18));
if (lVar1 == 0) {
JS_ThrowOutOfMemory(param_1);
}
return lVar1;
}
| |
54,149 | js_malloc | bluesky950520[P]quickjs/quickjs.c | void *js_malloc(JSContext *ctx, size_t size)
{
void *ptr;
ptr = js_malloc_rt(ctx->rt, size);
if (unlikely(!ptr)) {
JS_ThrowOutOfMemory(ctx);
return NULL;
}
return ptr;
} | O3 | c | js_malloc:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xed88
movq %rax, %r14
testq %rax, %rax
je 0xee35
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x1d44b
jmp 0xee2a
| js_malloc:
push r14
push rbx
push rax
mov rbx, rdi
mov rdi, [rdi+18h]
call js_malloc_rt
mov r14, rax
test rax, rax
jz short loc_EE35
loc_EE2A:
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
loc_EE35:
mov rdi, rbx
call JS_ThrowOutOfMemory
jmp short loc_EE2A
| long long js_malloc(long long a1, long long a2)
{
long long v2; // r14
v2 = js_malloc_rt(*(_QWORD *)(a1 + 24), a2);
if ( !v2 )
JS_ThrowOutOfMemory(a1);
return v2;
}
| js_malloc:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x18]
CALL 0x0010ed88
MOV R14,RAX
TEST RAX,RAX
JZ 0x0010ee35
LAB_0010ee2a:
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_0010ee35:
MOV RDI,RBX
CALL 0x0011d44b
JMP 0x0010ee2a
|
long js_malloc(long param_1)
{
long lVar1;
lVar1 = js_malloc_rt(*(int8 *)(param_1 + 0x18));
if (lVar1 == 0) {
JS_ThrowOutOfMemory(param_1);
}
return lVar1;
}
| |
54,150 | my_mb_wc_euc_jp | eloqsql/strings/ctype-ujis.c | static int
my_mb_wc_euc_jp(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e)
{
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
if ((hi= s[0]) < 0x80) /* ASCII code set: [00..7F] -> [U+0000..U+007F] */
{
*pwc= hi;
return 1;
}
if (hi >= 0xA1 && hi <= 0xFE) /* JIS-X-0208 code set: [A1..FE][A1..FE] */
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
return (*pwc= jisx0208_eucjp_to_unicode[(hi << 8) + s[1]]) ? 2 :
(s[1] < 0xA1 || s[1] > 0xFE) ? MY_CS_ILSEQ : -2;
}
/* JIS-X-0201 HALF WIDTH KATAKANA: [8E][A1..DF] -> [U+FF61..U+FF9F] */
if (hi == 0x8E)
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
if (s[1] < 0xA1 || s[1] > 0xDF)
return MY_CS_ILSEQ;
*pwc= 0xFEC0 + s[1]; /* 0xFFC0 = 0xFF61 - 0xA1 */
return 2;
}
if (hi == 0x8F) /* JIS X 0212 code set: [8F][A1..FE][A1..FE] */
{
if (s + 3 > e)
return MY_CS_TOOSMALL3;
return (*pwc= jisx0212_eucjp_to_unicode[(((int) s[1]) << 8) + s[2]]) ?
3 :
(s[1] < 0xA1 || s[1] > 0xFE || s[2] < 0xA1 || s[2] > 0xFE) ?
MY_CS_ILSEQ : -3;
}
return MY_CS_ILSEQ;
} | O0 | c | my_mb_wc_euc_jp:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0xb3f8a
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0xb41a6
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x80, %eax
jge 0xb3fb2
movslq -0x2c(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xb41a6
cmpl $0xa1, -0x2c(%rbp)
jl 0xb4061
cmpl $0xfe, -0x2c(%rbp)
jg 0xb4061
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0xb3fe6
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0xb41a6
movl -0x2c(%rbp), %eax
shll $0x8, %eax
movq -0x20(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x292400(%rip), %rax # 0x346400
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0xb401b
movl $0x2, %eax
movl %eax, -0x30(%rbp)
jmp 0xb4056
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %ecx
movb $0x1, %al
cmpl $0xa1, %ecx
movb %al, -0x31(%rbp)
jl 0xb4043
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xfe, %eax
setg %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %dl
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb41a6
cmpl $0x8e, -0x2c(%rbp)
jne 0xb40d1
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0xb4084
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0xb41a6
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xa1, %eax
jl 0xb40a2
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xdf, %eax
jle 0xb40ae
movl $0x0, -0x4(%rbp)
jmp 0xb41a6
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
addl $0xfec0, %eax # imm = 0xFEC0
movslq %eax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0xb41a6
cmpl $0x8f, -0x2c(%rbp)
jne 0xb419f
movq -0x20(%rbp), %rax
addq $0x3, %rax
cmpq -0x28(%rbp), %rax
jbe 0xb40f8
movl $0xffffff99, -0x4(%rbp) # imm = 0xFFFFFF99
jmp 0xb41a6
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
shll $0x8, %eax
movq -0x20(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x2b22e9(%rip), %rax # 0x366400
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0xb4132
movl $0x3, %eax
movl %eax, -0x38(%rbp)
jmp 0xb4197
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %ecx
movb $0x1, %al
cmpl $0xa1, %ecx
movb %al, -0x39(%rbp)
jl 0xb4184
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %ecx
movb $0x1, %al
cmpl $0xfe, %ecx
movb %al, -0x39(%rbp)
jg 0xb4184
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %ecx
movb $0x1, %al
cmpl $0xa1, %ecx
movb %al, -0x39(%rbp)
jl 0xb4184
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0xfe, %eax
setg %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %dl
movl $0xfffffffd, %eax # imm = 0xFFFFFFFD
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb41a6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
| my_mb_wc_euc_jp:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_B3F8A
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_B41A6
loc_B3F8A:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
mov [rbp+var_2C], eax
cmp eax, 80h
jge short loc_B3FB2
movsxd rcx, [rbp+var_2C]
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 1
jmp loc_B41A6
loc_B3FB2:
cmp [rbp+var_2C], 0A1h
jl loc_B4061
cmp [rbp+var_2C], 0FEh
jg loc_B4061
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_B3FE6
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_B41A6
loc_B3FE6:
mov eax, [rbp+var_2C]
shl eax, 8
mov rcx, [rbp+var_20]
movzx ecx, byte ptr [rcx+1]
add eax, ecx
movsxd rcx, eax
lea rax, jisx0208_eucjp_to_unicode
movzx eax, word ptr [rax+rcx*2]
mov rcx, [rbp+var_18]
mov [rcx], rax
cmp rax, 0
jz short loc_B401B
mov eax, 2
mov [rbp+var_30], eax
jmp short loc_B4056
loc_B401B:
mov rax, [rbp+var_20]
movzx ecx, byte ptr [rax+1]
mov al, 1
cmp ecx, 0A1h
mov [rbp+var_31], al
jl short loc_B4043
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 0FEh
setnle al
mov [rbp+var_31], al
loc_B4043:
mov dl, [rbp+var_31]
mov eax, 0FFFFFFFEh
xor ecx, ecx
test dl, 1
cmovnz eax, ecx
mov [rbp+var_30], eax
loc_B4056:
mov eax, [rbp+var_30]
mov [rbp+var_4], eax
jmp loc_B41A6
loc_B4061:
cmp [rbp+var_2C], 8Eh
jnz short loc_B40D1
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_B4084
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_B41A6
loc_B4084:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 0A1h
jl short loc_B40A2
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 0DFh
jle short loc_B40AE
loc_B40A2:
mov [rbp+var_4], 0
jmp loc_B41A6
loc_B40AE:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
add eax, 0FEC0h
movsxd rcx, eax
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 2
jmp loc_B41A6
loc_B40D1:
cmp [rbp+var_2C], 8Fh
jnz loc_B419F
mov rax, [rbp+var_20]
add rax, 3
cmp rax, [rbp+var_28]
jbe short loc_B40F8
mov [rbp+var_4], 0FFFFFF99h
jmp loc_B41A6
loc_B40F8:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
shl eax, 8
mov rcx, [rbp+var_20]
movzx ecx, byte ptr [rcx+2]
add eax, ecx
movsxd rcx, eax
lea rax, jisx0212_eucjp_to_unicode
movzx eax, word ptr [rax+rcx*2]
mov rcx, [rbp+var_18]
mov [rcx], rax
cmp rax, 0
jz short loc_B4132
mov eax, 3
mov [rbp+var_38], eax
jmp short loc_B4197
loc_B4132:
mov rax, [rbp+var_20]
movzx ecx, byte ptr [rax+1]
mov al, 1
cmp ecx, 0A1h
mov [rbp+var_39], al
jl short loc_B4184
mov rax, [rbp+var_20]
movzx ecx, byte ptr [rax+1]
mov al, 1
cmp ecx, 0FEh
mov [rbp+var_39], al
jg short loc_B4184
mov rax, [rbp+var_20]
movzx ecx, byte ptr [rax+2]
mov al, 1
cmp ecx, 0A1h
mov [rbp+var_39], al
jl short loc_B4184
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+2]
cmp eax, 0FEh
setnle al
mov [rbp+var_39], al
loc_B4184:
mov dl, [rbp+var_39]
mov eax, 0FFFFFFFDh
xor ecx, ecx
test dl, 1
cmovnz eax, ecx
mov [rbp+var_38], eax
loc_B4197:
mov eax, [rbp+var_38]
mov [rbp+var_4], eax
jmp short loc_B41A6
loc_B419F:
mov [rbp+var_4], 0
loc_B41A6:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_mb_wc_euc_jp(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
long long v4; // rax
unsigned int v5; // eax
long long v6; // rax
unsigned int v7; // eax
bool v9; // [rsp+1h] [rbp-39h]
bool v11; // [rsp+9h] [rbp-31h]
unsigned int v13; // [rsp+Eh] [rbp-2Ch]
if ( (unsigned long long)a3 < a4 )
{
v13 = *a3;
if ( v13 >= 0x80 )
{
if ( *a3 < 0xA1u || *a3 == 255 )
{
if ( v13 == 142 )
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
if ( a3[1] >= 0xA1u && a3[1] <= 0xDFu )
{
*a2 = a3[1] + 65216;
return 2;
}
else
{
return 0;
}
}
else
{
return (unsigned int)-102;
}
}
else if ( v13 == 143 )
{
if ( (unsigned long long)(a3 + 3) <= a4 )
{
v6 = jisx0212_eucjp_to_unicode[256 * a3[1] + a3[2]];
*a2 = v6;
if ( v6 )
{
return 3;
}
else
{
v9 = 1;
if ( a3[1] >= 0xA1u )
{
v9 = 1;
if ( a3[1] != 255 )
{
v9 = 1;
if ( a3[2] >= 0xA1u )
v9 = a3[2] == 255;
}
}
v7 = -3;
if ( v9 )
v7 = 0;
return v7;
}
}
else
{
return (unsigned int)-103;
}
}
else
{
return 0;
}
}
else if ( (unsigned long long)(a3 + 2) <= a4 )
{
v4 = jisx0208_eucjp_to_unicode[a3[1] + (v13 << 8)];
*a2 = v4;
if ( v4 )
{
return 2;
}
else
{
v11 = 1;
if ( a3[1] >= 0xA1u )
v11 = a3[1] == 255;
v5 = -2;
if ( v11 )
v5 = 0;
return v5;
}
}
else
{
return (unsigned int)-102;
}
}
else
{
*a2 = *a3;
return 1;
}
}
else
{
return (unsigned int)-101;
}
}
| my_mb_wc_euc_jp:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x001b3f8a
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x001b41a6
LAB_001b3f8a:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x80
JGE 0x001b3fb2
MOVSXD RCX,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001b41a6
LAB_001b3fb2:
CMP dword ptr [RBP + -0x2c],0xa1
JL 0x001b4061
CMP dword ptr [RBP + -0x2c],0xfe
JG 0x001b4061
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x001b3fe6
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x001b41a6
LAB_001b3fe6:
MOV EAX,dword ptr [RBP + -0x2c]
SHL EAX,0x8
MOV RCX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RCX + 0x1]
ADD EAX,ECX
MOVSXD RCX,EAX
LEA RAX,[0x446400]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JZ 0x001b401b
MOV EAX,0x2
MOV dword ptr [RBP + -0x30],EAX
JMP 0x001b4056
LAB_001b401b:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RAX + 0x1]
MOV AL,0x1
CMP ECX,0xa1
MOV byte ptr [RBP + -0x31],AL
JL 0x001b4043
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xfe
SETG AL
MOV byte ptr [RBP + -0x31],AL
LAB_001b4043:
MOV DL,byte ptr [RBP + -0x31]
MOV EAX,0xfffffffe
XOR ECX,ECX
TEST DL,0x1
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x30],EAX
LAB_001b4056:
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001b41a6
LAB_001b4061:
CMP dword ptr [RBP + -0x2c],0x8e
JNZ 0x001b40d1
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x001b4084
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x001b41a6
LAB_001b4084:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xa1
JL 0x001b40a2
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xdf
JLE 0x001b40ae
LAB_001b40a2:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001b41a6
LAB_001b40ae:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
ADD EAX,0xfec0
MOVSXD RCX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x2
JMP 0x001b41a6
LAB_001b40d1:
CMP dword ptr [RBP + -0x2c],0x8f
JNZ 0x001b419f
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x3
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x001b40f8
MOV dword ptr [RBP + -0x4],0xffffff99
JMP 0x001b41a6
LAB_001b40f8:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
SHL EAX,0x8
MOV RCX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RCX + 0x2]
ADD EAX,ECX
MOVSXD RCX,EAX
LEA RAX,[0x466400]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JZ 0x001b4132
MOV EAX,0x3
MOV dword ptr [RBP + -0x38],EAX
JMP 0x001b4197
LAB_001b4132:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RAX + 0x1]
MOV AL,0x1
CMP ECX,0xa1
MOV byte ptr [RBP + -0x39],AL
JL 0x001b4184
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RAX + 0x1]
MOV AL,0x1
CMP ECX,0xfe
MOV byte ptr [RBP + -0x39],AL
JG 0x001b4184
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RAX + 0x2]
MOV AL,0x1
CMP ECX,0xa1
MOV byte ptr [RBP + -0x39],AL
JL 0x001b4184
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x2]
CMP EAX,0xfe
SETG AL
MOV byte ptr [RBP + -0x39],AL
LAB_001b4184:
MOV DL,byte ptr [RBP + -0x39]
MOV EAX,0xfffffffd
XOR ECX,ECX
TEST DL,0x1
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x38],EAX
LAB_001b4197:
MOV EAX,dword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001b41a6
LAB_001b419f:
MOV dword ptr [RBP + -0x4],0x0
LAB_001b41a6:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_mb_wc_euc_jp(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
ushort uVar1;
bool bVar2;
uint uVar3;
int4 local_40;
int4 local_38;
int4 local_c;
if (param_3 < param_4) {
uVar3 = (uint)*param_3;
if (uVar3 < 0x80) {
*param_2 = (long)(int)uVar3;
local_c = 1;
}
else if ((uVar3 < 0xa1) || (0xfe < uVar3)) {
if (uVar3 == 0x8e) {
if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else if ((param_3[1] < 0xa1) || (0xdf < param_3[1])) {
local_c = 0;
}
else {
*param_2 = (long)(int)(param_3[1] + 0xfec0);
local_c = 2;
}
}
else if (uVar3 == 0x8f) {
if (param_4 < param_3 + 3) {
local_c = 0xffffff99;
}
else {
uVar1 = *(ushort *)
(&jisx0212_eucjp_to_unicode +
(long)(int)((uint)param_3[1] * 0x100 + (uint)param_3[2]) * 2);
*param_2 = (ulong)uVar1;
if ((ulong)uVar1 == 0) {
bVar2 = true;
if (((0xa0 < param_3[1]) && (bVar2 = true, param_3[1] != 0xff)) &&
(bVar2 = true, 0xa0 < param_3[2])) {
bVar2 = 0xfe < param_3[2];
}
local_40 = 0xfffffffd;
if (bVar2) {
local_40 = 0;
}
}
else {
local_40 = 3;
}
local_c = local_40;
}
}
else {
local_c = 0;
}
}
else if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else {
uVar1 = *(ushort *)
(jisx0208_eucjp_to_unicode + (long)(int)(uVar3 * 0x100 + (uint)param_3[1]) * 2);
*param_2 = (ulong)uVar1;
if ((ulong)uVar1 == 0) {
bVar2 = true;
if (0xa0 < param_3[1]) {
bVar2 = 0xfe < param_3[1];
}
local_38 = 0xfffffffe;
if (bVar2) {
local_38 = 0;
}
}
else {
local_38 = 2;
}
local_c = local_38;
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
| |
54,151 | find_collation_data_inheritance_source | eloqsql/mysys/charset.c | static CHARSET_INFO *find_collation_data_inheritance_source(CHARSET_INFO *cs, myf flags)
{
const char *beg, *end;
if (cs->tailoring &&
!strncmp(cs->tailoring, "[import ", 8) &&
(end= strchr(cs->tailoring + 8, ']')) &&
(beg= cs->tailoring + 8) + MY_CS_NAME_SIZE > end)
{
char name[MY_CS_NAME_SIZE + 1];
memcpy(name, beg, end - beg);
name[end - beg]= '\0';
return inheritance_source_by_id(cs, get_collation_number(name,MYF(flags)));
}
return NULL;
} | O0 | c | find_collation_data_inheritance_source:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq -0x40(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x72536
movq -0x40(%rbp), %rax
movq 0x38(%rax), %rdi
leaq 0x5ddbd(%rip), %rsi # 0xd0258
movl $0x8, %edx
callq 0x36220
cmpl $0x0, %eax
jne 0x72536
movq -0x40(%rbp), %rax
movq 0x38(%rax), %rdi
addq $0x8, %rdi
movl $0x5d, %esi
callq 0x364e0
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x72536
movq -0x40(%rbp), %rax
movq 0x38(%rax), %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
addq $0x20, %rax
cmpq -0x58(%rbp), %rax
jbe 0x72536
leaq -0x30(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rax
subq %rax, %rdx
callq 0x360b0
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rcx
subq %rcx, %rax
movb $0x0, -0x30(%rbp,%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x70270
movq -0x60(%rbp), %rdi
movl %eax, %esi
callq 0x726b0
movq %rax, -0x38(%rbp)
jmp 0x7253e
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x72562
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
callq 0x362a0
nopw (%rax,%rax)
| find_collation_data_inheritance_source:
push rbp
mov rbp, rsp
sub rsp, 70h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_40], rdi
mov [rbp+var_48], rsi
mov rax, [rbp+var_40]
cmp qword ptr [rax+38h], 0
jz loc_72536
mov rax, [rbp+var_40]
mov rdi, [rax+38h]
lea rsi, aImport; "[import "
mov edx, 8
call _strncmp
cmp eax, 0
jnz loc_72536
mov rax, [rbp+var_40]
mov rdi, [rax+38h]
add rdi, 8
mov esi, 5Dh ; ']'
call _strchr
mov [rbp+var_58], rax
cmp rax, 0
jz short loc_72536
mov rax, [rbp+var_40]
mov rax, [rax+38h]
add rax, 8
mov [rbp+var_50], rax
add rax, 20h ; ' '
cmp rax, [rbp+var_58]
jbe short loc_72536
lea rdi, [rbp+var_30]
mov rsi, [rbp+var_50]
mov rdx, [rbp+var_58]
mov rax, [rbp+var_50]
sub rdx, rax
call _memcpy
mov rax, [rbp+var_58]
mov rcx, [rbp+var_50]
sub rax, rcx
mov [rbp+rax+var_30], 0
mov rax, [rbp+var_40]
mov [rbp+var_60], rax
lea rdi, [rbp+var_30]
mov rsi, [rbp+var_48]
call get_collation_number
mov rdi, [rbp+var_60]
mov esi, eax
call inheritance_source_by_id
mov [rbp+var_38], rax
jmp short loc_7253E
loc_72536:
mov [rbp+var_38], 0
loc_7253E:
mov rax, [rbp+var_38]
mov [rbp+var_68], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_72562
mov rax, [rbp+var_68]
add rsp, 70h
pop rbp
retn
loc_72562:
call ___stack_chk_fail
| long long find_collation_data_inheritance_source(long long a1, long long a2)
{
unsigned int collation_number; // eax
unsigned long long v4; // [rsp+18h] [rbp-58h]
long long v5; // [rsp+20h] [rbp-50h]
_BYTE v7[40]; // [rsp+40h] [rbp-30h] BYREF
unsigned long long v8; // [rsp+68h] [rbp-8h]
v8 = __readfsqword(0x28u);
if ( !*(_QWORD *)(a1 + 56) )
return 0LL;
if ( (unsigned int)strncmp(*(_QWORD *)(a1 + 56), "[import ", 8LL) )
return 0LL;
v4 = strchr(*(_QWORD *)(a1 + 56) + 8LL, 93LL);
if ( !v4 )
return 0LL;
v5 = *(_QWORD *)(a1 + 56) + 8LL;
if ( *(_QWORD *)(a1 + 56) + 40LL <= v4 )
return 0LL;
memcpy(v7, v5, v4 - v5);
v7[v4 - v5] = 0;
collation_number = get_collation_number((long long)v7, a2);
return inheritance_source_by_id(a1, collation_number);
}
| find_collation_data_inheritance_source:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x40],RDI
MOV qword ptr [RBP + -0x48],RSI
MOV RAX,qword ptr [RBP + -0x40]
CMP qword ptr [RAX + 0x38],0x0
JZ 0x00172536
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RAX + 0x38]
LEA RSI,[0x1d0258]
MOV EDX,0x8
CALL 0x00136220
CMP EAX,0x0
JNZ 0x00172536
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RAX + 0x38]
ADD RDI,0x8
MOV ESI,0x5d
CALL 0x001364e0
MOV qword ptr [RBP + -0x58],RAX
CMP RAX,0x0
JZ 0x00172536
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX + 0x38]
ADD RAX,0x8
MOV qword ptr [RBP + -0x50],RAX
ADD RAX,0x20
CMP RAX,qword ptr [RBP + -0x58]
JBE 0x00172536
LEA RDI,[RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x50]
SUB RDX,RAX
CALL 0x001360b0
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x50]
SUB RAX,RCX
MOV byte ptr [RBP + RAX*0x1 + -0x30],0x0
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x60],RAX
LEA RDI,[RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x48]
CALL 0x00170270
MOV RDI,qword ptr [RBP + -0x60]
MOV ESI,EAX
CALL 0x001726b0
MOV qword ptr [RBP + -0x38],RAX
JMP 0x0017253e
LAB_00172536:
MOV qword ptr [RBP + -0x38],0x0
LAB_0017253e:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00172562
MOV RAX,qword ptr [RBP + -0x68]
ADD RSP,0x70
POP RBP
RET
LAB_00172562:
CALL 0x001362a0
|
int8 find_collation_data_inheritance_source(long param_1,int8 param_2)
{
int iVar1;
int4 uVar2;
char *pcVar3;
void *__src;
long in_FS_OFFSET;
int8 local_40;
char local_38 [40];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (*(long *)(param_1 + 0x38) != 0) {
iVar1 = strncmp(*(char **)(param_1 + 0x38),"[import ",8);
if (iVar1 == 0) {
pcVar3 = strchr((char *)(*(long *)(param_1 + 0x38) + 8),0x5d);
if ((pcVar3 != (char *)0x0) &&
(__src = (void *)(*(long *)(param_1 + 0x38) + 8),
pcVar3 < (char *)(*(long *)(param_1 + 0x38) + 0x28))) {
memcpy(local_38,__src,(long)pcVar3 - (long)__src);
pcVar3[(long)(local_38 + -(long)__src)] = '\0';
uVar2 = get_collation_number(local_38,param_2);
local_40 = inheritance_source_by_id(param_1,uVar2);
goto LAB_0017253e;
}
}
}
local_40 = 0;
LAB_0017253e:
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_40;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
54,152 | ftxui::separatorHSelector(float, float, ftxui::Color, ftxui::Color)::Impl::Render(ftxui::Screen&) | Andrewchistyakov[P]flashcards_lyc/build_O0/_deps/ftxui-src/src/ftxui/dom/separator.cpp | void Render(Screen& screen) override {
if (box_.y_max < box_.y_min) {
return;
}
// This are the two location with an empty demi-cell.
int demi_cell_left = int(left_ * 2.F - 1.F); // NOLINT
int demi_cell_right = int(right_ * 2.F + 2.F); // NOLINT
const int y = box_.y_min;
for (int x = box_.x_min; x <= box_.x_max; ++x) {
Pixel& pixel = screen.PixelAt(x, y);
const int a = (x - box_.x_min) * 2;
const int b = a + 1;
const bool a_empty = demi_cell_left == a || demi_cell_right == a;
const bool b_empty = demi_cell_left == b || demi_cell_right == b;
if (!a_empty && !b_empty) {
pixel.character = "─";
pixel.automerge = true;
} else {
pixel.character = a_empty ? "╶" : "╴"; // NOLINT
pixel.automerge = false;
}
if (demi_cell_left <= a && b <= demi_cell_right) {
pixel.foreground_color = selected_color_;
} else {
pixel.foreground_color = unselected_color_;
}
}
} | O0 | cpp | ftxui::separatorHSelector(float, float, ftxui::Color, ftxui::Color)::Impl::Render(ftxui::Screen&):
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movl 0x58(%rcx), %eax
cmpl 0x54(%rcx), %eax
jge 0x482d5
jmp 0x48447
movq -0x40(%rbp), %rax
movss 0x5c(%rax), %xmm0
addss %xmm0, %xmm0
movss 0x49c86(%rip), %xmm1 # 0x91f70
addss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movl %ecx, -0x14(%rbp)
movss 0x60(%rax), %xmm0
addss %xmm0, %xmm0
movss 0x49c66(%rip), %xmm1 # 0x91f6c
addss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movl %ecx, -0x18(%rbp)
movl 0x54(%rax), %ecx
movl %ecx, -0x1c(%rbp)
movl 0x4c(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x40(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x50(%rcx), %eax
jg 0x48447
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x882f0
movq -0x40(%rbp), %rcx
movq %rax, -0x28(%rbp)
movl -0x20(%rbp), %eax
subl 0x4c(%rcx), %eax
shll %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x14(%rbp), %ecx
movb $0x1, %al
cmpl -0x2c(%rbp), %ecx
movb %al, -0x41(%rbp)
je 0x48371
movl -0x18(%rbp), %eax
cmpl -0x2c(%rbp), %eax
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
movb %al, -0x31(%rbp)
movl -0x14(%rbp), %ecx
movb $0x1, %al
cmpl -0x30(%rbp), %ecx
movb %al, -0x42(%rbp)
je 0x48392
movl -0x18(%rbp), %eax
cmpl -0x30(%rbp), %eax
sete %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
andb $0x1, %al
movb %al, -0x32(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x483ca
testb $0x1, -0x32(%rbp)
jne 0x483ca
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
leaq 0x4985d(%rip), %rsi # 0x91c12
callq 0xd830
movq -0x28(%rbp), %rax
movb (%rax), %cl
andb $0x7f, %cl
orb $-0x80, %cl
movb %cl, (%rax)
jmp 0x48409
testb $0x1, -0x31(%rbp)
je 0x483dd
leaq 0x49b9d(%rip), %rax # 0x91f74
movq %rax, -0x50(%rbp)
jmp 0x483ea
leaq 0x49b94(%rip), %rax # 0x91f78
movq %rax, -0x50(%rbp)
jmp 0x483ea
movq -0x50(%rbp), %rsi
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0xd830
movq -0x28(%rbp), %rax
movb (%rax), %cl
andb $0x7f, %cl
orb $0x0, %cl
movb %cl, (%rax)
movl -0x14(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jg 0x48429
movl -0x30(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x48429
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movl 0x68(%rcx), %ecx
movl %ecx, 0x2c(%rax)
jmp 0x48437
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movl 0x64(%rcx), %ecx
movl %ecx, 0x2c(%rax)
jmp 0x48439
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4831d
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
| _ZZN5ftxui18separatorHSelectorEffNS_5ColorES0_EN4Impl6RenderERNS_6ScreenE:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rcx, [rbp+var_8]
mov [rbp+var_40], rcx
mov eax, [rcx+58h]
cmp eax, [rcx+54h]
jge short loc_482D5
jmp loc_48447
loc_482D5:
mov rax, [rbp+var_40]
movss xmm0, dword ptr [rax+5Ch]
addss xmm0, xmm0
movss xmm1, cs:dword_91F70
addss xmm0, xmm1
cvttss2si ecx, xmm0
mov [rbp+var_14], ecx
movss xmm0, dword ptr [rax+60h]
addss xmm0, xmm0
movss xmm1, cs:flt_91F6C
addss xmm0, xmm1
cvttss2si ecx, xmm0
mov [rbp+var_18], ecx
mov ecx, [rax+54h]
mov [rbp+var_1C], ecx
mov eax, [rax+4Ch]
mov [rbp+var_20], eax
loc_4831D:
mov rcx, [rbp+var_40]
mov eax, [rbp+var_20]
cmp eax, [rcx+50h]
jg loc_48447
mov rdi, [rbp+var_10]; this
mov esi, [rbp+var_20]; int
mov edx, [rbp+var_1C]; int
call _ZN5ftxui6Screen7PixelAtEii; ftxui::Screen::PixelAt(int,int)
mov rcx, [rbp+var_40]
mov [rbp+var_28], rax
mov eax, [rbp+var_20]
sub eax, [rcx+4Ch]
shl eax, 1
mov [rbp+var_2C], eax
mov eax, [rbp+var_2C]
add eax, 1
mov [rbp+var_30], eax
mov ecx, [rbp+var_14]
mov al, 1
cmp ecx, [rbp+var_2C]
mov [rbp+var_41], al
jz short loc_48371
mov eax, [rbp+var_18]
cmp eax, [rbp+var_2C]
setz al
mov [rbp+var_41], al
loc_48371:
mov al, [rbp+var_41]
and al, 1
mov [rbp+var_31], al
mov ecx, [rbp+var_14]
mov al, 1
cmp ecx, [rbp+var_30]
mov [rbp+var_42], al
jz short loc_48392
mov eax, [rbp+var_18]
cmp eax, [rbp+var_30]
setz al
mov [rbp+var_42], al
loc_48392:
mov al, [rbp+var_42]
and al, 1
mov [rbp+var_32], al
test [rbp+var_31], 1
jnz short loc_483CA
test [rbp+var_32], 1
jnz short loc_483CA
mov rdi, [rbp+var_28]
add rdi, 8
lea rsi, unk_91C12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc; std::string::operator=(char const*)
mov rax, [rbp+var_28]
mov cl, [rax]
and cl, 7Fh
or cl, 80h
mov [rax], cl
jmp short loc_48409
loc_483CA:
test [rbp+var_31], 1
jz short loc_483DD
lea rax, unk_91F74
mov [rbp+var_50], rax
jmp short loc_483EA
loc_483DD:
lea rax, unk_91F78
mov [rbp+var_50], rax
jmp short $+2
loc_483EA:
mov rsi, [rbp+var_50]
mov rdi, [rbp+var_28]
add rdi, 8
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc; std::string::operator=(char const*)
mov rax, [rbp+var_28]
mov cl, [rax]
and cl, 7Fh
or cl, 0
mov [rax], cl
loc_48409:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_2C]
jg short loc_48429
mov eax, [rbp+var_30]
cmp eax, [rbp+var_18]
jg short loc_48429
mov rcx, [rbp+var_40]
mov rax, [rbp+var_28]
mov ecx, [rcx+68h]
mov [rax+2Ch], ecx
jmp short loc_48437
loc_48429:
mov rcx, [rbp+var_40]
mov rax, [rbp+var_28]
mov ecx, [rcx+64h]
mov [rax+2Ch], ecx
loc_48437:
jmp short $+2
loc_48439:
mov eax, [rbp+var_20]
add eax, 1
mov [rbp+var_20], eax
jmp loc_4831D
loc_48447:
add rsp, 50h
pop rbp
retn
| long long ftxui::separatorHSelector(float,float,ftxui::Color,ftxui::Color)::Impl::Render(
long long a1,
ftxui::Screen *a2)
{
long long result; // rax
bool v3; // [rsp+Eh] [rbp-42h]
bool v4; // [rsp+Fh] [rbp-41h]
int v5; // [rsp+20h] [rbp-30h]
int v6; // [rsp+24h] [rbp-2Ch]
long long v7; // [rsp+28h] [rbp-28h]
int i; // [rsp+30h] [rbp-20h]
int v9; // [rsp+34h] [rbp-1Ch]
int v10; // [rsp+38h] [rbp-18h]
int v11; // [rsp+3Ch] [rbp-14h]
result = *(unsigned int *)(a1 + 88);
if ( (int)result >= *(_DWORD *)(a1 + 84) )
{
v11 = (int)(float)((float)(*(float *)(a1 + 92) + *(float *)(a1 + 92)) + -1.0);
v10 = (int)(float)((float)(*(float *)(a1 + 96) + *(float *)(a1 + 96)) + 2.0);
v9 = *(_DWORD *)(a1 + 84);
for ( i = *(_DWORD *)(a1 + 76); ; ++i )
{
result = (unsigned int)i;
if ( i > *(_DWORD *)(a1 + 80) )
break;
v7 = ftxui::Screen::PixelAt(a2, i, v9);
v6 = 2 * (i - *(_DWORD *)(a1 + 76));
v5 = v6 + 1;
v4 = 1;
if ( v11 != v6 )
v4 = v10 == v6;
v3 = 1;
if ( v11 != v5 )
v3 = v10 == v5;
if ( v4 || v3 )
{
if ( v4 )
std::string::operator=(v7 + 8, &unk_91F74);
else
std::string::operator=(v7 + 8, &unk_91F78);
*(_BYTE *)v7 &= ~0x80u;
}
else
{
std::string::operator=(v7 + 8, &unk_91C12);
*(_BYTE *)v7 = *(_BYTE *)v7 & 0x7F | 0x80;
}
if ( v11 > v6 || v5 > v10 )
*(_DWORD *)(v7 + 44) = *(_DWORD *)(a1 + 100);
else
*(_DWORD *)(v7 + 44) = *(_DWORD *)(a1 + 104);
}
}
return result;
}
| Screen&):
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RCX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x40],RCX
MOV EAX,dword ptr [RCX + 0x58]
CMP EAX,dword ptr [RCX + 0x54]
JGE 0x001482d5
JMP 0x00148447
LAB_001482d5:
MOV RAX,qword ptr [RBP + -0x40]
MOVSS XMM0,dword ptr [RAX + 0x5c]
ADDSS XMM0,XMM0
MOVSS XMM1,dword ptr [0x00191f70]
ADDSS XMM0,XMM1
CVTTSS2SI ECX,XMM0
MOV dword ptr [RBP + -0x14],ECX
MOVSS XMM0,dword ptr [RAX + 0x60]
ADDSS XMM0,XMM0
MOVSS XMM1,dword ptr [0x00191f6c]
ADDSS XMM0,XMM1
CVTTSS2SI ECX,XMM0
MOV dword ptr [RBP + -0x18],ECX
MOV ECX,dword ptr [RAX + 0x54]
MOV dword ptr [RBP + -0x1c],ECX
MOV EAX,dword ptr [RAX + 0x4c]
MOV dword ptr [RBP + -0x20],EAX
LAB_0014831d:
MOV RCX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RCX + 0x50]
JG 0x00148447
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x1c]
CALL 0x001882f0
MOV RCX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x28],RAX
MOV EAX,dword ptr [RBP + -0x20]
SUB EAX,dword ptr [RCX + 0x4c]
SHL EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x30],EAX
MOV ECX,dword ptr [RBP + -0x14]
MOV AL,0x1
CMP ECX,dword ptr [RBP + -0x2c]
MOV byte ptr [RBP + -0x41],AL
JZ 0x00148371
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x2c]
SETZ AL
MOV byte ptr [RBP + -0x41],AL
LAB_00148371:
MOV AL,byte ptr [RBP + -0x41]
AND AL,0x1
MOV byte ptr [RBP + -0x31],AL
MOV ECX,dword ptr [RBP + -0x14]
MOV AL,0x1
CMP ECX,dword ptr [RBP + -0x30]
MOV byte ptr [RBP + -0x42],AL
JZ 0x00148392
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x30]
SETZ AL
MOV byte ptr [RBP + -0x42],AL
LAB_00148392:
MOV AL,byte ptr [RBP + -0x42]
AND AL,0x1
MOV byte ptr [RBP + -0x32],AL
TEST byte ptr [RBP + -0x31],0x1
JNZ 0x001483ca
TEST byte ptr [RBP + -0x32],0x1
JNZ 0x001483ca
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x8
LEA RSI,[0x191c12]
CALL 0x0010d830
MOV RAX,qword ptr [RBP + -0x28]
MOV CL,byte ptr [RAX]
AND CL,0x7f
OR CL,0x80
MOV byte ptr [RAX],CL
JMP 0x00148409
LAB_001483ca:
TEST byte ptr [RBP + -0x31],0x1
JZ 0x001483dd
LEA RAX,[0x191f74]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x001483ea
LAB_001483dd:
LEA RAX,[0x191f78]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x001483ea
LAB_001483ea:
MOV RSI,qword ptr [RBP + -0x50]
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x8
CALL 0x0010d830
MOV RAX,qword ptr [RBP + -0x28]
MOV CL,byte ptr [RAX]
AND CL,0x7f
OR CL,0x0
MOV byte ptr [RAX],CL
LAB_00148409:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x2c]
JG 0x00148429
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x18]
JG 0x00148429
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RCX + 0x68]
MOV dword ptr [RAX + 0x2c],ECX
JMP 0x00148437
LAB_00148429:
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RCX + 0x64]
MOV dword ptr [RAX + 0x2c],ECX
LAB_00148437:
JMP 0x00148439
LAB_00148439:
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
JMP 0x0014831d
LAB_00148447:
ADD RSP,0x50
POP RBP
RET
|
/* ftxui::separatorHSelector(float, float, ftxui::Color, ftxui::Color)::Impl::Render(ftxui::Screen&)
*/
void ftxui::separatorHSelector(float,float,ftxui::Color,ftxui::Color)::Impl::Render(ftxui::Screen__
(long param_1,Screen *param_2)
{
int iVar1;
int iVar2;
int iVar3;
byte *pbVar4;
int iVar5;
int iVar6;
char *local_58;
bool local_4a;
bool local_49;
int local_28;
if (*(int *)(param_1 + 0x54) <= *(int *)(param_1 + 0x58)) {
iVar5 = (int)(*(float *)(param_1 + 0x5c) + *(float *)(param_1 + 0x5c) + DAT_00191f70);
iVar6 = (int)(*(float *)(param_1 + 0x60) + *(float *)(param_1 + 0x60) + DAT_00191f6c);
iVar1 = *(int *)(param_1 + 0x54);
for (local_28 = *(int *)(param_1 + 0x4c); local_28 <= *(int *)(param_1 + 0x50);
local_28 = local_28 + 1) {
pbVar4 = (byte *)Screen::PixelAt(param_2,local_28,iVar1);
iVar2 = (local_28 - *(int *)(param_1 + 0x4c)) * 2;
iVar3 = iVar2 + 1;
local_49 = iVar5 == iVar2 || iVar6 == iVar2;
local_4a = iVar5 == iVar3 || iVar6 == iVar3;
if ((local_49) || (local_4a)) {
if (iVar5 == iVar2 || iVar6 == iVar2) {
local_58 = &DAT_00191f74;
}
else {
local_58 = &DAT_00191f78;
}
std::__cxx11::string::operator=((string *)(pbVar4 + 8),local_58);
*pbVar4 = *pbVar4 & 0x7f;
}
else {
std::__cxx11::string::operator=((string *)(pbVar4 + 8),&DAT_00191c12);
*pbVar4 = *pbVar4 & 0x7f | 0x80;
}
if ((iVar2 < iVar5) || (iVar6 < iVar3)) {
*(int4 *)(pbVar4 + 0x2c) = *(int4 *)(param_1 + 100);
}
else {
*(int4 *)(pbVar4 + 0x2c) = *(int4 *)(param_1 + 0x68);
}
}
}
return;
}
| |
54,153 | my_setwd | eloqsql/mysys/my_getwd.c | int my_setwd(const char *dir, myf MyFlags)
{
int res;
size_t length;
char *start, *pos;
DBUG_ENTER("my_setwd");
DBUG_PRINT("my",("dir: '%s' MyFlags %lu", dir, MyFlags));
start=(char *) dir;
if (! dir[0] || (dir[0] == FN_LIBCHAR && dir[1] == 0))
dir=FN_ROOTDIR;
if ((res=chdir((char*) dir)) != 0)
{
my_errno=errno;
if (MyFlags & MY_WME)
my_error(EE_SETWD,MYF(ME_BELL),start,errno);
}
else
{
if (test_if_hard_path(start))
{ /* Hard pathname */
pos= strmake(&curr_dir[0],start,(size_t) FN_REFLEN-1);
if (pos[-1] != FN_LIBCHAR)
{
length=(uint) (pos-(char*) curr_dir);
curr_dir[length]=FN_LIBCHAR; /* must end with '/' */
curr_dir[length+1]='\0';
}
}
else
curr_dir[0]='\0'; /* Don't save name */
}
DBUG_RETURN(res);
} | O0 | c | my_setwd:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0xf1642
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0xf166c
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0xf1677
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0xf1677
leaq 0x64f95(%rip), %rax # 0x156608
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2a900
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0xf16d0
callq 0x2a760
movl (%rax), %eax
movl %eax, -0x34(%rbp)
callq 0xf7440
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0xf16ce
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x2a760
movq -0x40(%rbp), %rdx
movl (%rax), %ecx
movl $0x11, %edi
movl $0x4, %esi
movb $0x0, %al
callq 0xf0ef0
jmp 0xf1745
movq -0x28(%rbp), %rdi
callq 0xf1760
cmpl $0x0, %eax
je 0xf1739
movq -0x28(%rbp), %rsi
leaq 0xb92567(%rip), %rdi # 0xc83c50
movl $0x1ff, %edx # imm = 0x1FF
callq 0x14f1e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x2f, %eax
je 0xf1737
movq -0x30(%rbp), %rax
leaq 0xb92541(%rip), %rcx # 0xc83c50
subq %rcx, %rax
movl %eax, %eax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
leaq 0xb9252d(%rip), %rax # 0xc83c50
movb $0x2f, (%rax,%rcx)
movq -0x20(%rbp), %rcx
leaq 0xb9251e(%rip), %rax # 0xc83c50
movb $0x0, 0x1(%rax,%rcx)
jmp 0xf1743
leaq 0xb92510(%rip), %rax # 0xc83c50
movb $0x0, (%rax)
jmp 0xf1745
jmp 0xf1747
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_setwd:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
jmp short $+2
loc_F1642:
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
mov rax, [rbp+var_8]
cmp byte ptr [rax], 0
jz short loc_F166C
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz short loc_F1677
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax+1]
cmp eax, 0
jnz short loc_F1677
loc_F166C:
lea rax, word_156608
mov [rbp+var_8], rax
loc_F1677:
mov rdi, [rbp+var_8]
call _chdir
mov [rbp+var_14], eax
cmp eax, 0
jz short loc_F16D0
call ___errno_location
mov eax, [rax]
mov [rbp+var_34], eax
call _my_thread_var
mov ecx, [rbp+var_34]
mov [rax], ecx
mov rax, [rbp+var_10]
and rax, 10h
cmp rax, 0
jz short loc_F16CE
mov rax, [rbp+var_28]
mov [rbp+var_40], rax
call ___errno_location
mov rdx, [rbp+var_40]
mov ecx, [rax]
mov edi, 11h
mov esi, 4
mov al, 0
call my_error
loc_F16CE:
jmp short loc_F1745
loc_F16D0:
mov rdi, [rbp+var_28]
call test_if_hard_path
cmp eax, 0
jz short loc_F1739
mov rsi, [rbp+var_28]
lea rdi, curr_dir
mov edx, 1FFh
call strmake
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax-1]
cmp eax, 2Fh ; '/'
jz short loc_F1737
mov rax, [rbp+var_30]
lea rcx, curr_dir
sub rax, rcx
mov eax, eax
mov [rbp+var_20], rax
mov rcx, [rbp+var_20]
lea rax, curr_dir
mov byte ptr [rax+rcx], 2Fh ; '/'
mov rcx, [rbp+var_20]
lea rax, curr_dir
mov byte ptr [rax+rcx+1], 0
loc_F1737:
jmp short loc_F1743
loc_F1739:
lea rax, curr_dir
mov byte ptr [rax], 0
loc_F1743:
jmp short $+2
loc_F1745:
jmp short $+2
loc_F1747:
mov eax, [rbp+var_14]
mov [rbp+var_44], eax
mov eax, [rbp+var_44]
add rsp, 50h
pop rbp
retn
| long long my_setwd(__int16 *a1, const char *a2)
{
unsigned int *v2; // rax
int v4; // [rsp+1Ch] [rbp-34h]
long long v5; // [rsp+20h] [rbp-30h]
unsigned int v6; // [rsp+3Ch] [rbp-14h]
__int16 *v7; // [rsp+48h] [rbp-8h]
v7 = a1;
if ( !*(_BYTE *)a1 || *(_BYTE *)a1 == 47 && !*((_BYTE *)a1 + 1) )
v7 = &word_156608;
v6 = chdir(v7);
if ( v6 )
{
v4 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var(v7, a2) = v4;
if ( ((unsigned __int8)a2 & 0x10) != 0 )
{
v2 = (unsigned int *)__errno_location();
my_error(0x11u, 4LL, a1, *v2);
}
}
else if ( (unsigned int)test_if_hard_path(a1) )
{
v5 = strmake(curr_dir, a1, 511LL);
if ( *(_BYTE *)(v5 - 1) != 47 )
{
curr_dir[(unsigned int)(v5 - (_QWORD)curr_dir)] = 47;
curr_dir[(unsigned int)(v5 - (_QWORD)curr_dir) + 1] = 0;
}
}
else
{
curr_dir[0] = 0;
}
return v6;
}
| my_setwd:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x001f1642
LAB_001f1642:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX],0x0
JZ 0x001f166c
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x001f1677
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x0
JNZ 0x001f1677
LAB_001f166c:
LEA RAX,[0x256608]
MOV qword ptr [RBP + -0x8],RAX
LAB_001f1677:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0012a900
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JZ 0x001f16d0
CALL 0x0012a760
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x34],EAX
CALL 0x001f7440
MOV ECX,dword ptr [RBP + -0x34]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x10]
AND RAX,0x10
CMP RAX,0x0
JZ 0x001f16ce
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x40],RAX
CALL 0x0012a760
MOV RDX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RAX]
MOV EDI,0x11
MOV ESI,0x4
MOV AL,0x0
CALL 0x001f0ef0
LAB_001f16ce:
JMP 0x001f1745
LAB_001f16d0:
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x001f1760
CMP EAX,0x0
JZ 0x001f1739
MOV RSI,qword ptr [RBP + -0x28]
LEA RDI,[0xd83c50]
MOV EDX,0x1ff
CALL 0x0024f1e0
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x2f
JZ 0x001f1737
MOV RAX,qword ptr [RBP + -0x30]
LEA RCX,[0xd83c50]
SUB RAX,RCX
MOV EAX,EAX
MOV qword ptr [RBP + -0x20],RAX
MOV RCX,qword ptr [RBP + -0x20]
LEA RAX,[0xd83c50]
MOV byte ptr [RAX + RCX*0x1],0x2f
MOV RCX,qword ptr [RBP + -0x20]
LEA RAX,[0xd83c50]
MOV byte ptr [RAX + RCX*0x1 + 0x1],0x0
LAB_001f1737:
JMP 0x001f1743
LAB_001f1739:
LEA RAX,[0xd83c50]
MOV byte ptr [RAX],0x0
LAB_001f1743:
JMP 0x001f1745
LAB_001f1745:
JMP 0x001f1747
LAB_001f1747:
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x44],EAX
MOV EAX,dword ptr [RBP + -0x44]
ADD RSP,0x50
POP RBP
RET
|
int my_setwd(char *param_1,ulong param_2)
{
int iVar1;
int iVar2;
uint uVar3;
int *piVar4;
long lVar5;
char *local_10;
if ((*param_1 == '\0') || ((local_10 = param_1, *param_1 == '/' && (param_1[1] == '\0')))) {
local_10 = "/";
}
iVar1 = chdir(local_10);
if (iVar1 == 0) {
iVar2 = test_if_hard_path(param_1);
if (iVar2 == 0) {
curr_dir = 0;
}
else {
lVar5 = strmake(&curr_dir,param_1,0x1ff);
if (*(char *)(lVar5 + -1) != '/') {
uVar3 = (int)lVar5 - 0xd83c50;
(&curr_dir)[uVar3] = 0x2f;
(&DAT_00d83c51)[uVar3] = 0;
}
}
}
else {
piVar4 = __errno_location();
iVar2 = *piVar4;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar2;
if ((param_2 & 0x10) != 0) {
piVar4 = __errno_location();
my_error(0x11,4,param_1,*piVar4);
}
}
return iVar1;
}
| |
54,154 | tailoring_append | eloqsql/strings/ctype.c | static int
tailoring_append(MY_XML_PARSER *st,
const char *fmt, size_t len, const char *attr)
{
struct my_cs_file_info *i= (struct my_cs_file_info *) st->user_data;
size_t newlen= i->tailoring_length + len + 64; /* 64 for format */
if (MY_XML_OK == my_charset_file_tailoring_realloc(i, newlen))
{
char *dst= i->tailoring + i->tailoring_length;
sprintf(dst, fmt, (int) len, attr);
i->tailoring_length+= strlen(dst);
return MY_XML_OK;
}
return MY_XML_ERROR;
} | O3 | c | tailoring_append:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r9
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x690(%rdi), %r13
leaq (%rdx,%r13), %rax
addq $0x40, %rax
cmpq %rax, 0x698(%rdi)
jbe 0xd33d3
movq 0x688(%rbx), %rax
jmp 0xd3417
movq %r9, %r14
addq %r15, %r13
movq 0x688(%rbx), %rdi
movq 0x7a8(%rbx), %rax
movq 0x90(%rax), %rax
addq $0x8040, %r13 # imm = 0x8040
movq %r13, 0x698(%rbx)
movq %r13, %rsi
callq *%rax
movq %rax, 0x688(%rbx)
testq %rax, %rax
je 0xd345a
movq 0x690(%rbx), %r13
movq %r14, %r9
addq %rax, %r13
xorl %r14d, %r14d
movq %r13, %rdi
movl $0x1, %esi
movq $-0x1, %rdx
movq %r12, %rcx
movl %r15d, %r8d
xorl %eax, %eax
callq 0x29960
movq %r13, %rdi
callq 0x29340
addq %rax, 0x690(%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %r14d
jmp 0xd3448
| tailoring_append:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r9, rcx
mov r15, rdx
mov r12, rsi
mov rbx, rdi
mov r13, [rdi+690h]
lea rax, [rdx+r13]
add rax, 40h ; '@'
cmp [rdi+698h], rax
jbe short loc_D33D3
mov rax, [rbx+688h]
jmp short loc_D3417
loc_D33D3:
mov r14, r9
add r13, r15
mov rdi, [rbx+688h]
mov rax, [rbx+7A8h]
mov rax, [rax+90h]
add r13, 8040h
mov [rbx+698h], r13
mov rsi, r13
call rax
mov [rbx+688h], rax
test rax, rax
jz short loc_D345A
mov r13, [rbx+690h]
mov r9, r14
loc_D3417:
add r13, rax
xor r14d, r14d
mov rdi, r13
mov esi, 1
mov rdx, 0FFFFFFFFFFFFFFFFh
mov rcx, r12
mov r8d, r15d
xor eax, eax
call ___sprintf_chk
mov rdi, r13
call _strlen
add [rbx+690h], rax
loc_D3448:
mov eax, r14d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_D345A:
mov r14d, 1
jmp short loc_D3448
| long long tailoring_append(_QWORD *a1, const char *a2, long long a3, long long a4)
{
long long v4; // rax
long long v5; // r9
unsigned int v6; // r15d
long long v8; // r13
long long v9; // rax
long long v11; // rdi
long long ( *v12)(long long, long long); // rax
long long v13; // r13
long long v14; // r13
unsigned int v15; // r14d
long long v17; // [rsp-8h] [rbp-30h]
v17 = v4;
v5 = a4;
v6 = a3;
v8 = a1[210];
if ( a1[211] <= (unsigned long long)(a3 + v8 + 64) )
{
v11 = a1[209];
v12 = *(long long ( **)(long long, long long))(a1[245] + 144LL);
v13 = a3 + v8 + 32832;
a1[211] = v13;
v9 = v12(v11, v13);
a1[209] = v9;
if ( !v9 )
return 1;
v8 = a1[210];
v5 = a4;
}
else
{
v9 = a1[209];
}
v14 = v9 + v8;
v15 = 0;
__sprintf_chk(v14, 1LL, -1LL, a2, v6, v5, v17);
a1[210] += strlen(v14);
return v15;
}
| tailoring_append:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R9,RCX
MOV R15,RDX
MOV R12,RSI
MOV RBX,RDI
MOV R13,qword ptr [RDI + 0x690]
LEA RAX,[RDX + R13*0x1]
ADD RAX,0x40
CMP qword ptr [RDI + 0x698],RAX
JBE 0x001d33d3
MOV RAX,qword ptr [RBX + 0x688]
JMP 0x001d3417
LAB_001d33d3:
MOV R14,R9
ADD R13,R15
MOV RDI,qword ptr [RBX + 0x688]
MOV RAX,qword ptr [RBX + 0x7a8]
MOV RAX,qword ptr [RAX + 0x90]
ADD R13,0x8040
MOV qword ptr [RBX + 0x698],R13
MOV RSI,R13
CALL RAX
MOV qword ptr [RBX + 0x688],RAX
TEST RAX,RAX
JZ 0x001d345a
MOV R13,qword ptr [RBX + 0x690]
MOV R9,R14
LAB_001d3417:
ADD R13,RAX
XOR R14D,R14D
MOV RDI,R13
MOV ESI,0x1
MOV RDX,-0x1
MOV RCX,R12
MOV R8D,R15D
XOR EAX,EAX
CALL 0x00129960
MOV RDI,R13
CALL 0x00129340
ADD qword ptr [RBX + 0x690],RAX
LAB_001d3448:
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001d345a:
MOV R14D,0x1
JMP 0x001d3448
|
int8 tailoring_append(long param_1,int8 param_2,ulong param_3,int8 param_4)
{
code *pcVar1;
long lVar2;
size_t sVar3;
long lVar4;
lVar4 = *(long *)(param_1 + 0x690);
if (param_3 + lVar4 + 0x40 < *(ulong *)(param_1 + 0x698)) {
lVar2 = *(long *)(param_1 + 0x688);
}
else {
pcVar1 = *(code **)(*(long *)(param_1 + 0x7a8) + 0x90);
lVar4 = lVar4 + param_3 + 0x8040;
*(long *)(param_1 + 0x698) = lVar4;
lVar2 = (*pcVar1)(*(int8 *)(param_1 + 0x688),lVar4);
*(long *)(param_1 + 0x688) = lVar2;
if (lVar2 == 0) {
return 1;
}
lVar4 = *(long *)(param_1 + 0x690);
}
__sprintf_chk((char *)(lVar4 + lVar2),1,0xffffffffffffffff,param_2,param_3 & 0xffffffff,param_4);
sVar3 = strlen((char *)(lVar4 + lVar2));
*(long *)(param_1 + 0x690) = *(long *)(param_1 + 0x690) + sVar3;
return 0;
}
| |
54,155 | ma_ft_make_key | eloqsql/storage/maria/ma_ft_update.c | MARIA_KEY *_ma_ft_make_key(MARIA_HA *info, MARIA_KEY *key, uint keynr,
uchar *keybuf,
FT_WORD *wptr, my_off_t filepos)
{
uchar buf[HA_FT_MAXBYTELEN+16];
float weight=(float) ((filepos==HA_OFFSET_ERROR) ? 0 : wptr->weight);
DBUG_ENTER("_ma_ft_make_key");
mi_float4store(buf,weight);
int2store(buf+HA_FT_WLEN,wptr->len);
memcpy(buf+HA_FT_WLEN+2,wptr->pos,wptr->len);
/* Can't be spatial so it's ok to call _ma_make_key directly here */
DBUG_RETURN(_ma_make_key(info, key, keynr, keybuf, buf, filepos, 0));
} | O3 | c | ma_ft_make_key:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %r9, %rbx
movq %rcx, %r14
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r13
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
cmpq $-0x1, %r9
je 0x5b9f7
cvtsd2ss 0x10(%r8), %xmm0
movd %xmm0, %eax
jmp 0x5b9f9
xorl %eax, %eax
bswapl %eax
leaq -0x13a(%rbp), %rdi
movl %eax, -0x6(%rdi)
movl 0x8(%r8), %edx
movw %dx, -0x2(%rdi)
movq (%r8), %rsi
movl $0x108, %ecx # imm = 0x108
callq 0x293c0
movq $0x0, (%rsp)
leaq -0x140(%rbp), %r8
movq %r13, %rdi
movq %r12, %rsi
movl %r15d, %edx
movq %r14, %rcx
movq %rbx, %r9
callq 0x3c5c3
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x5ba5e
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29220
| _ma_ft_make_key:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 128h
mov rbx, r9
mov r14, rcx
mov r15d, edx
mov r12, rsi
mov r13, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
cmp r9, 0FFFFFFFFFFFFFFFFh
jz short loc_5B9F7
cvtsd2ss xmm0, qword ptr [r8+10h]
movd eax, xmm0
jmp short loc_5B9F9
loc_5B9F7:
xor eax, eax
loc_5B9F9:
bswap eax
lea rdi, [rbp+var_13A]
mov [rdi-6], eax
mov edx, [r8+8]
mov [rdi-2], dx
mov rsi, [r8]
mov ecx, 108h
call ___memcpy_chk
mov [rsp+150h+var_150], 0
lea r8, [rbp+var_140]
mov rdi, r13
mov rsi, r12
mov edx, r15d
mov rcx, r14
mov r9, rbx
call _ma_make_key
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz short loc_5BA5E
add rsp, 128h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_5BA5E:
call ___stack_chk_fail
| long long ma_ft_make_key(
long long a1,
long long a2,
unsigned int a3,
char *a4,
long long a5,
long long a6,
__m128i a7)
{
unsigned int v10; // eax
long long v11; // rdx
unsigned __int32 v13; // [rsp+10h] [rbp-140h] BYREF
__int16 v14; // [rsp+14h] [rbp-13Ch]
_BYTE v15[266]; // [rsp+16h] [rbp-13Ah] BYREF
unsigned long long v16; // [rsp+120h] [rbp-30h]
v16 = __readfsqword(0x28u);
if ( a6 == -1 )
{
v10 = 0;
}
else
{
*(float *)a7.m128i_i32 = *(double *)(a5 + 16);
v10 = _mm_cvtsi128_si32(a7);
}
v13 = _byteswap_ulong(v10);
v11 = *(unsigned int *)(a5 + 8);
v14 = *(_DWORD *)(a5 + 8);
__memcpy_chk(v15, *(_QWORD *)a5, v11, 264LL);
return ma_make_key(a1, a2, a3, a4, (long long)&v13, a6, 0LL);
}
| _ma_ft_make_key:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x128
MOV RBX,R9
MOV R14,RCX
MOV R15D,EDX
MOV R12,RSI
MOV R13,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
CMP R9,-0x1
JZ 0x0015b9f7
CVTSD2SS XMM0,qword ptr [R8 + 0x10]
MOVD EAX,XMM0
JMP 0x0015b9f9
LAB_0015b9f7:
XOR EAX,EAX
LAB_0015b9f9:
BSWAP EAX
LEA RDI,[RBP + -0x13a]
MOV dword ptr [RDI + -0x6],EAX
MOV EDX,dword ptr [R8 + 0x8]
MOV word ptr [RDI + -0x2],DX
MOV RSI,qword ptr [R8]
MOV ECX,0x108
CALL 0x001293c0
MOV qword ptr [RSP],0x0
LEA R8,[RBP + -0x140]
MOV RDI,R13
MOV RSI,R12
MOV EDX,R15D
MOV RCX,R14
MOV R9,RBX
CALL 0x0013c5c3
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x0015ba5e
ADD RSP,0x128
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0015ba5e:
CALL 0x00129220
|
void _ma_ft_make_key(int8 param_1,int8 param_2,int4 param_3,int8 param_4,
int8 *param_5,long param_6)
{
long in_FS_OFFSET;
float fVar1;
uint local_148;
int2 local_144;
int1 local_142 [266];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
if (param_6 == -1) {
fVar1 = 0.0;
}
else {
fVar1 = (float)(double)param_5[2];
}
local_148 = (uint)fVar1 >> 0x18 | ((uint)fVar1 & 0xff0000) >> 8 | ((uint)fVar1 & 0xff00) << 8 |
(int)fVar1 << 0x18;
local_144 = (int2)*(int4 *)(param_5 + 1);
__memcpy_chk(local_142,*param_5,*(int4 *)(param_5 + 1),0x108);
_ma_make_key(param_1,param_2,param_3,param_4,&local_148,param_6,0);
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
54,156 | unpack_filename | eloqsql/mysys/mf_pack.c | size_t unpack_filename(char * to, const char *from)
{
size_t length, n_length, buff_length;
char buff[FN_REFLEN + 1];
DBUG_ENTER("unpack_filename");
length=dirname_part(buff, from, &buff_length);/* copy & convert dirname */
n_length=unpack_dirname(buff,buff);
if (n_length+strlen(from+length) < FN_REFLEN)
{
(void) strmov(buff+n_length,from+length);
length= system_filename(to,buff); /* Fix to usably filename */
}
else
length= system_filename(to,from); /* Fix to usably filename */
DBUG_RETURN(length);
} | O0 | c | unpack_filename:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp # imm = 0x250
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x218(%rbp)
movq %rsi, -0x220(%rbp)
leaq -0x210(%rbp), %rdi
movq -0x220(%rbp), %rsi
leaq -0x238(%rbp), %rdx
callq 0xe1530
movq %rax, -0x228(%rbp)
leaq -0x210(%rbp), %rdi
leaq -0x210(%rbp), %rsi
callq 0xeb310
movq %rax, -0x230(%rbp)
movq -0x230(%rbp), %rax
movq %rax, -0x240(%rbp)
movq -0x220(%rbp), %rdi
addq -0x228(%rbp), %rdi
callq 0x2a330
movq %rax, %rcx
movq -0x240(%rbp), %rax
addq %rcx, %rax
cmpq $0x200, %rax # imm = 0x200
jae 0xeb6c4
leaq -0x210(%rbp), %rdi
addq -0x230(%rbp), %rdi
movq -0x220(%rbp), %rsi
addq -0x228(%rbp), %rsi
callq 0x2a720
movq -0x218(%rbp), %rdi
leaq -0x210(%rbp), %rsi
callq 0xeb5c0
movq %rax, -0x228(%rbp)
jmp 0xeb6de
movq -0x218(%rbp), %rdi
movq -0x220(%rbp), %rsi
callq 0xeb5c0
movq %rax, -0x228(%rbp)
jmp 0xeb6e0
movq -0x228(%rbp), %rax
movq %rax, -0x248(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xeb710
movq -0x248(%rbp), %rax
addq $0x250, %rsp # imm = 0x250
popq %rbp
retq
callq 0x2a250
nopw %cs:(%rax,%rax)
nop
| unpack_filename:
push rbp
mov rbp, rsp
sub rsp, 250h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_218], rdi
mov [rbp+var_220], rsi
lea rdi, [rbp+var_210]
mov rsi, [rbp+var_220]
lea rdx, [rbp+var_238]
call dirname_part
mov [rbp+var_228], rax
lea rdi, [rbp+var_210]
lea rsi, [rbp+var_210]
call unpack_dirname
mov [rbp+var_230], rax
mov rax, [rbp+var_230]
mov [rbp+var_240], rax
mov rdi, [rbp+var_220]
add rdi, [rbp+var_228]
call _strlen
mov rcx, rax
mov rax, [rbp+var_240]
add rax, rcx
cmp rax, 200h
jnb short loc_EB6C4
lea rdi, [rbp+var_210]
add rdi, [rbp+var_230]
mov rsi, [rbp+var_220]
add rsi, [rbp+var_228]
call _stpcpy
mov rdi, [rbp+var_218]
lea rsi, [rbp+var_210]
call system_filename
mov [rbp+var_228], rax
jmp short loc_EB6DE
loc_EB6C4:
mov rdi, [rbp+var_218]
mov rsi, [rbp+var_220]
call system_filename
mov [rbp+var_228], rax
loc_EB6DE:
jmp short $+2
loc_EB6E0:
mov rax, [rbp+var_228]
mov [rbp+var_248], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_EB710
mov rax, [rbp+var_248]
add rsp, 250h
pop rbp
retn
loc_EB710:
call ___stack_chk_fail
| long long unpack_filename(long long a1, _BYTE *a2)
{
long long v3; // [rsp+10h] [rbp-240h]
long long v4; // [rsp+18h] [rbp-238h] BYREF
long long v5; // [rsp+20h] [rbp-230h]
long long v6; // [rsp+28h] [rbp-228h]
_BYTE *v7; // [rsp+30h] [rbp-220h]
long long v8; // [rsp+38h] [rbp-218h]
_BYTE v9[520]; // [rsp+40h] [rbp-210h] BYREF
unsigned long long v10; // [rsp+248h] [rbp-8h]
v10 = __readfsqword(0x28u);
v8 = a1;
v7 = a2;
v6 = dirname_part((long long)v9, a2, &v4);
v5 = unpack_dirname((long long)v9, v9);
v3 = v5;
if ( (unsigned long long)(strlen(&v7[v6]) + v3) >= 0x200 )
return system_filename(v8, (long long)v7);
stpcpy(&v9[v5], &v7[v6]);
return system_filename(v8, (long long)v9);
}
| unpack_filename:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x250
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x218],RDI
MOV qword ptr [RBP + -0x220],RSI
LEA RDI,[RBP + -0x210]
MOV RSI,qword ptr [RBP + -0x220]
LEA RDX,[RBP + -0x238]
CALL 0x001e1530
MOV qword ptr [RBP + -0x228],RAX
LEA RDI,[RBP + -0x210]
LEA RSI,[RBP + -0x210]
CALL 0x001eb310
MOV qword ptr [RBP + -0x230],RAX
MOV RAX,qword ptr [RBP + -0x230]
MOV qword ptr [RBP + -0x240],RAX
MOV RDI,qword ptr [RBP + -0x220]
ADD RDI,qword ptr [RBP + -0x228]
CALL 0x0012a330
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x240]
ADD RAX,RCX
CMP RAX,0x200
JNC 0x001eb6c4
LEA RDI,[RBP + -0x210]
ADD RDI,qword ptr [RBP + -0x230]
MOV RSI,qword ptr [RBP + -0x220]
ADD RSI,qword ptr [RBP + -0x228]
CALL 0x0012a720
MOV RDI,qword ptr [RBP + -0x218]
LEA RSI,[RBP + -0x210]
CALL 0x001eb5c0
MOV qword ptr [RBP + -0x228],RAX
JMP 0x001eb6de
LAB_001eb6c4:
MOV RDI,qword ptr [RBP + -0x218]
MOV RSI,qword ptr [RBP + -0x220]
CALL 0x001eb5c0
MOV qword ptr [RBP + -0x228],RAX
LAB_001eb6de:
JMP 0x001eb6e0
LAB_001eb6e0:
MOV RAX,qword ptr [RBP + -0x228]
MOV qword ptr [RBP + -0x248],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001eb710
MOV RAX,qword ptr [RBP + -0x248]
ADD RSP,0x250
POP RBP
RET
LAB_001eb710:
CALL 0x0012a250
|
int8 unpack_filename(int8 param_1,long param_2)
{
long lVar1;
size_t sVar2;
long in_FS_OFFSET;
int1 local_240 [8];
long local_238;
long local_230;
long local_228;
int8 local_220;
char local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_228 = param_2;
local_220 = param_1;
local_230 = dirname_part(local_218,param_2,local_240);
lVar1 = unpack_dirname(local_218,local_218);
local_238 = lVar1;
sVar2 = strlen((char *)(local_228 + local_230));
if (lVar1 + sVar2 < 0x200) {
stpcpy(local_218 + local_238,(char *)(local_228 + local_230));
local_230 = system_filename(local_220,local_218);
}
else {
local_230 = system_filename(local_220,local_228);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_230;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
54,157 | JS_FlattenIntoArray | bluesky950520[P]quickjs/quickjs.c | static int64_t JS_FlattenIntoArray(JSContext *ctx, JSValue target,
JSValue source, int64_t sourceLen,
int64_t targetIndex, int depth,
JSValue mapperFunction,
JSValue thisArg)
{
JSValue element;
int64_t sourceIndex, elementLen;
int present, is_array;
if (js_check_stack_overflow(ctx->rt, 0)) {
JS_ThrowStackOverflow(ctx);
return -1;
}
for (sourceIndex = 0; sourceIndex < sourceLen; sourceIndex++) {
present = JS_TryGetPropertyInt64(ctx, source, sourceIndex, &element);
if (present < 0)
return -1;
if (!present)
continue;
if (!JS_IsUndefined(mapperFunction)) {
JSValue args[3] = { element, js_int64(sourceIndex), source };
element = JS_Call(ctx, mapperFunction, thisArg, 3, args);
JS_FreeValue(ctx, args[0]);
JS_FreeValue(ctx, args[1]);
if (JS_IsException(element))
return -1;
}
if (depth > 0) {
is_array = JS_IsArray(ctx, element);
if (is_array < 0)
goto fail;
if (is_array) {
if (js_get_length64(ctx, &elementLen, element) < 0)
goto fail;
targetIndex = JS_FlattenIntoArray(ctx, target, element,
elementLen, targetIndex,
depth - 1,
JS_UNDEFINED, JS_UNDEFINED);
if (targetIndex < 0)
goto fail;
JS_FreeValue(ctx, element);
continue;
}
}
if (targetIndex >= MAX_SAFE_INTEGER) {
JS_ThrowTypeError(ctx, "Array too long");
goto fail;
}
if (JS_DefinePropertyValueInt64(ctx, target, targetIndex, element,
JS_PROP_C_W_E | JS_PROP_THROW) < 0)
return -1;
targetIndex++;
}
return targetIndex;
fail:
JS_FreeValue(ctx, element);
return -1;
} | O2 | c | JS_FlattenIntoArray:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r8, -0x68(%rbp)
movq %rcx, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq %rsi, -0x50(%rbp)
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq %rbp, 0xe8(%rax)
jbe 0x68da3
movq %rbx, %rdi
callq 0x39941
jmp 0x69003
movq %r9, %r13
leaq 0x30(%rbp), %rax
leaq 0x20(%rbp), %rcx
movl 0x18(%rbp), %edx
movq 0x10(%rbp), %r14
movq (%rcx), %rsi
movq %rsi, -0x88(%rbp)
movq 0x8(%rcx), %rcx
movq %rcx, -0x80(%rbp)
movl %ecx, %ecx
movq %rcx, -0x90(%rbp)
movq (%rax), %rcx
movq %rcx, -0x78(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x70(%rbp)
xorl %r12d, %r12d
testq %r9, %r9
cmovleq %r12, %r13
leal -0x1(%rdx), %eax
movl %eax, -0x3c(%rbp)
movq %r13, -0x48(%rbp)
cmpq %r12, %r13
je 0x68fd7
movq %rbx, %rdi
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq %r12, %rcx
leaq -0x38(%rbp), %r8
callq 0x46238
testl %eax, %eax
js 0x69003
je 0x68fcf
cmpl $0x3, -0x90(%rbp)
je 0x68ed0
movups -0x38(%rbp), %xmm0
movaps %xmm0, -0xd0(%rbp)
movq %r12, %rdi
callq 0x245bb
movq %rax, -0xc0(%rbp)
movq %rdx, -0xb8(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0xd0(%rbp), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq -0x78(%rbp), %rcx
movq -0x70(%rbp), %r8
pushq $0x3
popq %r9
callq 0x25a66
movq %rdx, %r15
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq %rbx, %rdi
callq 0x1bbce
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
movq %rbx, %rdi
callq 0x1bbce
cmpl $0x6, %r15d
je 0x69003
movl 0x18(%rbp), %eax
testl %eax, %eax
jle 0x68f93
movq -0x38(%rbp), %r15
movq -0x30(%rbp), %r13
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x258b1
testl %eax, %eax
js 0x68ff5
je 0x68f93
movq %rbx, %rdi
leaq -0x98(%rbp), %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0x207f3
testl %eax, %eax
js 0x68ff5
movq -0x98(%rbp), %r9
andl $0x0, -0xf0(%rbp)
pushq $0x3
popq %rax
movq %rax, -0xe8(%rbp)
andl $0x0, -0xe0(%rbp)
movq %rax, -0xd8(%rbp)
movups -0xe0(%rbp), %xmm0
movups %xmm0, 0x20(%rsp)
movups -0xf0(%rbp), %xmm0
movups %xmm0, 0x10(%rsp)
movl -0x3c(%rbp), %eax
movl %eax, 0x8(%rsp)
movq %r14, (%rsp)
movq %rbx, %rdi
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq %r15, %rcx
movq %r13, %r8
callq 0x68d62
testq %rax, %rax
js 0x68ff5
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x1bbce
jmp 0x68fcb
movabsq $0x1fffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFF
cmpq %rax, %r14
jge 0x68fdc
movq -0x38(%rbp), %r8
movq -0x30(%rbp), %r9
movl $0x4007, (%rsp) # imm = 0x4007
movq %rbx, %rdi
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq %r14, %rcx
callq 0x24567
testl %eax, %eax
js 0x69003
incq %r14
movq -0x48(%rbp), %r13
incq %r12
jmp 0x68df3
movq %r14, %rax
jmp 0x69006
leaq 0x22f7d(%rip), %rsi # 0x8bf60
movq %rbx, %rdi
xorl %eax, %eax
callq 0x201fd
movq -0x38(%rbp), %r15
movq -0x30(%rbp), %r13
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x1bbce
pushq $-0x1
popq %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| JS_FlattenIntoArray:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0F8h
mov [rbp+var_68], r8
mov [rbp+var_60], rcx
mov [rbp+var_58], rdx
mov [rbp+var_50], rsi
mov rbx, rdi
mov rax, [rdi+18h]
cmp [rax+0E8h], rbp
jbe short loc_68DA3
mov rdi, rbx
call JS_ThrowStackOverflow
jmp loc_69003
loc_68DA3:
mov r13, r9
lea rax, [rbp+arg_20]
lea rcx, [rbp+arg_10]
mov edx, [rbp+arg_8]
mov r14, [rbp+arg_0]
mov rsi, [rcx]
mov [rbp+var_88], rsi
mov rcx, [rcx+8]
mov [rbp+var_80], rcx
mov ecx, ecx
mov [rbp+var_90], rcx
mov rcx, [rax]
mov [rbp+var_78], rcx
mov rax, [rax+8]
mov [rbp+var_70], rax
xor r12d, r12d
test r9, r9
cmovle r13, r12
lea eax, [rdx-1]
mov [rbp+var_3C], eax
mov [rbp+var_48], r13
loc_68DF3:
cmp r13, r12
jz loc_68FD7
mov rdi, rbx
mov rsi, [rbp+var_60]
mov rdx, [rbp+var_68]
mov rcx, r12
lea r8, [rbp+var_38]
call JS_TryGetPropertyInt64
test eax, eax
js loc_69003
jz loc_68FCF
cmp dword ptr [rbp+var_90], 3
jz loc_68ED0
movups xmm0, [rbp+var_38]
movaps [rbp+var_D0], xmm0
mov rdi, r12
call js_int64
mov [rbp+var_C0], rax
mov [rbp+var_B8], rdx
mov rax, [rbp+var_60]
mov [rbp+var_B0], rax
mov rax, [rbp+var_68]
mov [rbp+var_A8], rax
lea rax, [rbp+var_D0]
mov [rsp+120h+var_120], rax
mov rdi, rbx
mov rsi, [rbp+var_88]
mov rdx, [rbp+var_80]
mov rcx, [rbp+var_78]
mov r8, [rbp+var_70]
push 3
pop r9
call JS_Call
mov r15, rdx
mov qword ptr [rbp+var_38], rax
mov qword ptr [rbp+var_38+8], rdx
mov rsi, qword ptr [rbp+var_D0]
mov rdx, qword ptr [rbp+var_D0+8]
mov rdi, rbx
call JS_FreeValue
mov rsi, [rbp+var_C0]
mov rdx, [rbp+var_B8]
mov rdi, rbx
call JS_FreeValue
cmp r15d, 6
jz loc_69003
loc_68ED0:
mov eax, [rbp+arg_8]
test eax, eax
jle loc_68F93
mov r15, qword ptr [rbp+var_38]
mov r13, qword ptr [rbp+var_38+8]
mov rdi, rbx
mov rsi, r15
mov rdx, r13
call JS_IsArray
test eax, eax
js loc_68FF5
jz loc_68F93
mov rdi, rbx
lea rsi, [rbp+var_98]
mov rdx, r15
mov rcx, r13
call js_get_length64
test eax, eax
js loc_68FF5
mov r9, [rbp+var_98]
and dword ptr [rbp+var_F0], 0
push 3
pop rax
mov qword ptr [rbp+var_F0+8], rax
and dword ptr [rbp+var_E0], 0
mov qword ptr [rbp+var_E0+8], rax
movups xmm0, [rbp+var_E0]
movups [rsp+120h+var_100], xmm0
movups xmm0, [rbp+var_F0]
movups [rsp+120h+var_110], xmm0
mov eax, [rbp+var_3C]
mov [rsp+120h+var_118], eax
mov [rsp+120h+var_120], r14
mov rdi, rbx
mov rsi, [rbp+var_50]
mov rdx, [rbp+var_58]
mov rcx, r15
mov r8, r13
call JS_FlattenIntoArray
test rax, rax
js short loc_68FF5
mov r14, rax
mov rdi, rbx
mov rsi, r15
mov rdx, r13
call JS_FreeValue
jmp short loc_68FCB
loc_68F93:
mov rax, 1FFFFFFFFFFFFFh
cmp r14, rax
jge short loc_68FDC
mov r8, qword ptr [rbp+var_38]
mov r9, qword ptr [rbp+var_38+8]
mov dword ptr [rsp+120h+var_120], 4007h
mov rdi, rbx
mov rsi, [rbp+var_50]
mov rdx, [rbp+var_58]
mov rcx, r14
call JS_DefinePropertyValueInt64
test eax, eax
js short loc_69003
inc r14
loc_68FCB:
mov r13, [rbp+var_48]
loc_68FCF:
inc r12
jmp loc_68DF3
loc_68FD7:
mov rax, r14
jmp short loc_69006
loc_68FDC:
lea rsi, aArrayTooLong; "Array too long"
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
mov r15, qword ptr [rbp+var_38]
mov r13, qword ptr [rbp+var_38+8]
loc_68FF5:
mov rdi, rbx
mov rsi, r15
mov rdx, r13
call JS_FreeValue
loc_69003:
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_69006:
add rsp, 0F8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long JS_FlattenIntoArray(
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,
long long a15,
int a16,
long long a17,
long long a18,
long long a19,
long long a20)
{
long long v20; // r13
unsigned long long v22; // r12
int PropertyInt64; // eax
long long v24; // rdx
long long v25; // rcx
long long v26; // r8
long long v27; // r9
__m128 v28; // xmm4
__m128 v29; // xmm5
long long v30; // rdx
__m128 v31; // rax
__int32 v32; // r15d
__m128 v33; // kr00_16
int IsArray; // eax
long long v35; // rax
char v37; // [rsp+0h] [rbp-120h]
__m128 v38; // [rsp+30h] [rbp-F0h]
__m128 v39; // [rsp+50h] [rbp-D0h] BYREF
long long v40; // [rsp+60h] [rbp-C0h]
long long v41; // [rsp+68h] [rbp-B8h]
long long v42; // [rsp+70h] [rbp-B0h]
long long v43; // [rsp+78h] [rbp-A8h]
long long v44; // [rsp+88h] [rbp-98h] BYREF
long long v45; // [rsp+90h] [rbp-90h]
long long v46; // [rsp+98h] [rbp-88h]
long long v47; // [rsp+A0h] [rbp-80h]
long long v48; // [rsp+A8h] [rbp-78h]
long long v49; // [rsp+B0h] [rbp-70h]
long long v50; // [rsp+B8h] [rbp-68h]
long long v51; // [rsp+C0h] [rbp-60h]
long long v52; // [rsp+C8h] [rbp-58h]
long long v53; // [rsp+D0h] [rbp-50h]
long long v54; // [rsp+D8h] [rbp-48h]
int v55; // [rsp+E4h] [rbp-3Ch]
__m128 v56; // [rsp+E8h] [rbp-38h] BYREF
long long savedregs; // [rsp+120h] [rbp+0h] BYREF
v50 = a5;
v51 = a4;
v52 = a3;
v53 = a2;
if ( *(_QWORD *)(*(_QWORD *)(a1 + 24) + 232LL) > (unsigned long long)&savedregs )
{
JS_ThrowStackOverflow(a1, a7, a8, a9, a10, a11, a12, a13, a14, a2, a3, a4, a5, a6, v37);
return -1LL;
}
v20 = a6;
v46 = a17;
v47 = a18;
v45 = (unsigned int)a18;
v48 = a19;
v49 = a20;
v22 = 0LL;
if ( a6 <= 0 )
v20 = 0LL;
v55 = a16 - 1;
v54 = v20;
while ( 1 )
{
if ( v20 == v22 )
return a15;
PropertyInt64 = JS_TryGetPropertyInt64(a1, v51, v50, v22, (long long)&v56);
if ( PropertyInt64 < 0 )
return -1LL;
if ( PropertyInt64 )
break;
LABEL_21:
++v22;
}
if ( (_DWORD)v45 != 3 )
{
a7 = v56;
v39 = v56;
v40 = js_int64(v22);
v41 = v30;
v42 = v51;
v43 = v50;
v31.m128_u64[0] = JS_Call(a1, v46, v47, v48, v49, 3, (long long)&v39);
v32 = v31.m128_i32[2];
v56 = v31;
JS_FreeValue(a1, v39.m128_i64[0], v39.m128_i64[1]);
JS_FreeValue(a1, v40, v41);
if ( v32 == 6 )
return -1LL;
}
if ( a16 > 0 )
{
v33 = v56;
IsArray = JS_IsArray(a1, v56.m128_i64[0], v56.m128_i32[2]);
if ( IsArray < 0 )
goto LABEL_24;
if ( IsArray )
{
if ( (int)js_get_length64(a1, &v44, v33.m128_i32[0], v33.m128_i32[2]) < 0 )
goto LABEL_24;
v38.m128_i32[0] = 0;
v38.m128_u64[1] = 3LL;
a7 = v38;
v35 = JS_FlattenIntoArray(a1, v53, v52, v33.m128_i32[0], v33.m128_i32[2], v44, a15, v55, 0, 3);
if ( v35 < 0 )
goto LABEL_24;
a15 = v35;
JS_FreeValue(a1, v33.m128_i64[0], v33.m128_i64[1]);
goto LABEL_20;
}
}
if ( a15 < 0x1FFFFFFFFFFFFFLL )
{
if ( (int)JS_DefinePropertyValueInt64(
a1,
v53,
v52,
a15,
v56.m128_u64[0],
v56.m128_i64[1],
*(double *)a7.m128_u64,
a8,
a9,
a10,
*(double *)v28.m128_u64,
*(double *)v29.m128_u64,
a13,
a14,
16391) < 0 )
return -1LL;
++a15;
LABEL_20:
v20 = v54;
goto LABEL_21;
}
JS_ThrowTypeError(a1, (long long)"Array too long", v24, v25, v26, v27, a7, a8, a9, a10, v28, v29, a13, a14, v37);
v33 = v56;
LABEL_24:
JS_FreeValue(a1, v33.m128_i64[0], v33.m128_i64[1]);
return -1LL;
}
| JS_FlattenIntoArray:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xf8
MOV qword ptr [RBP + -0x68],R8
MOV qword ptr [RBP + -0x60],RCX
MOV qword ptr [RBP + -0x58],RDX
MOV qword ptr [RBP + -0x50],RSI
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x18]
CMP qword ptr [RAX + 0xe8],RBP
JBE 0x00168da3
MOV RDI,RBX
CALL 0x00139941
JMP 0x00169003
LAB_00168da3:
MOV R13,R9
LEA RAX,[RBP + 0x30]
LEA RCX,[RBP + 0x20]
MOV EDX,dword ptr [RBP + 0x18]
MOV R14,qword ptr [RBP + 0x10]
MOV RSI,qword ptr [RCX]
MOV qword ptr [RBP + -0x88],RSI
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RBP + -0x80],RCX
MOV ECX,ECX
MOV qword ptr [RBP + -0x90],RCX
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBP + -0x78],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x70],RAX
XOR R12D,R12D
TEST R9,R9
CMOVLE R13,R12
LEA EAX,[RDX + -0x1]
MOV dword ptr [RBP + -0x3c],EAX
MOV qword ptr [RBP + -0x48],R13
LAB_00168df3:
CMP R13,R12
JZ 0x00168fd7
MOV RDI,RBX
MOV RSI,qword ptr [RBP + -0x60]
MOV RDX,qword ptr [RBP + -0x68]
MOV RCX,R12
LEA R8,[RBP + -0x38]
CALL 0x00146238
TEST EAX,EAX
JS 0x00169003
JZ 0x00168fcf
CMP dword ptr [RBP + -0x90],0x3
JZ 0x00168ed0
MOVUPS XMM0,xmmword ptr [RBP + -0x38]
MOVAPS xmmword ptr [RBP + -0xd0],XMM0
MOV RDI,R12
CALL 0x001245bb
MOV qword ptr [RBP + -0xc0],RAX
MOV qword ptr [RBP + -0xb8],RDX
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0xb0],RAX
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0xa8],RAX
LEA RAX,[RBP + -0xd0]
MOV qword ptr [RSP],RAX
MOV RDI,RBX
MOV RSI,qword ptr [RBP + -0x88]
MOV RDX,qword ptr [RBP + -0x80]
MOV RCX,qword ptr [RBP + -0x78]
MOV R8,qword ptr [RBP + -0x70]
PUSH 0x3
POP R9
CALL 0x00125a66
MOV R15,RDX
MOV qword ptr [RBP + -0x38],RAX
MOV qword ptr [RBP + -0x30],RDX
MOV RSI,qword ptr [RBP + -0xd0]
MOV RDX,qword ptr [RBP + -0xc8]
MOV RDI,RBX
CALL 0x0011bbce
MOV RSI,qword ptr [RBP + -0xc0]
MOV RDX,qword ptr [RBP + -0xb8]
MOV RDI,RBX
CALL 0x0011bbce
CMP R15D,0x6
JZ 0x00169003
LAB_00168ed0:
MOV EAX,dword ptr [RBP + 0x18]
TEST EAX,EAX
JLE 0x00168f93
MOV R15,qword ptr [RBP + -0x38]
MOV R13,qword ptr [RBP + -0x30]
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R13
CALL 0x001258b1
TEST EAX,EAX
JS 0x00168ff5
JZ 0x00168f93
MOV RDI,RBX
LEA RSI,[RBP + -0x98]
MOV RDX,R15
MOV RCX,R13
CALL 0x001207f3
TEST EAX,EAX
JS 0x00168ff5
MOV R9,qword ptr [RBP + -0x98]
AND dword ptr [RBP + -0xf0],0x0
PUSH 0x3
POP RAX
MOV qword ptr [RBP + -0xe8],RAX
AND dword ptr [RBP + -0xe0],0x0
MOV qword ptr [RBP + -0xd8],RAX
MOVUPS XMM0,xmmword ptr [RBP + -0xe0]
MOVUPS xmmword ptr [RSP + 0x20],XMM0
MOVUPS XMM0,xmmword ptr [RBP + -0xf0]
MOVUPS xmmword ptr [RSP + 0x10],XMM0
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RSP + 0x8],EAX
MOV qword ptr [RSP],R14
MOV RDI,RBX
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x58]
MOV RCX,R15
MOV R8,R13
CALL 0x00168d62
TEST RAX,RAX
JS 0x00168ff5
MOV R14,RAX
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R13
CALL 0x0011bbce
JMP 0x00168fcb
LAB_00168f93:
MOV RAX,0x1fffffffffffff
CMP R14,RAX
JGE 0x00168fdc
MOV R8,qword ptr [RBP + -0x38]
MOV R9,qword ptr [RBP + -0x30]
MOV dword ptr [RSP],0x4007
MOV RDI,RBX
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x58]
MOV RCX,R14
CALL 0x00124567
TEST EAX,EAX
JS 0x00169003
INC R14
LAB_00168fcb:
MOV R13,qword ptr [RBP + -0x48]
LAB_00168fcf:
INC R12
JMP 0x00168df3
LAB_00168fd7:
MOV RAX,R14
JMP 0x00169006
LAB_00168fdc:
LEA RSI,[0x18bf60]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x001201fd
MOV R15,qword ptr [RBP + -0x38]
MOV R13,qword ptr [RBP + -0x30]
LAB_00168ff5:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R13
CALL 0x0011bbce
LAB_00169003:
PUSH -0x1
POP RAX
LAB_00169006:
ADD RSP,0xf8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long JS_FlattenIntoArray(long param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,long param_6,long param_7,int param_8,int8 param_9,
ulong param_10,int8 param_11,int8 param_12)
{
int8 uVar1;
int8 uVar2;
int iVar3;
long lVar4;
int1 auVar5 [16];
int1 auVar6 [16];
long in_stack_fffffffffffffed8;
int4 *puVar7;
int4 uVar8;
uint uStack_e4;
int4 local_d8;
int4 uStack_d4;
int4 uStack_d0;
int4 uStack_cc;
int1 local_c8 [16];
int8 local_b8;
int8 local_b0;
int8 local_a0;
ulong local_98;
int8 local_90;
ulong local_88;
int8 local_80;
int8 local_78;
int8 local_70;
int8 local_68;
int8 local_60;
int8 local_58;
long local_50;
int local_44;
int1 local_40 [16];
local_70 = param_5;
local_68 = param_4;
local_60 = param_3;
local_58 = param_2;
if (&stack0xfffffffffffffff8 < *(int1 **)(*(long *)(param_1 + 0x18) + 0xe8)) {
JS_ThrowStackOverflow(param_1);
LAB_00169003:
param_7 = -1;
}
else {
local_90 = param_9;
local_88 = param_10;
local_98 = param_10 & 0xffffffff;
local_80 = param_11;
local_78 = param_12;
lVar4 = 0;
if (param_6 < 1) {
param_6 = lVar4;
}
local_44 = param_8 + -1;
local_50 = param_6;
for (; param_6 != lVar4; lVar4 = lVar4 + 1) {
iVar3 = JS_TryGetPropertyInt64(param_1,local_68,local_70,lVar4,local_40);
uVar8 = (int4)((ulong)in_stack_fffffffffffffed8 >> 0x20);
if (iVar3 < 0) goto LAB_00169003;
if (iVar3 != 0) {
auVar5 = local_40;
if ((int)local_98 != 3) {
local_d8 = local_40._0_4_;
uStack_d4 = local_40._4_4_;
uStack_d0 = local_40._8_4_;
uStack_cc = local_40._12_4_;
auVar5 = js_int64(lVar4);
local_b8 = local_68;
local_b0 = local_70;
puVar7 = &local_d8;
local_c8 = auVar5;
auVar6 = JS_Call(param_1,local_90,local_88,local_80,local_78,3,puVar7);
uVar8 = (int4)((ulong)puVar7 >> 0x20);
local_40 = auVar6;
JS_FreeValue(param_1,CONCAT44(uStack_d4,local_d8),CONCAT44(uStack_cc,uStack_d0));
JS_FreeValue(param_1,local_c8._0_8_,local_c8._8_8_);
auVar5 = local_40;
if (auVar6._8_4_ == 6) goto LAB_00169003;
}
local_40._8_8_ = auVar5._8_8_;
uVar2 = local_40._8_8_;
local_40._0_8_ = auVar5._0_8_;
uVar1 = local_40._0_8_;
auVar6 = auVar5;
if (param_8 < 1) {
LAB_00168f93:
local_40._8_8_ = auVar6._8_8_;
local_40._0_8_ = auVar6._0_8_;
if (param_7 < 0x1fffffffffffff) {
in_stack_fffffffffffffed8 = CONCAT44(uVar8,0x4007);
iVar3 = JS_DefinePropertyValueInt64
(param_1,local_58,local_60,param_7,local_40._0_8_,local_40._8_8_,
in_stack_fffffffffffffed8);
local_40 = auVar6;
if (-1 < iVar3) {
param_7 = param_7 + 1;
param_6 = local_50;
goto LAB_00168fcf;
}
goto LAB_00169003;
}
local_40 = auVar6;
JS_ThrowTypeError(param_1,"Array too long");
auVar5 = local_40;
}
else {
iVar3 = JS_IsArray(param_1,local_40._0_8_,local_40._8_8_);
local_40 = auVar6;
if (-1 < iVar3) {
auVar6 = local_40;
if (iVar3 == 0) goto LAB_00168f93;
iVar3 = js_get_length64(param_1,&local_a0,uVar1,uVar2);
if (-1 < iVar3) {
in_stack_fffffffffffffed8 = param_7;
param_7 = JS_FlattenIntoArray(param_1,local_58,local_60,uVar1,uVar2,local_a0,param_7,
local_44,0,3,(ulong)uStack_e4 << 0x20,3);
if (-1 < param_7) {
JS_FreeValue(param_1,uVar1,uVar2);
param_6 = local_50;
goto LAB_00168fcf;
}
}
}
}
JS_FreeValue(param_1,auVar5._0_8_,auVar5._8_8_);
goto LAB_00169003;
}
LAB_00168fcf:
}
}
return param_7;
}
| |
54,158 | js_object___lookupGetter__ | bluesky950520[P]quickjs/quickjs.c | static JSValue js_object___lookupGetter__(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int setter)
{
JSValue obj, res = JS_EXCEPTION;
JSAtom prop = JS_ATOM_NULL;
JSPropertyDescriptor desc;
int has_prop;
obj = JS_ToObject(ctx, this_val);
if (JS_IsException(obj))
goto exception;
prop = JS_ValueToAtom(ctx, argv[0]);
if (unlikely(prop == JS_ATOM_NULL))
goto exception;
for (;;) {
has_prop = JS_GetOwnPropertyInternal(ctx, &desc, JS_VALUE_GET_OBJ(obj), prop);
if (has_prop < 0)
goto exception;
if (has_prop) {
if (desc.flags & JS_PROP_GETSET)
res = js_dup(setter ? desc.setter : desc.getter);
else
res = JS_UNDEFINED;
js_free_desc(ctx, &desc);
break;
}
obj = JS_GetPrototypeFree(ctx, obj);
if (JS_IsException(obj))
goto exception;
if (JS_IsNull(obj)) {
res = JS_UNDEFINED;
break;
}
/* avoid infinite loop (possible with proxies) */
if (js_poll_interrupts(ctx))
goto exception;
}
exception:
JS_FreeAtom(ctx, prop);
JS_FreeValue(ctx, obj);
return res;
} | O1 | c | js_object___lookupGetter__:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r9d, 0x14(%rsp)
movq %r8, %r12
movq %rdi, %rbx
callq 0x261c9
movq %rdx, %r15
movq %rax, 0x8(%rsp)
pushq $0x6
popq %rax
movq %rax, (%rsp)
cmpl $0x6, %r15d
jne 0x124c1
xorl %r12d, %r12d
jmp 0x12596
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x2347f
testl %eax, %eax
je 0x124b9
movl %eax, %r12d
movq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
movl %eax, %ecx
callq 0x22fc5
testl %eax, %eax
js 0x12596
testl %eax, %eax
jne 0x12576
movq 0x8(%rsp), %rbp
movq %rbx, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x21c8b
movq %rax, %r13
movq %rdx, %r14
movq 0x18(%rbx), %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x1ccb2
movq %r14, %r15
movq %r13, 0x8(%rsp)
cmpl $0x2, %r14d
je 0x1258f
cmpl $0x6, %r14d
je 0x125d3
movl 0x1d8(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x1d8(%rbx)
cmpl $0x1, %eax
jle 0x12568
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
leaq 0x20(%rsp), %rsi
movl %r12d, %ecx
callq 0x22fc5
testl %eax, %eax
jns 0x124f5
jmp 0x125da
movq %rbx, %rdi
callq 0x3c8ce
testl %eax, %eax
je 0x1254d
jmp 0x125da
testb $0x10, 0x20(%rsp)
jne 0x125e1
pushq $0x3
popq %rax
movq %rax, (%rsp)
xorl %r13d, %r13d
xorl %r14d, %r14d
jmp 0x1262d
pushq $0x3
popq %rax
movq %rax, (%rsp)
xorl %eax, %eax
xorl %r14d, %r14d
orq %r14, %rax
movq %rbx, %rdi
movl %r12d, %esi
movq %rax, %r14
callq 0x1fbc4
movq 0x8(%rsp), %rsi
movq 0x18(%rbx), %rdi
movq %r15, %rdx
callq 0x1ccb2
movq %r14, %rax
movq (%rsp), %rdx
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r14d, %eax
movq %rax, (%rsp)
xorl %r14d, %r14d
xorl %eax, %eax
jmp 0x1259b
cmpl $0x0, 0x14(%rsp)
leaq 0x48(%rsp), %rax
leaq 0x50(%rsp), %rcx
leaq 0x38(%rsp), %rdx
leaq 0x40(%rsp), %rsi
cmovneq %rax, %rdx
cmovneq %rcx, %rsi
movq (%rdx), %rax
movq (%rsi), %rcx
movq %rax, 0x18(%rsp)
movq %rcx, (%rsp)
cmpl $-0x9, %ecx
jb 0x1261d
movq 0x18(%rsp), %rcx
incl (%rcx)
movabsq $-0x100000000, %r14 # imm = 0xFFFFFFFF00000000
andq %rax, %r14
movl %eax, %r13d
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x3ccaf
movq %r13, %rax
jmp 0x1259b
| js_object___lookupGetter__:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov [rsp+88h+var_74], r9d
mov r12, r8
mov rbx, rdi
call JS_ToObject
mov r15, rdx
mov [rsp+88h+var_80], rax
push 6
pop rax
mov [rsp+88h+var_88], rax
cmp r15d, 6
jnz short loc_124C1
loc_124B9:
xor r12d, r12d
jmp loc_12596
loc_124C1:
mov rsi, [r12]
mov rdx, [r12+8]
mov rdi, rbx
call JS_ValueToAtom
test eax, eax
jz short loc_124B9
mov r12d, eax
mov rdx, [rsp+88h+var_80]
lea rsi, [rsp+88h+var_68]
mov rdi, rbx
mov ecx, eax
call JS_GetOwnPropertyInternal
test eax, eax
js loc_12596
loc_124F5:
test eax, eax
jnz short loc_12576
mov rbp, [rsp+88h+var_80]
mov rdi, rbx
mov rsi, rbp
mov rdx, r15
call JS_GetPrototype
mov r13, rax
mov r14, rdx
mov rdi, [rbx+18h]
mov rsi, rbp
mov rdx, r15
call JS_FreeValueRT
mov r15, r14
mov [rsp+88h+var_80], r13
cmp r14d, 2
jz short loc_1258F
cmp r14d, 6
jz loc_125D3
mov eax, [rbx+1D8h]
lea ecx, [rax-1]
mov [rbx+1D8h], ecx
cmp eax, 1
jle short loc_12568
loc_1254D:
mov rdx, [rsp+88h+var_80]
mov rdi, rbx
lea rsi, [rsp+88h+var_68]
mov ecx, r12d
call JS_GetOwnPropertyInternal
test eax, eax
jns short loc_124F5
jmp short loc_125DA
loc_12568:
mov rdi, rbx
call __js_poll_interrupts
test eax, eax
jz short loc_1254D
jmp short loc_125DA
loc_12576:
test [rsp+88h+var_68], 10h
jnz short loc_125E1
push 3
pop rax
mov [rsp+88h+var_88], rax
xor r13d, r13d
xor r14d, r14d
jmp loc_1262D
loc_1258F:
push 3
pop rax
mov [rsp+88h+var_88], rax
loc_12596:
xor eax, eax
xor r14d, r14d
loc_1259B:
or rax, r14
mov rdi, rbx
mov esi, r12d
mov r14, rax
call JS_FreeAtom
mov rsi, [rsp+88h+var_80]
mov rdi, [rbx+18h]
mov rdx, r15
call JS_FreeValueRT
mov rax, r14
mov rdx, [rsp+88h+var_88]
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_125D3:
mov eax, r14d
mov [rsp+88h+var_88], rax
loc_125DA:
xor r14d, r14d
xor eax, eax
jmp short loc_1259B
loc_125E1:
cmp [rsp+88h+var_74], 0
lea rax, [rsp+88h+var_40]
lea rcx, [rsp+88h+var_38]
lea rdx, [rsp+88h+var_50]
lea rsi, [rsp+88h+var_48]
cmovnz rdx, rax
cmovnz rsi, rcx
mov rax, [rdx]
mov rcx, [rsi]
mov [rsp+88h+var_70], rax
mov [rsp+88h+var_88], rcx
cmp ecx, 0FFFFFFF7h
jb short loc_1261D
mov rcx, [rsp+88h+var_70]
inc dword ptr [rcx]
loc_1261D:
mov r14, 0FFFFFFFF00000000h
and r14, rax
mov r13d, eax
loc_1262D:
lea rsi, [rsp+88h+var_68]
mov rdi, rbx
call js_free_desc
mov rax, r13
jmp loc_1259B
| unsigned long long js_object___lookupGetter__(
long long a1,
long long a2,
long long a3,
long long a4,
_QWORD *a5,
int a6)
{
long long v7; // rax
long long v8; // rdx
long long v9; // r15
unsigned int v10; // r12d
unsigned int v11; // eax
int OwnPropertyInternal; // eax
long long Prototype; // r13
long long v14; // rdx
long long v15; // r14
int v16; // eax
long long v17; // r13
unsigned long long v18; // r14
long long v19; // rax
unsigned long long v20; // r14
char *v22; // rdx
char *v23; // rsi
unsigned long long v24; // rax
long long v25; // [rsp+8h] [rbp-80h]
_BYTE v27[24]; // [rsp+20h] [rbp-68h] BYREF
char v28; // [rsp+38h] [rbp-50h] BYREF
char v29; // [rsp+40h] [rbp-48h] BYREF
char v30; // [rsp+48h] [rbp-40h] BYREF
char v31; // [rsp+50h] [rbp-38h] BYREF
v7 = JS_ToObject(a1, a2, a3);
v9 = v8;
v25 = v7;
if ( (_DWORD)v8 == 6 || (v11 = JS_ValueToAtom(a1, *a5, a5[1])) == 0 )
{
v10 = 0;
LABEL_15:
v19 = 0LL;
v18 = 0LL;
goto LABEL_16;
}
v10 = v11;
OwnPropertyInternal = JS_GetOwnPropertyInternal(a1, v27, v25, v11);
if ( OwnPropertyInternal < 0 )
goto LABEL_15;
while ( !OwnPropertyInternal )
{
Prototype = JS_GetPrototype(a1, v25, v9);
v15 = v14;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v25);
v9 = v15;
v25 = Prototype;
if ( (_DWORD)v15 == 2 )
goto LABEL_15;
if ( (_DWORD)v15 != 6 )
{
v16 = *(_DWORD *)(a1 + 472);
*(_DWORD *)(a1 + 472) = v16 - 1;
if ( v16 > 1 || !(unsigned int)_js_poll_interrupts(a1) )
{
OwnPropertyInternal = JS_GetOwnPropertyInternal(a1, v27, Prototype, v10);
if ( OwnPropertyInternal >= 0 )
continue;
}
}
v18 = 0LL;
v19 = 0LL;
goto LABEL_16;
}
if ( (v27[0] & 0x10) != 0 )
{
v22 = &v28;
v23 = &v29;
if ( a6 )
{
v22 = &v30;
v23 = &v31;
}
v24 = *(_QWORD *)v22;
if ( (unsigned int)*(_QWORD *)v23 >= 0xFFFFFFF7 )
++**(_DWORD **)v22;
v18 = v24 & 0xFFFFFFFF00000000LL;
v17 = (unsigned int)v24;
}
else
{
v17 = 0LL;
v18 = 0LL;
}
js_free_desc(a1);
v19 = v17;
LABEL_16:
v20 = v18 | v19;
JS_FreeAtom(a1, v10);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v25);
return v20;
}
| js_object___lookupGetter__:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV dword ptr [RSP + 0x14],R9D
MOV R12,R8
MOV RBX,RDI
CALL 0x001261c9
MOV R15,RDX
MOV qword ptr [RSP + 0x8],RAX
PUSH 0x6
POP RAX
MOV qword ptr [RSP],RAX
CMP R15D,0x6
JNZ 0x001124c1
LAB_001124b9:
XOR R12D,R12D
JMP 0x00112596
LAB_001124c1:
MOV RSI,qword ptr [R12]
MOV RDX,qword ptr [R12 + 0x8]
MOV RDI,RBX
CALL 0x0012347f
TEST EAX,EAX
JZ 0x001124b9
MOV R12D,EAX
MOV RDX,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
MOV ECX,EAX
CALL 0x00122fc5
TEST EAX,EAX
JS 0x00112596
LAB_001124f5:
TEST EAX,EAX
JNZ 0x00112576
MOV RBP,qword ptr [RSP + 0x8]
MOV RDI,RBX
MOV RSI,RBP
MOV RDX,R15
CALL 0x00121c8b
MOV R13,RAX
MOV R14,RDX
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,RBP
MOV RDX,R15
CALL 0x0011ccb2
MOV R15,R14
MOV qword ptr [RSP + 0x8],R13
CMP R14D,0x2
JZ 0x0011258f
CMP R14D,0x6
JZ 0x001125d3
MOV EAX,dword ptr [RBX + 0x1d8]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RBX + 0x1d8],ECX
CMP EAX,0x1
JLE 0x00112568
LAB_0011254d:
MOV RDX,qword ptr [RSP + 0x8]
MOV RDI,RBX
LEA RSI,[RSP + 0x20]
MOV ECX,R12D
CALL 0x00122fc5
TEST EAX,EAX
JNS 0x001124f5
JMP 0x001125da
LAB_00112568:
MOV RDI,RBX
CALL 0x0013c8ce
TEST EAX,EAX
JZ 0x0011254d
JMP 0x001125da
LAB_00112576:
TEST byte ptr [RSP + 0x20],0x10
JNZ 0x001125e1
PUSH 0x3
POP RAX
MOV qword ptr [RSP],RAX
XOR R13D,R13D
XOR R14D,R14D
JMP 0x0011262d
LAB_0011258f:
PUSH 0x3
POP RAX
MOV qword ptr [RSP],RAX
LAB_00112596:
XOR EAX,EAX
XOR R14D,R14D
LAB_0011259b:
OR RAX,R14
MOV RDI,RBX
MOV ESI,R12D
MOV R14,RAX
CALL 0x0011fbc4
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RBX + 0x18]
MOV RDX,R15
CALL 0x0011ccb2
MOV RAX,R14
MOV RDX,qword ptr [RSP]
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001125d3:
MOV EAX,R14D
MOV qword ptr [RSP],RAX
LAB_001125da:
XOR R14D,R14D
XOR EAX,EAX
JMP 0x0011259b
LAB_001125e1:
CMP dword ptr [RSP + 0x14],0x0
LEA RAX,[RSP + 0x48]
LEA RCX,[RSP + 0x50]
LEA RDX,[RSP + 0x38]
LEA RSI,[RSP + 0x40]
CMOVNZ RDX,RAX
CMOVNZ RSI,RCX
MOV RAX,qword ptr [RDX]
MOV RCX,qword ptr [RSI]
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP],RCX
CMP ECX,-0x9
JC 0x0011261d
MOV RCX,qword ptr [RSP + 0x18]
INC dword ptr [RCX]
LAB_0011261d:
MOV R14,-0x100000000
AND R14,RAX
MOV R13D,EAX
LAB_0011262d:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x0013ccaf
MOV RAX,R13
JMP 0x0011259b
|
int1 [16] js_object___lookupGetter__(long param_1)
{
int *piVar1;
int8 *puVar2;
int iVar3;
int iVar4;
ulong uVar5;
ulong *puVar6;
int8 *in_R8;
int in_R9D;
ulong uVar7;
int8 uVar8;
int1 auVar9 [16];
int1 auVar10 [16];
ulong local_88;
int8 local_80;
byte local_68 [24];
int8 local_50;
ulong local_48;
int8 local_40;
ulong local_38;
auVar9 = JS_ToObject();
local_88 = 6;
if ((auVar9._8_4_ == 6) || (iVar3 = JS_ValueToAtom(param_1,*in_R8,in_R8[1]), iVar3 == 0)) {
iVar3 = 0;
}
else {
iVar4 = JS_GetOwnPropertyInternal(param_1,local_68,auVar9._0_8_,iVar3);
if (-1 < iVar4) {
while( true ) {
uVar8 = auVar9._8_8_;
local_80 = auVar9._0_8_;
if (iVar4 != 0) {
if ((local_68[0] & 0x10) == 0) {
local_88 = 3;
uVar5 = 0;
uVar7 = 0;
}
else {
puVar6 = &local_48;
puVar2 = &local_50;
if (in_R9D != 0) {
puVar6 = &local_38;
puVar2 = &local_40;
}
piVar1 = (int *)*puVar2;
local_88 = *puVar6;
if (0xfffffff6 < (uint)local_88) {
*piVar1 = *piVar1 + 1;
}
uVar7 = (ulong)piVar1 & 0xffffffff00000000;
uVar5 = (ulong)piVar1 & 0xffffffff;
}
js_free_desc(param_1,local_68);
goto LAB_0011259b;
}
auVar9 = JS_GetPrototype(param_1,local_80,uVar8);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),local_80,uVar8);
if (auVar9._8_4_ == 2) {
local_88 = 3;
goto LAB_00112596;
}
if (auVar9._8_4_ == 6) break;
iVar4 = *(int *)(param_1 + 0x1d8);
*(int *)(param_1 + 0x1d8) = iVar4 + -1;
if (((iVar4 < 2) && (iVar4 = __js_poll_interrupts(param_1), iVar4 != 0)) ||
(iVar4 = JS_GetOwnPropertyInternal(param_1,local_68,auVar9._0_8_,iVar3), iVar4 < 0))
goto LAB_001125da;
}
local_88 = auVar9._8_8_ & 0xffffffff;
LAB_001125da:
uVar7 = 0;
uVar5 = 0;
goto LAB_0011259b;
}
}
LAB_00112596:
uVar5 = 0;
uVar7 = 0;
LAB_0011259b:
local_80 = auVar9._0_8_;
auVar10._0_8_ = uVar5 | uVar7;
JS_FreeAtom(param_1,iVar3);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),local_80,auVar9._8_8_);
auVar10._8_8_ = local_88;
return auVar10;
}
| |
54,159 | js_object___lookupGetter__ | bluesky950520[P]quickjs/quickjs.c | static JSValue js_object___lookupGetter__(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int setter)
{
JSValue obj, res = JS_EXCEPTION;
JSAtom prop = JS_ATOM_NULL;
JSPropertyDescriptor desc;
int has_prop;
obj = JS_ToObject(ctx, this_val);
if (JS_IsException(obj))
goto exception;
prop = JS_ValueToAtom(ctx, argv[0]);
if (unlikely(prop == JS_ATOM_NULL))
goto exception;
for (;;) {
has_prop = JS_GetOwnPropertyInternal(ctx, &desc, JS_VALUE_GET_OBJ(obj), prop);
if (has_prop < 0)
goto exception;
if (has_prop) {
if (desc.flags & JS_PROP_GETSET)
res = js_dup(setter ? desc.setter : desc.getter);
else
res = JS_UNDEFINED;
js_free_desc(ctx, &desc);
break;
}
obj = JS_GetPrototypeFree(ctx, obj);
if (JS_IsException(obj))
goto exception;
if (JS_IsNull(obj)) {
res = JS_UNDEFINED;
break;
}
/* avoid infinite loop (possible with proxies) */
if (js_poll_interrupts(ctx))
goto exception;
}
exception:
JS_FreeAtom(ctx, prop);
JS_FreeValue(ctx, obj);
return res;
} | O3 | c | js_object___lookupGetter__:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %ebp
movq %r8, %r13
movq %rdi, %rbx
callq 0x268d8
movq %rax, %r14
movq %rdx, %r15
pushq $0x6
popq %r12
cmpl $0x6, %r15d
movq %r12, (%rsp)
jne 0x12b89
xorl %r13d, %r13d
jmp 0x12c46
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %rbx, %rdi
callq 0x23ad1
testl %eax, %eax
je 0x12b81
movl %eax, %r13d
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
movl %eax, %ecx
callq 0x237bd
testl %eax, %eax
js 0x12c46
movl %ebp, 0xc(%rsp)
xorl %r12d, %r12d
leaq 0x10(%rsp), %rbp
testl %eax, %eax
jne 0x12c27
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3de50
movq %rax, %r14
movq %rdx, %r15
cmpl $0x2, %r15d
je 0x12c3f
cmpl $0x6, %r15d
je 0x12c92
movl 0x1d8(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x1d8(%rbx)
cmpl $0x1, %eax
jle 0x12c19
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
movl %r13d, %ecx
callq 0x237bd
testl %eax, %eax
jns 0x12bc6
jmp 0x12c49
movq %rbx, %rdi
callq 0x3de9f
testl %eax, %eax
je 0x12c02
jmp 0x12c49
testb $0x10, 0x10(%rsp)
jne 0x12c9b
pushq $0x3
popq %rax
movq %rax, (%rsp)
xorl %r12d, %r12d
xorl %ebp, %ebp
jmp 0x12cdd
pushq $0x3
popq %rax
movq %rax, (%rsp)
xorl %r12d, %r12d
xorl %ebp, %ebp
movq %rbx, %rdi
movl %r13d, %esi
callq 0x202f5
cmpl $-0x9, %r15d
jb 0x12c79
movq 0x18(%rbx), %rdi
movl (%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r14)
cmpl $0x1, %eax
jg 0x12c79
movq %r14, %rsi
movq %r15, %rdx
callq 0x20d90
orq %r12, %rbp
movq %rbp, %rax
movq (%rsp), %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r15d, %eax
movq %rax, (%rsp)
jmp 0x12c49
cmpl $0x0, 0xc(%rsp)
leaq 0x38(%rsp), %rax
leaq 0x40(%rsp), %rcx
leaq 0x28(%rsp), %rdx
leaq 0x30(%rsp), %rsi
cmovneq %rax, %rdx
movq (%rdx), %rax
cmovneq %rcx, %rsi
movq (%rsi), %rcx
movq %rcx, (%rsp)
cmpl $-0x9, %ecx
jb 0x12ccd
incl (%rax)
movabsq $-0x100000000, %rbp # imm = 0xFFFFFFFF00000000
andq %rax, %rbp
movl %eax, %r12d
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x3e21f
jmp 0x12c4b
| js_object___lookupGetter__:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov ebp, r9d
mov r13, r8
mov rbx, rdi
call JS_ToObject
mov r14, rax
mov r15, rdx
push 6
pop r12
cmp r15d, 6
mov [rsp+78h+var_78], r12
jnz short loc_12B89
loc_12B81:
xor r13d, r13d
jmp loc_12C46
loc_12B89:
mov rsi, [r13+0]
mov rdx, [r13+8]
mov rdi, rbx
call JS_ValueToAtom
test eax, eax
jz short loc_12B81
mov r13d, eax
lea rsi, [rsp+78h+var_68]
mov rdi, rbx
mov rdx, r14
mov ecx, eax
call JS_GetOwnPropertyInternal
test eax, eax
js loc_12C46
mov [rsp+78h+var_6C], ebp
xor r12d, r12d
lea rbp, [rsp+78h+var_68]
loc_12BC6:
test eax, eax
jnz short loc_12C27
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call JS_GetPrototypeFree
mov r14, rax
mov r15, rdx
cmp r15d, 2
jz short loc_12C3F
cmp r15d, 6
jz loc_12C92
mov eax, [rbx+1D8h]
lea ecx, [rax-1]
mov [rbx+1D8h], ecx
cmp eax, 1
jle short loc_12C19
loc_12C02:
mov rdi, rbx
mov rsi, rbp
mov rdx, r14
mov ecx, r13d
call JS_GetOwnPropertyInternal
test eax, eax
jns short loc_12BC6
jmp short loc_12C49
loc_12C19:
mov rdi, rbx
call __js_poll_interrupts
test eax, eax
jz short loc_12C02
jmp short loc_12C49
loc_12C27:
test [rsp+78h+var_68], 10h
jnz short loc_12C9B
push 3
pop rax
mov [rsp+78h+var_78], rax
xor r12d, r12d
xor ebp, ebp
jmp loc_12CDD
loc_12C3F:
push 3
pop rax
mov [rsp+78h+var_78], rax
loc_12C46:
xor r12d, r12d
loc_12C49:
xor ebp, ebp
loc_12C4B:
mov rdi, rbx
mov esi, r13d
call JS_FreeAtom
cmp r15d, 0FFFFFFF7h
jb short loc_12C79
mov rdi, [rbx+18h]
mov eax, [r14]
lea ecx, [rax-1]
mov [r14], ecx
cmp eax, 1
jg short loc_12C79
mov rsi, r14
mov rdx, r15
call js_free_value_rt
loc_12C79:
or rbp, r12
mov rax, rbp
mov rdx, [rsp+78h+var_78]
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_12C92:
mov eax, r15d
mov [rsp+78h+var_78], rax
jmp short loc_12C49
loc_12C9B:
cmp [rsp+78h+var_6C], 0
lea rax, [rsp+78h+var_40]
lea rcx, [rsp+78h+var_38]
lea rdx, [rsp+78h+var_50]
lea rsi, [rsp+78h+var_48]
cmovnz rdx, rax
mov rax, [rdx]
cmovnz rsi, rcx
mov rcx, [rsi]
mov [rsp+78h+var_78], rcx
cmp ecx, 0FFFFFFF7h
jb short loc_12CCD
inc dword ptr [rax]
loc_12CCD:
mov rbp, 0FFFFFFFF00000000h
and rbp, rax
mov r12d, eax
loc_12CDD:
lea rsi, [rsp+78h+var_68]
mov rdi, rbx
call js_free_desc
jmp loc_12C4B
| unsigned long long js_object___lookupGetter__(
long long a1,
long long a2,
long long a3,
long long a4,
_QWORD *a5,
int a6)
{
_DWORD *PrototypeFree; // r14
long long v9; // rdx
long long v10; // r15
unsigned int v11; // r13d
unsigned int v12; // eax
int OwnPropertyInternal; // eax
long long v14; // r12
long long v15; // rdx
int v16; // eax
unsigned long long v17; // rbp
long long v18; // rdi
int v19; // eax
char *v21; // rdx
char *v22; // rsi
unsigned long long v23; // rax
_BYTE v24[24]; // [rsp+10h] [rbp-68h] BYREF
char v25; // [rsp+28h] [rbp-50h] BYREF
char v26; // [rsp+30h] [rbp-48h] BYREF
char v27; // [rsp+38h] [rbp-40h] BYREF
char v28; // [rsp+40h] [rbp-38h] BYREF
PrototypeFree = (_DWORD *)JS_ToObject(a1, a2, a3);
v10 = v9;
if ( (_DWORD)v9 == 6 || (v12 = JS_ValueToAtom(a1, *a5, a5[1])) == 0 )
{
v11 = 0;
}
else
{
v11 = v12;
OwnPropertyInternal = JS_GetOwnPropertyInternal(a1, v24, PrototypeFree, v12);
if ( OwnPropertyInternal >= 0 )
{
v14 = 0LL;
while ( !OwnPropertyInternal )
{
PrototypeFree = (_DWORD *)JS_GetPrototypeFree(a1, PrototypeFree, v10);
v10 = v15;
if ( (_DWORD)v15 == 2 )
goto LABEL_16;
if ( (_DWORD)v15 != 6 )
{
v16 = *(_DWORD *)(a1 + 472);
*(_DWORD *)(a1 + 472) = v16 - 1;
if ( v16 > 1 || !(unsigned int)_js_poll_interrupts(a1) )
{
OwnPropertyInternal = JS_GetOwnPropertyInternal(a1, v24, PrototypeFree, v11);
if ( OwnPropertyInternal >= 0 )
continue;
}
}
goto LABEL_17;
}
if ( (v24[0] & 0x10) != 0 )
{
v21 = &v25;
v22 = &v26;
if ( a6 )
v21 = &v27;
v23 = *(_QWORD *)v21;
if ( a6 )
v22 = &v28;
if ( (unsigned int)*(_QWORD *)v22 >= 0xFFFFFFF7 )
++*(_DWORD *)v23;
v17 = v23 & 0xFFFFFFFF00000000LL;
v14 = (unsigned int)v23;
}
else
{
v14 = 0LL;
v17 = 0LL;
}
js_free_desc(a1);
goto LABEL_18;
}
}
LABEL_16:
v14 = 0LL;
LABEL_17:
v17 = 0LL;
LABEL_18:
JS_FreeAtom(a1, v11);
if ( (unsigned int)v10 >= 0xFFFFFFF7 )
{
v18 = *(_QWORD *)(a1 + 24);
v19 = (*PrototypeFree)--;
if ( v19 <= 1 )
js_free_value_rt(v18, PrototypeFree);
}
return v14 | v17;
}
| js_object___lookupGetter__:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV EBP,R9D
MOV R13,R8
MOV RBX,RDI
CALL 0x001268d8
MOV R14,RAX
MOV R15,RDX
PUSH 0x6
POP R12
CMP R15D,0x6
MOV qword ptr [RSP],R12
JNZ 0x00112b89
LAB_00112b81:
XOR R13D,R13D
JMP 0x00112c46
LAB_00112b89:
MOV RSI,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
MOV RDI,RBX
CALL 0x00123ad1
TEST EAX,EAX
JZ 0x00112b81
MOV R13D,EAX
LEA RSI,[RSP + 0x10]
MOV RDI,RBX
MOV RDX,R14
MOV ECX,EAX
CALL 0x001237bd
TEST EAX,EAX
JS 0x00112c46
MOV dword ptr [RSP + 0xc],EBP
XOR R12D,R12D
LEA RBP,[RSP + 0x10]
LAB_00112bc6:
TEST EAX,EAX
JNZ 0x00112c27
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
CALL 0x0013de50
MOV R14,RAX
MOV R15,RDX
CMP R15D,0x2
JZ 0x00112c3f
CMP R15D,0x6
JZ 0x00112c92
MOV EAX,dword ptr [RBX + 0x1d8]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RBX + 0x1d8],ECX
CMP EAX,0x1
JLE 0x00112c19
LAB_00112c02:
MOV RDI,RBX
MOV RSI,RBP
MOV RDX,R14
MOV ECX,R13D
CALL 0x001237bd
TEST EAX,EAX
JNS 0x00112bc6
JMP 0x00112c49
LAB_00112c19:
MOV RDI,RBX
CALL 0x0013de9f
TEST EAX,EAX
JZ 0x00112c02
JMP 0x00112c49
LAB_00112c27:
TEST byte ptr [RSP + 0x10],0x10
JNZ 0x00112c9b
PUSH 0x3
POP RAX
MOV qword ptr [RSP],RAX
XOR R12D,R12D
XOR EBP,EBP
JMP 0x00112cdd
LAB_00112c3f:
PUSH 0x3
POP RAX
MOV qword ptr [RSP],RAX
LAB_00112c46:
XOR R12D,R12D
LAB_00112c49:
XOR EBP,EBP
LAB_00112c4b:
MOV RDI,RBX
MOV ESI,R13D
CALL 0x001202f5
CMP R15D,-0x9
JC 0x00112c79
MOV RDI,qword ptr [RBX + 0x18]
MOV EAX,dword ptr [R14]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R14],ECX
CMP EAX,0x1
JG 0x00112c79
MOV RSI,R14
MOV RDX,R15
CALL 0x00120d90
LAB_00112c79:
OR RBP,R12
MOV RAX,RBP
MOV RDX,qword ptr [RSP]
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00112c92:
MOV EAX,R15D
MOV qword ptr [RSP],RAX
JMP 0x00112c49
LAB_00112c9b:
CMP dword ptr [RSP + 0xc],0x0
LEA RAX,[RSP + 0x38]
LEA RCX,[RSP + 0x40]
LEA RDX,[RSP + 0x28]
LEA RSI,[RSP + 0x30]
CMOVNZ RDX,RAX
MOV RAX,qword ptr [RDX]
CMOVNZ RSI,RCX
MOV RCX,qword ptr [RSI]
MOV qword ptr [RSP],RCX
CMP ECX,-0x9
JC 0x00112ccd
INC dword ptr [RAX]
LAB_00112ccd:
MOV RBP,-0x100000000
AND RBP,RAX
MOV R12D,EAX
LAB_00112cdd:
LEA RSI,[RSP + 0x10]
MOV RDI,RBX
CALL 0x0013e21f
JMP 0x00112c4b
|
int1 [16] js_object___lookupGetter__(long param_1)
{
int8 uVar1;
int iVar2;
int iVar3;
int8 *puVar4;
ulong uVar5;
ulong *puVar6;
int8 *in_R8;
int in_R9D;
ulong uVar7;
int *piVar8;
int1 auVar9 [16];
ulong local_78;
byte local_68 [24];
int8 local_50;
ulong local_48;
int8 local_40;
ulong local_38;
auVar9 = JS_ToObject();
local_78 = 6;
if ((auVar9._8_4_ == 6) || (iVar2 = JS_ValueToAtom(param_1,*in_R8,in_R8[1]), iVar2 == 0)) {
iVar2 = 0;
}
else {
iVar3 = JS_GetOwnPropertyInternal(param_1,local_68,auVar9._0_8_,iVar2);
if (-1 < iVar3) {
while( true ) {
if (iVar3 != 0) {
if ((local_68[0] & 0x10) == 0) {
local_78 = 3;
uVar7 = 0;
uVar5 = 0;
}
else {
puVar4 = &local_50;
if (in_R9D != 0) {
puVar4 = &local_40;
}
piVar8 = (int *)*puVar4;
puVar6 = &local_48;
if (in_R9D != 0) {
puVar6 = &local_38;
}
local_78 = *puVar6;
if (0xfffffff6 < (uint)local_78) {
*piVar8 = *piVar8 + 1;
}
uVar5 = (ulong)piVar8 & 0xffffffff00000000;
uVar7 = (ulong)piVar8 & 0xffffffff;
}
js_free_desc(param_1,local_68);
goto LAB_00112c4b;
}
auVar9 = JS_GetPrototypeFree(param_1,auVar9._0_8_,auVar9._8_8_);
if (auVar9._8_4_ == 2) break;
if (auVar9._8_4_ == 6) {
local_78 = auVar9._8_8_ & 0xffffffff;
goto LAB_00112c49;
}
iVar3 = *(int *)(param_1 + 0x1d8);
*(int *)(param_1 + 0x1d8) = iVar3 + -1;
if (((iVar3 < 2) && (iVar3 = __js_poll_interrupts(param_1), iVar3 != 0)) ||
(iVar3 = JS_GetOwnPropertyInternal(param_1,local_68,auVar9._0_8_,iVar2), iVar3 < 0))
goto LAB_00112c49;
}
local_78 = 3;
}
}
LAB_00112c49:
uVar7 = 0;
uVar5 = 0;
LAB_00112c4b:
piVar8 = auVar9._0_8_;
JS_FreeAtom(param_1,iVar2);
if (0xfffffff6 < auVar9._8_4_) {
uVar1 = *(int8 *)(param_1 + 0x18);
iVar2 = *piVar8;
*piVar8 = iVar2 + -1;
if (iVar2 < 2) {
js_free_value_rt(uVar1,piVar8,auVar9._8_8_);
}
}
auVar9._8_8_ = local_78;
auVar9._0_8_ = uVar5 | uVar7;
return auVar9;
}
| |
54,160 | facebook::yoga::StyleValuePool::StyleValuePool(facebook::yoga::StyleValuePool const&) | yoga-mod/yoga/../yoga/style/StyleValuePool.h | void store(StyleValueHandle& handle, StyleLength length) {
if (length.isUndefined()) {
handle.setType(StyleValueHandle::Type::Undefined);
} else if (length.isAuto()) {
handle.setType(StyleValueHandle::Type::Auto);
} else {
auto type = length.isPoints() ? StyleValueHandle::Type::Point
: StyleValueHandle::Type::Percent;
storeValue(handle, length.value().unwrap(), type);
}
} | O0 | c | facebook::yoga::StyleValuePool::StyleValuePool(facebook::yoga::StyleValuePool const&):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0xb4010
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZN8facebook4yoga14StyleValuePoolaSERKS1_:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdi, [rbp+var_8]
mov [rbp+var_18], rdi
mov rsi, [rbp+var_10]
call _ZN8facebook4yoga16SmallValueBufferILm4EEaSERKS2_; facebook::yoga::SmallValueBuffer<4ul>::operator=(facebook::yoga::SmallValueBuffer<4ul> const&)
mov rax, [rbp+var_18]
add rsp, 20h
pop rbp
retn
| long long facebook::yoga::StyleValuePool::operator=(long long a1, _WORD *a2)
{
facebook::yoga::SmallValueBuffer<4ul>::operator=(a1, a2);
return a1;
}
| |||
54,161 | facebook::yoga::StyleValuePool::StyleValuePool(facebook::yoga::StyleValuePool const&) | yoga-mod/yoga/../yoga/style/StyleValuePool.h | void store(StyleValueHandle& handle, StyleLength length) {
if (length.isUndefined()) {
handle.setType(StyleValueHandle::Type::Undefined);
} else if (length.isAuto()) {
handle.setType(StyleValueHandle::Type::Auto);
} else {
auto type = length.isPoints() ? StyleValueHandle::Type::Point
: StyleValueHandle::Type::Percent;
storeValue(handle, length.value().unwrap(), type);
}
} | O3 | c | facebook::yoga::StyleValuePool::StyleValuePool(facebook::yoga::StyleValuePool const&):
pushq %rbp
movq %rsp, %rbp
movq %rdx, %rax
shrq $0x20, %rax
cmpb $0x3, %al
je 0x79537
movzbl %al, %ecx
testl %ecx, %ecx
jne 0x79545
andb $-0x8, (%rsi)
jmp 0x79543
movzwl (%rsi), %eax
andl $-0x8, %eax
orl $0x4, %eax
movw %ax, (%rsi)
popq %rbp
retq
movd %edx, %xmm0
xorl %edx, %edx
cmpb $0x1, %al
setne %dl
incl %edx
popq %rbp
jmp 0x79558
| _ZN8facebook4yoga14StyleValuePool5storeERNS0_16StyleValueHandleENS0_11StyleLengthE:
push rbp
mov rbp, rsp
mov rax, rdx
shr rax, 20h
cmp al, 3
jz short loc_79537
movzx ecx, al
test ecx, ecx
jnz short loc_79545
and byte ptr [rsi], 0F8h
jmp short loc_79543
loc_79537:
movzx eax, word ptr [rsi]
and eax, 0FFFFFFF8h
or eax, 4
mov [rsi], ax
loc_79543:
pop rbp
retn
loc_79545:
movd xmm0, edx
xor edx, edx
cmp al, 1
setnz dl
inc edx
pop rbp
jmp $+5; facebook::yoga::StyleValuePool::storeValue(facebook::yoga::StyleValueHandle &,float,facebook::yoga::StyleValueHandle::Type)
| long long facebook::yoga::StyleValuePool::store(long long a1, _WORD *a2, unsigned long long a3)
{
long long result; // rax
result = HIDWORD(a3);
if ( BYTE4(a3) == 3 )
{
result = *a2 & 0xFFF8 | 4u;
*a2 = *a2 & 0xFFF8 | 4;
}
else if ( BYTE4(a3) )
{
return facebook::yoga::StyleValuePool::storeValue(
a1,
a2,
(unsigned int)(BYTE4(a3) != 1) + 1,
*(double *)_mm_cvtsi32_si128(a3).m128i_i64);
}
else
{
*(_BYTE *)a2 &= 0xF8u;
}
return result;
}
| store:
PUSH RBP
MOV RBP,RSP
MOV RAX,RDX
SHR RAX,0x20
CMP AL,0x3
JZ 0x00179537
MOVZX ECX,AL
TEST ECX,ECX
JNZ 0x00179545
AND byte ptr [RSI],0xf8
JMP 0x00179543
LAB_00179537:
MOVZX EAX,word ptr [RSI]
AND EAX,0xfffffff8
OR EAX,0x4
MOV word ptr [RSI],AX
LAB_00179543:
POP RBP
RET
LAB_00179545:
MOVD XMM0,EDX
XOR EDX,EDX
CMP AL,0x1
SETNZ DL
INC EDX
POP RBP
JMP 0x00179558
|
/* facebook::yoga::StyleValuePool::store(facebook::yoga::StyleValueHandle&,
facebook::yoga::StyleLength) */
void __thiscall
facebook::yoga::StyleValuePool::store(StyleValuePool *this,ushort *param_1,ulong param_3)
{
char cVar1;
cVar1 = (char)(param_3 >> 0x20);
if (cVar1 == '\x03') {
*param_1 = *param_1 & 0xfff8 | 4;
}
else {
if ((param_3 & 0xff00000000) != 0) {
storeValue((StyleValuePool *)(param_3 & 0xffffffff),this,param_1,(cVar1 != '\x01') + '\x01');
return;
}
*(byte *)param_1 = (byte)*param_1 & 0xf8;
}
return;
}
| |
54,162 | ma_write_init_default | eloqsql/storage/maria/ma_write.c | MARIA_RECORD_POS _ma_write_init_default(MARIA_HA *info,
const uchar *record
__attribute__((unused)))
{
return ((info->s->state.dellink != HA_OFFSET_ERROR &&
!info->append_insert_at_end) ?
info->s->state.dellink :
info->state->data_file_length);
} | O0 | c | ma_write_init_default:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $-0x1, 0xc8(%rax)
je 0x82a7e
movq -0x8(%rbp), %rax
cmpb $0x0, 0x681(%rax)
jne 0x82a7e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x82a8e
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ma_write_init_default:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax]
cmp qword ptr [rax+0C8h], 0FFFFFFFFFFFFFFFFh
jz short loc_82A7E
mov rax, [rbp+var_8]
cmp byte ptr [rax+681h], 0
jnz short loc_82A7E
mov rax, [rbp+var_8]
mov rax, [rax]
mov rax, [rax+0C8h]
mov [rbp+var_18], rax
jmp short loc_82A8E
loc_82A7E:
mov rax, [rbp+var_8]
mov rax, [rax+20h]
mov rax, [rax+28h]
mov [rbp+var_18], rax
loc_82A8E:
mov rax, [rbp+var_18]
pop rbp
retn
| long long ma_write_init_default(long long a1)
{
if ( *(_QWORD *)(*(_QWORD *)a1 + 200LL) == -1LL || *(_BYTE *)(a1 + 1665) )
return *(_QWORD *)(*(_QWORD *)(a1 + 32) + 40LL);
else
return *(_QWORD *)(*(_QWORD *)a1 + 200LL);
}
| _ma_write_init_default:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
CMP qword ptr [RAX + 0xc8],-0x1
JZ 0x00182a7e
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX + 0x681],0x0
JNZ 0x00182a7e
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0xc8]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00182a8e
LAB_00182a7e:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x18],RAX
LAB_00182a8e:
MOV RAX,qword ptr [RBP + -0x18]
POP RBP
RET
|
int8 _ma_write_init_default(long *param_1)
{
int8 local_20;
if ((*(long *)(*param_1 + 200) == -1) || (*(char *)((long)param_1 + 0x681) != '\0')) {
local_20 = *(int8 *)(param_1[4] + 0x28);
}
else {
local_20 = *(int8 *)(*param_1 + 200);
}
return local_20;
}
| |
54,163 | maria_upgrade | eloqsql/storage/maria/ma_init.c | my_bool maria_upgrade()
{
char name[FN_REFLEN], new_name[FN_REFLEN];
DBUG_ENTER("maria_upgrade");
fn_format(name, "maria_log_control", maria_data_root, "", MYF(MY_WME));
if (!my_access(name,F_OK))
{
/*
Old style control file found; Rename the control file and the log files.
We start by renaming all log files, so that if we get a crash
we will continue from where we left.
*/
uint i;
MY_DIR *dir= my_dir(maria_data_root, MYF(MY_WME));
if (!dir)
DBUG_RETURN(1);
my_message(HA_ERR_INITIALIZATION,
"Found old style Maria log files; "
"Converting them to Aria names",
MYF(ME_NOTE));
for (i= 0; i < dir->number_of_files; i++)
{
const char *file= dir->dir_entry[i].name;
if (strncmp(file, "maria_log.", 10) == 0 &&
file[10] >= '0' && file[10] <= '9' &&
file[11] >= '0' && file[11] <= '9' &&
file[12] >= '0' && file[12] <= '9' &&
file[13] >= '0' && file[13] <= '9' &&
file[14] >= '0' && file[14] <= '9' &&
file[15] >= '0' && file[15] <= '9' &&
file[16] >= '0' && file[16] <= '9' &&
file[17] >= '0' && file[17] <= '9' &&
file[18] == '\0')
{
/* Remove the 'm' in 'maria' */
char old_logname[FN_REFLEN], new_logname[FN_REFLEN];
fn_format(old_logname, file, maria_data_root, "", MYF(0));
fn_format(new_logname, file+1, maria_data_root, "", MYF(0));
if (mysql_file_rename(key_file_translog, old_logname,
new_logname, MYF(MY_WME)))
{
my_dirend(dir);
DBUG_RETURN(1);
}
}
}
my_dirend(dir);
fn_format(new_name, CONTROL_FILE_BASE_NAME, maria_data_root, "", MYF(0));
if (mysql_file_rename(key_file_control, name, new_name, MYF(MY_WME)))
DBUG_RETURN(1);
}
DBUG_RETURN(0);
} | O0 | c | maria_upgrade:
pushq %rbp
movq %rsp, %rbp
subq $0x830, %rsp # imm = 0x830
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
leaq -0x210(%rbp), %rdi
leaq 0x4597ea(%rip), %rax # 0x486bc0
movq (%rax), %rdx
leaq 0x12f585(%rip), %rsi # 0x15c965
leaq 0x12f57d(%rip), %rcx # 0x15c964
movl $0x10, %r8d
callq 0xe47d0
leaq -0x210(%rbp), %rdi
xorl %esi, %esi
callq 0x2a100
cmpl $0x0, %eax
jne 0x2d730
leaq 0x4597b0(%rip), %rax # 0x486bc0
movq (%rax), %rdi
movl $0x10, %esi
callq 0xfb7d0
movq %rax, -0x820(%rbp)
cmpq $0x0, -0x820(%rbp)
jne 0x2d43c
jmp 0x2d430
movb $0x1, -0x811(%rbp)
jmp 0x2d739
movl $0xae, %edi
leaq 0x12f52f(%rip), %rsi # 0x15c977
movl $0x400, %edx # imm = 0x400
callq 0xf4e90
movl $0x0, -0x818(%rbp)
movl -0x818(%rbp), %eax
movq -0x820(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x2d6bd
movq -0x820(%rbp), %rax
movq (%rax), %rax
movl -0x818(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x828(%rbp)
movq -0x828(%rbp), %rdi
leaq 0x12f515(%rip), %rsi # 0x15c9b6
movl $0xa, %edx
callq 0x2a1d0
cmpl $0x0, %eax
jne 0x2d6a7
movq -0x828(%rbp), %rax
movsbl 0xa(%rax), %eax
cmpl $0x30, %eax
jl 0x2d6a7
movq -0x828(%rbp), %rax
movsbl 0xa(%rax), %eax
cmpl $0x39, %eax
jg 0x2d6a7
movq -0x828(%rbp), %rax
movsbl 0xb(%rax), %eax
cmpl $0x30, %eax
jl 0x2d6a7
movq -0x828(%rbp), %rax
movsbl 0xb(%rax), %eax
cmpl $0x39, %eax
jg 0x2d6a7
movq -0x828(%rbp), %rax
movsbl 0xc(%rax), %eax
cmpl $0x30, %eax
jl 0x2d6a7
movq -0x828(%rbp), %rax
movsbl 0xc(%rax), %eax
cmpl $0x39, %eax
jg 0x2d6a7
movq -0x828(%rbp), %rax
movsbl 0xd(%rax), %eax
cmpl $0x30, %eax
jl 0x2d6a7
movq -0x828(%rbp), %rax
movsbl 0xd(%rax), %eax
cmpl $0x39, %eax
jg 0x2d6a7
movq -0x828(%rbp), %rax
movsbl 0xe(%rax), %eax
cmpl $0x30, %eax
jl 0x2d6a7
movq -0x828(%rbp), %rax
movsbl 0xe(%rax), %eax
cmpl $0x39, %eax
jg 0x2d6a7
movq -0x828(%rbp), %rax
movsbl 0xf(%rax), %eax
cmpl $0x30, %eax
jl 0x2d6a7
movq -0x828(%rbp), %rax
movsbl 0xf(%rax), %eax
cmpl $0x39, %eax
jg 0x2d6a7
movq -0x828(%rbp), %rax
movsbl 0x10(%rax), %eax
cmpl $0x30, %eax
jl 0x2d6a7
movq -0x828(%rbp), %rax
movsbl 0x10(%rax), %eax
cmpl $0x39, %eax
jg 0x2d6a7
movq -0x828(%rbp), %rax
movsbl 0x11(%rax), %eax
cmpl $0x30, %eax
jl 0x2d6a7
movq -0x828(%rbp), %rax
movsbl 0x11(%rax), %eax
cmpl $0x39, %eax
jg 0x2d6a7
movq -0x828(%rbp), %rax
movsbl 0x12(%rax), %eax
cmpl $0x0, %eax
jne 0x2d6a7
leaq -0x610(%rbp), %rdi
movq -0x828(%rbp), %rsi
leaq 0x4595a3(%rip), %rax # 0x486bc0
movq (%rax), %rdx
leaq 0x12f33d(%rip), %rcx # 0x15c964
xorl %r8d, %r8d
callq 0xe47d0
leaq -0x810(%rbp), %rdi
movq -0x828(%rbp), %rsi
addq $0x1, %rsi
leaq 0x459578(%rip), %rax # 0x486bc0
movq (%rax), %rdx
leaq 0x12f312(%rip), %rcx # 0x15c964
xorl %r8d, %r8d
callq 0xe47d0
leaq 0x459713(%rip), %rax # 0x486d74
movl (%rax), %edi
leaq -0x610(%rbp), %rcx
leaq -0x810(%rbp), %r8
leaq 0x12f349(%rip), %rsi # 0x15c9c1
movl $0xac, %edx
movl $0x10, %r9d
callq 0x2d770
cmpl $0x0, %eax
je 0x2d6a5
movq -0x820(%rbp), %rdi
callq 0xfb780
movb $0x1, -0x811(%rbp)
jmp 0x2d739
jmp 0x2d6a7
jmp 0x2d6a9
movl -0x818(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x818(%rbp)
jmp 0x2d45c
movq -0x820(%rbp), %rdi
callq 0xfb780
leaq -0x410(%rbp), %rdi
leaq 0x4594e9(%rip), %rax # 0x486bc0
movq (%rax), %rdx
leaq 0x12f285(%rip), %rsi # 0x15c966
leaq 0x12f27c(%rip), %rcx # 0x15c964
xorl %r8d, %r8d
callq 0xe47d0
leaq 0x459689(%rip), %rax # 0x486d80
movl (%rax), %edi
leaq -0x210(%rbp), %rcx
leaq -0x410(%rbp), %r8
leaq 0x12f2b3(%rip), %rsi # 0x15c9c1
movl $0xb6, %edx
movl $0x10, %r9d
callq 0x2d770
cmpl $0x0, %eax
je 0x2d72e
jmp 0x2d725
movb $0x1, -0x811(%rbp)
jmp 0x2d739
jmp 0x2d730
jmp 0x2d732
movb $0x0, -0x811(%rbp)
movb -0x811(%rbp), %al
movb %al, -0x829(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x2d766
movb -0x829(%rbp), %al
addq $0x830, %rsp # imm = 0x830
popq %rbp
retq
callq 0x2a250
nopl (%rax,%rax)
| maria_upgrade:
push rbp
mov rbp, rsp
sub rsp, 830h
mov rax, fs:28h
mov [rbp+var_8], rax
lea rdi, [rbp+var_210]
lea rax, maria_data_root
mov rdx, [rax]
lea rsi, aMariaLogContro; "maria_log_control"
lea rcx, aUsageSOptions+15h; ""
mov r8d, 10h
call fn_format
lea rdi, [rbp+var_210]
xor esi, esi
call _access
cmp eax, 0
jnz loc_2D730
lea rax, maria_data_root
mov rdi, [rax]
mov esi, 10h
call my_dir
mov [rbp+var_820], rax
cmp [rbp+var_820], 0
jnz short loc_2D43C
jmp short $+2
loc_2D430:
mov [rbp+var_811], 1
jmp loc_2D739
loc_2D43C:
mov edi, 0AEh
lea rsi, aFoundOldStyleM; "Found old style Maria log files; Conver"...
mov edx, 400h
call my_message
mov [rbp+var_818], 0
loc_2D45C:
mov eax, [rbp+var_818]
mov rcx, [rbp+var_820]
cmp eax, [rcx+8]
jnb loc_2D6BD
mov rax, [rbp+var_820]
mov rax, [rax]
mov ecx, [rbp+var_818]
shl rcx, 4
add rax, rcx
mov rax, [rax]
mov [rbp+var_828], rax
mov rdi, [rbp+var_828]
lea rsi, aMariaLog; "maria_log."
mov edx, 0Ah
call _strncmp
cmp eax, 0
jnz loc_2D6A7
mov rax, [rbp+var_828]
movsx eax, byte ptr [rax+0Ah]
cmp eax, 30h ; '0'
jl loc_2D6A7
mov rax, [rbp+var_828]
movsx eax, byte ptr [rax+0Ah]
cmp eax, 39h ; '9'
jg loc_2D6A7
mov rax, [rbp+var_828]
movsx eax, byte ptr [rax+0Bh]
cmp eax, 30h ; '0'
jl loc_2D6A7
mov rax, [rbp+var_828]
movsx eax, byte ptr [rax+0Bh]
cmp eax, 39h ; '9'
jg loc_2D6A7
mov rax, [rbp+var_828]
movsx eax, byte ptr [rax+0Ch]
cmp eax, 30h ; '0'
jl loc_2D6A7
mov rax, [rbp+var_828]
movsx eax, byte ptr [rax+0Ch]
cmp eax, 39h ; '9'
jg loc_2D6A7
mov rax, [rbp+var_828]
movsx eax, byte ptr [rax+0Dh]
cmp eax, 30h ; '0'
jl loc_2D6A7
mov rax, [rbp+var_828]
movsx eax, byte ptr [rax+0Dh]
cmp eax, 39h ; '9'
jg loc_2D6A7
mov rax, [rbp+var_828]
movsx eax, byte ptr [rax+0Eh]
cmp eax, 30h ; '0'
jl loc_2D6A7
mov rax, [rbp+var_828]
movsx eax, byte ptr [rax+0Eh]
cmp eax, 39h ; '9'
jg loc_2D6A7
mov rax, [rbp+var_828]
movsx eax, byte ptr [rax+0Fh]
cmp eax, 30h ; '0'
jl loc_2D6A7
mov rax, [rbp+var_828]
movsx eax, byte ptr [rax+0Fh]
cmp eax, 39h ; '9'
jg loc_2D6A7
mov rax, [rbp+var_828]
movsx eax, byte ptr [rax+10h]
cmp eax, 30h ; '0'
jl loc_2D6A7
mov rax, [rbp+var_828]
movsx eax, byte ptr [rax+10h]
cmp eax, 39h ; '9'
jg loc_2D6A7
mov rax, [rbp+var_828]
movsx eax, byte ptr [rax+11h]
cmp eax, 30h ; '0'
jl loc_2D6A7
mov rax, [rbp+var_828]
movsx eax, byte ptr [rax+11h]
cmp eax, 39h ; '9'
jg loc_2D6A7
mov rax, [rbp+var_828]
movsx eax, byte ptr [rax+12h]
cmp eax, 0
jnz loc_2D6A7
lea rdi, [rbp+var_610]
mov rsi, [rbp+var_828]
lea rax, maria_data_root
mov rdx, [rax]
lea rcx, aUsageSOptions+15h; ""
xor r8d, r8d
call fn_format
lea rdi, [rbp+var_810]
mov rsi, [rbp+var_828]
add rsi, 1
lea rax, maria_data_root
mov rdx, [rax]
lea rcx, aUsageSOptions+15h; ""
xor r8d, r8d
call fn_format
lea rax, key_file_translog
mov edi, [rax]
lea rcx, [rbp+var_610]
lea r8, [rbp+var_810]
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0ACh
mov r9d, 10h
call inline_mysql_file_rename
cmp eax, 0
jz short loc_2D6A5
mov rdi, [rbp+var_820]
call my_dirend
mov [rbp+var_811], 1
jmp loc_2D739
loc_2D6A5:
jmp short $+2
loc_2D6A7:
jmp short $+2
loc_2D6A9:
mov eax, [rbp+var_818]
add eax, 1
mov [rbp+var_818], eax
jmp loc_2D45C
loc_2D6BD:
mov rdi, [rbp+var_820]
call my_dirend
lea rdi, [rbp+var_410]
lea rax, maria_data_root
mov rdx, [rax]
lea rsi, aMariaLogContro+1; "aria_log_control"
lea rcx, aUsageSOptions+15h; ""
xor r8d, r8d
call fn_format
lea rax, key_file_control
mov edi, [rax]
lea rcx, [rbp+var_210]
lea r8, [rbp+var_410]
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0B6h
mov r9d, 10h
call inline_mysql_file_rename
cmp eax, 0
jz short loc_2D72E
jmp short $+2
loc_2D725:
mov [rbp+var_811], 1
jmp short loc_2D739
loc_2D72E:
jmp short $+2
loc_2D730:
jmp short $+2
loc_2D732:
mov [rbp+var_811], 0
loc_2D739:
mov al, [rbp+var_811]
mov [rbp+var_829], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_2D766
mov al, [rbp+var_829]
add rsp, 830h
pop rbp
retn
loc_2D766:
call ___stack_chk_fail
| bool maria_upgrade()
{
char *v1; // [rsp+8h] [rbp-828h]
long long v2; // [rsp+10h] [rbp-820h]
unsigned int i; // [rsp+18h] [rbp-818h]
_BYTE v5[512]; // [rsp+20h] [rbp-810h] BYREF
_BYTE v6[512]; // [rsp+220h] [rbp-610h] BYREF
_BYTE v7[512]; // [rsp+420h] [rbp-410h] BYREF
_BYTE v8[520]; // [rsp+620h] [rbp-210h] BYREF
unsigned long long v9; // [rsp+828h] [rbp-8h]
v9 = __readfsqword(0x28u);
fn_format(v8, "maria_log_control", *(_QWORD *)&maria_data_root, "", 16LL);
if ( (unsigned int)access(v8, 0LL) )
return 0;
v2 = my_dir(*(_QWORD *)&maria_data_root, 16LL);
if ( v2 )
{
my_message(174LL, "Found old style Maria log files; Converting them to Aria names", 1024LL);
for ( i = 0; i < *(_DWORD *)(v2 + 8); ++i )
{
v1 = *(char **)(16LL * i + *(_QWORD *)v2);
if ( !(unsigned int)strncmp(v1, "maria_log.", 10LL)
&& v1[10] >= 48
&& v1[10] <= 57
&& v1[11] >= 48
&& v1[11] <= 57
&& v1[12] >= 48
&& v1[12] <= 57
&& v1[13] >= 48
&& v1[13] <= 57
&& v1[14] >= 48
&& v1[14] <= 57
&& v1[15] >= 48
&& v1[15] <= 57
&& v1[16] >= 48
&& v1[16] <= 57
&& v1[17] >= 48
&& v1[17] <= 57
&& !v1[18] )
{
fn_format(v6, v1, *(_QWORD *)&maria_data_root, "", 0LL);
fn_format(v5, v1 + 1, *(_QWORD *)&maria_data_root, "", 0LL);
if ( (unsigned int)inline_mysql_file_rename(
key_file_translog,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_init.c",
172LL,
v6,
v5,
16LL) )
{
my_dirend(v2);
return 1;
}
}
}
my_dirend(v2);
fn_format(v7, "aria_log_control", *(_QWORD *)&maria_data_root, "", 0LL);
return (unsigned int)inline_mysql_file_rename(
key_file_control,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_init.c",
182LL,
v8,
v7,
16LL) != 0;
}
return 1;
}
| maria_upgrade:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x830
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
LEA RDI,[RBP + -0x210]
LEA RAX,[0x586bc0]
MOV RDX,qword ptr [RAX]
LEA RSI,[0x25c965]
LEA RCX,[0x25c964]
MOV R8D,0x10
CALL 0x001e47d0
LEA RDI,[RBP + -0x210]
XOR ESI,ESI
CALL 0x0012a100
CMP EAX,0x0
JNZ 0x0012d730
LEA RAX,[0x586bc0]
MOV RDI,qword ptr [RAX]
MOV ESI,0x10
CALL 0x001fb7d0
MOV qword ptr [RBP + -0x820],RAX
CMP qword ptr [RBP + -0x820],0x0
JNZ 0x0012d43c
JMP 0x0012d430
LAB_0012d430:
MOV byte ptr [RBP + -0x811],0x1
JMP 0x0012d739
LAB_0012d43c:
MOV EDI,0xae
LEA RSI,[0x25c977]
MOV EDX,0x400
CALL 0x001f4e90
MOV dword ptr [RBP + -0x818],0x0
LAB_0012d45c:
MOV EAX,dword ptr [RBP + -0x818]
MOV RCX,qword ptr [RBP + -0x820]
CMP EAX,dword ptr [RCX + 0x8]
JNC 0x0012d6bd
MOV RAX,qword ptr [RBP + -0x820]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x818]
SHL RCX,0x4
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x828],RAX
MOV RDI,qword ptr [RBP + -0x828]
LEA RSI,[0x25c9b6]
MOV EDX,0xa
CALL 0x0012a1d0
CMP EAX,0x0
JNZ 0x0012d6a7
MOV RAX,qword ptr [RBP + -0x828]
MOVSX EAX,byte ptr [RAX + 0xa]
CMP EAX,0x30
JL 0x0012d6a7
MOV RAX,qword ptr [RBP + -0x828]
MOVSX EAX,byte ptr [RAX + 0xa]
CMP EAX,0x39
JG 0x0012d6a7
MOV RAX,qword ptr [RBP + -0x828]
MOVSX EAX,byte ptr [RAX + 0xb]
CMP EAX,0x30
JL 0x0012d6a7
MOV RAX,qword ptr [RBP + -0x828]
MOVSX EAX,byte ptr [RAX + 0xb]
CMP EAX,0x39
JG 0x0012d6a7
MOV RAX,qword ptr [RBP + -0x828]
MOVSX EAX,byte ptr [RAX + 0xc]
CMP EAX,0x30
JL 0x0012d6a7
MOV RAX,qword ptr [RBP + -0x828]
MOVSX EAX,byte ptr [RAX + 0xc]
CMP EAX,0x39
JG 0x0012d6a7
MOV RAX,qword ptr [RBP + -0x828]
MOVSX EAX,byte ptr [RAX + 0xd]
CMP EAX,0x30
JL 0x0012d6a7
MOV RAX,qword ptr [RBP + -0x828]
MOVSX EAX,byte ptr [RAX + 0xd]
CMP EAX,0x39
JG 0x0012d6a7
MOV RAX,qword ptr [RBP + -0x828]
MOVSX EAX,byte ptr [RAX + 0xe]
CMP EAX,0x30
JL 0x0012d6a7
MOV RAX,qword ptr [RBP + -0x828]
MOVSX EAX,byte ptr [RAX + 0xe]
CMP EAX,0x39
JG 0x0012d6a7
MOV RAX,qword ptr [RBP + -0x828]
MOVSX EAX,byte ptr [RAX + 0xf]
CMP EAX,0x30
JL 0x0012d6a7
MOV RAX,qword ptr [RBP + -0x828]
MOVSX EAX,byte ptr [RAX + 0xf]
CMP EAX,0x39
JG 0x0012d6a7
MOV RAX,qword ptr [RBP + -0x828]
MOVSX EAX,byte ptr [RAX + 0x10]
CMP EAX,0x30
JL 0x0012d6a7
MOV RAX,qword ptr [RBP + -0x828]
MOVSX EAX,byte ptr [RAX + 0x10]
CMP EAX,0x39
JG 0x0012d6a7
MOV RAX,qword ptr [RBP + -0x828]
MOVSX EAX,byte ptr [RAX + 0x11]
CMP EAX,0x30
JL 0x0012d6a7
MOV RAX,qword ptr [RBP + -0x828]
MOVSX EAX,byte ptr [RAX + 0x11]
CMP EAX,0x39
JG 0x0012d6a7
MOV RAX,qword ptr [RBP + -0x828]
MOVSX EAX,byte ptr [RAX + 0x12]
CMP EAX,0x0
JNZ 0x0012d6a7
LEA RDI,[RBP + -0x610]
MOV RSI,qword ptr [RBP + -0x828]
LEA RAX,[0x586bc0]
MOV RDX,qword ptr [RAX]
LEA RCX,[0x25c964]
XOR R8D,R8D
CALL 0x001e47d0
LEA RDI,[RBP + -0x810]
MOV RSI,qword ptr [RBP + -0x828]
ADD RSI,0x1
LEA RAX,[0x586bc0]
MOV RDX,qword ptr [RAX]
LEA RCX,[0x25c964]
XOR R8D,R8D
CALL 0x001e47d0
LEA RAX,[0x586d74]
MOV EDI,dword ptr [RAX]
LEA RCX,[RBP + -0x610]
LEA R8,[RBP + -0x810]
LEA RSI,[0x25c9c1]
MOV EDX,0xac
MOV R9D,0x10
CALL 0x0012d770
CMP EAX,0x0
JZ 0x0012d6a5
MOV RDI,qword ptr [RBP + -0x820]
CALL 0x001fb780
MOV byte ptr [RBP + -0x811],0x1
JMP 0x0012d739
LAB_0012d6a5:
JMP 0x0012d6a7
LAB_0012d6a7:
JMP 0x0012d6a9
LAB_0012d6a9:
MOV EAX,dword ptr [RBP + -0x818]
ADD EAX,0x1
MOV dword ptr [RBP + -0x818],EAX
JMP 0x0012d45c
LAB_0012d6bd:
MOV RDI,qword ptr [RBP + -0x820]
CALL 0x001fb780
LEA RDI,[RBP + -0x410]
LEA RAX,[0x586bc0]
MOV RDX,qword ptr [RAX]
LEA RSI,[0x25c966]
LEA RCX,[0x25c964]
XOR R8D,R8D
CALL 0x001e47d0
LEA RAX,[0x586d80]
MOV EDI,dword ptr [RAX]
LEA RCX,[RBP + -0x210]
LEA R8,[RBP + -0x410]
LEA RSI,[0x25c9c1]
MOV EDX,0xb6
MOV R9D,0x10
CALL 0x0012d770
CMP EAX,0x0
JZ 0x0012d72e
JMP 0x0012d725
LAB_0012d725:
MOV byte ptr [RBP + -0x811],0x1
JMP 0x0012d739
LAB_0012d72e:
JMP 0x0012d730
LAB_0012d730:
JMP 0x0012d732
LAB_0012d732:
MOV byte ptr [RBP + -0x811],0x0
LAB_0012d739:
MOV AL,byte ptr [RBP + -0x811]
MOV byte ptr [RBP + -0x829],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0012d766
MOV AL,byte ptr [RBP + -0x829]
ADD RSP,0x830
POP RBP
RET
LAB_0012d766:
CALL 0x0012a250
|
int8 maria_upgrade(void)
{
char *__s1;
int iVar1;
long *plVar2;
long in_FS_OFFSET;
uint local_820;
int1 local_819;
int1 local_818 [512];
int1 local_618 [512];
int1 local_418 [512];
char local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
fn_format(local_218,"maria_log_control",maria_data_root,"",0x10);
iVar1 = access(local_218,0);
if (iVar1 == 0) {
plVar2 = (long *)my_dir(maria_data_root,0x10);
if (plVar2 == (long *)0x0) {
local_819 = 1;
goto LAB_0012d739;
}
my_message(0xae,"Found old style Maria log files; Converting them to Aria names",0x400);
for (local_820 = 0; local_820 < *(uint *)(plVar2 + 1); local_820 = local_820 + 1) {
__s1 = *(char **)(*plVar2 + (ulong)local_820 * 0x10);
iVar1 = strncmp(__s1,"maria_log.",10);
if (((((((iVar1 == 0) && ('/' < __s1[10])) && (__s1[10] < ':')) &&
(('/' < __s1[0xb] && (__s1[0xb] < ':')))) &&
(('/' < __s1[0xc] && ((__s1[0xc] < ':' && ('/' < __s1[0xd])))))) && (__s1[0xd] < ':')) &&
((((('/' < __s1[0xe] && (__s1[0xe] < ':')) && ('/' < __s1[0xf])) &&
(((__s1[0xf] < ':' && ('/' < __s1[0x10])) &&
((__s1[0x10] < ':' && (('/' < __s1[0x11] && (__s1[0x11] < ':')))))))) &&
(__s1[0x12] == '\0')))) {
fn_format(local_618,__s1,maria_data_root,"",0);
fn_format(local_818,__s1 + 1,maria_data_root,"",0);
iVar1 = inline_mysql_file_rename
(key_file_translog,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_init.c",0xac,
local_618,local_818,0x10);
if (iVar1 != 0) {
my_dirend(plVar2);
local_819 = 1;
goto LAB_0012d739;
}
}
}
my_dirend(plVar2);
fn_format(local_418,"aria_log_control",maria_data_root,"",0);
iVar1 = inline_mysql_file_rename
(key_file_control,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_init.c",0xb6,
local_218,local_418,0x10);
if (iVar1 != 0) {
local_819 = 1;
goto LAB_0012d739;
}
}
local_819 = 0;
LAB_0012d739:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),local_819);
}
| |
54,164 | strxmov | eloqsql/strings/strxmov.c | char *strxmov(char *dst,const char *src, ...)
{
va_list pvar;
va_start(pvar,src);
while (src != NullS) {
while ((*dst++ = *src++)) ;
dst--;
src = va_arg(pvar, char *);
}
va_end(pvar);
*dst = 0; /* there might have been no sources! */
return dst;
} | O0 | c | strxmov:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
testb %al, %al
je 0xdb0e8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
cmpq $0x0, -0x10(%rbp)
je 0xdb1dc
jmp 0xdb13d
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %al
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %al, (%rcx)
cmpb $0x0, %al
je 0xdb165
jmp 0xdb13d
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0xf0(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0xe4(%rbp)
cmpl $0x28, %eax
ja 0xdb1ac
movq -0xf0(%rbp), %rcx
movl -0xe4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0xf8(%rbp)
jmp 0xdb1c9
movq -0xf0(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xdb130
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
| strxmov:
push rbp
mov rbp, rsp
sub rsp, 80h
test al, al
jz short loc_DB0E8
movaps [rbp+var_B0], xmm0
movaps [rbp+var_A0], xmm1
movaps [rbp+var_90], xmm2
movaps [rbp+var_80], xmm3
movaps [rbp+var_70], xmm4
movaps [rbp+var_60], xmm5
movaps [rbp+var_50], xmm6
movaps [rbp+var_40], xmm7
loc_DB0E8:
mov [rbp+var_B8], r9
mov [rbp+var_C0], r8
mov [rbp+var_C8], rcx
mov [rbp+var_D0], rdx
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
lea rax, [rbp+var_30]
lea rcx, [rbp+var_E0]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 10h
loc_DB130:
cmp [rbp+var_10], 0
jz loc_DB1DC
jmp short $+2
loc_DB13D:
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov al, [rax]
mov rcx, [rbp+var_8]
mov rdx, rcx
add rdx, 1
mov [rbp+var_8], rdx
mov [rcx], al
cmp al, 0
jz short loc_DB165
jmp short loc_DB13D
loc_DB165:
mov rax, [rbp+var_8]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_8], rax
lea rax, [rbp+var_30]
mov [rbp+var_F0], rax
mov eax, [rbp+var_30]
mov [rbp+var_E4], eax
cmp eax, 28h ; '('
ja short loc_DB1AC
mov rcx, [rbp+var_F0]
mov edx, [rbp+var_E4]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_F8], rax
jmp short loc_DB1C9
loc_DB1AC:
mov rcx, [rbp+var_F0]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_F8], rax
loc_DB1C9:
mov rax, [rbp+var_F8]
mov rax, [rax]
mov [rbp+var_10], rax
jmp loc_DB130
loc_DB1DC:
mov rax, [rbp+var_8]
mov byte ptr [rax], 0
mov rax, [rbp+var_8]
add rsp, 80h
pop rbp
retn
| _BYTE * strxmov(
_BYTE *a1,
_BYTE *a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
_BYTE *v15; // rax
_BYTE *v16; // rcx
char *v17; // rax
char v19; // [rsp+18h] [rbp-E0h] BYREF
long long v20; // [rsp+28h] [rbp-D0h]
long long v21; // [rsp+30h] [rbp-C8h]
long long v22; // [rsp+38h] [rbp-C0h]
long long v23; // [rsp+40h] [rbp-B8h]
__m128 v24; // [rsp+48h] [rbp-B0h]
__m128 v25; // [rsp+58h] [rbp-A0h]
__m128 v26; // [rsp+68h] [rbp-90h]
__m128 v27; // [rsp+78h] [rbp-80h]
__m128 v28; // [rsp+88h] [rbp-70h]
__m128 v29; // [rsp+98h] [rbp-60h]
__m128 v30; // [rsp+A8h] [rbp-50h]
__m128 v31; // [rsp+B8h] [rbp-40h]
int v32; // [rsp+C8h] [rbp-30h]
int v33; // [rsp+CCh] [rbp-2Ch]
char *v34; // [rsp+D0h] [rbp-28h]
char *v35; // [rsp+D8h] [rbp-20h]
_BYTE *v36; // [rsp+E8h] [rbp-10h]
_BYTE *v37; // [rsp+F0h] [rbp-8h]
v24 = a7;
v25 = a8;
v26 = a9;
v27 = a10;
v28 = a11;
v29 = a12;
v30 = a13;
v31 = a14;
v23 = a6;
v22 = a5;
v21 = a4;
v20 = a3;
v37 = a1;
v36 = a2;
v35 = &v19;
v34 = &a15;
v33 = 48;
v32 = 16;
while ( v36 )
{
do
{
v15 = v36++;
LOBYTE(v15) = *v15;
v16 = v37++;
*v16 = (_BYTE)v15;
}
while ( (_BYTE)v15 );
--v37;
if ( (unsigned int)v32 > 0x28 )
{
v17 = v34;
v34 += 8;
}
else
{
v17 = &v35[v32];
v32 += 8;
}
v36 = *(_BYTE **)v17;
}
*v37 = 0;
return v37;
}
| strxmov:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
TEST AL,AL
JZ 0x001db0e8
MOVAPS xmmword ptr [RBP + -0xb0],XMM0
MOVAPS xmmword ptr [RBP + -0xa0],XMM1
MOVAPS xmmword ptr [RBP + -0x90],XMM2
MOVAPS xmmword ptr [RBP + -0x80],XMM3
MOVAPS xmmword ptr [RBP + -0x70],XMM4
MOVAPS xmmword ptr [RBP + -0x60],XMM5
MOVAPS xmmword ptr [RBP + -0x50],XMM6
MOVAPS xmmword ptr [RBP + -0x40],XMM7
LAB_001db0e8:
MOV qword ptr [RBP + -0xb8],R9
MOV qword ptr [RBP + -0xc0],R8
MOV qword ptr [RBP + -0xc8],RCX
MOV qword ptr [RBP + -0xd0],RDX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
LEA RAX,[RBP + -0x30]
LEA RCX,[RBP + -0xe0]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x10
LAB_001db130:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x001db1dc
JMP 0x001db13d
LAB_001db13d:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV AL,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x8],RDX
MOV byte ptr [RCX],AL
CMP AL,0x0
JZ 0x001db165
JMP 0x001db13d
LAB_001db165:
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x8],RAX
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0xf0],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0xe4],EAX
CMP EAX,0x28
JA 0x001db1ac
MOV RCX,qword ptr [RBP + -0xf0]
MOV EDX,dword ptr [RBP + -0xe4]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0xf8],RAX
JMP 0x001db1c9
LAB_001db1ac:
MOV RCX,qword ptr [RBP + -0xf0]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0xf8],RAX
LAB_001db1c9:
MOV RAX,qword ptr [RBP + -0xf8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001db130
LAB_001db1dc:
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x80
POP RBP
RET
|
/* WARNING: Restarted to delay deadcode elimination for space: stack */
char * strxmov(char *param_1,char *param_2)
{
char cVar1;
char *pcVar2;
int8 *local_100;
int8 local_e8 [22];
uint local_38;
int8 *local_30;
char *local_18;
char *local_10;
local_30 = (int8 *)&stack0x00000008;
local_38 = 0x10;
local_18 = param_2;
local_10 = param_1;
while (pcVar2 = local_10, local_18 != (char *)0x0) {
do {
local_10 = pcVar2;
cVar1 = *local_18;
*local_10 = cVar1;
local_18 = local_18 + 1;
pcVar2 = local_10 + 1;
} while (cVar1 != '\0');
if (local_38 < 0x29) {
local_100 = (int8 *)((long)local_e8 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_100 = local_30;
local_30 = local_30 + 1;
}
local_18 = (char *)*local_100;
}
*local_10 = '\0';
return local_10;
}
| |
54,165 | ma_hashtbl_next | eloqsql/libmariadb/libmariadb/ma_hashtbl.c | void *ma_hashtbl_next(MA_HASHTBL *hash,const uchar *key,uint length)
{
MA_HASHTBL_LINK *pos;
uint idx;
if (hash->current_record != NO_RECORD)
{
MA_HASHTBL_LINK *data=dynamic_element(&hash->array,0,MA_HASHTBL_LINK*);
for (idx=data[hash->current_record].next; idx != NO_RECORD ; idx=pos->next)
{
pos=data+idx;
if (!hashcmp(hash,pos,key,length))
{
hash->current_record= idx;
return pos->data;
}
}
hash->current_record=NO_RECORD;
}
return 0;
} | O3 | c | ma_hashtbl_next:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, -0x2c(%rbp)
movl 0x10(%rdi), %r13d
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rax, %r13
je 0x30689
movq %rsi, %r15
movq %rdi, %rbx
movq 0x18(%rdi), %r12
shlq $0x4, %r13
addq %r12, %r13
movl (%r13), %r14d
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rax, %r14
je 0x30682
movq %r14, %rax
shlq $0x4, %rax
leaq (%r12,%rax), %r13
movq 0x8(%r12,%rax), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movl -0x2c(%rbp), %ecx
callq 0x30536
testl %eax, %eax
jne 0x30648
movl %r14d, 0x10(%rbx)
movq 0x8(%r13), %rax
jmp 0x3068b
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ma_hashtbl_next:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov [rbp+var_2C], edx
mov r13d, [rdi+10h]
mov eax, 0FFFFFFFFh
cmp r13, rax
jz short loc_30689
mov r15, rsi
mov rbx, rdi
mov r12, [rdi+18h]
shl r13, 4
add r13, r12
loc_30648:
mov r14d, [r13+0]
mov eax, 0FFFFFFFFh
cmp r14, rax
jz short loc_30682
mov rax, r14
shl rax, 4
lea r13, [r12+rax]
mov rsi, [r12+rax+8]
mov rdi, rbx
mov rdx, r15
mov ecx, [rbp+var_2C]
call hashcmp
test eax, eax
jnz short loc_30648
mov [rbx+10h], r14d
mov rax, [r13+8]
jmp short loc_3068B
loc_30682:
mov dword ptr [rbx+10h], 0FFFFFFFFh
loc_30689:
xor eax, eax
loc_3068B:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ma_hashtbl_next(long long a1, long long a2, int a3)
{
long long v3; // r13
long long v4; // r12
unsigned int *v5; // r13
long long v6; // r14
v3 = *(unsigned int *)(a1 + 16);
if ( v3 != 0xFFFFFFFFLL )
{
v4 = *(_QWORD *)(a1 + 24);
v5 = (unsigned int *)(v4 + 16 * v3);
while ( 1 )
{
v6 = *v5;
if ( v6 == 0xFFFFFFFFLL )
break;
v5 = (unsigned int *)(v4 + 16 * v6);
if ( !hashcmp((unsigned int *)a1, *((_QWORD *)v5 + 1), a2, a3) )
{
*(_DWORD *)(a1 + 16) = v6;
return *((_QWORD *)v5 + 1);
}
}
*(_DWORD *)(a1 + 16) = -1;
}
return 0LL;
}
| ma_hashtbl_next:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV dword ptr [RBP + -0x2c],EDX
MOV R13D,dword ptr [RDI + 0x10]
MOV EAX,0xffffffff
CMP R13,RAX
JZ 0x00130689
MOV R15,RSI
MOV RBX,RDI
MOV R12,qword ptr [RDI + 0x18]
SHL R13,0x4
ADD R13,R12
LAB_00130648:
MOV R14D,dword ptr [R13]
MOV EAX,0xffffffff
CMP R14,RAX
JZ 0x00130682
MOV RAX,R14
SHL RAX,0x4
LEA R13,[R12 + RAX*0x1]
MOV RSI,qword ptr [R12 + RAX*0x1 + 0x8]
MOV RDI,RBX
MOV RDX,R15
MOV ECX,dword ptr [RBP + -0x2c]
CALL 0x00130536
TEST EAX,EAX
JNZ 0x00130648
MOV dword ptr [RBX + 0x10],R14D
MOV RAX,qword ptr [R13 + 0x8]
JMP 0x0013068b
LAB_00130682:
MOV dword ptr [RBX + 0x10],0xffffffff
LAB_00130689:
XOR EAX,EAX
LAB_0013068b:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 ma_hashtbl_next(long param_1,int8 param_2,int4 param_3)
{
uint uVar1;
long lVar2;
int iVar3;
long lVar4;
int8 uVar5;
uint *puVar6;
if ((ulong)*(uint *)(param_1 + 0x10) == 0xffffffff) {
LAB_00130689:
uVar5 = 0;
}
else {
lVar2 = *(long *)(param_1 + 0x18);
puVar6 = (uint *)((ulong)*(uint *)(param_1 + 0x10) * 0x10 + lVar2);
do {
uVar1 = *puVar6;
if ((ulong)uVar1 == 0xffffffff) {
*(int4 *)(param_1 + 0x10) = 0xffffffff;
goto LAB_00130689;
}
lVar4 = (ulong)uVar1 * 0x10;
puVar6 = (uint *)(lVar2 + lVar4);
iVar3 = hashcmp(param_1,*(int8 *)(lVar2 + 8 + lVar4),param_2,param_3);
} while (iVar3 != 0);
*(uint *)(param_1 + 0x10) = uVar1;
uVar5 = *(int8 *)(puVar6 + 2);
}
return uVar5;
}
| |
54,166 | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::skip_bom() | llama.cpp/common/./json.hpp | bool skip_bom()
{
if (get() == 0xEF)
{
// check if we completely parse the BOM
return get() == 0xBB && get() == 0xBF;
}
// the first character is not the beginning of the BOM; unget it to
// process is later
unget();
return true;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::skip_bom():
pushq %rbx
movq %rdi, %rbx
callq 0x1d246
cmpl $0xef, %eax
jne 0x2beeb
movq %rbx, %rdi
callq 0x1d246
cmpl $0xbb, %eax
je 0x2bef7
xorl %eax, %eax
jmp 0x2bef5
movq %rbx, %rdi
callq 0x1d2bc
movb $0x1, %al
popq %rbx
retq
movq %rbx, %rdi
callq 0x1d246
cmpl $0xbf, %eax
sete %al
jmp 0x2bef5
nop
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE8skip_bomEv:
push rbx
mov rbx, rdi
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
cmp eax, 0EFh
jnz short loc_2BEEB
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
cmp eax, 0BBh
jz short loc_2BEF7
xor eax, eax
jmp short loc_2BEF5
loc_2BEEB:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5ungetEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::unget(void)
mov al, 1
loc_2BEF5:
pop rbx
retn
loc_2BEF7:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
cmp eax, 0BFh
setz al
jmp short loc_2BEF5
| bool nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::skip_bom(
__m128i *a1)
{
if ( (unsigned int)nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1) == 239 )
return (unsigned int)nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1) == 187
&& (unsigned int)nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1) == 191;
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::unget((long long)a1);
return 1;
}
| skip_bom:
PUSH RBX
MOV RBX,RDI
CALL 0x0011d246
CMP EAX,0xef
JNZ 0x0012beeb
MOV RDI,RBX
CALL 0x0011d246
CMP EAX,0xbb
JZ 0x0012bef7
XOR EAX,EAX
JMP 0x0012bef5
LAB_0012beeb:
MOV RDI,RBX
CALL 0x0011d2bc
MOV AL,0x1
LAB_0012bef5:
POP RBX
RET
LAB_0012bef7:
MOV RDI,RBX
CALL 0x0011d246
CMP EAX,0xbf
SETZ AL
JMP 0x0012bef5
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::skip_bom() */
bool __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::skip_bom(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this)
{
int iVar1;
bool bVar2;
iVar1 = get(this);
if (iVar1 == 0xef) {
iVar1 = get(this);
if (iVar1 == 0xbb) {
iVar1 = get(this);
bVar2 = iVar1 == 0xbf;
}
else {
bVar2 = false;
}
}
else {
unget(this);
bVar2 = true;
}
return bVar2;
}
| |
54,167 | my_wildcmp_uca_impl | eloqsql/strings/ctype-uca.c | static
int my_wildcmp_uca_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 */
my_wc_t s_wc, w_wc;
int scan;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
if (my_string_stack_guard && my_string_stack_guard(recurse_level))
return 1;
while (wildstr != wildend)
{
while (1)
{
my_bool escaped= 0;
if ((scan= mb_wc(cs, &w_wc, (const uchar*)wildstr,
(const uchar*)wildend)) <= 0)
return 1;
if (w_wc == (my_wc_t) w_many)
{
result= 1; /* Found an anchor char */
break;
}
wildstr+= scan;
if (w_wc == (my_wc_t) escape && wildstr < wildend)
{
if ((scan= mb_wc(cs, &w_wc, (const uchar*)wildstr,
(const uchar*)wildend)) <= 0)
return 1;
wildstr+= scan;
escaped= 1;
}
if ((scan= mb_wc(cs, &s_wc, (const uchar*)str,
(const uchar*)str_end)) <= 0)
return 1;
str+= scan;
if (!escaped && w_wc == (my_wc_t) w_one)
{
result= 1; /* Found an anchor char */
}
else
{
if (my_uca_charcmp(cs,s_wc,w_wc))
return 1; /* No match */
}
if (wildstr == wildend)
return (str != str_end); /* Match if both are at end */
}
if (w_wc == (my_wc_t) w_many)
{ /* Found w_many */
/* Remove any '%' and '_' from the wild search string */
for ( ; wildstr != wildend ; )
{
if ((scan= mb_wc(cs, &w_wc, (const uchar*)wildstr,
(const uchar*)wildend)) <= 0)
return 1;
if (w_wc == (my_wc_t) w_many)
{
wildstr+= scan;
continue;
}
if (w_wc == (my_wc_t) w_one)
{
wildstr+= scan;
if ((scan= mb_wc(cs, &s_wc, (const uchar*)str,
(const uchar*)str_end)) <= 0)
return 1;
str+= scan;
continue;
}
break; /* Not a wild character */
}
if (wildstr == wildend)
return 0; /* Ok if w_many is last */
if (str == str_end)
return -1;
if ((scan= mb_wc(cs, &w_wc, (const uchar*)wildstr,
(const uchar*)wildend)) <= 0)
return 1;
wildstr+= scan;
if (w_wc == (my_wc_t) escape)
{
if (wildstr < wildend)
{
if ((scan= mb_wc(cs, &w_wc, (const uchar*)wildstr,
(const uchar*)wildend)) <= 0)
return 1;
wildstr+= scan;
}
}
while (1)
{
/* Skip until the first character from wildstr is found */
while (str != str_end)
{
if ((scan= mb_wc(cs, &s_wc, (const uchar*)str,
(const uchar*)str_end)) <= 0)
return 1;
if (!my_uca_charcmp(cs,s_wc,w_wc))
break;
str+= scan;
}
if (str == str_end)
return -1;
str+= scan;
result= my_wildcmp_uca_impl(cs, str, str_end, wildstr, wildend,
escape, w_one, w_many,
recurse_level + 1);
if (result <= 0)
return result;
}
}
}
return (str != str_end ? 1 : 0);
} | O3 | c | my_wildcmp_uca_impl:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r9d, -0x54(%rbp)
movq %r8, %r12
movq %rcx, %r13
movq %rdx, -0x40(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdi, %r15
movl 0x20(%rbp), %eax
movq %rax, -0x60(%rbp)
movq 0xb8(%rdi), %rax
movq 0x28(%rax), %r14
leaq 0x37f503(%rip), %rax # 0x3da478
movq (%rax), %rax
testq %rax, %rax
je 0x5af8f
movl 0x20(%rbp), %edi
callq *%rax
movl $0x1, %ebx
testl %eax, %eax
jne 0x5b20c
cmpq %r12, %r13
je 0x5b090
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %ecx
cltq
movq %rax, -0x78(%rbp)
movslq -0x54(%rbp), %rax
movq %rax, -0x70(%rbp)
movslq %ecx, %rax
movq %rax, -0x68(%rbp)
movq %r14, -0x48(%rbp)
movq %r15, %rdi
leaq -0x38(%rbp), %rsi
movq %r13, %rdx
movq %r12, %rcx
callq *%r14
testl %eax, %eax
jle 0x5b207
movq -0x38(%rbp), %rcx
cmpq -0x78(%rbp), %rcx
je 0x5b0a2
movl %eax, %eax
addq %rax, %r13
cmpq -0x70(%rbp), %rcx
jne 0x5b03e
cmpq %r12, %r13
jae 0x5b03e
movq %r15, %rdi
leaq -0x38(%rbp), %rsi
movq %r13, %rdx
movq %r12, %rcx
callq *%r14
testl %eax, %eax
jle 0x5b207
movl %eax, %ebx
movq %r15, %rdi
leaq -0x50(%rbp), %rsi
movq %r14, %rax
movq -0x30(%rbp), %r14
movq %r14, %rdx
movq -0x40(%rbp), %rcx
callq *%rax
testl %eax, %eax
jle 0x5b207
movl %ebx, %ecx
addq %rcx, %r13
movl %eax, %eax
addq %rax, %r14
movq %r14, -0x30(%rbp)
movq -0x38(%rbp), %rdx
movq -0x48(%rbp), %r14
jmp 0x5b06e
movq %r15, %rdi
leaq -0x50(%rbp), %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdx
movq -0x40(%rbp), %rcx
callq *%r14
testl %eax, %eax
jle 0x5b207
movl %eax, %eax
addq %rax, %rbx
movq %rbx, -0x30(%rbp)
movq -0x38(%rbp), %rdx
cmpq -0x68(%rbp), %rdx
je 0x5b087
movq -0x50(%rbp), %rsi
movq %r15, %rdi
callq 0x5fa2c
movl $0x1, %ebx
testl %eax, %eax
jne 0x5b20c
cmpq %r12, %r13
jne 0x5afb7
xorl %ebx, %ebx
movq -0x40(%rbp), %rax
cmpq %rax, -0x30(%rbp)
setne %bl
jmp 0x5b20c
xorl %ebx, %ebx
cmpq %r12, %r13
je 0x5b20c
movq %r15, %rdi
leaq -0x38(%rbp), %rsi
movq %r13, %rdx
movq %r12, %rcx
callq *%r14
testl %eax, %eax
jle 0x5b207
movl %eax, %r14d
movq -0x38(%rbp), %rax
cmpq -0x78(%rbp), %rax
jne 0x5b0e6
movl %r14d, %eax
addq %rax, %r13
cmpq %r12, %r13
movq -0x48(%rbp), %r14
jne 0x5b0ad
jmp 0x5b20c
cmpq -0x68(%rbp), %rax
jne 0x5b114
movq %r15, %rdi
leaq -0x50(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq *-0x48(%rbp)
testl %eax, %eax
jle 0x5b207
movl %r14d, %ecx
addq %rcx, %r13
movl %eax, %eax
addq %rax, -0x30(%rbp)
jmp 0x5b0d8
movq -0x40(%rbp), %rax
cmpq %rax, -0x30(%rbp)
je 0x5b21d
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
movq %r13, %rdx
movq %r12, %rcx
movq -0x48(%rbp), %r14
callq *%r14
testl %eax, %eax
jle 0x5b207
movl %eax, %eax
addq %rax, %r13
movq -0x70(%rbp), %rax
cmpq %rax, -0x38(%rbp)
jne 0x5b16f
cmpq %r12, %r13
jae 0x5b16f
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
movq %r13, %rdx
movq %r12, %rcx
callq *%r14
testl %eax, %eax
jle 0x5b207
movl %eax, %eax
addq %rax, %r13
movq -0x60(%rbp), %rax
incl %eax
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %rbx
movq -0x40(%rbp), %rcx
cmpq %rcx, %rbx
je 0x5b21d
movq %r15, %rdi
leaq -0x50(%rbp), %rsi
movq %rbx, %rdx
callq *%r14
testl %eax, %eax
jle 0x5b207
movl %eax, %r14d
movq -0x50(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %r15, %rdi
callq 0x5fa2c
movl %r14d, %ecx
addq %rcx, %rbx
testl %eax, %eax
je 0x5b1c7
movq -0x40(%rbp), %rcx
cmpq %rcx, %rbx
movq -0x48(%rbp), %r14
jne 0x5b18a
jmp 0x5b21d
subq $0x8, %rsp
movq %r15, %rdi
movq %rbx, -0x30(%rbp)
movq %rbx, %rsi
movq -0x40(%rbp), %rdx
movq %r13, %rcx
movq %r12, %r8
movl -0x54(%rbp), %r9d
pushq -0x60(%rbp)
movl 0x18(%rbp), %eax
pushq %rax
movl 0x10(%rbp), %eax
pushq %rax
callq 0x5af36
addq $0x20, %rsp
movl %eax, %ebx
testl %eax, %eax
movq -0x48(%rbp), %r14
jg 0x5b179
jmp 0x5b20c
movl $0x1, %ebx
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
jmp 0x5b20c
| my_wildcmp_uca_impl:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov [rbp+var_54], r9d
mov r12, r8
mov r13, rcx
mov [rbp+var_40], rdx
mov [rbp+var_30], rsi
mov r15, rdi
mov eax, [rbp+arg_10]
mov [rbp+var_60], rax
mov rax, [rdi+0B8h]
mov r14, [rax+28h]
lea rax, my_string_stack_guard
mov rax, [rax]
test rax, rax
jz short loc_5AF8F
mov edi, [rbp+arg_10]
call rax
mov ebx, 1
test eax, eax
jnz loc_5B20C
loc_5AF8F:
cmp r13, r12
jz loc_5B090
mov eax, [rbp+arg_8]
mov ecx, [rbp+arg_0]
cdqe
mov [rbp+var_78], rax
movsxd rax, [rbp+var_54]
mov [rbp+var_70], rax
movsxd rax, ecx
mov [rbp+var_68], rax
mov [rbp+var_48], r14
loc_5AFB7:
mov rdi, r15
lea rsi, [rbp+var_38]
mov rdx, r13
mov rcx, r12
call r14
test eax, eax
jle loc_5B207
mov rcx, [rbp+var_38]
cmp rcx, [rbp+var_78]
jz loc_5B0A2
mov eax, eax
add r13, rax
cmp rcx, [rbp+var_70]
jnz short loc_5B03E
cmp r13, r12
jnb short loc_5B03E
mov rdi, r15
lea rsi, [rbp+var_38]
mov rdx, r13
mov rcx, r12
call r14
test eax, eax
jle loc_5B207
mov ebx, eax
mov rdi, r15
lea rsi, [rbp+var_50]
mov rax, r14
mov r14, [rbp+var_30]
mov rdx, r14
mov rcx, [rbp+var_40]
call rax
test eax, eax
jle loc_5B207
mov ecx, ebx
add r13, rcx
mov eax, eax
add r14, rax
mov [rbp+var_30], r14
mov rdx, [rbp+var_38]
mov r14, [rbp+var_48]
jmp short loc_5B06E
loc_5B03E:
mov rdi, r15
lea rsi, [rbp+var_50]
mov rbx, [rbp+var_30]
mov rdx, rbx
mov rcx, [rbp+var_40]
call r14
test eax, eax
jle loc_5B207
mov eax, eax
add rbx, rax
mov [rbp+var_30], rbx
mov rdx, [rbp+var_38]
cmp rdx, [rbp+var_68]
jz short loc_5B087
loc_5B06E:
mov rsi, [rbp+var_50]
mov rdi, r15
call my_uca_charcmp
mov ebx, 1
test eax, eax
jnz loc_5B20C
loc_5B087:
cmp r13, r12
jnz loc_5AFB7
loc_5B090:
xor ebx, ebx
mov rax, [rbp+var_40]
cmp [rbp+var_30], rax
setnz bl
jmp loc_5B20C
loc_5B0A2:
xor ebx, ebx
cmp r13, r12
jz loc_5B20C
loc_5B0AD:
mov rdi, r15
lea rsi, [rbp+var_38]
mov rdx, r13
mov rcx, r12
call r14
test eax, eax
jle loc_5B207
mov r14d, eax
mov rax, [rbp+var_38]
cmp rax, [rbp+var_78]
jnz short loc_5B0E6
mov eax, r14d
add r13, rax
loc_5B0D8:
cmp r13, r12
mov r14, [rbp+var_48]
jnz short loc_5B0AD
jmp loc_5B20C
loc_5B0E6:
cmp rax, [rbp+var_68]
jnz short loc_5B114
mov rdi, r15
lea rsi, [rbp+var_50]
mov rdx, [rbp+var_30]
mov rcx, [rbp+var_40]
call [rbp+var_48]
test eax, eax
jle loc_5B207
mov ecx, r14d
add r13, rcx
mov eax, eax
add [rbp+var_30], rax
jmp short loc_5B0D8
loc_5B114:
mov rax, [rbp+var_40]
cmp [rbp+var_30], rax
jz loc_5B21D
lea rsi, [rbp+var_38]
mov rdi, r15
mov rdx, r13
mov rcx, r12
mov r14, [rbp+var_48]
call r14
test eax, eax
jle loc_5B207
mov eax, eax
add r13, rax
mov rax, [rbp+var_70]
cmp [rbp+var_38], rax
jnz short loc_5B16F
cmp r13, r12
jnb short loc_5B16F
lea rsi, [rbp+var_38]
mov rdi, r15
mov rdx, r13
mov rcx, r12
call r14
test eax, eax
jle loc_5B207
mov eax, eax
add r13, rax
loc_5B16F:
mov rax, [rbp+var_60]
inc eax
mov [rbp+var_60], rax
loc_5B179:
mov rbx, [rbp+var_30]
mov rcx, [rbp+var_40]
cmp rbx, rcx
jz loc_5B21D
loc_5B18A:
mov rdi, r15
lea rsi, [rbp+var_50]
mov rdx, rbx
call r14
test eax, eax
jle short loc_5B207
mov r14d, eax
mov rsi, [rbp+var_50]
mov rdx, [rbp+var_38]
mov rdi, r15
call my_uca_charcmp
mov ecx, r14d
add rbx, rcx
test eax, eax
jz short loc_5B1C7
mov rcx, [rbp+var_40]
cmp rbx, rcx
mov r14, [rbp+var_48]
jnz short loc_5B18A
jmp short loc_5B21D
loc_5B1C7:
sub rsp, 8
mov rdi, r15
mov [rbp+var_30], rbx
mov rsi, rbx
mov rdx, [rbp+var_40]
mov rcx, r13
mov r8, r12
mov r9d, [rbp+var_54]
push [rbp+var_60]
mov eax, [rbp+arg_8]
push rax
mov eax, [rbp+arg_0]
push rax
call my_wildcmp_uca_impl
add rsp, 20h
mov ebx, eax
test eax, eax
mov r14, [rbp+var_48]
jg loc_5B179
jmp short loc_5B20C
loc_5B207:
mov ebx, 1
loc_5B20C:
mov eax, ebx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_5B21D:
mov ebx, 0FFFFFFFFh
jmp short loc_5B20C
| long long my_wildcmp_uca_impl(
long long a1,
long long a2,
long long a3,
unsigned long long a4,
unsigned long long a5,
int a6,
int a7,
int a8,
unsigned int a9)
{
long long ( *v11)(long long, long long *, unsigned long long, unsigned long long); // r14
unsigned int v12; // ebx
int v13; // eax
int v14; // eax
unsigned int v15; // ebx
long long ( *v16)(long long, long long *, long long, long long); // rax
long long v17; // r14
int v18; // eax
long long v19; // rdx
long long v20; // rbx
int v21; // eax
int v22; // eax
unsigned int v23; // r14d
int v24; // eax
long long ( *v25)(long long, long long *, unsigned long long, unsigned long long); // r14
int v26; // eax
unsigned long long v27; // r13
int v28; // eax
long long v29; // rbx
int v30; // eax
long long v33; // [rsp+30h] [rbp-50h] BYREF
long long ( *v34)(long long, long long *, unsigned long long, unsigned long long); // [rsp+38h] [rbp-48h]
long long v35; // [rsp+40h] [rbp-40h]
long long v36; // [rsp+48h] [rbp-38h] BYREF
long long v37; // [rsp+50h] [rbp-30h]
v35 = a3;
v37 = a2;
v11 = *(long long ( **)(long long, long long *, unsigned long long, unsigned long long))(*(_QWORD *)(a1 + 184) + 40LL);
if ( !my_string_stack_guard || (v12 = 1, !(unsigned int)my_string_stack_guard(a9)) )
{
if ( a4 != a5 )
{
v34 = v11;
while ( 1 )
{
v13 = v11(a1, &v36, a4, a5);
if ( v13 <= 0 )
return 1;
if ( v36 == a8 )
{
v12 = 0;
if ( a4 == a5 )
return v12;
while ( 1 )
{
v22 = v11(a1, &v36, a4, a5);
if ( v22 <= 0 )
return 1;
v23 = v22;
if ( v36 == a8 )
{
a4 += (unsigned int)v22;
}
else
{
if ( v36 != a7 )
{
if ( v37 == v35 )
return (unsigned int)-1;
v25 = v34;
v26 = v34(a1, &v36, a4, a5);
if ( v26 <= 0 )
return 1;
v27 = (unsigned int)v26 + a4;
if ( v36 == a6 && v27 < a5 )
{
v28 = v25(a1, &v36, v27, a5);
if ( v28 <= 0 )
return 1;
LODWORD(v27) = v28 + v27;
}
LABEL_32:
v29 = v37;
if ( v37 == v35 )
return (unsigned int)-1;
while ( 1 )
{
v30 = ((long long ( *)(long long, long long *, long long))v25)(a1, &v33, v29);
if ( v30 <= 0 )
return 1;
v29 += (unsigned int)v30;
if ( !(unsigned int)my_uca_charcmp(a1, v33, v36) )
{
v37 = v29;
v12 = my_wildcmp_uca_impl(a1, v29, v35, v27, a5, a6, a7, a8, a9 + 1);
v25 = v34;
if ( (int)v12 > 0 )
goto LABEL_32;
return v12;
}
v25 = v34;
if ( v29 == v35 )
return (unsigned int)-1;
}
}
v24 = v34(a1, &v33, v37, v35);
if ( v24 <= 0 )
return 1;
a4 += v23;
v37 += (unsigned int)v24;
}
v11 = v34;
if ( a4 == a5 )
return v12;
}
}
a4 += (unsigned int)v13;
if ( v36 == a6 && a4 < a5 )
break;
v20 = v37;
v21 = v11(a1, &v33, v37, v35);
if ( v21 <= 0 )
return 1;
v37 = (unsigned int)v21 + v20;
v19 = v36;
if ( v36 != a7 )
goto LABEL_14;
LABEL_15:
if ( a4 == a5 )
return v37 != v35;
}
v14 = v11(a1, &v36, a4, a5);
if ( v14 <= 0 )
return 1;
v15 = v14;
v16 = (long long ( *)(long long, long long *, long long, long long))v11;
v17 = v37;
v18 = v16(a1, &v33, v37, v35);
if ( v18 <= 0 )
return 1;
a4 += v15;
v37 = (unsigned int)v18 + v17;
v19 = v36;
v11 = v34;
LABEL_14:
v12 = 1;
if ( (unsigned int)my_uca_charcmp(a1, v33, v19) )
return v12;
goto LABEL_15;
}
return v37 != v35;
}
return v12;
}
| my_wildcmp_uca_impl:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV dword ptr [RBP + -0x54],R9D
MOV R12,R8
MOV R13,RCX
MOV qword ptr [RBP + -0x40],RDX
MOV qword ptr [RBP + -0x30],RSI
MOV R15,RDI
MOV EAX,dword ptr [RBP + 0x20]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RDI + 0xb8]
MOV R14,qword ptr [RAX + 0x28]
LEA RAX,[0x4da478]
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x0015af8f
MOV EDI,dword ptr [RBP + 0x20]
CALL RAX
MOV EBX,0x1
TEST EAX,EAX
JNZ 0x0015b20c
LAB_0015af8f:
CMP R13,R12
JZ 0x0015b090
MOV EAX,dword ptr [RBP + 0x18]
MOV ECX,dword ptr [RBP + 0x10]
CDQE
MOV qword ptr [RBP + -0x78],RAX
MOVSXD RAX,dword ptr [RBP + -0x54]
MOV qword ptr [RBP + -0x70],RAX
MOVSXD RAX,ECX
MOV qword ptr [RBP + -0x68],RAX
MOV qword ptr [RBP + -0x48],R14
LAB_0015afb7:
MOV RDI,R15
LEA RSI,[RBP + -0x38]
MOV RDX,R13
MOV RCX,R12
CALL R14
TEST EAX,EAX
JLE 0x0015b207
MOV RCX,qword ptr [RBP + -0x38]
CMP RCX,qword ptr [RBP + -0x78]
JZ 0x0015b0a2
MOV EAX,EAX
ADD R13,RAX
CMP RCX,qword ptr [RBP + -0x70]
JNZ 0x0015b03e
CMP R13,R12
JNC 0x0015b03e
MOV RDI,R15
LEA RSI,[RBP + -0x38]
MOV RDX,R13
MOV RCX,R12
CALL R14
TEST EAX,EAX
JLE 0x0015b207
MOV EBX,EAX
MOV RDI,R15
LEA RSI,[RBP + -0x50]
MOV RAX,R14
MOV R14,qword ptr [RBP + -0x30]
MOV RDX,R14
MOV RCX,qword ptr [RBP + -0x40]
CALL RAX
TEST EAX,EAX
JLE 0x0015b207
MOV ECX,EBX
ADD R13,RCX
MOV EAX,EAX
ADD R14,RAX
MOV qword ptr [RBP + -0x30],R14
MOV RDX,qword ptr [RBP + -0x38]
MOV R14,qword ptr [RBP + -0x48]
JMP 0x0015b06e
LAB_0015b03e:
MOV RDI,R15
LEA RSI,[RBP + -0x50]
MOV RBX,qword ptr [RBP + -0x30]
MOV RDX,RBX
MOV RCX,qword ptr [RBP + -0x40]
CALL R14
TEST EAX,EAX
JLE 0x0015b207
MOV EAX,EAX
ADD RBX,RAX
MOV qword ptr [RBP + -0x30],RBX
MOV RDX,qword ptr [RBP + -0x38]
CMP RDX,qword ptr [RBP + -0x68]
JZ 0x0015b087
LAB_0015b06e:
MOV RSI,qword ptr [RBP + -0x50]
MOV RDI,R15
CALL 0x0015fa2c
MOV EBX,0x1
TEST EAX,EAX
JNZ 0x0015b20c
LAB_0015b087:
CMP R13,R12
JNZ 0x0015afb7
LAB_0015b090:
XOR EBX,EBX
MOV RAX,qword ptr [RBP + -0x40]
CMP qword ptr [RBP + -0x30],RAX
SETNZ BL
JMP 0x0015b20c
LAB_0015b0a2:
XOR EBX,EBX
CMP R13,R12
JZ 0x0015b20c
LAB_0015b0ad:
MOV RDI,R15
LEA RSI,[RBP + -0x38]
MOV RDX,R13
MOV RCX,R12
CALL R14
TEST EAX,EAX
JLE 0x0015b207
MOV R14D,EAX
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x78]
JNZ 0x0015b0e6
MOV EAX,R14D
ADD R13,RAX
LAB_0015b0d8:
CMP R13,R12
MOV R14,qword ptr [RBP + -0x48]
JNZ 0x0015b0ad
JMP 0x0015b20c
LAB_0015b0e6:
CMP RAX,qword ptr [RBP + -0x68]
JNZ 0x0015b114
MOV RDI,R15
LEA RSI,[RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x40]
CALL qword ptr [RBP + -0x48]
TEST EAX,EAX
JLE 0x0015b207
MOV ECX,R14D
ADD R13,RCX
MOV EAX,EAX
ADD qword ptr [RBP + -0x30],RAX
JMP 0x0015b0d8
LAB_0015b114:
MOV RAX,qword ptr [RBP + -0x40]
CMP qword ptr [RBP + -0x30],RAX
JZ 0x0015b21d
LEA RSI,[RBP + -0x38]
MOV RDI,R15
MOV RDX,R13
MOV RCX,R12
MOV R14,qword ptr [RBP + -0x48]
CALL R14
TEST EAX,EAX
JLE 0x0015b207
MOV EAX,EAX
ADD R13,RAX
MOV RAX,qword ptr [RBP + -0x70]
CMP qword ptr [RBP + -0x38],RAX
JNZ 0x0015b16f
CMP R13,R12
JNC 0x0015b16f
LEA RSI,[RBP + -0x38]
MOV RDI,R15
MOV RDX,R13
MOV RCX,R12
CALL R14
TEST EAX,EAX
JLE 0x0015b207
MOV EAX,EAX
ADD R13,RAX
LAB_0015b16f:
MOV RAX,qword ptr [RBP + -0x60]
INC EAX
MOV qword ptr [RBP + -0x60],RAX
LAB_0015b179:
MOV RBX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x40]
CMP RBX,RCX
JZ 0x0015b21d
LAB_0015b18a:
MOV RDI,R15
LEA RSI,[RBP + -0x50]
MOV RDX,RBX
CALL R14
TEST EAX,EAX
JLE 0x0015b207
MOV R14D,EAX
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x38]
MOV RDI,R15
CALL 0x0015fa2c
MOV ECX,R14D
ADD RBX,RCX
TEST EAX,EAX
JZ 0x0015b1c7
MOV RCX,qword ptr [RBP + -0x40]
CMP RBX,RCX
MOV R14,qword ptr [RBP + -0x48]
JNZ 0x0015b18a
JMP 0x0015b21d
LAB_0015b1c7:
SUB RSP,0x8
MOV RDI,R15
MOV qword ptr [RBP + -0x30],RBX
MOV RSI,RBX
MOV RDX,qword ptr [RBP + -0x40]
MOV RCX,R13
MOV R8,R12
MOV R9D,dword ptr [RBP + -0x54]
PUSH qword ptr [RBP + -0x60]
MOV EAX,dword ptr [RBP + 0x18]
PUSH RAX
MOV EAX,dword ptr [RBP + 0x10]
PUSH RAX
CALL 0x0015af36
ADD RSP,0x20
MOV EBX,EAX
TEST EAX,EAX
MOV R14,qword ptr [RBP + -0x48]
JG 0x0015b179
JMP 0x0015b20c
LAB_0015b207:
MOV EBX,0x1
LAB_0015b20c:
MOV EAX,EBX
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0015b21d:
MOV EBX,0xffffffff
JMP 0x0015b20c
|
uint my_wildcmp_uca_impl(long param_1,long param_2,long param_3,ulong param_4,ulong param_5,
int param_6,int param_7,int param_8,int param_9)
{
int iVar1;
uint uVar2;
uint uVar3;
long lVar4;
code *pcVar5;
int8 local_58;
code *local_50;
long local_48;
long local_40;
long local_38;
pcVar5 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
local_48 = param_3;
local_38 = param_2;
if ((my_string_stack_guard != (code *)0x0) &&
(iVar1 = (*my_string_stack_guard)(param_9), iVar1 != 0)) {
return 1;
}
if (param_4 != param_5) {
local_50 = pcVar5;
do {
uVar2 = (*pcVar5)(param_1,&local_40,param_4,param_5);
lVar4 = local_38;
if ((int)uVar2 < 1) {
return 1;
}
if (local_40 == param_8) {
do {
if (param_4 == param_5) {
return 0;
}
uVar2 = (*pcVar5)(param_1,&local_40,param_4,param_5);
pcVar5 = local_50;
if ((int)uVar2 < 1) {
return 1;
}
if (local_40 != param_8) {
if (local_40 != param_7) {
if (local_38 == local_48) {
return 0xffffffff;
}
uVar2 = (*local_50)(param_1,&local_40,param_4,param_5);
if (0 < (int)uVar2) {
param_4 = param_4 + uVar2;
if ((local_40 == param_6) && (param_4 < param_5)) {
uVar2 = (*pcVar5)(param_1,&local_40,param_4,param_5);
if ((int)uVar2 < 1) {
return 1;
}
param_4 = param_4 + uVar2;
}
do {
lVar4 = local_38;
if (local_38 == local_48) {
return 0xffffffff;
}
while( true ) {
uVar2 = (*pcVar5)(param_1,&local_58,lVar4);
if ((int)uVar2 < 1) {
return 1;
}
iVar1 = my_uca_charcmp(param_1,local_58,local_40);
lVar4 = lVar4 + (ulong)uVar2;
if (iVar1 == 0) break;
pcVar5 = local_50;
if (lVar4 == local_48) {
return 0xffffffff;
}
}
local_38 = lVar4;
uVar2 = my_wildcmp_uca_impl(param_1,lVar4,local_48,param_4,param_5,param_6,param_7
,param_8,param_9 + 1);
pcVar5 = local_50;
if ((int)uVar2 < 1) {
return uVar2;
}
} while( true );
}
return 1;
}
uVar3 = (*local_50)(param_1,&local_58,local_38,local_48);
if ((int)uVar3 < 1) {
return 1;
}
local_38 = local_38 + (ulong)uVar3;
}
param_4 = param_4 + uVar2;
pcVar5 = local_50;
} while( true );
}
param_4 = param_4 + uVar2;
if ((local_40 == param_6) && (param_4 < param_5)) {
uVar2 = (*pcVar5)(param_1,&local_40,param_4,param_5);
lVar4 = local_38;
if ((int)uVar2 < 1) {
return 1;
}
uVar3 = (*pcVar5)(param_1,&local_58,local_38,local_48);
if ((int)uVar3 < 1) {
return 1;
}
param_4 = param_4 + uVar2;
local_38 = lVar4 + (ulong)uVar3;
pcVar5 = local_50;
LAB_0015b06e:
iVar1 = my_uca_charcmp(param_1,local_58,local_40);
if (iVar1 != 0) {
return 1;
}
}
else {
uVar2 = (*pcVar5)(param_1,&local_58,local_38,local_48);
if ((int)uVar2 < 1) {
return 1;
}
local_38 = lVar4 + (ulong)uVar2;
if (local_40 != param_7) goto LAB_0015b06e;
}
} while (param_4 != param_5);
}
return (uint)(local_38 != local_48);
}
| |
54,168 | exchange_int32s | bluesky950520[P]quickjs/cutils.c | static void exchange_int32s(void *a, void *b, size_t size) {
uint32_t *ap = (uint32_t *)a;
uint32_t *bp = (uint32_t *)b;
for (size /= sizeof(uint32_t); size-- != 0;) {
uint32_t t = *ap;
*ap++ = *bp;
*bp++ = t;
}
} | O0 | c | exchange_int32s:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rax
shrq $0x2, %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rsp)
cmpq $0x0, %rax
je 0x20166
movq -0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rsp)
movq -0x28(%rsp), %rax
movl (%rax), %ecx
movq -0x20(%rsp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x20(%rsp)
movl %ecx, (%rax)
movl -0x2c(%rsp), %ecx
movq -0x28(%rsp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x28(%rsp)
movl %ecx, (%rax)
jmp 0x20111
retq
nopw (%rax,%rax)
| exchange_int32s:
mov [rsp+var_8], rdi
mov [rsp+var_10], rsi
mov [rsp+var_18], rdx
mov rax, [rsp+var_8]
mov [rsp+var_20], rax
mov rax, [rsp+var_10]
mov [rsp+var_28], rax
mov rax, [rsp+var_18]
shr rax, 2
mov [rsp+var_18], rax
loc_20111:
mov rax, [rsp+var_18]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rsp+var_18], rcx
cmp rax, 0
jz short locret_20166
mov rax, [rsp+var_20]
mov eax, [rax]
mov [rsp+var_2C], eax
mov rax, [rsp+var_28]
mov ecx, [rax]
mov rax, [rsp+var_20]
mov rdx, rax
add rdx, 4
mov [rsp+var_20], rdx
mov [rax], ecx
mov ecx, [rsp+var_2C]
mov rax, [rsp+var_28]
mov rdx, rax
add rdx, 4
mov [rsp+var_28], rdx
mov [rax], ecx
jmp short loc_20111
locret_20166:
retn
| long long exchange_int32s(int *a1, int *a2, unsigned long long a3)
{
long long result; // rax
int *v4; // rax
int *v5; // rax
int v6; // [rsp+0h] [rbp-2Ch]
unsigned long long v9; // [rsp+14h] [rbp-18h]
v9 = a3 >> 2;
while ( 1 )
{
result = v9--;
if ( !result )
break;
v6 = *a1;
v4 = a1++;
*v4 = *a2;
v5 = a2++;
*v5 = v6;
}
return result;
}
| exchange_int32s:
MOV qword ptr [RSP + -0x8],RDI
MOV qword ptr [RSP + -0x10],RSI
MOV qword ptr [RSP + -0x18],RDX
MOV RAX,qword ptr [RSP + -0x8]
MOV qword ptr [RSP + -0x20],RAX
MOV RAX,qword ptr [RSP + -0x10]
MOV qword ptr [RSP + -0x28],RAX
MOV RAX,qword ptr [RSP + -0x18]
SHR RAX,0x2
MOV qword ptr [RSP + -0x18],RAX
LAB_00120111:
MOV RAX,qword ptr [RSP + -0x18]
MOV RCX,RAX
ADD RCX,-0x1
MOV qword ptr [RSP + -0x18],RCX
CMP RAX,0x0
JZ 0x00120166
MOV RAX,qword ptr [RSP + -0x20]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RSP + -0x2c],EAX
MOV RAX,qword ptr [RSP + -0x28]
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RSP + -0x20]
MOV RDX,RAX
ADD RDX,0x4
MOV qword ptr [RSP + -0x20],RDX
MOV dword ptr [RAX],ECX
MOV ECX,dword ptr [RSP + -0x2c]
MOV RAX,qword ptr [RSP + -0x28]
MOV RDX,RAX
ADD RDX,0x4
MOV qword ptr [RSP + -0x28],RDX
MOV dword ptr [RAX],ECX
JMP 0x00120111
LAB_00120166:
RET
|
void exchange_int32s(int4 *param_1,int4 *param_2,ulong param_3)
{
int4 uVar1;
int4 *local_28;
int4 *local_20;
ulong local_18;
local_28 = param_2;
local_20 = param_1;
local_18 = param_3 >> 2;
while (local_18 != 0) {
uVar1 = *local_20;
*local_20 = *local_28;
*local_28 = uVar1;
local_28 = local_28 + 1;
local_20 = local_20 + 1;
local_18 = local_18 - 1;
}
return;
}
| |
54,169 | exchange_int32s | bluesky950520[P]quickjs/cutils.c | static void exchange_int32s(void *a, void *b, size_t size) {
uint32_t *ap = (uint32_t *)a;
uint32_t *bp = (uint32_t *)b;
for (size /= sizeof(uint32_t); size-- != 0;) {
uint32_t t = *ap;
*ap++ = *bp;
*bp++ = t;
}
} | O1 | c | exchange_int32s:
cmpq $0x4, %rdx
jb 0x1bd22
shrq $0x2, %rdx
xorl %eax, %eax
movl (%rdi,%rax,4), %ecx
movl (%rsi,%rax,4), %r8d
movl %r8d, (%rdi,%rax,4)
movl %ecx, (%rsi,%rax,4)
incq %rax
cmpq %rax, %rdx
jne 0x1bd0c
retq
| exchange_int32s:
cmp rdx, 4
jb short locret_1BD22
shr rdx, 2
xor eax, eax
loc_1BD0C:
mov ecx, [rdi+rax*4]
mov r8d, [rsi+rax*4]
mov [rdi+rax*4], r8d
mov [rsi+rax*4], ecx
inc rax
cmp rdx, rax
jnz short loc_1BD0C
locret_1BD22:
retn
| void exchange_int32s(long long a1, long long a2, unsigned long long a3)
{
unsigned long long v3; // rdx
long long v4; // rax
int v5; // ecx
if ( a3 >= 4 )
{
v3 = a3 >> 2;
v4 = 0LL;
do
{
v5 = *(_DWORD *)(a1 + 4 * v4);
*(_DWORD *)(a1 + 4 * v4) = *(_DWORD *)(a2 + 4 * v4);
*(_DWORD *)(a2 + 4 * v4++) = v5;
}
while ( v3 != v4 );
}
}
| exchange_int32s:
CMP RDX,0x4
JC 0x0011bd22
SHR RDX,0x2
XOR EAX,EAX
LAB_0011bd0c:
MOV ECX,dword ptr [RDI + RAX*0x4]
MOV R8D,dword ptr [RSI + RAX*0x4]
MOV dword ptr [RDI + RAX*0x4],R8D
MOV dword ptr [RSI + RAX*0x4],ECX
INC RAX
CMP RDX,RAX
JNZ 0x0011bd0c
LAB_0011bd22:
RET
|
void exchange_int32s(long param_1,long param_2,ulong param_3)
{
int4 uVar1;
ulong uVar2;
if (3 < param_3) {
uVar2 = 0;
do {
uVar1 = *(int4 *)(param_1 + uVar2 * 4);
*(int4 *)(param_1 + uVar2 * 4) = *(int4 *)(param_2 + uVar2 * 4);
*(int4 *)(param_2 + uVar2 * 4) = uVar1;
uVar2 = uVar2 + 1;
} while (param_3 >> 2 != uVar2);
}
return;
}
| |
54,170 | exchange_int32s | bluesky950520[P]quickjs/cutils.c | static void exchange_int32s(void *a, void *b, size_t size) {
uint32_t *ap = (uint32_t *)a;
uint32_t *bp = (uint32_t *)b;
for (size /= sizeof(uint32_t); size-- != 0;) {
uint32_t t = *ap;
*ap++ = *bp;
*bp++ = t;
}
} | O3 | c | exchange_int32s:
cmpq $0x4, %rdx
jb 0x1c5f8
shrq $0x2, %rdx
xorl %eax, %eax
movl (%rdi,%rax,4), %ecx
movl (%rsi,%rax,4), %r8d
movl %r8d, (%rdi,%rax,4)
movl %ecx, (%rsi,%rax,4)
incq %rax
cmpq %rax, %rdx
jne 0x1c5e2
retq
| exchange_int32s:
cmp rdx, 4
jb short locret_1C5F8
shr rdx, 2
xor eax, eax
loc_1C5E2:
mov ecx, [rdi+rax*4]
mov r8d, [rsi+rax*4]
mov [rdi+rax*4], r8d
mov [rsi+rax*4], ecx
inc rax
cmp rdx, rax
jnz short loc_1C5E2
locret_1C5F8:
retn
| void exchange_int32s(long long a1, long long a2, unsigned long long a3)
{
unsigned long long v3; // rdx
long long v4; // rax
int v5; // ecx
if ( a3 >= 4 )
{
v3 = a3 >> 2;
v4 = 0LL;
do
{
v5 = *(_DWORD *)(a1 + 4 * v4);
*(_DWORD *)(a1 + 4 * v4) = *(_DWORD *)(a2 + 4 * v4);
*(_DWORD *)(a2 + 4 * v4++) = v5;
}
while ( v3 != v4 );
}
}
| exchange_int32s:
CMP RDX,0x4
JC 0x0011c5f8
SHR RDX,0x2
XOR EAX,EAX
LAB_0011c5e2:
MOV ECX,dword ptr [RDI + RAX*0x4]
MOV R8D,dword ptr [RSI + RAX*0x4]
MOV dword ptr [RDI + RAX*0x4],R8D
MOV dword ptr [RSI + RAX*0x4],ECX
INC RAX
CMP RDX,RAX
JNZ 0x0011c5e2
LAB_0011c5f8:
RET
|
void exchange_int32s(long param_1,long param_2,ulong param_3)
{
int4 uVar1;
ulong uVar2;
if (3 < param_3) {
uVar2 = 0;
do {
uVar1 = *(int4 *)(param_1 + uVar2 * 4);
*(int4 *)(param_1 + uVar2 * 4) = *(int4 *)(param_2 + uVar2 * 4);
*(int4 *)(param_2 + uVar2 * 4) = uVar1;
uVar2 = uVar2 + 1;
} while (param_3 >> 2 != uVar2);
}
return;
}
| |
54,171 | my_casedn_ucs2 | eloqsql/strings/ctype-ucs2.c | static size_t my_casedn_ucs2(CHARSET_INFO *cs, const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
int res;
const char *srcend= src + srclen;
char *dstend= dst + dstlen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(srclen <= dstlen);
while ((src < srcend) &&
(res= my_ucs2_uni(cs, &wc, (uchar*) src, (uchar*) srcend)) > 0)
{
my_tolower_ucs2(uni_plane, &wc);
if (res != my_uni_ucs2(cs, wc, (uchar*) dst, (uchar*) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
} | O0 | c | my_casedn_ucs2:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0xabce2
jmp 0xabce4
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x51(%rbp)
jae 0xabd14
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq 0xabb10
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0xabd1d
jmp 0xabd77
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xb0aa0
movl -0x34(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0xabb40
movl %eax, %ecx
movl -0x58(%rbp), %eax
cmpl %ecx, %eax
je 0xabd50
jmp 0xabd77
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0xabce4
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_casedn_ucs2:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_20]
add rax, [rbp+var_28]
mov [rbp+var_48], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_50], rax
jmp short $+2
loc_ABCE2:
jmp short $+2
loc_ABCE4:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_51], al
jnb short loc_ABD14
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_40]
lea rsi, [rbp+var_30]
call my_ucs2_uni
mov [rbp+var_34], eax
cmp eax, 0
setnle al
mov [rbp+var_51], al
loc_ABD14:
mov al, [rbp+var_51]
test al, 1
jnz short loc_ABD1D
jmp short loc_ABD77
loc_ABD1D:
mov rdi, [rbp+var_50]
lea rsi, [rbp+var_30]
call my_tolower_ucs2
mov eax, [rbp+var_34]
mov [rbp+var_58], eax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_48]
call my_uni_ucs2
mov ecx, eax
mov eax, [rbp+var_58]
cmp eax, ecx
jz short loc_ABD50
jmp short loc_ABD77
loc_ABD50:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
mov ecx, [rbp+var_34]
mov rax, [rbp+var_20]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_20], rax
jmp loc_ABCE4
loc_ABD77:
mov rax, [rbp+var_18]
add rsp, 60h
pop rbp
retn
| long long my_casedn_ucs2(long long a1, unsigned long long a2, long long a3, _BYTE *a4, long long a5, long long a6)
{
bool v7; // [rsp+Fh] [rbp-51h]
long long v8; // [rsp+10h] [rbp-50h]
unsigned long long v9; // [rsp+18h] [rbp-48h]
unsigned long long v10; // [rsp+20h] [rbp-40h]
int v11; // [rsp+2Ch] [rbp-34h]
unsigned long long v12[2]; // [rsp+30h] [rbp-30h] BYREF
_BYTE *v13; // [rsp+40h] [rbp-20h]
long long v14; // [rsp+48h] [rbp-18h]
unsigned long long v15; // [rsp+50h] [rbp-10h]
long long v16; // [rsp+58h] [rbp-8h]
v16 = a1;
v15 = a2;
v14 = a3;
v13 = a4;
v12[1] = a5;
v10 = a3 + a2;
v9 = (unsigned long long)&a4[a5];
v8 = *(_QWORD *)(a1 + 120);
while ( 1 )
{
v7 = 0;
if ( v15 < v10 )
{
v11 = my_ucs2_uni(v16, (long long)v12, v15, v10, a5, a6);
v7 = v11 > 0;
}
if ( !v7 )
break;
my_tolower_ucs2(v8, v12);
if ( v11 != (unsigned int)my_uni_ucs2(v16, v12[0], v13, v9) )
break;
v15 += v11;
v13 += v11;
}
return v14;
}
| my_casedn_ucs2:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x001abce2
LAB_001abce2:
JMP 0x001abce4
LAB_001abce4:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x51],AL
JNC 0x001abd14
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x30]
CALL 0x001abb10
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
SETG AL
MOV byte ptr [RBP + -0x51],AL
LAB_001abd14:
MOV AL,byte ptr [RBP + -0x51]
TEST AL,0x1
JNZ 0x001abd1d
JMP 0x001abd77
LAB_001abd1d:
MOV RDI,qword ptr [RBP + -0x50]
LEA RSI,[RBP + -0x30]
CALL 0x001b0aa0
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x58],EAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x48]
CALL 0x001abb40
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x58]
CMP EAX,ECX
JZ 0x001abd50
JMP 0x001abd77
LAB_001abd50:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001abce4
LAB_001abd77:
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x60
POP RBP
RET
|
long my_casedn_ucs2(long param_1,ulong param_2,long param_3,long param_4,long param_5)
{
int8 uVar1;
bool bVar2;
int iVar3;
int local_3c;
int8 local_38;
long local_30;
long local_28;
long local_20;
ulong local_18;
long local_10;
uVar1 = *(int8 *)(param_1 + 0x78);
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar2 = false;
if (local_18 < param_2 + param_3) {
local_3c = my_ucs2_uni(local_10,&local_38,local_18,param_2 + param_3);
bVar2 = 0 < local_3c;
}
if (!bVar2) break;
my_tolower_ucs2(uVar1,&local_38);
iVar3 = my_uni_ucs2(local_10,local_38,local_28,param_4 + param_5);
if (local_3c != iVar3) {
return local_20;
}
local_18 = local_18 + (long)local_3c;
local_28 = local_28 + local_3c;
}
return local_20;
}
| |
54,172 | JS_AddRuntimeFinalizer | bluesky950520[P]quickjs/quickjs.c | int JS_AddRuntimeFinalizer(JSRuntime *rt, JSRuntimeFinalizer *finalizer,
void *arg)
{
JSRuntimeFinalizerState *fs = js_malloc_rt(rt, sizeof(*fs));
if (!fs)
return -1;
fs->next = rt->finalizers;
fs->finalizer = finalizer;
fs->arg = arg;
rt->finalizers = fs;
return 0;
} | O0 | c | JS_AddRuntimeFinalizer:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x18, %esi
callq 0x205d0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x224a7
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x224ec
movq 0x18(%rsp), %rax
movq 0x220(%rax), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x220(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| JS_AddRuntimeFinalizer:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_18], rsi
mov [rsp+28h+var_20], rdx
mov rdi, [rsp+28h+var_10]
mov esi, 18h
call js_malloc_rt
mov [rsp+28h+var_28], rax
cmp [rsp+28h+var_28], 0
jnz short loc_224A7
mov [rsp+28h+var_4], 0FFFFFFFFh
jmp short loc_224EC
loc_224A7:
mov rax, [rsp+28h+var_10]
mov rcx, [rax+220h]
mov rax, [rsp+28h+var_28]
mov [rax], rcx
mov rcx, [rsp+28h+var_18]
mov rax, [rsp+28h+var_28]
mov [rax+8], rcx
mov rcx, [rsp+28h+var_20]
mov rax, [rsp+28h+var_28]
mov [rax+10h], rcx
mov rcx, [rsp+28h+var_28]
mov rax, [rsp+28h+var_10]
mov [rax+220h], rcx
mov [rsp+28h+var_4], 0
loc_224EC:
mov eax, [rsp+28h+var_4]
add rsp, 28h
retn
| long long JS_AddRuntimeFinalizer(long long a1, long long a2, long long a3)
{
_QWORD *v4; // [rsp+0h] [rbp-28h]
v4 = (_QWORD *)js_malloc_rt(a1, 24LL);
if ( v4 )
{
*v4 = *(_QWORD *)(a1 + 544);
v4[1] = a2;
v4[2] = a3;
*(_QWORD *)(a1 + 544) = v4;
return 0;
}
else
{
return (unsigned int)-1;
}
}
| JS_AddRuntimeFinalizer:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RSP + 0x8],RDX
MOV RDI,qword ptr [RSP + 0x18]
MOV ESI,0x18
CALL 0x001205d0
MOV qword ptr [RSP],RAX
CMP qword ptr [RSP],0x0
JNZ 0x001224a7
MOV dword ptr [RSP + 0x24],0xffffffff
JMP 0x001224ec
LAB_001224a7:
MOV RAX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RAX + 0x220]
MOV RAX,qword ptr [RSP]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RSP]
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x220],RCX
MOV dword ptr [RSP + 0x24],0x0
LAB_001224ec:
MOV EAX,dword ptr [RSP + 0x24]
ADD RSP,0x28
RET
|
int4 JS_AddRuntimeFinalizer(long param_1,int8 param_2,int8 param_3)
{
int8 *puVar1;
int4 local_4;
puVar1 = (int8 *)js_malloc_rt(param_1,0x18);
if (puVar1 == (int8 *)0x0) {
local_4 = 0xffffffff;
}
else {
*puVar1 = *(int8 *)(param_1 + 0x220);
puVar1[1] = param_2;
puVar1[2] = param_3;
*(int8 **)(param_1 + 0x220) = puVar1;
local_4 = 0;
}
return local_4;
}
| |
54,173 | JS_AddRuntimeFinalizer | bluesky950520[P]quickjs/quickjs.c | int JS_AddRuntimeFinalizer(JSRuntime *rt, JSRuntimeFinalizer *finalizer,
void *arg)
{
JSRuntimeFinalizerState *fs = js_malloc_rt(rt, sizeof(*fs));
if (!fs)
return -1;
fs->next = rt->finalizers;
fs->finalizer = finalizer;
fs->arg = arg;
rt->finalizers = fs;
return 0;
} | O1 | c | JS_AddRuntimeFinalizer:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
pushq $0x18
popq %rsi
callq 0xece0
testq %rax, %rax
je 0xef8a
movq 0x220(%r14), %rcx
movq %rcx, (%rax)
movq %r15, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rax, 0x220(%r14)
xorl %eax, %eax
jmp 0xef8d
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
| JS_AddRuntimeFinalizer:
push r15
push r14
push rbx
mov rbx, rdx
mov r15, rsi
mov r14, rdi
push 18h
pop rsi
call js_malloc_rt
test rax, rax
jz short loc_EF8A
mov rcx, [r14+220h]
mov [rax], rcx
mov [rax+8], r15
mov [rax+10h], rbx
mov [r14+220h], rax
xor eax, eax
jmp short loc_EF8D
loc_EF8A:
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_EF8D:
pop rbx
pop r14
pop r15
retn
| long long JS_AddRuntimeFinalizer(long long a1, long long a2, long long a3)
{
_QWORD *v4; // rax
v4 = (_QWORD *)js_malloc_rt(a1, 24LL);
if ( !v4 )
return -1LL;
*v4 = *(_QWORD *)(a1 + 544);
v4[1] = a2;
v4[2] = a3;
*(_QWORD *)(a1 + 544) = v4;
return 0LL;
}
| JS_AddRuntimeFinalizer:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV R15,RSI
MOV R14,RDI
PUSH 0x18
POP RSI
CALL 0x0010ece0
TEST RAX,RAX
JZ 0x0010ef8a
MOV RCX,qword ptr [R14 + 0x220]
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],R15
MOV qword ptr [RAX + 0x10],RBX
MOV qword ptr [R14 + 0x220],RAX
XOR EAX,EAX
JMP 0x0010ef8d
LAB_0010ef8a:
PUSH -0x1
POP RAX
LAB_0010ef8d:
POP RBX
POP R14
POP R15
RET
|
int8 JS_AddRuntimeFinalizer(long param_1,int8 param_2,int8 param_3)
{
int8 *puVar1;
int8 uVar2;
puVar1 = (int8 *)js_malloc_rt(param_1,0x18);
if (puVar1 == (int8 *)0x0) {
uVar2 = 0xffffffffffffffff;
}
else {
*puVar1 = *(int8 *)(param_1 + 0x220);
puVar1[1] = param_2;
puVar1[2] = param_3;
*(int8 **)(param_1 + 0x220) = puVar1;
uVar2 = 0;
}
return uVar2;
}
| |
54,174 | JS_AddRuntimeFinalizer | bluesky950520[P]quickjs/quickjs.c | int JS_AddRuntimeFinalizer(JSRuntime *rt, JSRuntimeFinalizer *finalizer,
void *arg)
{
JSRuntimeFinalizerState *fs = js_malloc_rt(rt, sizeof(*fs));
if (!fs)
return -1;
fs->next = rt->finalizers;
fs->finalizer = finalizer;
fs->arg = arg;
rt->finalizers = fs;
return 0;
} | O3 | c | JS_AddRuntimeFinalizer:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
pushq $0x18
popq %rsi
callq 0xecff
testq %rax, %rax
je 0xeff8
movq 0x220(%r14), %rcx
movq %rcx, (%rax)
movq %r15, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rax, 0x220(%r14)
xorl %eax, %eax
jmp 0xeffb
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
| JS_AddRuntimeFinalizer:
push r15
push r14
push rbx
mov rbx, rdx
mov r15, rsi
mov r14, rdi
push 18h
pop rsi
call js_malloc_rt
test rax, rax
jz short loc_EFF8
mov rcx, [r14+220h]
mov [rax], rcx
mov [rax+8], r15
mov [rax+10h], rbx
mov [r14+220h], rax
xor eax, eax
jmp short loc_EFFB
loc_EFF8:
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_EFFB:
pop rbx
pop r14
pop r15
retn
| long long JS_AddRuntimeFinalizer(long long a1, long long a2, long long a3)
{
_QWORD *v4; // rax
v4 = (_QWORD *)js_malloc_rt(a1, 24LL);
if ( !v4 )
return -1LL;
*v4 = *(_QWORD *)(a1 + 544);
v4[1] = a2;
v4[2] = a3;
*(_QWORD *)(a1 + 544) = v4;
return 0LL;
}
| JS_AddRuntimeFinalizer:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV R15,RSI
MOV R14,RDI
PUSH 0x18
POP RSI
CALL 0x0010ecff
TEST RAX,RAX
JZ 0x0010eff8
MOV RCX,qword ptr [R14 + 0x220]
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],R15
MOV qword ptr [RAX + 0x10],RBX
MOV qword ptr [R14 + 0x220],RAX
XOR EAX,EAX
JMP 0x0010effb
LAB_0010eff8:
PUSH -0x1
POP RAX
LAB_0010effb:
POP RBX
POP R14
POP R15
RET
|
int8 JS_AddRuntimeFinalizer(long param_1,int8 param_2,int8 param_3)
{
int8 *puVar1;
int8 uVar2;
puVar1 = (int8 *)js_malloc_rt(param_1,0x18);
if (puVar1 == (int8 *)0x0) {
uVar2 = 0xffffffffffffffff;
}
else {
*puVar1 = *(int8 *)(param_1 + 0x220);
puVar1[1] = param_2;
puVar1[2] = param_3;
*(int8 **)(param_1 + 0x220) = puVar1;
uVar2 = 0;
}
return uVar2;
}
| |
54,175 | madb_reset_stmt | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | static my_bool madb_reset_stmt(MYSQL_STMT *stmt, unsigned int flags)
{
MYSQL *mysql= stmt->mysql;
my_bool ret= 0;
if (!stmt->mysql)
{
SET_CLIENT_STMT_ERROR(stmt, CR_SERVER_LOST, SQLSTATE_UNKNOWN, 0);
return(1);
}
/* clear error */
if (flags & MADB_RESET_ERROR)
{
CLEAR_CLIENT_ERROR(stmt->mysql);
CLEAR_CLIENT_STMT_ERROR(stmt);
}
if (stmt->stmt_id)
{
/* free buffered resultset, previously allocated
* by mysql_stmt_store_result
*/
if (flags & MADB_RESET_STORED &&
stmt->result_cursor)
{
ma_free_root(&stmt->result.alloc, MYF(MY_KEEP_PREALLOC));
stmt->result.data= NULL;
stmt->result.rows= 0;
stmt->result_cursor= NULL;
stmt->mysql->status= MYSQL_STATUS_READY;
stmt->state= MYSQL_STMT_FETCH_DONE;
}
/* if there is a pending result set, we will flush it */
if (flags & MADB_RESET_BUFFER)
{
if (stmt->state == MYSQL_STMT_WAITING_USE_OR_STORE)
{
stmt->default_rset_handler(stmt);
stmt->state = MYSQL_STMT_USER_FETCHING;
}
if (stmt->mysql->status!= MYSQL_STATUS_READY && stmt->field_count)
{
mysql->methods->db_stmt_flush_unbuffered(stmt);
mysql->status= MYSQL_STATUS_READY;
}
}
if (flags & MADB_RESET_SERVER)
{
/* reset statement on server side */
if (stmt->mysql && stmt->mysql->status == MYSQL_STATUS_READY &&
stmt->mysql->net.pvio)
{
unsigned char cmd_buf[STMT_ID_LENGTH];
int4store(cmd_buf, stmt->stmt_id);
if ((ret= stmt->mysql->methods->db_command(mysql,COM_STMT_RESET, (char *)cmd_buf,
sizeof(cmd_buf), 0, stmt)))
{
UPDATE_STMT_ERROR(stmt);
return(ret);
}
}
}
if (flags & MADB_RESET_LONGDATA)
{
if (stmt->params)
{
ulonglong i;
for (i=0; i < stmt->param_count; i++)
if (stmt->params[i].long_data_used)
stmt->params[i].long_data_used= 0;
}
}
}
return(ret);
} | O0 | c | madb_reset_stmt:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x44585
jmp 0x44519
movq -0x18(%rbp), %rax
movl $0x7dd, 0x108(%rax) # imm = 0x7DD
movq -0x18(%rbp), %rdi
addq $0x30d, %rdi # imm = 0x30D
leaq 0x3c967(%rip), %rax # 0x80ea0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x14220
movq -0x18(%rbp), %rax
movb $0x0, 0x312(%rax)
movq -0x18(%rbp), %rdi
addq $0x10c, %rdi # imm = 0x10C
leaq 0x3c94d(%rip), %rax # 0x80eb0
movq 0x68(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x14220
movq -0x18(%rbp), %rax
movb $0x0, 0x30b(%rax)
movb $0x1, -0xd(%rbp)
jmp 0x44926
movl -0x1c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x44630
jmp 0x44596
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movl $0x0, 0x90(%rax)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x265f1(%rip), %rsi # 0x6abaf
callq 0x143d0
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movb $0x0, 0x97(%rax)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
cmpq $0x0, 0x2a0(%rax)
je 0x445fa
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x2a0(%rax), %rax
movl $0x0, 0x4(%rax)
jmp 0x445fc
jmp 0x445fe
movq -0x18(%rbp), %rax
movl $0x0, 0x108(%rax)
movq -0x18(%rbp), %rdi
addq $0x30d, %rdi # imm = 0x30D
leaq 0x26591(%rip), %rsi # 0x6abaf
callq 0x143d0
movq -0x18(%rbp), %rax
movb $0x0, 0x10c(%rax)
jmp 0x44630
movq -0x18(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x44920
movl -0x1c(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x446bb
movq -0x18(%rbp), %rax
cmpq $0x0, 0xe0(%rax)
je 0x446bb
movq -0x18(%rbp), %rdi
addq $0x80, %rdi
addq $0x10, %rdi
movl $0x1, %esi
callq 0x3f420
movq -0x18(%rbp), %rax
movq $0x0, 0x80(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0xc8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0xe0(%rax)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movl $0x0, 0x488(%rax)
movq -0x18(%rbp), %rax
movl $0x6, 0x50(%rax)
movl -0x1c(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x4472c
movq -0x18(%rbp), %rax
cmpl $0x3, 0x50(%rax)
jne 0x446ec
movq -0x18(%rbp), %rax
movq 0x358(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq -0x18(%rbp), %rax
movl $0x5, 0x50(%rax)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
cmpl $0x0, 0x488(%rax)
je 0x4472a
movq -0x18(%rbp), %rax
cmpl $0x0, 0x60(%rax)
je 0x4472a
movq -0x28(%rbp), %rax
movq 0x4d0(%rax), %rax
movq 0x78(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq -0x28(%rbp), %rax
movl $0x0, 0x488(%rax)
jmp 0x4472c
movl -0x1c(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x448b2
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x448b0
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
cmpl $0x0, 0x488(%rax)
jne 0x448b0
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
cmpq $0x0, (%rax)
je 0x448b0
jmp 0x44773
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movb %al, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
shrq $0x8, %rax
movb %al, -0xb(%rbp)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
shrq $0x10, %rax
movb %al, -0xa(%rbp)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
shrq $0x18, %rax
movb %al, -0x9(%rbp)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x4d0(%rax), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rdi
leaq -0xc(%rbp), %rdx
movq -0x18(%rbp), %r9
movl $0x1a, %esi
movl $0x4, %ecx
xorl %r8d, %r8d
callq *%rax
movb %al, -0x29(%rbp)
cmpb $0x0, %al
je 0x448ae
jmp 0x447e6
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movl 0x90(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x108(%rax)
movq -0x18(%rbp), %rdi
addq $0x30d, %rdi # imm = 0x30D
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rsi
addq $0x297, %rsi # imm = 0x297
movl $0x5, %edx
callq 0x14220
movq -0x18(%rbp), %rax
movb $0x0, 0x312(%rax)
movq -0x18(%rbp), %rax
addq $0x10c, %rax # imm = 0x10C
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
addq $0x97, %rax
cmpq $0x0, %rax
je 0x44863
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
addq $0x97, %rax
movq %rax, -0x48(%rbp)
jmp 0x44889
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movl 0x90(%rax), %eax
subl $0x7d0, %eax # imm = 0x7D0
movl %eax, %eax
movl %eax, %ecx
leaq 0x3c62f(%rip), %rax # 0x80eb0
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x14220
movq -0x18(%rbp), %rax
movb $0x0, 0x30b(%rax)
movb -0x29(%rbp), %al
movb %al, -0xd(%rbp)
jmp 0x44926
jmp 0x448b0
jmp 0x448b2
movl -0x1c(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4491e
movq -0x18(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x4491c
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x64(%rcx), %ecx
cmpq %rcx, %rax
jae 0x4491a
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
imulq $0x70, -0x38(%rbp), %rcx
addq %rcx, %rax
cmpb $0x0, 0x66(%rax)
je 0x4490a
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
imulq $0x70, -0x38(%rbp), %rcx
addq %rcx, %rax
movb $0x0, 0x66(%rax)
jmp 0x4490c
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x448d0
jmp 0x4491c
jmp 0x4491e
jmp 0x44920
movb -0x29(%rbp), %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
movb %al, -0x49(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x44947
movb -0x49(%rbp), %al
addq $0x50, %rsp
popq %rbp
retq
callq 0x144c0
nopl (%rax)
| madb_reset_stmt:
push rbp
mov rbp, rsp
sub rsp, 50h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov [rbp+var_28], rax
mov [rbp+var_29], 0
mov rax, [rbp+var_18]
cmp qword ptr [rax+38h], 0
jnz short loc_44585
jmp short $+2
loc_44519:
mov rax, [rbp+var_18]
mov dword ptr [rax+108h], 7DDh
mov rdi, [rbp+var_18]
add rdi, 30Dh
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_18]
mov byte ptr [rax+312h], 0
mov rdi, [rbp+var_18]
add rdi, 10Ch
lea rax, client_errors
mov rsi, [rax+68h]
mov edx, 200h
call _strncpy
mov rax, [rbp+var_18]
mov byte ptr [rax+30Bh], 0
mov [rbp+var_D], 1
jmp loc_44926
loc_44585:
mov eax, [rbp+var_1C]
and eax, 1
cmp eax, 0
jz loc_44630
jmp short $+2
loc_44596:
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov dword ptr [rax+90h], 0
mov rax, [rbp+var_18]
mov rdi, [rax+38h]
add rdi, 297h
lea rsi, a00000; "00000"
call _strcpy
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov byte ptr [rax+97h], 0
mov rax, [rbp+var_18]
mov rax, [rax+38h]
cmp qword ptr [rax+2A0h], 0
jz short loc_445FA
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov rax, [rax+2A0h]
mov dword ptr [rax+4], 0
loc_445FA:
jmp short $+2
loc_445FC:
jmp short $+2
loc_445FE:
mov rax, [rbp+var_18]
mov dword ptr [rax+108h], 0
mov rdi, [rbp+var_18]
add rdi, 30Dh
lea rsi, a00000; "00000"
call _strcpy
mov rax, [rbp+var_18]
mov byte ptr [rax+10Ch], 0
jmp short $+2
loc_44630:
mov rax, [rbp+var_18]
cmp qword ptr [rax+40h], 0
jz loc_44920
mov eax, [rbp+var_1C]
and eax, 10h
cmp eax, 0
jz short loc_446BB
mov rax, [rbp+var_18]
cmp qword ptr [rax+0E0h], 0
jz short loc_446BB
mov rdi, [rbp+var_18]
add rdi, 80h
add rdi, 10h
mov esi, 1
call ma_free_root
mov rax, [rbp+var_18]
mov qword ptr [rax+80h], 0
mov rax, [rbp+var_18]
mov qword ptr [rax+0C8h], 0
mov rax, [rbp+var_18]
mov qword ptr [rax+0E0h], 0
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov dword ptr [rax+488h], 0
mov rax, [rbp+var_18]
mov dword ptr [rax+50h], 6
loc_446BB:
mov eax, [rbp+var_1C]
and eax, 8
cmp eax, 0
jz short loc_4472C
mov rax, [rbp+var_18]
cmp dword ptr [rax+50h], 3
jnz short loc_446EC
mov rax, [rbp+var_18]
mov rax, [rax+358h]
mov rdi, [rbp+var_18]
call rax
mov rax, [rbp+var_18]
mov dword ptr [rax+50h], 5
loc_446EC:
mov rax, [rbp+var_18]
mov rax, [rax+38h]
cmp dword ptr [rax+488h], 0
jz short loc_4472A
mov rax, [rbp+var_18]
cmp dword ptr [rax+60h], 0
jz short loc_4472A
mov rax, [rbp+var_28]
mov rax, [rax+4D0h]
mov rax, [rax+78h]
mov rdi, [rbp+var_18]
call rax
mov rax, [rbp+var_28]
mov dword ptr [rax+488h], 0
loc_4472A:
jmp short $+2
loc_4472C:
mov eax, [rbp+var_1C]
and eax, 4
cmp eax, 0
jz loc_448B2
mov rax, [rbp+var_18]
cmp qword ptr [rax+38h], 0
jz loc_448B0
mov rax, [rbp+var_18]
mov rax, [rax+38h]
cmp dword ptr [rax+488h], 0
jnz loc_448B0
mov rax, [rbp+var_18]
mov rax, [rax+38h]
cmp qword ptr [rax], 0
jz loc_448B0
jmp short $+2
loc_44773:
mov rax, [rbp+var_18]
mov rax, [rax+40h]
mov [rbp+var_C], al
mov rax, [rbp+var_18]
mov rax, [rax+40h]
shr rax, 8
mov [rbp+var_B], al
mov rax, [rbp+var_18]
mov rax, [rax+40h]
shr rax, 10h
mov [rbp+var_A], al
mov rax, [rbp+var_18]
mov rax, [rax+40h]
shr rax, 18h
mov [rbp+var_9], al
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov rax, [rax+4D0h]
mov rax, [rax+10h]
mov rdi, [rbp+var_28]
lea rdx, [rbp+var_C]
mov r9, [rbp+var_18]
mov esi, 1Ah
mov ecx, 4
xor r8d, r8d
call rax
mov [rbp+var_29], al
cmp al, 0
jz loc_448AE
jmp short $+2
loc_447E6:
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov ecx, [rax+90h]
mov rax, [rbp+var_18]
mov [rax+108h], ecx
mov rdi, [rbp+var_18]
add rdi, 30Dh
mov rax, [rbp+var_18]
mov rsi, [rax+38h]
add rsi, 297h
mov edx, 5
call _strncpy
mov rax, [rbp+var_18]
mov byte ptr [rax+312h], 0
mov rax, [rbp+var_18]
add rax, 10Ch
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
mov rax, [rax+38h]
add rax, 97h
cmp rax, 0
jz short loc_44863
mov rax, [rbp+var_18]
mov rax, [rax+38h]
add rax, 97h
mov [rbp+var_48], rax
jmp short loc_44889
loc_44863:
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov eax, [rax+90h]
sub eax, 7D0h
mov eax, eax
mov ecx, eax
lea rax, client_errors
mov rax, [rax+rcx*8]
mov [rbp+var_48], rax
loc_44889:
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_48]
mov edx, 200h
call _strncpy
mov rax, [rbp+var_18]
mov byte ptr [rax+30Bh], 0
mov al, [rbp+var_29]
mov [rbp+var_D], al
jmp short loc_44926
loc_448AE:
jmp short $+2
loc_448B0:
jmp short $+2
loc_448B2:
mov eax, [rbp+var_1C]
and eax, 2
cmp eax, 0
jz short loc_4491E
mov rax, [rbp+var_18]
cmp qword ptr [rax+70h], 0
jz short loc_4491C
mov [rbp+var_38], 0
loc_448D0:
mov rax, [rbp+var_38]
mov rcx, [rbp+var_18]
mov ecx, [rcx+64h]
cmp rax, rcx
jnb short loc_4491A
mov rax, [rbp+var_18]
mov rax, [rax+70h]
imul rcx, [rbp+var_38], 70h ; 'p'
add rax, rcx
cmp byte ptr [rax+66h], 0
jz short loc_4490A
mov rax, [rbp+var_18]
mov rax, [rax+70h]
imul rcx, [rbp+var_38], 70h ; 'p'
add rax, rcx
mov byte ptr [rax+66h], 0
loc_4490A:
jmp short $+2
loc_4490C:
mov rax, [rbp+var_38]
add rax, 1
mov [rbp+var_38], rax
jmp short loc_448D0
loc_4491A:
jmp short $+2
loc_4491C:
jmp short $+2
loc_4491E:
jmp short $+2
loc_44920:
mov al, [rbp+var_29]
mov [rbp+var_D], al
loc_44926:
mov al, [rbp+var_D]
mov [rbp+var_49], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_44947
mov al, [rbp+var_49]
add rsp, 50h
pop rbp
retn
loc_44947:
call ___stack_chk_fail
| char madb_reset_stmt(long long a1, char a2)
{
char *v2; // rax
unsigned long long i; // [rsp+18h] [rbp-38h]
char v5; // [rsp+27h] [rbp-29h]
long long v6; // [rsp+28h] [rbp-28h]
_BYTE v8[4]; // [rsp+44h] [rbp-Ch] BYREF
unsigned long long v9; // [rsp+48h] [rbp-8h]
v9 = __readfsqword(0x28u);
v6 = *(_QWORD *)(a1 + 56);
if ( !v6 )
{
*(_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;
}
if ( (a2 & 1) != 0 )
{
*(_DWORD *)(*(_QWORD *)(a1 + 56) + 144LL) = 0;
strcpy(*(_QWORD *)(a1 + 56) + 663LL, "00000");
*(_BYTE *)(*(_QWORD *)(a1 + 56) + 151LL) = 0;
if ( *(_QWORD *)(*(_QWORD *)(a1 + 56) + 672LL) )
*(_DWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 56) + 672LL) + 4LL) = 0;
*(_DWORD *)(a1 + 264) = 0;
strcpy(a1 + 781, "00000");
*(_BYTE *)(a1 + 268) = 0;
}
if ( !*(_QWORD *)(a1 + 64) )
return 0;
if ( (a2 & 0x10) != 0 && *(_QWORD *)(a1 + 224) )
{
ma_free_root((_QWORD *)(a1 + 144), 1);
*(_QWORD *)(a1 + 128) = 0LL;
*(_QWORD *)(a1 + 200) = 0LL;
*(_QWORD *)(a1 + 224) = 0LL;
*(_DWORD *)(*(_QWORD *)(a1 + 56) + 1160LL) = 0;
*(_DWORD *)(a1 + 80) = 6;
}
if ( (a2 & 8) != 0 )
{
if ( *(_DWORD *)(a1 + 80) == 3 )
{
(*(void ( **)(long long))(a1 + 856))(a1);
*(_DWORD *)(a1 + 80) = 5;
}
if ( *(_DWORD *)(*(_QWORD *)(a1 + 56) + 1160LL) && *(_DWORD *)(a1 + 96) )
{
(*(void ( **)(long long))(*(_QWORD *)(v6 + 1232) + 120LL))(a1);
*(_DWORD *)(v6 + 1160) = 0;
}
}
if ( (a2 & 4) == 0
|| !*(_QWORD *)(a1 + 56)
|| *(_DWORD *)(*(_QWORD *)(a1 + 56) + 1160LL)
|| !**(_QWORD **)(a1 + 56)
|| (v8[0] = *(_QWORD *)(a1 + 64),
v8[1] = BYTE1(*(_QWORD *)(a1 + 64)),
v8[2] = BYTE2(*(_QWORD *)(a1 + 64)),
v8[3] = BYTE3(*(_QWORD *)(a1 + 64)),
(v5 = (*(long long ( **)(long long, long long, _BYTE *, long long, _QWORD, long long))(*(_QWORD *)(*(_QWORD *)(a1 + 56) + 1232LL)
+ 16LL))(
v6,
26LL,
v8,
4LL,
0LL,
a1)) == 0) )
{
if ( (a2 & 2) != 0 && *(_QWORD *)(a1 + 112) )
{
for ( i = 0LL; i < *(unsigned int *)(a1 + 100); ++i )
{
if ( *(_BYTE *)(112 * i + *(_QWORD *)(a1 + 112) + 102) )
*(_BYTE *)(112 * i + *(_QWORD *)(a1 + 112) + 102) = 0;
}
}
return 0;
}
*(_DWORD *)(a1 + 264) = *(_DWORD *)(*(_QWORD *)(a1 + 56) + 144LL);
strncpy(a1 + 781, *(_QWORD *)(a1 + 56) + 663LL, 5LL);
*(_BYTE *)(a1 + 786) = 0;
if ( *(_QWORD *)(a1 + 56) == -151LL )
v2 = client_errors[*(_DWORD *)(*(_QWORD *)(a1 + 56) + 144LL) - 2000];
else
v2 = (char *)(*(_QWORD *)(a1 + 56) + 151LL);
strncpy(a1 + 268, v2, 512LL);
*(_BYTE *)(a1 + 779) = 0;
return v5;
}
| madb_reset_stmt:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV qword ptr [RBP + -0x28],RAX
MOV byte ptr [RBP + -0x29],0x0
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x38],0x0
JNZ 0x00144585
JMP 0x00144519
LAB_00144519:
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x108],0x7dd
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x30d
LEA RAX,[0x180ea0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00114220
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x312],0x0
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x10c
LEA RAX,[0x180eb0]
MOV RSI,qword ptr [RAX + 0x68]
MOV EDX,0x200
CALL 0x00114220
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x30b],0x0
MOV byte ptr [RBP + -0xd],0x1
JMP 0x00144926
LAB_00144585:
MOV EAX,dword ptr [RBP + -0x1c]
AND EAX,0x1
CMP EAX,0x0
JZ 0x00144630
JMP 0x00144596
LAB_00144596:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV dword ptr [RAX + 0x90],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x38]
ADD RDI,0x297
LEA RSI,[0x16abaf]
CALL 0x001143d0
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV byte ptr [RAX + 0x97],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
CMP qword ptr [RAX + 0x2a0],0x0
JZ 0x001445fa
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x2a0]
MOV dword ptr [RAX + 0x4],0x0
LAB_001445fa:
JMP 0x001445fc
LAB_001445fc:
JMP 0x001445fe
LAB_001445fe:
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x108],0x0
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x30d
LEA RSI,[0x16abaf]
CALL 0x001143d0
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x10c],0x0
JMP 0x00144630
LAB_00144630:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x40],0x0
JZ 0x00144920
MOV EAX,dword ptr [RBP + -0x1c]
AND EAX,0x10
CMP EAX,0x0
JZ 0x001446bb
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0xe0],0x0
JZ 0x001446bb
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x80
ADD RDI,0x10
MOV ESI,0x1
CALL 0x0013f420
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x80],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0xc8],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0xe0],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV dword ptr [RAX + 0x488],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x50],0x6
LAB_001446bb:
MOV EAX,dword ptr [RBP + -0x1c]
AND EAX,0x8
CMP EAX,0x0
JZ 0x0014472c
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0x50],0x3
JNZ 0x001446ec
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x358]
MOV RDI,qword ptr [RBP + -0x18]
CALL RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x50],0x5
LAB_001446ec:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
CMP dword ptr [RAX + 0x488],0x0
JZ 0x0014472a
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0x60],0x0
JZ 0x0014472a
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RAX,qword ptr [RAX + 0x78]
MOV RDI,qword ptr [RBP + -0x18]
CALL RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x488],0x0
LAB_0014472a:
JMP 0x0014472c
LAB_0014472c:
MOV EAX,dword ptr [RBP + -0x1c]
AND EAX,0x4
CMP EAX,0x0
JZ 0x001448b2
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x38],0x0
JZ 0x001448b0
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
CMP dword ptr [RAX + 0x488],0x0
JNZ 0x001448b0
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
CMP qword ptr [RAX],0x0
JZ 0x001448b0
JMP 0x00144773
LAB_00144773:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x40]
MOV byte ptr [RBP + -0xc],AL
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x40]
SHR RAX,0x8
MOV byte ptr [RBP + -0xb],AL
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x40]
SHR RAX,0x10
MOV byte ptr [RBP + -0xa],AL
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x40]
SHR RAX,0x18
MOV byte ptr [RBP + -0x9],AL
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RAX,qword ptr [RAX + 0x10]
MOV RDI,qword ptr [RBP + -0x28]
LEA RDX,[RBP + -0xc]
MOV R9,qword ptr [RBP + -0x18]
MOV ESI,0x1a
MOV ECX,0x4
XOR R8D,R8D
CALL RAX
MOV byte ptr [RBP + -0x29],AL
CMP AL,0x0
JZ 0x001448ae
JMP 0x001447e6
LAB_001447e6:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV ECX,dword ptr [RAX + 0x90]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x108],ECX
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x30d
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX + 0x38]
ADD RSI,0x297
MOV EDX,0x5
CALL 0x00114220
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x312],0x0
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x10c
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
ADD RAX,0x97
CMP RAX,0x0
JZ 0x00144863
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
ADD RAX,0x97
MOV qword ptr [RBP + -0x48],RAX
JMP 0x00144889
LAB_00144863:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV EAX,dword ptr [RAX + 0x90]
SUB EAX,0x7d0
MOV EAX,EAX
MOV ECX,EAX
LEA RAX,[0x180eb0]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x48],RAX
LAB_00144889:
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x48]
MOV EDX,0x200
CALL 0x00114220
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x30b],0x0
MOV AL,byte ptr [RBP + -0x29]
MOV byte ptr [RBP + -0xd],AL
JMP 0x00144926
LAB_001448ae:
JMP 0x001448b0
LAB_001448b0:
JMP 0x001448b2
LAB_001448b2:
MOV EAX,dword ptr [RBP + -0x1c]
AND EAX,0x2
CMP EAX,0x0
JZ 0x0014491e
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x70],0x0
JZ 0x0014491c
MOV qword ptr [RBP + -0x38],0x0
LAB_001448d0:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RCX + 0x64]
CMP RAX,RCX
JNC 0x0014491a
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x70]
IMUL RCX,qword ptr [RBP + -0x38],0x70
ADD RAX,RCX
CMP byte ptr [RAX + 0x66],0x0
JZ 0x0014490a
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x70]
IMUL RCX,qword ptr [RBP + -0x38],0x70
ADD RAX,RCX
MOV byte ptr [RAX + 0x66],0x0
LAB_0014490a:
JMP 0x0014490c
LAB_0014490c:
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x1
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001448d0
LAB_0014491a:
JMP 0x0014491c
LAB_0014491c:
JMP 0x0014491e
LAB_0014491e:
JMP 0x00144920
LAB_00144920:
MOV AL,byte ptr [RBP + -0x29]
MOV byte ptr [RBP + -0xd],AL
LAB_00144926:
MOV AL,byte ptr [RBP + -0xd]
MOV byte ptr [RBP + -0x49],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00144947
MOV AL,byte ptr [RBP + -0x49]
ADD RSP,0x50
POP RBP
RET
LAB_00144947:
CALL 0x001144c0
|
int8 madb_reset_stmt(long param_1,uint param_2)
{
long lVar1;
long in_FS_OFFSET;
char *local_50;
ulong local_40;
char local_31;
char local_15;
int1 local_14;
int1 local_13;
int1 local_12;
int1 local_11;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
lVar1 = *(long *)(param_1 + 0x38);
local_31 = '\0';
if (*(long *)(param_1 + 0x38) == 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_00180f18,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
local_15 = '\x01';
}
else {
if ((param_2 & 1) != 0) {
*(int4 *)(*(long *)(param_1 + 0x38) + 0x90) = 0;
strcpy((char *)(*(long *)(param_1 + 0x38) + 0x297),"00000");
*(int1 *)(*(long *)(param_1 + 0x38) + 0x97) = 0;
if (*(long *)(*(long *)(param_1 + 0x38) + 0x2a0) != 0) {
*(int4 *)(*(long *)(*(long *)(param_1 + 0x38) + 0x2a0) + 4) = 0;
}
*(int4 *)(param_1 + 0x108) = 0;
strcpy((char *)(param_1 + 0x30d),"00000");
*(int1 *)(param_1 + 0x10c) = 0;
}
if (*(long *)(param_1 + 0x40) != 0) {
if (((param_2 & 0x10) != 0) && (*(long *)(param_1 + 0xe0) != 0)) {
ma_free_root(param_1 + 0x90,1);
*(int8 *)(param_1 + 0x80) = 0;
*(int8 *)(param_1 + 200) = 0;
*(int8 *)(param_1 + 0xe0) = 0;
*(int4 *)(*(long *)(param_1 + 0x38) + 0x488) = 0;
*(int4 *)(param_1 + 0x50) = 6;
}
if ((param_2 & 8) != 0) {
if (*(int *)(param_1 + 0x50) == 3) {
(**(code **)(param_1 + 0x358))(param_1);
*(int4 *)(param_1 + 0x50) = 5;
}
if ((*(int *)(*(long *)(param_1 + 0x38) + 0x488) != 0) && (*(int *)(param_1 + 0x60) != 0)) {
(**(code **)(*(long *)(lVar1 + 0x4d0) + 0x78))(param_1);
*(int4 *)(lVar1 + 0x488) = 0;
}
}
if (((((param_2 & 4) != 0) && (*(long *)(param_1 + 0x38) != 0)) &&
(*(int *)(*(long *)(param_1 + 0x38) + 0x488) == 0)) && (**(long **)(param_1 + 0x38) != 0))
{
local_14 = (int1)*(int8 *)(param_1 + 0x40);
local_13 = (int1)((ulong)*(int8 *)(param_1 + 0x40) >> 8);
local_12 = (int1)((ulong)*(int8 *)(param_1 + 0x40) >> 0x10);
local_11 = (int1)((ulong)*(int8 *)(param_1 + 0x40) >> 0x18);
local_31 = (**(code **)(*(long *)(*(long *)(param_1 + 0x38) + 0x4d0) + 0x10))
(lVar1,0x1a,&local_14,4,0,param_1);
if (local_31 != '\0') {
*(int4 *)(param_1 + 0x108) = *(int4 *)(*(long *)(param_1 + 0x38) + 0x90);
strncpy((char *)(param_1 + 0x30d),(char *)(*(long *)(param_1 + 0x38) + 0x297),5);
*(int1 *)(param_1 + 0x312) = 0;
if (*(long *)(param_1 + 0x38) == -0x97) {
local_50 = (&client_errors)[*(int *)(*(long *)(param_1 + 0x38) + 0x90) - 2000];
}
else {
local_50 = (char *)(*(long *)(param_1 + 0x38) + 0x97);
}
strncpy((char *)(param_1 + 0x10c),local_50,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
local_15 = local_31;
goto LAB_00144926;
}
}
if (((param_2 & 2) != 0) && (*(long *)(param_1 + 0x70) != 0)) {
for (local_40 = 0; local_40 < *(uint *)(param_1 + 100); local_40 = local_40 + 1) {
if (*(char *)(*(long *)(param_1 + 0x70) + local_40 * 0x70 + 0x66) != '\0') {
*(int1 *)(*(long *)(param_1 + 0x70) + local_40 * 0x70 + 0x66) = 0;
}
}
}
}
local_15 = local_31;
}
LAB_00144926:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),local_15);
}
| |
54,176 | net_realloc | eloqsql/libmariadb/libmariadb/ma_net.c | static my_bool net_realloc(NET *net, size_t length)
{
uchar *buff;
size_t pkt_length;
if (length >= net->max_packet_size)
{
net->error=1;
net->pvio->set_error(net->pvio->mysql, CR_NET_PACKET_TOO_LARGE, SQLSTATE_UNKNOWN, 0);
return(1);
}
pkt_length = (length+IO_SIZE-1) & ~(IO_SIZE-1);
/* reallocate buffer:
size= pkt_length + NET_HEADER_SIZE + COMP_HEADER_SIZE */
if (!(buff=(uchar*) realloc(net->buff,
pkt_length + NET_HEADER_SIZE + COMP_HEADER_SIZE)))
{
net->error=1;
return(1);
}
net->buff=net->write_pos=buff;
net->buff_end=buff+(net->max_packet=(unsigned long)pkt_length);
return(0);
} | O0 | c | net_realloc:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x58(%rcx), %rax
jb 0x46c0d
movq -0x10(%rbp), %rax
movb $0x1, 0x94(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x50(%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x40(%rax), %rdi
leaq 0x1928a(%rip), %rax # 0x5fe80
movq (%rax), %rdx
movl $0x7e4, %esi # imm = 0x7E4
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq *%r8
movb $0x1, -0x1(%rbp)
jmp 0x46c8c
movq -0x18(%rbp), %rax
addq $0x1000, %rax # imm = 0x1000
subq $0x1, %rax
andq $-0x1000, %rax # imm = 0xF000
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x4, %rsi
addq $0x3, %rsi
callq 0x13700
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x46c59
movq -0x10(%rbp), %rax
movb $0x1, 0x94(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x46c8c
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdx
movq %rax, 0x50(%rdx)
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| net_realloc:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
cmp rax, [rcx+58h]
jb short loc_46C0D
mov rax, [rbp+var_10]
mov byte ptr [rax+94h], 1
mov rax, [rbp+var_10]
mov rax, [rax]
mov r8, [rax+50h]
mov rax, [rbp+var_10]
mov rax, [rax]
mov rdi, [rax+40h]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov esi, 7E4h
xor eax, eax
mov ecx, eax
mov al, 0
call r8
mov [rbp+var_1], 1
jmp short loc_46C8C
loc_46C0D:
mov rax, [rbp+var_18]
add rax, 1000h
sub rax, 1
and rax, 0FFFFFFFFFFFFF000h
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov rdi, [rax+8]
mov rsi, [rbp+var_28]
add rsi, 4
add rsi, 3
call _realloc
mov [rbp+var_20], rax
cmp rax, 0
jnz short loc_46C59
mov rax, [rbp+var_10]
mov byte ptr [rax+94h], 1
mov [rbp+var_1], 1
jmp short loc_46C8C
loc_46C59:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax+18h], rcx
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rcx, [rbp+var_20]
mov rax, [rbp+var_28]
mov rdx, [rbp+var_10]
mov [rdx+50h], rax
add rcx, rax
mov rax, [rbp+var_10]
mov [rax+10h], rcx
mov [rbp+var_1], 0
loc_46C8C:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char net_realloc(_QWORD *a1, unsigned long long a2)
{
unsigned long long v3; // [rsp+8h] [rbp-28h]
long long v4; // [rsp+10h] [rbp-20h]
if ( a2 < a1[11] )
{
v3 = (a2 + 4095) & 0xFFFFFFFFFFFFF000LL;
v4 = realloc(a1[1], v3 + 7);
if ( v4 )
{
a1[3] = v4;
a1[1] = v4;
a1[10] = v3;
a1[2] = v3 + v4;
return 0;
}
else
{
*((_BYTE *)a1 + 148) = 1;
return 1;
}
}
else
{
*((_BYTE *)a1 + 148) = 1;
(*(void ( **)(_QWORD, long long, char *, _QWORD))(*a1 + 80LL))(
*(_QWORD *)(*a1 + 64LL),
2020LL,
SQLSTATE_UNKNOWN,
0LL);
return 1;
}
}
| net_realloc:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x58]
JC 0x00146c0d
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x94],0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV R8,qword ptr [RAX + 0x50]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + 0x40]
LEA RAX,[0x15fe80]
MOV RDX,qword ptr [RAX]
MOV ESI,0x7e4
XOR EAX,EAX
MOV ECX,EAX
MOV AL,0x0
CALL R8
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00146c8c
LAB_00146c0d:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1000
SUB RAX,0x1
AND RAX,-0x1000
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x8]
MOV RSI,qword ptr [RBP + -0x28]
ADD RSI,0x4
ADD RSI,0x3
CALL 0x00113700
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JNZ 0x00146c59
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x94],0x1
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00146c8c
LAB_00146c59:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x10]
MOV qword ptr [RDX + 0x50],RAX
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV byte ptr [RBP + -0x1],0x0
LAB_00146c8c:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 net_realloc(long *param_1,ulong param_2)
{
ulong uVar1;
void *pvVar2;
int1 local_9;
if (param_2 < (ulong)param_1[0xb]) {
uVar1 = param_2 + 0xfff & 0xfffffffffffff000;
pvVar2 = realloc((void *)param_1[1],uVar1 + 7);
if (pvVar2 == (void *)0x0) {
*(int1 *)((long)param_1 + 0x94) = 1;
local_9 = 1;
}
else {
param_1[3] = (long)pvVar2;
param_1[1] = (long)pvVar2;
param_1[10] = uVar1;
param_1[2] = (long)pvVar2 + uVar1;
local_9 = 0;
}
}
else {
*(int1 *)((long)param_1 + 0x94) = 1;
(**(code **)(*param_1 + 0x50))(*(int8 *)(*param_1 + 0x40),0x7e4,SQLSTATE_UNKNOWN,0);
local_9 = 1;
}
return local_9;
}
| |
54,177 | my_strcasecmp_mb | eloqsql/strings/ctype-mb.c | int my_strcasecmp_mb(CHARSET_INFO * cs,const char *s, const char *t)
{
register uint32 l;
register const uchar *map=cs->to_upper;
while (*s && *t)
{
/* Pointing after the '\0' is safe here. */
if ((l=my_ismbchar(cs, s, s + cs->mbmaxlen)))
{
while (l--)
if (*s++ != *t++)
return 1;
}
else if (my_ci_charlen(cs, (const uchar *) t, (const uchar *) t + cs->mbmaxlen) > 1)
return 1;
else if (map[(uchar) *s++] != map[(uchar) *t++])
return 1;
}
/* At least one of '*s' and '*t' is zero here. */
return (*t != *s);
} | O3 | c | my_strcasecmp_mb:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movb (%rsi), %cl
testb %cl, %cl
je 0x39ed7
cmpb $0x0, (%rbx)
je 0x39ed9
movq %rsi, %r15
movq %rdi, %r14
movq 0x50(%rdi), %r12
movl 0x9c(%r14), %edx
addq %r15, %rdx
movq 0xb8(%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0xc0(%rax)
cmpl $0x2, %eax
jge 0x39e9c
movl 0x9c(%r14), %edx
addq %rbx, %rdx
movq 0xb8(%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0xc0(%rax)
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x1, %ecx
jg 0x39ee7
movzbl (%r15), %ecx
movb (%r12,%rcx), %cl
movzbl (%rbx), %edx
cmpb (%r12,%rdx), %cl
jne 0x39ee7
incq %r15
incq %rbx
jmp 0x39ec5
movl %eax, %eax
leaq (%r15,%rax), %rcx
leaq (%rbx,%rax), %rdx
xorl %esi, %esi
cmpl %esi, %eax
je 0x39ebf
movb (%r15,%rsi), %dil
leaq 0x1(%rsi), %r8
cmpb (%rbx,%rsi), %dil
movq %r8, %rsi
je 0x39ea8
jmp 0x39ee2
movq %rcx, %r15
movq %rdx, %rbx
movb (%r15), %cl
testb %cl, %cl
je 0x39ed7
cmpb $0x0, (%rbx)
jne 0x39e38
jmp 0x39ed9
xorl %ecx, %ecx
xorl %eax, %eax
cmpb %cl, (%rbx)
setne %al
jmp 0x39ee7
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| my_strcasecmp_mb:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rdx
mov cl, [rsi]
test cl, cl
jz loc_39ED7
cmp byte ptr [rbx], 0
jz loc_39ED9
mov r15, rsi
mov r14, rdi
mov r12, [rdi+50h]
loc_39E38:
mov edx, [r14+9Ch]
add rdx, r15
mov rax, [r14+0B8h]
mov rdi, r14
mov rsi, r15
call qword ptr [rax+0C0h]
cmp eax, 2
jge short loc_39E9C
mov edx, [r14+9Ch]
add rdx, rbx
mov rax, [r14+0B8h]
mov rdi, r14
mov rsi, rbx
call qword ptr [rax+0C0h]
mov ecx, eax
mov eax, 1
cmp ecx, 1
jg short loc_39EE7
movzx ecx, byte ptr [r15]
mov cl, [r12+rcx]
movzx edx, byte ptr [rbx]
cmp cl, [r12+rdx]
jnz short loc_39EE7
inc r15
inc rbx
jmp short loc_39EC5
loc_39E9C:
mov eax, eax
lea rcx, [r15+rax]
lea rdx, [rbx+rax]
xor esi, esi
loc_39EA8:
cmp eax, esi
jz short loc_39EBF
mov dil, [r15+rsi]
lea r8, [rsi+1]
cmp dil, [rbx+rsi]
mov rsi, r8
jz short loc_39EA8
jmp short loc_39EE2
loc_39EBF:
mov r15, rcx
mov rbx, rdx
loc_39EC5:
mov cl, [r15]
test cl, cl
jz short loc_39ED7
cmp byte ptr [rbx], 0
jnz loc_39E38
jmp short loc_39ED9
loc_39ED7:
xor ecx, ecx
loc_39ED9:
xor eax, eax
cmp [rbx], cl
setnz al
jmp short loc_39EE7
loc_39EE2:
mov eax, 1
loc_39EE7:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| _BOOL8 my_strcasecmp_mb(long long a1, unsigned __int8 *a2, _BYTE *a3)
{
_BYTE *v3; // rbx
unsigned __int8 v4; // cl
unsigned __int8 *v5; // r15
long long v6; // r12
int v7; // eax
int v8; // ecx
_BOOL8 result; // rax
long long i; // rsi
v3 = a3;
v4 = *a2;
if ( *a2 )
{
if ( *a3 )
{
v5 = a2;
v6 = *(_QWORD *)(a1 + 80);
do
{
v7 = (*(long long ( **)(long long, unsigned __int8 *, unsigned __int8 *))(*(_QWORD *)(a1 + 184) + 192LL))(
a1,
v5,
&v5[*(unsigned int *)(a1 + 156)]);
if ( v7 >= 2 )
{
for ( i = 0LL; v7 != (_DWORD)i; ++i )
{
if ( v5[i] != v3[i] )
return 1LL;
}
v5 += (unsigned int)v7;
v3 += (unsigned int)v7;
}
else
{
v8 = (*(long long ( **)(long long, _BYTE *, _BYTE *))(*(_QWORD *)(a1 + 184) + 192LL))(
a1,
v3,
&v3[*(unsigned int *)(a1 + 156)]);
result = 1LL;
if ( v8 > 1 || *(_BYTE *)(v6 + *v5) != *(_BYTE *)(v6 + (unsigned __int8)*v3) )
return result;
++v5;
++v3;
}
v4 = *v5;
if ( !*v5 )
goto LABEL_16;
}
while ( *v3 );
}
}
else
{
LABEL_16:
v4 = 0;
}
return *v3 != v4;
}
| my_strcasecmp_mb:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RDX
MOV CL,byte ptr [RSI]
TEST CL,CL
JZ 0x00139ed7
CMP byte ptr [RBX],0x0
JZ 0x00139ed9
MOV R15,RSI
MOV R14,RDI
MOV R12,qword ptr [RDI + 0x50]
LAB_00139e38:
MOV EDX,dword ptr [R14 + 0x9c]
ADD RDX,R15
MOV RAX,qword ptr [R14 + 0xb8]
MOV RDI,R14
MOV RSI,R15
CALL qword ptr [RAX + 0xc0]
CMP EAX,0x2
JGE 0x00139e9c
MOV EDX,dword ptr [R14 + 0x9c]
ADD RDX,RBX
MOV RAX,qword ptr [R14 + 0xb8]
MOV RDI,R14
MOV RSI,RBX
CALL qword ptr [RAX + 0xc0]
MOV ECX,EAX
MOV EAX,0x1
CMP ECX,0x1
JG 0x00139ee7
MOVZX ECX,byte ptr [R15]
MOV CL,byte ptr [R12 + RCX*0x1]
MOVZX EDX,byte ptr [RBX]
CMP CL,byte ptr [R12 + RDX*0x1]
JNZ 0x00139ee7
INC R15
INC RBX
JMP 0x00139ec5
LAB_00139e9c:
MOV EAX,EAX
LEA RCX,[R15 + RAX*0x1]
LEA RDX,[RBX + RAX*0x1]
XOR ESI,ESI
LAB_00139ea8:
CMP EAX,ESI
JZ 0x00139ebf
MOV DIL,byte ptr [R15 + RSI*0x1]
LEA R8,[RSI + 0x1]
CMP DIL,byte ptr [RBX + RSI*0x1]
MOV RSI,R8
JZ 0x00139ea8
JMP 0x00139ee2
LAB_00139ebf:
MOV R15,RCX
MOV RBX,RDX
LAB_00139ec5:
MOV CL,byte ptr [R15]
TEST CL,CL
JZ 0x00139ed7
CMP byte ptr [RBX],0x0
JNZ 0x00139e38
JMP 0x00139ed9
LAB_00139ed7:
XOR ECX,ECX
LAB_00139ed9:
XOR EAX,EAX
CMP byte ptr [RBX],CL
SETNZ AL
JMP 0x00139ee7
LAB_00139ee2:
MOV EAX,0x1
LAB_00139ee7:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
bool my_strcasecmp_mb(long param_1,byte *param_2,byte *param_3)
{
byte *pbVar1;
byte *pbVar2;
long lVar3;
uint uVar4;
int iVar5;
byte bVar6;
byte *pbVar7;
long lVar8;
byte *pbVar9;
bVar6 = *param_2;
if (bVar6 == 0) {
LAB_00139ed7:
bVar6 = 0;
}
else if (*param_3 != 0) {
lVar3 = *(long *)(param_1 + 0x50);
pbVar7 = param_3;
do {
uVar4 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))
(param_1,param_2,param_2 + *(uint *)(param_1 + 0x9c));
if ((int)uVar4 < 2) {
iVar5 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))
(param_1,pbVar7,pbVar7 + *(uint *)(param_1 + 0x9c));
if (1 < iVar5) {
return true;
}
if (*(char *)(lVar3 + (ulong)*param_2) != *(char *)(lVar3 + (ulong)*pbVar7)) {
return true;
}
pbVar9 = param_2 + 1;
param_3 = pbVar7 + 1;
}
else {
pbVar9 = param_2 + uVar4;
param_3 = pbVar7 + uVar4;
lVar8 = 0;
while (uVar4 != (uint)lVar8) {
pbVar1 = param_2 + lVar8;
pbVar2 = pbVar7 + lVar8;
lVar8 = lVar8 + 1;
if (*pbVar1 != *pbVar2) {
return true;
}
}
}
bVar6 = *pbVar9;
if (bVar6 == 0) goto LAB_00139ed7;
pbVar7 = param_3;
param_2 = pbVar9;
} while (*param_3 != 0);
}
return *param_3 != bVar6;
}
| |
54,178 | rtree_delete | eloqsql/storage/myisam/rt_index.c | int rtree_delete(MI_INFO *info, uint keynr, uchar *key, uint key_length)
{
uint page_size;
stPageList ReinsertList;
my_off_t old_root;
MI_KEYDEF *keyinfo = info->s->keyinfo + keynr;
DBUG_ENTER("rtree_delete");
if ((old_root = info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
{
my_errno= HA_ERR_END_OF_FILE;
DBUG_RETURN(-1); /* purecov: inspected */
}
DBUG_PRINT("rtree", ("starting deletion at root page: %lu",
(ulong) old_root));
ReinsertList.pages = NULL;
ReinsertList.n_pages = 0;
ReinsertList.m_pages = 0;
switch (rtree_delete_req(info, keyinfo, key, key_length, old_root,
&page_size, &ReinsertList, 0))
{
case 2: /* empty */
{
info->s->state.key_root[keynr] = HA_OFFSET_ERROR;
DBUG_RETURN(0);
}
case 0: /* deleted */
{
uint nod_flag;
ulong i;
for (i = 0; i < ReinsertList.n_pages; ++i)
{
uchar *page_buf;
uchar *k;
uchar *last;
if (!(page_buf = (uchar*)my_alloca((uint)keyinfo->block_length)))
{
my_errno = HA_ERR_OUT_OF_MEM;
goto err1;
}
if (!_mi_fetch_keypage(info, keyinfo, ReinsertList.pages[i].offs,
DFLT_INIT_HITS, page_buf, 0))
goto err1;
nod_flag = mi_test_if_nod(page_buf);
DBUG_PRINT("rtree", ("reinserting keys from "
"page: %lu level: %d nod_flag: %u",
(ulong) ReinsertList.pages[i].offs,
ReinsertList.pages[i].level, nod_flag));
k = rt_PAGE_FIRST_KEY(page_buf, nod_flag);
last = rt_PAGE_END(page_buf);
for (; k < last; k = rt_PAGE_NEXT_KEY(k, key_length, nod_flag))
{
int res;
if ((res= rtree_insert_level(info, keynr, k, key_length,
ReinsertList.pages[i].level)) == -1)
{
my_afree((uchar*)page_buf);
goto err1;
}
if (res)
{
ulong j;
DBUG_PRINT("rtree", ("root has been split, adjust levels"));
for (j= i; j < ReinsertList.n_pages; j++)
{
ReinsertList.pages[j].level++;
DBUG_PRINT("rtree", ("keys from page: %lu now level: %d",
(ulong) ReinsertList.pages[i].offs,
ReinsertList.pages[i].level));
}
}
}
my_afree((uchar*)page_buf);
if (_mi_dispose(info, keyinfo, ReinsertList.pages[i].offs,
DFLT_INIT_HITS))
goto err1;
}
if (ReinsertList.pages)
my_free(ReinsertList.pages);
/* check for redundant root (not leaf, 1 child) and eliminate */
if ((old_root = info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
goto err1;
if (!_mi_fetch_keypage(info, keyinfo, old_root, DFLT_INIT_HITS,
info->buff, 0))
goto err1;
nod_flag = mi_test_if_nod(info->buff);
page_size = mi_getint(info->buff);
if (nod_flag && (page_size == 2 + key_length + nod_flag))
{
my_off_t new_root = _mi_kpos(nod_flag,
rt_PAGE_FIRST_KEY(info->buff, nod_flag));
if (_mi_dispose(info, keyinfo, old_root, DFLT_INIT_HITS))
goto err1;
info->s->state.key_root[keynr] = new_root;
}
info->update= HA_STATE_DELETED;
DBUG_RETURN(0);
err1:
DBUG_RETURN(-1); /* purecov: inspected */
}
case 1: /* not found */
{
my_errno = HA_ERR_KEY_NOT_FOUND;
DBUG_RETURN(-1); /* purecov: inspected */
}
default:
case -1: /* error */
{
DBUG_RETURN(-1); /* purecov: inspected */
}
}
} | O3 | c | rtree_delete:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %ecx, %r14d
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %rax
movl %esi, -0x3c(%rbp)
movl %esi, %ebx
movq 0x98(%rax), %rcx
movq (%rcx,%rbx,8), %r8
cmpq $-0x1, %r8
je 0x8a75e
imulq $0x70, %rbx, %r13
addq 0x218(%rax), %r13
xorps %xmm0, %xmm0
leaq -0xa0(%rbp), %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq -0x84(%rbp), %r9
movq %rdi, -0x38(%rbp)
movq %r13, %rsi
movl %r14d, %ecx
pushq $0x0
pushq %rax
callq 0x8a8ab
addq $0x10, %rsp
cmpl $0x2, %eax
je 0x8a784
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
cmpl $0x1, %eax
je 0x8a774
testl %eax, %eax
jne 0x8a86e
movq %rbx, -0x48(%rbp)
movq -0xa0(%rbp), %r12
movq -0x90(%rbp), %rbx
testq %r12, %r12
movq %r14, -0x70(%rbp)
je 0x8a7aa
movl %r14d, %eax
movq %rax, -0x80(%rbp)
xorl %r14d, %r14d
movq %rbx, -0x60(%rbp)
movq -0x38(%rbp), %rdi
movq %r13, -0x78(%rbp)
movq %rbx, -0x50(%rbp)
movzwl 0xe(%r13), %eax
movq %rsp, %r15
addl $0xf, %eax
andl $-0x10, %eax
subq %rax, %r15
movq %r15, %rsp
movq %r14, %rax
shlq $0x4, %rax
movq %rax, -0x58(%rbp)
movq 0x8(%rbx,%rax), %rdx
movq %r13, %rsi
movl $0x3, %ecx
movq %r15, %r8
xorl %r9d, %r9d
callq 0x83cd8
testq %rax, %rax
je 0x8a769
movq %r14, -0x68(%rbp)
movzbl (%r15), %ebx
xorl %eax, %eax
testb %bl, %bl
movq -0x38(%rbp), %rdi
jns 0x8a699
movq (%rdi), %rax
movl 0x17c(%rax), %eax
movl %eax, %r13d
leaq (%r15,%r13), %r14
addq $0x2, %r14
movzbl 0x1(%r15), %eax
andl $0x7f, %ebx
shll $0x8, %ebx
orq %rax, %rbx
addq %r15, %rbx
cmpq %rbx, %r14
jae 0x8a71c
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rcx
leaq (%rax,%rcx), %r15
movl (%r15), %r8d
movl -0x3c(%rbp), %esi
movq %r14, %rdx
movq -0x70(%rbp), %rcx
callq 0x8a311
testl %eax, %eax
je 0x8a6fb
cmpl $-0x1, %eax
je 0x8a7a2
movq -0x60(%rbp), %rax
movq -0x68(%rbp), %rcx
incl (%rax)
incq %rcx
addq $0x10, %rax
cmpq %r12, %rcx
jb 0x8a6ed
movq %r13, %rax
testl %r13d, %r13d
movq -0x38(%rbp), %rdi
jne 0x8a710
movq (%rdi), %rax
movl 0x178(%rax), %eax
addq -0x80(%rbp), %r14
addq %rax, %r14
cmpq %rbx, %r14
jb 0x8a6c6
movq -0x50(%rbp), %rbx
movq -0x58(%rbp), %rax
addq %rbx, %rax
addq $0x8, %rax
movq (%rax), %rdx
movq -0x78(%rbp), %r13
movq %r13, %rsi
movl $0x3, %ecx
callq 0x83e57
testl %eax, %eax
jne 0x8a769
movq -0x68(%rbp), %r14
incq %r14
addq $0x10, -0x60(%rbp)
cmpq %r12, %r14
movq -0x38(%rbp), %rdi
jne 0x8a63e
jmp 0x8a7b3
callq 0xa1b22
movl $0x89, (%rax)
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
jmp 0x8a86e
callq 0xa1b22
movl $0x78, (%rax)
jmp 0x8a86e
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq 0x98(%rax), %rax
movq $-0x1, (%rax,%rbx,8)
xorl %r12d, %r12d
jmp 0x8a86e
movl %eax, %r12d
jmp 0x8a86e
testq %rbx, %rbx
movq -0x38(%rbp), %rdi
je 0x8a7bf
movq %rbx, %rdi
callq 0x9ffde
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq 0x98(%rax), %rax
movq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %r14
cmpq $-0x1, %r14
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
je 0x8a86e
movq 0x100(%rdi), %r8
movq %rdi, %rbx
movq %r13, %rsi
movq %r14, %rdx
movl $0x3, %ecx
xorl %r9d, %r9d
callq 0x83cd8
testq %rax, %rax
je 0x8a86e
movq 0x100(%rbx), %rax
movzbl (%rax), %ecx
testb %cl, %cl
js 0x8a820
movl $0x8, 0x1d0(%rbx)
jmp 0x8a79a
movq (%rbx), %rdx
movl 0x17c(%rdx), %edi
testq %rdi, %rdi
je 0x8a811
andl $0x7f, %ecx
shll $0x8, %ecx
movzbl 0x1(%rax), %edx
orl %ecx, %edx
movq -0x70(%rbp), %rcx
addl %edi, %ecx
addl $0x2, %ecx
cmpl %ecx, %edx
jne 0x8a811
leaq (%rax,%rdi), %rsi
addq $0x2, %rsi
callq 0x84652
movq %rax, %r15
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
movl $0x3, %ecx
callq 0x83e57
testl %eax, %eax
je 0x8a88f
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x8a8a6
movl %r12d, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rax
movq 0x98(%rax), %rax
movq -0x48(%rbp), %rcx
movq %r15, (%rax,%rcx,8)
jmp 0x8a811
callq 0x29270
| rtree_delete:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov r14d, ecx
mov rax, fs:28h
mov [rbp+var_30], rax
mov rax, [rdi]
mov [rbp+var_3C], esi
mov ebx, esi
mov rcx, [rax+98h]
mov r8, [rcx+rbx*8]
cmp r8, 0FFFFFFFFFFFFFFFFh
jz loc_8A75E
imul r13, rbx, 70h ; 'p'
add r13, [rax+218h]
xorps xmm0, xmm0
lea rax, [rbp+var_A0]
movaps xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
lea r9, [rbp+var_84]
mov [rbp+var_38], rdi
mov rsi, r13
mov ecx, r14d
push 0
push rax
call rtree_delete_req
add rsp, 10h
cmp eax, 2
jz loc_8A784
mov r12d, 0FFFFFFFFh
cmp eax, 1
jz loc_8A774
test eax, eax
jnz loc_8A86E
mov [rbp+var_48], rbx
mov r12, [rbp+var_A0]
mov rbx, [rbp+var_90]
test r12, r12
mov [rbp+var_70], r14
jz loc_8A7AA
mov eax, r14d
mov [rbp+var_80], rax
xor r14d, r14d
mov [rbp+var_60], rbx
mov rdi, [rbp+var_38]
mov [rbp+var_78], r13
mov [rbp+var_50], rbx
loc_8A63E:
movzx eax, word ptr [r13+0Eh]
mov r15, rsp
add eax, 0Fh
and eax, 0FFFFFFF0h
sub r15, rax
mov rsp, r15
mov rax, r14
shl rax, 4
mov [rbp+var_58], rax
mov rdx, [rbx+rax+8]
mov rsi, r13
mov ecx, 3
mov r8, r15
xor r9d, r9d
call _mi_fetch_keypage
test rax, rax
jz loc_8A769
mov [rbp+var_68], r14
movzx ebx, byte ptr [r15]
xor eax, eax
test bl, bl
mov rdi, [rbp+var_38]
jns short loc_8A699
mov rax, [rdi]
mov eax, [rax+17Ch]
loc_8A699:
mov r13d, eax
lea r14, [r15+r13]
add r14, 2
movzx eax, byte ptr [r15+1]
and ebx, 7Fh
shl ebx, 8
or rbx, rax
add rbx, r15
cmp r14, rbx
jnb short loc_8A71C
mov rax, [rbp+var_50]
mov rcx, [rbp+var_58]
lea r15, [rax+rcx]
loc_8A6C6:
mov r8d, [r15]
mov esi, [rbp+var_3C]
mov rdx, r14
mov rcx, [rbp+var_70]
call rtree_insert_level
test eax, eax
jz short loc_8A6FB
cmp eax, 0FFFFFFFFh
jz loc_8A7A2
mov rax, [rbp+var_60]
mov rcx, [rbp+var_68]
loc_8A6ED:
inc dword ptr [rax]
inc rcx
add rax, 10h
cmp rcx, r12
jb short loc_8A6ED
loc_8A6FB:
mov rax, r13
test r13d, r13d
mov rdi, [rbp+var_38]
jnz short loc_8A710
mov rax, [rdi]
mov eax, [rax+178h]
loc_8A710:
add r14, [rbp+var_80]
add r14, rax
cmp r14, rbx
jb short loc_8A6C6
loc_8A71C:
mov rbx, [rbp+var_50]
mov rax, [rbp+var_58]
add rax, rbx
add rax, 8
mov rdx, [rax]
mov r13, [rbp+var_78]
mov rsi, r13
mov ecx, 3
call _mi_dispose
test eax, eax
jnz short loc_8A769
mov r14, [rbp+var_68]
inc r14
add [rbp+var_60], 10h
cmp r14, r12
mov rdi, [rbp+var_38]
jnz loc_8A63E
jmp short loc_8A7B3
loc_8A75E:
call _my_thread_var
mov dword ptr [rax], 89h
loc_8A769:
mov r12d, 0FFFFFFFFh
jmp loc_8A86E
loc_8A774:
call _my_thread_var
mov dword ptr [rax], 78h ; 'x'
jmp loc_8A86E
loc_8A784:
mov rax, [rbp+var_38]
mov rax, [rax]
mov rax, [rax+98h]
mov qword ptr [rax+rbx*8], 0FFFFFFFFFFFFFFFFh
loc_8A79A:
xor r12d, r12d
jmp loc_8A86E
loc_8A7A2:
mov r12d, eax
jmp loc_8A86E
loc_8A7AA:
test rbx, rbx
mov rdi, [rbp+var_38]
jz short loc_8A7BF
loc_8A7B3:
mov rdi, rbx
call my_free
mov rdi, [rbp+var_38]
loc_8A7BF:
mov rax, [rdi]
mov rax, [rax+98h]
mov rcx, [rbp+var_48]
mov r14, [rax+rcx*8]
cmp r14, 0FFFFFFFFFFFFFFFFh
mov r12d, 0FFFFFFFFh
jz loc_8A86E
mov r8, [rdi+100h]
mov rbx, rdi
mov rsi, r13
mov rdx, r14
mov ecx, 3
xor r9d, r9d
call _mi_fetch_keypage
test rax, rax
jz short loc_8A86E
mov rax, [rbx+100h]
movzx ecx, byte ptr [rax]
test cl, cl
js short loc_8A820
loc_8A811:
mov dword ptr [rbx+1D0h], 8
jmp loc_8A79A
loc_8A820:
mov rdx, [rbx]
mov edi, [rdx+17Ch]
test rdi, rdi
jz short loc_8A811
and ecx, 7Fh
shl ecx, 8
movzx edx, byte ptr [rax+1]
or edx, ecx
mov rcx, [rbp+var_70]
add ecx, edi
add ecx, 2
cmp edx, ecx
jnz short loc_8A811
lea rsi, [rax+rdi]
add rsi, 2
call _mi_kpos
mov r15, rax
mov rdi, rbx
mov rsi, r13
mov rdx, r14
mov ecx, 3
call _mi_dispose
test eax, eax
jz short loc_8A88F
loc_8A86E:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_8A8A6
mov eax, r12d
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8A88F:
mov rax, [rbx]
mov rax, [rax+98h]
mov rcx, [rbp+var_48]
mov [rax+rcx*8], r15
jmp loc_8A811
loc_8A8A6:
call ___stack_chk_fail
| long long rtree_delete(_QWORD *a1, const char *a2, int a3, unsigned int a4)
{
long long v4; // r14
long long v5; // rax
long long v6; // r8
long long v7; // r13
int v8; // eax
unsigned int v9; // r12d
unsigned long long v10; // r12
_DWORD *v11; // rbx
unsigned long long v12; // r14
_QWORD *v13; // rdi
char *v14; // r15
unsigned int v15; // eax
long long *v16; // rdi
long long v17; // r13
unsigned long long v18; // r14
char *v19; // rbx
int *v20; // r15
int inserted; // eax
_DWORD *v22; // rax
unsigned long long v23; // rcx
long long v24; // rax
_QWORD *v25; // rdi
long long v26; // rax
long long v27; // r14
_DWORD *v28; // rbx
char *v29; // rax
long long v30; // rdi
unsigned long long v31; // r15
__int128 v33; // [rsp+0h] [rbp-A0h] BYREF
_DWORD *v34; // [rsp+10h] [rbp-90h]
char v35; // [rsp+1Ch] [rbp-84h] BYREF
long long v36; // [rsp+20h] [rbp-80h]
long long v37; // [rsp+28h] [rbp-78h]
long long v38; // [rsp+30h] [rbp-70h]
unsigned long long v39; // [rsp+38h] [rbp-68h]
_DWORD *v40; // [rsp+40h] [rbp-60h]
long long v41; // [rsp+48h] [rbp-58h]
_DWORD *v42; // [rsp+50h] [rbp-50h]
long long v43; // [rsp+58h] [rbp-48h]
unsigned int v44; // [rsp+64h] [rbp-3Ch]
_QWORD *v45; // [rsp+68h] [rbp-38h]
unsigned long long v46; // [rsp+70h] [rbp-30h]
v4 = a4;
v46 = __readfsqword(0x28u);
v5 = *a1;
v44 = (unsigned int)a2;
v6 = *(_QWORD *)(*(_QWORD *)(v5 + 152) + 8LL * (unsigned int)a2);
if ( v6 == -1 )
{
*(_DWORD *)my_thread_var(a1, a2) = 137;
return (unsigned int)-1;
}
v7 = *(_QWORD *)(v5 + 536) + 112LL * (unsigned int)a2;
v33 = 0LL;
v34 = 0LL;
v45 = a1;
v8 = rtree_delete_req((_DWORD)a1, v7, a3, a4, v6, (unsigned int)&v35, (long long)&v33, 0);
if ( v8 == 2 )
{
*(_QWORD *)(*(_QWORD *)(*v45 + 152LL) + 8LL * (unsigned int)a2) = -1LL;
return 0;
}
v9 = -1;
if ( v8 == 1 )
{
*(_DWORD *)my_thread_var(a1, (const char *)v7) = 120;
return v9;
}
if ( !v8 )
{
v43 = (unsigned int)a2;
v10 = v33;
v11 = v34;
v38 = v4;
if ( (_QWORD)v33 )
{
v36 = (unsigned int)v4;
v12 = 0LL;
v40 = v34;
v13 = v45;
v37 = v7;
v42 = v34;
while ( 1 )
{
v14 = (char *)&v33 - ((*(unsigned __int16 *)(v7 + 14) + 15) & 0xFFFFFFF0);
v41 = 16 * v12;
if ( !mi_fetch_keypage(v13, v7, *(_QWORD *)&v11[4 * v12 + 2]) )
break;
v39 = v12;
v15 = 0;
v16 = v45;
if ( *v14 < 0 )
v15 = *(_DWORD *)(*v45 + 380LL);
v17 = v15;
v18 = (unsigned long long)&v14[v15 + 2];
v19 = &v14[(unsigned __int8)v14[1] | (unsigned long long)((unsigned __int8)(*v14 & 0x7F) << 8)];
if ( v18 < (unsigned long long)v19 )
{
v20 = &v42[(unsigned long long)v41 / 4];
do
{
inserted = rtree_insert_level(v16, v44, v18, v38, *v20);
if ( inserted )
{
if ( inserted == -1 )
return (unsigned int)-1;
v22 = v40;
v23 = v39;
do
{
++*v22;
++v23;
v22 += 4;
}
while ( v23 < v10 );
}
v24 = v17;
v16 = v45;
if ( !(_DWORD)v17 )
v24 = *(unsigned int *)(*v45 + 376LL);
v18 += v24 + v36;
}
while ( v18 < (unsigned long long)v19 );
}
v11 = v42;
v7 = v37;
if ( (unsigned int)mi_dispose(v16, v37, *(_QWORD *)&v42[(unsigned long long)v41 / 4 + 2], 3u) )
break;
v12 = v39 + 1;
v40 += 4;
v13 = v45;
if ( v39 + 1 == v10 )
goto LABEL_29;
}
return (unsigned int)-1;
}
v25 = v45;
if ( v34 )
{
LABEL_29:
my_free(v11);
v25 = v45;
}
v26 = *(_QWORD *)(*v25 + 152LL);
v27 = *(_QWORD *)(v26 + 8 * v43);
v9 = -1;
if ( v27 != -1 )
{
v28 = v25;
if ( mi_fetch_keypage(v25, v7, *(_QWORD *)(v26 + 8 * v43)) )
{
v29 = (char *)v25[32];
if ( *v29 < 0 )
{
v30 = *(unsigned int *)(*v25 + 380LL);
if ( *(_DWORD *)(*(_QWORD *)v28 + 380LL) )
{
if ( (((*v29 & 0x7F) << 8) | (unsigned __int8)v29[1]) == (_DWORD)v30 + (_DWORD)v38 + 2 )
{
v31 = mi_kpos(v30, (long long)&v29[v30 + 2]);
if ( (unsigned int)mi_dispose(v28, v7, v27, 3u) )
return v9;
*(_QWORD *)(*(_QWORD *)(*(_QWORD *)v28 + 152LL) + 8 * v43) = v31;
}
}
}
v28[116] = 8;
return 0;
}
}
}
return v9;
}
| rtree_delete:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV R14D,ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RDI]
MOV dword ptr [RBP + -0x3c],ESI
MOV EBX,ESI
MOV RCX,qword ptr [RAX + 0x98]
MOV R8,qword ptr [RCX + RBX*0x8]
CMP R8,-0x1
JZ 0x0018a75e
IMUL R13,RBX,0x70
ADD R13,qword ptr [RAX + 0x218]
XORPS XMM0,XMM0
LEA RAX,[RBP + -0xa0]
MOVAPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
LEA R9,[RBP + -0x84]
MOV qword ptr [RBP + -0x38],RDI
MOV RSI,R13
MOV ECX,R14D
PUSH 0x0
PUSH RAX
CALL 0x0018a8ab
ADD RSP,0x10
CMP EAX,0x2
JZ 0x0018a784
MOV R12D,0xffffffff
CMP EAX,0x1
JZ 0x0018a774
TEST EAX,EAX
JNZ 0x0018a86e
MOV qword ptr [RBP + -0x48],RBX
MOV R12,qword ptr [RBP + -0xa0]
MOV RBX,qword ptr [RBP + -0x90]
TEST R12,R12
MOV qword ptr [RBP + -0x70],R14
JZ 0x0018a7aa
MOV EAX,R14D
MOV qword ptr [RBP + -0x80],RAX
XOR R14D,R14D
MOV qword ptr [RBP + -0x60],RBX
MOV RDI,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x78],R13
MOV qword ptr [RBP + -0x50],RBX
LAB_0018a63e:
MOVZX EAX,word ptr [R13 + 0xe]
MOV R15,RSP
ADD EAX,0xf
AND EAX,0xfffffff0
SUB R15,RAX
MOV RSP,R15
MOV RAX,R14
SHL RAX,0x4
MOV qword ptr [RBP + -0x58],RAX
MOV RDX,qword ptr [RBX + RAX*0x1 + 0x8]
MOV RSI,R13
MOV ECX,0x3
MOV R8,R15
XOR R9D,R9D
CALL 0x00183cd8
TEST RAX,RAX
JZ 0x0018a769
MOV qword ptr [RBP + -0x68],R14
MOVZX EBX,byte ptr [R15]
XOR EAX,EAX
TEST BL,BL
MOV RDI,qword ptr [RBP + -0x38]
JNS 0x0018a699
MOV RAX,qword ptr [RDI]
MOV EAX,dword ptr [RAX + 0x17c]
LAB_0018a699:
MOV R13D,EAX
LEA R14,[R15 + R13*0x1]
ADD R14,0x2
MOVZX EAX,byte ptr [R15 + 0x1]
AND EBX,0x7f
SHL EBX,0x8
OR RBX,RAX
ADD RBX,R15
CMP R14,RBX
JNC 0x0018a71c
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x58]
LEA R15,[RAX + RCX*0x1]
LAB_0018a6c6:
MOV R8D,dword ptr [R15]
MOV ESI,dword ptr [RBP + -0x3c]
MOV RDX,R14
MOV RCX,qword ptr [RBP + -0x70]
CALL 0x0018a311
TEST EAX,EAX
JZ 0x0018a6fb
CMP EAX,-0x1
JZ 0x0018a7a2
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x68]
LAB_0018a6ed:
INC dword ptr [RAX]
INC RCX
ADD RAX,0x10
CMP RCX,R12
JC 0x0018a6ed
LAB_0018a6fb:
MOV RAX,R13
TEST R13D,R13D
MOV RDI,qword ptr [RBP + -0x38]
JNZ 0x0018a710
MOV RAX,qword ptr [RDI]
MOV EAX,dword ptr [RAX + 0x178]
LAB_0018a710:
ADD R14,qword ptr [RBP + -0x80]
ADD R14,RAX
CMP R14,RBX
JC 0x0018a6c6
LAB_0018a71c:
MOV RBX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RBX
ADD RAX,0x8
MOV RDX,qword ptr [RAX]
MOV R13,qword ptr [RBP + -0x78]
MOV RSI,R13
MOV ECX,0x3
CALL 0x00183e57
TEST EAX,EAX
JNZ 0x0018a769
MOV R14,qword ptr [RBP + -0x68]
INC R14
ADD qword ptr [RBP + -0x60],0x10
CMP R14,R12
MOV RDI,qword ptr [RBP + -0x38]
JNZ 0x0018a63e
JMP 0x0018a7b3
LAB_0018a75e:
CALL 0x001a1b22
MOV dword ptr [RAX],0x89
LAB_0018a769:
MOV R12D,0xffffffff
JMP 0x0018a86e
LAB_0018a774:
CALL 0x001a1b22
MOV dword ptr [RAX],0x78
JMP 0x0018a86e
LAB_0018a784:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x98]
MOV qword ptr [RAX + RBX*0x8],-0x1
LAB_0018a79a:
XOR R12D,R12D
JMP 0x0018a86e
LAB_0018a7a2:
MOV R12D,EAX
JMP 0x0018a86e
LAB_0018a7aa:
TEST RBX,RBX
MOV RDI,qword ptr [RBP + -0x38]
JZ 0x0018a7bf
LAB_0018a7b3:
MOV RDI,RBX
CALL 0x0019ffde
MOV RDI,qword ptr [RBP + -0x38]
LAB_0018a7bf:
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x98]
MOV RCX,qword ptr [RBP + -0x48]
MOV R14,qword ptr [RAX + RCX*0x8]
CMP R14,-0x1
MOV R12D,0xffffffff
JZ 0x0018a86e
MOV R8,qword ptr [RDI + 0x100]
MOV RBX,RDI
MOV RSI,R13
MOV RDX,R14
MOV ECX,0x3
XOR R9D,R9D
CALL 0x00183cd8
TEST RAX,RAX
JZ 0x0018a86e
MOV RAX,qword ptr [RBX + 0x100]
MOVZX ECX,byte ptr [RAX]
TEST CL,CL
JS 0x0018a820
LAB_0018a811:
MOV dword ptr [RBX + 0x1d0],0x8
JMP 0x0018a79a
LAB_0018a820:
MOV RDX,qword ptr [RBX]
MOV EDI,dword ptr [RDX + 0x17c]
TEST RDI,RDI
JZ 0x0018a811
AND ECX,0x7f
SHL ECX,0x8
MOVZX EDX,byte ptr [RAX + 0x1]
OR EDX,ECX
MOV RCX,qword ptr [RBP + -0x70]
ADD ECX,EDI
ADD ECX,0x2
CMP EDX,ECX
JNZ 0x0018a811
LEA RSI,[RAX + RDI*0x1]
ADD RSI,0x2
CALL 0x00184652
MOV R15,RAX
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R14
MOV ECX,0x3
CALL 0x00183e57
TEST EAX,EAX
JZ 0x0018a88f
LAB_0018a86e:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0018a8a6
MOV EAX,R12D
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0018a88f:
MOV RAX,qword ptr [RBX]
MOV RAX,qword ptr [RAX + 0x98]
MOV RCX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + RCX*0x8],R15
JMP 0x0018a811
LAB_0018a8a6:
CALL 0x00129270
|
int8 rtree_delete(long *param_1,uint param_2,int8 param_3,uint param_4)
{
byte bVar1;
byte bVar2;
int4 uVar3;
ulong uVar4;
uint uVar5;
long *plVar6;
ulong *puVar7;
int iVar8;
uint uVar9;
long lVar10;
int *piVar11;
int4 *puVar12;
long lVar13;
int8 uVar14;
ulong uVar15;
int8 uVar16;
long lVar17;
ulong uVar18;
byte *pbVar19;
ulong *puVar20;
long in_FS_OFFSET;
ulong local_a8 [2];
int *local_98;
int1 local_8c [4];
ulong local_88;
long local_80;
ulong local_78;
ulong local_70;
int *local_68;
long local_60;
int *local_58;
ulong local_50;
uint local_44;
long *local_40;
long local_38;
puVar20 = local_a8;
uVar18 = (ulong)param_4;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar15 = (ulong)param_2;
lVar10 = *(long *)(*(long *)(*param_1 + 0x98) + uVar15 * 8);
local_44 = param_2;
if (lVar10 == -1) {
puVar12 = (int4 *)_my_thread_var();
*puVar12 = 0x89;
LAB_0018a769:
uVar16 = 0xffffffff;
goto LAB_0018a86e;
}
lVar17 = uVar15 * 0x70 + *(long *)(*param_1 + 0x218);
local_a8[0] = 0;
local_a8[1] = 0;
local_98 = (int *)0x0;
local_40 = param_1;
iVar8 = rtree_delete_req(param_1,lVar17,param_3,uVar18,lVar10,local_8c,local_a8,0);
uVar4 = local_a8[0];
puVar20 = local_a8;
if (iVar8 == 2) {
*(int8 *)(*(long *)(*local_40 + 0x98) + uVar15 * 8) = 0xffffffffffffffff;
puVar20 = local_a8;
}
else {
uVar16 = 0xffffffff;
if (iVar8 == 1) {
puVar12 = (int4 *)_my_thread_var();
*puVar12 = 0x78;
goto LAB_0018a86e;
}
puVar20 = local_a8;
if (iVar8 != 0) goto LAB_0018a86e;
piVar11 = local_98;
local_78 = uVar18;
local_50 = uVar15;
if (local_a8[0] == 0) {
puVar20 = local_a8;
puVar7 = local_a8;
if (local_98 != (int *)0x0) goto LAB_0018a7b3;
}
else {
local_88 = (ulong)param_4;
uVar15 = 0;
local_68 = local_98;
local_58 = local_98;
puVar20 = local_a8;
local_80 = lVar17;
do {
plVar6 = local_40;
puVar20 = (ulong *)((long)puVar20 + -(ulong)(*(ushort *)(lVar17 + 0xe) + 0xf & 0xfffffff0));
local_60 = uVar15 * 0x10;
uVar16 = *(int8 *)(piVar11 + uVar15 * 4 + 2);
*(byte *)((long)puVar20 + -8) = 0x75;
*(byte *)((long)puVar20 + -7) = 0xa6;
*(byte *)((long)puVar20 + -6) = 0x18;
*(byte *)((long)puVar20 + -5) = 0;
*(byte *)((long)puVar20 + -4) = 0;
*(byte *)((long)puVar20 + -3) = 0;
*(byte *)((long)puVar20 + -2) = 0;
*(byte *)((long)puVar20 + -1) = 0;
lVar10 = _mi_fetch_keypage(plVar6,lVar17,uVar16,3,puVar20,0);
if (lVar10 == 0) goto LAB_0018a769;
local_70 = uVar15;
bVar1 = *(byte *)puVar20;
uVar9 = 0;
if ((char)bVar1 < '\0') {
uVar9 = *(uint *)(*local_40 + 0x17c);
}
pbVar19 = (byte *)((long)puVar20 + (ulong)uVar9 + 2);
bVar2 = *(byte *)((long)puVar20 + 1);
if (pbVar19 < (byte *)((long)puVar20 + ((ulong)((bVar1 & 0x7f) << 8) | (ulong)bVar2))) {
puVar12 = (int4 *)((long)local_58 + local_60);
do {
plVar6 = local_40;
uVar5 = local_44;
uVar15 = local_78;
uVar3 = *puVar12;
*(byte *)((long)puVar20 + -8) = 0xd8;
*(byte *)((long)puVar20 + -7) = 0xa6;
*(byte *)((long)puVar20 + -6) = 0x18;
*(byte *)((long)puVar20 + -5) = 0;
*(byte *)((long)puVar20 + -4) = 0;
*(byte *)((long)puVar20 + -3) = 0;
*(byte *)((long)puVar20 + -2) = 0;
*(byte *)((long)puVar20 + -1) = 0;
iVar8 = rtree_insert_level(plVar6,uVar5,pbVar19,uVar15,uVar3);
if (iVar8 != 0) {
piVar11 = local_68;
uVar15 = local_70;
if (iVar8 == -1) {
uVar16 = 0xffffffff;
goto LAB_0018a86e;
}
do {
*piVar11 = *piVar11 + 1;
uVar15 = uVar15 + 1;
piVar11 = piVar11 + 4;
} while (uVar15 < uVar4);
}
uVar15 = (ulong)uVar9;
if (uVar9 == 0) {
uVar15 = (ulong)*(uint *)(*local_40 + 0x178);
}
pbVar19 = pbVar19 + uVar15 + local_88;
} while (pbVar19 < (byte *)((long)puVar20 + ((ulong)((bVar1 & 0x7f) << 8) | (ulong)bVar2))
);
}
plVar6 = local_40;
piVar11 = local_58;
lVar17 = local_80;
uVar16 = *(int8 *)((long)local_58 + local_60 + 8);
*(byte *)((long)puVar20 + -8) = 0x3f;
*(byte *)((long)puVar20 + -7) = 0xa7;
*(byte *)((long)puVar20 + -6) = 0x18;
*(byte *)((long)puVar20 + -5) = 0;
*(byte *)((long)puVar20 + -4) = 0;
*(byte *)((long)puVar20 + -3) = 0;
*(byte *)((long)puVar20 + -2) = 0;
*(byte *)((long)puVar20 + -1) = 0;
iVar8 = _mi_dispose(plVar6,lVar17,uVar16,3);
if (iVar8 != 0) goto LAB_0018a769;
uVar15 = local_70 + 1;
local_68 = local_68 + 4;
} while (uVar15 != uVar4);
LAB_0018a7b3:
*(byte *)((long)puVar20 + -8) = 0xbb;
*(byte *)((long)puVar20 + -7) = 0xa7;
*(byte *)((long)puVar20 + -6) = 0x18;
*(byte *)((long)puVar20 + -5) = 0;
*(byte *)((long)puVar20 + -4) = 0;
*(byte *)((long)puVar20 + -3) = 0;
*(byte *)((long)puVar20 + -2) = 0;
*(byte *)((long)puVar20 + -1) = 0;
my_free(piVar11);
puVar7 = puVar20;
}
puVar20 = puVar7;
plVar6 = local_40;
lVar10 = *(long *)(*(long *)(*local_40 + 0x98) + local_50 * 8);
uVar16 = 0xffffffff;
if (lVar10 == -1) goto LAB_0018a86e;
lVar13 = local_40[0x20];
*(int8 *)((long)puVar20 + -8) = 0x18a7fe;
lVar13 = _mi_fetch_keypage(plVar6,lVar17,lVar10,3,lVar13,0);
if (lVar13 == 0) goto LAB_0018a86e;
pbVar19 = (byte *)plVar6[0x20];
if ((char)*pbVar19 < '\0') {
uVar15 = (ulong)*(uint *)(*plVar6 + 0x17c);
if ((uVar15 != 0) &&
(((uint)pbVar19[1] | (*pbVar19 & 0x7f) << 8) ==
(int)local_78 + *(uint *)(*plVar6 + 0x17c) + 2)) {
*(int8 *)((long)puVar20 + -8) = 0x18a854;
uVar14 = _mi_kpos(uVar15,pbVar19 + uVar15 + 2);
*(int8 *)((long)puVar20 + -8) = 0x18a86a;
iVar8 = _mi_dispose(plVar6,lVar17,lVar10,3);
if (iVar8 != 0) goto LAB_0018a86e;
*(int8 *)(*(long *)(*plVar6 + 0x98) + local_50 * 8) = uVar14;
}
}
*(int4 *)(plVar6 + 0x3a) = 8;
}
uVar16 = 0;
LAB_0018a86e:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
*(code **)((long)puVar20 + -8) = rtree_delete_req;
__stack_chk_fail();
}
return uVar16;
}
| |
54,179 | OpenSubdiv::v3_6_0::Vtr::internal::TriRefinement::populateFaceEdgeRelation() | NVIDIA-RTX[P]OSD-Lite/opensubdiv/vtr/triRefinement.cpp | void
TriRefinement::populateFaceEdgeRelation() {
// Both face-vertex and face-edge share the face-vertex counts/offsets, so be sure
// not to re-initialize it if already done:
//
if (_child->_faceVertCountsAndOffsets.size() == 0) {
populateFaceVertexCountsAndOffsets();
}
_child->_faceEdgeIndices.resize(_child->getNumFaces() * 3);
populateFaceEdgesFromParentFaces();
} | O2 | cpp | OpenSubdiv::v3_6_0::Vtr::internal::TriRefinement::populateFaceEdgeRelation():
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x20(%rdi), %rax
cmpq 0x18(%rdi), %rax
jne 0x63126
movq %rbx, %rdi
callq 0x55a70
movq 0x10(%rbx), %rdi
movslq (%rdi), %rax
addq $0x48, %rdi
leaq (%rax,%rax,2), %rsi
callq 0x514b0
movq %rbx, %rdi
popq %rbx
jmp 0x54bd0
nop
| _ZN10OpenSubdiv6v3_6_03Vtr8internal13TriRefinement24populateFaceEdgeRelationEv:
push rbx
mov rbx, rdi
mov rdi, [rdi+10h]
mov rax, [rdi+20h]
cmp rax, [rdi+18h]
jnz short loc_63126
mov rdi, rbx; this
call __ZN10OpenSubdiv6v3_6_03Vtr8internal13TriRefinement34populateFaceVertexCountsAndOffsetsEv; OpenSubdiv::v3_6_0::Vtr::internal::TriRefinement::populateFaceVertexCountsAndOffsets(void)
mov rdi, [rbx+10h]
loc_63126:
movsxd rax, dword ptr [rdi]
add rdi, 48h ; 'H'
lea rsi, [rax+rax*2]
call __ZNSt6vectorIiSaIiEE6resizeEm; std::vector<int>::resize(ulong)
mov rdi, rbx; this
pop rbx
jmp __ZN10OpenSubdiv6v3_6_03Vtr8internal13TriRefinement32populateFaceEdgesFromParentFacesEv; OpenSubdiv::v3_6_0::Vtr::internal::TriRefinement::populateFaceEdgesFromParentFaces(void)
| long long OpenSubdiv::v3_6_0::Vtr::internal::TriRefinement::populateFaceEdgeRelation(
OpenSubdiv::v3_6_0::Vtr::internal::TriRefinement *this)
{
int *v2; // rdi
v2 = (int *)*((_QWORD *)this + 2);
if ( *((_QWORD *)v2 + 4) == *((_QWORD *)v2 + 3) )
{
OpenSubdiv::v3_6_0::Vtr::internal::TriRefinement::populateFaceVertexCountsAndOffsets(this);
v2 = (int *)*((_QWORD *)this + 2);
}
std::vector<int>::resize(v2 + 18, 3LL * *v2);
return OpenSubdiv::v3_6_0::Vtr::internal::TriRefinement::populateFaceEdgesFromParentFaces(this);
}
| populateFaceEdgeRelation:
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x10]
MOV RAX,qword ptr [RDI + 0x20]
CMP RAX,qword ptr [RDI + 0x18]
JNZ 0x00163126
MOV RDI,RBX
CALL 0x00155a70
MOV RDI,qword ptr [RBX + 0x10]
LAB_00163126:
MOVSXD RAX,dword ptr [RDI]
ADD RDI,0x48
LEA RSI,[RAX + RAX*0x2]
CALL 0x001514b0
MOV RDI,RBX
POP RBX
JMP 0x00154bd0
|
/* OpenSubdiv::v3_6_0::Vtr::internal::TriRefinement::populateFaceEdgeRelation() */
void __thiscall
OpenSubdiv::v3_6_0::Vtr::internal::TriRefinement::populateFaceEdgeRelation(TriRefinement *this)
{
int *piVar1;
piVar1 = *(int **)(this + 0x10);
if (*(long *)(piVar1 + 8) == *(long *)(piVar1 + 6)) {
populateFaceVertexCountsAndOffsets(this);
piVar1 = *(int **)(this + 0x10);
}
std::vector<int,std::allocator<int>>::resize
((vector<int,std::allocator<int>> *)(piVar1 + 0x12),(long)*piVar1 * 3);
populateFaceEdgesFromParentFaces(this);
return;
}
| |
54,180 | part_html_cmd | navaro[P]qoraal-tictactoe/src/services/www/parts/html.c | int32_t
part_html_cmd (PENGINE_T instance, uint32_t start)
{
#if USE_MUTEX
if (!instance) {
if (start == PART_CMD_PARM_START) {
return os_mutex_create (&_html_mutex) ;
} else {
os_mutex_delete (&_html_mutex) ;
_html_mutex = 0 ;
}
}
#endif
return ENGINE_OK ;
} | O3 | c | part_html_cmd:
testq %rdi, %rdi
jne 0x13d16
cmpl $0x1, %esi
jne 0x13cfa
leaq 0x2cc43(%rip), %rdi # 0x40938
jmp 0x14f7b
pushq %rbp
movq %rsp, %rbp
leaq 0x2cc33(%rip), %rdi # 0x40938
callq 0x14fbd
movq $0x0, 0x2cc23(%rip) # 0x40938
popq %rbp
xorl %eax, %eax
retq
| part_html_cmd:
test rdi, rdi
jnz short loc_13D16
cmp esi, 1
jnz short loc_13CFA
lea rdi, _html_mutex
jmp os_mutex_create
loc_13CFA:
push rbp
mov rbp, rsp
lea rdi, _html_mutex
call os_mutex_delete
mov cs:_html_mutex, 0
pop rbp
loc_13D16:
xor eax, eax
retn
| long long part_html_cmd(long long a1, int a2)
{
if ( !a1 )
{
if ( a2 == 1 )
return os_mutex_create(&html_mutex);
os_mutex_delete(&html_mutex);
html_mutex = 0LL;
}
return 0LL;
}
| part_html_cmd:
TEST RDI,RDI
JNZ 0x00113d16
CMP ESI,0x1
JNZ 0x00113cfa
LEA RDI,[0x140938]
JMP 0x00114f7b
LAB_00113cfa:
PUSH RBP
MOV RBP,RSP
LEA RDI,[0x140938]
CALL 0x00114fbd
MOV qword ptr [0x00140938],0x0
POP RBP
LAB_00113d16:
XOR EAX,EAX
RET
|
int8 part_html_cmd(long param_1,int param_2)
{
int8 uVar1;
if (param_1 == 0) {
if (param_2 == 1) {
uVar1 = os_mutex_create(&_html_mutex);
return uVar1;
}
os_mutex_delete(&_html_mutex);
_html_mutex = 0;
}
return 0;
}
| |
54,181 | google::protobuf::compiler::csharp::WrapperFieldGenerator::WrapperFieldGenerator(google::protobuf::FieldDescriptor const*, int, google::protobuf::compiler::csharp::Options const*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/csharp/csharp_wrapper_field.cc | WrapperFieldGenerator::WrapperFieldGenerator(const FieldDescriptor* descriptor,
int presenceIndex, const Options *options)
: FieldGeneratorBase(descriptor, presenceIndex, options) {
variables_["has_property_check"] = name() + "_ != null";
variables_["has_not_property_check"] = name() + "_ == null";
const FieldDescriptor* wrapped_field = descriptor->message_type()->field(0);
is_value_type = wrapped_field->type() != FieldDescriptor::TYPE_STRING &&
wrapped_field->type() != FieldDescriptor::TYPE_BYTES;
if (is_value_type) {
variables_["nonnullable_type_name"] = type_name(wrapped_field);
}
} | O3 | cpp | google::protobuf::compiler::csharp::WrapperFieldGenerator::WrapperFieldGenerator(google::protobuf::FieldDescriptor const*, int, google::protobuf::compiler::csharp::Options const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, %rbx
callq 0xa11ca
leaq 0x2353a4(%rip), %rax # 0x276eb8
movq %rax, (%rbx)
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0xa05b6
leaq 0x15cc81(%rip), %rsi # 0x19e7ac
leaq 0x28(%rsp), %rdi
callq 0x1f8e0
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x41b5d
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x41b65
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x58(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x15d817(%rip), %rsi # 0x19f3a4
leaq 0x15d822(%rip), %rdx # 0x19f3b6
leaq 0x48(%rsp), %rdi
callq 0x250b2
leaq 0x20(%rbx), %r14
leaq 0x48(%rsp), %rsi
movq %r14, %rdi
callq 0x2e310
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1f5d0
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x41bcb
callq 0x1f4a0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x41bda
callq 0x1f4a0
leaq 0x38(%rsp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x41bed
callq 0x1f4a0
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0xa05b6
leaq 0x15cbb5(%rip), %rsi # 0x19e7b6
leaq 0x28(%rsp), %rdi
callq 0x1f8e0
movq %r12, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x41c2e
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x41c36
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x48(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x17696a(%rip), %rsi # 0x1b85c7
leaq 0x176979(%rip), %rdx # 0x1b85dd
callq 0x250b2
leaq 0x48(%rsp), %rsi
movq %r14, %rdi
callq 0x2e310
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1f5d0
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x41c92
callq 0x1f4a0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x41ca1
callq 0x1f4a0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x41cb0
callq 0x1f4a0
movq %r15, %rdi
callq 0x11d7ce
movq 0x28(%rax), %r15
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0x41ce1
leaq 0xf7f68(%rip), %rax # 0x139c34
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x28(%rsp), %rdx
movq %r15, (%rdx)
callq 0x2f19d
movb 0x2(%r15), %al
cmpb $0x9, %al
jne 0x41cf2
movb $0x0, 0x50(%rbx)
jmp 0x41d86
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0x41d1b
leaq 0xf7f32(%rip), %rax # 0x139c34
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x28(%rsp), %rdx
movq %r15, (%rdx)
callq 0x2f19d
movb 0x2(%r15), %al
cmpb $0xc, %al
setne 0x50(%rbx)
je 0x41d86
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xa132e
leaq 0x28(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x15ee7d(%rip), %rsi # 0x1a0bbf
leaq 0x15ee8b(%rip), %rdx # 0x1a0bd4
callq 0x250b2
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x2e310
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1f5d0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x41d77
callq 0x1f4a0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x41d86
callq 0x1f4a0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x41dac
callq 0x1f4a0
jmp 0x41dac
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
jne 0x41e2f
jmp 0x41e3b
jmp 0x41e38
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x41dd4
callq 0x1f4a0
jmp 0x41dd4
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x41de8
callq 0x1f4a0
jmp 0x41de8
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
jne 0x41e2f
jmp 0x41e3b
jmp 0x41e38
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x41e0d
callq 0x1f4a0
jmp 0x41e0d
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x41e21
callq 0x1f4a0
jmp 0x41e21
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x41e3b
callq 0x1f4a0
jmp 0x41e3b
jmp 0x41e38
movq %rax, %r14
movq %rbx, %rdi
callq 0xa1244
movq %r14, %rdi
callq 0x1f860
nop
| _ZN6google8protobuf8compiler6csharp21WrapperFieldGeneratorC2EPKNS0_15FieldDescriptorEiPKNS2_7OptionsE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r15, rsi
mov rbx, rdi
call _ZN6google8protobuf8compiler6csharp18FieldGeneratorBaseC2EPKNS0_15FieldDescriptorEiPKNS2_7OptionsE; google::protobuf::compiler::csharp::FieldGeneratorBase::FieldGeneratorBase(google::protobuf::FieldDescriptor const*,int,google::protobuf::compiler::csharp::Options const*)
lea rax, off_276EB8
mov [rbx], rax
lea rdi, [rsp+98h+var_70]
mov rsi, rbx
call _ZN6google8protobuf8compiler6csharp18FieldGeneratorBase4nameB5cxx11Ev; google::protobuf::compiler::csharp::FieldGeneratorBase::name(void)
lea rsi, aNull; "_ != null"
lea rdi, [rsp+98h+var_70]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea r12, [rsp+98h+var_80]
mov [r12-10h], r12
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_41B5D
mov [rsp+98h+var_90], rdx
mov rdx, [rcx]
mov [rsp+98h+var_80], rdx
jmp short loc_41B65
loc_41B5D:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r12], xmm0
loc_41B65:
mov rdx, [rax+8]
mov [rsp+98h+var_88], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
lea rbp, [rsp+98h+var_40]
mov [rbp-10h], rbp
lea rsi, aOtherHasProper+6; "has_property_check"
lea rdx, aOtherHasProper+18h; ""
lea rdi, [rsp+98h+var_50]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea r14, [rbx+20h]
lea rsi, [rsp+98h+var_50]
mov rdi, r14
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_St4lessIS5_ESaISt4pairIKS5_S5_EEEixEOS5_; std::map<std::string,std::string>::operator[](std::string&&)
lea rsi, [rsp+98h+var_90]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [rsp+98h+var_50]; void *
cmp rdi, rbp
jz short loc_41BCB
call __ZdlPv; operator delete(void *)
loc_41BCB:
mov rdi, [rsp+98h+var_90]; void *
cmp rdi, r12
jz short loc_41BDA
call __ZdlPv; operator delete(void *)
loc_41BDA:
lea r13, [rsp+98h+var_60]
mov rdi, [r13-10h]; void *
cmp rdi, r13
jz short loc_41BED
call __ZdlPv; operator delete(void *)
loc_41BED:
lea rdi, [rsp+98h+var_70]
mov rsi, rbx
call _ZN6google8protobuf8compiler6csharp18FieldGeneratorBase4nameB5cxx11Ev; google::protobuf::compiler::csharp::FieldGeneratorBase::name(void)
lea rsi, aNull_0; "_ == null"
lea rdi, [rsp+98h+var_70]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov [rsp+98h+var_90], r12
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_41C2E
mov [rsp+98h+var_90], rdx
mov rdx, [rcx]
mov [rsp+98h+var_80], rdx
jmp short loc_41C36
loc_41C2E:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r12], xmm0
loc_41C36:
mov rdx, [rax+8]
mov [rsp+98h+var_88], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
lea rdi, [rsp+98h+var_50]
mov [rdi], rbp
lea rsi, aOtherHasNotPro+6; "has_not_property_check"
lea rdx, aOtherHasNotPro+1Ch; ""
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rsi, [rsp+98h+var_50]
mov rdi, r14
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_St4lessIS5_ESaISt4pairIKS5_S5_EEEixEOS5_; std::map<std::string,std::string>::operator[](std::string&&)
lea rsi, [rsp+98h+var_90]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [rsp+98h+var_50]; void *
cmp rdi, rbp
jz short loc_41C92
call __ZdlPv; operator delete(void *)
loc_41C92:
mov rdi, [rsp+98h+var_90]; void *
cmp rdi, r12
jz short loc_41CA1
call __ZdlPv; operator delete(void *)
loc_41CA1:
mov rdi, [rsp+98h+var_70]; void *
cmp rdi, r13
jz short loc_41CB0
call __ZdlPv; operator delete(void *)
loc_41CB0:
mov rdi, r15; this
call _ZNK6google8protobuf15FieldDescriptor12message_typeEv; google::protobuf::FieldDescriptor::message_type(void)
mov r15, [rax+28h]
mov rdi, [r15+18h]
test rdi, rdi
jz short loc_41CE1
lea rax, _ZN6google8protobuf15FieldDescriptor12TypeOnceInitEPKS1_; google::protobuf::FieldDescriptor::TypeOnceInit(google::protobuf::FieldDescriptor const*)
lea rsi, [rsp+98h+var_90]
mov [rsi], rax
lea rdx, [rsp+98h+var_70]
mov [rdx], r15
call _ZSt9call_onceIPFvPKN6google8protobuf15FieldDescriptorEEJS4_EEvRSt9once_flagOT_DpOT0_; std::call_once<void (*)(google::protobuf::FieldDescriptor const*),google::protobuf::FieldDescriptor const*>(std::once_flag &,void (*)(google::protobuf::FieldDescriptor const*) &&,google::protobuf::FieldDescriptor const* &&)
loc_41CE1:
mov al, [r15+2]
cmp al, 9
jnz short loc_41CF2
mov byte ptr [rbx+50h], 0
jmp loc_41D86
loc_41CF2:
mov rdi, [r15+18h]
test rdi, rdi
jz short loc_41D1B
lea rax, _ZN6google8protobuf15FieldDescriptor12TypeOnceInitEPKS1_; google::protobuf::FieldDescriptor::TypeOnceInit(google::protobuf::FieldDescriptor const*)
lea rsi, [rsp+98h+var_90]
mov [rsi], rax
lea rdx, [rsp+98h+var_70]
mov [rdx], r15
call _ZSt9call_onceIPFvPKN6google8protobuf15FieldDescriptorEEJS4_EEvRSt9once_flagOT_DpOT0_; std::call_once<void (*)(google::protobuf::FieldDescriptor const*),google::protobuf::FieldDescriptor const*>(std::once_flag &,void (*)(google::protobuf::FieldDescriptor const*) &&,google::protobuf::FieldDescriptor const* &&)
mov al, [r15+2]
loc_41D1B:
cmp al, 0Ch
setnz byte ptr [rbx+50h]
jz short loc_41D86
lea rdi, [rsp+98h+var_90]
mov rsi, rbx
mov rdx, r15
call _ZN6google8protobuf8compiler6csharp18FieldGeneratorBase9type_nameB5cxx11EPKNS0_15FieldDescriptorE; google::protobuf::compiler::csharp::FieldGeneratorBase::type_name(google::protobuf::FieldDescriptor const*)
lea rdi, [rsp+98h+var_70]
mov [rdi], r13
lea rsi, aNonnullableTyp; "nonnullable_type_name"
lea rdx, aNonnullableTyp+15h; ""
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rsi, [rsp+98h+var_70]
mov rdi, r14
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_St4lessIS5_ESaISt4pairIKS5_S5_EEEixEOS5_; std::map<std::string,std::string>::operator[](std::string&&)
lea rsi, [rsp+98h+var_90]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [rsp+98h+var_70]; void *
cmp rdi, r13
jz short loc_41D77
call __ZdlPv; operator delete(void *)
loc_41D77:
mov rdi, [rsp+98h+var_90]; void *
cmp rdi, r12
jz short loc_41D86
call __ZdlPv; operator delete(void *)
loc_41D86:
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
mov rdi, [rsp+arg_20]; void *
cmp rdi, r13
jz short loc_41DAC
call __ZdlPv; operator delete(void *)
jmp short loc_41DAC
mov r14, rax
loc_41DAC:
mov rdi, [rsp+arg_0]
cmp rdi, r12
jnz short loc_41E2F
jmp loc_41E3B
jmp short loc_41E38
mov r14, rax
mov rdi, [rsp+arg_40]; void *
cmp rdi, rbp
jz short loc_41DD4
call __ZdlPv; operator delete(void *)
jmp short loc_41DD4
mov r14, rax
loc_41DD4:
mov rdi, [rsp+arg_0]; void *
cmp rdi, r12
jz short loc_41DE8
call __ZdlPv; operator delete(void *)
jmp short loc_41DE8
mov r14, rax
loc_41DE8:
mov rdi, [rsp+arg_20]
cmp rdi, r13
jnz short loc_41E2F
jmp short loc_41E3B
jmp short loc_41E38
mov r14, rax
mov rdi, [rsp+arg_40]; void *
cmp rdi, rbp
jz short loc_41E0D
call __ZdlPv; operator delete(void *)
jmp short loc_41E0D
mov r14, rax
loc_41E0D:
mov rdi, [rsp+arg_0]; void *
cmp rdi, r12
jz short loc_41E21
call __ZdlPv; operator delete(void *)
jmp short loc_41E21
mov r14, rax
loc_41E21:
lea rax, [rsp+arg_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_41E3B
loc_41E2F:
call __ZdlPv; operator delete(void *)
jmp short loc_41E3B
jmp short $+2
loc_41E38:
mov r14, rax
loc_41E3B:
mov rdi, rbx; this
call _ZN6google8protobuf8compiler6csharp18FieldGeneratorBaseD2Ev; google::protobuf::compiler::csharp::FieldGeneratorBase::~FieldGeneratorBase()
mov rdi, r14
call __Unwind_Resume
| void google::protobuf::compiler::csharp::WrapperFieldGenerator::WrapperFieldGenerator(
google::protobuf::compiler::csharp::WrapperFieldGenerator *this,
const google::protobuf::FieldDescriptor *a2,
int a3,
const google::protobuf::compiler::csharp::Options *a4)
{
int v5; // edx
int v6; // ecx
int v7; // r8d
int v8; // r9d
long long v9; // rax
__int128 *v10; // rcx
long long v11; // rax
int v12; // edx
int v13; // ecx
int v14; // r8d
int v15; // r9d
long long v16; // rax
__int128 *v17; // rcx
long long v18; // rax
int v19; // ecx
int v20; // r8d
int v21; // r9d
long long v22; // r15
long long v23; // rdi
char v24; // al
long long v25; // rdi
long long v26; // rax
void *v27; // [rsp+8h] [rbp-90h] BYREF
long long v28; // [rsp+10h] [rbp-88h]
__int128 v29; // [rsp+18h] [rbp-80h] BYREF
void *v30[2]; // [rsp+28h] [rbp-70h] BYREF
_BYTE v31[16]; // [rsp+38h] [rbp-60h] BYREF
void *v32[2]; // [rsp+48h] [rbp-50h] BYREF
_BYTE v33[64]; // [rsp+58h] [rbp-40h] BYREF
google::protobuf::compiler::csharp::FieldGeneratorBase::FieldGeneratorBase(this, a2, a3, a4);
*(_QWORD *)this = off_276EB8;
google::protobuf::compiler::csharp::FieldGeneratorBase::name[abi:cxx11](
(unsigned int)v30,
(_DWORD)this,
v5,
v6,
v7,
v8);
v9 = std::string::append(v30, "_ != null");
v27 = &v29;
v10 = (__int128 *)(v9 + 16);
if ( *(_QWORD *)v9 == v9 + 16 )
{
v29 = *v10;
}
else
{
v27 = *(void **)v9;
*(_QWORD *)&v29 = *(_QWORD *)v10;
}
v28 = *(_QWORD *)(v9 + 8);
*(_QWORD *)v9 = v10;
*(_QWORD *)(v9 + 8) = 0LL;
*(_BYTE *)(v9 + 16) = 0;
v32[0] = v33;
std::string::_M_construct<char const*>((long long)v32, "has_property_check", (long long)"");
v11 = std::map<std::string,std::string>::operator[]((long long)this + 32, (long long)v32);
std::string::operator=(v11, &v27);
if ( v32[0] != v33 )
operator delete(v32[0]);
if ( v27 != &v29 )
operator delete(v27);
if ( v30[0] != v31 )
operator delete(v30[0]);
google::protobuf::compiler::csharp::FieldGeneratorBase::name[abi:cxx11](
(unsigned int)v30,
(_DWORD)this,
v12,
v13,
v14,
v15);
v16 = std::string::append(v30, "_ == null");
v27 = &v29;
v17 = (__int128 *)(v16 + 16);
if ( *(_QWORD *)v16 == v16 + 16 )
{
v29 = *v17;
}
else
{
v27 = *(void **)v16;
*(_QWORD *)&v29 = *(_QWORD *)v17;
}
v28 = *(_QWORD *)(v16 + 8);
*(_QWORD *)v16 = v17;
*(_QWORD *)(v16 + 8) = 0LL;
*(_BYTE *)(v16 + 16) = 0;
v32[0] = v33;
std::string::_M_construct<char const*>((long long)v32, "has_not_property_check", (long long)"");
v18 = std::map<std::string,std::string>::operator[]((long long)this + 32, (long long)v32);
std::string::operator=(v18, &v27);
if ( v32[0] != v33 )
operator delete(v32[0]);
if ( v27 != &v29 )
operator delete(v27);
if ( v30[0] != v31 )
operator delete(v30[0]);
v22 = *(_QWORD *)(google::protobuf::FieldDescriptor::message_type(a2) + 40);
v23 = *(_QWORD *)(v22 + 24);
if ( v23 )
{
v27 = google::protobuf::FieldDescriptor::TypeOnceInit;
v30[0] = (void *)v22;
std::call_once<void (*)(google::protobuf::FieldDescriptor const*),google::protobuf::FieldDescriptor const*>(
v23,
(long long)&v27,
(long long)v30);
}
v24 = *(_BYTE *)(v22 + 2);
if ( v24 == 9 )
{
*((_BYTE *)this + 80) = 0;
}
else
{
v25 = *(_QWORD *)(v22 + 24);
if ( v25 )
{
v27 = google::protobuf::FieldDescriptor::TypeOnceInit;
v30[0] = (void *)v22;
std::call_once<void (*)(google::protobuf::FieldDescriptor const*),google::protobuf::FieldDescriptor const*>(
v25,
(long long)&v27,
(long long)v30);
v24 = *(_BYTE *)(v22 + 2);
}
*((_BYTE *)this + 80) = v24 != 12;
if ( v24 != 12 )
{
google::protobuf::compiler::csharp::FieldGeneratorBase::type_name[abi:cxx11](
(unsigned int)&v27,
(_DWORD)this,
v22,
v19,
v20,
v21);
v30[0] = v31;
std::string::_M_construct<char const*>((long long)v30, "nonnullable_type_name", (long long)"");
v26 = std::map<std::string,std::string>::operator[]((long long)this + 32, (long long)v30);
std::string::operator=(v26, &v27);
if ( v30[0] != v31 )
operator delete(v30[0]);
if ( v27 != &v29 )
operator delete(v27);
}
}
}
| WrapperFieldGenerator:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R15,RSI
MOV RBX,RDI
CALL 0x001a11ca
LEA RAX,[0x376eb8]
MOV qword ptr [RBX],RAX
LAB_00141b17:
LEA RDI,[RSP + 0x28]
MOV RSI,RBX
CALL 0x001a05b6
LAB_00141b24:
LEA RSI,[0x29e7ac]
LEA RDI,[RSP + 0x28]
CALL 0x0011f8e0
LEA R12,[RSP + 0x18]
MOV qword ptr [R12 + -0x10],R12
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x00141b5d
MOV qword ptr [RSP + 0x8],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x18],RDX
JMP 0x00141b65
LAB_00141b5d:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R12],XMM0
LAB_00141b65:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LEA RBP,[RSP + 0x58]
MOV qword ptr [RBP + -0x10],RBP
LAB_00141b86:
LEA RSI,[0x29f3a4]
LEA RDX,[0x29f3b6]
LEA RDI,[RSP + 0x48]
CALL 0x001250b2
LAB_00141b9e:
LEA R14,[RBX + 0x20]
LEA RSI,[RSP + 0x48]
MOV RDI,R14
CALL 0x0012e310
LEA RSI,[RSP + 0x8]
MOV RDI,RAX
CALL 0x0011f5d0
MOV RDI,qword ptr [RSP + 0x48]
CMP RDI,RBP
JZ 0x00141bcb
CALL 0x0011f4a0
LAB_00141bcb:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R12
JZ 0x00141bda
CALL 0x0011f4a0
LAB_00141bda:
LEA R13,[RSP + 0x38]
MOV RDI,qword ptr [R13 + -0x10]
CMP RDI,R13
JZ 0x00141bed
CALL 0x0011f4a0
LAB_00141bed:
LEA RDI,[RSP + 0x28]
MOV RSI,RBX
CALL 0x001a05b6
LAB_00141bfa:
LEA RSI,[0x29e7b6]
LEA RDI,[RSP + 0x28]
CALL 0x0011f8e0
MOV qword ptr [RSP + 0x8],R12
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x00141c2e
MOV qword ptr [RSP + 0x8],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x18],RDX
JMP 0x00141c36
LAB_00141c2e:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R12],XMM0
LAB_00141c36:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LEA RDI,[RSP + 0x48]
MOV qword ptr [RDI],RBP
LAB_00141c56:
LEA RSI,[0x2b85c7]
LEA RDX,[0x2b85dd]
CALL 0x001250b2
LAB_00141c69:
LEA RSI,[RSP + 0x48]
MOV RDI,R14
CALL 0x0012e310
LEA RSI,[RSP + 0x8]
MOV RDI,RAX
CALL 0x0011f5d0
MOV RDI,qword ptr [RSP + 0x48]
CMP RDI,RBP
JZ 0x00141c92
CALL 0x0011f4a0
LAB_00141c92:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R12
JZ 0x00141ca1
CALL 0x0011f4a0
LAB_00141ca1:
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R13
JZ 0x00141cb0
CALL 0x0011f4a0
LAB_00141cb0:
MOV RDI,R15
CALL 0x0021d7ce
MOV R15,qword ptr [RAX + 0x28]
MOV RDI,qword ptr [R15 + 0x18]
TEST RDI,RDI
JZ 0x00141ce1
LEA RAX,[0x239c34]
LEA RSI,[RSP + 0x8]
MOV qword ptr [RSI],RAX
LEA RDX,[RSP + 0x28]
MOV qword ptr [RDX],R15
CALL 0x0012f19d
LAB_00141ce1:
MOV AL,byte ptr [R15 + 0x2]
CMP AL,0x9
JNZ 0x00141cf2
MOV byte ptr [RBX + 0x50],0x0
JMP 0x00141d86
LAB_00141cf2:
MOV RDI,qword ptr [R15 + 0x18]
TEST RDI,RDI
JZ 0x00141d1b
LEA RAX,[0x239c34]
LEA RSI,[RSP + 0x8]
MOV qword ptr [RSI],RAX
LEA RDX,[RSP + 0x28]
MOV qword ptr [RDX],R15
CALL 0x0012f19d
MOV AL,byte ptr [R15 + 0x2]
LAB_00141d1b:
CMP AL,0xc
SETNZ byte ptr [RBX + 0x50]
JZ 0x00141d86
LAB_00141d23:
LEA RDI,[RSP + 0x8]
MOV RSI,RBX
MOV RDX,R15
CALL 0x001a132e
LEA RDI,[RSP + 0x28]
MOV qword ptr [RDI],R13
LAB_00141d3b:
LEA RSI,[0x2a0bbf]
LEA RDX,[0x2a0bd4]
CALL 0x001250b2
LAB_00141d4e:
LEA RSI,[RSP + 0x28]
MOV RDI,R14
CALL 0x0012e310
LAB_00141d5b:
LEA RSI,[RSP + 0x8]
MOV RDI,RAX
CALL 0x0011f5d0
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R13
JZ 0x00141d77
CALL 0x0011f4a0
LAB_00141d77:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R12
JZ 0x00141d86
CALL 0x0011f4a0
LAB_00141d86:
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* google::protobuf::compiler::csharp::WrapperFieldGenerator::WrapperFieldGenerator(google::protobuf::FieldDescriptor
const*, int, google::protobuf::compiler::csharp::Options const*) */
void __thiscall
google::protobuf::compiler::csharp::WrapperFieldGenerator::WrapperFieldGenerator
(WrapperFieldGenerator *this,FieldDescriptor *param_1,int param_2,Options *param_3)
{
map<std::__cxx11::string,std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
*this_00;
FieldDescriptor *pFVar1;
FieldDescriptor FVar2;
long *plVar3;
string *psVar4;
long lVar5;
code *pcVar6;
code *local_90;
long local_88;
long local_80;
int4 uStack_78;
int4 uStack_74;
FieldDescriptor *local_70 [2];
FieldDescriptor local_60 [16];
int1 *local_50 [2];
int1 local_40 [16];
FieldGeneratorBase::FieldGeneratorBase((FieldGeneratorBase *)this,param_1,param_2,param_3);
*(int ***)this = &PTR__WrapperOneofFieldGenerator_00376eb8;
/* try { // try from 00141b17 to 00141b23 has its CatchHandler @ 00141e36 */
FieldGeneratorBase::name_abi_cxx11_();
/* try { // try from 00141b24 to 00141b34 has its CatchHandler @ 00141e1e */
plVar3 = (long *)std::__cxx11::string::append((char *)local_70);
pcVar6 = (code *)(plVar3 + 2);
if ((code *)*plVar3 == pcVar6) {
local_80 = *(long *)pcVar6;
uStack_78 = (int4)plVar3[3];
uStack_74 = *(int4 *)((long)plVar3 + 0x1c);
local_90 = (code *)&local_80;
}
else {
local_80 = *(long *)pcVar6;
local_90 = (code *)*plVar3;
}
local_88 = plVar3[1];
*plVar3 = (long)pcVar6;
plVar3[1] = 0;
*(int1 *)(plVar3 + 2) = 0;
/* try { // try from 00141b86 to 00141b9d has its CatchHandler @ 00141e0a */
local_50[0] = local_40;
std::__cxx11::string::_M_construct<char_const*>(local_50,"has_property_check","");
/* try { // try from 00141b9e to 00141bae has its CatchHandler @ 00141df6 */
this_00 = (map<std::__cxx11::string,std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
*)(this + 0x20);
psVar4 = (string *)
std::
map<std::__cxx11::string,std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
::operator[](this_00,(string *)local_50);
std::__cxx11::string::operator=(psVar4,(string *)&local_90);
if (local_50[0] != local_40) {
operator_delete(local_50[0]);
}
if (local_90 != (code *)&local_80) {
operator_delete(local_90);
}
if (local_70[0] != local_60) {
operator_delete(local_70[0]);
}
/* try { // try from 00141bed to 00141bf9 has its CatchHandler @ 00141df4 */
FieldGeneratorBase::name_abi_cxx11_();
/* try { // try from 00141bfa to 00141c0a has its CatchHandler @ 00141de5 */
plVar3 = (long *)std::__cxx11::string::append((char *)local_70);
pcVar6 = (code *)(plVar3 + 2);
if ((code *)*plVar3 == pcVar6) {
local_80 = *(long *)pcVar6;
uStack_78 = (int4)plVar3[3];
uStack_74 = *(int4 *)((long)plVar3 + 0x1c);
local_90 = (code *)&local_80;
}
else {
local_80 = *(long *)pcVar6;
local_90 = (code *)*plVar3;
}
local_88 = plVar3[1];
*plVar3 = (long)pcVar6;
plVar3[1] = 0;
*(int1 *)(plVar3 + 2) = 0;
local_50[0] = local_40;
/* try { // try from 00141c56 to 00141c68 has its CatchHandler @ 00141dd1 */
std::__cxx11::string::_M_construct<char_const*>(local_50,"has_not_property_check","");
/* try { // try from 00141c69 to 00141c75 has its CatchHandler @ 00141dbd */
psVar4 = (string *)
std::
map<std::__cxx11::string,std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
::operator[](this_00,(string *)local_50);
std::__cxx11::string::operator=(psVar4,(string *)&local_90);
if (local_50[0] != local_40) {
operator_delete(local_50[0]);
}
if (local_90 != (code *)&local_80) {
operator_delete(local_90);
}
if (local_70[0] != local_60) {
operator_delete(local_70[0]);
}
/* try { // try from 00141cb0 to 00141d16 has its CatchHandler @ 00141e38 */
lVar5 = FieldDescriptor::message_type(param_1);
pFVar1 = *(FieldDescriptor **)(lVar5 + 0x28);
if (*(once_flag **)(pFVar1 + 0x18) != (once_flag *)0x0) {
local_90 = FieldDescriptor::TypeOnceInit;
local_70[0] = pFVar1;
std::
call_once<void(*)(google::protobuf::FieldDescriptor_const*),google::protobuf::FieldDescriptor_const*>
(*(once_flag **)(pFVar1 + 0x18),(_func_void_FieldDescriptor_ptr *)&local_90,local_70);
}
FVar2 = pFVar1[2];
if (FVar2 == (FieldDescriptor)0x9) {
this[0x50] = (WrapperFieldGenerator)0x0;
}
else {
if (*(once_flag **)(pFVar1 + 0x18) != (once_flag *)0x0) {
local_90 = FieldDescriptor::TypeOnceInit;
local_70[0] = pFVar1;
std::
call_once<void(*)(google::protobuf::FieldDescriptor_const*),google::protobuf::FieldDescriptor_const*>
(*(once_flag **)(pFVar1 + 0x18),(_func_void_FieldDescriptor_ptr *)&local_90,local_70
);
FVar2 = pFVar1[2];
}
this[0x50] = (WrapperFieldGenerator)(FVar2 != (FieldDescriptor)0xc);
if (FVar2 != (FieldDescriptor)0xc) {
/* try { // try from 00141d23 to 00141d32 has its CatchHandler @ 00141dbb */
FieldGeneratorBase::type_name_abi_cxx11_((FieldDescriptor *)&local_90);
local_70[0] = local_60;
/* try { // try from 00141d3b to 00141d4d has its CatchHandler @ 00141da9 */
std::__cxx11::string::_M_construct<char_const*>(local_70,"nonnullable_type_name","");
/* try { // try from 00141d4e to 00141d5a has its CatchHandler @ 00141d95 */
psVar4 = (string *)
std::
map<std::__cxx11::string,std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
::operator[](this_00,(string *)local_70);
std::__cxx11::string::operator=(psVar4,(string *)&local_90);
if (local_70[0] != local_60) {
operator_delete(local_70[0]);
}
if (local_90 != (code *)&local_80) {
operator_delete(local_90);
}
}
}
return;
}
| |
54,182 | my_uca_copy_page | eloqsql/strings/ctype-uca.c | static my_bool
my_uca_copy_page(MY_CHARSET_LOADER *loader,
const MY_UCA_WEIGHT_LEVEL *src,
MY_UCA_WEIGHT_LEVEL *dst,
size_t page)
{
uint chc, size= 256 * dst->lengths[page] * sizeof(uint16);
if (!(dst->weights[page]= (uint16 *) (loader->once_alloc)(size)))
return TRUE;
DBUG_ASSERT(src->lengths[page] <= dst->lengths[page]);
memset(dst->weights[page], 0, size);
for (chc=0 ; chc < 256; chc++)
{
memcpy(dst->weights[page] + chc * dst->lengths[page],
src->weights[page] + chc * src->lengths[page],
src->lengths[page] * sizeof(uint16));
}
return FALSE;
} | O0 | c | my_uca_copy_page:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
cltq
shlq %rax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movl -0x30(%rbp), %ecx
movl %ecx, %edi
callq *%rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x28(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
jne 0x58184
movb $0x1, -0x1(%rbp)
jmp 0x58240
jmp 0x58186
jmp 0x58188
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0x30(%rbp), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x24180
movl $0x0, -0x2c(%rbp)
cmpl $0x100, -0x2c(%rbp) # imm = 0x100
jae 0x5823c
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
imull %ecx, %eax
movl %eax, %eax
shlq %rax
addq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl -0x2c(%rbp), %eax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
imull %ecx, %eax
movl %eax, %eax
shlq %rax
addq %rax, %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %edx
shlq %rdx
callq 0x24200
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x581ab
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| my_uca_copy_page:
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_28], rcx
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov rcx, [rbp+var_28]
movzx eax, byte ptr [rax+rcx]
shl eax, 8
cdqe
shl rax, 1
mov [rbp+var_30], eax
mov rax, [rbp+var_10]
mov rax, [rax+80h]
mov ecx, [rbp+var_30]
mov edi, ecx
call rax
mov rcx, [rbp+var_20]
mov rcx, [rcx+10h]
mov rdx, [rbp+var_28]
mov [rcx+rdx*8], rax
cmp rax, 0
jnz short loc_58184
mov [rbp+var_1], 1
jmp loc_58240
loc_58184:
jmp short $+2
loc_58186:
jmp short $+2
loc_58188:
mov rax, [rbp+var_20]
mov rax, [rax+10h]
mov rcx, [rbp+var_28]
mov rdi, [rax+rcx*8]
mov eax, [rbp+var_30]
mov edx, eax
xor esi, esi
call _memset
mov [rbp+var_2C], 0
loc_581AB:
cmp [rbp+var_2C], 100h
jnb loc_5823C
mov rax, [rbp+var_20]
mov rax, [rax+10h]
mov rcx, [rbp+var_28]
mov rdi, [rax+rcx*8]
mov eax, [rbp+var_2C]
mov rcx, [rbp+var_20]
mov rcx, [rcx+8]
mov rdx, [rbp+var_28]
movzx ecx, byte ptr [rcx+rdx]
imul eax, ecx
mov eax, eax
shl rax, 1
add rdi, rax
mov rax, [rbp+var_18]
mov rax, [rax+10h]
mov rcx, [rbp+var_28]
mov rsi, [rax+rcx*8]
mov eax, [rbp+var_2C]
mov rcx, [rbp+var_18]
mov rcx, [rcx+8]
mov rdx, [rbp+var_28]
movzx ecx, byte ptr [rcx+rdx]
imul eax, ecx
mov eax, eax
shl rax, 1
add rsi, rax
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov rcx, [rbp+var_28]
movzx eax, byte ptr [rax+rcx]
mov edx, eax
shl rdx, 1
call _memcpy
mov eax, [rbp+var_2C]
add eax, 1
mov [rbp+var_2C], eax
jmp loc_581AB
loc_5823C:
mov [rbp+var_1], 0
loc_58240:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char my_uca_copy_page(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rax
unsigned int v6; // [rsp+0h] [rbp-30h]
unsigned int i; // [rsp+4h] [rbp-2Ch]
v6 = *(unsigned __int8 *)(*(_QWORD *)(a3 + 8) + a4) << 9;
v4 = (*(long long ( **)(_QWORD))(a1 + 128))(v6);
*(_QWORD *)(*(_QWORD *)(a3 + 16) + 8 * a4) = v4;
if ( !v4 )
return 1;
memset(*(_QWORD *)(*(_QWORD *)(a3 + 16) + 8 * a4), 0LL, v6);
for ( i = 0; i < 0x100; ++i )
memcpy(
2LL * *(unsigned __int8 *)(*(_QWORD *)(a3 + 8) + a4) * i + *(_QWORD *)(*(_QWORD *)(a3 + 16) + 8 * a4),
2LL * *(unsigned __int8 *)(*(_QWORD *)(a2 + 8) + a4) * i + *(_QWORD *)(*(_QWORD *)(a2 + 16) + 8 * a4),
2LL * *(unsigned __int8 *)(*(_QWORD *)(a2 + 8) + a4));
return 0;
}
| my_uca_copy_page:
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 qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
SHL EAX,0x8
CDQE
SHL RAX,0x1
MOV dword ptr [RBP + -0x30],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x80]
MOV ECX,dword ptr [RBP + -0x30]
MOV EDI,ECX
CALL RAX
MOV RCX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RCX + 0x10]
MOV RDX,qword ptr [RBP + -0x28]
MOV qword ptr [RCX + RDX*0x8],RAX
CMP RAX,0x0
JNZ 0x00158184
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00158240
LAB_00158184:
JMP 0x00158186
LAB_00158186:
JMP 0x00158188
LAB_00158188:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX + RCX*0x8]
MOV EAX,dword ptr [RBP + -0x30]
MOV EDX,EAX
XOR ESI,ESI
CALL 0x00124180
MOV dword ptr [RBP + -0x2c],0x0
LAB_001581ab:
CMP dword ptr [RBP + -0x2c],0x100
JNC 0x0015823c
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX + RCX*0x8]
MOV EAX,dword ptr [RBP + -0x2c]
MOV RCX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RCX + 0x8]
MOV RDX,qword ptr [RBP + -0x28]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
IMUL EAX,ECX
MOV EAX,EAX
SHL RAX,0x1
ADD RDI,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RAX + RCX*0x8]
MOV EAX,dword ptr [RBP + -0x2c]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX + 0x8]
MOV RDX,qword ptr [RBP + -0x28]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
IMUL EAX,ECX
MOV EAX,EAX
SHL RAX,0x1
ADD RSI,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV EDX,EAX
SHL RDX,0x1
CALL 0x00124200
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x001581ab
LAB_0015823c:
MOV byte ptr [RBP + -0x1],0x0
LAB_00158240:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 my_uca_copy_page(long param_1,long param_2,long param_3,long param_4)
{
size_t __n;
long lVar1;
int4 local_34;
int1 local_9;
__n = (long)(int)((uint)*(byte *)(*(long *)(param_3 + 8) + param_4) << 8) << 1;
lVar1 = (**(code **)(param_1 + 0x80))(__n);
*(long *)(*(long *)(param_3 + 0x10) + param_4 * 8) = lVar1;
if (lVar1 == 0) {
local_9 = 1;
}
else {
memset(*(void **)(*(long *)(param_3 + 0x10) + param_4 * 8),0,__n);
for (local_34 = 0; local_34 < 0x100; local_34 = local_34 + 1) {
memcpy((void *)(*(long *)(*(long *)(param_3 + 0x10) + param_4 * 8) +
(ulong)(local_34 * *(byte *)(*(long *)(param_3 + 8) + param_4)) * 2),
(void *)(*(long *)(*(long *)(param_2 + 0x10) + param_4 * 8) +
(ulong)(local_34 * *(byte *)(*(long *)(param_2 + 8) + param_4)) * 2),
(ulong)*(byte *)(*(long *)(param_2 + 8) + param_4) << 1);
}
local_9 = 0;
}
return local_9;
}
| |
54,183 | minja::FilterNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/minja.hpp | void do_render(std::ostringstream & out, const std::shared_ptr<Context> & context) const override {
if (!filter) throw std::runtime_error("FilterNode.filter is null");
if (!body) throw std::runtime_error("FilterNode.body is null");
auto filter_value = filter->evaluate(context);
if (!filter_value.is_callable()) {
throw std::runtime_error("Filter must be a callable: " + filter_value.dump());
}
std::string rendered_body = body->render(context);
ArgumentsValue filter_args = {{Value(rendered_body)}, {}};
auto result = filter_value.call(context, filter_args);
out << result.to_str();
} | O0 | cpp | minja::FilterNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const:
subq $0x278, %rsp # imm = 0x278
movq %rdi, 0x270(%rsp)
movq %rsi, 0x268(%rsp)
movq %rdx, 0x260(%rsp)
movq 0x270(%rsp), %rdi
movq %rdi, 0x80(%rsp)
addq $0x20, %rdi
callq 0x10e0f0
testb $0x1, %al
jne 0x15b17a
movl $0x10, %edi
callq 0x5a680
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x78(%rsp)
leaq 0xb87d2(%rip), %rsi # 0x21390a
callq 0x5a470
jmp 0x15b13f
movq 0x78(%rsp), %rdi
movq 0x148e65(%rip), %rsi # 0x2a3fb0
movq 0x148e26(%rip), %rdx # 0x2a3f78
callq 0x5aae0
movq 0x78(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x258(%rsp)
movl %eax, 0x254(%rsp)
callq 0x5af60
jmp 0x15b642
movq 0x80(%rsp), %rdi
addq $0x30, %rdi
callq 0x14c560
testb $0x1, %al
jne 0x15b1ed
movl $0x10, %edi
callq 0x5a680
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x70(%rsp)
leaq 0xb8779(%rip), %rsi # 0x213924
callq 0x5a470
jmp 0x15b1b2
movq 0x70(%rsp), %rdi
movq 0x148df2(%rip), %rsi # 0x2a3fb0
movq 0x148db3(%rip), %rdx # 0x2a3f78
callq 0x5aae0
movq 0x70(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x258(%rsp)
movl %eax, 0x254(%rsp)
callq 0x5af60
jmp 0x15b642
movq 0x80(%rsp), %rdi
addq $0x20, %rdi
callq 0x114220
movq %rax, %rsi
movq 0x260(%rsp), %rdx
leaq 0x200(%rsp), %rdi
callq 0x114230
leaq 0x200(%rsp), %rdi
callq 0x133e70
testb $0x1, %al
jne 0x15b32c
movb $0x1, 0x1bf(%rsp)
movl $0x10, %edi
callq 0x5a680
movq %rax, 0x68(%rsp)
leaq 0x1c0(%rsp), %rdi
leaq 0x200(%rsp), %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x114c00
jmp 0x15b260
leaq 0xb86d5(%rip), %rsi # 0x21393c
leaq 0x1e0(%rsp), %rdi
leaq 0x1c0(%rsp), %rdx
callq 0xf99c0
jmp 0x15b27e
movq 0x68(%rsp), %rdi
leaq 0x1e0(%rsp), %rsi
callq 0x5a4c0
jmp 0x15b292
movq 0x68(%rsp), %rdi
movb $0x0, 0x1bf(%rsp)
movq 0x148d0a(%rip), %rsi # 0x2a3fb0
movq 0x148ccb(%rip), %rdx # 0x2a3f78
callq 0x5aae0
jmp 0x15b64f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x258(%rsp)
movl %eax, 0x254(%rsp)
jmp 0x15b311
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x258(%rsp)
movl %eax, 0x254(%rsp)
jmp 0x15b304
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x258(%rsp)
movl %eax, 0x254(%rsp)
leaq 0x1e0(%rsp), %rdi
callq 0x5b548
leaq 0x1c0(%rsp), %rdi
callq 0x5b548
testb $0x1, 0x1bf(%rsp)
jne 0x15b31d
jmp 0x15b327
movq 0x68(%rsp), %rdi
callq 0x5af60
jmp 0x15b635
movq 0x80(%rsp), %rdi
addq $0x30, %rdi
callq 0x1494a0
movq %rax, %rsi
movq 0x260(%rsp), %rdx
leaq 0x198(%rsp), %rdi
callq 0x156a50
jmp 0x15b357
leaq 0x168(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x108(%rsp), %rdi
movq %rdi, 0x100(%rsp)
leaq 0x198(%rsp), %rsi
callq 0x11be40
jmp 0x15b383
leaq 0x108(%rsp), %rax
movq %rax, 0x158(%rsp)
movq $0x1, 0x160(%rsp)
leaq 0xff(%rsp), %rdi
movq %rdi, 0x58(%rsp)
callq 0x11ebd0
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rcx
movq 0x158(%rsp), %rsi
movq 0x160(%rsp), %rdx
callq 0x133840
jmp 0x15b3d2
leaq 0x168(%rsp), %rdi
addq $0x18, %rdi
movq %rdi, 0x40(%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x5a560
movq 0x40(%rsp), %rdi
callq 0x134950
leaq 0xff(%rsp), %rdi
callq 0x11ebe0
leaq 0x108(%rsp), %rax
movq %rax, 0x48(%rsp)
addq $0x50, %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
addq $-0x50, %rdi
movq %rdi, 0x38(%rsp)
callq 0x1146d0
movq 0x48(%rsp), %rcx
movq 0x38(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x50(%rsp)
jne 0x15b41c
movq 0x260(%rsp), %rdx
leaq 0xa8(%rsp), %rdi
leaq 0x200(%rsp), %rsi
leaq 0x168(%rsp), %rcx
callq 0x133e90
jmp 0x15b46a
movq 0x268(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x13ea70
jmp 0x15b48e
movq 0x30(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x5a540
jmp 0x15b4a2
leaq 0x88(%rsp), %rdi
callq 0x5b548
leaq 0xa8(%rsp), %rdi
callq 0x1146d0
leaq 0x168(%rsp), %rdi
callq 0x134060
leaq 0x198(%rsp), %rdi
callq 0x5b548
leaq 0x200(%rsp), %rdi
callq 0x1146d0
addq $0x278, %rsp # imm = 0x278
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x258(%rsp)
movl %eax, 0x254(%rsp)
jmp 0x15b635
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x258(%rsp)
movl %eax, 0x254(%rsp)
movq 0x100(%rsp), %rax
leaq 0x108(%rsp), %rcx
cmpq %rax, %rcx
movq %rax, 0x28(%rsp)
je 0x15b55c
movq 0x28(%rsp), %rdi
addq $-0x50, %rdi
movq %rdi, 0x20(%rsp)
callq 0x1146d0
movq 0x20(%rsp), %rax
leaq 0x108(%rsp), %rcx
cmpq %rcx, %rax
movq %rax, 0x28(%rsp)
jne 0x15b532
jmp 0x15b628
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x258(%rsp)
movl %eax, 0x254(%rsp)
leaq 0xff(%rsp), %rdi
callq 0x11ebe0
leaq 0x108(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x50, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
addq $-0x50, %rdi
movq %rdi, 0x8(%rsp)
callq 0x1146d0
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x18(%rsp)
jne 0x15b598
jmp 0x15b628
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x258(%rsp)
movl %eax, 0x254(%rsp)
jmp 0x15b61b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x258(%rsp)
movl %eax, 0x254(%rsp)
jmp 0x15b60e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x258(%rsp)
movl %eax, 0x254(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x5b548
leaq 0xa8(%rsp), %rdi
callq 0x1146d0
leaq 0x168(%rsp), %rdi
callq 0x134060
leaq 0x198(%rsp), %rdi
callq 0x5b548
leaq 0x200(%rsp), %rdi
callq 0x1146d0
movq 0x258(%rsp), %rdi
callq 0x5aba0
nop
| _ZNK5minja10FilterNode9do_renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS_7ContextEE:
sub rsp, 278h
mov [rsp+278h+var_8], rdi
mov [rsp+278h+var_10], rsi
mov qword ptr [rsp+278h+var_18], rdx
mov rdi, [rsp+278h+var_8]
mov [rsp+278h+var_1F8], rdi
add rdi, 20h ; ' '
call _ZNKSt12__shared_ptrIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2EEcvbEv; std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool(void)
test al, 1
jnz short loc_15B17A
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+278h+var_200], rax
lea rsi, aFilternodeFilt; "FilterNode.filter is null"
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_15B13F:
mov rdi, [rsp+278h+var_200]; void *
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
mov rdi, [rsp+278h+var_200]; void *
mov rcx, rax
mov eax, edx
mov [rsp+278h+var_20], rcx
mov [rsp+278h+var_24], eax
call ___cxa_free_exception
jmp loc_15B642
loc_15B17A:
mov rdi, [rsp+278h+var_1F8]
add rdi, 30h ; '0'
call _ZNKSt12__shared_ptrIN5minja12TemplateNodeELN9__gnu_cxx12_Lock_policyE2EEcvbEv; std::__shared_ptr<minja::TemplateNode,(__gnu_cxx::_Lock_policy)2>::operator bool(void)
test al, 1
jnz short loc_15B1ED
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+278h+var_208], rax
lea rsi, aFilternodeBody; "FilterNode.body is null"
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_15B1B2:
mov rdi, [rsp+278h+var_208]; void *
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
mov rdi, [rsp+278h+var_208]; void *
mov rcx, rax
mov eax, edx
mov [rsp+278h+var_20], rcx
mov [rsp+278h+var_24], eax
call ___cxa_free_exception
jmp loc_15B642
loc_15B1ED:
mov rdi, [rsp+278h+var_1F8]
add rdi, 20h ; ' '
call _ZNKSt19__shared_ptr_accessIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rsi, rax
mov rdx, qword ptr [rsp+278h+var_18]
lea rdi, [rsp+278h+var_78]
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
lea rdi, [rsp+278h+var_78]; this
call _ZNK5minja5Value11is_callableEv; minja::Value::is_callable(void)
test al, 1
jnz loc_15B32C
mov [rsp+278h+var_B9], 1
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov [rsp+278h+var_210], rax
lea rdi, [rsp+278h+var_B8]
lea rsi, [rsp+278h+var_78]
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
jmp short $+2
loc_15B260:
lea rsi, aFilterMustBeAC; "Filter must be a callable: "
lea rdi, [rsp+278h+var_98]
lea rdx, [rsp+278h+var_B8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
jmp short $+2
loc_15B27E:
mov rdi, [rsp+278h+var_210]
lea rsi, [rsp+278h+var_98]
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
jmp short $+2
loc_15B292:
mov rdi, [rsp+278h+var_210]; void *
mov [rsp+278h+var_B9], 0
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_15B64F
mov rcx, rax
mov eax, edx
mov [rsp+278h+var_20], rcx
mov [rsp+278h+var_24], eax
jmp short loc_15B311
mov rcx, rax
mov eax, edx
mov [rsp+278h+var_20], rcx
mov [rsp+278h+var_24], eax
jmp short loc_15B304
mov rcx, rax
mov eax, edx
mov [rsp+278h+var_20], rcx
mov [rsp+278h+var_24], eax
lea rdi, [rsp+278h+var_98]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_15B304:
lea rdi, [rsp+278h+var_B8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_15B311:
test [rsp+278h+var_B9], 1
jnz short loc_15B31D
jmp short loc_15B327
loc_15B31D:
mov rdi, [rsp+278h+var_210]; void *
call ___cxa_free_exception
loc_15B327:
jmp loc_15B635
loc_15B32C:
mov rdi, [rsp+278h+var_1F8]
add rdi, 30h ; '0'
call _ZNKSt19__shared_ptr_accessIN5minja12TemplateNodeELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<minja::TemplateNode,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rsi, rax
mov rdx, qword ptr [rsp+278h+var_18]
lea rdi, [rsp+278h+var_E0]
call _ZNK5minja12TemplateNode6renderB5cxx11ERKSt10shared_ptrINS_7ContextEE; minja::TemplateNode::render(std::shared_ptr<minja::Context> const&)
jmp short $+2
loc_15B357:
lea rax, [rsp+278h+var_110]
mov [rsp+278h+var_218], rax
lea rdi, [rsp+278h+var_170]
mov [rsp+278h+var_178], rdi
lea rsi, [rsp+278h+var_E0]
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
jmp short $+2
loc_15B383:
lea rax, [rsp+278h+var_170]
mov [rsp+278h+var_120], rax
mov [rsp+278h+var_118], 1
lea rdi, [rsp+278h+var_179]
mov [rsp+278h+var_220], rdi
call _ZNSaIN5minja5ValueEEC2Ev; std::allocator<minja::Value>::allocator(void)
mov rdi, [rsp+278h+var_218]
mov rcx, [rsp+278h+var_220]
mov rsi, [rsp+278h+var_120]
mov rdx, [rsp+278h+var_118]
call _ZNSt6vectorIN5minja5ValueESaIS1_EEC2ESt16initializer_listIS1_ERKS2_; std::vector<minja::Value>::vector(std::initializer_list<minja::Value>,std::allocator<minja::Value> const&)
jmp short $+2
loc_15B3D2:
lea rdi, [rsp+278h+var_110]
add rdi, 18h
mov qword ptr [rsp+278h+var_238], rdi; int
xor esi, esi
mov edx, 18h
call _memset
mov rdi, qword ptr [rsp+278h+var_238]
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEESaIS9_EEC2Ev; std::vector<std::pair<std::string,minja::Value>>::vector(void)
lea rdi, [rsp+278h+var_179]
call _ZNSaIN5minja5ValueEED2Ev; std::allocator<minja::Value>::~allocator()
lea rax, [rsp+278h+var_170]
mov qword ptr [rsp+278h+var_230], rax; int
add rax, 50h ; 'P'
mov qword ptr [rsp+278h+var_228], rax
loc_15B41C:
mov rdi, qword ptr [rsp+278h+var_228]
add rdi, 0FFFFFFFFFFFFFFB0h; this
mov qword ptr [rsp+278h+var_240], rdi; int
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rcx, qword ptr [rsp+278h+var_230]
mov rax, qword ptr [rsp+278h+var_240]
cmp rax, rcx
mov qword ptr [rsp+278h+var_228], rax; char
jnz short loc_15B41C
mov rdx, qword ptr [rsp+278h+var_18]; int
lea rdi, [rsp+278h+var_1D0]; int
lea rsi, [rsp+278h+var_78]; int
lea rcx, [rsp+278h+var_110]; int
call _ZNK5minja5Value4callERKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueE; minja::Value::call(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)
jmp short $+2
loc_15B46A:
mov rax, [rsp+278h+var_10]
mov [rsp+278h+var_248], rax; __int64
lea rdi, [rsp+278h+var_1F0]; int
lea rsi, [rsp+278h+var_1D0]; int
call _ZNK5minja5Value6to_strB5cxx11Ev; minja::Value::to_str(void)
jmp short $+2
loc_15B48E:
mov rdi, [rsp+278h+var_248]
lea rsi, [rsp+278h+var_1F0]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
jmp short $+2
loc_15B4A2:
lea rdi, [rsp+278h+var_1F0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+278h+var_1D0]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
lea rdi, [rsp+278h+var_110]; this
call _ZN5minja14ArgumentsValueD2Ev; minja::ArgumentsValue::~ArgumentsValue()
lea rdi, [rsp+278h+var_E0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+278h+var_78]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
add rsp, 278h
retn
mov rcx, rax
mov eax, edx
mov [rsp+278h+var_20], rcx
mov [rsp+278h+var_24], eax
jmp loc_15B635
mov rcx, rax
mov eax, edx
mov [rsp+278h+var_20], rcx
mov [rsp+278h+var_24], eax
mov rax, [rsp+278h+var_178]
lea rcx, [rsp+278h+var_170]
cmp rcx, rax
mov [rsp+278h+var_250], rax
jz short loc_15B55C
loc_15B532:
mov rdi, [rsp+278h+var_250]
add rdi, 0FFFFFFFFFFFFFFB0h; this
mov [rsp+278h+var_258], rdi
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rax, [rsp+278h+var_258]
lea rcx, [rsp+278h+var_170]
cmp rax, rcx
mov [rsp+278h+var_250], rax
jnz short loc_15B532
loc_15B55C:
jmp loc_15B628
mov rcx, rax
mov eax, edx
mov [rsp+278h+var_20], rcx
mov [rsp+278h+var_24], eax
lea rdi, [rsp+278h+var_179]
call _ZNSaIN5minja5ValueEED2Ev; std::allocator<minja::Value>::~allocator()
lea rax, [rsp+278h+var_170]
mov [rsp+278h+var_268], rax
add rax, 50h ; 'P'
mov [rsp+278h+var_260], rax
loc_15B598:
mov rdi, [rsp+278h+var_260]
add rdi, 0FFFFFFFFFFFFFFB0h; this
mov [rsp+278h+var_270], rdi
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rcx, [rsp+278h+var_268]
mov rax, [rsp+278h+var_270]
cmp rax, rcx
mov [rsp+278h+var_260], rax
jnz short loc_15B598
jmp short loc_15B628
mov rcx, rax
mov eax, edx
mov [rsp+278h+var_20], rcx
mov [rsp+278h+var_24], eax
jmp short loc_15B61B
mov rcx, rax
mov eax, edx
mov [rsp+278h+var_20], rcx
mov [rsp+278h+var_24], eax
jmp short loc_15B60E
mov rcx, rax
mov eax, edx
mov [rsp+278h+var_20], rcx
mov [rsp+278h+var_24], eax
lea rdi, [rsp+278h+var_1F0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_15B60E:
lea rdi, [rsp+278h+var_1D0]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_15B61B:
lea rdi, [rsp+278h+var_110]; this
call _ZN5minja14ArgumentsValueD2Ev; minja::ArgumentsValue::~ArgumentsValue()
loc_15B628:
lea rdi, [rsp+278h+var_E0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_15B635:
lea rdi, [rsp+278h+var_78]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_15B642:
mov rdi, [rsp+278h+var_20]
call __Unwind_Resume
loc_15B64F:
nop
| void minja::FilterNode::do_render(long long a1, long long a2, long long a3, double a4)
{
void (***v4)(void); // rax
long long ( ***v5)(_QWORD); // rax
long long v6; // [rsp+30h] [rbp-248h]
int *v7; // [rsp+50h] [rbp-228h]
void *v8; // [rsp+68h] [rbp-210h]
std::runtime_error *v9; // [rsp+70h] [rbp-208h]
std::runtime_error *exception; // [rsp+78h] [rbp-200h]
int v11[8]; // [rsp+88h] [rbp-1F0h] BYREF
int v12[21]; // [rsp+A8h] [rbp-1D0h] BYREF
char v13; // [rsp+FFh] [rbp-179h] BYREF
int *v14; // [rsp+100h] [rbp-178h]
int v15[20]; // [rsp+108h] [rbp-170h] BYREF
int *v16; // [rsp+158h] [rbp-120h] BYREF
long long v17; // [rsp+160h] [rbp-118h]
int v18[6]; // [rsp+168h] [rbp-110h] BYREF
_BYTE v19[24]; // [rsp+180h] [rbp-F8h] BYREF
_BYTE v20[40]; // [rsp+198h] [rbp-E0h] BYREF
_BYTE v21[32]; // [rsp+1C0h] [rbp-B8h] BYREF
_BYTE v22[32]; // [rsp+1E0h] [rbp-98h] BYREF
int v23[21]; // [rsp+200h] [rbp-78h] BYREF
int v24[2]; // [rsp+260h] [rbp-18h]
long long v25; // [rsp+268h] [rbp-10h]
long long v26; // [rsp+270h] [rbp-8h]
v26 = a1;
v25 = a2;
*(_QWORD *)v24 = a3;
if ( !std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool((_QWORD *)(a1 + 32)) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "FilterNode.filter is null");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( !std::__shared_ptr<minja::TemplateNode,(__gnu_cxx::_Lock_policy)2>::operator bool((_QWORD *)(a1 + 48)) )
{
v9 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v9, "FilterNode.body is null");
__cxa_throw(
v9,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v4 = (void (***)(void))std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(a1 + 32);
minja::Expression::evaluate((long long)v23, v4);
if ( !minja::Value::is_callable((minja::Value *)v23) )
{
v8 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v21, (long long)v23, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v22, (long long)"Filter must be a callable: ", (long long)v21);
std::runtime_error::runtime_error(v8, v22);
v20[39] = 0;
__cxa_throw(
v8,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v5 = (long long ( ***)(_QWORD))std::__shared_ptr_access<minja::TemplateNode,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(a1 + 48);
minja::TemplateNode::render[abi:cxx11]((long long)v20, v5, *(long long *)v24);
v14 = v15;
minja::Value::Value((long long)v15, (long long)v20);
v16 = v15;
v17 = 1LL;
std::allocator<minja::Value>::allocator((long long)&v13);
std::vector<minja::Value>::vector((long long)v18, (long long)v16, v17, (long long)&v13);
memset(v19, 0LL, sizeof(v19));
std::vector<std::pair<std::string,minja::Value>>::vector((long long)v19);
std::allocator<minja::Value>::~allocator((long long)&v13);
v7 = (int *)&v16;
do
{
minja::Value::~Value((minja::Value *)(v7 - 20));
v7 -= 20;
}
while ( v7 != v15 );
minja::Value::call((long long)v12, (long long)v23, *(long long *)v24, (long long)v18);
v6 = v25;
minja::Value::to_str[abi:cxx11](v11, (minja::Value *)v12, a4);
std::operator<<<char>(v6, v11);
std::string::~string(v11);
minja::Value::~Value((minja::Value *)v12);
minja::ArgumentsValue::~ArgumentsValue((minja::ArgumentsValue *)v18);
std::string::~string(v20);
minja::Value::~Value((minja::Value *)v23);
}
| |||
54,184 | minja::FilterNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/minja.hpp | void do_render(std::ostringstream & out, const std::shared_ptr<Context> & context) const override {
if (!filter) throw std::runtime_error("FilterNode.filter is null");
if (!body) throw std::runtime_error("FilterNode.body is null");
auto filter_value = filter->evaluate(context);
if (!filter_value.is_callable()) {
throw std::runtime_error("Filter must be a callable: " + filter_value.dump());
}
std::string rendered_body = body->render(context);
ArgumentsValue filter_args = {{Value(rendered_body)}, {}};
auto result = filter_value.call(context, filter_args);
out << result.to_str();
} | O3 | cpp | minja::FilterNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rsi, %rbx
movq 0x20(%rdi), %rsi
testq %rsi, %rsi
je 0xa0f75
movq %rdi, %r14
cmpq $0x0, 0x30(%rdi)
je 0xa0f93
movq %rdx, %r15
leaq 0xc0(%rsp), %r12
movq %r12, %rdi
callq 0x865fc
cmpq $0x0, 0x30(%r12)
je 0xa0fc5
movq 0x30(%r14), %rsi
leaq 0xa0(%rsp), %rdi
movq %r15, %rdx
callq 0x9f402
leaq 0x50(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x8a94c
movq %rsp, %rdi
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rcx
movl $0x1, %edx
callq 0x93b14
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
movq $0x0, 0x28(%rsp)
leaq 0x90(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x58f20
movq %r14, %rdi
callq 0x5e40e
movq -0x8(%r14), %rdi
testq %rdi, %rdi
je 0xa0d86
callq 0x6de32
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0xa0d95
callq 0x6de32
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0xa0da4
callq 0x6de32
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0xa0dda
movq 0x8b1d3(%rip), %rax # 0x12bf88
cmpb $0x0, (%rax)
je 0xa0dc5
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0xa0dcf
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0xa0dda
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x18(%rsp), %r14
leaq 0x50(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
movq %rsp, %rcx
movq %r15, %rdx
callq 0x93ef6
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x971ee
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq %rbx, %rdi
callq 0x1aa00
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa0e33
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1a8e0
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f20
movq %rbx, %rdi
callq 0x5e40e
movq -0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xa0e5b
callq 0x6de32
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0xa0e6a
callq 0x6de32
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0xa0e79
callq 0x6de32
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0xa0eaf
movq 0x8b0fe(%rip), %rax # 0x12bf88
cmpb $0x0, (%rax)
je 0xa0e9a
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0xa0ea4
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0xa0eaf
movq (%rdi), %rax
callq *0x18(%rax)
movq %r14, %rdi
callq 0x9523e
movq %rsp, %rdi
callq 0x8e0d0
leaq 0xb0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa0ee0
movq 0xb0(%rsp), %rsi
incq %rsi
callq 0x1a8e0
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f20
movq %rbx, %rdi
callq 0x5e40e
movq -0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xa0f08
callq 0x6de32
movq 0xe8(%rsp), %rdi
testq %rdi, %rdi
je 0xa0f1a
callq 0x6de32
movq 0xd8(%rsp), %rdi
testq %rdi, %rdi
je 0xa0f2c
callq 0x6de32
movq 0xc8(%rsp), %rdi
testq %rdi, %rdi
je 0xa0f65
movq 0x8b048(%rip), %rax # 0x12bf88
cmpb $0x0, (%rax)
je 0xa0f50
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0xa0f5a
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0xa0f65
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1a450
movq %rax, %r14
leaq 0x4ffaa(%rip), %rsi # 0xf0f33
movq %rax, %rdi
callq 0x1a330
jmp 0xa0faf
movl $0x10, %edi
callq 0x1a450
movq %rax, %r14
leaq 0x4ffa6(%rip), %rsi # 0xf0f4d
movq %rax, %rdi
callq 0x1a330
movq 0x8b03a(%rip), %rsi # 0x12bff0
movq 0x8afa3(%rip), %rdx # 0x12bf60
movq %r14, %rdi
callq 0x1af10
movl $0x10, %edi
callq 0x1a450
movq %rax, %r14
movq %rsp, %rdi
leaq 0xc0(%rsp), %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x86c10
leaq 0x4ff75(%rip), %rsi # 0xf0f65
leaq 0x50(%rsp), %rdi
movq %rsp, %rdx
callq 0x793a5
movb $0x1, %bpl
leaq 0x50(%rsp), %rsi
movq %r14, %rdi
callq 0x1ae20
xorl %ebp, %ebp
movq 0x8afda(%rip), %rsi # 0x12bff0
movq 0x8af43(%rip), %rdx # 0x12bf60
movq %r14, %rdi
callq 0x1af10
movq %rax, %rbx
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa1043
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1a8e0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa105e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a8e0
testb %bpl, %bpl
jne 0xa108b
jmp 0xa1126
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa108b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a8e0
jmp 0xa108b
movq %rax, %rbx
movq %r14, %rdi
callq 0x1a690
jmp 0xa1126
jmp 0xa109a
movq %rax, %rbx
movq %r14, %rdi
callq 0x1a690
jmp 0xa1133
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa10cd
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1a8e0
jmp 0xa10cd
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x868ee
jmp 0xa10dc
movq %rax, %rbx
movq %r14, %rdi
callq 0x9523e
movq %rsp, %rdi
callq 0x8e0d0
jmp 0xa1100
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x868ee
jmp 0xa1100
movq %rax, %rbx
leaq 0xb0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa1126
movq 0xb0(%rsp), %rsi
incq %rsi
callq 0x1a8e0
jmp 0xa1126
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x868ee
movq %rbx, %rdi
callq 0x1af90
nop
| _ZNK5minja10FilterNode9do_renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS_7ContextEE:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 110h
mov rbx, rsi
mov rsi, [rdi+20h]
test rsi, rsi
jz loc_A0F75
mov r14, rdi
cmp qword ptr [rdi+30h], 0
jz loc_A0F93
mov r15, rdx
lea r12, [rsp+138h+var_78]
mov rdi, r12
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
cmp qword ptr [r12+30h], 0
jz loc_A0FC5
mov rsi, [r14+30h]
lea rdi, [rsp+138h+var_98]
mov rdx, r15
call _ZNK5minja12TemplateNode6renderB5cxx11ERKSt10shared_ptrINS_7ContextEE; minja::TemplateNode::render(std::shared_ptr<minja::Context> const&)
lea rdi, [rsp+138h+var_E8]
lea rsi, [rsp+138h+var_98]
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
mov rdi, rsp
lea rsi, [rsp+138h+var_E8]
lea rcx, [rsp+138h+var_108]
mov edx, 1
call _ZNSt6vectorIN5minja5ValueESaIS1_EEC2ESt16initializer_listIS1_ERKS2_; std::vector<minja::Value>::vector(std::initializer_list<minja::Value>,std::allocator<minja::Value> const&)
xorps xmm0, xmm0
movups [rsp+138h+var_120], xmm0
mov [rsp+138h+var_110], 0
lea r14, [rsp+138h+var_A8]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [r14-8]
test rdi, rdi
jz short loc_A0D86
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A0D86:
mov rdi, [rsp+138h+var_C0]
test rdi, rdi
jz short loc_A0D95
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A0D95:
mov rdi, [rsp+138h+var_D0]
test rdi, rdi
jz short loc_A0DA4
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A0DA4:
mov rdi, [rsp+138h+var_E0]
test rdi, rdi
jz short loc_A0DDA
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_A0DC5
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_A0DCF
loc_A0DC5:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_A0DCF:
cmp eax, 1
jnz short loc_A0DDA
mov rax, [rdi]
call qword ptr [rax+18h]
loc_A0DDA:
lea r14, [rsp+138h+var_120]
lea rdi, [rsp+138h+var_E8]
lea rsi, [rsp+138h+var_78]
mov rcx, rsp
mov rdx, r15
call _ZNK5minja5Value4callERKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueE; minja::Value::call(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)
lea rdi, [rsp+138h+var_108]
lea rsi, [rsp+138h+var_E8]
call _ZNK5minja5Value6to_strB5cxx11Ev; minja::Value::to_str(void)
mov rsi, [rsp+138h+var_108]
mov rdx, [rsp+138h+var_100]
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 rax, [rsp+138h+var_F8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A0E33
mov rsi, [rsp+138h+var_F8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A0E33:
lea rbx, [rsp+138h+var_A8]
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rbx-8]
test rdi, rdi
jz short loc_A0E5B
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A0E5B:
mov rdi, [rsp+138h+var_C0]
test rdi, rdi
jz short loc_A0E6A
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A0E6A:
mov rdi, [rsp+138h+var_D0]
test rdi, rdi
jz short loc_A0E79
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A0E79:
mov rdi, [rsp+138h+var_E0]
test rdi, rdi
jz short loc_A0EAF
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_A0E9A
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_A0EA4
loc_A0E9A:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_A0EA4:
cmp eax, 1
jnz short loc_A0EAF
mov rax, [rdi]
call qword ptr [rax+18h]
loc_A0EAF:
mov rdi, r14
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEESaIS9_EED2Ev; std::vector<std::pair<std::string,minja::Value>>::~vector()
mov rdi, rsp
call _ZNSt6vectorIN5minja5ValueESaIS1_EED2Ev; std::vector<minja::Value>::~vector()
lea rax, [rsp+138h+var_88]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A0EE0
mov rsi, [rsp+138h+var_88]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A0EE0:
lea rbx, [rsp+138h+var_38]
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rbx-8]
test rdi, rdi
jz short loc_A0F08
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A0F08:
mov rdi, [rsp+138h+var_50]
test rdi, rdi
jz short loc_A0F1A
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A0F1A:
mov rdi, [rsp+138h+var_60]
test rdi, rdi
jz short loc_A0F2C
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A0F2C:
mov rdi, [rsp+138h+var_70]
test rdi, rdi
jz short loc_A0F65
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_A0F50
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_A0F5A
loc_A0F50:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_A0F5A:
cmp eax, 1
jnz short loc_A0F65
mov rax, [rdi]
call qword ptr [rax+18h]
loc_A0F65:
add rsp, 110h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_A0F75:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aFilternodeFilt; "FilterNode.filter is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_A0FAF
loc_A0F93:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aFilternodeBody; "FilterNode.body is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_A0FAF:
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_A0FC5:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
mov rdi, rsp
lea rsi, [rsp+138h+var_78]
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aFilterMustBeAC; "Filter must be a callable: "
lea rdi, [rsp+138h+var_E8]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+138h+var_E8]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
mov rbx, rax
lea rax, [rsp+138h+var_D8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A1043
mov rsi, [rsp+138h+var_D8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A1043:
lea rax, [rsp+138h+var_128]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A105E
mov rsi, [rsp+138h+var_128]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A105E:
test bpl, bpl
jnz short loc_A108B
jmp loc_A1126
mov rbx, rax
lea rax, [rsp+138h+var_128]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A108B
mov rsi, [rsp+138h+var_128]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A108B
mov rbx, rax
loc_A108B:
mov rdi, r14; void *
call ___cxa_free_exception
jmp loc_A1126
jmp short $+2
loc_A109A:
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp loc_A1133
mov rbx, rax
lea rax, [rsp+138h+var_F8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A10CD
mov rsi, [rsp+138h+var_F8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A10CD
mov rbx, rax
loc_A10CD:
lea rdi, [rsp+138h+var_E8]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp short loc_A10DC
mov rbx, rax
loc_A10DC:
mov rdi, r14
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEESaIS9_EED2Ev; std::vector<std::pair<std::string,minja::Value>>::~vector()
mov rdi, rsp
call _ZNSt6vectorIN5minja5ValueESaIS1_EED2Ev; std::vector<minja::Value>::~vector()
jmp short loc_A1100
mov rbx, rax
lea rdi, [rsp+138h+var_E8]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp short loc_A1100
mov rbx, rax
loc_A1100:
lea rax, [rsp+138h+var_88]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A1126
mov rsi, [rsp+138h+var_88]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A1126
mov rbx, rax
loc_A1126:
lea rdi, [rsp+138h+var_78]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_A1133:
mov rdi, rbx
call __Unwind_Resume
| long long minja::FilterNode::do_render(long long a1, long long a2)
{
void (***v3)(void); // rsi
long long v4; // rdi
signed __int32 v5; // eax
long long v6; // rdi
signed __int32 v7; // eax
long long result; // rax
long long v9; // rdi
std::runtime_error *exception; // r14
void *v11; // r14
_QWORD v12[2]; // [rsp+0h] [rbp-138h] BYREF
__int128 v13; // [rsp+18h] [rbp-120h] BYREF
long long v14; // [rsp+28h] [rbp-110h]
void *v15[2]; // [rsp+30h] [rbp-108h] BYREF
long long v16; // [rsp+40h] [rbp-F8h] BYREF
_BYTE v17[8]; // [rsp+50h] [rbp-E8h] BYREF
long long v18; // [rsp+58h] [rbp-E0h]
volatile signed __int32 *v19; // [rsp+68h] [rbp-D0h]
volatile signed __int32 *v20; // [rsp+78h] [rbp-C0h]
volatile signed __int32 *v21; // [rsp+88h] [rbp-B0h]
char v22[16]; // [rsp+90h] [rbp-A8h] BYREF
void *v23[2]; // [rsp+A0h] [rbp-98h] BYREF
long long v24; // [rsp+B0h] [rbp-88h] BYREF
_BYTE v25[8]; // [rsp+C0h] [rbp-78h] BYREF
long long v26; // [rsp+C8h] [rbp-70h]
volatile signed __int32 *v27; // [rsp+D8h] [rbp-60h]
volatile signed __int32 *v28; // [rsp+E8h] [rbp-50h]
long long v29; // [rsp+F0h] [rbp-48h]
volatile signed __int32 *v30; // [rsp+F8h] [rbp-40h]
char v31[56]; // [rsp+100h] [rbp-38h] BYREF
v3 = *(void (****)(void))(a1 + 32);
if ( !v3 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "FilterNode.filter is null");
goto LABEL_47;
}
if ( !*(_QWORD *)(a1 + 48) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "FilterNode.body is null");
LABEL_47:
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Expression::evaluate((long long)v25, v3);
if ( !v29 )
{
v11 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v12, (long long)v25, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v17, (long long)"Filter must be a callable: ", (long long)v12);
std::runtime_error::runtime_error(v11, v17);
__cxa_throw(
v11,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::TemplateNode::render[abi:cxx11]((long long)v23, *(long long ( ****)(_QWORD))(a1 + 48));
minja::Value::Value((long long)v17, (long long)v23);
std::vector<minja::Value>::vector((long long)v12, (long long)v17, 1LL);
v13 = 0LL;
v14 = 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(v22);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v22);
if ( v21 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v21);
if ( v20 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v20);
if ( v19 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v19);
v4 = v18;
if ( v18 )
{
if ( _libc_single_threaded )
{
v5 = *(_DWORD *)(v18 + 12);
*(_DWORD *)(v18 + 12) = v5 - 1;
}
else
{
v5 = _InterlockedExchangeAdd((volatile signed __int32 *)(v18 + 12), 0xFFFFFFFF);
}
if ( v5 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v4 + 24LL))(v4, 0LL);
}
minja::Value::call((long long)v17, (long long)v25);
minja::Value::to_str[abi:cxx11](v15, (long long)v17);
std::__ostream_insert<char,std::char_traits<char>>(a2, v15[0], v15[1]);
if ( v15[0] != &v16 )
operator delete(v15[0], v16 + 1);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v22);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v22);
if ( v21 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v21);
if ( v20 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v20);
if ( v19 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v19);
v6 = v18;
if ( v18 )
{
if ( _libc_single_threaded )
{
v7 = *(_DWORD *)(v18 + 12);
*(_DWORD *)(v18 + 12) = v7 - 1;
}
else
{
v7 = _InterlockedExchangeAdd((volatile signed __int32 *)(v18 + 12), 0xFFFFFFFF);
}
if ( v7 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v6 + 24LL))(v6, 0LL);
}
std::vector<std::pair<std::string,minja::Value>>::~vector((char **)&v13);
std::vector<minja::Value>::~vector(v12);
if ( v23[0] != &v24 )
operator delete(v23[0], v24 + 1);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v31);
result = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v31);
if ( v30 )
result = std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v30);
if ( v28 )
result = std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v28);
if ( v27 )
result = std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v27);
v9 = v26;
if ( v26 )
{
if ( _libc_single_threaded )
{
result = *(unsigned int *)(v26 + 12);
*(_DWORD *)(v26 + 12) = result - 1;
}
else
{
result = (unsigned int)_InterlockedExchangeAdd((volatile signed __int32 *)(v26 + 12), 0xFFFFFFFF);
}
if ( (_DWORD)result == 1 )
return (*(long long ( **)(long long, _QWORD))(*(_QWORD *)v9 + 24LL))(v9, 0LL);
}
return result;
}
| do_render:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x110
MOV RBX,RSI
MOV RSI,qword ptr [RDI + 0x20]
TEST RSI,RSI
JZ 0x001a0f75
MOV R14,RDI
CMP qword ptr [RDI + 0x30],0x0
JZ 0x001a0f93
MOV R15,RDX
LEA R12,[RSP + 0xc0]
MOV RDI,R12
CALL 0x001865fc
CMP qword ptr [R12 + 0x30],0x0
JZ 0x001a0fc5
MOV RSI,qword ptr [R14 + 0x30]
LAB_001a0d14:
LEA RDI,[RSP + 0xa0]
MOV RDX,R15
CALL 0x0019f402
LAB_001a0d24:
LEA RDI,[RSP + 0x50]
LEA RSI,[RSP + 0xa0]
CALL 0x0018a94c
LAB_001a0d36:
MOV RDI,RSP
LEA RSI,[RSP + 0x50]
LEA RCX,[RSP + 0x30]
MOV EDX,0x1
CALL 0x00193b14
LAB_001a0d4d:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP + 0x18],XMM0
MOV qword ptr [RSP + 0x28],0x0
LEA R14,[RSP + 0x90]
MOV RDI,R14
XOR ESI,ESI
CALL 0x00158f20
MOV RDI,R14
CALL 0x0015e40e
MOV RDI,qword ptr [R14 + -0x8]
TEST RDI,RDI
JZ 0x001a0d86
CALL 0x0016de32
LAB_001a0d86:
MOV RDI,qword ptr [RSP + 0x78]
TEST RDI,RDI
JZ 0x001a0d95
CALL 0x0016de32
LAB_001a0d95:
MOV RDI,qword ptr [RSP + 0x68]
TEST RDI,RDI
JZ 0x001a0da4
CALL 0x0016de32
LAB_001a0da4:
MOV RDI,qword ptr [RSP + 0x58]
TEST RDI,RDI
JZ 0x001a0dda
MOV RAX,qword ptr [0x0022bf88]
CMP byte ptr [RAX],0x0
JZ 0x001a0dc5
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001a0dcf
LAB_001a0dc5:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001a0dcf:
CMP EAX,0x1
JNZ 0x001a0dda
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_001a0dda:
LEA R14,[RSP + 0x18]
LEA RDI,[RSP + 0x50]
LEA RSI,[RSP + 0xc0]
MOV RCX,RSP
MOV RDX,R15
CALL 0x00193ef6
LAB_001a0df7:
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x50]
CALL 0x001971ee
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
LAB_001a0e10:
MOV RDI,RBX
CALL 0x0011aa00
LAB_001a0e18:
LEA RAX,[RSP + 0x40]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001a0e33
MOV RSI,qword ptr [RSP + 0x40]
INC RSI
CALL 0x0011a8e0
LAB_001a0e33:
LEA RBX,[RSP + 0x90]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00158f20
MOV RDI,RBX
CALL 0x0015e40e
MOV RDI,qword ptr [RBX + -0x8]
TEST RDI,RDI
JZ 0x001a0e5b
CALL 0x0016de32
LAB_001a0e5b:
MOV RDI,qword ptr [RSP + 0x78]
TEST RDI,RDI
JZ 0x001a0e6a
CALL 0x0016de32
LAB_001a0e6a:
MOV RDI,qword ptr [RSP + 0x68]
TEST RDI,RDI
JZ 0x001a0e79
CALL 0x0016de32
LAB_001a0e79:
MOV RDI,qword ptr [RSP + 0x58]
TEST RDI,RDI
JZ 0x001a0eaf
MOV RAX,qword ptr [0x0022bf88]
CMP byte ptr [RAX],0x0
JZ 0x001a0e9a
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001a0ea4
LAB_001a0e9a:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001a0ea4:
CMP EAX,0x1
JNZ 0x001a0eaf
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_001a0eaf:
MOV RDI,R14
CALL 0x0019523e
MOV RDI,RSP
CALL 0x0018e0d0
LEA RAX,[RSP + 0xb0]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001a0ee0
MOV RSI,qword ptr [RSP + 0xb0]
INC RSI
CALL 0x0011a8e0
LAB_001a0ee0:
LEA RBX,[RSP + 0x100]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00158f20
MOV RDI,RBX
CALL 0x0015e40e
MOV RDI,qword ptr [RBX + -0x8]
TEST RDI,RDI
JZ 0x001a0f08
CALL 0x0016de32
LAB_001a0f08:
MOV RDI,qword ptr [RSP + 0xe8]
TEST RDI,RDI
JZ 0x001a0f1a
CALL 0x0016de32
LAB_001a0f1a:
MOV RDI,qword ptr [RSP + 0xd8]
TEST RDI,RDI
JZ 0x001a0f2c
CALL 0x0016de32
LAB_001a0f2c:
MOV RDI,qword ptr [RSP + 0xc8]
TEST RDI,RDI
JZ 0x001a0f65
MOV RAX,qword ptr [0x0022bf88]
CMP byte ptr [RAX],0x0
JZ 0x001a0f50
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001a0f5a
LAB_001a0f50:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001a0f5a:
CMP EAX,0x1
JNZ 0x001a0f65
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_001a0f65:
ADD RSP,0x110
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001a0f75:
MOV EDI,0x10
CALL 0x0011a450
MOV R14,RAX
LAB_001a0f82:
LEA RSI,[0x1f0f33]
MOV RDI,RAX
CALL 0x0011a330
LAB_001a0f91:
JMP 0x001a0faf
LAB_001a0f93:
MOV EDI,0x10
CALL 0x0011a450
MOV R14,RAX
LAB_001a0fa0:
LEA RSI,[0x1f0f4d]
MOV RDI,RAX
CALL 0x0011a330
LAB_001a0faf:
MOV RSI,qword ptr [0x0022bff0]
MOV RDX,qword ptr [0x0022bf60]
MOV RDI,R14
CALL 0x0011af10
LAB_001a0fc5:
MOV EDI,0x10
CALL 0x0011a450
MOV R14,RAX
LAB_001a0fd2:
MOV RDI,RSP
LEA RSI,[RSP + 0xc0]
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x00186c10
LAB_001a0fe9:
LEA RSI,[0x1f0f65]
LEA RDI,[RSP + 0x50]
MOV RDX,RSP
CALL 0x001793a5
MOV BPL,0x1
LAB_001a1000:
LEA RSI,[RSP + 0x50]
MOV RDI,R14
CALL 0x0011ae20
XOR EBP,EBP
MOV RSI,qword ptr [0x0022bff0]
MOV RDX,qword ptr [0x0022bf60]
MOV RDI,R14
CALL 0x0011af10
|
/* minja::FilterNode::do_render(std::__cxx11::ostringstream&, std::shared_ptr<minja::Context>
const&) const */
void minja::FilterNode::do_render(ostringstream *param_1,shared_ptr *param_2)
{
int *piVar1;
int iVar2;
runtime_error *prVar3;
vector<minja::Value,std::allocator<minja::Value>> avStack_138 [24];
int8 local_120;
int8 uStack_118;
int8 local_110;
long *local_108;
long local_100;
long local_f8 [2];
Value local_e8 [8];
long *local_e0;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_d0;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_c0;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_b0;
data local_a8 [16];
long *local_98 [2];
long local_88 [2];
Expression local_78 [8];
long *local_70;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_60;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_50;
long local_48;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_40;
data local_38 [16];
if (*(shared_ptr **)(param_1 + 0x20) == (shared_ptr *)0x0) {
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001a0f82 to 001a0f90 has its CatchHandler @ 001a109a */
std::runtime_error::runtime_error(prVar3,"FilterNode.filter is null");
}
else {
if (*(long *)(param_1 + 0x30) != 0) {
Expression::evaluate(local_78,*(shared_ptr **)(param_1 + 0x20));
if (local_48 != 0) {
/* try { // try from 001a0d14 to 001a0d23 has its CatchHandler @ 001a1123 */
TemplateNode::render_abi_cxx11_((TemplateNode *)local_98,*(shared_ptr **)(param_1 + 0x30));
/* try { // try from 001a0d24 to 001a0d35 has its CatchHandler @ 001a10fd */
Value::Value(local_e8,(string *)local_98);
/* try { // try from 001a0d36 to 001a0d4c has its CatchHandler @ 001a10ee */
std::vector<minja::Value,std::allocator<minja::Value>>::vector
(avStack_138,local_e8,1,&local_108);
local_120 = 0;
uStack_118 = 0;
local_110 = 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(local_a8,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>
::data::~data(local_a8);
if (local_b0 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_b0);
}
if (local_c0 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_c0);
}
if (local_d0 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_d0);
}
if (local_e0 != (long *)0x0) {
if (*PTR___libc_single_threaded_0022bf88 == '\0') {
LOCK();
piVar1 = (int *)((long)local_e0 + 0xc);
iVar2 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar2 = *(int *)((long)local_e0 + 0xc);
*(int *)((long)local_e0 + 0xc) = iVar2 + -1;
}
if (iVar2 == 1) {
(**(code **)(*local_e0 + 0x18))();
}
}
/* try { // try from 001a0dda to 001a0df6 has its CatchHandler @ 001a10d9 */
Value::call((shared_ptr *)local_e8,(ArgumentsValue *)local_78);
/* try { // try from 001a0df7 to 001a0e05 has its CatchHandler @ 001a10ca */
Value::to_str_abi_cxx11_();
/* try { // try from 001a0e10 to 001a0e17 has its CatchHandler @ 001a10aa */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)param_2,(char *)local_108,local_100);
if (local_108 != local_f8) {
operator_delete(local_108,local_f8[0] + 1);
}
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(local_a8,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>
::data::~data(local_a8);
if (local_b0 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_b0);
}
if (local_c0 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_c0);
}
if (local_d0 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_d0);
}
if (local_e0 != (long *)0x0) {
if (*PTR___libc_single_threaded_0022bf88 == '\0') {
LOCK();
piVar1 = (int *)((long)local_e0 + 0xc);
iVar2 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar2 = *(int *)((long)local_e0 + 0xc);
*(int *)((long)local_e0 + 0xc) = iVar2 + -1;
}
if (iVar2 == 1) {
(**(code **)(*local_e0 + 0x18))();
}
}
std::
vector<std::pair<std::__cxx11::string,minja::Value>,std::allocator<std::pair<std::__cxx11::string,minja::Value>>>
::~vector((vector<std::pair<std::__cxx11::string,minja::Value>,std::allocator<std::pair<std::__cxx11::string,minja::Value>>>
*)&local_120);
std::vector<minja::Value,std::allocator<minja::Value>>::~vector(avStack_138);
if (local_98[0] != local_88) {
operator_delete(local_98[0],local_88[0] + 1);
}
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(local_38,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>
::data::~data(local_38);
if (local_40 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_40);
}
if (local_50 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_50);
}
if (local_60 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_60);
}
if (local_70 != (long *)0x0) {
if (*PTR___libc_single_threaded_0022bf88 == '\0') {
LOCK();
piVar1 = (int *)((long)local_70 + 0xc);
iVar2 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar2 = *(int *)((long)local_70 + 0xc);
*(int *)((long)local_70 + 0xc) = iVar2 + -1;
}
if (iVar2 == 1) {
(**(code **)(*local_70 + 0x18))();
}
}
return;
}
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001a0fd2 to 001a0fe8 has its CatchHandler @ 001a1088 */
Value::dump_abi_cxx11_((int)avStack_138,SUB81(local_78,0));
/* try { // try from 001a0fe9 to 001a0ffc has its CatchHandler @ 001a1068 */
std::operator+((char *)local_e8,(string *)"Filter must be a callable: ");
/* try { // try from 001a1000 to 001a1024 has its CatchHandler @ 001a1025 */
std::runtime_error::runtime_error(prVar3,(string *)local_e8);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_0022bff0,PTR__runtime_error_0022bf60);
}
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001a0fa0 to 001a0fae has its CatchHandler @ 001a1098 */
std::runtime_error::runtime_error(prVar3,"FilterNode.body is null");
}
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_0022bff0,PTR__runtime_error_0022bf60);
}
| |
54,185 | getSelectionString | untodesu[P]riteg/build_O1/_deps/glfw-src/src/x11_window.c | static const char* getSelectionString(Atom selection)
{
size_t i;
char** selectionString = NULL;
const Atom targets[] = { _glfw.x11.UTF8_STRING, XA_STRING };
const size_t targetCount = sizeof(targets) / sizeof(targets[0]);
if (selection == _glfw.x11.PRIMARY)
selectionString = &_glfw.x11.primarySelectionString;
else
selectionString = &_glfw.x11.clipboardString;
if (XGetSelectionOwner(_glfw.x11.display, selection) ==
_glfw.x11.helperWindowHandle)
{
// Instead of doing a large number of X round-trips just to put this
// string into a window property and then read it back, just return it
return *selectionString;
}
free(*selectionString);
*selectionString = NULL;
for (i = 0; i < targetCount; i++)
{
char* data;
Atom actualType;
int actualFormat;
unsigned long itemCount, bytesAfter;
XEvent notification, dummy;
XConvertSelection(_glfw.x11.display,
selection,
targets[i],
_glfw.x11.GLFW_SELECTION,
_glfw.x11.helperWindowHandle,
CurrentTime);
while (!XCheckTypedWindowEvent(_glfw.x11.display,
_glfw.x11.helperWindowHandle,
SelectionNotify,
¬ification))
{
waitForEvent(NULL);
}
if (notification.xselection.property == None)
continue;
XCheckIfEvent(_glfw.x11.display,
&dummy,
isSelPropNewValueNotify,
(XPointer) ¬ification);
XGetWindowProperty(_glfw.x11.display,
notification.xselection.requestor,
notification.xselection.property,
0,
LONG_MAX,
True,
AnyPropertyType,
&actualType,
&actualFormat,
&itemCount,
&bytesAfter,
(unsigned char**) &data);
if (actualType == _glfw.x11.INCR)
{
size_t size = 1;
char* string = NULL;
for (;;)
{
while (!XCheckIfEvent(_glfw.x11.display,
&dummy,
isSelPropNewValueNotify,
(XPointer) ¬ification))
{
waitForEvent(NULL);
}
XFree(data);
XGetWindowProperty(_glfw.x11.display,
notification.xselection.requestor,
notification.xselection.property,
0,
LONG_MAX,
True,
AnyPropertyType,
&actualType,
&actualFormat,
&itemCount,
&bytesAfter,
(unsigned char**) &data);
if (itemCount)
{
size += itemCount;
string = realloc(string, size);
string[size - itemCount - 1] = '\0';
strcat(string, data);
}
if (!itemCount)
{
if (targets[i] == XA_STRING)
{
*selectionString = convertLatin1toUTF8(string);
free(string);
}
else
*selectionString = string;
break;
}
}
}
else if (actualType == targets[i])
{
if (targets[i] == XA_STRING)
*selectionString = convertLatin1toUTF8(data);
else
*selectionString = _glfw_strdup(data);
}
XFree(data);
if (*selectionString)
break;
}
if (!*selectionString)
{
_glfwInputError(GLFW_FORMAT_UNAVAILABLE,
"X11: Failed to convert selection to string");
}
return *selectionString;
} | O1 | c | getSelectionString:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, %rsi
leaq 0x7f015(%rip), %r14 # 0xa4638
movq 0x20550(%r14), %rax
movq %rax, 0x30(%rsp)
xorl %eax, %eax
cmpq %rdi, 0x20530(%r14)
movq $0x1f, 0x38(%rsp)
setne %al
leaq 0x1ff08(,%rax,8), %rbp
movq 0x1fec0(%r14), %rdi
movq %rsi, 0x48(%rsp)
callq 0xcfd0
cmpq 0x1fee0(%r14), %rax
je 0x258cd
movq (%r14,%rbp), %rdi
callq 0xca50
movq $0x0, (%r14,%rbp)
xorl %eax, %eax
leaq 0x58(%rsp), %r15
leaq 0x638(%rip), %r12 # 0x25cc1
leaq 0x118(%rsp), %r13
movq %rbp, 0x20(%rsp)
movq %rax, 0x10(%rsp)
movq 0x30(%rsp,%rax,8), %rbx
movq 0x20568(%r14), %rcx
movq 0x1fec0(%r14), %rdi
movq 0x1fee0(%r14), %r8
movq 0x48(%rsp), %rsi
movq %rbx, %rdx
xorl %r9d, %r9d
callq 0xc070
movq 0x1fec0(%r14), %rdi
movq 0x1fee0(%r14), %rsi
movl $0x1f, %edx
movq %r15, %rcx
callq 0xcaf0
testl %eax, %eax
jne 0x256ed
xorl %edi, %edi
callq 0x21c1d
jmp 0x256c5
cmpq $0x0, 0x90(%rsp)
je 0x2585d
movq 0x1fec0(%r14), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0xd070
movq 0x1fec0(%r14), %rdi
movq 0x78(%rsp), %rsi
movq 0x90(%rsp), %rdx
xorl %ecx, %ecx
movabsq $0x7fffffffffffffff, %r8 # imm = 0x7FFFFFFFFFFFFFFF
movl $0x1, %r9d
movq %rsp, %rax
pushq %rax
leaq 0x58(%rsp), %rax
pushq %rax
leaq 0x18(%rsp), %rax
pushq %rax
leaq 0x34(%rsp), %rax
pushq %rax
leaq 0x48(%rsp), %rax
pushq %rax
pushq $0x0
callq 0xc200
addq $0x30, %rsp
movq 0x28(%rsp), %rax
cmpq 0x20520(%r14), %rax
jne 0x25864
movl $0x1, %ebx
xorl %ebp, %ebp
movq 0x1fec0(%r14), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0xd070
testl %eax, %eax
jne 0x25799
xorl %edi, %edi
callq 0x21c1d
jmp 0x25777
movq (%rsp), %rdi
callq 0xcac0
movq 0x1fec0(%r14), %rdi
movq 0x78(%rsp), %rsi
movq 0x90(%rsp), %rdx
xorl %ecx, %ecx
movabsq $0x7fffffffffffffff, %r8 # imm = 0x7FFFFFFFFFFFFFFF
movl $0x1, %r9d
movq %rsp, %rax
pushq %rax
leaq 0x58(%rsp), %rax
pushq %rax
leaq 0x18(%rsp), %rax
pushq %rax
leaq 0x34(%rsp), %rax
pushq %rax
leaq 0x48(%rsp), %rax
pushq %rax
pushq $0x0
callq 0xc200
addq $0x30, %rsp
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x25826
addq %rax, %rbx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xce20
movq %rax, %rbp
movq 0x8(%rsp), %rax
notq %rax
leaq (%rbx,%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq (%rsp), %rsi
movq %rbp, %rdi
callq 0xcf10
cmpq $0x0, 0x8(%rsp)
jne 0x25777
movq 0x10(%rsp), %rax
cmpq $0x1f, 0x30(%rsp,%rax,8)
jne 0x2587a
movq %rbp, %rdi
callq 0x25ce7
movq 0x20(%rsp), %rcx
movq %rax, (%r14,%rcx)
movq %rbp, %rdi
movq %rcx, %rbp
callq 0xca50
jmp 0x25891
movq 0x10(%rsp), %rax
jmp 0x258a6
cmpq %rbx, %rax
jne 0x25891
movq (%rsp), %rdi
cmpq $0x1f, %rbx
jne 0x25888
callq 0x25ce7
jmp 0x2588d
movq 0x20(%rsp), %rax
movq %rbp, (%r14,%rax)
movq %rax, %rbp
jmp 0x25891
callq 0x19034
movq %rax, (%r14,%rbp)
movq (%rsp), %rdi
callq 0xcac0
cmpq $0x0, (%r14,%rbp)
movq 0x10(%rsp), %rax
jne 0x258b3
testq %rax, %rax
jne 0x258b3
incq %rax
jmp 0x25696
cmpq $0x0, (%r14,%rbp)
jne 0x258cd
leaq 0x5c5f5(%rip), %rsi # 0x81eb6
movl $0x10009, %edi # imm = 0x10009
xorl %eax, %eax
callq 0x19081
movq (%r14,%rbp), %rax
addq $0x1d8, %rsp # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| getSelectionString:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1D8h
mov rsi, rdi
lea r14, _glfw
mov rax, [r14+20550h]
mov [rsp+208h+var_1D8], rax
xor eax, eax
cmp qword ptr ds:loc_20530[r14], rdi
mov [rsp+208h+var_1D0], 1Fh
setnz al
lea rbp, ds:1FF08h[rax*8]
mov rdi, [r14+1FEC0h]
mov [rsp+208h+var_1C0], rsi
call _XGetSelectionOwner
cmp rax, [r14+1FEE0h]
jz loc_258CD
mov rdi, [r14+rbp]
call _free
mov qword ptr [r14+rbp], 0
xor eax, eax
lea r15, [rsp+208h+var_1B0]
lea r12, isSelPropNewValueNotify
lea r13, [rsp+208h+var_F0]
mov [rsp+208h+var_1E8], rbp
loc_25696:
mov [rsp+208h+var_1F8], rax
mov rbx, [rsp+rax*8+208h+var_1D8]
mov rcx, [r14+20568h]
mov rdi, [r14+1FEC0h]
mov r8, [r14+1FEE0h]
mov rsi, [rsp+208h+var_1C0]
mov rdx, rbx
xor r9d, r9d
call _XConvertSelection
loc_256C5:
mov rdi, [r14+1FEC0h]
mov rsi, [r14+1FEE0h]
mov edx, 1Fh
mov rcx, r15
call _XCheckTypedWindowEvent
test eax, eax
jnz short loc_256ED
xor edi, edi
call waitForEvent
jmp short loc_256C5
loc_256ED:
cmp [rsp+208h+var_178], 0
jz loc_2585D
mov rdi, [r14+1FEC0h]
mov rsi, r13
mov rdx, r12
mov rcx, r15
call _XCheckIfEvent
mov rdi, [r14+1FEC0h]
mov rsi, [rsp+208h+var_190]
mov rdx, [rsp+208h+var_178]
xor ecx, ecx
mov r8, 7FFFFFFFFFFFFFFFh
mov r9d, 1
mov rax, rsp
push rax
lea rax, [rsp+210h+var_1B8]
push rax
lea rax, [rsp+218h+var_200]
push rax
lea rax, [rsp+220h+var_1EC]
push rax
lea rax, [rsp+228h+var_1E0]
push rax
push 0
call _XGetWindowProperty
add rsp, 30h
mov rax, [rsp+208h+var_1E0]
cmp rax, [r14+20520h]
jnz loc_25864
mov ebx, 1
xor ebp, ebp
loc_25777:
mov rdi, [r14+1FEC0h]
mov rsi, r13
mov rdx, r12
mov rcx, r15
call _XCheckIfEvent
test eax, eax
jnz short loc_25799
xor edi, edi
call waitForEvent
jmp short loc_25777
loc_25799:
mov rdi, [rsp+208h+var_208]
call _XFree
mov rdi, [r14+1FEC0h]
mov rsi, [rsp+208h+var_190]
mov rdx, [rsp+208h+var_178]
xor ecx, ecx
mov r8, 7FFFFFFFFFFFFFFFh
mov r9d, 1
mov rax, rsp
push rax
lea rax, [rsp+210h+var_1B8]
push rax
lea rax, [rsp+218h+var_200]
push rax
lea rax, [rsp+220h+var_1EC]
push rax
lea rax, [rsp+228h+var_1E0]
push rax
push 0
call _XGetWindowProperty
add rsp, 30h
mov rax, [rsp+208h+var_200]
test rax, rax
jz short loc_25826
add rbx, rax
mov rdi, rbp
mov rsi, rbx
call _realloc
mov rbp, rax
mov rax, [rsp+208h+var_200]
not rax
lea rcx, [rbx+rbp]
mov byte ptr [rax+rcx], 0
mov rsi, [rsp+208h+var_208]
mov rdi, rbp
call _strcat
loc_25826:
cmp [rsp+208h+var_200], 0
jnz loc_25777
mov rax, [rsp+208h+var_1F8]
cmp [rsp+rax*8+208h+var_1D8], 1Fh
jnz short loc_2587A
mov rdi, rbp
call convertLatin1toUTF8
mov rcx, [rsp+208h+var_1E8]
mov [r14+rcx], rax
mov rdi, rbp
mov rbp, rcx
call _free
jmp short loc_25891
loc_2585D:
mov rax, [rsp+208h+var_1F8]
jmp short loc_258A6
loc_25864:
cmp rax, rbx
jnz short loc_25891
mov rdi, [rsp+208h+var_208]
cmp rbx, 1Fh
jnz short loc_25888
call convertLatin1toUTF8
jmp short loc_2588D
loc_2587A:
mov rax, [rsp+208h+var_1E8]
mov [r14+rax], rbp
mov rbp, rax
jmp short loc_25891
loc_25888:
call _glfw_strdup
loc_2588D:
mov [r14+rbp], rax
loc_25891:
mov rdi, [rsp+208h+var_208]
call _XFree
cmp qword ptr [r14+rbp], 0
mov rax, [rsp+208h+var_1F8]
jnz short loc_258B3
loc_258A6:
test rax, rax
jnz short loc_258B3
inc rax
jmp loc_25696
loc_258B3:
cmp qword ptr [r14+rbp], 0
jnz short loc_258CD
lea rsi, aX11FailedToCon; "X11: Failed to convert selection to str"...
mov edi, 10009h
xor eax, eax
call _glfwInputError
loc_258CD:
mov rax, [r14+rbp]
add rsp, 1D8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long getSelectionString(long long a1)
{
bool v2; // zf
long long v3; // rbp
long long v4; // rdi
long long v5; // rax
long long v6; // rbx
long long v7; // rbx
long long v8; // rbp
long long v9; // rax
long long v10; // rcx
long long v11; // rdi
long long v12; // rax
long long v13; // rax
long long v14; // rax
long long v16; // [rsp+0h] [rbp-208h] BYREF
long long v17; // [rsp+8h] [rbp-200h] BYREF
long long v18; // [rsp+10h] [rbp-1F8h]
_BYTE v19[4]; // [rsp+1Ch] [rbp-1ECh] BYREF
long long v20; // [rsp+20h] [rbp-1E8h]
long long v21; // [rsp+28h] [rbp-1E0h] BYREF
_QWORD v22[3]; // [rsp+30h] [rbp-1D8h]
long long v23; // [rsp+48h] [rbp-1C0h]
char v24[8]; // [rsp+50h] [rbp-1B8h] BYREF
_BYTE v25[32]; // [rsp+58h] [rbp-1B0h] BYREF
long long v26; // [rsp+78h] [rbp-190h]
long long v27; // [rsp+90h] [rbp-178h]
_BYTE v28[240]; // [rsp+118h] [rbp-F0h] BYREF
v22[0] = *(_QWORD *)&glfw[33108];
v2 = *(_QWORD *)((char *)&loc_20530 + (_QWORD)glfw) == a1;
v22[1] = 31LL;
v3 = 8LL * !v2 + 130824;
v4 = *(_QWORD *)&glfw[32688];
v23 = a1;
if ( XGetSelectionOwner(v4, a1) == *(_QWORD *)&glfw[32696] )
return *(_QWORD *)((char *)glfw + v3);
free(*(_QWORD *)((char *)glfw + v3));
*(_QWORD *)((char *)glfw + v3) = 0LL;
v5 = 0LL;
v20 = v3;
while ( 1 )
{
v18 = v5;
v6 = v22[v5];
XConvertSelection(*(_QWORD *)&glfw[32688], v23, v6, *(_QWORD *)&glfw[33114], *(_QWORD *)&glfw[32696], 0LL);
while ( !(unsigned int)XCheckTypedWindowEvent(*(_QWORD *)&glfw[32688], *(_QWORD *)&glfw[32696], 31LL, v25) )
waitForEvent(0LL);
if ( !v27 )
{
v12 = v18;
goto LABEL_24;
}
XCheckIfEvent(*(_QWORD *)&glfw[32688], v28, isSelPropNewValueNotify, v25);
XGetWindowProperty(
*(_QWORD *)&glfw[32688],
v26,
v27,
0LL,
0x7FFFFFFFFFFFFFFFLL,
1LL,
0LL,
&v21,
v19,
&v17,
v24,
&v16);
if ( v21 == *(_QWORD *)&glfw[33096] )
{
v7 = 1LL;
v8 = 0LL;
do
{
while ( !(unsigned int)XCheckIfEvent(*(_QWORD *)&glfw[32688], v28, isSelPropNewValueNotify, v25) )
waitForEvent(0LL);
XFree(v16);
XGetWindowProperty(
*(_QWORD *)&glfw[32688],
v26,
v27,
0LL,
0x7FFFFFFFFFFFFFFFLL,
1LL,
0LL,
&v21,
v19,
&v17,
v24,
&v16);
if ( v17 )
{
v7 += v17;
v8 = realloc(v8, v7);
*(_BYTE *)(~v17 + v7 + v8) = 0;
strcat(v8, v16);
}
}
while ( v17 );
if ( v22[v18] == 31LL )
{
v9 = convertLatin1toUTF8(v8);
v10 = v20;
*(_QWORD *)((char *)glfw + v20) = v9;
v11 = v8;
v3 = v10;
free(v11);
}
else
{
v14 = v20;
*(_QWORD *)((char *)glfw + v20) = v8;
v3 = v14;
}
}
else if ( v21 == v6 )
{
if ( v6 == 31 )
v13 = convertLatin1toUTF8(v16);
else
v13 = glfw_strdup(v16);
*(_QWORD *)((char *)glfw + v3) = v13;
}
XFree(v16);
v12 = v18;
if ( *(_QWORD *)((char *)glfw + v3) )
break;
LABEL_24:
if ( v12 )
break;
v5 = 1LL;
}
if ( !*(_QWORD *)((char *)glfw + v3) )
glfwInputError(0x10009u, (long long)"X11: Failed to convert selection to string");
return *(_QWORD *)((char *)glfw + v3);
}
| getSelectionString:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1d8
MOV RSI,RDI
LEA R14,[0x1a4638]
MOV RAX,qword ptr [R14 + 0x20550]
MOV qword ptr [RSP + 0x30],RAX
XOR EAX,EAX
CMP qword ptr [R14 + 0x20530],RDI
MOV qword ptr [RSP + 0x38],0x1f
SETNZ AL
LEA RBP,[0x1ff08 + RAX*0x8]
MOV RDI,qword ptr [R14 + 0x1fec0]
MOV qword ptr [RSP + 0x48],RSI
CALL 0x0010cfd0
CMP RAX,qword ptr [R14 + 0x1fee0]
JZ 0x001258cd
MOV RDI,qword ptr [R14 + RBP*0x1]
CALL 0x0010ca50
MOV qword ptr [R14 + RBP*0x1],0x0
XOR EAX,EAX
LEA R15,[RSP + 0x58]
LEA R12,[0x125cc1]
LEA R13,[RSP + 0x118]
MOV qword ptr [RSP + 0x20],RBP
LAB_00125696:
MOV qword ptr [RSP + 0x10],RAX
MOV RBX,qword ptr [RSP + RAX*0x8 + 0x30]
MOV RCX,qword ptr [R14 + 0x20568]
MOV RDI,qword ptr [R14 + 0x1fec0]
MOV R8,qword ptr [R14 + 0x1fee0]
MOV RSI,qword ptr [RSP + 0x48]
MOV RDX,RBX
XOR R9D,R9D
CALL 0x0010c070
LAB_001256c5:
MOV RDI,qword ptr [R14 + 0x1fec0]
MOV RSI,qword ptr [R14 + 0x1fee0]
MOV EDX,0x1f
MOV RCX,R15
CALL 0x0010caf0
TEST EAX,EAX
JNZ 0x001256ed
XOR EDI,EDI
CALL 0x00121c1d
JMP 0x001256c5
LAB_001256ed:
CMP qword ptr [RSP + 0x90],0x0
JZ 0x0012585d
MOV RDI,qword ptr [R14 + 0x1fec0]
MOV RSI,R13
MOV RDX,R12
MOV RCX,R15
CALL 0x0010d070
MOV RDI,qword ptr [R14 + 0x1fec0]
MOV RSI,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x90]
XOR ECX,ECX
MOV R8,0x7fffffffffffffff
MOV R9D,0x1
MOV RAX,RSP
PUSH RAX
LEA RAX,[RSP + 0x58]
PUSH RAX
LEA RAX,[RSP + 0x18]
PUSH RAX
LEA RAX,[RSP + 0x34]
PUSH RAX
LEA RAX,[RSP + 0x48]
PUSH RAX
PUSH 0x0
CALL 0x0010c200
ADD RSP,0x30
MOV RAX,qword ptr [RSP + 0x28]
CMP RAX,qword ptr [R14 + 0x20520]
JNZ 0x00125864
MOV EBX,0x1
XOR EBP,EBP
LAB_00125777:
MOV RDI,qword ptr [R14 + 0x1fec0]
MOV RSI,R13
MOV RDX,R12
MOV RCX,R15
CALL 0x0010d070
TEST EAX,EAX
JNZ 0x00125799
XOR EDI,EDI
CALL 0x00121c1d
JMP 0x00125777
LAB_00125799:
MOV RDI,qword ptr [RSP]
CALL 0x0010cac0
MOV RDI,qword ptr [R14 + 0x1fec0]
MOV RSI,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x90]
XOR ECX,ECX
MOV R8,0x7fffffffffffffff
MOV R9D,0x1
MOV RAX,RSP
PUSH RAX
LEA RAX,[RSP + 0x58]
PUSH RAX
LEA RAX,[RSP + 0x18]
PUSH RAX
LEA RAX,[RSP + 0x34]
PUSH RAX
LEA RAX,[RSP + 0x48]
PUSH RAX
PUSH 0x0
CALL 0x0010c200
ADD RSP,0x30
MOV RAX,qword ptr [RSP + 0x8]
TEST RAX,RAX
JZ 0x00125826
ADD RBX,RAX
MOV RDI,RBP
MOV RSI,RBX
CALL 0x0010ce20
MOV RBP,RAX
MOV RAX,qword ptr [RSP + 0x8]
NOT RAX
LEA RCX,[RBX + RBP*0x1]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV RSI,qword ptr [RSP]
MOV RDI,RBP
CALL 0x0010cf10
LAB_00125826:
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x00125777
MOV RAX,qword ptr [RSP + 0x10]
CMP qword ptr [RSP + RAX*0x8 + 0x30],0x1f
JNZ 0x0012587a
MOV RDI,RBP
CALL 0x00125ce7
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [R14 + RCX*0x1],RAX
MOV RDI,RBP
MOV RBP,RCX
CALL 0x0010ca50
JMP 0x00125891
LAB_0012585d:
MOV RAX,qword ptr [RSP + 0x10]
JMP 0x001258a6
LAB_00125864:
CMP RAX,RBX
JNZ 0x00125891
MOV RDI,qword ptr [RSP]
CMP RBX,0x1f
JNZ 0x00125888
CALL 0x00125ce7
JMP 0x0012588d
LAB_0012587a:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [R14 + RAX*0x1],RBP
MOV RBP,RAX
JMP 0x00125891
LAB_00125888:
CALL 0x00119034
LAB_0012588d:
MOV qword ptr [R14 + RBP*0x1],RAX
LAB_00125891:
MOV RDI,qword ptr [RSP]
CALL 0x0010cac0
CMP qword ptr [R14 + RBP*0x1],0x0
MOV RAX,qword ptr [RSP + 0x10]
JNZ 0x001258b3
LAB_001258a6:
TEST RAX,RAX
JNZ 0x001258b3
INC RAX
JMP 0x00125696
LAB_001258b3:
CMP qword ptr [R14 + RBP*0x1],0x0
JNZ 0x001258cd
LEA RSI,[0x181eb6]
MOV EDI,0x10009
XOR EAX,EAX
CALL 0x00119081
LAB_001258cd:
MOV RAX,qword ptr [R14 + RBP*0x1]
ADD RSP,0x1d8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 getSelectionString(long param_1)
{
int iVar1;
ulong uVar2;
long lVar3;
char *__dest;
int8 uVar4;
size_t __size;
long lVar5;
char *local_208;
ulong local_200;
long local_1f8;
int1 local_1ec [4];
long local_1e8;
long local_1e0;
long local_1d8 [4];
int1 local_1b8 [8];
int1 local_1b0 [32];
int8 local_190;
long local_178;
int1 local_f0 [192];
local_1d8[0] = DAT_001c4b88;
local_1d8[1] = 0x1f;
uVar2 = (ulong)(DAT_001c4b68 != param_1);
lVar5 = uVar2 * 8 + 0x1ff08;
local_1d8[3] = param_1;
lVar3 = XGetSelectionOwner(DAT_001c44f8);
if (lVar3 != DAT_001c4518) {
free((void *)(&DAT_001c4540)[uVar2]);
(&DAT_001c4540)[uVar2] = 0;
local_1f8 = 0;
local_1e8 = lVar5;
do {
lVar3 = local_1d8[local_1f8];
XConvertSelection(DAT_001c44f8,local_1d8[3],lVar3,DAT_001c4ba0,DAT_001c4518,0);
while (iVar1 = XCheckTypedWindowEvent(DAT_001c44f8,DAT_001c4518,0x1f,local_1b0), iVar1 == 0) {
waitForEvent(0);
}
if (local_178 != 0) {
XCheckIfEvent(DAT_001c44f8,local_f0,isSelPropNewValueNotify,local_1b0);
XGetWindowProperty(DAT_001c44f8,local_190,local_178,0,0x7fffffffffffffff,1,0,&local_1e0,
local_1ec,&local_200,local_1b8,&local_208);
if (local_1e0 == DAT_001c4b58) {
__size = 1;
__dest = (char *)0x0;
do {
while (iVar1 = XCheckIfEvent(DAT_001c44f8,local_f0,isSelPropNewValueNotify,local_1b0),
iVar1 == 0) {
waitForEvent(0);
}
XFree(local_208);
XGetWindowProperty(DAT_001c44f8,local_190,local_178,0,0x7fffffffffffffff,1,0,&local_1e0,
local_1ec,&local_200,local_1b8,&local_208);
if (local_200 != 0) {
__size = __size + local_200;
__dest = (char *)realloc(__dest,__size);
__dest[~local_200 + __size] = '\0';
strcat(__dest,local_208);
}
} while (local_200 != 0);
if (local_1d8[local_1f8] == 0x1f) {
uVar4 = convertLatin1toUTF8(__dest);
lVar5 = local_1e8;
*(int8 *)((long)&_glfw + local_1e8) = uVar4;
free(__dest);
}
else {
*(char **)((long)&_glfw + local_1e8) = __dest;
lVar5 = local_1e8;
}
}
else if (local_1e0 == lVar3) {
if (lVar3 == 0x1f) {
uVar4 = convertLatin1toUTF8();
}
else {
uVar4 = _glfw_strdup(local_208);
}
*(int8 *)((long)&_glfw + lVar5) = uVar4;
}
XFree(local_208);
if (*(long *)((long)&_glfw + lVar5) != 0) goto LAB_001258b3;
}
if (local_1f8 != 0) goto LAB_001258b3;
local_1f8 = 1;
} while( true );
}
LAB_001258cd:
return *(int8 *)((long)&_glfw + lVar5);
LAB_001258b3:
if (*(long *)((long)&_glfw + lVar5) == 0) {
_glfwInputError(0x10009,"X11: Failed to convert selection to string");
}
goto LAB_001258cd;
}
| |
54,186 | 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 0xf3d95
movq 0x1c9234(%rip), %rax # 0x2bcfd0
movq (%rax), %rdi
callq 0x2a3d0
movq -0x18(%rbp), %rax
andq $0x480, %rax # imm = 0x480
cmpq $0x0, %rax
je 0xf3dbb
jmp 0xf3db6
jmp 0xf3e51
movq -0x18(%rbp), %rax
andq $0x4, %rax
cmpq $0x0, %rax
je 0xf3ddd
movq 0x1c9208(%rip), %rax # 0x2bcfd8
movq (%rax), %rsi
movl $0x7, %edi
callq 0x2a670
leaq 0xb8e87c(%rip), %rax # 0xc82660
cmpq $0x0, (%rax)
je 0xf3e19
leaq 0xb8e86f(%rip), %rax # 0xc82660
movq (%rax), %rdi
movq 0x1c91dd(%rip), %rax # 0x2bcfd8
movq (%rax), %rsi
callq 0x2a2c0
movq 0x1c91ce(%rip), %rax # 0x2bcfd8
movq (%rax), %rsi
leaq 0x606da(%rip), %rdi # 0x1544ee
callq 0x2a2c0
movq -0x10(%rbp), %rdi
movq 0x1c91b4(%rip), %rax # 0x2bcfd8
movq (%rax), %rsi
callq 0x2a2c0
movq 0x1c91a5(%rip), %rax # 0x2bcfd8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x2a670
movq 0x1c9191(%rip), %rax # 0x2bcfd8
movq (%rax), %rdi
callq 0x2a3d0
jmp 0xf3e51
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_F3D95:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, [rbp+var_18]
and rax, 480h
cmp rax, 0
jz short loc_F3DBB
jmp short $+2
loc_F3DB6:
jmp loc_F3E51
loc_F3DBB:
mov rax, [rbp+var_18]
and rax, 4
cmp rax, 0
jz short loc_F3DDD
mov rax, cs:stderr_ptr
mov rsi, [rax]
mov edi, 7
call _fputc
loc_F3DDD:
lea rax, my_progname
cmp qword ptr [rax], 0
jz short loc_F3E19
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, aWarning+8; ": "
call _fputs
loc_F3E19:
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_F3E51:
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 0x001f3d95
LAB_001f3d95:
MOV RAX,qword ptr [0x003bcfd0]
MOV RDI,qword ptr [RAX]
CALL 0x0012a3d0
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x480
CMP RAX,0x0
JZ 0x001f3dbb
JMP 0x001f3db6
LAB_001f3db6:
JMP 0x001f3e51
LAB_001f3dbb:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x4
CMP RAX,0x0
JZ 0x001f3ddd
MOV RAX,qword ptr [0x003bcfd8]
MOV RSI,qword ptr [RAX]
MOV EDI,0x7
CALL 0x0012a670
LAB_001f3ddd:
LEA RAX,[0xd82660]
CMP qword ptr [RAX],0x0
JZ 0x001f3e19
LEA RAX,[0xd82660]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [0x003bcfd8]
MOV RSI,qword ptr [RAX]
CALL 0x0012a2c0
MOV RAX,qword ptr [0x003bcfd8]
MOV RSI,qword ptr [RAX]
LEA RDI,[0x2544ee]
CALL 0x0012a2c0
LAB_001f3e19:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [0x003bcfd8]
MOV RSI,qword ptr [RAX]
CALL 0x0012a2c0
MOV RAX,qword ptr [0x003bcfd8]
MOV RSI,qword ptr [RAX]
MOV EDI,0xa
CALL 0x0012a670
MOV RAX,qword ptr [0x003bcfd8]
MOV RDI,qword ptr [RAX]
CALL 0x0012a3d0
JMP 0x001f3e51
LAB_001f3e51:
ADD RSP,0x20
POP RBP
RET
|
void my_message_stderr(int8 param_1,char *param_2,ulong param_3)
{
fflush(*(FILE **)PTR_stdout_003bcfd0);
if ((param_3 & 0x480) == 0) {
if ((param_3 & 4) != 0) {
fputc(7,*(FILE **)PTR_stderr_003bcfd8);
}
if (my_progname != (char *)0x0) {
fputs(my_progname,*(FILE **)PTR_stderr_003bcfd8);
fputs(": ",*(FILE **)PTR_stderr_003bcfd8);
}
fputs(param_2,*(FILE **)PTR_stderr_003bcfd8);
fputc(10,*(FILE **)PTR_stderr_003bcfd8);
fflush(*(FILE **)PTR_stderr_003bcfd8);
}
return;
}
| |
54,187 | google::protobuf::ServiceDescriptor::CopyTo(google::protobuf::ServiceDescriptorProto*) const | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc | void ServiceDescriptor::CopyTo(ServiceDescriptorProto* proto) const {
proto->set_name(name());
for (int i = 0; i < method_count(); i++) {
method(i)->CopyTo(proto->add_method());
}
if (&options() != &ServiceOptions::default_instance()) {
proto->mutable_options()->CopyFrom(options());
}
} | O0 | cpp | google::protobuf::ServiceDescriptor::CopyTo(google::protobuf::ServiceDescriptorProto*) const:
subq $0x78, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0x283f10
movq 0x28(%rsp), %rcx
movq %rcx, 0x60(%rsp)
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, %rax
addq $0x10, %rax
movq %rax, 0x70(%rsp)
movl $0x0, 0x6c(%rsp)
movq 0x70(%rsp), %rax
movslq 0x6c(%rsp), %rcx
movl (%rax,%rcx,4), %edx
orl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq %rdi, %rax
addq $0x10, %rax
addq $0x20, %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
callq 0x102610
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq %rax, %rdx
callq 0x169310
movl $0x0, 0x44(%rsp)
movq 0x20(%rsp), %rdi
movl 0x44(%rsp), %eax
movl %eax, 0x1c(%rsp)
callq 0x283f20
movl %eax, %ecx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
jge 0x2468be
movq 0x20(%rsp), %rdi
movl 0x44(%rsp), %esi
callq 0x283f30
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x283f50
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x2477b0
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x24686b
movq 0x20(%rsp), %rdi
callq 0x283f80
movq %rax, 0x8(%rsp)
callq 0x283f90
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0x246903
movq 0x48(%rsp), %rdi
callq 0x283fa0
movq 0x20(%rsp), %rdi
movq %rax, (%rsp)
callq 0x283f80
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x2d0970
addq $0x78, %rsp
retq
nopl (%rax,%rax)
| _ZNK6google8protobuf17ServiceDescriptor6CopyToEPNS0_22ServiceDescriptorProtoE:
sub rsp, 78h
mov [rsp+78h+var_28], rdi
mov [rsp+78h+var_30], rsi
mov rdi, [rsp+78h+var_28]
mov [rsp+78h+var_58], rdi
mov rax, [rsp+78h+var_30]
mov [rsp+78h+var_50], rax
call _ZNK6google8protobuf17ServiceDescriptor4nameB5cxx11Ev; google::protobuf::ServiceDescriptor::name(void)
mov rcx, [rsp+78h+var_50]
mov [rsp+78h+var_18], rcx
mov [rsp+78h+var_20], rax
mov rdi, [rsp+78h+var_18]; this
mov rax, rdi
add rax, 10h
mov [rsp+78h+var_8], rax
mov [rsp+78h+var_C], 0
mov rax, [rsp+78h+var_8]
movsxd rcx, [rsp+78h+var_C]
mov edx, [rax+rcx*4]
or edx, 1
mov [rax+rcx*4], edx
mov rax, rdi
add rax, 10h
add rax, 20h ; ' '
mov qword ptr [rsp+78h+var_48], rax
mov rax, [rsp+78h+var_20]
mov qword ptr [rsp+78h+var_40], rax
call _ZNK6google8protobuf11MessageLite21GetArenaForAllocationEv; google::protobuf::MessageLite::GetArenaForAllocation(void)
mov rdi, qword ptr [rsp+78h+var_48]; int
mov rsi, qword ptr [rsp+78h+var_40]; int
mov rdx, rax; int
call _ZN6google8protobuf8internal14ArenaStringPtr3SetERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPNS0_5ArenaE; google::protobuf::internal::ArenaStringPtr::Set(std::string const&,google::protobuf::Arena *)
mov [rsp+78h+var_34], 0
loc_24686B:
mov rdi, [rsp+78h+var_58]; this
mov eax, [rsp+78h+var_34]
mov [rsp+78h+var_5C], eax
call _ZNK6google8protobuf17ServiceDescriptor12method_countEv; google::protobuf::ServiceDescriptor::method_count(void)
mov ecx, eax
mov eax, [rsp+78h+var_5C]
cmp eax, ecx
jge short loc_2468BE
mov rdi, [rsp+78h+var_58]; this
mov esi, [rsp+78h+var_34]; int
call _ZNK6google8protobuf17ServiceDescriptor6methodEi; google::protobuf::ServiceDescriptor::method(int)
mov [rsp+78h+var_68], rax
mov rdi, [rsp+78h+var_30]; this
call _ZN6google8protobuf22ServiceDescriptorProto10add_methodEv; google::protobuf::ServiceDescriptorProto::add_method(void)
mov rdi, [rsp+78h+var_68]; this
mov rsi, rax; google::protobuf::MethodDescriptorProto *
call _ZNK6google8protobuf16MethodDescriptor6CopyToEPNS0_21MethodDescriptorProtoE; google::protobuf::MethodDescriptor::CopyTo(google::protobuf::MethodDescriptorProto *)
mov eax, [rsp+78h+var_34]
add eax, 1
mov [rsp+78h+var_34], eax
jmp short loc_24686B
loc_2468BE:
mov rdi, [rsp+78h+var_58]; this
call _ZNK6google8protobuf17ServiceDescriptor7optionsEv; google::protobuf::ServiceDescriptor::options(void)
mov [rsp+78h+var_70], rax
call _ZN6google8protobuf14ServiceOptions16default_instanceEv; google::protobuf::ServiceOptions::default_instance(void)
mov rcx, rax
mov rax, [rsp+78h+var_70]
cmp rax, rcx
jz short loc_246903
mov rdi, [rsp+78h+var_30]; this
call _ZN6google8protobuf22ServiceDescriptorProto15mutable_optionsEv; google::protobuf::ServiceDescriptorProto::mutable_options(void)
mov rdi, [rsp+78h+var_58]; this
mov [rsp+78h+var_78], rax
call _ZNK6google8protobuf17ServiceDescriptor7optionsEv; google::protobuf::ServiceDescriptor::options(void)
mov rdi, [rsp+78h+var_78]; this
mov rsi, rax; google::protobuf::ServiceOptions *
call _ZN6google8protobuf14ServiceOptions8CopyFromERKS1_; google::protobuf::ServiceOptions::CopyFrom(google::protobuf::ServiceOptions const&)
loc_246903:
add rsp, 78h
retn
| long long google::protobuf::ServiceDescriptor::CopyTo(
google::protobuf::ServiceDescriptor *this,
google::protobuf::ServiceDescriptorProto *a2)
{
int ArenaForAllocation; // eax
google::protobuf::MethodDescriptorProto *v3; // rax
long long v4; // rcx
long long result; // rax
const google::protobuf::ServiceOptions *v6; // rax
google::protobuf::ServiceOptions *v7; // [rsp+0h] [rbp-78h]
long long v8; // [rsp+8h] [rbp-70h]
google::protobuf::MethodDescriptor *v9; // [rsp+10h] [rbp-68h]
int i; // [rsp+44h] [rbp-34h]
int v11; // [rsp+58h] [rbp-20h]
v11 = google::protobuf::ServiceDescriptor::name[abi:cxx11]();
*((_DWORD *)a2 + 4) |= 1u;
ArenaForAllocation = google::protobuf::MessageLite::GetArenaForAllocation(a2);
google::protobuf::internal::ArenaStringPtr::Set((_DWORD)a2 + 48, v11, ArenaForAllocation);
for ( i = 0; i < (int)google::protobuf::ServiceDescriptor::method_count(this); ++i )
{
v9 = (google::protobuf::MethodDescriptor *)google::protobuf::ServiceDescriptor::method(this, i);
v3 = (google::protobuf::MethodDescriptorProto *)google::protobuf::ServiceDescriptorProto::add_method(a2);
google::protobuf::MethodDescriptor::CopyTo(v9, v3);
}
v8 = google::protobuf::ServiceDescriptor::options(this);
v4 = google::protobuf::ServiceOptions::default_instance(this);
result = v8;
if ( v8 != v4 )
{
v7 = (google::protobuf::ServiceOptions *)google::protobuf::ServiceDescriptorProto::mutable_options(a2);
v6 = (const google::protobuf::ServiceOptions *)google::protobuf::ServiceDescriptor::options(this);
return google::protobuf::ServiceOptions::CopyFrom(v7, v6);
}
return result;
}
| |||
54,188 | google::protobuf::ServiceDescriptor::CopyTo(google::protobuf::ServiceDescriptorProto*) const | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc | void ServiceDescriptor::CopyTo(ServiceDescriptorProto* proto) const {
proto->set_name(name());
for (int i = 0; i < method_count(); i++) {
method(i)->CopyTo(proto->add_method());
}
if (&options() != &ServiceOptions::default_instance()) {
proto->mutable_options()->CopyFrom(options());
}
} | O3 | cpp | google::protobuf::ServiceDescriptor::CopyTo(google::protobuf::ServiceDescriptorProto*) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
orl $0x1, 0x10(%r14)
leaq 0x30(%r14), %rdi
movq 0x8(%r14), %rax
movq %rax, %rdx
andq $-0x4, %rdx
testb $0x1, %al
jne 0xc2925
callq 0x786ce
cmpl $0x0, 0x28(%rbx)
jle 0xc28c9
leaq 0x18(%r14), %r15
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x20(%rbx), %r12
addq %r13, %r12
movq %r15, %rdi
xorl %esi, %esi
callq 0xe24d6
movq %r12, %rdi
movq %rax, %rsi
callq 0xc3220
incq %rbp
movslq 0x28(%rbx), %rax
addq $0x40, %r13
cmpq %rax, %rbp
jl 0xc289d
movq 0x18(%rbx), %rsi
cmpq 0x14d5cc(%rip), %rsi # 0x20fea0
je 0xc2916
orb $0x2, 0x10(%r14)
movq 0x38(%r14), %rdi
testq %rdi, %rdi
jne 0xc2903
movq 0x8(%r14), %rax
movq %rax, %rdi
andq $-0x4, %rdi
testb $0x1, %al
jne 0xc292d
callq 0xfa9b2
movq %rax, %rdi
movq %rax, 0x38(%r14)
movq 0x18(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf6a96
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rdx), %rdx
jmp 0xc2889
movq (%rdi), %rdi
jmp 0xc28f3
| _ZNK6google8protobuf17ServiceDescriptor6CopyToEPNS0_22ServiceDescriptorProtoE:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rsi, [rdi+8]
or dword ptr [r14+10h], 1
lea rdi, [r14+30h]
mov rax, [r14+8]
mov rdx, rax
and rdx, 0FFFFFFFFFFFFFFFCh
test al, 1
jnz loc_C2925
loc_C2889:
call _ZN6google8protobuf8internal14ArenaStringPtr3SetERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPNS0_5ArenaE; google::protobuf::internal::ArenaStringPtr::Set(std::string const&,google::protobuf::Arena *)
cmp dword ptr [rbx+28h], 0
jle short loc_C28C9
lea r15, [r14+18h]
xor r13d, r13d
xor ebp, ebp
loc_C289D:
mov r12, [rbx+20h]
add r12, r13
mov rdi, r15; this
xor esi, esi
call _ZN6google8protobuf8internal20RepeatedPtrFieldBase3AddINS0_16RepeatedPtrFieldINS0_21MethodDescriptorProtoEE11TypeHandlerEEEPNT_4TypeEPKS9_; google::protobuf::internal::RepeatedPtrFieldBase::Add<google::protobuf::RepeatedPtrField<google::protobuf::MethodDescriptorProto>::TypeHandler>(google::protobuf::RepeatedPtrField<google::protobuf::MethodDescriptorProto>::TypeHandler::Type * const*)
mov rdi, r12; this
mov rsi, rax; google::protobuf::MethodDescriptorProto *
call _ZNK6google8protobuf16MethodDescriptor6CopyToEPNS0_21MethodDescriptorProtoE; google::protobuf::MethodDescriptor::CopyTo(google::protobuf::MethodDescriptorProto *)
inc rbp
movsxd rax, dword ptr [rbx+28h]
add r13, 40h ; '@'
cmp rbp, rax
jl short loc_C289D
loc_C28C9:
mov rsi, [rbx+18h]
cmp rsi, cs:_ZN6google8protobuf33_ServiceOptions_default_instance_E_ptr
jz short loc_C2916
or byte ptr [r14+10h], 2
mov rdi, [r14+38h]
test rdi, rdi
jnz short loc_C2903
mov rax, [r14+8]
mov rdi, rax
and rdi, 0FFFFFFFFFFFFFFFCh
test al, 1
jnz short loc_C292D
loc_C28F3:
call _ZN6google8protobuf5Arena18CreateMaybeMessageINS0_14ServiceOptionsEJEEEPT_PS1_DpOT0_; google::protobuf::Arena::CreateMaybeMessage<google::protobuf::ServiceOptions>(google::protobuf::Arena*)
mov rdi, rax; this
mov [r14+38h], rax
mov rsi, [rbx+18h]; google::protobuf::ServiceOptions *
loc_C2903:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _ZN6google8protobuf14ServiceOptions8CopyFromERKS1_; google::protobuf::ServiceOptions::CopyFrom(google::protobuf::ServiceOptions const&)
loc_C2916:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_C2925:
mov rdx, [rdx]
jmp loc_C2889
loc_C292D:
mov rdi, [rdi]
jmp short loc_C28F3
| long long google::protobuf::ServiceDescriptor::CopyTo(
google::protobuf::ServiceDescriptor *this,
google::protobuf::ServiceDescriptorProto *a2)
{
long long v4; // rsi
google::protobuf::Arena *v5; // rdx
long long result; // rax
long long v7; // r13
long long v8; // rbp
google::protobuf::MethodDescriptor *v9; // r12
google::protobuf::MethodDescriptorProto *v10; // rax
const google::protobuf::ServiceOptions *v11; // rsi
google::protobuf::ServiceOptions *v12; // rdi
_QWORD *v13; // rdi
v4 = *((_QWORD *)this + 1);
*((_DWORD *)a2 + 4) |= 1u;
v5 = (google::protobuf::Arena *)(*((_QWORD *)a2 + 1) & 0xFFFFFFFFFFFFFFFCLL);
if ( (*((_QWORD *)a2 + 1) & 1) != 0 )
v5 = *(google::protobuf::Arena **)v5;
result = google::protobuf::internal::ArenaStringPtr::Set((long long *)a2 + 6, v4, v5);
if ( *((int *)this + 10) > 0 )
{
v7 = 0LL;
v8 = 0LL;
do
{
v9 = (google::protobuf::MethodDescriptor *)(v7 + *((_QWORD *)this + 4));
v10 = (google::protobuf::MethodDescriptorProto *)google::protobuf::internal::RepeatedPtrFieldBase::Add<google::protobuf::RepeatedPtrField<google::protobuf::MethodDescriptorProto>::TypeHandler>((google::protobuf::ServiceDescriptorProto *)((char *)a2 + 24));
google::protobuf::MethodDescriptor::CopyTo(v9, v10);
++v8;
result = *((int *)this + 10);
v7 += 64LL;
}
while ( v8 < result );
}
v11 = (const google::protobuf::ServiceOptions *)*((_QWORD *)this + 3);
if ( v11 != (const google::protobuf::ServiceOptions *)&google::protobuf::_ServiceOptions_default_instance_ )
{
*((_BYTE *)a2 + 16) |= 2u;
v12 = (google::protobuf::ServiceOptions *)*((_QWORD *)a2 + 7);
if ( !v12 )
{
v13 = (_QWORD *)(*((_QWORD *)a2 + 1) & 0xFFFFFFFFFFFFFFFCLL);
if ( (*((_QWORD *)a2 + 1) & 1) != 0 )
v13 = (_QWORD *)*v13;
v12 = (google::protobuf::ServiceOptions *)google::protobuf::Arena::CreateMaybeMessage<google::protobuf::ServiceOptions>(v13);
*((_QWORD *)a2 + 7) = v12;
v11 = (const google::protobuf::ServiceOptions *)*((_QWORD *)this + 3);
}
return google::protobuf::ServiceOptions::CopyFrom(v12, v11);
}
return result;
}
| CopyTo:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RSI,qword ptr [RDI + 0x8]
OR dword ptr [R14 + 0x10],0x1
LEA RDI,[R14 + 0x30]
MOV RAX,qword ptr [R14 + 0x8]
MOV RDX,RAX
AND RDX,-0x4
TEST AL,0x1
JNZ 0x001c2925
LAB_001c2889:
CALL 0x001786ce
CMP dword ptr [RBX + 0x28],0x0
JLE 0x001c28c9
LEA R15,[R14 + 0x18]
XOR R13D,R13D
XOR EBP,EBP
LAB_001c289d:
MOV R12,qword ptr [RBX + 0x20]
ADD R12,R13
MOV RDI,R15
XOR ESI,ESI
CALL 0x001e24d6
MOV RDI,R12
MOV RSI,RAX
CALL 0x001c3220
INC RBP
MOVSXD RAX,dword ptr [RBX + 0x28]
ADD R13,0x40
CMP RBP,RAX
JL 0x001c289d
LAB_001c28c9:
MOV RSI,qword ptr [RBX + 0x18]
CMP RSI,qword ptr [0x0030fea0]
JZ 0x001c2916
OR byte ptr [R14 + 0x10],0x2
MOV RDI,qword ptr [R14 + 0x38]
TEST RDI,RDI
JNZ 0x001c2903
MOV RAX,qword ptr [R14 + 0x8]
MOV RDI,RAX
AND RDI,-0x4
TEST AL,0x1
JNZ 0x001c292d
LAB_001c28f3:
CALL 0x001fa9b2
MOV RDI,RAX
MOV qword ptr [R14 + 0x38],RAX
MOV RSI,qword ptr [RBX + 0x18]
LAB_001c2903:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001f6a96
LAB_001c2916:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001c2925:
MOV RDX,qword ptr [RDX]
JMP 0x001c2889
LAB_001c292d:
MOV RDI,qword ptr [RDI]
JMP 0x001c28f3
|
/* google::protobuf::ServiceDescriptor::CopyTo(google::protobuf::ServiceDescriptorProto*) const */
void __thiscall
google::protobuf::ServiceDescriptor::CopyTo(ServiceDescriptor *this,ServiceDescriptorProto *param_1)
{
string *psVar1;
long lVar2;
Type *pTVar3;
ServiceOptions *this_00;
Arena *pAVar4;
long lVar5;
ServiceOptions *pSVar6;
long lVar7;
psVar1 = *(string **)(this + 8);
*(uint *)(param_1 + 0x10) = *(uint *)(param_1 + 0x10) | 1;
pAVar4 = (Arena *)(*(ulong *)(param_1 + 8) & 0xfffffffffffffffc);
if ((*(ulong *)(param_1 + 8) & 1) != 0) {
pAVar4 = *(Arena **)pAVar4;
}
internal::ArenaStringPtr::Set((ArenaStringPtr *)(param_1 + 0x30),psVar1,pAVar4);
if (0 < *(int *)(this + 0x28)) {
lVar7 = 0;
lVar5 = 0;
do {
lVar2 = *(long *)(this + 0x20);
pTVar3 = internal::RepeatedPtrFieldBase::
Add<google::protobuf::RepeatedPtrField<google::protobuf::MethodDescriptorProto>::TypeHandler>
((Type *)(param_1 + 0x18));
MethodDescriptor::CopyTo((MethodDescriptor *)(lVar2 + lVar7),(MethodDescriptorProto *)pTVar3);
lVar5 = lVar5 + 1;
lVar7 = lVar7 + 0x40;
} while (lVar5 < *(int *)(this + 0x28));
}
pSVar6 = *(ServiceOptions **)(this + 0x18);
if (pSVar6 != (ServiceOptions *)PTR__ServiceOptions_default_instance__0030fea0) {
param_1[0x10] = (ServiceDescriptorProto)((byte)param_1[0x10] | 2);
this_00 = *(ServiceOptions **)(param_1 + 0x38);
if (this_00 == (ServiceOptions *)0x0) {
pAVar4 = (Arena *)(*(ulong *)(param_1 + 8) & 0xfffffffffffffffc);
if ((*(ulong *)(param_1 + 8) & 1) != 0) {
pAVar4 = *(Arena **)pAVar4;
}
this_00 = Arena::CreateMaybeMessage<google::protobuf::ServiceOptions>(pAVar4);
*(ServiceOptions **)(param_1 + 0x38) = this_00;
pSVar6 = *(ServiceOptions **)(this + 0x18);
}
ServiceOptions::CopyFrom(this_00,pSVar6);
return;
}
return;
}
| |
54,189 | minja::UnaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/./minja.hpp | Value do_evaluate(const std::shared_ptr<Context> & context) const override {
if (!expr) throw std::runtime_error("UnaryOpExpr.expr is null");
auto e = expr->evaluate(context);
switch (op) {
case Op::Plus: return e;
case Op::Minus: return -e;
case Op::LogicalNot: return !e.to_bool();
case Op::Expansion:
case Op::ExpansionDict:
throw std::runtime_error("Expansion operator is only supported in function calls and collections");
}
throw std::runtime_error("Unknown unary operator");
} | O0 | cpp | minja::UnaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const:
subq $0xc8, %rsp
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq 0xb8(%rsp), %rdi
movq %rdi, 0x40(%rsp)
addq $0x20, %rdi
callq 0x77a80
testb $0x1, %al
jne 0x9f074
movl $0x10, %edi
callq 0x50540
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x28(%rsp)
leaq 0x12d82e(%rip), %rsi # 0x1cc860
callq 0x50340
jmp 0x9f039
movq 0x28(%rsp), %rdi
movq 0x1b4f6b(%rip), %rsi # 0x253fb0
movq 0x1b4f2c(%rip), %rdx # 0x253f78
callq 0x508f0
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
callq 0x50c40
jmp 0x9f22e
movq 0x40(%rsp), %rdi
addq $0x20, %rdi
callq 0x9f2f0
movq %rax, %rsi
movq 0xb0(%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0x9f300
movq 0x40(%rsp), %rax
movl 0x30(%rax), %eax
movq %rax, 0x20(%rsp)
subq $0x4, %rax
ja 0x9f1b0
movq 0x20(%rsp), %rax
leaq 0x123082(%rip), %rcx # 0x1c213c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x9f530
movl $0x1, 0x4c(%rsp)
jmp 0x9f20d
movq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x9f5b0
jmp 0x9f0f0
movl $0x1, 0x4c(%rsp)
jmp 0x9f20d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x9f224
leaq 0x50(%rsp), %rdi
callq 0x9f650
movb %al, 0x1f(%rsp)
jmp 0x9f126
movq 0x30(%rsp), %rdi
movb 0x1f(%rsp), %al
notb %al
andb $0x1, %al
movb %al, 0x4b(%rsp)
leaq 0x4b(%rsp), %rsi
callq 0x9f740
jmp 0x9f143
movl $0x1, 0x4c(%rsp)
jmp 0x9f20d
movl $0x10, %edi
callq 0x50540
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
leaq 0x12d70d(%rip), %rsi # 0x1cc879
callq 0x50340
jmp 0x9f173
movq 0x10(%rsp), %rdi
movq 0x1b4e31(%rip), %rsi # 0x253fb0
movq 0x1b4df2(%rip), %rdx # 0x253f78
callq 0x508f0
jmp 0x9f23b
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
callq 0x50c40
jmp 0x9f224
movl $0x10, %edi
callq 0x50540
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x12d6f4(%rip), %rsi # 0x1cc8c0
callq 0x50340
jmp 0x9f1d3
movq 0x8(%rsp), %rdi
movq 0x1b4dd1(%rip), %rsi # 0x253fb0
movq 0x1b4d92(%rip), %rdx # 0x253f78
callq 0x508f0
jmp 0x9f23b
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
callq 0x50c40
jmp 0x9f224
leaq 0x50(%rsp), %rdi
callq 0x9f7a0
movq 0x38(%rsp), %rax
addq $0xc8, %rsp
retq
leaq 0x50(%rsp), %rdi
callq 0x9f7a0
movq 0xa8(%rsp), %rdi
callq 0x50940
nopl (%rax,%rax)
| _ZNK5minja11UnaryOpExpr11do_evaluateERKSt10shared_ptrINS_7ContextEE:
sub rsp, 0C8h
mov [rsp+0C8h+var_98], rdi
mov rax, rdi
mov [rsp+0C8h+var_90], rax
mov [rsp+0C8h+var_8], rdi
mov [rsp+0C8h+var_10], rsi
mov [rsp+0C8h+var_18], rdx
mov rdi, [rsp+0C8h+var_10]
mov [rsp+0C8h+var_88], rdi
add rdi, 20h ; ' '
call _ZNKSt12__shared_ptrIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2EEcvbEv; std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool(void)
test al, 1
jnz short loc_9F074
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+0C8h+var_A0], rax
lea rsi, aUnaryopexprExp; "UnaryOpExpr.expr is null"
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_9F039:
mov rdi, [rsp+0C8h+var_A0]; void *
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
mov rdi, [rsp+0C8h+var_A0]; void *
mov rcx, rax
mov eax, edx
mov [rsp+0C8h+var_20], rcx
mov [rsp+0C8h+var_24], eax
call ___cxa_free_exception
jmp loc_9F22E
loc_9F074:
mov rdi, [rsp+0C8h+var_88]
add rdi, 20h ; ' '
call _ZNKSt19__shared_ptr_accessIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rsi, rax
mov rdx, [rsp+0C8h+var_18]
lea rdi, [rsp+0C8h+var_78]
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
mov rax, [rsp+0C8h+var_88]
mov eax, [rax+30h]
mov [rsp+0C8h+var_A8], rax
sub rax, 4; switch 5 cases
ja def_9F0C1; jumptable 000000000009F0C1 default case
mov rax, [rsp+0C8h+var_A8]
lea rcx, jpt_9F0C1
movsxd rax, ds:(jpt_9F0C1 - 1C213Ch)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_9F0C3:
mov rdi, [rsp+0C8h+var_98]; jumptable 000000000009F0C1 case 0
lea rsi, [rsp+0C8h+var_78]
call _ZN5minja5ValueC2EOS0_; minja::Value::Value(minja::Value&&)
mov [rsp+0C8h+var_7C], 1
jmp loc_9F20D
loc_9F0DF:
mov rdi, [rsp+0C8h+var_98]; jumptable 000000000009F0C1 case 1
lea rsi, [rsp+0C8h+var_78]
call _ZNK5minja5ValuengEv; minja::Value::operator-(void)
jmp short $+2
loc_9F0F0:
mov [rsp+0C8h+var_7C], 1
jmp loc_9F20D
mov rcx, rax
mov eax, edx
mov [rsp+0C8h+var_20], rcx
mov [rsp+0C8h+var_24], eax
jmp loc_9F224
loc_9F116:
lea rdi, [rsp+0C8h+var_78]; jumptable 000000000009F0C1 case 2
call _ZNK5minja5Value7to_boolEv; minja::Value::to_bool(void)
mov [rsp+0C8h+var_A9], al
jmp short $+2
loc_9F126:
mov rdi, [rsp+0C8h+var_98]; this
mov al, [rsp+0C8h+var_A9]
not al
and al, 1
mov [rsp+0C8h+var_7D], al
lea rsi, [rsp+0C8h+var_7D]; bool *
call _ZN5minja5ValueC2ERKb; minja::Value::Value(bool const&)
jmp short $+2
loc_9F143:
mov [rsp+0C8h+var_7C], 1
jmp loc_9F20D
loc_9F150:
mov edi, 10h; jumptable 000000000009F0C1 cases 3,4
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+0C8h+var_B8], rax
lea rsi, aExpansionOpera; "Expansion operator is only supported in"...
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_9F173:
mov rdi, [rsp+0C8h+var_B8]; void *
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_9F23B
mov rdi, [rsp+0C8h+var_B8]; void *
mov rcx, rax
mov eax, edx
mov [rsp+0C8h+var_20], rcx
mov [rsp+0C8h+var_24], eax
call ___cxa_free_exception
jmp short loc_9F224
def_9F0C1:
mov edi, 10h; jumptable 000000000009F0C1 default case
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+0C8h+var_C0], rax
lea rsi, aUnknownUnaryOp; "Unknown unary operator"
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_9F1D3:
mov rdi, [rsp+0C8h+var_C0]; void *
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp short loc_9F23B
mov rdi, [rsp+0C8h+var_C0]; void *
mov rcx, rax
mov eax, edx
mov [rsp+0C8h+var_20], rcx
mov [rsp+0C8h+var_24], eax
call ___cxa_free_exception
jmp short loc_9F224
loc_9F20D:
lea rdi, [rsp+0C8h+var_78]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rax, [rsp+0C8h+var_90]
add rsp, 0C8h
retn
loc_9F224:
lea rdi, [rsp+0C8h+var_78]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_9F22E:
mov rdi, [rsp+0C8h+var_20]
call __Unwind_Resume
loc_9F23B:
nop dword ptr [rax+rax+00h]
| minja::Value * minja::UnaryOpExpr::do_evaluate(minja::Value *a1, long long a2, long long a3)
{
long long v3; // rax
std::runtime_error *v5; // [rsp+8h] [rbp-C0h]
std::runtime_error *v6; // [rsp+10h] [rbp-B8h]
std::runtime_error *exception; // [rsp+28h] [rbp-A0h]
bool v8; // [rsp+4Bh] [rbp-7Dh] BYREF
int v9; // [rsp+4Ch] [rbp-7Ch]
_BYTE v10[84]; // [rsp+50h] [rbp-78h] BYREF
long long v11; // [rsp+B0h] [rbp-18h]
long long v12; // [rsp+B8h] [rbp-10h]
minja::Value *v13; // [rsp+C0h] [rbp-8h]
v13 = a1;
v12 = a2;
v11 = a3;
if ( !std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool((_QWORD *)(a2 + 32)) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "UnaryOpExpr.expr is null");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v3 = std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(a2 + 32);
minja::Expression::evaluate(v10, v3, v11);
switch ( *(_DWORD *)(a2 + 48) )
{
case 0:
minja::Value::Value(a1, v10);
v9 = 1;
break;
case 1:
minja::Value::operator-(a1, v10);
v9 = 1;
break;
case 2:
v8 = (minja::Value::to_bool((minja::Value *)v10) & 1) == 0;
minja::Value::Value(a1, &v8);
v9 = 1;
break;
case 3:
case 4:
v6 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v6, "Expansion operator is only supported in function calls and collections");
__cxa_throw(
v6,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
default:
v5 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v5, "Unknown unary operator");
__cxa_throw(
v5,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Value::~Value((minja::Value *)v10);
return a1;
}
| do_evaluate:
SUB RSP,0xc8
MOV qword ptr [RSP + 0x30],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0xc0],RDI
MOV qword ptr [RSP + 0xb8],RSI
MOV qword ptr [RSP + 0xb0],RDX
MOV RDI,qword ptr [RSP + 0xb8]
MOV qword ptr [RSP + 0x40],RDI
ADD RDI,0x20
CALL 0x00177a80
TEST AL,0x1
JNZ 0x0019f074
MOV EDI,0x10
CALL 0x00150540
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RSP + 0x28],RAX
LAB_0019f02b:
LEA RSI,[0x2cc860]
CALL 0x00150340
LAB_0019f037:
JMP 0x0019f039
LAB_0019f039:
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [0x00353fb0]
MOV RDX,qword ptr [0x00353f78]
CALL 0x001508f0
LAB_0019f074:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x20
CALL 0x0019f2f0
MOV RSI,RAX
MOV RDX,qword ptr [RSP + 0xb0]
LEA RDI,[RSP + 0x50]
CALL 0x0019f300
MOV RAX,qword ptr [RSP + 0x40]
MOV EAX,dword ptr [RAX + 0x30]
MOV qword ptr [RSP + 0x20],RAX
SUB RAX,0x4
JA 0x0019f1b0
MOV RAX,qword ptr [RSP + 0x20]
LEA RCX,[0x2c213c]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
MOV RDI,qword ptr [RSP + 0x30]
LEA RSI,[RSP + 0x50]
CALL 0x0019f530
MOV dword ptr [RSP + 0x4c],0x1
JMP 0x0019f20d
caseD_1:
MOV RDI,qword ptr [RSP + 0x30]
LEA RSI,[RSP + 0x50]
CALL 0x0019f5b0
JMP 0x0019f0f0
LAB_0019f0f0:
MOV dword ptr [RSP + 0x4c],0x1
JMP 0x0019f20d
caseD_2:
LEA RDI,[RSP + 0x50]
CALL 0x0019f650
MOV byte ptr [RSP + 0x1f],AL
JMP 0x0019f126
LAB_0019f126:
MOV RDI,qword ptr [RSP + 0x30]
MOV AL,byte ptr [RSP + 0x1f]
NOT AL
AND AL,0x1
MOV byte ptr [RSP + 0x4b],AL
LEA RSI,[RSP + 0x4b]
CALL 0x0019f740
LAB_0019f141:
JMP 0x0019f143
LAB_0019f143:
MOV dword ptr [RSP + 0x4c],0x1
JMP 0x0019f20d
caseD_3:
MOV EDI,0x10
CALL 0x00150540
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RSP + 0x10],RAX
LAB_0019f165:
LEA RSI,[0x2cc879]
CALL 0x00150340
JMP 0x0019f173
LAB_0019f173:
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [0x00353fb0]
MOV RDX,qword ptr [0x00353f78]
CALL 0x001508f0
default:
MOV EDI,0x10
CALL 0x00150540
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RSP + 0x8],RAX
LAB_0019f1c5:
LEA RSI,[0x2cc8c0]
CALL 0x00150340
JMP 0x0019f1d3
LAB_0019f1d3:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [0x00353fb0]
MOV RDX,qword ptr [0x00353f78]
CALL 0x001508f0
LAB_0019f20d:
LEA RDI,[RSP + 0x50]
CALL 0x0019f7a0
MOV RAX,qword ptr [RSP + 0x38]
ADD RSP,0xc8
RET
|
/* minja::UnaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const */
shared_ptr * minja::UnaryOpExpr::do_evaluate(shared_ptr *param_1)
{
bool bVar1;
byte bVar2;
runtime_error *prVar3;
long in_RSI;
bool local_7d [5];
shared_ptr local_78 [112];
shared_ptr *local_8;
local_8 = param_1;
bVar1 = std::__shared_ptr::operator_cast_to_bool((__shared_ptr *)(in_RSI + 0x20));
if (bVar1) {
std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::operator->
((__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false> *)
(in_RSI + 0x20));
Expression::evaluate(local_78);
switch(*(int4 *)(in_RSI + 0x30)) {
case 0:
Value::Value((Value *)param_1,(Value *)local_78);
break;
case 1:
/* try { // try from 0019f0df to 0019f140 has its CatchHandler @ 0019f0fd */
Value::operator-((Value *)param_1);
break;
case 2:
bVar2 = Value::to_bool((Value *)local_78);
local_7d[0] = (bool)(~bVar2 & 1);
Value::Value((Value *)param_1,local_7d);
break;
case 3:
case 4:
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0019f165 to 0019f170 has its CatchHandler @ 0019f190 */
std::runtime_error::runtime_error
(prVar3,"Expansion operator is only supported in function calls and collections");
/* try { // try from 0019f173 to 0019f18a has its CatchHandler @ 0019f0fd */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_00353fb0,PTR__runtime_error_00353f78);
default:
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0019f1c5 to 0019f1d0 has its CatchHandler @ 0019f1ed */
std::runtime_error::runtime_error(prVar3,"Unknown unary operator");
/* try { // try from 0019f1d3 to 0019f1ea has its CatchHandler @ 0019f0fd */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_00353fb0,PTR__runtime_error_00353f78);
}
local_7d[1] = true;
local_7d[2] = false;
local_7d[3] = false;
local_7d[4] = false;
Value::~Value((Value *)local_78);
return param_1;
}
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0019f02b to 0019f036 has its CatchHandler @ 0019f051 */
std::runtime_error::runtime_error(prVar3,"UnaryOpExpr.expr is null");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_00353fb0,PTR__runtime_error_00353f78);
}
| |
54,190 | minja::UnaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/./minja.hpp | Value do_evaluate(const std::shared_ptr<Context> & context) const override {
if (!expr) throw std::runtime_error("UnaryOpExpr.expr is null");
auto e = expr->evaluate(context);
switch (op) {
case Op::Plus: return e;
case Op::Minus: return -e;
case Op::LogicalNot: return !e.to_bool();
case Op::Expansion:
case Op::ExpansionDict:
throw std::runtime_error("Expansion operator is only supported in function calls and collections");
}
throw std::runtime_error("Unknown unary operator");
} | O1 | cpp | minja::UnaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq 0x20(%rsi), %rsi
testq %rsi, %rsi
je 0x3eb12
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3ec5a
movl 0x30(%r14), %eax
cmpq $0x4, %rax
ja 0x3eb62
leaq 0x72761(%rip), %rcx # 0xb1128
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %r12d, %r12d
movq %r12, 0x18(%rbx)
leaq 0x48(%rsp), %r15
movups -0x30(%r15), %xmm0
movq %r12, -0x28(%r15)
movups %xmm0, 0x10(%rbx)
movq %r12, -0x30(%r15)
movq %r12, 0x28(%rbx)
movups -0x20(%r15), %xmm0
movq %r12, -0x18(%r15)
movups %xmm0, 0x20(%rbx)
movq %r12, -0x20(%r15)
movq %r12, 0x38(%rbx)
movups -0x10(%r15), %xmm0
movq %r12, -0x8(%r15)
movups %xmm0, 0x30(%rbx)
movq %r12, -0x10(%r15)
leaq 0x40(%rbx), %r14
movups (%r15), %xmm0
movups %xmm0, 0x40(%rbx)
movq %r15, %rdi
xorl %esi, %esi
callq 0x3efdc
movb $0x0, (%r15)
movq %r12, 0x8(%r15)
jmp 0x3ea6e
leaq 0x8(%rsp), %rdi
callq 0x3ee5c
xorb $0x1, %al
leaq 0x40(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movzbl %al, %esi
movq %r14, %rdi
callq 0x41084
movq %r14, %rdi
movl $0x1, %esi
callq 0x3efdc
jmp 0x3ea8a
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3edd8
leaq 0x48(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3efdc
movq %r14, %rdi
callq 0x4bfb8
movq -0x8(%r14), %rdi
testq %rdi, %rdi
je 0x3eaaf
callq 0x30e64
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x3eabe
callq 0x30e64
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x3eacd
callq 0x30e64
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3eb03
movq 0xb44c2(%rip), %rax # 0xf2fa0
cmpb $0x0, (%rax)
je 0x3eaee
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x3eaf8
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x3eb03
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x18360
movq %rax, %r14
leaq 0x7c24c(%rip), %rsi # 0xbad72
movq %rax, %rdi
callq 0x18270
movq 0xb44bb(%rip), %rsi # 0xf2ff0
movq 0xb4444(%rip), %rdx # 0xf2f80
movq %r14, %rdi
callq 0x18b30
movl $0x10, %edi
callq 0x18360
movq %rax, %r14
leaq 0x7c233(%rip), %rsi # 0xbad8b
movq %rax, %rdi
callq 0x18270
jmp 0x3eb7e
movl $0x10, %edi
callq 0x18360
movq %rax, %r14
leaq 0x7c25c(%rip), %rsi # 0xbadd2
movq %rax, %rdi
callq 0x18270
movq 0xb446b(%rip), %rsi # 0xf2ff0
movq 0xb43f4(%rip), %rdx # 0xf2f80
movq %r14, %rdi
callq 0x18b30
jmp 0x3eb98
jmp 0x3ebb2
movq %rax, %rbx
movq %r14, %rdi
callq 0x18500
jmp 0x3ebb5
movq %rax, %rbx
movq %r14, %rdi
callq 0x18500
jmp 0x3ebbf
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3ef50
movq %rbx, %rdi
callq 0x18b90
nop
| _ZNK5minja11UnaryOpExpr11do_evaluateERKSt10shared_ptrINS_7ContextEE:
push r15
push r14
push r12
push rbx
sub rsp, 58h
mov r14, rsi
mov rsi, [rsi+20h]
test rsi, rsi
jz loc_3EB12
mov rbx, rdi
lea rdi, [rsp+78h+var_70]
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
mov eax, [r14+30h]
cmp rax, 4; switch 5 cases
ja def_3E9CE; jumptable 000000000003E9CE default case
lea rcx, jpt_3E9CE
movsxd rax, ds:(jpt_3E9CE - 0B1128h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_3E9D0:
xorps xmm0, xmm0; jumptable 000000000003E9CE case 0
movups xmmword ptr [rbx], xmm0
xor r12d, r12d
mov [rbx+18h], r12
lea r15, [rsp+78h+var_30]
movups xmm0, xmmword ptr [r15-30h]
mov [r15-28h], r12
movups xmmword ptr [rbx+10h], xmm0
mov [r15-30h], r12
mov [rbx+28h], r12
movups xmm0, xmmword ptr [r15-20h]
mov [r15-18h], r12
movups xmmword ptr [rbx+20h], xmm0
mov [r15-20h], r12
mov [rbx+38h], r12
movups xmm0, xmmword ptr [r15-10h]
mov [r15-8], r12
movups xmmword ptr [rbx+30h], xmm0
mov [r15-10h], r12
lea r14, [rbx+40h]
movups xmm0, xmmword ptr [r15]
movups xmmword ptr [rbx+40h], xmm0
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r15], 0
mov [r15+8], r12
jmp short loc_3EA6E
loc_3EA3D:
lea rdi, [rsp+78h+var_70]; jumptable 000000000003E9CE case 2
call _ZNK5minja5Value7to_boolEv; minja::Value::to_bool(void)
xor al, 1
lea r14, [rbx+40h]
xorps xmm0, xmm0
movups xmmword ptr [rbx+40h], xmm0
movups xmmword ptr [rbx+30h], xmm0
movups xmmword ptr [rbx+20h], xmm0
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx], xmm0
movzx esi, al
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE4EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_9boolean_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::boolean_t)
loc_3EA6E:
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_3EA8A
loc_3EA7D:
lea rsi, [rsp+78h+var_70]; jumptable 000000000003E9CE case 1
mov rdi, rbx
call _ZNK5minja5ValuengEv; minja::Value::operator-(void)
loc_3EA8A:
lea r14, [rsp+78h+var_30]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [r14-8]
test rdi, rdi
jz short loc_3EAAF
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_3EAAF:
mov rdi, [rsp+78h+var_48]
test rdi, rdi
jz short loc_3EABE
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_3EABE:
mov rdi, [rsp+78h+var_58]
test rdi, rdi
jz short loc_3EACD
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_3EACD:
mov rdi, [rsp+78h+var_68]
test rdi, rdi
jz short loc_3EB03
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_3EAEE
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_3EAF8
loc_3EAEE:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_3EAF8:
cmp eax, 1
jnz short loc_3EB03
mov rax, [rdi]
call qword ptr [rax+18h]
loc_3EB03:
mov rax, rbx
add rsp, 58h
pop rbx
pop r12
pop r14
pop r15
retn
loc_3EB12:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aUnaryopexprExp; "UnaryOpExpr.expr is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_3EB44:
mov edi, 10h; jumptable 000000000003E9CE cases 3,4
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aExpansionOpera; "Expansion operator is only supported in"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_3EB7E
def_3E9CE:
mov edi, 10h; jumptable 000000000003E9CE default case
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aUnknownUnaryOp; "Unknown unary operator"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_3EB7E:
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short loc_3EB98
jmp short loc_3EBB2
loc_3EB98:
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_3EBB5
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_3EBBF
loc_3EBB2:
mov rbx, rax
loc_3EBB5:
lea rdi, [rsp+78h+var_70]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_3EBBF:
mov rdi, rbx
call __Unwind_Resume
| do_evaluate:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R14,RSI
MOV RSI,qword ptr [RSI + 0x20]
TEST RSI,RSI
JZ 0x0013eb12
MOV RBX,RDI
LEA RDI,[RSP + 0x8]
CALL 0x0013ec5a
MOV EAX,dword ptr [R14 + 0x30]
CMP RAX,0x4
JA 0x0013eb62
LEA RCX,[0x1b1128]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
XOR R12D,R12D
MOV qword ptr [RBX + 0x18],R12
LEA R15,[RSP + 0x48]
MOVUPS XMM0,xmmword ptr [R15 + -0x30]
MOV qword ptr [R15 + -0x28],R12
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOV qword ptr [R15 + -0x30],R12
MOV qword ptr [RBX + 0x28],R12
MOVUPS XMM0,xmmword ptr [R15 + -0x20]
MOV qword ptr [R15 + -0x18],R12
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOV qword ptr [R15 + -0x20],R12
MOV qword ptr [RBX + 0x38],R12
MOVUPS XMM0,xmmword ptr [R15 + -0x10]
MOV qword ptr [R15 + -0x8],R12
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOV qword ptr [R15 + -0x10],R12
LEA R14,[RBX + 0x40]
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RBX + 0x40],XMM0
MOV RDI,R15
XOR ESI,ESI
CALL 0x0013efdc
MOV byte ptr [R15],0x0
MOV qword ptr [R15 + 0x8],R12
JMP 0x0013ea6e
caseD_2:
LEA RDI,[RSP + 0x8]
CALL 0x0013ee5c
XOR AL,0x1
LEA R14,[RBX + 0x40]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x40],XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX],XMM0
MOVZX ESI,AL
MOV RDI,R14
CALL 0x00141084
LAB_0013ea6e:
MOV RDI,R14
MOV ESI,0x1
CALL 0x0013efdc
JMP 0x0013ea8a
caseD_1:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x0013edd8
LAB_0013ea8a:
LEA R14,[RSP + 0x48]
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013efdc
MOV RDI,R14
CALL 0x0014bfb8
MOV RDI,qword ptr [R14 + -0x8]
TEST RDI,RDI
JZ 0x0013eaaf
CALL 0x00130e64
LAB_0013eaaf:
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x0013eabe
CALL 0x00130e64
LAB_0013eabe:
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x0013eacd
CALL 0x00130e64
LAB_0013eacd:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x0013eb03
MOV RAX,qword ptr [0x001f2fa0]
CMP byte ptr [RAX],0x0
JZ 0x0013eaee
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x0013eaf8
LAB_0013eaee:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_0013eaf8:
CMP EAX,0x1
JNZ 0x0013eb03
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_0013eb03:
MOV RAX,RBX
ADD RSP,0x58
POP RBX
POP R12
POP R14
POP R15
RET
LAB_0013eb12:
MOV EDI,0x10
CALL 0x00118360
MOV R14,RAX
LAB_0013eb1f:
LEA RSI,[0x1bad72]
MOV RDI,RAX
CALL 0x00118270
LAB_0013eb2e:
MOV RSI,qword ptr [0x001f2ff0]
MOV RDX,qword ptr [0x001f2f80]
MOV RDI,R14
CALL 0x00118b30
caseD_3:
MOV EDI,0x10
CALL 0x00118360
MOV R14,RAX
LAB_0013eb51:
LEA RSI,[0x1bad8b]
MOV RDI,RAX
CALL 0x00118270
LAB_0013eb60:
JMP 0x0013eb7e
default:
MOV EDI,0x10
CALL 0x00118360
MOV R14,RAX
LAB_0013eb6f:
LEA RSI,[0x1badd2]
MOV RDI,RAX
CALL 0x00118270
LAB_0013eb7e:
MOV RSI,qword ptr [0x001f2ff0]
MOV RDX,qword ptr [0x001f2f80]
MOV RDI,R14
CALL 0x00118b30
|
/* minja::UnaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const */
UnaryOpExpr * __thiscall minja::UnaryOpExpr::do_evaluate(UnaryOpExpr *this,shared_ptr *param_1)
{
int *piVar1;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Var2;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Var3;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Var4;
byte bVar5;
int iVar6;
runtime_error *prVar7;
Expression local_70 [8];
long *local_68;
int8 local_60;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Stack_58;
int8 local_50;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Stack_48;
int8 local_40;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Stack_38;
data local_30;
int7 uStack_2f;
int8 uStack_28;
if (*(shared_ptr **)(param_1 + 0x20) == (shared_ptr *)0x0) {
prVar7 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0013eb1f to 0013eb2d has its CatchHandler @ 0013eba5 */
std::runtime_error::runtime_error(prVar7,"UnaryOpExpr.expr is null");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar7,PTR_typeinfo_001f2ff0,PTR__runtime_error_001f2f80);
}
Expression::evaluate(local_70,*(shared_ptr **)(param_1 + 0x20));
p_Var4 = p_Stack_38;
p_Var3 = p_Stack_48;
p_Var2 = p_Stack_58;
switch(*(int4 *)(param_1 + 0x30)) {
case 0:
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x18) = 0;
p_Stack_58 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0;
*(int8 *)(this + 0x10) = local_60;
*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18) = p_Var2;
local_60 = 0;
*(int8 *)(this + 0x28) = 0;
p_Stack_48 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0;
*(int8 *)(this + 0x20) = local_50;
*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x28) = p_Var3;
local_50 = 0;
*(int8 *)(this + 0x38) = 0;
p_Stack_38 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0;
*(int8 *)(this + 0x30) = local_40;
*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38) = p_Var4;
local_40 = 0;
*(ulong *)(this + 0x40) = CONCAT71(uStack_2f,local_30);
*(int8 *)(this + 0x48) = uStack_28;
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(&local_30,0));
local_30 = (data)0x0;
uStack_28 = 0;
break;
case 1:
/* try { // try from 0013ea7d to 0013ea89 has its CatchHandler @ 0013ebb2 */
minja::Value::operator-((Value *)this);
goto LAB_0013ea8a;
case 2:
/* try { // try from 0013ea3d to 0013ea46 has its CatchHandler @ 0013eb96 */
bVar5 = minja::Value::to_bool((Value *)local_70);
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
nlohmann::json_abi_v3_11_3::detail::
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::
construct<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 + 0x40,bVar5 ^ 1);
break;
case 3:
case 4:
prVar7 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0013eb51 to 0013eb5f has its CatchHandler @ 0013eb98 */
std::runtime_error::runtime_error
(prVar7,"Expansion operator is only supported in function calls and collections");
goto LAB_0013eb7e;
default:
prVar7 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0013eb6f to 0013eb7d has its CatchHandler @ 0013eb94 */
std::runtime_error::runtime_error(prVar7,"Unknown unary operator");
LAB_0013eb7e:
/* try { // try from 0013eb7e to 0013eb93 has its CatchHandler @ 0013ebb2 */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar7,PTR_typeinfo_001f2ff0,PTR__runtime_error_001f2f80);
}
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((bool)((char)this + '@'));
LAB_0013ea8a:
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(&local_30,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>
::data::~data(&local_30);
if (p_Stack_38 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Stack_38);
}
if (p_Stack_48 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Stack_48);
}
if (p_Stack_58 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Stack_58);
}
if (local_68 != (long *)0x0) {
if (*PTR___libc_single_threaded_001f2fa0 == '\0') {
LOCK();
piVar1 = (int *)((long)local_68 + 0xc);
iVar6 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar6 = *(int *)((long)local_68 + 0xc);
*(int *)((long)local_68 + 0xc) = iVar6 + -1;
}
if (iVar6 == 1) {
(**(code **)(*local_68 + 0x18))();
}
}
return this;
}
| ||
54,191 | my_strnncollsp_8bit_bin | eloqsql/strings/ctype-bin.c | static int my_strnncollsp_8bit_bin(CHARSET_INFO * cs __attribute__((unused)),
const uchar *a, size_t a_length,
const uchar *b, size_t b_length)
{
const uchar *end;
size_t length;
end= a + (length= MY_MIN(a_length, b_length));
while (a < end)
{
if (*a++ != *b++)
return ((int) a[-1] - (int) b[-1]);
}
return a_length == b_length ? 0 :
a_length < b_length ?
-my_strnncollsp_padspace_bin(b, b_length - length) :
my_strnncollsp_padspace_bin(a, a_length - length);
} | O3 | c | my_strnncollsp_8bit_bin:
pushq %rbp
movq %rsp, %rbp
cmpq %r8, %rdx
movq %r8, %rdi
cmovbq %rdx, %rdi
leaq (%rsi,%rdi), %r9
cmpq %r9, %rsi
jae 0xb2651
movzbl (%rsi), %eax
incq %rsi
movzbl (%rcx), %r10d
incq %rcx
cmpb %r10b, %al
je 0xb2635
subl %r10d, %eax
jmp 0xb2658
xorl %eax, %eax
cmpq %r8, %rdx
jne 0xb265a
popq %rbp
retq
jae 0xb2677
subq %rdi, %r8
je 0xb2658
xorl %edx, %edx
xorl %eax, %eax
cmpb $0x20, (%rcx,%rdx)
jb 0xb2692
jne 0xb2699
incq %rdx
cmpq %rdx, %r8
jne 0xb2665
jmp 0xb2658
subq %rdi, %rdx
je 0xb2658
xorl %ecx, %ecx
xorl %eax, %eax
cmpb $0x20, (%rsi,%rcx)
jb 0xb2699
jne 0xb2692
incq %rcx
cmpq %rcx, %rdx
jne 0xb2680
jmp 0xb2658
movl $0x1, %eax
jmp 0xb2658
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0xb2658
| my_strnncollsp_8bit_bin:
push rbp
mov rbp, rsp
cmp rdx, r8
mov rdi, r8
cmovb rdi, rdx
lea r9, [rsi+rdi]
loc_B2635:
cmp rsi, r9
jnb short loc_B2651
movzx eax, byte ptr [rsi]
inc rsi
movzx r10d, byte ptr [rcx]
inc rcx
cmp al, r10b
jz short loc_B2635
sub eax, r10d
jmp short loc_B2658
loc_B2651:
xor eax, eax
cmp rdx, r8
jnz short loc_B265A
loc_B2658:
pop rbp
retn
loc_B265A:
jnb short loc_B2677
sub r8, rdi
jz short loc_B2658
xor edx, edx
xor eax, eax
loc_B2665:
cmp byte ptr [rcx+rdx], 20h ; ' '
jb short loc_B2692
jnz short loc_B2699
inc rdx
cmp r8, rdx
jnz short loc_B2665
jmp short loc_B2658
loc_B2677:
sub rdx, rdi
jz short loc_B2658
xor ecx, ecx
xor eax, eax
loc_B2680:
cmp byte ptr [rsi+rcx], 20h ; ' '
jb short loc_B2699
jnz short loc_B2692
inc rcx
cmp rdx, rcx
jnz short loc_B2680
jmp short loc_B2658
loc_B2692:
mov eax, 1
jmp short loc_B2658
loc_B2699:
mov eax, 0FFFFFFFFh
jmp short loc_B2658
| long long my_strnncollsp_8bit_bin(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned __int8 *a4,
unsigned long long a5)
{
unsigned long long v5; // rdi
unsigned __int8 *v6; // r9
int v7; // eax
int v8; // r10d
long long result; // rax
unsigned long long v10; // r8
long long v11; // rdx
unsigned long long v12; // rdx
long long v13; // rcx
v5 = a5;
if ( a3 < a5 )
v5 = a3;
v6 = &a2[v5];
while ( a2 < v6 )
{
v7 = *a2++;
v8 = *a4++;
if ( (_BYTE)v7 != (_BYTE)v8 )
return (unsigned int)(v7 - v8);
}
result = 0LL;
if ( a3 != a5 )
{
if ( a3 >= a5 )
{
v12 = a3 - v5;
if ( v12 )
{
v13 = 0LL;
result = 0LL;
while ( a2[v13] >= 0x20u )
{
if ( a2[v13] != 32 )
return 1LL;
if ( v12 == ++v13 )
return result;
}
return 0xFFFFFFFFLL;
}
}
else
{
v10 = a5 - v5;
if ( v10 )
{
v11 = 0LL;
result = 0LL;
while ( a4[v11] >= 0x20u )
{
if ( a4[v11] != 32 )
return 0xFFFFFFFFLL;
if ( v10 == ++v11 )
return result;
}
return 1LL;
}
}
}
return result;
}
| my_strnncollsp_8bit_bin:
PUSH RBP
MOV RBP,RSP
CMP RDX,R8
MOV RDI,R8
CMOVC RDI,RDX
LEA R9,[RSI + RDI*0x1]
LAB_001b2635:
CMP RSI,R9
JNC 0x001b2651
MOVZX EAX,byte ptr [RSI]
INC RSI
MOVZX R10D,byte ptr [RCX]
INC RCX
CMP AL,R10B
JZ 0x001b2635
SUB EAX,R10D
JMP 0x001b2658
LAB_001b2651:
XOR EAX,EAX
CMP RDX,R8
JNZ 0x001b265a
LAB_001b2658:
POP RBP
RET
LAB_001b265a:
JNC 0x001b2677
SUB R8,RDI
JZ 0x001b2658
XOR EDX,EDX
XOR EAX,EAX
LAB_001b2665:
CMP byte ptr [RCX + RDX*0x1],0x20
JC 0x001b2692
JNZ 0x001b2699
INC RDX
CMP R8,RDX
JNZ 0x001b2665
JMP 0x001b2658
LAB_001b2677:
SUB RDX,RDI
JZ 0x001b2658
XOR ECX,ECX
XOR EAX,EAX
LAB_001b2680:
CMP byte ptr [RSI + RCX*0x1],0x20
JC 0x001b2699
JNZ 0x001b2692
INC RCX
CMP RDX,RCX
JNZ 0x001b2680
JMP 0x001b2658
LAB_001b2692:
MOV EAX,0x1
JMP 0x001b2658
LAB_001b2699:
MOV EAX,0xffffffff
JMP 0x001b2658
|
int my_strnncollsp_8bit_bin
(int8 param_1,byte *param_2,ulong param_3,byte *param_4,ulong param_5)
{
byte *pbVar1;
byte bVar2;
byte bVar3;
long lVar4;
ulong uVar5;
uVar5 = param_5;
if (param_3 < param_5) {
uVar5 = param_3;
}
pbVar1 = param_2 + uVar5;
while (param_2 < pbVar1) {
bVar2 = *param_2;
param_2 = param_2 + 1;
bVar3 = *param_4;
param_4 = param_4 + 1;
if (bVar2 != bVar3) {
return (uint)bVar2 - (uint)bVar3;
}
}
if (param_3 == param_5) {
return 0;
}
if (param_3 < param_5) {
if (param_5 == uVar5) {
return 0;
}
lVar4 = 0;
while( true ) {
if (param_4[lVar4] < 0x20) {
return 1;
}
if (param_4[lVar4] != 0x20) break;
lVar4 = lVar4 + 1;
if (param_5 - uVar5 == lVar4) {
return 0;
}
}
return -1;
}
if (param_3 != uVar5) {
lVar4 = 0;
while( true ) {
if (param_2[lVar4] < 0x20) {
return -1;
}
if (param_2[lVar4] != 0x20) break;
lVar4 = lVar4 + 1;
if (param_3 - uVar5 == lVar4) {
return 0;
}
}
return 1;
}
return 0;
}
| |
54,192 | ma_close | eloqsql/libmariadb/libmariadb/ma_io.c | int ma_close(MA_FILE *file)
{
int rc;
if (!file)
return -1;
switch (file->type) {
case MA_FILE_LOCAL:
rc= fclose((FILE *)file->ptr);
free(file);
break;
#ifdef HAVE_REMOTEIO
case MA_FILE_REMOTE:
rc= rio_plugin->methods->mclose(file);
break;
#endif
default:
return -1;
}
return rc;
} | O0 | c | ma_close:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x681fc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6825d
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
subl $0x1, %eax
je 0x68216
jmp 0x6820c
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0x68231
jmp 0x6824e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x38450
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x381b0
jmp 0x68257
leaq 0x39c158(%rip), %rax # 0x404390
movq (%rax), %rax
movq 0x58(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movl %eax, -0x14(%rbp)
jmp 0x68257
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6825d
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ma_close:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
cmp [rbp+var_10], 0
jnz short loc_681FC
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_6825D
loc_681FC:
mov rax, [rbp+var_10]
mov eax, [rax]
mov [rbp+var_18], eax
sub eax, 1
jz short loc_68216
jmp short $+2
loc_6820C:
mov eax, [rbp+var_18]
sub eax, 2
jz short loc_68231
jmp short loc_6824E
loc_68216:
mov rax, [rbp+var_10]
mov rdi, [rax+8]
call _fclose
mov [rbp+var_14], eax
mov rdi, [rbp+var_10]
call _free
jmp short loc_68257
loc_68231:
lea rax, rio_plugin
mov rax, [rax]
mov rax, [rax+58h]
mov rax, [rax+8]
mov rdi, [rbp+var_10]
call rax
mov [rbp+var_14], eax
jmp short loc_68257
loc_6824E:
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_6825D
loc_68257:
mov eax, [rbp+var_14]
mov [rbp+var_4], eax
loc_6825D:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long ma_close(long long a1)
{
unsigned int v2; // [rsp+Ch] [rbp-14h]
if ( a1 )
{
if ( *(_DWORD *)a1 == 1 )
{
v2 = fclose(*(_QWORD *)(a1 + 8));
free(a1);
}
else
{
if ( *(_DWORD *)a1 != 2 )
return (unsigned int)-1;
return (unsigned int)(*(long long ( **)(long long))(*(_QWORD *)(rio_plugin + 88LL) + 8LL))(a1);
}
return v2;
}
return (unsigned int)-1;
}
| ma_close:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x001681fc
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0016825d
LAB_001681fc:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x18],EAX
SUB EAX,0x1
JZ 0x00168216
JMP 0x0016820c
LAB_0016820c:
MOV EAX,dword ptr [RBP + -0x18]
SUB EAX,0x2
JZ 0x00168231
JMP 0x0016824e
LAB_00168216:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x00138450
MOV dword ptr [RBP + -0x14],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001381b0
JMP 0x00168257
LAB_00168231:
LEA RAX,[0x504390]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x58]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x10]
CALL RAX
MOV dword ptr [RBP + -0x14],EAX
JMP 0x00168257
LAB_0016824e:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0016825d
LAB_00168257:
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x4],EAX
LAB_0016825d:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int ma_close(int *param_1)
{
int local_1c;
int local_c;
if (param_1 == (int *)0x0) {
local_c = -1;
}
else {
if (*param_1 == 1) {
local_1c = fclose(*(FILE **)(param_1 + 2));
free(param_1);
}
else {
if (*param_1 != 2) {
return -1;
}
local_1c = (**(code **)(*(long *)(rio_plugin + 0x58) + 8))(param_1);
}
local_c = local_1c;
}
return local_c;
}
| |
54,193 | google::protobuf::EnumValueDescriptor* google::protobuf::(anonymous namespace)::FlatAllocatorImpl<char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, google::protobuf::SourceCodeInfo, google::protobuf::FileDescriptorTables, google::protobuf::MessageOptions, google::protobuf::FieldOptions, google::protobuf::EnumOptions, google::protobuf::EnumValueOptions, google::protobuf::ExtensionRangeOptions, google::protobuf::OneofOptions, google::protobuf::ServiceOptions, google::protobuf::MethodOptions, google::protobuf::FileOptions>::AllocateArray<google::protobuf::EnumValueDescriptor>(int) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc | U* AllocateArray(int array_size) {
constexpr bool trivial = std::is_trivially_destructible<U>::value;
using TypeToUse = typename std::conditional<trivial, char, U>::type;
// We can only allocate after FinalizePlanning has been called.
GOOGLE_CHECK(has_allocated());
TypeToUse*& data = pointers_.template Get<TypeToUse>();
int& used = used_.template Get<TypeToUse>();
U* res = reinterpret_cast<U*>(data + used);
used += trivial ? RoundUpTo<8>(array_size * sizeof(U)) : array_size;
GOOGLE_CHECK_LE(used, total_.template Get<TypeToUse>());
return res;
} | O0 | cpp | google::protobuf::EnumValueDescriptor* google::protobuf::(anonymous namespace)::FlatAllocatorImpl<char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, google::protobuf::SourceCodeInfo, google::protobuf::FileDescriptorTables, google::protobuf::MessageOptions, google::protobuf::FieldOptions, google::protobuf::EnumOptions, google::protobuf::EnumValueOptions, google::protobuf::ExtensionRangeOptions, google::protobuf::OneofOptions, google::protobuf::ServiceOptions, google::protobuf::MethodOptions, google::protobuf::FileOptions>::AllocateArray<google::protobuf::EnumValueDescriptor>(int):
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movl %esi, 0xdc(%rsp)
movq 0xe0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movb $0x0, 0xdb(%rsp)
callq 0x271c00
movb $0x0, 0x9f(%rsp)
testb $0x1, %al
jne 0x27dfee
jmp 0x27dff0
jmp 0x27e049
leaq 0x16e1dc(%rip), %rdx # 0x3ec1d3
leaq 0xa0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x3, %esi
movl $0x187, %ecx # imm = 0x187
callq 0x19a670
movq 0x18(%rsp), %rdi
movb $0x1, 0x9f(%rsp)
leaq 0x170858(%rip), %rsi # 0x3ee87f
callq 0x199f30
movq %rax, 0x20(%rsp)
jmp 0x27e033
movq 0x20(%rsp), %rsi
leaq 0x8b(%rsp), %rdi
callq 0x19a0e0
jmp 0x27e047
jmp 0x27e049
testb $0x1, 0x9f(%rsp)
jne 0x27e055
jmp 0x27e062
leaq 0xa0(%rsp), %rdi
callq 0x19a6b0
movq 0x28(%rsp), %rdi
callq 0x27a280
movq 0x28(%rsp), %rdi
movq %rax, 0x80(%rsp)
addq $0x9c, %rdi
callq 0x273c40
movq 0x28(%rsp), %rdi
movq %rax, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq (%rax), %rax
movq 0x78(%rsp), %rcx
movslq (%rcx), %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x70(%rsp)
movslq 0xdc(%rsp), %rdx
movq 0x78(%rsp), %rax
movslq (%rax), %rcx
addq %rdx, %rcx
movl %ecx, (%rax)
movq 0x78(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x14(%rsp)
addq $0x68, %rdi
callq 0x273c40
movq %rax, %rcx
movl 0x14(%rsp), %eax
movl (%rcx), %ecx
movb $0x0, 0x37(%rsp)
cmpl %ecx, %eax
jg 0x27e0eb
jmp 0x27e139
leaq 0x16e0e1(%rip), %rdx # 0x3ec1d3
leaq 0x38(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x3, %esi
movl $0x18d, %ecx # imm = 0x18D
callq 0x19a670
movq (%rsp), %rdi
movb $0x1, 0x37(%rsp)
leaq 0x170785(%rip), %rsi # 0x3ee89f
callq 0x199f30
movq %rax, 0x8(%rsp)
jmp 0x27e126
movq 0x8(%rsp), %rsi
leaq 0x36(%rsp), %rdi
callq 0x19a0e0
jmp 0x27e137
jmp 0x27e139
testb $0x1, 0x37(%rsp)
jne 0x27e142
jmp 0x27e14c
leaq 0x38(%rsp), %rdi
callq 0x19a6b0
movq 0x70(%rsp), %rax
addq $0xe8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
testb $0x1, 0x9f(%rsp)
jne 0x27e179
jmp 0x27e186
leaq 0xa0(%rsp), %rdi
callq 0x19a6b0
jmp 0x27e1b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x27e1a5
jmp 0x27e1af
leaq 0x38(%rsp), %rdi
callq 0x19a6b0
jmp 0x27e1b1
movq 0x90(%rsp), %rdi
callq 0x90db0
nop
| _ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE13AllocateArrayISH_EEPT_i:
sub rsp, 0E8h
mov [rsp+0E8h+var_8], rdi
mov [rsp+0E8h+var_C], esi
mov rdi, [rsp+0E8h+var_8]
mov [rsp+0E8h+var_C0], rdi
mov [rsp+0E8h+var_D], 0
call _ZNK6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE13has_allocatedEv; google::protobuf::`anonymous namespace'::FlatAllocatorImpl<char,std::string,google::protobuf::SourceCodeInfo,google::protobuf::FileDescriptorTables,google::protobuf::MessageOptions,google::protobuf::FieldOptions,google::protobuf::EnumOptions,google::protobuf::EnumValueOptions,google::protobuf::ExtensionRangeOptions,google::protobuf::OneofOptions,google::protobuf::ServiceOptions,google::protobuf::MethodOptions,google::protobuf::FileOptions>::has_allocated(void)
mov [rsp+0E8h+var_49], 0
test al, 1
jnz short loc_27DFEE
jmp short loc_27DFF0
loc_27DFEE:
jmp short loc_27E049
loc_27DFF0:
lea rdx, aWorkspaceLlm4b_54; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+0E8h+var_48]
mov [rsp+0E8h+var_D0], rdi
mov esi, 3
mov ecx, 187h
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+0E8h+var_D0]
mov [rsp+0E8h+var_49], 1
lea rsi, aCheckFailedHas_6; "CHECK failed: has_allocated(): "
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+0E8h+var_C8], rax
jmp short $+2
loc_27E033:
mov rsi, [rsp+0E8h+var_C8]
lea rdi, [rsp+0E8h+var_5D]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_27E047:
jmp short $+2
loc_27E049:
test [rsp+0E8h+var_49], 1
jnz short loc_27E055
jmp short loc_27E062
loc_27E055:
lea rdi, [rsp+0E8h+var_48]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_27E062:
mov rdi, [rsp+0E8h+var_C0]
call _ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_8PointerTEJcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISI_EERPT_v; google::protobuf::`anonymous namespace'::TypeMap<google::protobuf::`anonymous namespace'::PointerT,char,std::string,google::protobuf::SourceCodeInfo,google::protobuf::FileDescriptorTables,google::protobuf::MessageOptions,google::protobuf::FieldOptions,google::protobuf::EnumOptions,google::protobuf::EnumValueOptions,google::protobuf::ExtensionRangeOptions,google::protobuf::OneofOptions,google::protobuf::ServiceOptions,google::protobuf::MethodOptions,google::protobuf::FileOptions>::Get<google::protobuf::ServiceOptions>(void)
mov rdi, [rsp+0E8h+var_C0]
mov [rsp+0E8h+var_68], rax
add rdi, 9Ch
call _ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISI_EERiv; google::protobuf::`anonymous namespace'::TypeMap<google::protobuf::`anonymous namespace'::IntT,char,std::string,google::protobuf::SourceCodeInfo,google::protobuf::FileDescriptorTables,google::protobuf::MessageOptions,google::protobuf::FieldOptions,google::protobuf::EnumOptions,google::protobuf::EnumValueOptions,google::protobuf::ExtensionRangeOptions,google::protobuf::OneofOptions,google::protobuf::ServiceOptions,google::protobuf::MethodOptions,google::protobuf::FileOptions>::Get<google::protobuf::ServiceOptions>(void)
mov rdi, [rsp+0E8h+var_C0]
mov [rsp+0E8h+var_70], rax
mov rax, [rsp+0E8h+var_68]
mov rax, [rax]
mov rcx, [rsp+0E8h+var_70]
movsxd rcx, dword ptr [rcx]
imul rcx, 50h ; 'P'
add rax, rcx
mov [rsp+0E8h+var_78], rax
movsxd rdx, [rsp+0E8h+var_C]
mov rax, [rsp+0E8h+var_70]
movsxd rcx, dword ptr [rax]
add rcx, rdx
mov [rax], ecx
mov rax, [rsp+0E8h+var_70]
mov eax, [rax]
mov [rsp+0E8h+var_D4], eax
add rdi, 68h ; 'h'
call _ZN6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISI_EERiv; google::protobuf::`anonymous namespace'::TypeMap<google::protobuf::`anonymous namespace'::IntT,char,std::string,google::protobuf::SourceCodeInfo,google::protobuf::FileDescriptorTables,google::protobuf::MessageOptions,google::protobuf::FieldOptions,google::protobuf::EnumOptions,google::protobuf::EnumValueOptions,google::protobuf::ExtensionRangeOptions,google::protobuf::OneofOptions,google::protobuf::ServiceOptions,google::protobuf::MethodOptions,google::protobuf::FileOptions>::Get<google::protobuf::ServiceOptions>(void)
mov rcx, rax
mov eax, [rsp+0E8h+var_D4]
mov ecx, [rcx]
mov [rsp+0E8h+var_B1], 0
cmp eax, ecx
jg short loc_27E0EB
jmp short loc_27E139
loc_27E0EB:
lea rdx, aWorkspaceLlm4b_54; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+0E8h+var_B0]
mov [rsp+0E8h+var_E8], rdi
mov esi, 3
mov ecx, 18Dh
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+0E8h+var_E8]
mov [rsp+0E8h+var_B1], 1
lea rsi, aCheckFailedUse; "CHECK failed: (used) <= (total_.templat"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+0E8h+var_E0], rax
jmp short $+2
loc_27E126:
mov rsi, [rsp+0E8h+var_E0]
lea rdi, [rsp+0E8h+var_B2]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_27E137:
jmp short $+2
loc_27E139:
test [rsp+0E8h+var_B1], 1
jnz short loc_27E142
jmp short loc_27E14C
loc_27E142:
lea rdi, [rsp+0E8h+var_B0]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_27E14C:
mov rax, [rsp+0E8h+var_78]
add rsp, 0E8h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_88], rcx
mov [rsp+arg_84], eax
test [rsp+arg_97], 1
jnz short loc_27E179
jmp short loc_27E186
loc_27E179:
lea rdi, [rsp+arg_98]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_27E186:
jmp short loc_27E1B1
mov rcx, rax
mov eax, edx
mov [rsp+arg_88], rcx
mov [rsp+arg_84], eax
test [rsp+arg_2F], 1
jnz short loc_27E1A5
jmp short loc_27E1AF
loc_27E1A5:
lea rdi, [rsp+arg_30]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_27E1AF:
jmp short $+2
loc_27E1B1:
mov rdi, [rsp+arg_88]
call __Unwind_Resume
| long long google::protobuf::`anonymous namespace'::FlatAllocatorImpl<char,std::string,google::protobuf::SourceCodeInfo,google::protobuf::FileDescriptorTables,google::protobuf::MessageOptions,google::protobuf::FieldOptions,google::protobuf::EnumOptions,google::protobuf::EnumValueOptions,google::protobuf::ExtensionRangeOptions,google::protobuf::OneofOptions,google::protobuf::ServiceOptions,google::protobuf::MethodOptions,google::protobuf::FileOptions>::AllocateArray<google::protobuf::ServiceOptions>(
long long a1,
int a2)
{
int v2; // ecx
google::protobuf::internal::LogMessage *v4; // [rsp+8h] [rbp-E0h]
int v5; // [rsp+14h] [rbp-D4h]
google::protobuf::internal::LogMessage *v6; // [rsp+20h] [rbp-C8h]
char v7; // [rsp+36h] [rbp-B2h] BYREF
char v8; // [rsp+37h] [rbp-B1h]
_BYTE v9[56]; // [rsp+38h] [rbp-B0h] BYREF
long long v10; // [rsp+70h] [rbp-78h]
int *v11; // [rsp+78h] [rbp-70h]
_QWORD *v12; // [rsp+80h] [rbp-68h]
_BYTE v13[20]; // [rsp+8Bh] [rbp-5Dh] BYREF
char v14; // [rsp+9Fh] [rbp-49h]
_BYTE v15[60]; // [rsp+A0h] [rbp-48h] BYREF
int v16; // [rsp+DCh] [rbp-Ch]
long long v17; // [rsp+E0h] [rbp-8h]
v17 = a1;
v16 = a2;
v15[59] = 0;
v14 = 0;
if ( !google::protobuf::`anonymous namespace'::FlatAllocatorImpl<char,std::string,google::protobuf::SourceCodeInfo,google::protobuf::FileDescriptorTables,google::protobuf::MessageOptions,google::protobuf::FieldOptions,google::protobuf::EnumOptions,google::protobuf::EnumValueOptions,google::protobuf::ExtensionRangeOptions,google::protobuf::OneofOptions,google::protobuf::ServiceOptions,google::protobuf::MethodOptions,google::protobuf::FileOptions>::has_allocated(a1) )
{
google::protobuf::internal::LogMessage::LogMessage(
(long long)v15,
3,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc",
391);
v14 = 1;
v6 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(
(long long)v15,
(long long)"CHECK failed: has_allocated(): ");
google::protobuf::internal::LogFinisher::operator=((long long)v13, v6);
}
if ( (v14 & 1) != 0 )
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v15);
v12 = (_QWORD *)google::protobuf::`anonymous namespace'::TypeMap<google::protobuf::`anonymous namespace'::PointerT,char,std::string,google::protobuf::SourceCodeInfo,google::protobuf::FileDescriptorTables,google::protobuf::MessageOptions,google::protobuf::FieldOptions,google::protobuf::EnumOptions,google::protobuf::EnumValueOptions,google::protobuf::ExtensionRangeOptions,google::protobuf::OneofOptions,google::protobuf::ServiceOptions,google::protobuf::MethodOptions,google::protobuf::FileOptions>::Get<google::protobuf::ServiceOptions>(a1);
v11 = (int *)google::protobuf::`anonymous namespace'::TypeMap<google::protobuf::`anonymous namespace'::IntT,char,std::string,google::protobuf::SourceCodeInfo,google::protobuf::FileDescriptorTables,google::protobuf::MessageOptions,google::protobuf::FieldOptions,google::protobuf::EnumOptions,google::protobuf::EnumValueOptions,google::protobuf::ExtensionRangeOptions,google::protobuf::OneofOptions,google::protobuf::ServiceOptions,google::protobuf::MethodOptions,google::protobuf::FileOptions>::Get<google::protobuf::ServiceOptions>(a1 + 156);
v10 = 80LL * *v11 + *v12;
*v11 += v16;
v5 = *v11;
v2 = *(_DWORD *)google::protobuf::`anonymous namespace'::TypeMap<google::protobuf::`anonymous namespace'::IntT,char,std::string,google::protobuf::SourceCodeInfo,google::protobuf::FileDescriptorTables,google::protobuf::MessageOptions,google::protobuf::FieldOptions,google::protobuf::EnumOptions,google::protobuf::EnumValueOptions,google::protobuf::ExtensionRangeOptions,google::protobuf::OneofOptions,google::protobuf::ServiceOptions,google::protobuf::MethodOptions,google::protobuf::FileOptions>::Get<google::protobuf::ServiceOptions>(a1 + 104);
v8 = 0;
if ( v5 > v2 )
{
google::protobuf::internal::LogMessage::LogMessage(
(long long)v9,
3,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc",
397);
v8 = 1;
v4 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(
(long long)v9,
(long long)"CHECK failed: (used) <= (total_.template Get<TypeToUse>()): ");
google::protobuf::internal::LogFinisher::operator=((long long)&v7, v4);
}
if ( (v8 & 1) != 0 )
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v9);
return v10;
}
| |||
54,194 | google::protobuf::EnumValueDescriptor* google::protobuf::(anonymous namespace)::FlatAllocatorImpl<char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, google::protobuf::SourceCodeInfo, google::protobuf::FileDescriptorTables, google::protobuf::MessageOptions, google::protobuf::FieldOptions, google::protobuf::EnumOptions, google::protobuf::EnumValueOptions, google::protobuf::ExtensionRangeOptions, google::protobuf::OneofOptions, google::protobuf::ServiceOptions, google::protobuf::MethodOptions, google::protobuf::FileOptions>::AllocateArray<google::protobuf::EnumValueDescriptor>(int) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc | U* AllocateArray(int array_size) {
constexpr bool trivial = std::is_trivially_destructible<U>::value;
using TypeToUse = typename std::conditional<trivial, char, U>::type;
// We can only allocate after FinalizePlanning has been called.
GOOGLE_CHECK(has_allocated());
TypeToUse*& data = pointers_.template Get<TypeToUse>();
int& used = used_.template Get<TypeToUse>();
U* res = reinterpret_cast<U*>(data + used);
used += trivial ? RoundUpTo<8>(array_size * sizeof(U)) : array_size;
GOOGLE_CHECK_LE(used, total_.template Get<TypeToUse>());
return res;
} | O3 | cpp | google::protobuf::EnumValueDescriptor* google::protobuf::(anonymous namespace)::FlatAllocatorImpl<char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, google::protobuf::SourceCodeInfo, google::protobuf::FileDescriptorTables, google::protobuf::MessageOptions, google::protobuf::FieldOptions, google::protobuf::EnumOptions, google::protobuf::EnumValueOptions, google::protobuf::ExtensionRangeOptions, google::protobuf::OneofOptions, google::protobuf::ServiceOptions, google::protobuf::MethodOptions, google::protobuf::FileOptions>::AllocateArray<google::protobuf::EnumValueDescriptor>(int):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %r15d
movq %rdi, %r14
movq (%rdi), %rbx
testq %rbx, %rbx
jne 0xd3474
leaq 0x98a5f(%rip), %rdx # 0x16be93
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x3, %esi
movl $0x187, %ecx # imm = 0x187
callq 0x857c2
leaq 0x9b07e(%rip), %rsi # 0x16e4d0
movq %rbx, %rdi
callq 0x852c0
leaq 0xf(%rsp), %rdi
movq %rax, %rsi
callq 0x8539a
leaq 0x10(%rsp), %rdi
callq 0x857e0
movq (%r14), %rbx
movslq 0x9c(%r14), %r12
leal (%r12,%r15,8), %eax
movl %eax, 0x9c(%r14)
cmpl 0x68(%r14), %eax
jle 0xd34d0
leaq 0x98a00(%rip), %rdx # 0x16be93
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl $0x3, %esi
movl $0x18d, %ecx # imm = 0x18D
callq 0x857c2
leaq 0x9b03f(%rip), %rsi # 0x16e4f0
movq %r14, %rdi
callq 0x852c0
leaq 0xf(%rsp), %rdi
movq %rax, %rsi
callq 0x8539a
leaq 0x10(%rsp), %rdi
callq 0x857e0
addq %r12, %rbx
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xd34e8
jmp 0xd34e8
jmp 0xd34e8
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x857e0
movq %rbx, %rdi
callq 0x2e220
nop
| _ZN6google8protobuf12_GLOBAL__N_117FlatAllocatorImplIJcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE13AllocateArrayIPKS8_EEPT_i:
push r15
push r14
push r12
push rbx
sub rsp, 48h
mov r15d, esi
mov r14, rdi
mov rbx, [rdi]
test rbx, rbx
jnz short loc_D3474
lea rdx, aWorkspaceLlm4b_34; "/workspace/llm4binary/github2025/aimrt_"...
lea rbx, [rsp+68h+var_58]
mov rdi, rbx
mov esi, 3
mov ecx, 187h
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
lea rsi, aCheckFailedHas_1; "CHECK failed: has_allocated(): "
mov rdi, rbx
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rdi, [rsp+68h+var_59]
mov rsi, rax
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
lea rdi, [rsp+68h+var_58]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
mov rbx, [r14]
loc_D3474:
movsxd r12, dword ptr [r14+9Ch]
lea eax, [r12+r15*8]
mov [r14+9Ch], eax
cmp eax, [r14+68h]
jle short loc_D34D0
lea rdx, aWorkspaceLlm4b_34; "/workspace/llm4binary/github2025/aimrt_"...
lea r14, [rsp+68h+var_58]
mov rdi, r14
mov esi, 3
mov ecx, 18Dh
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
lea rsi, aCheckFailedUse; "CHECK failed: (used) <= (total_.templat"...
mov rdi, r14
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rdi, [rsp+68h+var_59]
mov rsi, rax
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
lea rdi, [rsp+68h+var_58]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_D34D0:
add rbx, r12
mov rax, rbx
add rsp, 48h
pop rbx
pop r12
pop r14
pop r15
retn
jmp short loc_D34E8
jmp short loc_D34E8
jmp short $+2
loc_D34E8:
mov rbx, rax
lea rdi, [rsp+arg_8]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
mov rdi, rbx
call __Unwind_Resume
| long long google::protobuf::`anonymous namespace'::FlatAllocatorImpl<char,std::string,google::protobuf::SourceCodeInfo,google::protobuf::FileDescriptorTables,google::protobuf::MessageOptions,google::protobuf::FieldOptions,google::protobuf::EnumOptions,google::protobuf::EnumValueOptions,google::protobuf::ExtensionRangeOptions,google::protobuf::OneofOptions,google::protobuf::ServiceOptions,google::protobuf::MethodOptions,google::protobuf::FileOptions>::AllocateArray<std::string const*>(
long long *a1,
int a2)
{
long long v2; // rbx
google::protobuf::internal::LogMessage *v3; // rax
long long v4; // r12
int v5; // eax
google::protobuf::internal::LogMessage *v6; // rax
char v8; // [rsp+Fh] [rbp-59h] BYREF
_BYTE v9[88]; // [rsp+10h] [rbp-58h] BYREF
v2 = *a1;
if ( !*a1 )
{
google::protobuf::internal::LogMessage::LogMessage(
(long long)v9,
3,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc",
391);
v3 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(
(long long)v9,
(long long)"CHECK failed: has_allocated(): ");
google::protobuf::internal::LogFinisher::operator=((long long)&v8, v3);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v9);
v2 = *a1;
}
v4 = *((int *)a1 + 39);
v5 = v4 + 8 * a2;
*((_DWORD *)a1 + 39) = v5;
if ( v5 > *((_DWORD *)a1 + 26) )
{
google::protobuf::internal::LogMessage::LogMessage(
(long long)v9,
3,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc",
397);
v6 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(
(long long)v9,
(long long)"CHECK failed: (used) <= (total_.template Get<TypeToUse>()): ");
google::protobuf::internal::LogFinisher::operator=((long long)&v8, v6);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v9);
}
return v4 + v2;
}
| AllocateArray<std::__cxx11::string_const*>:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R15D,ESI
MOV R14,RDI
MOV RBX,qword ptr [RDI]
TEST RBX,RBX
JNZ 0x001d3474
LEA RDX,[0x26be93]
LEA RBX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x3
MOV ECX,0x187
CALL 0x001857c2
LAB_001d344b:
LEA RSI,[0x26e4d0]
MOV RDI,RBX
CALL 0x001852c0
LAB_001d345a:
LEA RDI,[RSP + 0xf]
MOV RSI,RAX
CALL 0x0018539a
LAB_001d3467:
LEA RDI,[RSP + 0x10]
CALL 0x001857e0
MOV RBX,qword ptr [R14]
LAB_001d3474:
MOVSXD R12,dword ptr [R14 + 0x9c]
LEA EAX,[R12 + R15*0x8]
MOV dword ptr [R14 + 0x9c],EAX
CMP EAX,dword ptr [R14 + 0x68]
JLE 0x001d34d0
LEA RDX,[0x26be93]
LEA R14,[RSP + 0x10]
MOV RDI,R14
MOV ESI,0x3
MOV ECX,0x18d
CALL 0x001857c2
LAB_001d34aa:
LEA RSI,[0x26e4f0]
MOV RDI,R14
CALL 0x001852c0
LAB_001d34b9:
LEA RDI,[RSP + 0xf]
MOV RSI,RAX
CALL 0x0018539a
LAB_001d34c6:
LEA RDI,[RSP + 0x10]
CALL 0x001857e0
LAB_001d34d0:
ADD RBX,R12
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R12
POP R14
POP R15
RET
|
/* std::__cxx11::string const** google::protobuf::(anonymous namespace)::FlatAllocatorImpl<char,
std::__cxx11::string, google::protobuf::SourceCodeInfo, google::protobuf::FileDescriptorTables,
google::protobuf::MessageOptions, google::protobuf::FieldOptions, google::protobuf::EnumOptions,
google::protobuf::EnumValueOptions, google::protobuf::ExtensionRangeOptions,
google::protobuf::OneofOptions, google::protobuf::ServiceOptions,
google::protobuf::MethodOptions,
google::protobuf::FileOptions>::AllocateArray<std::__cxx11::string const*>(int) */
string ** __thiscall
google::protobuf::(anonymous_namespace)::
FlatAllocatorImpl<char,std::__cxx11::string,google::protobuf::SourceCodeInfo,google::protobuf::FileDescriptorTables,google::protobuf::MessageOptions,google::protobuf::FieldOptions,google::protobuf::EnumOptions,google::protobuf::EnumValueOptions,google::protobuf::ExtensionRangeOptions,google::protobuf::OneofOptions,google::protobuf::ServiceOptions,google::protobuf::MethodOptions,google::protobuf::FileOptions>
::AllocateArray<std::__cxx11::string_const*>
(FlatAllocatorImpl<char,std::__cxx11::string,google::protobuf::SourceCodeInfo,google::protobuf::FileDescriptorTables,google::protobuf::MessageOptions,google::protobuf::FieldOptions,google::protobuf::EnumOptions,google::protobuf::EnumValueOptions,google::protobuf::ExtensionRangeOptions,google::protobuf::OneofOptions,google::protobuf::ServiceOptions,google::protobuf::MethodOptions,google::protobuf::FileOptions>
*this,int param_1)
{
int iVar1;
int iVar2;
LogMessage *pLVar3;
long lVar4;
LogFinisher local_59;
LogMessage local_58 [56];
lVar4 = *(long *)this;
if (lVar4 == 0) {
internal::LogMessage::LogMessage
(local_58,3,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc"
,0x187);
/* try { // try from 001d344b to 001d3459 has its CatchHandler @ 001d34e4 */
pLVar3 = (LogMessage *)
internal::LogMessage::operator<<(local_58,"CHECK failed: has_allocated(): ");
/* try { // try from 001d345a to 001d3466 has its CatchHandler @ 001d34e2 */
internal::LogFinisher::operator=(&local_59,pLVar3);
internal::LogMessage::~LogMessage(local_58);
lVar4 = *(long *)this;
}
iVar1 = *(int *)(this + 0x9c);
iVar2 = iVar1 + param_1 * 8;
*(int *)(this + 0x9c) = iVar2;
if (*(int *)(this + 0x68) < iVar2) {
internal::LogMessage::LogMessage
(local_58,3,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc"
,0x18d);
/* try { // try from 001d34aa to 001d34b8 has its CatchHandler @ 001d34e8 */
pLVar3 = (LogMessage *)
internal::LogMessage::operator<<
(local_58,"CHECK failed: (used) <= (total_.template Get<TypeToUse>()): ");
/* try { // try from 001d34b9 to 001d34c5 has its CatchHandler @ 001d34e6 */
internal::LogFinisher::operator=(&local_59,pLVar3);
internal::LogMessage::~LogMessage(local_58);
}
return (string **)(lVar4 + iVar1);
}
| |
54,195 | write_hook_for_undo_row_insert | eloqsql/storage/maria/ma_blockrec.c | my_bool write_hook_for_undo_row_insert(enum translog_record_type type
__attribute__ ((unused)),
TRN *trn, MARIA_HA *tbl_info,
LSN *lsn, void *hook_arg)
{
MARIA_SHARE *share= tbl_info->s;
share->state.state.records++;
share->state.state.checksum+= *(ha_checksum *)hook_arg;
return write_hook_for_undo(type, trn, tbl_info, lsn, hook_arg);
} | O3 | c | write_hook_for_undo_row_insert:
pushq %rbp
movq %rsp, %rbp
movq (%rdx), %rax
incq 0x18(%rax)
movl (%r8), %edx
addl %edx, 0x48(%rax)
movq (%rcx), %rax
movq %rax, 0x98(%rsi)
movq 0xa0(%rsi), %rcx
movq %rcx, %rdx
shlq $0x8, %rdx
je 0x5ea51
xorl %eax, %eax
popq %rbp
retq
orq %rax, %rcx
movq %rcx, 0xa0(%rsi)
jmp 0x5ea4d
| write_hook_for_undo_row_insert:
push rbp
mov rbp, rsp
mov rax, [rdx]
inc qword ptr [rax+18h]
mov edx, [r8]
add [rax+48h], edx
mov rax, [rcx]
mov [rsi+98h], rax
mov rcx, [rsi+0A0h]
mov rdx, rcx
shl rdx, 8
jz short loc_5EA51
loc_5EA4D:
xor eax, eax
pop rbp
retn
loc_5EA51:
or rcx, rax
mov [rsi+0A0h], rcx
jmp short loc_5EA4D
| long long write_hook_for_undo_row_insert(long long a1, long long a2, long long *a3, long long *a4, _DWORD *a5)
{
long long v5; // rax
long long v6; // rax
v5 = *a3;
++*(_QWORD *)(v5 + 24);
*(_DWORD *)(v5 + 72) += *a5;
v6 = *a4;
*(_QWORD *)(a2 + 152) = *a4;
if ( !(*(_QWORD *)(a2 + 160) << 8) )
*(_QWORD *)(a2 + 160) |= v6;
return 0LL;
}
| write_hook_for_undo_row_insert:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDX]
INC qword ptr [RAX + 0x18]
MOV EDX,dword ptr [R8]
ADD dword ptr [RAX + 0x48],EDX
MOV RAX,qword ptr [RCX]
MOV qword ptr [RSI + 0x98],RAX
MOV RCX,qword ptr [RSI + 0xa0]
MOV RDX,RCX
SHL RDX,0x8
JZ 0x0015ea51
LAB_0015ea4d:
XOR EAX,EAX
POP RBP
RET
LAB_0015ea51:
OR RCX,RAX
MOV qword ptr [RSI + 0xa0],RCX
JMP 0x0015ea4d
|
int8
write_hook_for_undo_row_insert
(int8 param_1,long param_2,long *param_3,ulong *param_4,int *param_5)
{
long *plVar1;
int *piVar2;
long lVar3;
ulong uVar4;
lVar3 = *param_3;
plVar1 = (long *)(lVar3 + 0x18);
*plVar1 = *plVar1 + 1;
piVar2 = (int *)(lVar3 + 0x48);
*piVar2 = *piVar2 + *param_5;
uVar4 = *param_4;
*(ulong *)(param_2 + 0x98) = uVar4;
if ((*(ulong *)(param_2 + 0xa0) & 0xffffffffffffff) == 0) {
*(ulong *)(param_2 + 0xa0) = *(ulong *)(param_2 + 0xa0) | uVar4;
}
return 0;
}
| |
54,196 | Bfree | eloqsql/libmariadb/libmariadb/ma_dtoa.c | static void Bfree(Bigint *v, Stack_alloc *alloc)
{
char *gptr= (char*) v; /* generic pointer */
if (gptr < alloc->begin || gptr >= alloc->end)
free(gptr);
else if (v->k <= Kmax)
{
/*
Maintain free lists only for stack objects: this way we don't
have to bother with freeing lists in the end of dtoa;
heap should not be used normally anyway.
*/
v->p.next= alloc->freelist[v->k];
alloc->freelist[v->k]= v;
}
} | O0 | c | Bfree:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jb 0x3c9b3
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x3c9be
movq -0x18(%rbp), %rdi
callq 0x13520
jmp 0x3c9f7
movq -0x8(%rbp), %rax
cmpl $0xf, 0x8(%rax)
jg 0x3c9f5
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq 0x18(%rax,%rcx,8), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, 0x18(%rax,%rcx,8)
jmp 0x3c9f7
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| Bfree:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
cmp rax, [rcx]
jb short loc_3C9B3
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
cmp rax, [rcx+10h]
jb short loc_3C9BE
loc_3C9B3:
mov rdi, [rbp+var_18]
call _free
jmp short loc_3C9F7
loc_3C9BE:
mov rax, [rbp+var_8]
cmp dword ptr [rax+8], 0Fh
jg short loc_3C9F5
mov rax, [rbp+var_10]
mov rcx, [rbp+var_8]
movsxd rcx, dword ptr [rcx+8]
mov rcx, [rax+rcx*8+18h]
mov rax, [rbp+var_8]
mov [rax], rcx
mov rdx, [rbp+var_8]
mov rax, [rbp+var_10]
mov rcx, [rbp+var_8]
movsxd rcx, dword ptr [rcx+8]
mov [rax+rcx*8+18h], rdx
loc_3C9F5:
jmp short $+2
loc_3C9F7:
add rsp, 20h
pop rbp
retn
| long long Bfree(unsigned long long a1, unsigned long long *a2)
{
long long result; // rax
if ( a1 < *a2 || a1 >= a2[2] )
return free(a1);
result = a1;
if ( *(int *)(a1 + 8) <= 15 )
{
*(_QWORD *)a1 = a2[*(int *)(a1 + 8) + 3];
result = (long long)a2;
a2[*(int *)(a1 + 8) + 3] = a1;
}
return result;
}
| Bfree:
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 + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX]
JC 0x0013c9b3
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x10]
JC 0x0013c9be
LAB_0013c9b3:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00113520
JMP 0x0013c9f7
LAB_0013c9be:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x8],0xf
JG 0x0013c9f5
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RCX + 0x8]
MOV RCX,qword ptr [RAX + RCX*0x8 + 0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
MOV RDX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RCX + 0x8]
MOV qword ptr [RAX + RCX*0x8 + 0x18],RDX
LAB_0013c9f5:
JMP 0x0013c9f7
LAB_0013c9f7:
ADD RSP,0x20
POP RBP
RET
|
void Bfree(ulong *param_1,ulong *param_2)
{
if ((param_1 < (ulong *)*param_2) || ((ulong *)param_2[2] <= param_1)) {
free(param_1);
}
else if ((int)param_1[1] < 0x10) {
*param_1 = param_2[(long)(int)param_1[1] + 3];
param_2[(long)(int)param_1[1] + 3] = (ulong)param_1;
}
return;
}
| |
54,197 | my_open | eloqsql/mysys/my_open.c | File my_open(const char *FileName, int Flags, myf MyFlags)
/* Path-name of file */
/* Read | write .. */
/* Special flags */
{
File fd;
DBUG_ENTER("my_open");
DBUG_PRINT("my",("Name: '%s' Flags: %d MyFlags: %lu",
FileName, Flags, MyFlags));
if (!(MyFlags & (MY_WME | MY_FAE | MY_FFNF)))
MyFlags|= my_global_flags;
#if defined(_WIN32)
fd= my_win_open(FileName, Flags);
#else
if (MyFlags & MY_NOSYMLINKS)
fd = open_nosymlinks(FileName, Flags | O_CLOEXEC, my_umask);
else
fd = open(FileName, Flags | O_CLOEXEC, my_umask);
#endif
fd= my_register_filename(fd, FileName, FILE_BY_OPEN,
EE_FILENOTFOUND, MyFlags);
DBUG_RETURN(fd);
} | O0 | c | my_open:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x80575
movq -0x18(%rbp), %rax
andq $0x19, %rax
cmpq $0x0, %rax
jne 0x80595
leaq 0x3780de(%rip), %rax # 0x3f8668
movq (%rax), %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x200, %rax # imm = 0x200
cmpq $0x0, %rax
je 0x805c5
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
orl $0x80000, %esi # imm = 0x80000
leaq 0x1b84df(%rip), %rax # 0x238a98
movl (%rax), %edx
callq 0x80620
movl %eax, -0x1c(%rbp)
jmp 0x805e5
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
orl $0x80000, %esi # imm = 0x80000
leaq 0x1b84bf(%rip), %rax # 0x238a98
movl (%rax), %edx
movb $0x0, %al
callq 0x28660
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %r8
movl $0x1, %edx
movl $0x1d, %ecx
callq 0x80690
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_open:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
jmp short $+2
loc_80575:
mov rax, [rbp+var_18]
and rax, 19h
cmp rax, 0
jnz short loc_80595
lea rax, my_global_flags
mov rax, [rax]
or rax, [rbp+var_18]
mov [rbp+var_18], rax
loc_80595:
mov rax, [rbp+var_18]
and rax, 200h
cmp rax, 0
jz short loc_805C5
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
or esi, 80000h
lea rax, my_umask
mov edx, [rax]
call open_nosymlinks
mov [rbp+var_1C], eax
jmp short loc_805E5
loc_805C5:
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
or esi, 80000h
lea rax, my_umask
mov edx, [rax]
mov al, 0
call _open64
mov [rbp+var_1C], eax
loc_805E5:
mov edi, [rbp+var_1C]
mov rsi, [rbp+var_8]
mov r8, [rbp+var_18]
mov edx, 1
mov ecx, 1Dh
call my_register_filename
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
mov [rbp+var_20], eax
mov eax, [rbp+var_20]
add rsp, 20h
pop rbp
retn
| long long my_open(long long a1, int a2, long long a3)
{
unsigned int v4; // [rsp+4h] [rbp-1Ch]
long long v5; // [rsp+8h] [rbp-18h]
v5 = a3;
if ( (a3 & 0x19) == 0 )
v5 = a3 | my_global_flags;
if ( (v5 & 0x200) != 0 )
v4 = open_nosymlinks(a1, a2 | 0x80000u, my_umask);
else
v4 = open64(a1, a2 | 0x80000u, my_umask);
return (unsigned int)my_register_filename(v4, a1, 1LL, 29LL, v5);
}
| my_open:
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
JMP 0x00180575
LAB_00180575:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x19
CMP RAX,0x0
JNZ 0x00180595
LEA RAX,[0x4f8668]
MOV RAX,qword ptr [RAX]
OR RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
LAB_00180595:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x200
CMP RAX,0x0
JZ 0x001805c5
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
OR ESI,0x80000
LEA RAX,[0x338a98]
MOV EDX,dword ptr [RAX]
CALL 0x00180620
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x001805e5
LAB_001805c5:
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
OR ESI,0x80000
LEA RAX,[0x338a98]
MOV EDX,dword ptr [RAX]
MOV AL,0x0
CALL 0x00128660
MOV dword ptr [RBP + -0x1c],EAX
LAB_001805e5:
MOV EDI,dword ptr [RBP + -0x1c]
MOV RSI,qword ptr [RBP + -0x8]
MOV R8,qword ptr [RBP + -0x18]
MOV EDX,0x1
MOV ECX,0x1d
CALL 0x00180690
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x20]
ADD RSP,0x20
POP RBP
RET
|
int4 my_open(char *param_1,uint param_2,ulong param_3)
{
int4 uVar1;
int4 local_24;
int8 local_20;
local_20 = param_3;
if ((param_3 & 0x19) == 0) {
local_20 = my_global_flags | param_3;
}
if ((local_20 & 0x200) == 0) {
local_24 = open64(param_1,param_2 | 0x80000,(ulong)my_umask);
}
else {
local_24 = open_nosymlinks(param_1,param_2 | 0x80000,my_umask);
}
uVar1 = my_register_filename(local_24,param_1,1,0x1d,local_20);
return uVar1;
}
| |
54,198 | string_parse_kv_override(char const*, std::vector<llama_model_kv_override, std::allocator<llama_model_kv_override>>&) | monkey531[P]llama/common/common.cpp | bool string_parse_kv_override(const char * data, std::vector<llama_model_kv_override> & overrides) {
const char * sep = strchr(data, '=');
if (sep == nullptr || sep - data >= 128) {
LOG_ERR("%s: malformed KV override '%s'\n", __func__, data);
return false;
}
llama_model_kv_override kvo;
std::strncpy(kvo.key, data, sep - data);
kvo.key[sep - data] = 0;
sep++;
if (strncmp(sep, "int:", 4) == 0) {
sep += 4;
kvo.tag = LLAMA_KV_OVERRIDE_TYPE_INT;
kvo.val_i64 = std::atol(sep);
} else if (strncmp(sep, "float:", 6) == 0) {
sep += 6;
kvo.tag = LLAMA_KV_OVERRIDE_TYPE_FLOAT;
kvo.val_f64 = std::atof(sep);
} else if (strncmp(sep, "bool:", 5) == 0) {
sep += 5;
kvo.tag = LLAMA_KV_OVERRIDE_TYPE_BOOL;
if (std::strcmp(sep, "true") == 0) {
kvo.val_bool = true;
} else if (std::strcmp(sep, "false") == 0) {
kvo.val_bool = false;
} else {
LOG_ERR("%s: invalid boolean value for KV override '%s'\n", __func__, data);
return false;
}
} else if (strncmp(sep, "str:", 4) == 0) {
sep += 4;
kvo.tag = LLAMA_KV_OVERRIDE_TYPE_STR;
if (strlen(sep) > 127) {
LOG_ERR("%s: malformed KV override '%s', value cannot exceed 127 chars\n", __func__, data);
return false;
}
strncpy(kvo.val_str, sep, 127);
kvo.val_str[127] = '\0';
} else {
LOG_ERR("%s: invalid type for KV override '%s'\n", __func__, data);
return false;
}
overrides.emplace_back(std::move(kvo));
return true;
} | O2 | cpp | string_parse_kv_override(char const*, std::vector<llama_model_kv_override, std::allocator<llama_model_kv_override>>&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x3d
popq %rsi
callq 0x20250
testq %rax, %rax
je 0x243a3
movq %rax, %r15
movq %rax, %r12
subq %rbx, %r12
cmpq $0x80, %r12
jl 0x243dd
leaq 0xabc66(%rip), %rax # 0xd0010
cmpl $0x0, (%rax)
js 0x24555
callq 0x6ff0a
leaq 0x68a9d(%rip), %rdx # 0x8ce5c
leaq 0x68ab6(%rip), %rcx # 0x8ce7c
xorl %ebp, %ebp
pushq $0x4
popq %rsi
movq %rax, %rdi
movq %rbx, %r8
xorl %eax, %eax
callq 0x6ffa2
jmp 0x24557
leaq 0xc(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x203a0
movb $0x0, 0xc(%rsp,%r12)
leaq 0x1(%r15), %r12
leaq 0x68a97(%rip), %rsi # 0x8ce95
pushq $0x4
popq %rdx
movq %r12, %rdi
callq 0x20360
testl %eax, %eax
je 0x24478
leaq 0x68a86(%rip), %rsi # 0x8ce9a
pushq $0x6
popq %rdx
movq %r12, %rdi
callq 0x20360
testl %eax, %eax
je 0x24493
leaq 0x68a77(%rip), %rsi # 0x8cea1
pushq $0x5
popq %rdx
movq %r12, %rdi
callq 0x20360
testl %eax, %eax
je 0x244c5
leaq 0x68a93(%rip), %rsi # 0x8ced7
pushq $0x4
popq %rdx
movq %r12, %rdi
callq 0x20360
testl %eax, %eax
je 0x2451c
leaq 0xabbb2(%rip), %rax # 0xd0010
cmpl $0x0, (%rax)
js 0x24555
callq 0x6ff0a
leaq 0x68aa8(%rip), %rdx # 0x8cf1b
jmp 0x243bf
addq $0x5, %r15
andl $0x0, 0x8(%rsp)
movq %r15, %rdi
callq 0x20800
movq %rax, 0x90(%rsp)
jmp 0x244b0
addq $0x7, %r15
movl $0x1, 0x8(%rsp)
movq %r15, %rdi
callq 0x20830
movsd %xmm0, 0x90(%rsp)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x284ac
movb $0x1, %bpl
jmp 0x24557
addq $0x6, %r15
movl $0x2, 0x8(%rsp)
leaq 0x68942(%rip), %rsi # 0x8ce1a
movq %r15, %rdi
callq 0x20950
testl %eax, %eax
je 0x24569
leaq 0x68930(%rip), %rsi # 0x8ce1f
movq %r15, %rdi
callq 0x20950
testl %eax, %eax
je 0x24595
leaq 0xabb0a(%rip), %rax # 0xd0010
cmpl $0x0, (%rax)
js 0x24555
callq 0x6ff0a
leaq 0x68990(%rip), %rdx # 0x8cea7
jmp 0x243bf
addq $0x5, %r15
movl $0x3, 0x8(%rsp)
movq %r15, %rdi
callq 0x20310
cmpq $0x80, %rax
jb 0x24576
leaq 0xabad1(%rip), %rax # 0xd0010
cmpl $0x0, (%rax)
js 0x24555
callq 0x6ff0a
leaq 0x6898c(%rip), %rdx # 0x8cedc
jmp 0x243bf
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, 0x90(%rsp)
jmp 0x244b0
leaq 0x90(%rsp), %rbx
pushq $0x7f
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x203a0
movb $0x0, 0x7f(%rbx)
jmp 0x244b0
movb $0x0, 0x90(%rsp)
jmp 0x244b0
| _Z24string_parse_kv_overridePKcRSt6vectorI23llama_model_kv_overrideSaIS2_EE:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 110h
mov r14, rsi
mov rbx, rdi
push 3Dh ; '='
pop rsi
call _strchr
test rax, rax
jz short loc_243A3
mov r15, rax
mov r12, rax
sub r12, rbx
cmp r12, 80h
jl short loc_243DD
loc_243A3:
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js loc_24555
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSMalformedKvOv; "%s: malformed KV override '%s'\n"
loc_243BF:
lea rcx, aStringParseKvO; "string_parse_kv_override"
xor ebp, ebp
push 4
pop rsi
mov rdi, rax
mov r8, rbx
xor eax, eax
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
jmp loc_24557
loc_243DD:
lea rdi, [rsp+138h+var_12C]
mov rsi, rbx
mov rdx, r12
call _strncpy
mov [rsp+r12+138h+var_12C], 0
lea r12, [r15+1]
lea rsi, aInt; "int:"
push 4
pop rdx
mov rdi, r12
call _strncmp
test eax, eax
jz short loc_24478
lea rsi, aFloat; "float:"
push 6
pop rdx
mov rdi, r12
call _strncmp
test eax, eax
jz short loc_24493
lea rsi, aBool; "bool:"
push 5
pop rdx
mov rdi, r12
call _strncmp
test eax, eax
jz loc_244C5
lea rsi, aStr; "str:"
push 4
pop rdx
mov rdi, r12
call _strncmp
test eax, eax
jz loc_2451C
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js loc_24555
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSInvalidTypeFo; "%s: invalid type for KV override '%s'\n"
jmp loc_243BF
loc_24478:
add r15, 5
and [rsp+138h+var_130], 0
mov rdi, r15
call _atol
mov [rsp+138h+var_A8], rax
jmp short loc_244B0
loc_24493:
add r15, 7
mov [rsp+138h+var_130], 1
mov rdi, r15
call _atof
movsd [rsp+138h+var_A8], xmm0
loc_244B0:
lea rsi, [rsp+138h+var_130]
mov rdi, r14
call _ZNSt6vectorI23llama_model_kv_overrideSaIS0_EE12emplace_backIJS0_EEERS0_DpOT_; std::vector<llama_model_kv_override>::emplace_back<llama_model_kv_override>(llama_model_kv_override &&)
mov bpl, 1
jmp loc_24557
loc_244C5:
add r15, 6
mov [rsp+138h+var_130], 2
lea rsi, aTrue; "true"
mov rdi, r15
call _strcmp
test eax, eax
jz loc_24569
lea rsi, aFalse; "false"
mov rdi, r15
call _strcmp
test eax, eax
jz loc_24595
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_24555
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSInvalidBoolea; "%s: invalid boolean value for KV overri"...
jmp loc_243BF
loc_2451C:
add r15, 5
mov [rsp+138h+var_130], 3
mov rdi, r15
call _strlen
cmp rax, 80h
jb short loc_24576
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_24555
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSMalformedKvOv_0; "%s: malformed KV override '%s', value c"...
jmp loc_243BF
loc_24555:
xor ebp, ebp
loc_24557:
mov eax, ebp
add rsp, 110h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_24569:
mov byte ptr [rsp+138h+var_A8], 1
jmp loc_244B0
loc_24576:
lea rbx, [rsp+138h+var_A8]
push 7Fh
pop rdx
mov rdi, rbx
mov rsi, r15
call _strncpy
mov byte ptr [rbx+7Fh], 0
jmp loc_244B0
loc_24595:
mov byte ptr [rsp+138h+var_A8], 0
jmp loc_244B0
| long long string_parse_kv_override(long long a1, long long a2)
{
unsigned int v2; // ebp
long long v3; // rax
long long v4; // r15
long long v5; // r12
int v6; // eax
int v7; // r9d
const char *v8; // rdx
long long v9; // r15
long long v10; // r15
int v12; // [rsp+8h] [rbp-130h] BYREF
_BYTE v13[132]; // [rsp+Ch] [rbp-12Ch] BYREF
long long v14[15]; // [rsp+90h] [rbp-A8h] BYREF
char v15; // [rsp+10Fh] [rbp-29h]
v3 = strchr(a1, 61LL);
if ( v3 )
{
v4 = v3;
v5 = v3 - a1;
if ( v3 - a1 < 128 )
{
strncpy(v13, a1, v3 - a1);
v13[v5] = 0;
if ( !(unsigned int)strncmp(v4 + 1, "int:", 4LL) )
{
v12 = 0;
v14[0] = atol(v4 + 5);
}
else if ( !(unsigned int)strncmp(v4 + 1, "float:", 6LL) )
{
v12 = 1;
v14[0] = atof(v4 + 7);
}
else if ( !(unsigned int)strncmp(v4 + 1, "bool:", 5LL) )
{
v9 = v4 + 6;
v12 = 2;
if ( !(unsigned int)strcmp(v9, "true") )
{
LOBYTE(v14[0]) = 1;
}
else
{
if ( (unsigned int)strcmp(v9, "false") )
{
if ( common_log_verbosity_thold >= 0 )
{
v6 = common_log_main();
v8 = "%s: invalid boolean value for KV override '%s'\n";
goto LABEL_5;
}
return 0;
}
LOBYTE(v14[0]) = 0;
}
}
else
{
if ( (unsigned int)strncmp(v4 + 1, "str:", 4LL) )
{
if ( common_log_verbosity_thold >= 0 )
{
v6 = common_log_main();
v8 = "%s: invalid type for KV override '%s'\n";
goto LABEL_5;
}
return 0;
}
v10 = v4 + 5;
v12 = 3;
if ( (unsigned long long)strlen(v10) >= 0x80 )
{
if ( common_log_verbosity_thold >= 0 )
{
v6 = common_log_main();
v8 = "%s: malformed KV override '%s', value cannot exceed 127 chars\n";
goto LABEL_5;
}
return 0;
}
strncpy(v14, v10, 127LL);
v15 = 0;
}
std::vector<llama_model_kv_override>::emplace_back<llama_model_kv_override>(a2, &v12);
LOBYTE(v2) = 1;
return v2;
}
}
if ( common_log_verbosity_thold < 0 )
return 0;
v6 = common_log_main();
v8 = "%s: malformed KV override '%s'\n";
LABEL_5:
v2 = 0;
common_log_add(v6, 4, (_DWORD)v8, (unsigned int)"string_parse_kv_override", a1, v7);
return v2;
}
| string_parse_kv_override:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x110
MOV R14,RSI
MOV RBX,RDI
PUSH 0x3d
POP RSI
CALL 0x00120250
TEST RAX,RAX
JZ 0x001243a3
MOV R15,RAX
MOV R12,RAX
SUB R12,RBX
CMP R12,0x80
JL 0x001243dd
LAB_001243a3:
LEA RAX,[0x1d0010]
CMP dword ptr [RAX],0x0
JS 0x00124555
CALL 0x0016ff0a
LEA RDX,[0x18ce5c]
LAB_001243bf:
LEA RCX,[0x18ce7c]
XOR EBP,EBP
PUSH 0x4
POP RSI
MOV RDI,RAX
MOV R8,RBX
XOR EAX,EAX
CALL 0x0016ffa2
JMP 0x00124557
LAB_001243dd:
LEA RDI,[RSP + 0xc]
MOV RSI,RBX
MOV RDX,R12
CALL 0x001203a0
MOV byte ptr [RSP + R12*0x1 + 0xc],0x0
LEA R12,[R15 + 0x1]
LEA RSI,[0x18ce95]
PUSH 0x4
POP RDX
MOV RDI,R12
CALL 0x00120360
TEST EAX,EAX
JZ 0x00124478
LEA RSI,[0x18ce9a]
PUSH 0x6
POP RDX
MOV RDI,R12
CALL 0x00120360
TEST EAX,EAX
JZ 0x00124493
LEA RSI,[0x18cea1]
PUSH 0x5
POP RDX
MOV RDI,R12
CALL 0x00120360
TEST EAX,EAX
JZ 0x001244c5
LEA RSI,[0x18ced7]
PUSH 0x4
POP RDX
MOV RDI,R12
CALL 0x00120360
TEST EAX,EAX
JZ 0x0012451c
LEA RAX,[0x1d0010]
CMP dword ptr [RAX],0x0
JS 0x00124555
CALL 0x0016ff0a
LEA RDX,[0x18cf1b]
JMP 0x001243bf
LAB_00124478:
ADD R15,0x5
AND dword ptr [RSP + 0x8],0x0
MOV RDI,R15
CALL 0x00120800
MOV qword ptr [RSP + 0x90],RAX
JMP 0x001244b0
LAB_00124493:
ADD R15,0x7
MOV dword ptr [RSP + 0x8],0x1
MOV RDI,R15
CALL 0x00120830
MOVSD qword ptr [RSP + 0x90],XMM0
LAB_001244b0:
LEA RSI,[RSP + 0x8]
MOV RDI,R14
CALL 0x001284ac
MOV BPL,0x1
JMP 0x00124557
LAB_001244c5:
ADD R15,0x6
MOV dword ptr [RSP + 0x8],0x2
LEA RSI,[0x18ce1a]
MOV RDI,R15
CALL 0x00120950
TEST EAX,EAX
JZ 0x00124569
LEA RSI,[0x18ce1f]
MOV RDI,R15
CALL 0x00120950
TEST EAX,EAX
JZ 0x00124595
LEA RAX,[0x1d0010]
CMP dword ptr [RAX],0x0
JS 0x00124555
CALL 0x0016ff0a
LEA RDX,[0x18cea7]
JMP 0x001243bf
LAB_0012451c:
ADD R15,0x5
MOV dword ptr [RSP + 0x8],0x3
MOV RDI,R15
CALL 0x00120310
CMP RAX,0x80
JC 0x00124576
LEA RAX,[0x1d0010]
CMP dword ptr [RAX],0x0
JS 0x00124555
CALL 0x0016ff0a
LEA RDX,[0x18cedc]
JMP 0x001243bf
LAB_00124555:
XOR EBP,EBP
LAB_00124557:
MOV EAX,EBP
ADD RSP,0x110
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00124569:
MOV byte ptr [RSP + 0x90],0x1
JMP 0x001244b0
LAB_00124576:
LEA RBX,[RSP + 0x90]
PUSH 0x7f
POP RDX
MOV RDI,RBX
MOV RSI,R15
CALL 0x001203a0
MOV byte ptr [RBX + 0x7f],0x0
JMP 0x001244b0
LAB_00124595:
MOV byte ptr [RSP + 0x90],0x0
JMP 0x001244b0
|
/* string_parse_kv_override(char const*, std::vector<llama_model_kv_override,
std::allocator<llama_model_kv_override> >&) */
ulong string_parse_kv_override(char *param_1,vector *param_2)
{
char *__s1;
int iVar1;
char *pcVar2;
int8 uVar3;
int8 unaff_RBP;
ulong uVar4;
size_t sVar5;
int4 local_130;
char local_12c [132];
double local_a8 [15];
int1 local_29;
pcVar2 = strchr(param_1,0x3d);
if ((pcVar2 == (char *)0x0) || (sVar5 = (long)pcVar2 - (long)param_1, 0x7f < (long)sVar5)) {
if (common_log_verbosity_thold < 0) goto LAB_00124555;
uVar3 = common_log_main();
pcVar2 = "%s: malformed KV override \'%s\'\n";
goto LAB_001243bf;
}
strncpy(local_12c,param_1,sVar5);
local_12c[sVar5] = '\0';
__s1 = pcVar2 + 1;
iVar1 = strncmp(__s1,"int:",4);
if (iVar1 == 0) {
local_130 = 0;
local_a8[0] = (double)atol(pcVar2 + 5);
}
else {
iVar1 = strncmp(__s1,"float:",6);
if (iVar1 == 0) {
local_130 = 1;
local_a8[0] = atof(pcVar2 + 7);
}
else {
iVar1 = strncmp(__s1,"bool:",5);
if (iVar1 != 0) {
iVar1 = strncmp(__s1,"str:",4);
if (iVar1 == 0) {
local_130 = 3;
sVar5 = strlen(pcVar2 + 5);
if (sVar5 < 0x80) {
strncpy((char *)local_a8,pcVar2 + 5,0x7f);
local_29 = 0;
goto LAB_001244b0;
}
if (common_log_verbosity_thold < 0) goto LAB_00124555;
uVar3 = common_log_main();
pcVar2 = "%s: malformed KV override \'%s\', value cannot exceed 127 chars\n";
}
else {
if (common_log_verbosity_thold < 0) {
LAB_00124555:
uVar4 = 0;
goto LAB_00124557;
}
uVar3 = common_log_main();
pcVar2 = "%s: invalid type for KV override \'%s\'\n";
}
LAB_001243bf:
uVar4 = 0;
common_log_add(uVar3,4,pcVar2,"string_parse_kv_override",param_1);
goto LAB_00124557;
}
local_130 = 2;
iVar1 = strcmp(pcVar2 + 6,"true");
if (iVar1 == 0) {
local_a8[0] = (double)CONCAT71(local_a8[0]._1_7_,1);
}
else {
iVar1 = strcmp(pcVar2 + 6,"false");
if (iVar1 != 0) {
if (common_log_verbosity_thold < 0) goto LAB_00124555;
uVar3 = common_log_main();
pcVar2 = "%s: invalid boolean value for KV override \'%s\'\n";
goto LAB_001243bf;
}
local_a8[0] = (double)((ulong)local_a8[0] & 0xffffffffffffff00);
}
}
}
LAB_001244b0:
std::vector<llama_model_kv_override,std::allocator<llama_model_kv_override>>::
emplace_back<llama_model_kv_override>
((vector<llama_model_kv_override,std::allocator<llama_model_kv_override>> *)param_2,
(llama_model_kv_override *)&local_130);
uVar4 = CONCAT71((int7)((ulong)unaff_RBP >> 8),1);
LAB_00124557:
return uVar4 & 0xffffffff;
}
| |
54,199 | my_strnncollsp_latin1_de | eloqsql/strings/ctype-latin1.c | static int my_strnncollsp_latin1_de(CHARSET_INFO *cs __attribute__((unused)),
const uchar *a, size_t a_length,
const uchar *b, size_t b_length)
{
const uchar *a_end= a + a_length, *b_end= b + b_length;
uchar a_char, a_extend= 0, b_char, b_extend= 0;
while ((a < a_end || a_extend) && (b < b_end || b_extend))
{
if (a_extend)
{
a_char=a_extend;
a_extend= 0;
}
else
{
a_extend= combo2map[*a];
a_char= combo1map[*a++];
}
if (b_extend)
{
b_char= b_extend;
b_extend= 0;
}
else
{
b_extend= combo2map[*b];
b_char= combo1map[*b++];
}
if (a_char != b_char)
return (int) a_char - (int) b_char;
}
/* Check if double character last */
if (a_extend)
return 1;
if (b_extend)
return -1;
if (a < a_end)
return my_strnncollsp_padspace_bin(a, a_end - a);
if (b < b_end)
return -my_strnncollsp_padspace_bin(b, b_end - b);
return 0;
} | O0 | c | my_strnncollsp_latin1_de:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x42(%rbp)
movb $0x0, -0x44(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x38(%rbp), %rax
jb 0x37544
movzbl -0x42(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x45(%rbp)
je 0x37566
movq -0x28(%rbp), %rcx
movb $0x1, %al
cmpq -0x40(%rbp), %rcx
movb %al, -0x46(%rbp)
jb 0x37560
movzbl -0x44(%rbp), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x46(%rbp)
movb -0x46(%rbp), %al
movb %al, -0x45(%rbp)
movb -0x45(%rbp), %al
testb $0x1, %al
jne 0x37572
jmp 0x37624
cmpb $0x0, -0x42(%rbp)
je 0x37584
movb -0x42(%rbp), %al
movb %al, -0x41(%rbp)
movb $0x0, -0x42(%rbp)
jmp 0x375bb
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x10314c(%rip), %rax # 0x13a6e0
movb (%rax,%rcx), %al
movb %al, -0x42(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x10302b(%rip), %rax # 0x13a5e0
movb (%rax,%rcx), %al
movb %al, -0x41(%rbp)
cmpb $0x0, -0x44(%rbp)
je 0x375cd
movb -0x44(%rbp), %al
movb %al, -0x43(%rbp)
movb $0x0, -0x44(%rbp)
jmp 0x37604
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x103103(%rip), %rax # 0x13a6e0
movb (%rax,%rcx), %al
movb %al, -0x44(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x102fe2(%rip), %rax # 0x13a5e0
movb (%rax,%rcx), %al
movb %al, -0x43(%rbp)
movzbl -0x41(%rbp), %eax
movzbl -0x43(%rbp), %ecx
cmpl %ecx, %eax
je 0x3761f
movzbl -0x41(%rbp), %eax
movzbl -0x43(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x37695
jmp 0x3752c
cmpb $0x0, -0x42(%rbp)
je 0x37633
movl $0x1, -0x4(%rbp)
jmp 0x37695
cmpb $0x0, -0x44(%rbp)
je 0x37642
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x37695
movq -0x18(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x37665
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rax
subq %rax, %rsi
callq 0x70170
movl %eax, -0x4(%rbp)
jmp 0x37695
movq -0x28(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x3768e
movq -0x28(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x28(%rbp), %rax
subq %rax, %rsi
callq 0x70170
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x37695
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
| my_strnncollsp_latin1_de:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
add rax, [rbp+var_30]
mov [rbp+var_40], rax
mov [rbp+var_42], 0
mov [rbp+var_44], 0
loc_3752C:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_38]
jb short loc_37544
movzx ecx, [rbp+var_42]
xor eax, eax
cmp ecx, 0
mov [rbp+var_45], al
jz short loc_37566
loc_37544:
mov rcx, [rbp+var_28]
mov al, 1
cmp rcx, [rbp+var_40]
mov [rbp+var_46], al
jb short loc_37560
movzx eax, [rbp+var_44]
cmp eax, 0
setnz al
mov [rbp+var_46], al
loc_37560:
mov al, [rbp+var_46]
mov [rbp+var_45], al
loc_37566:
mov al, [rbp+var_45]
test al, 1
jnz short loc_37572
jmp loc_37624
loc_37572:
cmp [rbp+var_42], 0
jz short loc_37584
mov al, [rbp+var_42]
mov [rbp+var_41], al
mov [rbp+var_42], 0
jmp short loc_375BB
loc_37584:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, combo2map
mov al, [rax+rcx]
mov [rbp+var_42], al
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, combo1map
mov al, [rax+rcx]
mov [rbp+var_41], al
loc_375BB:
cmp [rbp+var_44], 0
jz short loc_375CD
mov al, [rbp+var_44]
mov [rbp+var_43], al
mov [rbp+var_44], 0
jmp short loc_37604
loc_375CD:
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, combo2map
mov al, [rax+rcx]
mov [rbp+var_44], al
mov rax, [rbp+var_28]
mov rcx, rax
add rcx, 1
mov [rbp+var_28], rcx
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, combo1map
mov al, [rax+rcx]
mov [rbp+var_43], al
loc_37604:
movzx eax, [rbp+var_41]
movzx ecx, [rbp+var_43]
cmp eax, ecx
jz short loc_3761F
movzx eax, [rbp+var_41]
movzx ecx, [rbp+var_43]
sub eax, ecx
mov [rbp+var_4], eax
jmp short loc_37695
loc_3761F:
jmp loc_3752C
loc_37624:
cmp [rbp+var_42], 0
jz short loc_37633
mov [rbp+var_4], 1
jmp short loc_37695
loc_37633:
cmp [rbp+var_44], 0
jz short loc_37642
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_37695
loc_37642:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_38]
jnb short loc_37665
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_38]
mov rax, [rbp+var_18]
sub rsi, rax
call my_strnncollsp_padspace_bin
mov [rbp+var_4], eax
jmp short loc_37695
loc_37665:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_40]
jnb short loc_3768E
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_40]
mov rax, [rbp+var_28]
sub rsi, rax
call my_strnncollsp_padspace_bin
mov ecx, eax
xor eax, eax
sub eax, ecx
mov [rbp+var_4], eax
jmp short loc_37695
loc_3768E:
mov [rbp+var_4], 0
loc_37695:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long my_strnncollsp_latin1_de(
long long a1,
unsigned __int8 *a2,
long long a3,
unsigned __int8 *a4,
long long a5)
{
unsigned __int8 *v5; // rax
unsigned __int8 *v6; // rax
bool v8; // [rsp+Ah] [rbp-46h]
bool v9; // [rsp+Bh] [rbp-45h]
unsigned __int8 v10; // [rsp+Ch] [rbp-44h]
unsigned __int8 v11; // [rsp+Dh] [rbp-43h]
unsigned __int8 v12; // [rsp+Eh] [rbp-42h]
unsigned __int8 v13; // [rsp+Fh] [rbp-41h]
unsigned long long v14; // [rsp+10h] [rbp-40h]
unsigned long long v15; // [rsp+18h] [rbp-38h]
unsigned __int8 *v16; // [rsp+28h] [rbp-28h]
unsigned __int8 *v17; // [rsp+38h] [rbp-18h]
v17 = a2;
v16 = a4;
v15 = (unsigned long long)&a2[a3];
v14 = (unsigned long long)&a4[a5];
v12 = 0;
v10 = 0;
while ( 1 )
{
if ( (unsigned long long)v17 < v15 || (v9 = 0, v12) )
{
v8 = 1;
if ( (unsigned long long)v16 >= v14 )
v8 = v10 != 0;
v9 = v8;
}
if ( !v9 )
break;
if ( v12 )
{
v13 = v12;
v12 = 0;
}
else
{
v12 = combo2map[*v17];
v5 = v17++;
v13 = combo1map[*v5];
}
if ( v10 )
{
v11 = v10;
v10 = 0;
}
else
{
v10 = combo2map[*v16];
v6 = v16++;
v11 = combo1map[*v6];
}
if ( v13 != v11 )
return (unsigned int)(v13 - v11);
}
if ( v12 )
{
return 1;
}
else if ( v10 )
{
return (unsigned int)-1;
}
else if ( (unsigned long long)v17 >= v15 )
{
if ( (unsigned long long)v16 >= v14 )
return 0;
else
return (unsigned int)-(int)my_strnncollsp_padspace_bin(v16, v14 - (_QWORD)v16);
}
else
{
return (unsigned int)my_strnncollsp_padspace_bin(v17, v15 - (_QWORD)v17);
}
}
| my_strnncollsp_latin1_de:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x40],RAX
MOV byte ptr [RBP + -0x42],0x0
MOV byte ptr [RBP + -0x44],0x0
LAB_0013752c:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x38]
JC 0x00137544
MOVZX ECX,byte ptr [RBP + -0x42]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x45],AL
JZ 0x00137566
LAB_00137544:
MOV RCX,qword ptr [RBP + -0x28]
MOV AL,0x1
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x46],AL
JC 0x00137560
MOVZX EAX,byte ptr [RBP + -0x44]
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x46],AL
LAB_00137560:
MOV AL,byte ptr [RBP + -0x46]
MOV byte ptr [RBP + -0x45],AL
LAB_00137566:
MOV AL,byte ptr [RBP + -0x45]
TEST AL,0x1
JNZ 0x00137572
JMP 0x00137624
LAB_00137572:
CMP byte ptr [RBP + -0x42],0x0
JZ 0x00137584
MOV AL,byte ptr [RBP + -0x42]
MOV byte ptr [RBP + -0x41],AL
MOV byte ptr [RBP + -0x42],0x0
JMP 0x001375bb
LAB_00137584:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x23a6e0]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x42],AL
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x23a5e0]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x41],AL
LAB_001375bb:
CMP byte ptr [RBP + -0x44],0x0
JZ 0x001375cd
MOV AL,byte ptr [RBP + -0x44]
MOV byte ptr [RBP + -0x43],AL
MOV byte ptr [RBP + -0x44],0x0
JMP 0x00137604
LAB_001375cd:
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x23a6e0]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x44],AL
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x28],RCX
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x23a5e0]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x43],AL
LAB_00137604:
MOVZX EAX,byte ptr [RBP + -0x41]
MOVZX ECX,byte ptr [RBP + -0x43]
CMP EAX,ECX
JZ 0x0013761f
MOVZX EAX,byte ptr [RBP + -0x41]
MOVZX ECX,byte ptr [RBP + -0x43]
SUB EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00137695
LAB_0013761f:
JMP 0x0013752c
LAB_00137624:
CMP byte ptr [RBP + -0x42],0x0
JZ 0x00137633
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00137695
LAB_00137633:
CMP byte ptr [RBP + -0x44],0x0
JZ 0x00137642
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00137695
LAB_00137642:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x38]
JNC 0x00137665
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x18]
SUB RSI,RAX
CALL 0x00170170
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00137695
LAB_00137665:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x0013768e
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x28]
SUB RSI,RAX
CALL 0x00170170
MOV ECX,EAX
XOR EAX,EAX
SUB EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00137695
LAB_0013768e:
MOV dword ptr [RBP + -0x4],0x0
LAB_00137695:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int my_strnncollsp_latin1_de
(int8 param_1,byte *param_2,long param_3,byte *param_4,long param_5)
{
int iVar1;
byte *pbVar2;
byte *pbVar3;
bool local_4e;
byte local_4c;
byte local_4b;
byte local_4a;
byte local_49;
byte *local_30;
byte *local_20;
pbVar2 = param_2 + param_3;
pbVar3 = param_4 + param_5;
local_4a = 0;
local_4c = 0;
local_30 = param_4;
local_20 = param_2;
while( true ) {
if ((local_20 < pbVar2) || (local_4e = false, local_4a != 0)) {
local_4e = local_30 < pbVar3 || local_4c != 0;
}
if (!local_4e) break;
if (local_4a == 0) {
local_4a = combo2map[*local_20];
local_49 = combo1map[*local_20];
local_20 = local_20 + 1;
}
else {
local_49 = local_4a;
local_4a = 0;
}
if (local_4c == 0) {
local_4c = combo2map[*local_30];
local_4b = combo1map[*local_30];
local_30 = local_30 + 1;
}
else {
local_4b = local_4c;
local_4c = 0;
}
if (local_49 != local_4b) {
return (uint)local_49 - (uint)local_4b;
}
}
if (local_4a != 0) {
return 1;
}
if (local_4c != 0) {
return -1;
}
if (local_20 < pbVar2) {
iVar1 = my_strnncollsp_padspace_bin(local_20,(long)pbVar2 - (long)local_20);
return iVar1;
}
if (local_30 < pbVar3) {
iVar1 = my_strnncollsp_padspace_bin(local_30,(long)pbVar3 - (long)local_30);
return -iVar1;
}
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.