index int64 0 66.5k | func_name stringlengths 2 5.36k | func_dep stringlengths 16 2.19k | func stringlengths 8 55.3k | test stringlengths 0 7.07k | opt stringclasses 4
values | language stringclasses 2
values | asm stringlengths 0 45.4k | ida_asm stringlengths 0 44.7k | ida_pseudo stringlengths 0 44.3k | ghidra_asm stringlengths 0 49.1k | ghidra_pseudo stringlengths 0 64.7k |
|---|---|---|---|---|---|---|---|---|---|---|---|
41,600 | boundary_iterator_next | memononen[P]budouxc/src/budoux.c | int32_t boundary_iterator_next(boundary_iterator_t* bit, int32_t* range_start, int32_t* range_end)
{
if (!bit->model || !bit->utf_iter.buf || bit->done)
return 0;
uint32_t* buffer = bit->buffer;
int32_t* offset = bit->offset;
const budoux_model_t* model = bit->model;
*range_start = 0;
*range_end = 0;
while (!bit->utf_iter.done) {
ROLL(offset);
offset[5] = bit->utf_iter.pos;
ROLL(buffer);
buffer[5] = bit->utf_iter.get(&bit->utf_iter);
// buffer[0] is -3, buffer[3] = 0, buffer[5] = +2;
int score = model->base_score;
score += find_uni_weight(&model->UW1, buffer[0]);
score += find_uni_weight(&model->UW2, buffer[1]);
score += find_uni_weight(&model->UW3, buffer[2]);
score += find_uni_weight(&model->UW4, buffer[3]);
score += find_uni_weight(&model->UW5, buffer[4]);
score += find_uni_weight(&model->UW6, buffer[5]);
score += find_bi_weight(&model->BW1, buffer[1],buffer[2]);
score += find_bi_weight(&model->BW2, buffer[2],buffer[3]);
score += find_bi_weight(&model->BW3, buffer[3],buffer[4]);
score += find_tri_weight(&model->TW1, buffer[0],buffer[1],buffer[2]);
score += find_tri_weight(&model->TW1, buffer[1],buffer[2],buffer[3]);
score += find_tri_weight(&model->TW1, buffer[2],buffer[3],buffer[4]);
score += find_tri_weight(&model->TW1, buffer[3],buffer[4],buffer[5]);
int32_t pos_end = offset[3];
if (score > 0 && bit->range_start != pos_end) {
*range_start = bit->range_start;
*range_end = pos_end;
bit->range_start = pos_end;
break;
}
}
if (bit->utf_iter.done) {
*range_start = bit->range_start;
*range_end = offset[3+1]; // 3 is the start of last processed codepoint, 3+1 is null term.
bit->done = 1;
}
return 1;
} | O2 | c | boundary_iterator_next:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq (%rdi), %rcx
xorl %eax, %eax
movq %rcx, 0x28(%rsp)
testq %rcx, %rcx
je 0x2c80
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0x2c80
cmpl $0x0, 0x5c(%r14)
jne 0x2c80
movq %rsi, 0x20(%rsp)
andl $0x0, (%rsi)
movq %rdx, 0x18(%rsp)
andl $0x0, (%rdx)
leaq 0x8(%r14), %rax
movq %rax, 0x90(%rsp)
movq 0x28(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x88(%rsp)
leaq 0x20(%rax), %rcx
movq %rcx, 0x80(%rsp)
leaq 0x38(%rax), %rcx
movq %rcx, 0x78(%rsp)
leaq 0x50(%rax), %rcx
movq %rcx, 0x70(%rsp)
leaq 0x68(%rax), %rcx
movq %rcx, 0x68(%rsp)
leaq 0x80(%rax), %rcx
movq %rcx, 0x60(%rsp)
leaq 0x98(%rax), %rcx
movq %rcx, 0x58(%rsp)
leaq 0xb0(%rax), %rcx
movq %rcx, 0x50(%rsp)
leaq 0xc8(%rax), %rcx
movq %rcx, 0x48(%rsp)
addq $0xe0, %rax
movq %rax, 0x40(%rsp)
cmpl $0x0, 0x20(%r14)
pushq $0x1
popq %rax
jne 0x2c62
movups 0x44(%r14), %xmm0
movups %xmm0, 0x40(%r14)
movl 0x54(%r14), %eax
movl %eax, 0x50(%r14)
movl 0x1c(%r14), %eax
movl %eax, 0x54(%r14)
movups 0x2c(%r14), %xmm0
movups %xmm0, 0x28(%r14)
movl 0x3c(%r14), %eax
movl %eax, 0x38(%r14)
movq 0x90(%rsp), %rdi
callq *0x8(%r14)
movl %eax, 0x8(%rsp)
movl %eax, 0x3c(%r14)
movq 0x28(%rsp), %rax
movl (%rax), %ebp
movl 0x28(%r14), %esi
movq %rsi, 0xa0(%rsp)
movq 0x88(%rsp), %rdi
callq 0x2d64
movl %eax, %ebx
addl %ebp, %ebx
movl 0x2c(%r14), %esi
movq %rsi, 0x98(%rsp)
movq 0x80(%rsp), %rdi
callq 0x2d64
movl %eax, %r13d
movl 0x30(%r14), %r12d
movq 0x78(%rsp), %rdi
movq %r12, %rsi
callq 0x2d64
movl %eax, %r15d
addl %r13d, %r15d
addl %ebx, %r15d
movl 0x34(%r14), %esi
movq %rsi, 0x10(%rsp)
movq 0x70(%rsp), %rdi
callq 0x2d64
movl %eax, %ebp
movl 0x38(%r14), %esi
movq %rsi, 0x38(%rsp)
movq 0x68(%rsp), %rdi
callq 0x2d64
movl %eax, %ebx
addl %ebp, %ebx
movl 0x8(%rsp), %esi
movq %rsi, 0x8(%rsp)
movq 0x60(%rsp), %rdi
callq 0x2d64
movl %eax, %ebp
addl %ebx, %ebp
addl %r15d, %ebp
movq 0x58(%rsp), %rdi
movq 0x98(%rsp), %r13
movq %r13, %rsi
movq %r12, 0x30(%rsp)
movq %r12, %rdx
callq 0x2c92
movl %eax, %ebx
movq 0x50(%rsp), %rdi
movq %r12, %rsi
movq 0x10(%rsp), %r12
movq %r12, %rdx
callq 0x2c92
movl %eax, %r15d
addl %ebx, %r15d
movq 0x48(%rsp), %rdi
movq %r12, %rsi
movq 0x38(%rsp), %rdx
callq 0x2c92
movl %eax, %ebx
addl %r15d, %ebx
movq 0x40(%rsp), %r12
movq %r12, %rdi
movq 0xa0(%rsp), %rsi
movq %r13, %rdx
movq 0x30(%rsp), %rcx
callq 0x2c9e
movl %eax, %r15d
addl %ebx, %r15d
addl %ebp, %r15d
movq %r12, %rdi
movq %r13, %rsi
movq 0x30(%rsp), %r13
movq %r13, %rdx
movq 0x10(%rsp), %rbp
movq %rbp, %rcx
callq 0x2c9e
movl %eax, %ebx
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq 0x38(%rsp), %r13
movq %r13, %rcx
callq 0x2c9e
movl %eax, %ebp
addl %ebx, %ebp
addl %r15d, %ebp
movq %r12, %rdi
movq 0x10(%rsp), %rsi
movq %r13, %rdx
movq 0x8(%rsp), %rcx
callq 0x2c9e
addl %ebp, %eax
jle 0x2a78
movl 0x4c(%r14), %esi
movl 0x58(%r14), %ecx
cmpl %esi, %ecx
je 0x2a78
movq 0x20(%rsp), %rdx
movl %ecx, (%rdx)
movq 0x18(%rsp), %rcx
movl %esi, (%rcx)
movl %esi, 0x58(%r14)
cmpl $0x0, 0x20(%r14)
pushq $0x1
popq %rax
jne 0x2c6b
jmp 0x2c80
movl 0x58(%r14), %esi
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rdx
movl %esi, (%rdx)
movl 0x50(%r14), %edx
movl %edx, (%rcx)
movl $0x1, 0x5c(%r14)
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| boundary_iterator_next:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A8h
mov rcx, [rdi]
xor eax, eax
mov [rsp+0D8h+var_B0], rcx
test rcx, rcx
jz loc_2C80
mov r14, rdi
cmp qword ptr [rdi+10h], 0
jz loc_2C80
cmp dword ptr [r14+5Ch], 0
jnz loc_2C80
mov [rsp+0D8h+var_B8], rsi
and dword ptr [rsi], 0
mov [rsp+0D8h+var_C0], rdx
and dword ptr [rdx], 0
lea rax, [r14+8]
mov [rsp+0D8h+var_48], rax
mov rax, [rsp+0D8h+var_B0]
lea rcx, [rax+8]
mov [rsp+0D8h+var_50], rcx
lea rcx, [rax+20h]
mov [rsp+0D8h+var_58], rcx
lea rcx, [rax+38h]
mov [rsp+0D8h+var_60], rcx
lea rcx, [rax+50h]
mov [rsp+0D8h+var_68], rcx
lea rcx, [rax+68h]
mov [rsp+0D8h+var_70], rcx
lea rcx, [rax+80h]
mov [rsp+0D8h+var_78], rcx
lea rcx, [rax+98h]
mov [rsp+0D8h+var_80], rcx
lea rcx, [rax+0B0h]
mov [rsp+0D8h+var_88], rcx
lea rcx, [rax+0C8h]
mov [rsp+0D8h+var_90], rcx
add rax, 0E0h
mov [rsp+0D8h+var_98], rax
loc_2A78:
cmp dword ptr [r14+20h], 0
push 1
pop rax
jnz loc_2C62
movups xmm0, xmmword ptr [r14+44h]
movups xmmword ptr [r14+40h], xmm0
mov eax, [r14+54h]
mov [r14+50h], eax
mov eax, [r14+1Ch]
mov [r14+54h], eax
movups xmm0, xmmword ptr [r14+2Ch]
movups xmmword ptr [r14+28h], xmm0
mov eax, [r14+3Ch]
mov [r14+38h], eax
mov rdi, [rsp+0D8h+var_48]
call qword ptr [r14+8]
mov dword ptr [rsp+0D8h+var_D0], eax
mov [r14+3Ch], eax
mov rax, [rsp+0D8h+var_B0]
mov ebp, [rax]
mov esi, [r14+28h]
mov [rsp+0D8h+var_38], rsi
mov rdi, [rsp+0D8h+var_50]
call find_weight
mov ebx, eax
add ebx, ebp
mov esi, [r14+2Ch]
mov [rsp+0D8h+var_40], rsi
mov rdi, [rsp+0D8h+var_58]
call find_weight
mov r13d, eax
mov r12d, [r14+30h]
mov rdi, [rsp+0D8h+var_60]
mov rsi, r12
call find_weight
mov r15d, eax
add r15d, r13d
add r15d, ebx
mov esi, [r14+34h]
mov [rsp+0D8h+var_C8], rsi
mov rdi, [rsp+0D8h+var_68]
call find_weight
mov ebp, eax
mov esi, [r14+38h]
mov [rsp+0D8h+var_A0], rsi
mov rdi, [rsp+0D8h+var_70]
call find_weight
mov ebx, eax
add ebx, ebp
mov esi, dword ptr [rsp+0D8h+var_D0]
mov [rsp+0D8h+var_D0], rsi
mov rdi, [rsp+0D8h+var_78]
call find_weight
mov ebp, eax
add ebp, ebx
add ebp, r15d
mov rdi, [rsp+0D8h+var_80]
mov r13, [rsp+0D8h+var_40]
mov rsi, r13
mov [rsp+0D8h+var_A8], r12
mov rdx, r12
call find_bi_weight
mov ebx, eax
mov rdi, [rsp+0D8h+var_88]
mov rsi, r12
mov r12, [rsp+0D8h+var_C8]
mov rdx, r12
call find_bi_weight
mov r15d, eax
add r15d, ebx
mov rdi, [rsp+0D8h+var_90]
mov rsi, r12
mov rdx, [rsp+0D8h+var_A0]
call find_bi_weight
mov ebx, eax
add ebx, r15d
mov r12, [rsp+0D8h+var_98]
mov rdi, r12
mov rsi, [rsp+0D8h+var_38]
mov rdx, r13
mov rcx, [rsp+0D8h+var_A8]
call find_tri_weight
mov r15d, eax
add r15d, ebx
add r15d, ebp
mov rdi, r12
mov rsi, r13
mov r13, [rsp+0D8h+var_A8]
mov rdx, r13
mov rbp, [rsp+0D8h+var_C8]
mov rcx, rbp
call find_tri_weight
mov ebx, eax
mov rdi, r12
mov rsi, r13
mov rdx, rbp
mov r13, [rsp+0D8h+var_A0]
mov rcx, r13
call find_tri_weight
mov ebp, eax
add ebp, ebx
add ebp, r15d
mov rdi, r12
mov rsi, [rsp+0D8h+var_C8]
mov rdx, r13
mov rcx, [rsp+0D8h+var_D0]
call find_tri_weight
add eax, ebp
jle loc_2A78
mov esi, [r14+4Ch]
mov ecx, [r14+58h]
cmp ecx, esi
jz loc_2A78
mov rdx, [rsp+0D8h+var_B8]
mov [rdx], ecx
mov rcx, [rsp+0D8h+var_C0]
mov [rcx], esi
mov [r14+58h], esi
cmp dword ptr [r14+20h], 0
push 1
pop rax
jnz short loc_2C6B
jmp short loc_2C80
loc_2C62:
mov esi, [r14+58h]
mov rcx, [rsp+0D8h+var_C0]
loc_2C6B:
mov rdx, [rsp+0D8h+var_B8]
mov [rdx], esi
mov edx, [r14+50h]
mov [rcx], edx
mov dword ptr [r14+5Ch], 1
loc_2C80:
add rsp, 0A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long boundary_iterator_next(long long a1, _DWORD *a2, _DWORD *a3)
{
long long result; // rax
int v4; // ebp
int v5; // ebx
int weight; // r13d
long long v7; // r12
int v8; // r15d
int v9; // ebp
int v10; // ebx
int v11; // ebp
int bi_weight; // ebx
int v13; // r15d
int v14; // ebx
int v15; // r15d
int tri_weight; // ebx
int v17; // ebp
int v18; // eax
int v19; // esi
int v20; // ecx
_DWORD *v21; // rcx
unsigned int v22; // [rsp+8h] [rbp-D0h]
long long v23; // [rsp+10h] [rbp-C8h]
int *v26; // [rsp+28h] [rbp-B0h]
long long v27; // [rsp+38h] [rbp-A0h]
_DWORD *v28; // [rsp+40h] [rbp-98h]
long long v29; // [rsp+98h] [rbp-40h]
long long v30; // [rsp+A0h] [rbp-38h]
result = 0LL;
v26 = *(int **)a1;
if ( *(_QWORD *)a1 && *(_QWORD *)(a1 + 16) && !*(_DWORD *)(a1 + 92) )
{
*a2 = 0;
*a3 = 0;
v28 = v26 + 56;
while ( 1 )
{
result = 1LL;
if ( *(_DWORD *)(a1 + 32) )
{
v19 = *(_DWORD *)(a1 + 88);
v21 = a3;
goto LABEL_11;
}
*(_OWORD *)(a1 + 64) = *(_OWORD *)(a1 + 68);
*(_DWORD *)(a1 + 80) = *(_DWORD *)(a1 + 84);
*(_DWORD *)(a1 + 84) = *(_DWORD *)(a1 + 28);
*(_OWORD *)(a1 + 40) = *(_OWORD *)(a1 + 44);
*(_DWORD *)(a1 + 56) = *(_DWORD *)(a1 + 60);
v22 = (*(long long ( **)(long long))(a1 + 8))(a1 + 8);
*(_DWORD *)(a1 + 60) = v22;
v4 = *v26;
v30 = *(unsigned int *)(a1 + 40);
v5 = v4 + find_weight(v26 + 2);
v29 = *(unsigned int *)(a1 + 44);
weight = find_weight(v26 + 8);
v7 = *(unsigned int *)(a1 + 48);
v8 = v5 + weight + find_weight(v26 + 14);
v23 = *(unsigned int *)(a1 + 52);
v9 = find_weight(v26 + 20);
v27 = *(unsigned int *)(a1 + 56);
v10 = v9 + find_weight(v26 + 26);
v11 = v8 + v10 + find_weight(v26 + 32);
bi_weight = find_bi_weight(v26 + 38, v29, v7);
v13 = bi_weight + find_bi_weight(v26 + 44, v7, v23);
v14 = v13 + find_bi_weight(v26 + 50, v23, v27);
v15 = v11 + v14 + find_tri_weight(v28, v30, v29, v7);
tri_weight = find_tri_weight(v28, v29, v7, v23);
v17 = v15 + tri_weight + find_tri_weight(v28, v7, v23, v27);
v18 = find_tri_weight(v28, v23, v27, v22);
if ( !((v17 + v18 < 0) ^ __OFADD__(v17, v18) | (v17 + v18 == 0)) )
{
v19 = *(_DWORD *)(a1 + 76);
v20 = *(_DWORD *)(a1 + 88);
if ( v20 != v19 )
break;
}
}
*a2 = v20;
v21 = a3;
*a3 = v19;
*(_DWORD *)(a1 + 88) = v19;
result = 1LL;
if ( !*(_DWORD *)(a1 + 32) )
return result;
LABEL_11:
*a2 = v19;
*v21 = *(_DWORD *)(a1 + 80);
*(_DWORD *)(a1 + 92) = 1;
}
return result;
}
| boundary_iterator_next:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa8
MOV RCX,qword ptr [RDI]
XOR EAX,EAX
MOV qword ptr [RSP + 0x28],RCX
TEST RCX,RCX
JZ 0x00102c80
MOV R14,RDI
CMP qword ptr [RDI + 0x10],0x0
JZ 0x00102c80
CMP dword ptr [R14 + 0x5c],0x0
JNZ 0x00102c80
MOV qword ptr [RSP + 0x20],RSI
AND dword ptr [RSI],0x0
MOV qword ptr [RSP + 0x18],RDX
AND dword ptr [RDX],0x0
LEA RAX,[R14 + 0x8]
MOV qword ptr [RSP + 0x90],RAX
MOV RAX,qword ptr [RSP + 0x28]
LEA RCX,[RAX + 0x8]
MOV qword ptr [RSP + 0x88],RCX
LEA RCX,[RAX + 0x20]
MOV qword ptr [RSP + 0x80],RCX
LEA RCX,[RAX + 0x38]
MOV qword ptr [RSP + 0x78],RCX
LEA RCX,[RAX + 0x50]
MOV qword ptr [RSP + 0x70],RCX
LEA RCX,[RAX + 0x68]
MOV qword ptr [RSP + 0x68],RCX
LEA RCX,[RAX + 0x80]
MOV qword ptr [RSP + 0x60],RCX
LEA RCX,[RAX + 0x98]
MOV qword ptr [RSP + 0x58],RCX
LEA RCX,[RAX + 0xb0]
MOV qword ptr [RSP + 0x50],RCX
LEA RCX,[RAX + 0xc8]
MOV qword ptr [RSP + 0x48],RCX
ADD RAX,0xe0
MOV qword ptr [RSP + 0x40],RAX
LAB_00102a78:
CMP dword ptr [R14 + 0x20],0x0
PUSH 0x1
POP RAX
JNZ 0x00102c62
MOVUPS XMM0,xmmword ptr [R14 + 0x44]
MOVUPS xmmword ptr [R14 + 0x40],XMM0
MOV EAX,dword ptr [R14 + 0x54]
MOV dword ptr [R14 + 0x50],EAX
MOV EAX,dword ptr [R14 + 0x1c]
MOV dword ptr [R14 + 0x54],EAX
MOVUPS XMM0,xmmword ptr [R14 + 0x2c]
MOVUPS xmmword ptr [R14 + 0x28],XMM0
MOV EAX,dword ptr [R14 + 0x3c]
MOV dword ptr [R14 + 0x38],EAX
MOV RDI,qword ptr [RSP + 0x90]
CALL qword ptr [R14 + 0x8]
MOV dword ptr [RSP + 0x8],EAX
MOV dword ptr [R14 + 0x3c],EAX
MOV RAX,qword ptr [RSP + 0x28]
MOV EBP,dword ptr [RAX]
MOV ESI,dword ptr [R14 + 0x28]
MOV qword ptr [RSP + 0xa0],RSI
MOV RDI,qword ptr [RSP + 0x88]
CALL 0x00102d64
MOV EBX,EAX
ADD EBX,EBP
MOV ESI,dword ptr [R14 + 0x2c]
MOV qword ptr [RSP + 0x98],RSI
MOV RDI,qword ptr [RSP + 0x80]
CALL 0x00102d64
MOV R13D,EAX
MOV R12D,dword ptr [R14 + 0x30]
MOV RDI,qword ptr [RSP + 0x78]
MOV RSI,R12
CALL 0x00102d64
MOV R15D,EAX
ADD R15D,R13D
ADD R15D,EBX
MOV ESI,dword ptr [R14 + 0x34]
MOV qword ptr [RSP + 0x10],RSI
MOV RDI,qword ptr [RSP + 0x70]
CALL 0x00102d64
MOV EBP,EAX
MOV ESI,dword ptr [R14 + 0x38]
MOV qword ptr [RSP + 0x38],RSI
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x00102d64
MOV EBX,EAX
ADD EBX,EBP
MOV ESI,dword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x8],RSI
MOV RDI,qword ptr [RSP + 0x60]
CALL 0x00102d64
MOV EBP,EAX
ADD EBP,EBX
ADD EBP,R15D
MOV RDI,qword ptr [RSP + 0x58]
MOV R13,qword ptr [RSP + 0x98]
MOV RSI,R13
MOV qword ptr [RSP + 0x30],R12
MOV RDX,R12
CALL 0x00102c92
MOV EBX,EAX
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,R12
MOV R12,qword ptr [RSP + 0x10]
MOV RDX,R12
CALL 0x00102c92
MOV R15D,EAX
ADD R15D,EBX
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,R12
MOV RDX,qword ptr [RSP + 0x38]
CALL 0x00102c92
MOV EBX,EAX
ADD EBX,R15D
MOV R12,qword ptr [RSP + 0x40]
MOV RDI,R12
MOV RSI,qword ptr [RSP + 0xa0]
MOV RDX,R13
MOV RCX,qword ptr [RSP + 0x30]
CALL 0x00102c9e
MOV R15D,EAX
ADD R15D,EBX
ADD R15D,EBP
MOV RDI,R12
MOV RSI,R13
MOV R13,qword ptr [RSP + 0x30]
MOV RDX,R13
MOV RBP,qword ptr [RSP + 0x10]
MOV RCX,RBP
CALL 0x00102c9e
MOV EBX,EAX
MOV RDI,R12
MOV RSI,R13
MOV RDX,RBP
MOV R13,qword ptr [RSP + 0x38]
MOV RCX,R13
CALL 0x00102c9e
MOV EBP,EAX
ADD EBP,EBX
ADD EBP,R15D
MOV RDI,R12
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,R13
MOV RCX,qword ptr [RSP + 0x8]
CALL 0x00102c9e
ADD EAX,EBP
JLE 0x00102a78
MOV ESI,dword ptr [R14 + 0x4c]
MOV ECX,dword ptr [R14 + 0x58]
CMP ECX,ESI
JZ 0x00102a78
MOV RDX,qword ptr [RSP + 0x20]
MOV dword ptr [RDX],ECX
MOV RCX,qword ptr [RSP + 0x18]
MOV dword ptr [RCX],ESI
MOV dword ptr [R14 + 0x58],ESI
CMP dword ptr [R14 + 0x20],0x0
PUSH 0x1
POP RAX
JNZ 0x00102c6b
JMP 0x00102c80
LAB_00102c62:
MOV ESI,dword ptr [R14 + 0x58]
MOV RCX,qword ptr [RSP + 0x18]
LAB_00102c6b:
MOV RDX,qword ptr [RSP + 0x20]
MOV dword ptr [RDX],ESI
MOV EDX,dword ptr [R14 + 0x50]
MOV dword ptr [RCX],EDX
MOV dword ptr [R14 + 0x5c],0x1
LAB_00102c80:
ADD RSP,0xa8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 boundary_iterator_next(int8 *param_1,int *param_2,int *param_3)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
int4 uVar4;
int4 uVar5;
int *piVar6;
int4 uVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
int iVar16;
int iVar17;
int iVar18;
int iVar19;
int iVar20;
int8 uVar21;
int *piVar22;
piVar6 = (int *)*param_1;
uVar21 = 0;
if (((piVar6 != (int *)0x0) && (param_1[2] != 0)) && (*(int *)((long)param_1 + 0x5c) == 0)) {
*param_2 = 0;
*param_3 = 0;
piVar22 = piVar6 + 0x38;
do {
do {
if (*(int *)(param_1 + 4) != 0) {
iVar20 = *(int *)(param_1 + 0xb);
goto LAB_00102c6b;
}
param_1[8] = *(int8 *)((long)param_1 + 0x44);
param_1[9] = *(int8 *)((long)param_1 + 0x4c);
*(int4 *)(param_1 + 10) = *(int4 *)((long)param_1 + 0x54);
*(int4 *)((long)param_1 + 0x54) = *(int4 *)((long)param_1 + 0x1c);
*(int4 *)(param_1 + 5) = *(int4 *)((long)param_1 + 0x2c);
*(int4 *)((long)param_1 + 0x2c) = *(int4 *)(param_1 + 6);
*(int4 *)(param_1 + 6) = *(int4 *)((long)param_1 + 0x34);
*(int4 *)((long)param_1 + 0x34) = *(int4 *)(param_1 + 7);
*(int4 *)(param_1 + 7) = *(int4 *)((long)param_1 + 0x3c);
uVar7 = (*(code *)param_1[1])(param_1 + 1);
*(int4 *)((long)param_1 + 0x3c) = uVar7;
iVar20 = *piVar6;
uVar1 = *(int4 *)(param_1 + 5);
iVar8 = find_weight(piVar6 + 2);
uVar2 = *(int4 *)((long)param_1 + 0x2c);
iVar9 = find_weight(piVar6 + 8);
uVar3 = *(int4 *)(param_1 + 6);
iVar10 = find_weight(piVar6 + 0xe,uVar3);
uVar4 = *(int4 *)((long)param_1 + 0x34);
iVar11 = find_weight(piVar6 + 0x14);
uVar5 = *(int4 *)(param_1 + 7);
iVar12 = find_weight(piVar6 + 0x1a);
iVar13 = find_weight(piVar6 + 0x20);
iVar14 = find_bi_weight(piVar6 + 0x26,uVar2,uVar3);
iVar15 = find_bi_weight(piVar6 + 0x2c,uVar3,uVar4);
iVar16 = find_bi_weight(piVar6 + 0x32,uVar4,uVar5);
iVar17 = find_tri_weight(piVar22,uVar1,uVar2,uVar3);
iVar18 = find_tri_weight(piVar22,uVar2,uVar3,uVar4);
iVar19 = find_tri_weight(piVar22,uVar3,uVar4,uVar5);
iVar9 = iVar19 + iVar18 +
iVar17 + iVar16 + iVar15 + iVar14 +
iVar13 + iVar12 + iVar11 + iVar10 + iVar9 + iVar8 + iVar20;
iVar20 = find_tri_weight(piVar22,uVar4,uVar5,uVar7);
iVar8 = iVar20 + iVar9;
} while (iVar8 == 0 || SCARRY4(iVar20,iVar9) != iVar8 < 0);
iVar20 = *(int *)((long)param_1 + 0x4c);
} while (*(int *)(param_1 + 0xb) == iVar20);
*param_2 = *(int *)(param_1 + 0xb);
*param_3 = iVar20;
*(int *)(param_1 + 0xb) = iVar20;
uVar21 = 1;
if (*(int *)(param_1 + 4) != 0) {
LAB_00102c6b:
uVar21 = 1;
*param_2 = iVar20;
*param_3 = *(int *)(param_1 + 10);
*(int4 *)((long)param_1 + 0x5c) = 1;
}
}
return uVar21;
}
| |
41,601 | boundary_iterator_next | memononen[P]budouxc/src/budoux.c | int32_t boundary_iterator_next(boundary_iterator_t* bit, int32_t* range_start, int32_t* range_end)
{
if (!bit->model || !bit->utf_iter.buf || bit->done)
return 0;
uint32_t* buffer = bit->buffer;
int32_t* offset = bit->offset;
const budoux_model_t* model = bit->model;
*range_start = 0;
*range_end = 0;
while (!bit->utf_iter.done) {
ROLL(offset);
offset[5] = bit->utf_iter.pos;
ROLL(buffer);
buffer[5] = bit->utf_iter.get(&bit->utf_iter);
// buffer[0] is -3, buffer[3] = 0, buffer[5] = +2;
int score = model->base_score;
score += find_uni_weight(&model->UW1, buffer[0]);
score += find_uni_weight(&model->UW2, buffer[1]);
score += find_uni_weight(&model->UW3, buffer[2]);
score += find_uni_weight(&model->UW4, buffer[3]);
score += find_uni_weight(&model->UW5, buffer[4]);
score += find_uni_weight(&model->UW6, buffer[5]);
score += find_bi_weight(&model->BW1, buffer[1],buffer[2]);
score += find_bi_weight(&model->BW2, buffer[2],buffer[3]);
score += find_bi_weight(&model->BW3, buffer[3],buffer[4]);
score += find_tri_weight(&model->TW1, buffer[0],buffer[1],buffer[2]);
score += find_tri_weight(&model->TW1, buffer[1],buffer[2],buffer[3]);
score += find_tri_weight(&model->TW1, buffer[2],buffer[3],buffer[4]);
score += find_tri_weight(&model->TW1, buffer[3],buffer[4],buffer[5]);
int32_t pos_end = offset[3];
if (score > 0 && bit->range_start != pos_end) {
*range_start = bit->range_start;
*range_end = pos_end;
bit->range_start = pos_end;
break;
}
}
if (bit->utf_iter.done) {
*range_start = bit->range_start;
*range_end = offset[3+1]; // 3 is the start of last processed codepoint, 3+1 is null term.
bit->done = 1;
}
return 1;
} | O3 | c | boundary_iterator_next:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq (%rdi), %rcx
xorl %eax, %eax
movq %rcx, 0x30(%rsp)
testq %rcx, %rcx
je 0x2d84
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0x2d84
cmpl $0x0, 0x5c(%r14)
jne 0x2d84
xorl %eax, %eax
movq %rsi, 0x20(%rsp)
movl %eax, (%rsi)
movq %rdx, 0x28(%rsp)
movl %eax, (%rdx)
cmpl %eax, 0x20(%r14)
jne 0x2d61
leaq 0x8(%r14), %rax
movq %rax, 0x98(%rsp)
movq 0x30(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x90(%rsp)
leaq 0x20(%rax), %rcx
movq %rcx, 0x88(%rsp)
leaq 0x38(%rax), %rcx
movq %rcx, 0x80(%rsp)
leaq 0x50(%rax), %rcx
movq %rcx, 0x78(%rsp)
leaq 0x68(%rax), %rcx
movq %rcx, 0x70(%rsp)
leaq 0x80(%rax), %rcx
movq %rcx, 0x68(%rsp)
leaq 0x98(%rax), %rcx
movq %rcx, 0x60(%rsp)
leaq 0xb0(%rax), %rcx
movq %rcx, 0x58(%rsp)
leaq 0xc8(%rax), %rcx
movq %rcx, 0x50(%rsp)
addq $0xe0, %rax
movq %rax, 0x48(%rsp)
movdqu 0x2c(%r14), %xmm0
movl 0x3c(%r14), %ecx
movq %r14, 0x40(%rsp)
movups 0x44(%r14), %xmm1
movups %xmm1, 0x40(%r14)
movl 0x54(%r14), %eax
movl %eax, 0x50(%r14)
movl 0x1c(%r14), %eax
movl %eax, 0x54(%r14)
movl %ecx, 0x38(%r14)
movdqu %xmm0, 0x28(%r14)
movq 0x98(%rsp), %rdi
callq *0x8(%r14)
movl %eax, %r13d
movl %eax, 0x3c(%r14)
movq 0x30(%rsp), %rax
movl (%rax), %ebx
movl 0x28(%r14), %esi
movq %rsi, 0xb0(%rsp)
movq 0x90(%rsp), %rdi
callq 0x2e0b
movl %eax, %ebp
addl %ebx, %ebp
movl 0x2c(%r14), %esi
movq %rsi, 0x10(%rsp)
movq 0x88(%rsp), %rdi
callq 0x2e0b
movl %eax, %r12d
movl 0x30(%r14), %r15d
movq 0x80(%rsp), %rdi
movq %r15, %rsi
callq 0x2e0b
movl %eax, %ebx
addl %r12d, %ebx
addl %ebp, %ebx
movl 0x34(%r14), %esi
movq %rsi, 0x38(%rsp)
movq 0x78(%rsp), %rdi
callq 0x2e0b
movl %eax, %ebp
movl 0x38(%r14), %esi
movq %rsi, 0x8(%rsp)
movq 0x70(%rsp), %rdi
callq 0x2e0b
movl %eax, %r12d
addl %ebp, %r12d
movl %r13d, 0x1c(%rsp)
movl %r13d, %esi
movq %rsi, 0xa8(%rsp)
movq 0x68(%rsp), %rdi
callq 0x2e0b
movl %eax, %ebp
addl %r12d, %ebp
addl %ebx, %ebp
movq %r15, %rbx
shlq $0x14, %rbx
orq 0x10(%rsp), %rbx
movq 0x60(%rsp), %rdi
movq %rbx, %rsi
callq 0x2e0b
movl %eax, 0x4(%rsp)
movq 0x38(%rsp), %r12
movq %r12, %r14
shlq $0x14, %r14
orq %r15, %r14
movq 0x58(%rsp), %rdi
movq %r14, %rsi
callq 0x2e0b
movl %eax, %r13d
addl 0x4(%rsp), %r13d
addl %ebp, %r13d
movq 0x8(%rsp), %rbp
shlq $0x14, %rbp
orq %r12, %rbp
movq 0x50(%rsp), %rdi
movq %rbp, %rsi
callq 0x2e0b
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
shlq $0x14, %rax
movq %r15, 0xa0(%rsp)
shlq $0x28, %r15
orq %rax, %r15
orq 0xb0(%rsp), %r15
movq 0x48(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2e0b
movl %eax, %r15d
addl 0x4(%rsp), %r15d
addl %r13d, %r15d
movq 0x38(%rsp), %r13
movq %r13, %rsi
shlq $0x28, %rsi
orq %rbx, %rsi
movq %r12, %rdi
callq 0x2e0b
movl %eax, %ebx
movq 0x8(%rsp), %rsi
shlq $0x28, %rsi
orq %r14, %rsi
movq %r12, %r14
movq %r12, %rdi
callq 0x2e0b
movl %eax, %r12d
addl %ebx, %r12d
addl %r15d, %r12d
movq 0xa8(%rsp), %rsi
shlq $0x28, %rsi
orq %rbp, %rsi
movq %r14, %rdi
movq 0x40(%rsp), %r14
callq 0x2e0b
addl %r12d, %eax
jle 0x2d11
movl 0x4c(%r14), %eax
movl 0x58(%r14), %ecx
cmpl %eax, %ecx
jne 0x2d48
cmpl $0x0, 0x20(%r14)
movd 0x8(%rsp), %xmm0
movd %r13d, %xmm1
punpckldq %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movd 0xa0(%rsp), %xmm2
movd 0x10(%rsp), %xmm0
punpckldq %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
punpcklqdq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movl 0x1c(%rsp), %ecx
je 0x2b31
jmp 0x2d61
movq 0x20(%rsp), %rdx
movl %ecx, (%rdx)
movq 0x28(%rsp), %rcx
movl %eax, (%rcx)
movl %eax, 0x58(%r14)
cmpl $0x0, 0x20(%r14)
je 0x2d7f
movl 0x58(%r14), %eax
movq 0x20(%rsp), %rcx
movl %eax, (%rcx)
movl 0x50(%r14), %eax
movq 0x28(%rsp), %rcx
movl %eax, (%rcx)
movl $0x1, 0x5c(%r14)
movl $0x1, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| boundary_iterator_next:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0B8h
mov rcx, [rdi]
xor eax, eax
mov [rsp+0E8h+var_B8], rcx
test rcx, rcx
jz loc_2D84
mov r14, rdi
cmp qword ptr [rdi+10h], 0
jz loc_2D84
cmp dword ptr [r14+5Ch], 0
jnz loc_2D84
xor eax, eax
mov [rsp+0E8h+var_C8], rsi
mov [rsi], eax
mov [rsp+0E8h+var_C0], rdx
mov [rdx], eax
cmp [r14+20h], eax
jnz loc_2D61
lea rax, [r14+8]
mov [rsp+0E8h+var_50], rax
mov rax, [rsp+0E8h+var_B8]
lea rcx, [rax+8]
mov [rsp+0E8h+var_58], rcx
lea rcx, [rax+20h]
mov [rsp+0E8h+var_60], rcx
lea rcx, [rax+38h]
mov [rsp+0E8h+var_68], rcx
lea rcx, [rax+50h]
mov [rsp+0E8h+var_70], rcx
lea rcx, [rax+68h]
mov [rsp+0E8h+var_78], rcx
lea rcx, [rax+80h]
mov [rsp+0E8h+var_80], rcx
lea rcx, [rax+98h]
mov [rsp+0E8h+var_88], rcx
lea rcx, [rax+0B0h]
mov [rsp+0E8h+var_90], rcx
lea rcx, [rax+0C8h]
mov [rsp+0E8h+var_98], rcx
add rax, 0E0h
mov [rsp+0E8h+var_A0], rax
movdqu xmm0, xmmword ptr [r14+2Ch]
mov ecx, [r14+3Ch]
mov [rsp+0E8h+var_A8], r14
loc_2B31:
movups xmm1, xmmword ptr [r14+44h]
movups xmmword ptr [r14+40h], xmm1
mov eax, [r14+54h]
mov [r14+50h], eax
mov eax, [r14+1Ch]
mov [r14+54h], eax
mov [r14+38h], ecx
movdqu xmmword ptr [r14+28h], xmm0
mov rdi, [rsp+0E8h+var_50]
call qword ptr [r14+8]
mov r13d, eax
mov [r14+3Ch], eax
mov rax, [rsp+0E8h+var_B8]
mov ebx, [rax]
mov esi, [r14+28h]
mov [rsp+0E8h+var_38], rsi
mov rdi, [rsp+0E8h+var_58]
call find_weight
mov ebp, eax
add ebp, ebx
mov esi, [r14+2Ch]
mov [rsp+0E8h+var_D8], rsi
mov rdi, [rsp+0E8h+var_60]
call find_weight
mov r12d, eax
mov r15d, [r14+30h]
mov rdi, [rsp+0E8h+var_68]
mov rsi, r15
call find_weight
mov ebx, eax
add ebx, r12d
add ebx, ebp
mov esi, [r14+34h]
mov [rsp+0E8h+var_B0], rsi
mov rdi, [rsp+0E8h+var_70]
call find_weight
mov ebp, eax
mov esi, [r14+38h]
mov [rsp+0E8h+var_E0], rsi
mov rdi, [rsp+0E8h+var_78]
call find_weight
mov r12d, eax
add r12d, ebp
mov [rsp+0E8h+var_CC], r13d
mov esi, r13d
mov [rsp+0E8h+var_40], rsi
mov rdi, [rsp+0E8h+var_80]
call find_weight
mov ebp, eax
add ebp, r12d
add ebp, ebx
mov rbx, r15
shl rbx, 14h
or rbx, [rsp+0E8h+var_D8]
mov rdi, [rsp+0E8h+var_88]
mov rsi, rbx
call find_weight
mov [rsp+0E8h+var_E4], eax
mov r12, [rsp+0E8h+var_B0]
mov r14, r12
shl r14, 14h
or r14, r15
mov rdi, [rsp+0E8h+var_90]
mov rsi, r14
call find_weight
mov r13d, eax
add r13d, [rsp+0E8h+var_E4]
add r13d, ebp
mov rbp, [rsp+0E8h+var_E0]
shl rbp, 14h
or rbp, r12
mov rdi, [rsp+0E8h+var_98]
mov rsi, rbp
call find_weight
mov [rsp+0E8h+var_E4], eax
mov rax, [rsp+0E8h+var_D8]
shl rax, 14h
mov [rsp+0E8h+var_48], r15
shl r15, 28h
or r15, rax
or r15, [rsp+0E8h+var_38]
mov r12, [rsp+0E8h+var_A0]
mov rdi, r12
mov rsi, r15
call find_weight
mov r15d, eax
add r15d, [rsp+0E8h+var_E4]
add r15d, r13d
mov r13, [rsp+0E8h+var_B0]
mov rsi, r13
shl rsi, 28h
or rsi, rbx
mov rdi, r12
call find_weight
mov ebx, eax
mov rsi, [rsp+0E8h+var_E0]
shl rsi, 28h
or rsi, r14
mov r14, r12
mov rdi, r12
call find_weight
mov r12d, eax
add r12d, ebx
add r12d, r15d
mov rsi, [rsp+0E8h+var_40]
shl rsi, 28h
or rsi, rbp
mov rdi, r14
mov r14, [rsp+0E8h+var_A8]
call find_weight
add eax, r12d
jle short loc_2D11
mov eax, [r14+4Ch]
mov ecx, [r14+58h]
cmp ecx, eax
jnz short loc_2D48
loc_2D11:
cmp dword ptr [r14+20h], 0
movd xmm0, dword ptr [rsp+0E8h+var_E0]
movd xmm1, r13d
punpckldq xmm1, xmm0
movd xmm2, dword ptr [rsp+0E8h+var_48]
movd xmm0, dword ptr [rsp+0E8h+var_D8]
punpckldq xmm0, xmm2
punpcklqdq xmm0, xmm1
mov ecx, [rsp+0E8h+var_CC]
jz loc_2B31
jmp short loc_2D61
loc_2D48:
mov rdx, [rsp+0E8h+var_C8]
mov [rdx], ecx
mov rcx, [rsp+0E8h+var_C0]
mov [rcx], eax
mov [r14+58h], eax
cmp dword ptr [r14+20h], 0
jz short loc_2D7F
loc_2D61:
mov eax, [r14+58h]
mov rcx, [rsp+0E8h+var_C8]
mov [rcx], eax
mov eax, [r14+50h]
mov rcx, [rsp+0E8h+var_C0]
mov [rcx], eax
mov dword ptr [r14+5Ch], 1
loc_2D7F:
mov eax, 1
loc_2D84:
add rsp, 0B8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long boundary_iterator_next(long long a1, _DWORD *a2, _DWORD *a3)
{
long long result; // rax
long long v4; // r14
__m128i v5; // xmm0
int v6; // ecx
int v7; // r13d
int v8; // ebx
int v9; // ebp
int weight; // r12d
unsigned int v11; // r15d
int v12; // ebx
int v13; // ebp
int v14; // r12d
int v15; // ebp
int v16; // r13d
int v17; // r15d
int v18; // ebx
int v19; // r12d
int v20; // eax
int v21; // eax
int v22; // ecx
int v23; // [rsp+4h] [rbp-E4h]
int v24; // [rsp+4h] [rbp-E4h]
unsigned int v25; // [rsp+8h] [rbp-E0h]
unsigned int v26; // [rsp+10h] [rbp-D8h]
int v27; // [rsp+1Ch] [rbp-CCh]
int *v29; // [rsp+30h] [rbp-B8h]
unsigned int v30; // [rsp+38h] [rbp-B0h]
_DWORD *v31; // [rsp+48h] [rbp-A0h]
unsigned int v32; // [rsp+A0h] [rbp-48h]
result = 0LL;
v29 = *(int **)a1;
if ( *(_QWORD *)a1 )
{
v4 = a1;
if ( *(_QWORD *)(a1 + 16) )
{
if ( !*(_DWORD *)(a1 + 92) )
{
*a2 = 0;
*a3 = 0;
if ( *(_DWORD *)(a1 + 32) )
goto LABEL_11;
v31 = v29 + 56;
v5 = _mm_loadu_si128((const __m128i *)(a1 + 44));
v6 = *(_DWORD *)(a1 + 60);
while ( 1 )
{
*(_OWORD *)(v4 + 64) = *(_OWORD *)(v4 + 68);
*(_DWORD *)(v4 + 80) = *(_DWORD *)(v4 + 84);
*(_DWORD *)(v4 + 84) = *(_DWORD *)(v4 + 28);
*(_DWORD *)(v4 + 56) = v6;
*(__m128i *)(v4 + 40) = v5;
v7 = (*(long long ( **)(long long))(v4 + 8))(a1 + 8);
*(_DWORD *)(v4 + 60) = v7;
v8 = *v29;
v9 = v8 + find_weight(v29 + 2);
v26 = *(_DWORD *)(v4 + 44);
weight = find_weight(v29 + 8);
v11 = *(_DWORD *)(v4 + 48);
v12 = v9 + weight + find_weight(v29 + 14);
v30 = *(_DWORD *)(v4 + 52);
v13 = find_weight(v29 + 20);
v25 = *(_DWORD *)(v4 + 56);
v14 = v13 + find_weight(v29 + 26);
v27 = v7;
v15 = v12 + v14 + find_weight(v29 + 32);
v23 = find_weight(v29 + 38);
v16 = v15 + v23 + find_weight(v29 + 44);
v24 = find_weight(v29 + 50);
v32 = v11;
v17 = v16 + v24 + find_weight(v31);
v18 = find_weight(v31);
v19 = v17 + v18 + find_weight(v31);
v4 = a1;
v20 = find_weight(v31);
if ( !((v19 + v20 < 0) ^ __OFADD__(v19, v20) | (v19 + v20 == 0)) )
{
v21 = *(_DWORD *)(a1 + 76);
v22 = *(_DWORD *)(a1 + 88);
if ( v22 != v21 )
break;
}
v5 = _mm_unpacklo_epi64(
_mm_unpacklo_epi32(_mm_cvtsi32_si128(v26), _mm_cvtsi32_si128(v32)),
_mm_unpacklo_epi32(_mm_cvtsi32_si128(v30), _mm_cvtsi32_si128(v25)));
v6 = v27;
if ( *(_DWORD *)(a1 + 32) )
goto LABEL_11;
}
*a2 = v22;
*a3 = v21;
*(_DWORD *)(a1 + 88) = v21;
if ( *(_DWORD *)(a1 + 32) )
{
LABEL_11:
*a2 = *(_DWORD *)(v4 + 88);
*a3 = *(_DWORD *)(v4 + 80);
*(_DWORD *)(v4 + 92) = 1;
}
return 1LL;
}
}
}
return result;
}
| boundary_iterator_next:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xb8
MOV RCX,qword ptr [RDI]
XOR EAX,EAX
MOV qword ptr [RSP + 0x30],RCX
TEST RCX,RCX
JZ 0x00102d84
MOV R14,RDI
CMP qword ptr [RDI + 0x10],0x0
JZ 0x00102d84
CMP dword ptr [R14 + 0x5c],0x0
JNZ 0x00102d84
XOR EAX,EAX
MOV qword ptr [RSP + 0x20],RSI
MOV dword ptr [RSI],EAX
MOV qword ptr [RSP + 0x28],RDX
MOV dword ptr [RDX],EAX
CMP dword ptr [R14 + 0x20],EAX
JNZ 0x00102d61
LEA RAX,[R14 + 0x8]
MOV qword ptr [RSP + 0x98],RAX
MOV RAX,qword ptr [RSP + 0x30]
LEA RCX,[RAX + 0x8]
MOV qword ptr [RSP + 0x90],RCX
LEA RCX,[RAX + 0x20]
MOV qword ptr [RSP + 0x88],RCX
LEA RCX,[RAX + 0x38]
MOV qword ptr [RSP + 0x80],RCX
LEA RCX,[RAX + 0x50]
MOV qword ptr [RSP + 0x78],RCX
LEA RCX,[RAX + 0x68]
MOV qword ptr [RSP + 0x70],RCX
LEA RCX,[RAX + 0x80]
MOV qword ptr [RSP + 0x68],RCX
LEA RCX,[RAX + 0x98]
MOV qword ptr [RSP + 0x60],RCX
LEA RCX,[RAX + 0xb0]
MOV qword ptr [RSP + 0x58],RCX
LEA RCX,[RAX + 0xc8]
MOV qword ptr [RSP + 0x50],RCX
ADD RAX,0xe0
MOV qword ptr [RSP + 0x48],RAX
MOVDQU XMM0,xmmword ptr [R14 + 0x2c]
MOV ECX,dword ptr [R14 + 0x3c]
MOV qword ptr [RSP + 0x40],R14
LAB_00102b31:
MOVUPS XMM1,xmmword ptr [R14 + 0x44]
MOVUPS xmmword ptr [R14 + 0x40],XMM1
MOV EAX,dword ptr [R14 + 0x54]
MOV dword ptr [R14 + 0x50],EAX
MOV EAX,dword ptr [R14 + 0x1c]
MOV dword ptr [R14 + 0x54],EAX
MOV dword ptr [R14 + 0x38],ECX
MOVDQU xmmword ptr [R14 + 0x28],XMM0
MOV RDI,qword ptr [RSP + 0x98]
CALL qword ptr [R14 + 0x8]
MOV R13D,EAX
MOV dword ptr [R14 + 0x3c],EAX
MOV RAX,qword ptr [RSP + 0x30]
MOV EBX,dword ptr [RAX]
MOV ESI,dword ptr [R14 + 0x28]
MOV qword ptr [RSP + 0xb0],RSI
MOV RDI,qword ptr [RSP + 0x90]
CALL 0x00102e0b
MOV EBP,EAX
ADD EBP,EBX
MOV ESI,dword ptr [R14 + 0x2c]
MOV qword ptr [RSP + 0x10],RSI
MOV RDI,qword ptr [RSP + 0x88]
CALL 0x00102e0b
MOV R12D,EAX
MOV R15D,dword ptr [R14 + 0x30]
MOV RDI,qword ptr [RSP + 0x80]
MOV RSI,R15
CALL 0x00102e0b
MOV EBX,EAX
ADD EBX,R12D
ADD EBX,EBP
MOV ESI,dword ptr [R14 + 0x34]
MOV qword ptr [RSP + 0x38],RSI
MOV RDI,qword ptr [RSP + 0x78]
CALL 0x00102e0b
MOV EBP,EAX
MOV ESI,dword ptr [R14 + 0x38]
MOV qword ptr [RSP + 0x8],RSI
MOV RDI,qword ptr [RSP + 0x70]
CALL 0x00102e0b
MOV R12D,EAX
ADD R12D,EBP
MOV dword ptr [RSP + 0x1c],R13D
MOV ESI,R13D
MOV qword ptr [RSP + 0xa8],RSI
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x00102e0b
MOV EBP,EAX
ADD EBP,R12D
ADD EBP,EBX
MOV RBX,R15
SHL RBX,0x14
OR RBX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,RBX
CALL 0x00102e0b
MOV dword ptr [RSP + 0x4],EAX
MOV R12,qword ptr [RSP + 0x38]
MOV R14,R12
SHL R14,0x14
OR R14,R15
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,R14
CALL 0x00102e0b
MOV R13D,EAX
ADD R13D,dword ptr [RSP + 0x4]
ADD R13D,EBP
MOV RBP,qword ptr [RSP + 0x8]
SHL RBP,0x14
OR RBP,R12
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,RBP
CALL 0x00102e0b
MOV dword ptr [RSP + 0x4],EAX
MOV RAX,qword ptr [RSP + 0x10]
SHL RAX,0x14
MOV qword ptr [RSP + 0xa0],R15
SHL R15,0x28
OR R15,RAX
OR R15,qword ptr [RSP + 0xb0]
MOV R12,qword ptr [RSP + 0x48]
MOV RDI,R12
MOV RSI,R15
CALL 0x00102e0b
MOV R15D,EAX
ADD R15D,dword ptr [RSP + 0x4]
ADD R15D,R13D
MOV R13,qword ptr [RSP + 0x38]
MOV RSI,R13
SHL RSI,0x28
OR RSI,RBX
MOV RDI,R12
CALL 0x00102e0b
MOV EBX,EAX
MOV RSI,qword ptr [RSP + 0x8]
SHL RSI,0x28
OR RSI,R14
MOV R14,R12
MOV RDI,R12
CALL 0x00102e0b
MOV R12D,EAX
ADD R12D,EBX
ADD R12D,R15D
MOV RSI,qword ptr [RSP + 0xa8]
SHL RSI,0x28
OR RSI,RBP
MOV RDI,R14
MOV R14,qword ptr [RSP + 0x40]
CALL 0x00102e0b
ADD EAX,R12D
JLE 0x00102d11
MOV EAX,dword ptr [R14 + 0x4c]
MOV ECX,dword ptr [R14 + 0x58]
CMP ECX,EAX
JNZ 0x00102d48
LAB_00102d11:
CMP dword ptr [R14 + 0x20],0x0
MOVD XMM0,dword ptr [RSP + 0x8]
MOVD XMM1,R13D
PUNPCKLDQ XMM1,XMM0
MOVD XMM2,dword ptr [RSP + 0xa0]
MOVD XMM0,dword ptr [RSP + 0x10]
PUNPCKLDQ XMM0,XMM2
PUNPCKLQDQ XMM0,XMM1
MOV ECX,dword ptr [RSP + 0x1c]
JZ 0x00102b31
JMP 0x00102d61
LAB_00102d48:
MOV RDX,qword ptr [RSP + 0x20]
MOV dword ptr [RDX],ECX
MOV RCX,qword ptr [RSP + 0x28]
MOV dword ptr [RCX],EAX
MOV dword ptr [R14 + 0x58],EAX
CMP dword ptr [R14 + 0x20],0x0
JZ 0x00102d7f
LAB_00102d61:
MOV EAX,dword ptr [R14 + 0x58]
MOV RCX,qword ptr [RSP + 0x20]
MOV dword ptr [RCX],EAX
MOV EAX,dword ptr [R14 + 0x50]
MOV RCX,qword ptr [RSP + 0x28]
MOV dword ptr [RCX],EAX
MOV dword ptr [R14 + 0x5c],0x1
LAB_00102d7f:
MOV EAX,0x1
LAB_00102d84:
ADD RSP,0xb8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 boundary_iterator_next(int8 *param_1,int *param_2,int *param_3)
{
uint uVar1;
uint uVar2;
uint uVar3;
uint uVar4;
uint uVar5;
int *piVar6;
uint uVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
int iVar16;
int iVar17;
int iVar18;
int iVar19;
int iVar20;
int *piVar21;
int8 uVar22;
ulong uVar23;
ulong uVar24;
ulong uVar25;
ulong uVar26;
ulong uVar27;
int8 uVar28;
piVar6 = (int *)*param_1;
uVar22 = 0;
if (((piVar6 != (int *)0x0) && (param_1[2] != 0)) && (*(int *)((long)param_1 + 0x5c) == 0)) {
*param_2 = 0;
*param_3 = 0;
if (*(int *)(param_1 + 4) == 0) {
piVar21 = piVar6 + 0x38;
uVar22 = *(int8 *)((long)param_1 + 0x2c);
uVar28 = *(int8 *)((long)param_1 + 0x34);
uVar7 = *(uint *)((long)param_1 + 0x3c);
do {
param_1[8] = *(int8 *)((long)param_1 + 0x44);
param_1[9] = *(int8 *)((long)param_1 + 0x4c);
*(int4 *)(param_1 + 10) = *(int4 *)((long)param_1 + 0x54);
*(int4 *)((long)param_1 + 0x54) = *(int4 *)((long)param_1 + 0x1c);
*(uint *)(param_1 + 7) = uVar7;
param_1[5] = uVar22;
param_1[6] = uVar28;
uVar7 = (*(code *)param_1[1])(param_1 + 1);
*(uint *)((long)param_1 + 0x3c) = uVar7;
iVar20 = *piVar6;
uVar1 = *(uint *)(param_1 + 5);
iVar8 = find_weight(piVar6 + 2);
uVar2 = *(uint *)((long)param_1 + 0x2c);
iVar9 = find_weight(piVar6 + 8);
uVar3 = *(uint *)(param_1 + 6);
uVar27 = (ulong)uVar3;
iVar10 = find_weight(piVar6 + 0xe,uVar27);
uVar4 = *(uint *)((long)param_1 + 0x34);
uVar25 = (ulong)uVar4;
iVar11 = find_weight(piVar6 + 0x14);
uVar5 = *(uint *)(param_1 + 7);
iVar12 = find_weight(piVar6 + 0x1a);
iVar13 = find_weight(piVar6 + 0x20);
uVar23 = uVar27 << 0x14 | (ulong)uVar2;
iVar14 = find_weight(piVar6 + 0x26,uVar23);
uVar26 = uVar25 << 0x14 | uVar27;
iVar15 = find_weight(piVar6 + 0x2c,uVar26);
uVar24 = (ulong)uVar5 << 0x14 | uVar25;
iVar16 = find_weight(piVar6 + 0x32,uVar24);
iVar17 = find_weight(piVar21,uVar27 << 0x28 | (ulong)uVar2 << 0x14 | (ulong)uVar1);
iVar18 = find_weight(piVar21,uVar25 << 0x28 | uVar23);
iVar19 = find_weight(piVar21,(ulong)uVar5 << 0x28 | uVar26);
iVar9 = iVar19 + iVar18 +
iVar17 + iVar16 +
iVar15 + iVar14 + iVar13 + iVar12 + iVar11 + iVar10 + iVar9 + iVar8 + iVar20;
iVar20 = find_weight(piVar21,(ulong)uVar7 << 0x28 | uVar24);
iVar8 = iVar20 + iVar9;
if (iVar8 != 0 && SCARRY4(iVar20,iVar9) == iVar8 < 0) {
iVar20 = *(int *)((long)param_1 + 0x4c);
if (*(int *)(param_1 + 0xb) != iVar20) {
*param_2 = *(int *)(param_1 + 0xb);
*param_3 = iVar20;
*(int *)(param_1 + 0xb) = iVar20;
if (*(int *)(param_1 + 4) == 0) goto LAB_00102d7f;
break;
}
}
uVar28 = CONCAT44(uVar5,uVar4);
uVar22 = CONCAT44(uVar3,uVar2);
} while (*(int *)(param_1 + 4) == 0);
}
*param_2 = *(int *)(param_1 + 0xb);
*param_3 = *(int *)(param_1 + 10);
*(int4 *)((long)param_1 + 0x5c) = 1;
LAB_00102d7f:
uVar22 = 1;
}
return uVar22;
}
| |
41,602 | quantize_row_q8_K_reference | 7CodeWizard[P]stablediffusion/ggml/src/ggml-quants.c | void quantize_row_q8_K_reference(const float * restrict x, block_q8_K * restrict y, int k) {
assert(k % QK_K == 0);
const int nb = k / QK_K;
for (int i = 0; i < nb; i++) {
float max = 0;
float amax = 0;
for (int j = 0; j < QK_K; ++j) {
float ax = fabsf(x[j]);
if (ax > amax) {
amax = ax; max = x[j];
}
}
if (!amax) {
y[i].d = 0;
memset(y[i].qs, 0, QK_K);
x += QK_K;
continue;
}
const float iscale = -128.f/max;
for (int j = 0; j < QK_K; ++j) {
int v = nearest_int(iscale*x[j]);
y[i].qs[j] = MIN(127, v);
}
for (int j = 0; j < QK_K/16; ++j) {
int sum = 0;
for (int ii = 0; ii < 16; ++ii) {
sum += y[i].qs[j*16 + ii];
}
y[i].bsums[j] = sum;
}
y[i].d = 1/iscale;
x += QK_K;
}
} | O0 | c | quantize_row_q8_K_reference:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl $0x100, %ecx # imm = 0x100
cltd
idivl %ecx
movl %eax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x30(%rsp), %eax
jge 0x173948
vxorps %xmm0, %xmm0, %xmm0
vmovss %xmm0, 0x28(%rsp)
vxorps %xmm0, %xmm0, %xmm0
vmovss %xmm0, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
cmpl $0x100, 0x20(%rsp) # imm = 0x100
jge 0x17376e
movq 0x40(%rsp), %rax
movslq 0x20(%rsp), %rcx
vmovss (%rax,%rcx,4), %xmm0
vpbroadcastd 0x15ea2(%rip), %xmm1 # 0x1895c8
vpand %xmm1, %xmm0, %xmm0
vmovss %xmm0, 0x1c(%rsp)
vmovss 0x1c(%rsp), %xmm0
vucomiss 0x24(%rsp), %xmm0
jbe 0x17375f
vmovss 0x1c(%rsp), %xmm0
vmovss %xmm0, 0x24(%rsp)
movq 0x40(%rsp), %rax
movslq 0x20(%rsp), %rcx
vmovss (%rax,%rcx,4), %xmm0
vmovss %xmm0, 0x28(%rsp)
jmp 0x173761
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x173704
vmovss 0x24(%rsp), %xmm0
vxorps %xmm1, %xmm1, %xmm1
vucomiss %xmm1, %xmm0
jne 0x1737d5
jp 0x1737d5
movq 0x38(%rsp), %rax
movslq 0x2c(%rsp), %rcx
imulq $0x124, %rcx, %rcx # imm = 0x124
addq %rcx, %rax
vxorps %xmm0, %xmm0, %xmm0
vmovss %xmm0, (%rax)
movq 0x38(%rsp), %rdi
movslq 0x2c(%rsp), %rax
imulq $0x124, %rax, %rax # imm = 0x124
addq %rax, %rdi
addq $0x4, %rdi
xorl %esi, %esi
movl $0x100, %edx # imm = 0x100
callq 0xb390
movq 0x40(%rsp), %rax
addq $0x400, %rax # imm = 0x400
movq %rax, 0x40(%rsp)
jmp 0x173938
vmovss 0x19593(%rip), %xmm0 # 0x18cd70
vdivss 0x28(%rsp), %xmm0, %xmm0
vmovss %xmm0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x100, 0x14(%rsp) # imm = 0x100
jge 0x173864
vmovss 0x18(%rsp), %xmm0
movq 0x40(%rsp), %rax
movslq 0x14(%rsp), %rcx
vmulss (%rax,%rcx,4), %xmm0, %xmm0
callq 0x16f0b0
movl %eax, 0x10(%rsp)
movl $0x7f, %eax
cmpl 0x10(%rsp), %eax
jge 0x17382e
movl $0x7f, %eax
movl %eax, (%rsp)
jmp 0x173835
movl 0x10(%rsp), %eax
movl %eax, (%rsp)
movl (%rsp), %eax
movb %al, %dl
movq 0x38(%rsp), %rax
movslq 0x2c(%rsp), %rcx
imulq $0x124, %rcx, %rcx # imm = 0x124
addq %rcx, %rax
movslq 0x14(%rsp), %rcx
movb %dl, 0x4(%rax,%rcx)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1737f1
movl $0x0, 0xc(%rsp)
cmpl $0x10, 0xc(%rsp)
jge 0x173902
movl $0x0, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpl $0x10, 0x4(%rsp)
jge 0x1738ca
movq 0x38(%rsp), %rax
movslq 0x2c(%rsp), %rcx
imulq $0x124, %rcx, %rcx # imm = 0x124
addq %rcx, %rax
movl 0xc(%rsp), %ecx
shll $0x4, %ecx
addl 0x4(%rsp), %ecx
movslq %ecx, %rcx
movsbl 0x4(%rax,%rcx), %eax
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x173887
movl 0x8(%rsp), %eax
movw %ax, %dx
movq 0x38(%rsp), %rax
movslq 0x2c(%rsp), %rcx
imulq $0x124, %rcx, %rcx # imm = 0x124
addq %rcx, %rax
movslq 0xc(%rsp), %rcx
movw %dx, 0x104(%rax,%rcx,2)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x17386c
vmovss 0x96fa(%rip), %xmm0 # 0x17d004
vdivss 0x18(%rsp), %xmm0, %xmm0
movq 0x38(%rsp), %rax
movslq 0x2c(%rsp), %rcx
imulq $0x124, %rcx, %rcx # imm = 0x124
addq %rcx, %rax
vmovss %xmm0, (%rax)
movq 0x40(%rsp), %rax
addq $0x400, %rax # imm = 0x400
movq %rax, 0x40(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1736da
addq $0x48, %rsp
retq
nopl (%rax)
| quantize_row_q8_K_reference:
sub rsp, 48h
mov [rsp+48h+var_8], rdi
mov [rsp+48h+var_10], rsi
mov [rsp+48h+var_14], edx
mov eax, [rsp+48h+var_14]
mov ecx, 100h
cdq
idiv ecx
mov [rsp+48h+var_18], eax
mov [rsp+48h+var_1C], 0
loc_1736DA:
mov eax, [rsp+48h+var_1C]
cmp eax, [rsp+48h+var_18]
jge loc_173948
vxorps xmm0, xmm0, xmm0
vmovss [rsp+48h+var_20], xmm0
vxorps xmm0, xmm0, xmm0
vmovss [rsp+48h+var_24], xmm0
mov [rsp+48h+var_28], 0
loc_173704:
cmp [rsp+48h+var_28], 100h
jge short loc_17376E
mov rax, [rsp+48h+var_8]
movsxd rcx, [rsp+48h+var_28]
vmovss xmm0, dword ptr [rax+rcx*4]
vpbroadcastd xmm1, cs:dword_1895C8
vpand xmm0, xmm0, xmm1
vmovss [rsp+48h+var_2C], xmm0
vmovss xmm0, [rsp+48h+var_2C]
vucomiss xmm0, [rsp+48h+var_24]
jbe short loc_17375F
vmovss xmm0, [rsp+48h+var_2C]
vmovss [rsp+48h+var_24], xmm0
mov rax, [rsp+48h+var_8]
movsxd rcx, [rsp+48h+var_28]
vmovss xmm0, dword ptr [rax+rcx*4]
vmovss [rsp+48h+var_20], xmm0
loc_17375F:
jmp short $+2
loc_173761:
mov eax, [rsp+48h+var_28]
add eax, 1
mov [rsp+48h+var_28], eax
jmp short loc_173704
loc_17376E:
vmovss xmm0, [rsp+48h+var_24]
vxorps xmm1, xmm1, xmm1
vucomiss xmm0, xmm1
jnz short loc_1737D5
jp short loc_1737D5
mov rax, [rsp+48h+var_10]
movsxd rcx, [rsp+48h+var_1C]
imul rcx, 124h
add rax, rcx
vxorps xmm0, xmm0, xmm0
vmovss dword ptr [rax], xmm0
mov rdi, [rsp+48h+var_10]
movsxd rax, [rsp+48h+var_1C]
imul rax, 124h
add rdi, rax
add rdi, 4
xor esi, esi
mov edx, 100h
call _memset
mov rax, [rsp+48h+var_8]
add rax, 400h
mov [rsp+48h+var_8], rax
jmp loc_173938
loc_1737D5:
vmovss xmm0, cs:dword_18CD70
vdivss xmm0, xmm0, [rsp+48h+var_20]
vmovss [rsp+48h+var_30], xmm0
mov [rsp+48h+var_34], 0
loc_1737F1:
cmp [rsp+48h+var_34], 100h
jge short loc_173864
vmovss xmm0, [rsp+48h+var_30]
mov rax, [rsp+48h+var_8]
movsxd rcx, [rsp+48h+var_34]
vmulss xmm0, xmm0, dword ptr [rax+rcx*4]
call nearest_int
mov [rsp+48h+var_38], eax
mov eax, 7Fh
cmp eax, [rsp+48h+var_38]
jge short loc_17382E
mov eax, 7Fh
mov [rsp+48h+var_48], eax
jmp short loc_173835
loc_17382E:
mov eax, [rsp+48h+var_38]
mov [rsp+48h+var_48], eax
loc_173835:
mov eax, [rsp+48h+var_48]
mov dl, al
mov rax, [rsp+48h+var_10]
movsxd rcx, [rsp+48h+var_1C]
imul rcx, 124h
add rax, rcx
movsxd rcx, [rsp+48h+var_34]
mov [rax+rcx+4], dl
mov eax, [rsp+48h+var_34]
add eax, 1
mov [rsp+48h+var_34], eax
jmp short loc_1737F1
loc_173864:
mov [rsp+48h+var_3C], 0
loc_17386C:
cmp [rsp+48h+var_3C], 10h
jge loc_173902
mov [rsp+48h+var_40], 0
mov [rsp+48h+var_44], 0
loc_173887:
cmp [rsp+48h+var_44], 10h
jge short loc_1738CA
mov rax, [rsp+48h+var_10]
movsxd rcx, [rsp+48h+var_1C]
imul rcx, 124h
add rax, rcx
mov ecx, [rsp+48h+var_3C]
shl ecx, 4
add ecx, [rsp+48h+var_44]
movsxd rcx, ecx
movsx eax, byte ptr [rax+rcx+4]
add eax, [rsp+48h+var_40]
mov [rsp+48h+var_40], eax
mov eax, [rsp+48h+var_44]
add eax, 1
mov [rsp+48h+var_44], eax
jmp short loc_173887
loc_1738CA:
mov eax, [rsp+48h+var_40]
mov dx, ax
mov rax, [rsp+48h+var_10]
movsxd rcx, [rsp+48h+var_1C]
imul rcx, 124h
add rax, rcx
movsxd rcx, [rsp+48h+var_3C]
mov [rax+rcx*2+104h], dx
mov eax, [rsp+48h+var_3C]
add eax, 1
mov [rsp+48h+var_3C], eax
jmp loc_17386C
loc_173902:
vmovss xmm0, cs:flt_17D004
vdivss xmm0, xmm0, [rsp+48h+var_30]
mov rax, [rsp+48h+var_10]
movsxd rcx, [rsp+48h+var_1C]
imul rcx, 124h
add rax, rcx
vmovss dword ptr [rax], xmm0
mov rax, [rsp+48h+var_8]
add rax, 400h
mov [rsp+48h+var_8], rax
loc_173938:
mov eax, [rsp+48h+var_1C]
add eax, 1
mov [rsp+48h+var_1C], eax
jmp loc_1736DA
loc_173948:
add rsp, 48h
retn
| long long quantize_row_q8_K_reference(long long a1, long long a2, int a3, __m128 _XMM0, __m128 _XMM1)
{
long long result; // rax
char v25; // [rsp+0h] [rbp-48h]
int n; // [rsp+4h] [rbp-44h]
__int16 v27; // [rsp+8h] [rbp-40h]
int m; // [rsp+Ch] [rbp-3Ch]
int v29; // [rsp+10h] [rbp-38h]
int k; // [rsp+14h] [rbp-34h]
int j; // [rsp+20h] [rbp-28h]
int i; // [rsp+2Ch] [rbp-1Ch]
int v38; // [rsp+30h] [rbp-18h]
v38 = a3 / 256;
for ( i = 0; ; ++i )
{
result = (unsigned int)i;
if ( i >= v38 )
break;
__asm
{
vxorps xmm0, xmm0, xmm0
vmovss [rsp+48h+var_20], xmm0
vxorps xmm0, xmm0, xmm0
vmovss [rsp+48h+var_24], xmm0
}
for ( j = 0; j < 256; ++j )
{
_RAX = a1;
_RCX = j;
__asm
{
vmovss xmm0, dword ptr [rax+rcx*4]
vpbroadcastd xmm1, cs:dword_1895C8
vpand xmm0, xmm0, xmm1
vmovss [rsp+48h+var_2C], xmm0
vmovss xmm0, [rsp+48h+var_2C]
vucomiss xmm0, [rsp+48h+var_24]
}
if ( (unsigned int)j > 0x100 )
{
__asm
{
vmovss xmm0, [rsp+48h+var_2C]
vmovss [rsp+48h+var_24], xmm0
}
_RAX = a1;
_RCX = j;
__asm
{
vmovss xmm0, dword ptr [rax+rcx*4]
vmovss [rsp+48h+var_20], xmm0
}
}
}
__asm
{
vmovss xmm0, [rsp+48h+var_24]
vxorps xmm1, xmm1, xmm1
vucomiss xmm0, xmm1
}
if ( j != 256 || __SETP__(256, 256) )
{
__asm
{
vmovss xmm0, cs:dword_18CD70
vdivss xmm0, xmm0, [rsp+48h+var_20]
vmovss [rsp+48h+var_30], xmm0
}
for ( k = 0; k < 256; ++k )
{
__asm
{
vmovss xmm0, [rsp+48h+var_30]
vmulss xmm0, xmm0, dword ptr [rax+rcx*4]
}
v29 = nearest_int(_XMM0);
if ( v29 <= 127 )
v25 = v29;
else
v25 = 127;
*(_BYTE *)(292LL * i + a2 + k + 4) = v25;
}
for ( m = 0; m < 16; ++m )
{
v27 = 0;
for ( n = 0; n < 16; ++n )
v27 += *(char *)(292LL * i + a2 + n + 16 * m + 4);
*(_WORD *)(292LL * i + a2 + 2LL * m + 260) = v27;
}
__asm
{
vmovss xmm0, cs:flt_17D004
vdivss xmm0, xmm0, [rsp+48h+var_30]
}
_RAX = 292LL * i + a2;
__asm { vmovss dword ptr [rax], xmm0 }
a1 += 1024LL;
}
else
{
_RAX = 292LL * i + a2;
__asm
{
vxorps xmm0, xmm0, xmm0
vmovss dword ptr [rax], xmm0
}
memset(_RAX + 4, 0LL, 256LL);
a1 += 1024LL;
}
}
return result;
}
| |||
41,603 | quantize_row_q8_K_reference | 7CodeWizard[P]stablediffusion/ggml/src/ggml-quants.c | void quantize_row_q8_K_reference(const float * restrict x, block_q8_K * restrict y, int k) {
assert(k % QK_K == 0);
const int nb = k / QK_K;
for (int i = 0; i < nb; i++) {
float max = 0;
float amax = 0;
for (int j = 0; j < QK_K; ++j) {
float ax = fabsf(x[j]);
if (ax > amax) {
amax = ax; max = x[j];
}
}
if (!amax) {
y[i].d = 0;
memset(y[i].qs, 0, QK_K);
x += QK_K;
continue;
}
const float iscale = -128.f/max;
for (int j = 0; j < QK_K; ++j) {
int v = nearest_int(iscale*x[j]);
y[i].qs[j] = MIN(127, v);
}
for (int j = 0; j < QK_K/16; ++j) {
int sum = 0;
for (int ii = 0; ii < 16; ++ii) {
sum += y[i].qs[j*16 + ii];
}
y[i].bsums[j] = sum;
}
y[i].d = 1/iscale;
x += QK_K;
}
} | O2 | c | quantize_row_q8_K_reference:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %eax
movq %rsi, %rbx
movl $0x100, %ecx # imm = 0x100
cltd
idivl %ecx
movl %eax, %r14d
xorl %r12d, %r12d
testl %eax, %eax
cmovlel %r12d, %r14d
movq %rdi, %r15
leaq 0x4(%rsi), %r13
vxorps %xmm5, %xmm5, %xmm5
vmovss 0xfbc5(%rip), %xmm6 # 0xa4d60
vbroadcastss 0xbee8(%rip), %xmm7 # 0xa108c
vmovaps %xmm7, (%rsp)
cmpq %r14, %r12
je 0x952c0
vxorps %xmm0, %xmm0, %xmm0
xorl %eax, %eax
vxorps %xmm1, %xmm1, %xmm1
cmpq $0x100, %rax # imm = 0x100
je 0x951e2
vmovss (%r15,%rax,4), %xmm2
vandps %xmm7, %xmm2, %xmm3
vcmpltss %xmm3, %xmm1, %xmm4
vblendvps %xmm4, %xmm2, %xmm0, %xmm0
vmaxss %xmm1, %xmm3, %xmm1
incq %rax
jmp 0x951bc
vucomiss %xmm5, %xmm1
jne 0x951ee
jnp 0x95283
vmovss 0xfb8a(%rip), %xmm1 # 0xa4d80
vdivss %xmm0, %xmm1, %xmm0
xorl %eax, %eax
cmpq $0x100, %rax # imm = 0x100
je 0x95230
vmulss (%r15,%rax,4), %xmm0, %xmm1
vaddss %xmm6, %xmm1, %xmm1
vmovd %xmm1, %ecx
andl $0x7fffff, %ecx # imm = 0x7FFFFF
movl $0x40007f, %edx # imm = 0x40007F
cmpl %edx, %ecx
jb 0x95226
movl $0x40007f, %ecx # imm = 0x40007F
movb %cl, (%r13,%rax)
incq %rax
jmp 0x951fc
imulq $0x124, %r12, %rax # imm = 0x124
leaq (%rbx,%rax), %rcx
movq %r13, %rdx
xorl %esi, %esi
cmpq $0x10, %rsi
je 0x95270
xorl %edi, %edi
xorl %r8d, %r8d
cmpq $0x10, %rdi
je 0x9525e
movsbl (%rdx,%rdi), %r9d
addl %r9d, %r8d
incq %rdi
jmp 0x9524b
movw %r8w, 0x104(%rcx,%rsi,2)
incq %rsi
addq $0x10, %rdx
jmp 0x95240
vmovss 0x1d90(%rip), %xmm1 # 0x97008
vdivss %xmm0, %xmm1, %xmm0
vmovss %xmm0, (%rbx,%rax)
jmp 0x952aa
imulq $0x124, %r12, %rdi # imm = 0x124
addq %rbx, %rdi
movl $0x104, %edx # imm = 0x104
xorl %esi, %esi
callq 0xa2f0
vmovaps (%rsp), %xmm7
vmovss 0xfaba(%rip), %xmm6 # 0xa4d60
vxorps %xmm5, %xmm5, %xmm5
addq $0x400, %r15 # imm = 0x400
incq %r12
addq $0x124, %r13 # imm = 0x124
jmp 0x951a9
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| quantize_row_q8_K_reference:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov eax, edx
mov rbx, rsi
mov ecx, 100h
cdq
idiv ecx
mov r14d, eax
xor r12d, r12d
test eax, eax
cmovle r14d, r12d
mov r15, rdi
lea r13, [rsi+4]
vxorps xmm5, xmm5, xmm5
vmovss xmm6, cs:dword_A4D60
vbroadcastss xmm7, cs:dword_A108C
vmovaps [rsp+38h+var_38], xmm7
loc_951A9:
cmp r12, r14
jz loc_952C0
vxorps xmm0, xmm0, xmm0
xor eax, eax
vxorps xmm1, xmm1, xmm1
loc_951BC:
cmp rax, 100h
jz short loc_951E2
vmovss xmm2, dword ptr [r15+rax*4]
vandps xmm3, xmm2, xmm7
vcmpltss xmm4, xmm1, xmm3
vblendvps xmm0, xmm0, xmm2, xmm4
vmaxss xmm1, xmm3, xmm1
inc rax
jmp short loc_951BC
loc_951E2:
vucomiss xmm1, xmm5
jnz short loc_951EE
jnp loc_95283
loc_951EE:
vmovss xmm1, cs:dword_A4D80
vdivss xmm0, xmm1, xmm0
xor eax, eax
loc_951FC:
cmp rax, 100h
jz short loc_95230
vmulss xmm1, xmm0, dword ptr [r15+rax*4]
vaddss xmm1, xmm1, xmm6
vmovd ecx, xmm1
and ecx, 7FFFFFh
mov edx, 40007Fh
cmp ecx, edx
jb short loc_95226
mov ecx, 40007Fh
loc_95226:
mov [r13+rax+0], cl
inc rax
jmp short loc_951FC
loc_95230:
imul rax, r12, 124h
lea rcx, [rbx+rax]
mov rdx, r13
xor esi, esi
loc_95240:
cmp rsi, 10h
jz short loc_95270
xor edi, edi
xor r8d, r8d
loc_9524B:
cmp rdi, 10h
jz short loc_9525E
movsx r9d, byte ptr [rdx+rdi]
add r8d, r9d
inc rdi
jmp short loc_9524B
loc_9525E:
mov [rcx+rsi*2+104h], r8w
inc rsi
add rdx, 10h
jmp short loc_95240
loc_95270:
vmovss xmm1, cs:dword_97008
vdivss xmm0, xmm1, xmm0
vmovss dword ptr [rbx+rax], xmm0
jmp short loc_952AA
loc_95283:
imul rdi, r12, 124h
add rdi, rbx
mov edx, 104h
xor esi, esi
call _memset
vmovaps xmm7, [rsp+38h+var_38]
vmovss xmm6, cs:dword_A4D60
vxorps xmm5, xmm5, xmm5
loc_952AA:
add r15, 400h
inc r12
add r13, 124h
jmp loc_951A9
loc_952C0:
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| void quantize_row_q8_K_reference(
long long a1,
long long a2,
int a3,
__m128 _XMM0,
__m128 _XMM1,
double a6,
double a7,
double a8,
__m128 _XMM5)
{
long long v10; // r14
long long v11; // r12
long long v13; // r13
long long i; // rax
unsigned int v27; // ecx
long long v29; // rdx
long long j; // rsi
long long v31; // rdi
__int16 v32; // r8
_RBX = a2;
v10 = (unsigned int)(a3 / 256);
v11 = 0LL;
if ( a3 / 256 <= 0 )
v10 = 0LL;
_R15 = a1;
v13 = a2 + 4;
__asm
{
vxorps xmm5, xmm5, xmm5
vmovss xmm6, cs:dword_A4D60
vbroadcastss xmm7, cs:dword_A108C
vmovaps [rsp+38h+var_38], xmm7
}
while ( v11 != v10 )
{
__asm { vxorps xmm0, xmm0, xmm0 }
_RAX = 0LL;
__asm { vxorps xmm1, xmm1, xmm1 }
while ( _RAX != 256 )
{
__asm
{
vmovss xmm2, dword ptr [r15+rax*4]
vandps xmm3, xmm2, xmm7
vcmpltss xmm4, xmm1, xmm3
vblendvps xmm0, xmm0, xmm2, xmm4
vmaxss xmm1, xmm3, xmm1
}
++_RAX;
}
__asm { vucomiss xmm1, xmm5 }
if ( __SETP__(256LL, 256LL) )
{
__asm
{
vmovss xmm1, cs:dword_A4D80
vdivss xmm0, xmm1, xmm0
}
for ( i = 0LL; i != 256; ++i )
{
__asm
{
vmulss xmm1, xmm0, dword ptr [r15+rax*4]
vaddss xmm1, xmm1, xmm6
vmovd ecx, xmm1
}
v27 = _ECX & 0x7FFFFF;
if ( v27 >= 0x40007F )
LOBYTE(v27) = 127;
*(_BYTE *)(v13 + i) = v27;
}
_RAX = 292 * v11;
v29 = v13;
for ( j = 0LL; j != 16; ++j )
{
v31 = 0LL;
v32 = 0;
while ( v31 != 16 )
v32 += *(char *)(v29 + v31++);
*(_WORD *)(_RBX + 292 * v11 + 2 * j + 260) = v32;
v29 += 16LL;
}
__asm
{
vmovss xmm1, cs:dword_97008
vdivss xmm0, xmm1, xmm0
vmovss dword ptr [rbx+rax], xmm0
}
}
else
{
*(double *)_XMM0.m128_u64 = memset(_RBX + 292 * v11, 0LL, 260LL);
__asm
{
vmovaps xmm7, [rsp+38h+var_38]
vmovss xmm6, cs:dword_A4D60
vxorps xmm5, xmm5, xmm5
}
}
_R15 += 1024LL;
++v11;
v13 += 292LL;
}
}
| quantize_row_q8_K_reference:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV EAX,EDX
MOV RBX,RSI
MOV ECX,0x100
CDQ
IDIV ECX
MOV R14D,EAX
XOR R12D,R12D
TEST EAX,EAX
CMOVLE R14D,R12D
MOV R15,RDI
LEA R13,[RSI + 0x4]
VXORPS XMM5,XMM5,XMM5
VMOVSS XMM6,dword ptr [0x001a4d60]
VBROADCASTSS XMM7,dword ptr [0x001a108c]
VMOVAPS xmmword ptr [RSP],XMM7
LAB_001951a9:
CMP R12,R14
JZ 0x001952c0
VXORPS XMM0,XMM0,XMM0
XOR EAX,EAX
VXORPS XMM1,XMM1,XMM1
LAB_001951bc:
CMP RAX,0x100
JZ 0x001951e2
VMOVSS XMM2,dword ptr [R15 + RAX*0x4]
VANDPS XMM3,XMM2,XMM7
VCMPLTSS XMM4,XMM1,XMM3
VBLENDVPS XMM0,XMM0,XMM2,XMM4
VMAXSS XMM1,XMM3,XMM1
INC RAX
JMP 0x001951bc
LAB_001951e2:
VUCOMISS XMM1,XMM5
JNZ 0x001951ee
JNP 0x00195283
LAB_001951ee:
VMOVSS XMM1,dword ptr [0x001a4d80]
VDIVSS XMM0,XMM1,XMM0
XOR EAX,EAX
LAB_001951fc:
CMP RAX,0x100
JZ 0x00195230
VMULSS XMM1,XMM0,dword ptr [R15 + RAX*0x4]
VADDSS XMM1,XMM1,XMM6
VMOVD ECX,XMM1
AND ECX,0x7fffff
MOV EDX,0x40007f
CMP ECX,EDX
JC 0x00195226
MOV ECX,0x40007f
LAB_00195226:
MOV byte ptr [R13 + RAX*0x1],CL
INC RAX
JMP 0x001951fc
LAB_00195230:
IMUL RAX,R12,0x124
LEA RCX,[RBX + RAX*0x1]
MOV RDX,R13
XOR ESI,ESI
LAB_00195240:
CMP RSI,0x10
JZ 0x00195270
XOR EDI,EDI
XOR R8D,R8D
LAB_0019524b:
CMP RDI,0x10
JZ 0x0019525e
MOVSX R9D,byte ptr [RDX + RDI*0x1]
ADD R8D,R9D
INC RDI
JMP 0x0019524b
LAB_0019525e:
MOV word ptr [RCX + RSI*0x2 + 0x104],R8W
INC RSI
ADD RDX,0x10
JMP 0x00195240
LAB_00195270:
VMOVSS XMM1,dword ptr [0x00197008]
VDIVSS XMM0,XMM1,XMM0
VMOVSS dword ptr [RBX + RAX*0x1],XMM0
JMP 0x001952aa
LAB_00195283:
IMUL RDI,R12,0x124
ADD RDI,RBX
MOV EDX,0x104
XOR ESI,ESI
CALL 0x0010a2f0
VMOVAPS XMM7,xmmword ptr [RSP]
VMOVSS XMM6,dword ptr [0x001a4d60]
VXORPS XMM5,XMM5,XMM5
LAB_001952aa:
ADD R15,0x400
INC R12
ADD R13,0x124
JMP 0x001951a9
LAB_001952c0:
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
void quantize_row_q8_K_reference(long param_1,long param_2,int param_3)
{
int1 auVar1 [16];
int1 auVar2 [16];
long lVar3;
uint uVar4;
long lVar5;
long lVar6;
short sVar7;
ulong uVar8;
long lVar9;
ulong uVar10;
float fVar11;
int1 auVar12 [16];
int1 auVar13 [16];
int1 auVar14 [16];
float fVar15;
int1 auVar16 [16];
uVar8 = 0;
uVar10 = (long)param_3 / 0x100 & 0xffffffff;
if ((int)((long)param_3 / 0x100) < 1) {
uVar10 = uVar8;
}
lVar9 = param_2 + 4;
auVar16._4_4_ = DAT_001a108c;
auVar16._0_4_ = DAT_001a108c;
auVar16._8_4_ = DAT_001a108c;
auVar16._12_4_ = DAT_001a108c;
fVar15 = DAT_001a4d60;
for (; uVar8 != uVar10; uVar8 = uVar8 + 1) {
auVar12 = ZEXT816(0) << 0x40;
auVar13 = ZEXT816(0) << 0x40;
for (lVar3 = 0; lVar3 != 0x100; lVar3 = lVar3 + 1) {
auVar14 = ZEXT416(*(uint *)(param_1 + lVar3 * 4));
auVar1 = vandps_avx(auVar14,auVar16);
auVar2 = vcmpss_avx(auVar13,auVar1,1);
auVar12 = vblendvps_avx(auVar12,auVar14,auVar2);
auVar13 = vmaxss_avx(auVar1,auVar13);
}
if ((auVar13._0_4_ != 0.0) || (NAN(auVar13._0_4_))) {
fVar11 = DAT_001a4d80 / auVar12._0_4_;
for (lVar3 = 0; lVar3 != 0x100; lVar3 = lVar3 + 1) {
uVar4 = (uint)(fVar11 * *(float *)(param_1 + lVar3 * 4) + fVar15) & 0x7fffff;
if (0x40007e < uVar4) {
uVar4 = 0x40007f;
}
*(char *)(lVar9 + lVar3) = (char)uVar4;
}
lVar3 = lVar9;
for (lVar5 = 0; lVar5 != 0x10; lVar5 = lVar5 + 1) {
sVar7 = 0;
for (lVar6 = 0; lVar6 != 0x10; lVar6 = lVar6 + 1) {
sVar7 = sVar7 + *(char *)(lVar3 + lVar6);
}
*(short *)(param_2 + uVar8 * 0x124 + 0x104 + lVar5 * 2) = sVar7;
lVar3 = lVar3 + 0x10;
}
*(float *)(param_2 + uVar8 * 0x124) = DAT_00197008 / fVar11;
}
else {
memset((void *)(uVar8 * 0x124 + param_2),0,0x104);
fVar15 = DAT_001a4d60;
}
param_1 = param_1 + 0x400;
lVar9 = lVar9 + 0x124;
}
return;
}
| |
41,604 | quantize_row_q8_K_reference | 7CodeWizard[P]stablediffusion/ggml/src/ggml-quants.c | void quantize_row_q8_K_reference(const float * restrict x, block_q8_K * restrict y, int k) {
assert(k % QK_K == 0);
const int nb = k / QK_K;
for (int i = 0; i < nb; i++) {
float max = 0;
float amax = 0;
for (int j = 0; j < QK_K; ++j) {
float ax = fabsf(x[j]);
if (ax > amax) {
amax = ax; max = x[j];
}
}
if (!amax) {
y[i].d = 0;
memset(y[i].qs, 0, QK_K);
x += QK_K;
continue;
}
const float iscale = -128.f/max;
for (int j = 0; j < QK_K; ++j) {
int v = nearest_int(iscale*x[j]);
y[i].qs[j] = MIN(127, v);
}
for (int j = 0; j < QK_K/16; ++j) {
int sum = 0;
for (int ii = 0; ii < 16; ++ii) {
sum += y[i].qs[j*16 + ii];
}
y[i].bsums[j] = sum;
}
y[i].d = 1/iscale;
x += QK_K;
}
} | O3 | c | quantize_row_q8_K_reference:
cmpl $0x100, %edx # imm = 0x100
jl 0xb813f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
shrl $0x8, %ebx
leaq 0x4(%rsi), %r12
leaq 0x104(%rsi), %r13
vbroadcastss 0xc2d0(%rip), %xmm5 # 0xc4290
xorl %ebp, %ebp
vxorps %xmm6, %xmm6, %xmm6
vbroadcastss 0xffd5(%rip), %ymm7 # 0xc7fa4
vbroadcastss 0xffd0(%rip), %ymm8 # 0xc7fa8
vpbroadcastd 0x10007(%rip), %ymm9 # 0xc7fe8
vmovd 0x10317(%rip), %xmm10 # 0xc8300
movl $0x124, %ecx # imm = 0x124
vmovaps %xmm5, (%rsp)
vmovups %ymm8, 0x30(%rsp)
vmovdqu %ymm9, 0x10(%rsp)
xorl %eax, %eax
vxorps %xmm1, %xmm1, %xmm1
vxorps %xmm0, %xmm0, %xmm0
vmovss (%r15,%rax,4), %xmm2
vandps %xmm5, %xmm2, %xmm3
vcmpltss %xmm3, %xmm1, %xmm4
vblendvps %xmm4, %xmm2, %xmm0, %xmm0
vmaxss %xmm1, %xmm3, %xmm1
incq %rax
cmpq $0x100, %rax # imm = 0x100
jne 0xb8009
vucomiss %xmm6, %xmm1
jne 0xb8039
jnp 0xb80d4
vmovss 0xff9f(%rip), %xmm1 # 0xc7fe0
vdivss %xmm0, %xmm1, %xmm0
vbroadcastss %xmm0, %ymm1
xorl %eax, %eax
vmulps (%r15,%rax,4), %ymm1, %ymm2
vaddps %ymm7, %ymm2, %ymm2
vandps %ymm2, %ymm8, %ymm2
vpminud %ymm9, %ymm2, %ymm2
vextracti128 $0x1, %ymm2, %xmm3
vpshufb %xmm10, %xmm3, %xmm3
vpshufb %xmm10, %xmm2, %xmm2
vpunpckldq %xmm3, %xmm2, %xmm2 # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
vmovq %xmm2, (%r12,%rax)
addq $0x8, %rax
cmpq $0x100, %rax # imm = 0x100
jne 0xb804c
xorl %eax, %eax
vpmovsxbw (%r12,%rax,8), %ymm1
vextracti128 $0x1, %ymm1, %xmm2
vphaddw %xmm1, %xmm2, %xmm1
vphaddw %xmm1, %xmm1, %xmm1
vphaddw %xmm1, %xmm1, %xmm1
vphaddw %xmm1, %xmm1, %xmm1
vpextrw $0x0, %xmm1, (%r13,%rax)
addq $0x2, %rax
cmpq $0x20, %rax
jne 0xb8087
vmovss 0x1f47(%rip), %xmm1 # 0xba008
vdivss %xmm0, %xmm1, %xmm0
imulq $0x124, %rbp, %rax # imm = 0x124
vmovss %xmm0, (%r14,%rax)
jmp 0xb8118
imulq $0x124, %rbp, %rdi # imm = 0x124
addq %r14, %rdi
movl $0x104, %edx # imm = 0x104
xorl %esi, %esi
vzeroupper
callq 0xa2f0
movl $0x124, %ecx # imm = 0x124
vmovd 0x10206(%rip), %xmm10 # 0xc8300
vmovdqu 0x10(%rsp), %ymm9
vmovups 0x30(%rsp), %ymm8
vbroadcastss 0xfe95(%rip), %ymm7 # 0xc7fa4
vxorps %xmm6, %xmm6, %xmm6
vmovaps (%rsp), %xmm5
addq $0x400, %r15 # imm = 0x400
incq %rbp
addq %rcx, %r12
addq %rcx, %r13
cmpq %rbx, %rbp
jne 0xb7fff
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
| quantize_row_q8_K_reference:
cmp edx, 100h
jl loc_B813F
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov ebx, edx
mov r14, rsi
mov r15, rdi
shr ebx, 8
lea r12, [rsi+4]
lea r13, [rsi+104h]
vbroadcastss xmm5, cs:dword_C4290
xor ebp, ebp
vxorps xmm6, xmm6, xmm6
vbroadcastss ymm7, cs:dword_C7FA4
vbroadcastss ymm8, cs:dword_C7FA8
vpbroadcastd ymm9, cs:dword_C7FE8
vmovd xmm10, cs:dword_C8300
mov ecx, 124h
vmovaps [rsp+88h+var_88], xmm5
vmovups [rsp+88h+var_58], ymm8
vmovdqu [rsp+88h+var_78], ymm9
loc_B7FFF:
xor eax, eax
vxorps xmm1, xmm1, xmm1
vxorps xmm0, xmm0, xmm0
loc_B8009:
vmovss xmm2, dword ptr [r15+rax*4]
vandps xmm3, xmm2, xmm5
vcmpltss xmm4, xmm1, xmm3
vblendvps xmm0, xmm0, xmm2, xmm4
vmaxss xmm1, xmm3, xmm1
inc rax
cmp rax, 100h
jnz short loc_B8009
vucomiss xmm1, xmm6
jnz short loc_B8039
jnp loc_B80D4
loc_B8039:
vmovss xmm1, cs:dword_C7FE0
vdivss xmm0, xmm1, xmm0
vbroadcastss ymm1, xmm0
xor eax, eax
loc_B804C:
vmulps ymm2, ymm1, ymmword ptr [r15+rax*4]
vaddps ymm2, ymm2, ymm7
vandps ymm2, ymm8, ymm2
vpminud ymm2, ymm2, ymm9
vextracti128 xmm3, ymm2, 1
vpshufb xmm3, xmm3, xmm10
vpshufb xmm2, xmm2, xmm10
vpunpckldq xmm2, xmm2, xmm3
vmovq qword ptr [r12+rax], xmm2
add rax, 8
cmp rax, 100h
jnz short loc_B804C
xor eax, eax
loc_B8087:
vpmovsxbw ymm1, xmmword ptr [r12+rax*8]
vextracti128 xmm2, ymm1, 1
vphaddw xmm1, xmm2, xmm1
vphaddw xmm1, xmm1, xmm1
vphaddw xmm1, xmm1, xmm1
vphaddw xmm1, xmm1, xmm1
vpextrw word ptr [r13+rax+0], xmm1, 0
add rax, 2
cmp rax, 20h ; ' '
jnz short loc_B8087
vmovss xmm1, cs:dword_BA008
vdivss xmm0, xmm1, xmm0
imul rax, rbp, 124h
vmovss dword ptr [r14+rax], xmm0
jmp short loc_B8118
loc_B80D4:
imul rdi, rbp, 124h
add rdi, r14
mov edx, 104h
xor esi, esi
vzeroupper
call _memset
mov ecx, 124h
vmovd xmm10, cs:dword_C8300
vmovdqu ymm9, [rsp+88h+var_78]
vmovups ymm8, [rsp+88h+var_58]
vbroadcastss ymm7, cs:dword_C7FA4
vxorps xmm6, xmm6, xmm6
vmovaps xmm5, [rsp+88h+var_88]
loc_B8118:
add r15, 400h
inc rbp
add r12, rcx
add r13, rcx
cmp rbp, rbx
jnz loc_B7FFF
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
loc_B813F:
vzeroupper
retn
| void quantize_row_q8_K_reference(
long long a1,
long long a2,
int a3,
__m128 _XMM0,
__m128 _XMM1,
double a6,
double a7,
double a8,
double a9,
__m128 _XMM6)
{
long long v12; // rbx
long long v16; // rbp
if ( a3 >= 256 )
{
_R14 = a2;
_R15 = a1;
v12 = (unsigned int)a3 >> 8;
_R12 = a2 + 4;
_R13 = a2 + 260;
__asm { vbroadcastss xmm5, cs:dword_C4290 }
v16 = 0LL;
__asm
{
vxorps xmm6, xmm6, xmm6
vbroadcastss ymm7, cs:dword_C7FA4
vbroadcastss ymm8, cs:dword_C7FA8
vpbroadcastd ymm9, cs:dword_C7FE8
vmovd xmm10, cs:dword_C8300
vmovaps [rsp+88h+var_88], xmm5
vmovups [rsp+88h+var_58], ymm8
vmovdqu [rsp+88h+var_78], ymm9
}
do
{
_RAX = 0LL;
__asm
{
vxorps xmm1, xmm1, xmm1
vxorps xmm0, xmm0, xmm0
}
do
{
__asm
{
vmovss xmm2, dword ptr [r15+rax*4]
vandps xmm3, xmm2, xmm5
vcmpltss xmm4, xmm1, xmm3
vblendvps xmm0, xmm0, xmm2, xmm4
vmaxss xmm1, xmm3, xmm1
}
++_RAX;
}
while ( _RAX != 256 );
__asm { vucomiss xmm1, xmm6 }
if ( __SETP__(256LL, 256LL) )
{
__asm
{
vmovss xmm1, cs:dword_C7FE0
vdivss xmm0, xmm1, xmm0
vbroadcastss ymm1, xmm0
}
for ( _RAX = 0LL; _RAX != 256; _RAX += 8LL )
{
__asm
{
vmulps ymm2, ymm1, ymmword ptr [r15+rax*4]
vaddps ymm2, ymm2, ymm7
vandps ymm2, ymm8, ymm2
vpminud ymm2, ymm2, ymm9
vextracti128 xmm3, ymm2, 1
vpshufb xmm3, xmm3, xmm10
vpshufb xmm2, xmm2, xmm10
vpunpckldq xmm2, xmm2, xmm3
vmovq qword ptr [r12+rax], xmm2
}
}
for ( _RAX = 0LL; _RAX != 32; _RAX += 2LL )
{
__asm
{
vpmovsxbw ymm1, xmmword ptr [r12+rax*8]
vextracti128 xmm2, ymm1, 1
vphaddw xmm1, xmm2, xmm1
vphaddw xmm1, xmm1, xmm1
vphaddw xmm1, xmm1, xmm1
vphaddw xmm1, xmm1, xmm1
vpextrw word ptr [r13+rax+0], xmm1, 0
}
}
__asm
{
vmovss xmm1, cs:dword_BA008
vdivss xmm0, xmm1, xmm0
}
_RAX = 292 * v16;
__asm { vmovss dword ptr [r14+rax], xmm0 }
}
else
{
__asm { vzeroupper }
*(double *)_XMM0.m128_u64 = memset(a2 + 292 * v16, 0LL, 260LL);
__asm
{
vmovd xmm10, cs:dword_C8300
vmovdqu ymm9, [rsp+88h+var_78]
vmovups ymm8, [rsp+88h+var_58]
vbroadcastss ymm7, cs:dword_C7FA4
vxorps xmm6, xmm6, xmm6
vmovaps xmm5, [rsp+88h+var_88]
}
}
_R15 += 1024LL;
++v16;
_R12 += 292LL;
_R13 += 292LL;
}
while ( v16 != v12 );
}
__asm { vzeroupper }
}
| |||
41,605 | rtree_delete_req | eloqsql/storage/myisam/rt_index.c | static int rtree_delete_req(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
uint key_length, my_off_t page, uint *page_size,
stPageList *ReinsertList, int level)
{
uchar *k;
uchar *last;
ulong i;
uint nod_flag;
uchar *page_buf;
int res;
DBUG_ENTER("rtree_delete_req");
if (!(page_buf = (uchar*)my_alloca((uint)keyinfo->block_length)))
{
my_errno = HA_ERR_OUT_OF_MEM;
DBUG_RETURN(-1); /* purecov: inspected */
}
if (!_mi_fetch_keypage(info, keyinfo, page, DFLT_INIT_HITS, page_buf, 0))
goto err1;
nod_flag = mi_test_if_nod(page_buf);
DBUG_PRINT("rtree", ("page: %lu level: %d nod_flag: %u",
(ulong) page, level, nod_flag));
k = rt_PAGE_FIRST_KEY(page_buf, nod_flag);
last = rt_PAGE_END(page_buf);
for (i = 0; k < last; k = rt_PAGE_NEXT_KEY(k, key_length, nod_flag), ++i)
{
if (nod_flag)
{
/* not leaf */
if (!rtree_key_cmp(keyinfo->seg, key, k, key_length, MBR_WITHIN))
{
switch ((res = rtree_delete_req(info, keyinfo, key, key_length,
_mi_kpos(nod_flag, k), page_size, ReinsertList, level + 1)))
{
case 0: /* deleted */
{
/* test page filling */
if (*page_size + key_length >= rt_PAGE_MIN_SIZE(keyinfo->block_length))
{
/* OK */
/* Calculate a new key value (MBR) for the shrinked block. */
if (rtree_set_key_mbr(info, keyinfo, k, key_length,
_mi_kpos(nod_flag, k)))
goto err1;
if (_mi_write_keypage(info, keyinfo, page,
DFLT_INIT_HITS, page_buf))
goto err1;
}
else
{
/*
Too small: delete key & add it descendant to reinsert list.
Store position and level of the block so that it can be
accessed later for inserting the remaining keys.
*/
DBUG_PRINT("rtree", ("too small. move block to reinsert list"));
if (rtree_fill_reinsert_list(ReinsertList, _mi_kpos(nod_flag, k),
level + 1))
goto err1;
/*
Delete the key that references the block. This makes the
block disappear from the index. Hence we need to insert
its remaining keys later. Note: if the block is a branch
block, we do not only remove this block, but the whole
subtree. So we need to re-insert its keys on the same
level later to reintegrate the subtrees.
*/
rtree_delete_key(info, page_buf, k, key_length, nod_flag);
if (_mi_write_keypage(info, keyinfo, page,
DFLT_INIT_HITS, page_buf))
goto err1;
*page_size = mi_getint(page_buf);
}
goto ok;
}
case 1: /* not found - continue searching */
{
break;
}
case 2: /* vacuous case: last key in the leaf */
{
rtree_delete_key(info, page_buf, k, key_length, nod_flag);
if (_mi_write_keypage(info, keyinfo, page,
DFLT_INIT_HITS, page_buf))
goto err1;
*page_size = mi_getint(page_buf);
res = 0;
goto ok;
}
default: /* error */
case -1:
{
goto err1;
}
}
}
}
else
{
/* leaf */
if (!rtree_key_cmp(keyinfo->seg, key, k, key_length, MBR_EQUAL | MBR_DATA))
{
rtree_delete_key(info, page_buf, k, key_length, nod_flag);
*page_size = mi_getint(page_buf);
if (*page_size == 2)
{
/* last key in the leaf */
res = 2;
if (_mi_dispose(info, keyinfo, page, DFLT_INIT_HITS))
goto err1;
}
else
{
res = 0;
if (_mi_write_keypage(info, keyinfo, page, DFLT_INIT_HITS, page_buf))
goto err1;
}
goto ok;
}
}
}
res = 1;
ok:
my_afree((uchar*)page_buf);
DBUG_RETURN(res);
err1:
my_afree((uchar*)page_buf);
DBUG_RETURN(-1); /* purecov: inspected */
} | O3 | c | rtree_delete_req:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, -0x60(%rbp)
movl %ecx, -0x34(%rbp)
movq %rdx, %r14
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movzwl 0xe(%rsi), %eax
movq %rsp, %r12
addl $0xf, %eax
andl $-0x10, %eax
subq %rax, %r12
movq %r12, %rsp
xorl %ebx, %ebx
movq %rdi, -0x48(%rbp)
movq %rsi, -0x40(%rbp)
movq %r8, -0x50(%rbp)
movq %r8, %rdx
movl $0x3, %ecx
movq %r12, %r8
xorl %r9d, %r9d
callq 0x3bcf4
testq %rax, %rax
je 0x437f8
movzbl (%r12), %r15d
testb %r15b, %r15b
jns 0x43513
movq -0x48(%rbp), %rax
movq (%rax), %rax
movl 0x17c(%rax), %ebx
movl %ebx, %r13d
leaq (%r12,%r13), %rbx
addq $0x2, %rbx
movzbl 0x1(%r12), %eax
andl $0x7f, %r15d
shll $0x8, %r15d
orq %rax, %r15
addq %r12, %r15
movl $0x1, %eax
cmpq %r15, %rbx
movq -0x40(%rbp), %rsi
movl -0x34(%rbp), %ecx
jae 0x437fd
movq %r12, -0x58(%rbp)
movl 0x18(%rbp), %edx
incl %edx
movq %rdx, -0x68(%rbp)
movl %ecx, %r12d
movq 0x28(%rsi), %rdi
movq %r14, %rsi
movq %rbx, %rdx
testq %r13, %r13
je 0x435b1
movl $0x800, %r8d # imm = 0x800
callq 0x44080
movq %r13, %rcx
testl %eax, %eax
jne 0x435d1
movl %r13d, %edi
movq %rbx, %rsi
callq 0x3c97a
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %r14, %rdx
movl -0x34(%rbp), %ecx
movq %rax, %r8
movq -0x60(%rbp), %r9
pushq -0x68(%rbp)
pushq 0x10(%rbp)
callq 0x43497
addq $0x10, %rsp
movq %r13, %rcx
cmpl $0x1, %eax
je 0x435d1
jmp 0x435f1
movl $0x6000, %r8d # imm = 0x6000
callq 0x44080
testl %eax, %eax
je 0x43694
movq -0x48(%rbp), %rax
movq (%rax), %rax
movl 0x178(%rax), %ecx
addq %r12, %rbx
addq %rcx, %rbx
cmpq %r15, %rbx
movq -0x40(%rbp), %rsi
movl -0x34(%rbp), %ecx
jb 0x43557
movl $0x1, %eax
jmp 0x437fd
cmpl $0x2, %eax
je 0x436f2
testl %eax, %eax
jne 0x437f8
movq -0x60(%rbp), %rax
movl (%rax), %r15d
addl -0x34(%rbp), %r15d
movq -0x40(%rbp), %r14
movzwl 0xe(%r14), %eax
imull $0xaaab, %eax, %r12d # imm = 0xAAAB
shrl $0x11, %r12d
movl %r13d, %edi
movq %rbx, %rsi
callq 0x3c97a
movq %rax, %r8
cmpl %r12d, %r15d
jae 0x43762
movq 0x10(%rbp), %r14
movq (%r14), %rdx
cmpq 0x8(%r14), %rdx
jne 0x4379b
movq %r8, -0x70(%rbp)
addq $0xa, %rdx
movq %rdx, 0x8(%r14)
leaq 0x364d48(%rip), %rax # 0x3a83a4
movl (%rax), %edi
movq 0x10(%r14), %rsi
shlq $0x4, %rdx
movl $0x40, %ecx
callq 0x5b434
movq %rax, 0x10(%r14)
testq %rax, %rax
movq -0x58(%rbp), %r15
je 0x437f8
movq (%r14), %rdx
movq -0x50(%rbp), %r12
movl -0x34(%rbp), %ecx
movq -0x70(%rbp), %r8
jmp 0x437aa
movq -0x48(%rbp), %r15
movq %r15, %rdi
movq -0x58(%rbp), %r14
movq %r14, %rsi
movq %rbx, %rdx
movl -0x34(%rbp), %ecx
xorl %r8d, %r8d
callq 0x43f8b
movzbl 0x1(%r14), %eax
movl (%r14), %ecx
andl $0x7f, %ecx
shll $0x8, %ecx
orl %eax, %ecx
movq -0x60(%rbp), %rax
movl %ecx, (%rax)
movq %r15, %rdi
cmpl $0x2, %ecx
jne 0x4373b
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdx
movl $0x3, %ecx
callq 0x3be73
testl %eax, %eax
jne 0x437f8
movl $0x2, %eax
jmp 0x437fd
movq -0x48(%rbp), %r15
movq %r15, %rdi
movq -0x58(%rbp), %r14
movq %r14, %rsi
movq %rbx, %rdx
movl -0x34(%rbp), %ecx
movl %r13d, %r8d
callq 0x43f8b
movq %r15, %rdi
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdx
movl $0x3, %ecx
movq %r14, %r8
callq 0x3bda0
testl %eax, %eax
jne 0x437f8
movzbl 0x1(%r14), %eax
movl (%r14), %ecx
jmp 0x43823
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdx
movl $0x3, %ecx
movq %r14, %r8
callq 0x3bda0
testl %eax, %eax
movl $0x0, %eax
jne 0x437f8
jmp 0x437fd
movq -0x48(%rbp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl -0x34(%rbp), %ecx
callq 0x44018
testl %eax, %eax
movq -0x58(%rbp), %r8
jne 0x437f8
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdx
movl $0x3, %ecx
callq 0x3bda0
testl %eax, %eax
jne 0x437f8
jmp 0x43831
movq 0x10(%r14), %rax
movq -0x58(%rbp), %r15
movq -0x50(%rbp), %r12
movl -0x34(%rbp), %ecx
shlq $0x4, %rdx
movq %r8, 0x8(%rax,%rdx)
movq (%r14), %rax
movq 0x10(%r14), %rdx
shlq $0x4, %rax
movq -0x68(%rbp), %rsi
movl %esi, (%rdx,%rax)
incq (%r14)
movq -0x48(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl %r13d, %r8d
callq 0x43f8b
movq %r14, %rdi
movq -0x40(%rbp), %rsi
movq %r12, %rdx
movl $0x3, %ecx
movq %r15, %r8
callq 0x3bda0
testl %eax, %eax
je 0x4381b
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x43835
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzbl 0x1(%r15), %eax
movl (%r15), %ecx
andl $0x7f, %ecx
shll $0x8, %ecx
orl %eax, %ecx
movq -0x60(%rbp), %rax
movl %ecx, (%rax)
xorl %eax, %eax
jmp 0x437fd
callq 0x28430
| rtree_delete_req:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov [rbp+var_60], r9
mov [rbp+var_34], ecx
mov r14, rdx
mov rax, fs:28h
mov [rbp+var_30], rax
movzx eax, word ptr [rsi+0Eh]
mov r12, rsp
add eax, 0Fh
and eax, 0FFFFFFF0h
sub r12, rax
mov rsp, r12
xor ebx, ebx
mov [rbp+var_48], rdi
mov [rbp+var_40], rsi
mov [rbp+var_50], r8
mov rdx, r8
mov ecx, 3
mov r8, r12
xor r9d, r9d
call _mi_fetch_keypage
test rax, rax
jz loc_437F8
movzx r15d, byte ptr [r12]
test r15b, r15b
jns short loc_43513
mov rax, [rbp+var_48]
mov rax, [rax]
mov ebx, [rax+17Ch]
loc_43513:
mov r13d, ebx
lea rbx, [r12+r13]
add rbx, 2
movzx eax, byte ptr [r12+1]
and r15d, 7Fh
shl r15d, 8
or r15, rax
add r15, r12
mov eax, 1
cmp rbx, r15
mov rsi, [rbp+var_40]
mov ecx, [rbp+var_34]
jnb loc_437FD
mov [rbp+var_58], r12
mov edx, [rbp+arg_8]
inc edx
mov [rbp+var_68], rdx
mov r12d, ecx
loc_43557:
mov rdi, [rsi+28h]
mov rsi, r14
mov rdx, rbx
test r13, r13
jz short loc_435B1
mov r8d, 800h
call rtree_key_cmp
mov rcx, r13
test eax, eax
jnz short loc_435D1
mov edi, r13d
mov rsi, rbx
call _mi_kpos
mov rdi, [rbp+var_48]
mov rsi, [rbp+var_40]
mov rdx, r14
mov ecx, [rbp+var_34]
mov r8, rax
mov r9, [rbp+var_60]
push [rbp+var_68]
push [rbp+arg_0]
call rtree_delete_req
add rsp, 10h
mov rcx, r13
cmp eax, 1
jz short loc_435D1
jmp short loc_435F1
loc_435B1:
mov r8d, 6000h
call rtree_key_cmp
test eax, eax
jz loc_43694
mov rax, [rbp+var_48]
mov rax, [rax]
mov ecx, [rax+178h]
loc_435D1:
add rbx, r12
add rbx, rcx
cmp rbx, r15
mov rsi, [rbp+var_40]
mov ecx, [rbp+var_34]
jb loc_43557
mov eax, 1
jmp loc_437FD
loc_435F1:
cmp eax, 2
jz loc_436F2
test eax, eax
jnz loc_437F8
mov rax, [rbp+var_60]
mov r15d, [rax]
add r15d, [rbp+var_34]
mov r14, [rbp+var_40]
movzx eax, word ptr [r14+0Eh]
imul r12d, eax, 0AAABh
shr r12d, 11h
mov edi, r13d
mov rsi, rbx
call _mi_kpos
mov r8, rax
cmp r15d, r12d
jnb loc_43762
mov r14, [rbp+arg_0]
mov rdx, [r14]
cmp rdx, [r14+8]
jnz loc_4379B
mov [rbp+var_70], r8
add rdx, 0Ah
mov [r14+8], rdx
lea rax, mi_key_memory_stPageList_pages
mov edi, [rax]
mov rsi, [r14+10h]
shl rdx, 4
mov ecx, 40h ; '@'
call my_realloc
mov [r14+10h], rax
test rax, rax
mov r15, [rbp+var_58]
jz loc_437F8
mov rdx, [r14]
mov r12, [rbp+var_50]
mov ecx, [rbp+var_34]
mov r8, [rbp+var_70]
jmp loc_437AA
loc_43694:
mov r15, [rbp+var_48]
mov rdi, r15
mov r14, [rbp+var_58]
mov rsi, r14
mov rdx, rbx
mov ecx, [rbp+var_34]
xor r8d, r8d
call rtree_delete_key
movzx eax, byte ptr [r14+1]
mov ecx, [r14]
and ecx, 7Fh
shl ecx, 8
or ecx, eax
mov rax, [rbp+var_60]
mov [rax], ecx
mov rdi, r15
cmp ecx, 2
jnz short loc_4373B
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_50]
mov ecx, 3
call _mi_dispose
test eax, eax
jnz loc_437F8
mov eax, 2
jmp loc_437FD
loc_436F2:
mov r15, [rbp+var_48]
mov rdi, r15
mov r14, [rbp+var_58]
mov rsi, r14
mov rdx, rbx
mov ecx, [rbp+var_34]
mov r8d, r13d
call rtree_delete_key
mov rdi, r15
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_50]
mov ecx, 3
mov r8, r14
call _mi_write_keypage
test eax, eax
jnz loc_437F8
movzx eax, byte ptr [r14+1]
mov ecx, [r14]
jmp loc_43823
loc_4373B:
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_50]
mov ecx, 3
mov r8, r14
call _mi_write_keypage
test eax, eax
mov eax, 0
jnz loc_437F8
jmp loc_437FD
loc_43762:
mov rdi, [rbp+var_48]
mov rsi, r14
mov rdx, rbx
mov ecx, [rbp+var_34]
call rtree_set_key_mbr
test eax, eax
mov r8, [rbp+var_58]
jnz short loc_437F8
mov rdi, [rbp+var_48]
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_50]
mov ecx, 3
call _mi_write_keypage
test eax, eax
jnz short loc_437F8
jmp loc_43831
loc_4379B:
mov rax, [r14+10h]
mov r15, [rbp+var_58]
mov r12, [rbp+var_50]
mov ecx, [rbp+var_34]
loc_437AA:
shl rdx, 4
mov [rax+rdx+8], r8
mov rax, [r14]
mov rdx, [r14+10h]
shl rax, 4
mov rsi, [rbp+var_68]
mov [rdx+rax], esi
inc qword ptr [r14]
mov r14, [rbp+var_48]
mov rdi, r14
mov rsi, r15
mov rdx, rbx
mov r8d, r13d
call rtree_delete_key
mov rdi, r14
mov rsi, [rbp+var_40]
mov rdx, r12
mov ecx, 3
mov r8, r15
call _mi_write_keypage
test eax, eax
jz short loc_4381B
loc_437F8:
mov eax, 0FFFFFFFFh
loc_437FD:
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz short loc_43835
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4381B:
movzx eax, byte ptr [r15+1]
mov ecx, [r15]
loc_43823:
and ecx, 7Fh
shl ecx, 8
or ecx, eax
mov rax, [rbp+var_60]
mov [rax], ecx
loc_43831:
xor eax, eax
jmp short loc_437FD
loc_43835:
call ___stack_chk_fail
| long long rtree_delete_req(
long long *a1,
long long a2,
long long a3,
unsigned int a4,
long long a5,
int *a6,
long long *a7,
int a8)
{
char *v9; // r12
unsigned int v10; // ebx
long long v11; // r13
unsigned long long v12; // rbx
char *v13; // r15
long long result; // rax
long long v15; // rsi
long long v16; // rcx
long long v17; // r12
long long v18; // rdi
int v19; // eax
long long v20; // rcx
int v21; // eax
int v22; // eax
unsigned int v23; // r15d
long long v24; // r14
unsigned int v25; // r12d
unsigned long long v26; // rax
unsigned long long v27; // r8
long long v28; // rdx
long long v29; // rdx
long long v30; // rax
_BYTE *v31; // r15
unsigned long long v32; // r12
long long v33; // rcx
long long *v34; // r15
_BYTE *v35; // r14
int v36; // ecx
long long *v37; // r15
_BYTE *v38; // r14
int v39; // eax
int v40; // ecx
bool v41; // zf
long long *v42; // r14
unsigned long long v43; // [rsp+0h] [rbp-70h] BYREF
long long v44; // [rsp+8h] [rbp-68h]
int *v45; // [rsp+10h] [rbp-60h]
_BYTE *v46; // [rsp+18h] [rbp-58h]
unsigned long long v47; // [rsp+20h] [rbp-50h]
long long *v48; // [rsp+28h] [rbp-48h]
long long v49; // [rsp+30h] [rbp-40h]
unsigned int v50; // [rsp+3Ch] [rbp-34h]
unsigned long long v51; // [rsp+40h] [rbp-30h]
v45 = a6;
v50 = a4;
v51 = __readfsqword(0x28u);
v9 = (char *)&v43 - ((*(unsigned __int16 *)(a2 + 14) + 15) & 0xFFFFFFF0);
v10 = 0;
v48 = a1;
v49 = a2;
v47 = a5;
if ( !mi_fetch_keypage(a1, a2, a5) )
return 0xFFFFFFFFLL;
if ( *v9 < 0 )
v10 = *(_DWORD *)(*v48 + 380);
v11 = v10;
v12 = (unsigned long long)&v9[v10 + 2];
v13 = &v9[(unsigned __int8)v9[1] | (unsigned long long)((unsigned __int8)(*v9 & 0x7F) << 8)];
result = 1LL;
v15 = v49;
v16 = v50;
if ( v12 < (unsigned long long)v13 )
{
v46 = v9;
v44 = (unsigned int)(a8 + 1);
v17 = v50;
while ( 1 )
{
v18 = *(_QWORD *)(v15 + 40);
if ( v11 )
{
v19 = rtree_key_cmp(v18, a3, v12, v16, 2048LL);
v20 = v11;
if ( !v19 )
{
v21 = mi_kpos(v11, v12);
v22 = rtree_delete_req((_DWORD)v48, v49, a3, v50, v21, (_DWORD)v45, (long long)a7, v44);
v20 = v11;
if ( v22 != 1 )
{
if ( v22 != 2 )
{
if ( v22 )
return 0xFFFFFFFFLL;
v23 = v50 + *v45;
v24 = v49;
v25 = *(unsigned __int16 *)(v49 + 14) / 3u;
v26 = mi_kpos(v11, v12);
v27 = v26;
if ( v23 >= v25 )
{
if ( (unsigned int)rtree_set_key_mbr(v48, v24, v12, v50, v26)
|| (unsigned int)mi_write_keypage(v48, v49, v47, 3u, v46) )
{
return 0xFFFFFFFFLL;
}
}
else
{
v28 = *a7;
if ( *a7 == a7[1] )
{
v43 = v26;
v29 = v28 + 10;
a7[1] = v29;
v30 = my_realloc(mi_key_memory_stPageList_pages, a7[2], 16 * v29, 64LL);
a7[2] = v30;
v31 = v46;
if ( !v30 )
return 0xFFFFFFFFLL;
v28 = *a7;
v32 = v47;
v33 = v50;
v27 = v43;
}
else
{
v30 = a7[2];
v31 = v46;
v32 = v47;
v33 = v50;
}
*(_QWORD *)(v30 + 16 * v28 + 8) = v27;
*(_DWORD *)(a7[2] + 16 * (*a7)++) = v44;
v42 = v48;
rtree_delete_key(v48, v31, v12, v33, (unsigned int)v11);
if ( (unsigned int)mi_write_keypage(v42, v49, v32, 3u, v31) )
return 0xFFFFFFFFLL;
v39 = (unsigned __int8)v31[1];
v40 = *(_DWORD *)v31;
LABEL_35:
*v45 = v39 | ((v40 & 0x7F) << 8);
}
return 0LL;
}
v37 = v48;
v38 = v46;
rtree_delete_key(v48, v46, v12, v50, (unsigned int)v11);
if ( (unsigned int)mi_write_keypage(v37, v49, v47, 3u, v38) )
return 0xFFFFFFFFLL;
v39 = (unsigned __int8)v38[1];
v40 = *(_DWORD *)v38;
goto LABEL_35;
}
}
}
else
{
if ( !(unsigned int)rtree_key_cmp(v18, a3, v12, v16, 24576LL) )
{
v34 = v48;
v35 = v46;
rtree_delete_key(v48, v46, v12, v50, 0LL);
v36 = (unsigned __int8)v35[1] | ((*(_DWORD *)v35 & 0x7F) << 8);
*v45 = v36;
if ( v36 == 2 )
{
if ( (unsigned int)mi_dispose(v34, v49, v47, 3u) )
return 0xFFFFFFFFLL;
return 2LL;
}
else
{
v41 = (unsigned int)mi_write_keypage(v34, v49, v47, 3u, v35) == 0;
result = 0LL;
if ( !v41 )
return 0xFFFFFFFFLL;
}
return result;
}
v20 = *(unsigned int *)(*v48 + 376);
}
v12 += v20 + v17;
v15 = v49;
v16 = v50;
if ( v12 >= (unsigned long long)v13 )
return 1LL;
}
}
return result;
}
| rtree_delete_req:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x60],R9
MOV dword ptr [RBP + -0x34],ECX
MOV R14,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOVZX EAX,word ptr [RSI + 0xe]
MOV R12,RSP
ADD EAX,0xf
AND EAX,0xfffffff0
SUB R12,RAX
MOV RSP,R12
XOR EBX,EBX
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x50],R8
MOV RDX,R8
MOV ECX,0x3
MOV R8,R12
XOR R9D,R9D
CALL 0x0013bcf4
TEST RAX,RAX
JZ 0x001437f8
MOVZX R15D,byte ptr [R12]
TEST R15B,R15B
JNS 0x00143513
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX]
MOV EBX,dword ptr [RAX + 0x17c]
LAB_00143513:
MOV R13D,EBX
LEA RBX,[R12 + R13*0x1]
ADD RBX,0x2
MOVZX EAX,byte ptr [R12 + 0x1]
AND R15D,0x7f
SHL R15D,0x8
OR R15,RAX
ADD R15,R12
MOV EAX,0x1
CMP RBX,R15
MOV RSI,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RBP + -0x34]
JNC 0x001437fd
MOV qword ptr [RBP + -0x58],R12
MOV EDX,dword ptr [RBP + 0x18]
INC EDX
MOV qword ptr [RBP + -0x68],RDX
MOV R12D,ECX
LAB_00143557:
MOV RDI,qword ptr [RSI + 0x28]
MOV RSI,R14
MOV RDX,RBX
TEST R13,R13
JZ 0x001435b1
MOV R8D,0x800
CALL 0x00144080
MOV RCX,R13
TEST EAX,EAX
JNZ 0x001435d1
MOV EDI,R13D
MOV RSI,RBX
CALL 0x0013c97a
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,R14
MOV ECX,dword ptr [RBP + -0x34]
MOV R8,RAX
MOV R9,qword ptr [RBP + -0x60]
PUSH qword ptr [RBP + -0x68]
PUSH qword ptr [RBP + 0x10]
CALL 0x00143497
ADD RSP,0x10
MOV RCX,R13
CMP EAX,0x1
JZ 0x001435d1
JMP 0x001435f1
LAB_001435b1:
MOV R8D,0x6000
CALL 0x00144080
TEST EAX,EAX
JZ 0x00143694
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x178]
LAB_001435d1:
ADD RBX,R12
ADD RBX,RCX
CMP RBX,R15
MOV RSI,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RBP + -0x34]
JC 0x00143557
MOV EAX,0x1
JMP 0x001437fd
LAB_001435f1:
CMP EAX,0x2
JZ 0x001436f2
TEST EAX,EAX
JNZ 0x001437f8
MOV RAX,qword ptr [RBP + -0x60]
MOV R15D,dword ptr [RAX]
ADD R15D,dword ptr [RBP + -0x34]
MOV R14,qword ptr [RBP + -0x40]
MOVZX EAX,word ptr [R14 + 0xe]
IMUL R12D,EAX,0xaaab
SHR R12D,0x11
MOV EDI,R13D
MOV RSI,RBX
CALL 0x0013c97a
MOV R8,RAX
CMP R15D,R12D
JNC 0x00143762
MOV R14,qword ptr [RBP + 0x10]
MOV RDX,qword ptr [R14]
CMP RDX,qword ptr [R14 + 0x8]
JNZ 0x0014379b
MOV qword ptr [RBP + -0x70],R8
ADD RDX,0xa
MOV qword ptr [R14 + 0x8],RDX
LEA RAX,[0x4a83a4]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [R14 + 0x10]
SHL RDX,0x4
MOV ECX,0x40
CALL 0x0015b434
MOV qword ptr [R14 + 0x10],RAX
TEST RAX,RAX
MOV R15,qword ptr [RBP + -0x58]
JZ 0x001437f8
MOV RDX,qword ptr [R14]
MOV R12,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RBP + -0x34]
MOV R8,qword ptr [RBP + -0x70]
JMP 0x001437aa
LAB_00143694:
MOV R15,qword ptr [RBP + -0x48]
MOV RDI,R15
MOV R14,qword ptr [RBP + -0x58]
MOV RSI,R14
MOV RDX,RBX
MOV ECX,dword ptr [RBP + -0x34]
XOR R8D,R8D
CALL 0x00143f8b
MOVZX EAX,byte ptr [R14 + 0x1]
MOV ECX,dword ptr [R14]
AND ECX,0x7f
SHL ECX,0x8
OR ECX,EAX
MOV RAX,qword ptr [RBP + -0x60]
MOV dword ptr [RAX],ECX
MOV RDI,R15
CMP ECX,0x2
JNZ 0x0014373b
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x50]
MOV ECX,0x3
CALL 0x0013be73
TEST EAX,EAX
JNZ 0x001437f8
MOV EAX,0x2
JMP 0x001437fd
LAB_001436f2:
MOV R15,qword ptr [RBP + -0x48]
MOV RDI,R15
MOV R14,qword ptr [RBP + -0x58]
MOV RSI,R14
MOV RDX,RBX
MOV ECX,dword ptr [RBP + -0x34]
MOV R8D,R13D
CALL 0x00143f8b
MOV RDI,R15
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x50]
MOV ECX,0x3
MOV R8,R14
CALL 0x0013bda0
TEST EAX,EAX
JNZ 0x001437f8
MOVZX EAX,byte ptr [R14 + 0x1]
MOV ECX,dword ptr [R14]
JMP 0x00143823
LAB_0014373b:
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x50]
MOV ECX,0x3
MOV R8,R14
CALL 0x0013bda0
TEST EAX,EAX
MOV EAX,0x0
JNZ 0x001437f8
JMP 0x001437fd
LAB_00143762:
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,R14
MOV RDX,RBX
MOV ECX,dword ptr [RBP + -0x34]
CALL 0x00144018
TEST EAX,EAX
MOV R8,qword ptr [RBP + -0x58]
JNZ 0x001437f8
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x50]
MOV ECX,0x3
CALL 0x0013bda0
TEST EAX,EAX
JNZ 0x001437f8
JMP 0x00143831
LAB_0014379b:
MOV RAX,qword ptr [R14 + 0x10]
MOV R15,qword ptr [RBP + -0x58]
MOV R12,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RBP + -0x34]
LAB_001437aa:
SHL RDX,0x4
MOV qword ptr [RAX + RDX*0x1 + 0x8],R8
MOV RAX,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x10]
SHL RAX,0x4
MOV RSI,qword ptr [RBP + -0x68]
MOV dword ptr [RDX + RAX*0x1],ESI
INC qword ptr [R14]
MOV R14,qword ptr [RBP + -0x48]
MOV RDI,R14
MOV RSI,R15
MOV RDX,RBX
MOV R8D,R13D
CALL 0x00143f8b
MOV RDI,R14
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,R12
MOV ECX,0x3
MOV R8,R15
CALL 0x0013bda0
TEST EAX,EAX
JZ 0x0014381b
LAB_001437f8:
MOV EAX,0xffffffff
LAB_001437fd:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x00143835
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014381b:
MOVZX EAX,byte ptr [R15 + 0x1]
MOV ECX,dword ptr [R15]
LAB_00143823:
AND ECX,0x7f
SHL ECX,0x8
OR ECX,EAX
MOV RAX,qword ptr [RBP + -0x60]
MOV dword ptr [RAX],ECX
LAB_00143831:
XOR EAX,EAX
JMP 0x001437fd
LAB_00143835:
CALL 0x00128430
|
int8
rtree_delete_req(long *param_1,long param_2,int8 param_3,uint param_4,int8 param_5,
uint *param_6,long *param_7,int param_8)
{
byte bVar1;
ushort uVar2;
long lVar3;
int8 uVar4;
long *plVar5;
uint uVar6;
int iVar7;
long lVar8;
int8 uVar9;
long lVar10;
uint uVar11;
ulong uVar12;
byte *pbVar13;
uint *puVar14;
ulong uVar15;
ulong uVar16;
uint uVar17;
byte *pbVar18;
long in_FS_OFFSET;
ulong auStack_90 [3];
int8 local_78;
ulong local_70;
uint *local_68;
uint *local_60;
int8 local_58;
long *local_50;
long local_48;
uint local_3c;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar3 = -(ulong)(*(ushort *)(param_2 + 0xe) + 0xf & 0xfffffff0);
puVar14 = (uint *)((long)&local_78 + lVar3);
uVar11 = 0;
local_68 = param_6;
local_58 = param_5;
local_50 = param_1;
local_48 = param_2;
local_3c = param_4;
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x1434f3;
lVar8 = _mi_fetch_keypage(param_1,param_2,param_5,3,puVar14,0);
if (lVar8 == 0) {
LAB_001437f8:
uVar9 = 0xffffffff;
}
else {
if ((char)(byte)*puVar14 < '\0') {
uVar11 = *(uint *)(*local_50 + 0x17c);
}
uVar16 = (ulong)uVar11;
pbVar13 = (byte *)((long)puVar14 + uVar16 + 2);
pbVar18 = (byte *)(((ulong)(((byte)*puVar14 & 0x7f) << 8) |
(ulong)*(byte *)((long)&local_78 + lVar3 + 1)) + (long)puVar14);
uVar9 = 1;
if (pbVar13 < pbVar18) {
local_70 = (ulong)(param_8 + 1);
uVar15 = (ulong)local_3c;
local_60 = puVar14;
do {
uVar6 = local_3c;
uVar9 = *(int8 *)(local_48 + 0x28);
if (uVar16 == 0) {
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x1435bc;
iVar7 = rtree_key_cmp(uVar9,param_3,pbVar13,uVar6,0x6000);
uVar6 = local_3c;
plVar5 = local_50;
puVar14 = local_60;
if (iVar7 == 0) {
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x1436b0;
rtree_delete_key(plVar5,puVar14,pbVar13,uVar6,0);
lVar8 = local_48;
uVar9 = local_58;
uVar11 = (*puVar14 & 0x7f) << 8 | (uint)*(byte *)((long)puVar14 + 1);
*local_68 = uVar11;
if (uVar11 != 2) {
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x143750;
iVar7 = _mi_write_keypage(plVar5,lVar8,uVar9,3,puVar14);
uVar9 = 0;
if (iVar7 == 0) goto LAB_001437fd;
goto LAB_001437f8;
}
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x1436e0;
iVar7 = _mi_dispose(plVar5,lVar8,uVar9,3);
if (iVar7 != 0) goto LAB_001437f8;
uVar9 = 2;
goto LAB_001437fd;
}
uVar12 = (ulong)*(uint *)(*local_50 + 0x178);
}
else {
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x143571;
iVar7 = rtree_key_cmp(uVar9,param_3,pbVar13,uVar6,0x800);
uVar12 = uVar16;
if (iVar7 == 0) {
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x143583;
uVar9 = _mi_kpos(uVar16,pbVar13);
uVar6 = local_3c;
lVar8 = local_48;
plVar5 = local_50;
puVar14 = local_68;
*(ulong *)((long)auStack_90 + lVar3 + 0x10) = local_70;
*(long **)((long)auStack_90 + lVar3 + 8) = param_7;
*(int8 *)((long)auStack_90 + lVar3) = 0x1435a3;
iVar7 = rtree_delete_req(plVar5,lVar8,param_3,uVar6,uVar9,puVar14);
uVar6 = local_3c;
lVar8 = local_48;
plVar5 = local_50;
puVar14 = local_60;
if (iVar7 != 1) {
if (iVar7 == 2) {
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x14370e;
rtree_delete_key(plVar5,puVar14,pbVar13,uVar6,uVar11);
lVar8 = local_48;
uVar9 = local_58;
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x143726;
iVar7 = _mi_write_keypage(plVar5,lVar8,uVar9,3,puVar14);
if (iVar7 != 0) goto LAB_001437f8;
bVar1 = *(byte *)((long)puVar14 + 1);
uVar11 = *puVar14;
LAB_00143823:
*local_68 = (uVar11 & 0x7f) << 8 | (uint)bVar1;
}
else {
if (iVar7 != 0) goto LAB_001437f8;
uVar17 = *local_68 + local_3c;
uVar2 = *(ushort *)(local_48 + 0xe);
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x14362c;
uVar9 = _mi_kpos(uVar16,pbVar13);
uVar6 = local_3c;
plVar5 = local_50;
if (uVar17 < uVar2 / 3) {
lVar8 = *param_7;
if (lVar8 == param_7[1]) {
param_7[1] = lVar8 + 10;
lVar10 = param_7[2];
local_78 = uVar9;
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x143670;
lVar10 = my_realloc(mi_key_memory_stPageList_pages,lVar10,(lVar8 + 10) * 0x10,
0x40);
param_7[2] = lVar10;
if (lVar10 == 0) goto LAB_001437f8;
lVar8 = *param_7;
uVar9 = local_78;
}
else {
lVar10 = param_7[2];
}
uVar6 = local_3c;
plVar5 = local_50;
uVar4 = local_58;
puVar14 = local_60;
*(int8 *)(lVar10 + 8 + lVar8 * 0x10) = uVar9;
*(int *)(param_7[2] + *param_7 * 0x10) = (int)local_70;
*param_7 = *param_7 + 1;
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x1437dd;
rtree_delete_key(plVar5,puVar14,pbVar13,uVar6,uVar11);
lVar8 = local_48;
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x1437f4;
iVar7 = _mi_write_keypage(plVar5,lVar8,uVar4,3,puVar14);
if (iVar7 == 0) {
bVar1 = *(byte *)((long)puVar14 + 1);
uVar11 = *puVar14;
goto LAB_00143823;
}
goto LAB_001437f8;
}
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x143774;
iVar7 = rtree_set_key_mbr(plVar5,lVar8,pbVar13,uVar6);
lVar8 = local_48;
plVar5 = local_50;
uVar9 = local_58;
puVar14 = local_60;
if (iVar7 != 0) goto LAB_001437f8;
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x143792;
iVar7 = _mi_write_keypage(plVar5,lVar8,uVar9,3,puVar14);
if (iVar7 != 0) goto LAB_001437f8;
}
uVar9 = 0;
goto LAB_001437fd;
}
}
}
pbVar13 = pbVar13 + uVar12 + uVar15;
} while (pbVar13 < pbVar18);
uVar9 = 1;
}
}
LAB_001437fd:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
*(code **)((long)auStack_90 + lVar3 + 0x10) = rtree_estimate;
__stack_chk_fail();
}
return uVar9;
}
| |
41,606 | mysql_real_query_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_real_query_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_real_query,
(parms->mysql, parms->stmt_str, parms->length),
parms->mysql,
int,
r_int)
} | O0 | c | mysql_real_query_start_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x21670
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| mysql_real_query_start_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rax, [rbp+var_10]
mov rsi, [rax+8]
mov rax, [rbp+var_10]
mov rdx, [rax+10h]
call mysql_real_query
mov [rbp+var_14], eax
mov ecx, [rbp+var_14]
mov rax, [rbp+var_20]
mov [rax+8], ecx
mov rax, [rbp+var_20]
mov dword ptr [rax], 0
add rsp, 20h
pop rbp
retn
| _DWORD * mysql_real_query_start_internal(long long *a1)
{
_DWORD *result; // rax
_DWORD *v2; // [rsp+0h] [rbp-20h]
v2 = *(_DWORD **)(*(_QWORD *)(*a1 + 1152) + 40LL);
v2[2] = mysql_real_query(*a1, a1[1], a1[2]);
result = v2;
*v2 = 0;
return result;
}
| mysql_real_query_start_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x10]
CALL 0x00121670
MOV dword ptr [RBP + -0x14],EAX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x8],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
ADD RSP,0x20
POP RBP
RET
|
void mysql_real_query_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_real_query(*param_1,param_1[1],param_1[2]);
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
| |
41,607 | stbtt__cff_skip_operand | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h | static void stbtt__cff_skip_operand(stbtt__buf *b) {
int v, b0 = stbtt__buf_peek8(b);
STBTT_assert(b0 >= 28);
if (b0 == 30) {
stbtt__buf_skip(b, 1);
while (b->cursor < b->size) {
v = stbtt__buf_get8(b);
if ((v & 0xF) == 0xF || (v >> 4) == 0xF)
break;
}
} else {
stbtt__cff_int(b);
}
} | O0 | c | stbtt__cff_skip_operand:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8440
movzbl %al, %eax
movl %eax, -0x10(%rbp)
cmpl $0x1c, -0x10(%rbp)
jl 0x84a3
jmp 0x84c2
leaq 0x3316c(%rip), %rdi # 0x3b616
leaq 0x32fb9(%rip), %rsi # 0x3b46a
movl $0x4c2, %edx # imm = 0x4C2
leaq 0x33162(%rip), %rcx # 0x3b61f
callq 0x30b0
cmpl $0x1e, -0x10(%rbp)
jne 0x8511
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x7cc0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x850f
movq -0x8(%rbp), %rdi
callq 0x7d70
movzbl %al, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0xf, %eax
cmpl $0xf, %eax
je 0x850b
movl -0xc(%rbp), %eax
sarl $0x4, %eax
cmpl $0xf, %eax
jne 0x850d
jmp 0x850f
jmp 0x84d6
jmp 0x851a
movq -0x8(%rbp), %rdi
callq 0x8320
addq $0x10, %rsp
popq %rbp
retq
| stbtt__cff_skip_operand:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
call stbtt__buf_peek8
movzx eax, al
mov [rbp+var_10], eax
cmp [rbp+var_10], 1Ch
jl short loc_84A3
jmp short loc_84C2
loc_84A3:
lea rdi, aB028; "b0 >= 28"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 4C2h
lea rcx, aVoidStbttCffSk; "void stbtt__cff_skip_operand(stbtt__buf"...
call ___assert_fail
loc_84C2:
cmp [rbp+var_10], 1Eh
jnz short loc_8511
mov rdi, [rbp+var_8]
mov esi, 1
call stbtt__buf_skip
loc_84D6:
mov rax, [rbp+var_8]
mov eax, [rax+8]
mov rcx, [rbp+var_8]
cmp eax, [rcx+0Ch]
jge short loc_850F
mov rdi, [rbp+var_8]
call stbtt__buf_get8
movzx eax, al
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
and eax, 0Fh
cmp eax, 0Fh
jz short loc_850B
mov eax, [rbp+var_C]
sar eax, 4
cmp eax, 0Fh
jnz short loc_850D
loc_850B:
jmp short loc_850F
loc_850D:
jmp short loc_84D6
loc_850F:
jmp short loc_851A
loc_8511:
mov rdi, [rbp+var_8]
call stbtt__cff_int
loc_851A:
add rsp, 10h
pop rbp
retn
| long long stbtt__cff_skip_operand(long long a1)
{
long long result; // rax
unsigned __int8 v2; // al
unsigned int v3; // [rsp+0h] [rbp-10h]
int v4; // [rsp+4h] [rbp-Ch]
v3 = (unsigned __int8)stbtt__buf_peek8(a1);
if ( v3 < 0x1C )
__assert_fail(
"b0 >= 28",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h",
1218LL,
"void stbtt__cff_skip_operand(stbtt__buf *)");
if ( v3 != 30 )
return stbtt__cff_int((long long *)a1);
stbtt__buf_skip(a1, 1);
do
{
result = *(unsigned int *)(a1 + 8);
if ( (int)result >= *(_DWORD *)(a1 + 12) )
break;
v2 = stbtt__buf_get8((long long *)a1);
v4 = v2;
result = v2 & 0xF;
if ( (_DWORD)result == 15 )
break;
result = (unsigned int)(v4 >> 4);
}
while ( (_DWORD)result != 15 );
return result;
}
| stbtt__cff_skip_operand:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00108440
MOVZX EAX,AL
MOV dword ptr [RBP + -0x10],EAX
CMP dword ptr [RBP + -0x10],0x1c
JL 0x001084a3
JMP 0x001084c2
LAB_001084a3:
LEA RDI,[0x13b616]
LEA RSI,[0x13b46a]
MOV EDX,0x4c2
LEA RCX,[0x13b61f]
CALL 0x001030b0
LAB_001084c2:
CMP dword ptr [RBP + -0x10],0x1e
JNZ 0x00108511
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,0x1
CALL 0x00107cc0
LAB_001084d6:
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX + 0xc]
JGE 0x0010850f
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00107d70
MOVZX EAX,AL
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
AND EAX,0xf
CMP EAX,0xf
JZ 0x0010850b
MOV EAX,dword ptr [RBP + -0xc]
SAR EAX,0x4
CMP EAX,0xf
JNZ 0x0010850d
LAB_0010850b:
JMP 0x0010850f
LAB_0010850d:
JMP 0x001084d6
LAB_0010850f:
JMP 0x0010851a
LAB_00108511:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00108320
LAB_0010851a:
ADD RSP,0x10
POP RBP
RET
|
void stbtt__cff_skip_operand(long param_1)
{
byte bVar1;
bVar1 = stbtt__buf_peek8(param_1);
if (bVar1 < 0x1c) {
/* WARNING: Subroutine does not return */
__assert_fail("b0 >= 28",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h"
,0x4c2,"void stbtt__cff_skip_operand(stbtt__buf *)");
}
if (bVar1 == 0x1e) {
stbtt__buf_skip(param_1,1);
while (*(int *)(param_1 + 8) < *(int *)(param_1 + 0xc)) {
bVar1 = stbtt__buf_get8(param_1);
if ((bVar1 & 0xf) == 0xf) {
return;
}
if ((int)(uint)bVar1 >> 4 == 0xf) {
return;
}
}
}
else {
stbtt__cff_int(param_1);
}
return;
}
| |
41,608 | has_path | eloqsql/mysys/my_getwd.c | my_bool has_path(const char *name)
{
return MY_TEST(strchr(name, FN_LIBCHAR))
#if FN_LIBCHAR != '/'
|| MY_TEST(strchr(name, '/'))
#endif
#ifdef FN_DEVCHAR
|| MY_TEST(strchr(name, FN_DEVCHAR))
#endif
;
} | O0 | c | has_path:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x25110
movq %rax, %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| has_path:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
mov esi, 2Fh ; '/'
call _strchr
mov rdx, rax
xor eax, eax
mov ecx, 1
cmp rdx, 0
cmovnz eax, ecx
add rsp, 10h
pop rbp
retn
| _BOOL8 has_path(long long a1)
{
return strchr(a1, 47LL) != 0;
}
| has_path:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,0x2f
CALL 0x00125110
MOV RDX,RAX
XOR EAX,EAX
MOV ECX,0x1
CMP RDX,0x0
CMOVNZ EAX,ECX
ADD RSP,0x10
POP RBP
RET
|
bool has_path(char *param_1)
{
char *pcVar1;
pcVar1 = strchr(param_1,0x2f);
return pcVar1 != (char *)0x0;
}
| |
41,609 | LefDefParser::defiPinAntennaModel::addAPinMaxAreaCar(int, char const*) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiPinCap.cpp | void defiPinAntennaModel::addAPinMaxAreaCar(int value, const char* layer) {
if (numAPinMaxAreaCar_ == APinMaxAreaCarAllocated_) {
int i;
int max;
int lim = numAPinMaxAreaCar_;
int* nd;
char** nl;
if (APinMaxAreaCarAllocated_ == 0)
max = APinMaxAreaCarAllocated_ = 2;
else
max = APinMaxAreaCarAllocated_ *= 2;
nd = (int*)malloc(sizeof(int)*max);
nl = (char**)malloc(sizeof(char*)*max);
for (i = 0; i < lim; i++) {
nd[i] = APinMaxAreaCar_[i];
nl[i] = APinMaxAreaCarLayer_[i];
}
free((char*)(APinMaxAreaCar_));
free((char*)(APinMaxAreaCarLayer_));
APinMaxAreaCar_ = nd;
APinMaxAreaCarLayer_ = nl;
}
APinMaxAreaCar_[numAPinMaxAreaCar_] = value;
if (layer) {
APinMaxAreaCarLayer_[numAPinMaxAreaCar_] =
(char*)malloc(strlen(layer)+1);
strcpy(APinMaxAreaCarLayer_[numAPinMaxAreaCar_],
defData->DEFCASE(layer));
} else
APinMaxAreaCarLayer_[numAPinMaxAreaCar_] = NULL;
numAPinMaxAreaCar_ += 1;
} | O3 | cpp | LefDefParser::defiPinAntennaModel::addAPinMaxAreaCar(int, char const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movl 0x20(%rdi), %r13d
cmpl 0x24(%rdi), %r13d
jne 0x1969d
leal (,%r13,2), %eax
testl %r13d, %r13d
movl $0x2, %ecx
cmovnel %eax, %ecx
movl %ecx, 0x24(%rbx)
movslq %ecx, %r12
leaq (,%r12,4), %rdi
callq 0x6270
movq %rax, %r15
shlq $0x3, %r12
movq %r12, %rdi
callq 0x6270
movq %rax, %r12
movq 0x28(%rbx), %rdi
testl %r13d, %r13d
jle 0x19681
movq 0x30(%rbx), %rax
xorl %ecx, %ecx
movl (%rdi,%rcx,4), %edx
movl %edx, (%r15,%rcx,4)
movq (%rax,%rcx,8), %rdx
movq %rdx, (%r12,%rcx,8)
incq %rcx
cmpq %rcx, %r13
jne 0x1966a
callq 0x6220
movq 0x30(%rbx), %rdi
callq 0x6220
movq %r15, 0x28(%rbx)
movq %r12, 0x30(%rbx)
movl 0x20(%rbx), %r13d
jmp 0x196a1
movq 0x28(%rbx), %r15
movslq %r13d, %rax
movl %ebp, (%r15,%rax,4)
testq %r14, %r14
je 0x196ee
movq %r14, %rdi
callq 0x60d0
leaq 0x1(%rax), %rdi
callq 0x6270
movq 0x30(%rbx), %rcx
movslq 0x20(%rbx), %rdx
movq %rax, (%rcx,%rdx,8)
movq 0x30(%rbx), %rax
movq 0x68(%rbx), %rdi
movq (%rax,%rdx,8), %r15
movq %r14, %rsi
callq 0x18aa0
movq %r15, %rdi
movq %rax, %rsi
callq 0x6190
movl 0x20(%rbx), %eax
jmp 0x196fe
movq 0x30(%rbx), %rcx
movslq 0x20(%rbx), %rax
movq $0x0, (%rcx,%rax,8)
incl %eax
movl %eax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN12LefDefParser19defiPinAntennaModel17addAPinMaxAreaCarEiPKc:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdx
mov ebp, esi
mov rbx, rdi
mov r13d, [rdi+20h]
cmp r13d, [rdi+24h]
jnz short loc_1969D
lea eax, ds:0[r13*2]
test r13d, r13d
mov ecx, 2
cmovnz ecx, eax
mov [rbx+24h], ecx
movsxd r12, ecx
lea rdi, ds:0[r12*4]
call _malloc
mov r15, rax
shl r12, 3
mov rdi, r12
call _malloc
mov r12, rax
mov rdi, [rbx+28h]
test r13d, r13d
jle short loc_19681
mov rax, [rbx+30h]
xor ecx, ecx
loc_1966A:
mov edx, [rdi+rcx*4]
mov [r15+rcx*4], edx
mov rdx, [rax+rcx*8]
mov [r12+rcx*8], rdx
inc rcx
cmp r13, rcx
jnz short loc_1966A
loc_19681:
call _free
mov rdi, [rbx+30h]
call _free
mov [rbx+28h], r15
mov [rbx+30h], r12
mov r13d, [rbx+20h]
jmp short loc_196A1
loc_1969D:
mov r15, [rbx+28h]
loc_196A1:
movsxd rax, r13d
mov [r15+rax*4], ebp
test r14, r14
jz short loc_196EE
mov rdi, r14
call _strlen
lea rdi, [rax+1]
call _malloc
mov rcx, [rbx+30h]
movsxd rdx, dword ptr [rbx+20h]
mov [rcx+rdx*8], rax
mov rax, [rbx+30h]
mov rdi, [rbx+68h]; this
mov r15, [rax+rdx*8]
mov rsi, r14; char *
call _ZN12LefDefParser8defrData7DEFCASEEPKc; LefDefParser::defrData::DEFCASE(char const*)
mov rdi, r15
mov rsi, rax
call _strcpy
mov eax, [rbx+20h]
jmp short loc_196FE
loc_196EE:
mov rcx, [rbx+30h]
movsxd rax, dword ptr [rbx+20h]
mov qword ptr [rcx+rax*8], 0
loc_196FE:
inc eax
mov [rbx+20h], eax
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long LefDefParser::defiPinAntennaModel::addAPinMaxAreaCar(
LefDefParser::defiPinAntennaModel *this,
int a2,
const char *a3)
{
long long v5; // r13
int v6; // ecx
long long v7; // r12
long long v8; // r15
long long v9; // r12
long long v10; // rdi
long long v11; // rax
long long i; // rcx
long long v13; // rax
long long v14; // rax
long long v15; // rdx
long long v16; // r15
const char *v17; // rax
long long v18; // rax
long long result; // rax
v5 = *((unsigned int *)this + 8);
if ( (_DWORD)v5 == *((_DWORD *)this + 9) )
{
v6 = 2;
if ( (_DWORD)v5 )
v6 = 2 * v5;
*((_DWORD *)this + 9) = v6;
v7 = v6;
v8 = malloc(4LL * v6);
v9 = malloc(8 * v7);
v10 = *((_QWORD *)this + 5);
if ( (int)v5 > 0 )
{
v11 = *((_QWORD *)this + 6);
for ( i = 0LL; i != v5; ++i )
{
*(_DWORD *)(v8 + 4 * i) = *(_DWORD *)(v10 + 4 * i);
*(_QWORD *)(v9 + 8 * i) = *(_QWORD *)(v11 + 8 * i);
}
}
free(v10);
free(*((_QWORD *)this + 6));
*((_QWORD *)this + 5) = v8;
*((_QWORD *)this + 6) = v9;
LODWORD(v5) = *((_DWORD *)this + 8);
}
else
{
v8 = *((_QWORD *)this + 5);
}
*(_DWORD *)(v8 + 4LL * (int)v5) = a2;
if ( a3 )
{
v13 = strlen(a3);
v14 = malloc(v13 + 1);
v15 = *((int *)this + 8);
*(_QWORD *)(*((_QWORD *)this + 6) + 8 * v15) = v14;
v16 = *(_QWORD *)(*((_QWORD *)this + 6) + 8 * v15);
v17 = LefDefParser::defrData::DEFCASE(*((LefDefParser::defrData **)this + 13), a3);
strcpy(v16, v17);
LODWORD(v18) = *((_DWORD *)this + 8);
}
else
{
v18 = *((int *)this + 8);
*(_QWORD *)(*((_QWORD *)this + 6) + 8 * v18) = 0LL;
}
result = (unsigned int)(v18 + 1);
*((_DWORD *)this + 8) = result;
return result;
}
| addAPinMaxAreaCar:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV EBP,ESI
MOV RBX,RDI
MOV R13D,dword ptr [RDI + 0x20]
CMP R13D,dword ptr [RDI + 0x24]
JNZ 0x0011969d
LEA EAX,[R13*0x2]
TEST R13D,R13D
MOV ECX,0x2
CMOVNZ ECX,EAX
MOV dword ptr [RBX + 0x24],ECX
MOVSXD R12,ECX
LEA RDI,[R12*0x4]
CALL 0x00106270
MOV R15,RAX
SHL R12,0x3
MOV RDI,R12
CALL 0x00106270
MOV R12,RAX
MOV RDI,qword ptr [RBX + 0x28]
TEST R13D,R13D
JLE 0x00119681
MOV RAX,qword ptr [RBX + 0x30]
XOR ECX,ECX
LAB_0011966a:
MOV EDX,dword ptr [RDI + RCX*0x4]
MOV dword ptr [R15 + RCX*0x4],EDX
MOV RDX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [R12 + RCX*0x8],RDX
INC RCX
CMP R13,RCX
JNZ 0x0011966a
LAB_00119681:
CALL 0x00106220
MOV RDI,qword ptr [RBX + 0x30]
CALL 0x00106220
MOV qword ptr [RBX + 0x28],R15
MOV qword ptr [RBX + 0x30],R12
MOV R13D,dword ptr [RBX + 0x20]
JMP 0x001196a1
LAB_0011969d:
MOV R15,qword ptr [RBX + 0x28]
LAB_001196a1:
MOVSXD RAX,R13D
MOV dword ptr [R15 + RAX*0x4],EBP
TEST R14,R14
JZ 0x001196ee
MOV RDI,R14
CALL 0x001060d0
LEA RDI,[RAX + 0x1]
CALL 0x00106270
MOV RCX,qword ptr [RBX + 0x30]
MOVSXD RDX,dword ptr [RBX + 0x20]
MOV qword ptr [RCX + RDX*0x8],RAX
MOV RAX,qword ptr [RBX + 0x30]
MOV RDI,qword ptr [RBX + 0x68]
MOV R15,qword ptr [RAX + RDX*0x8]
MOV RSI,R14
CALL 0x00118aa0
MOV RDI,R15
MOV RSI,RAX
CALL 0x00106190
MOV EAX,dword ptr [RBX + 0x20]
JMP 0x001196fe
LAB_001196ee:
MOV RCX,qword ptr [RBX + 0x30]
MOVSXD RAX,dword ptr [RBX + 0x20]
MOV qword ptr [RCX + RAX*0x8],0x0
LAB_001196fe:
INC EAX
MOV dword ptr [RBX + 0x20],EAX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* LefDefParser::defiPinAntennaModel::addAPinMaxAreaCar(int, char const*) */
void __thiscall
LefDefParser::defiPinAntennaModel::addAPinMaxAreaCar
(defiPinAntennaModel *this,int param_1,char *param_2)
{
void *__ptr;
long lVar1;
char *__dest;
int iVar2;
void *pvVar3;
void *pvVar4;
size_t sVar5;
char *__src;
ulong uVar6;
uint uVar7;
uVar7 = *(uint *)(this + 0x20);
if (uVar7 == *(uint *)(this + 0x24)) {
iVar2 = 2;
if (uVar7 != 0) {
iVar2 = uVar7 * 2;
}
*(int *)(this + 0x24) = iVar2;
pvVar3 = malloc((long)iVar2 * 4);
pvVar4 = malloc((long)iVar2 << 3);
__ptr = *(void **)(this + 0x28);
if (0 < (int)uVar7) {
lVar1 = *(long *)(this + 0x30);
uVar6 = 0;
do {
*(int4 *)((long)pvVar3 + uVar6 * 4) = *(int4 *)((long)__ptr + uVar6 * 4);
*(int8 *)((long)pvVar4 + uVar6 * 8) = *(int8 *)(lVar1 + uVar6 * 8);
uVar6 = uVar6 + 1;
} while (uVar7 != uVar6);
}
free(__ptr);
free(*(void **)(this + 0x30));
*(void **)(this + 0x28) = pvVar3;
*(void **)(this + 0x30) = pvVar4;
uVar7 = *(uint *)(this + 0x20);
}
else {
pvVar3 = *(void **)(this + 0x28);
}
*(int *)((long)pvVar3 + (long)(int)uVar7 * 4) = param_1;
if (param_2 == (char *)0x0) {
iVar2 = *(int *)(this + 0x20);
*(int8 *)(*(long *)(this + 0x30) + (long)iVar2 * 8) = 0;
}
else {
sVar5 = strlen(param_2);
pvVar3 = malloc(sVar5 + 1);
iVar2 = *(int *)(this + 0x20);
*(void **)(*(long *)(this + 0x30) + (long)iVar2 * 8) = pvVar3;
__dest = *(char **)(*(long *)(this + 0x30) + (long)iVar2 * 8);
__src = (char *)defrData::DEFCASE(*(defrData **)(this + 0x68),param_2);
strcpy(__dest,__src);
iVar2 = *(int *)(this + 0x20);
}
*(int *)(this + 0x20) = iVar2 + 1;
return;
}
| |
41,610 | psi_rwlock_rdlock | eloqsql/mysys/my_thr_init.c | ATTRIBUTE_COLD
int psi_rwlock_rdlock(mysql_rwlock_t *that, const char *file, uint line)
{
PSI_rwlock_locker_state state;
PSI_rwlock_locker *locker= PSI_RWLOCK_CALL(start_rwlock_rdwait)
(&state, that->m_psi, PSI_RWLOCK_READLOCK, file, line);
int result= rw_rdlock(&that->m_rwlock);
if (locker)
PSI_RWLOCK_CALL(end_rwlock_rdwait)(locker, result);
return result;
} | O3 | c | psi_rwlock_rdlock:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %r8d
movq %rsi, %rcx
movq %rdi, %r14
leaq 0x3063e6(%rip), %r15 # 0x330350
movq (%r15), %rax
movq 0x90(%rdi), %rsi
leaq -0x48(%rbp), %rdi
xorl %edx, %edx
callq *0x1a0(%rax)
movq %rax, %rbx
movq %r14, %rdi
callq 0x5e91c
movl %eax, %r14d
testq %rbx, %rbx
je 0x29fa2
movq (%r15), %rax
movq %rbx, %rdi
movl %r14d, %esi
callq *0x1a8(%rax)
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| psi_rwlock_rdlock:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 38h
mov r8d, edx
mov rcx, rsi
mov r14, rdi
lea r15, PSI_server
mov rax, [r15]
mov rsi, [rdi+90h]
lea rdi, [rbp+var_48]
xor edx, edx
call qword ptr [rax+1A0h]
mov rbx, rax
mov rdi, r14
call my_rw_rdlock
mov r14d, eax
test rbx, rbx
jz short loc_29FA2
mov rax, [r15]
mov rdi, rbx
mov esi, r14d
call qword ptr [rax+1A8h]
loc_29FA2:
mov eax, r14d
add rsp, 38h
pop rbx
pop r14
pop r15
pop rbp
retn
| long long psi_rwlock_rdlock(long long a1, long long a2, unsigned int a3)
{
long long v3; // rbx
unsigned int v4; // r14d
_BYTE v6[72]; // [rsp+8h] [rbp-48h] BYREF
v3 = ((long long ( *)(_BYTE *, _QWORD, _QWORD, long long, _QWORD))PSI_server[52])(
v6,
*(_QWORD *)(a1 + 144),
0LL,
a2,
a3);
v4 = my_rw_rdlock(a1);
if ( v3 )
((void ( *)(long long, _QWORD))PSI_server[53])(v3, v4);
return v4;
}
| psi_rwlock_rdlock:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV R8D,EDX
MOV RCX,RSI
MOV R14,RDI
LEA R15,[0x430350]
MOV RAX,qword ptr [R15]
MOV RSI,qword ptr [RDI + 0x90]
LEA RDI,[RBP + -0x48]
XOR EDX,EDX
CALL qword ptr [RAX + 0x1a0]
MOV RBX,RAX
MOV RDI,R14
CALL 0x0015e91c
MOV R14D,EAX
TEST RBX,RBX
JZ 0x00129fa2
MOV RAX,qword ptr [R15]
MOV RDI,RBX
MOV ESI,R14D
CALL qword ptr [RAX + 0x1a8]
LAB_00129fa2:
MOV EAX,R14D
ADD RSP,0x38
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 psi_rwlock_rdlock(long param_1,int8 param_2,int4 param_3)
{
int4 uVar1;
long lVar2;
int1 local_50 [48];
lVar2 = (**(code **)(PSI_server + 0x1a0))
(local_50,*(int8 *)(param_1 + 0x90),0,param_2,param_3);
uVar1 = my_rw_rdlock(param_1);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x1a8))(lVar2,uVar1);
}
return uVar1;
}
| |
41,611 | testing::internal::String::EndsWithCaseInsensitive(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest.cc | bool String::EndsWithCaseInsensitive(const std::string& str,
const std::string& suffix) {
const size_t str_len = str.length();
const size_t suffix_len = suffix.length();
return (str_len >= suffix_len) &&
CaseInsensitiveCStringEquals(str.c_str() + str_len - suffix_len,
suffix.c_str());
} | O0 | cpp | testing::internal::String::EndsWithCaseInsensitive(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1ec30
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1ec30
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rcx
xorl %eax, %eax
cmpq 0x18(%rsp), %rcx
movb %al, 0x17(%rsp)
jb 0xbefb7
movq 0x30(%rsp), %rdi
callq 0x1f1e0
addq 0x20(%rsp), %rax
xorl %ecx, %ecx
subq 0x18(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1f1e0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xcb8c0
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZN7testing8internal6String23EndsWithCaseInsensitiveERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES9_:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_10], rsi
mov rdi, [rsp+38h+var_8]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv; std::string::length(void)
mov [rsp+38h+var_18], rax
mov rdi, [rsp+38h+var_10]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv; std::string::length(void)
mov [rsp+38h+var_20], rax
mov rcx, [rsp+38h+var_18]
xor eax, eax
cmp rcx, [rsp+38h+var_20]
mov [rsp+38h+var_21], al
jb short loc_BEFB7
mov rdi, [rsp+38h+var_8]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
add rax, [rsp+38h+var_18]
xor ecx, ecx
sub rcx, [rsp+38h+var_20]
add rax, rcx
mov [rsp+38h+var_30], rax
mov rdi, [rsp+38h+var_10]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rdi, [rsp+38h+var_30]; this
mov rsi, rax; char *
call _ZN7testing8internal6String28CaseInsensitiveCStringEqualsEPKcS3_; testing::internal::String::CaseInsensitiveCStringEquals(char const*,char const*)
mov [rsp+38h+var_21], al
loc_BEFB7:
mov al, [rsp+38h+var_21]
and al, 1
add rsp, 38h
retn
| char testing::internal::String::EndsWithCaseInsensitive(long long a1, long long a2)
{
const char *v2; // rax
const char *v3; // rdx
testing::internal::String *v5; // [rsp+8h] [rbp-30h]
char v6; // [rsp+17h] [rbp-21h]
unsigned long long v7; // [rsp+18h] [rbp-20h]
unsigned long long v8; // [rsp+20h] [rbp-18h]
v8 = std::string::length(a1);
v7 = std::string::length(a2);
v6 = 0;
if ( v8 >= v7 )
{
v5 = (testing::internal::String *)(v8 + std::string::c_str(a1) - v7);
v2 = (const char *)std::string::c_str(a2);
v6 = testing::internal::String::CaseInsensitiveCStringEquals(v5, v2, v3);
}
return v6 & 1;
}
| EndsWithCaseInsensitive:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV qword ptr [RSP + 0x28],RSI
MOV RDI,qword ptr [RSP + 0x30]
CALL 0x0011ec30
MOV qword ptr [RSP + 0x20],RAX
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0011ec30
MOV qword ptr [RSP + 0x18],RAX
MOV RCX,qword ptr [RSP + 0x20]
XOR EAX,EAX
CMP RCX,qword ptr [RSP + 0x18]
MOV byte ptr [RSP + 0x17],AL
JC 0x001befb7
MOV RDI,qword ptr [RSP + 0x30]
CALL 0x0011f1e0
ADD RAX,qword ptr [RSP + 0x20]
XOR ECX,ECX
SUB RCX,qword ptr [RSP + 0x18]
ADD RAX,RCX
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0011f1e0
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RAX
CALL 0x001cb8c0
MOV byte ptr [RSP + 0x17],AL
LAB_001befb7:
MOV AL,byte ptr [RSP + 0x17]
AND AL,0x1
ADD RSP,0x38
RET
|
/* testing::internal::String::EndsWithCaseInsensitive(std::__cxx11::string const&,
std::__cxx11::string const&) */
ulong testing::internal::String::EndsWithCaseInsensitive(string *param_1,string *param_2)
{
ulong uVar1;
ulong uVar2;
long lVar3;
char *pcVar4;
int8 uVar5;
int1 local_21;
uVar1 = std::__cxx11::string::length(param_1);
uVar2 = std::__cxx11::string::length(param_2);
uVar5 = 0;
local_21 = 0;
if (uVar2 <= uVar1) {
lVar3 = std::__cxx11::string::c_str(param_1);
pcVar4 = (char *)std::__cxx11::string::c_str(param_2);
uVar5 = CaseInsensitiveCStringEquals((char *)((lVar3 + uVar1) - uVar2),pcVar4);
local_21 = (int1)uVar5;
}
return CONCAT71((int7)((ulong)uVar5 >> 8),local_21) & 0xffffffffffffff01;
}
| |
41,612 | LefDefParser::defiWire::Init(char const*, char const*) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiNet.cpp | void defiWire::Init(const char* type, const char* wireShieldName) {
int len = strlen(type) + 1;
type_ = (char*)malloc(len);
strcpy(type_, defData->DEFCASE(type));
if (wireShieldName) {
wireShieldName_ = (char*)malloc(strlen(wireShieldName)+1);
strcpy(wireShieldName_, wireShieldName);
} else
wireShieldName_ = 0;
numPaths_ = 0;
pathsAllocated_ = 0;
paths_ = 0;
} | O3 | cpp | LefDefParser::defiWire::Init(char const*, char const*):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x60d0
incl %eax
movslq %eax, %rdi
callq 0x6270
movq %rax, %r12
movq %rax, (%rbx)
movq 0x20(%rbx), %rdi
movq %r15, %rsi
callq 0x18aa0
movq %r12, %rdi
movq %rax, %rsi
callq 0x6190
testq %r14, %r14
je 0x20309
movq %r14, %rdi
callq 0x60d0
leaq 0x1(%rax), %rdi
callq 0x6270
movq %rax, 0x8(%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x6190
jmp 0x20311
movq $0x0, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| _ZN12LefDefParser8defiWire4InitEPKcS2_:
push r15
push r14
push r12
push rbx
push rax
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov rdi, rsi
call _strlen
inc eax
movsxd rdi, eax
call _malloc
mov r12, rax
mov [rbx], rax
mov rdi, [rbx+20h]; this
mov rsi, r15; char *
call _ZN12LefDefParser8defrData7DEFCASEEPKc; LefDefParser::defrData::DEFCASE(char const*)
mov rdi, r12
mov rsi, rax
call _strcpy
test r14, r14
jz short loc_20309
mov rdi, r14
call _strlen
lea rdi, [rax+1]
call _malloc
mov [rbx+8], rax
mov rdi, rax
mov rsi, r14
call _strcpy
jmp short loc_20311
loc_20309:
mov qword ptr [rbx+8], 0
loc_20311:
xorps xmm0, xmm0
movups xmmword ptr [rbx+10h], xmm0
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long LefDefParser::defiWire::Init(LefDefParser::defrData **this, const char *a2, const char *a3)
{
int v4; // eax
long long v5; // r12
const char *v6; // rax
long long result; // rax
long long v8; // rax
long long v9; // rax
v4 = strlen(a2);
v5 = malloc(v4 + 1);
*this = (LefDefParser::defrData *)v5;
v6 = LefDefParser::defrData::DEFCASE(this[4], a2);
result = strcpy(v5, v6);
if ( a3 )
{
v8 = strlen(a3);
v9 = malloc(v8 + 1);
this[1] = (LefDefParser::defrData *)v9;
result = strcpy(v9, a3);
}
else
{
this[1] = 0LL;
}
*((_OWORD *)this + 1) = 0LL;
return result;
}
| Init:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV RDI,RSI
CALL 0x001060d0
INC EAX
MOVSXD RDI,EAX
CALL 0x00106270
MOV R12,RAX
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x20]
MOV RSI,R15
CALL 0x00118aa0
MOV RDI,R12
MOV RSI,RAX
CALL 0x00106190
TEST R14,R14
JZ 0x00120309
MOV RDI,R14
CALL 0x001060d0
LEA RDI,[RAX + 0x1]
CALL 0x00106270
MOV qword ptr [RBX + 0x8],RAX
MOV RDI,RAX
MOV RSI,R14
CALL 0x00106190
JMP 0x00120311
LAB_00120309:
MOV qword ptr [RBX + 0x8],0x0
LAB_00120311:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* LefDefParser::defiWire::Init(char const*, char const*) */
void __thiscall LefDefParser::defiWire::Init(defiWire *this,char *param_1,char *param_2)
{
size_t sVar1;
char *pcVar2;
char *__src;
sVar1 = strlen(param_1);
pcVar2 = (char *)malloc((long)((int)sVar1 + 1));
*(char **)this = pcVar2;
__src = (char *)defrData::DEFCASE(*(defrData **)(this + 0x20),param_1);
strcpy(pcVar2,__src);
if (param_2 == (char *)0x0) {
*(int8 *)(this + 8) = 0;
}
else {
sVar1 = strlen(param_2);
pcVar2 = (char *)malloc(sVar1 + 1);
*(char **)(this + 8) = pcVar2;
strcpy(pcVar2,param_2);
}
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
return;
}
| |
41,613 | lf_pinbox_get_pins | eloqsql/mysys/lf_alloc-pin.c | LF_PINS *lf_pinbox_get_pins(LF_PINBOX *pinbox)
{
uint32 pins, next, top_ver;
LF_PINS *el;
/*
We have an array of max. 64k elements.
The highest index currently allocated is pinbox->pins_in_array.
Freed elements are in a lifo stack, pinstack_top_ver.
pinstack_top_ver is 32 bits; 16 low bits are the index in the
array, to the first element of the list. 16 high bits are a version
(every time the 16 low bits are updated, the 16 high bits are
incremented). Versioning prevents the ABA problem.
*/
top_ver= pinbox->pinstack_top_ver;
do
{
if (!(pins= top_ver % LF_PINBOX_MAX_PINS))
{
/* the stack of free elements is empty */
pins= my_atomic_add32((int32 volatile*) &pinbox->pins_in_array, 1)+1;
if (unlikely(pins >= LF_PINBOX_MAX_PINS))
return 0;
/*
note that the first allocated element has index 1 (pins==1).
index 0 is reserved to mean "NULL pointer"
*/
el= (LF_PINS *)lf_dynarray_lvalue(&pinbox->pinarray, pins);
if (unlikely(!el))
return 0;
break;
}
el= (LF_PINS *)lf_dynarray_value(&pinbox->pinarray, pins);
next= el->link;
} while (!my_atomic_cas32((int32 volatile*) &pinbox->pinstack_top_ver,
(int32*) &top_ver,
top_ver-pins+next+LF_PINBOX_MAX_PINS));
/*
set el->link to the index of el in the dynarray (el->link has two usages:
- if element is allocated, it's its own index
- if element is free, it's its next element in the free stack
*/
el->link= pins;
el->purgatory_count= 0;
el->pinbox= pinbox;
return el;
} | O3 | c | lf_pinbox_get_pins:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x3c(%rdi), %r15d
movl %r15d, %r14d
andl $0xffff, %r14d # imm = 0xFFFF
je 0x2ba76
movq %rbx, %rdi
movl %r14d, %esi
callq 0x471a0
movq %rax, %rcx
movl 0x34(%rax), %eax
movl %r15d, %edx
andl $0xffff0000, %edx # imm = 0xFFFF0000
addl %eax, %edx
addl $0x10000, %edx # imm = 0x10000
movl %r15d, %eax
lock
cmpxchgl %edx, 0x3c(%rbx)
movl %eax, %r15d
jne 0x2ba39
jmp 0x2ba9f
pushq $0x1
popq %r14
lock
xaddl %r14d, 0x40(%rbx)
incl %r14d
cmpl $0xffff, %r14d # imm = 0xFFFF
ja 0x2bab9
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2babd
testq %rax, %rax
je 0x2bab9
movq %rax, %rcx
movl %r14d, 0x34(%rcx)
andl $0x0, 0x30(%rcx)
movq %rbx, 0x20(%rcx)
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %ecx, %ecx
jmp 0x2baab
| lf_pinbox_get_pins:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
mov r15d, [rdi+3Ch]
loc_2BA39:
mov r14d, r15d
and r14d, 0FFFFh
jz short loc_2BA76
mov rdi, rbx
mov esi, r14d
call lf_dynarray_value
mov rcx, rax
mov eax, [rax+34h]
mov edx, r15d
and edx, 0FFFF0000h
add edx, eax
add edx, 10000h
mov eax, r15d
lock cmpxchg [rbx+3Ch], edx
mov r15d, eax
jnz short loc_2BA39
jmp short loc_2BA9F
loc_2BA76:
push 1
pop r14
lock xadd [rbx+40h], r14d
inc r14d
cmp r14d, 0FFFFh
ja short loc_2BAB9
mov rdi, rbx
mov esi, r14d
call lf_dynarray_lvalue
test rax, rax
jz short loc_2BAB9
mov rcx, rax
loc_2BA9F:
mov [rcx+34h], r14d
and dword ptr [rcx+30h], 0
mov [rcx+20h], rbx
loc_2BAAB:
mov rax, rcx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_2BAB9:
xor ecx, ecx
jmp short loc_2BAAB
| long long lf_pinbox_get_pins(long long a1)
{
signed __int32 v1; // r15d
unsigned __int32 v2; // r14d
long long v3; // rcx
bool v4; // zf
signed __int32 v5; // eax
long long v6; // rax
v1 = *(_DWORD *)(a1 + 60);
while ( 1 )
{
v2 = (unsigned __int16)v1;
if ( !(_WORD)v1 )
break;
v3 = lf_dynarray_value(a1, (unsigned __int16)v1);
v5 = _InterlockedCompareExchange(
(volatile signed __int32 *)(a1 + 60),
*(_DWORD *)(v3 + 52) + (v1 & 0xFFFF0000) + 0x10000,
v1);
v4 = v1 == v5;
v1 = v5;
if ( v4 )
goto LABEL_8;
}
v2 = _InterlockedIncrement((volatile signed __int32 *)(a1 + 64));
if ( v2 <= 0xFFFF )
{
v6 = lf_dynarray_lvalue(a1, v2);
if ( v6 )
{
v3 = v6;
LABEL_8:
*(_DWORD *)(v3 + 52) = v2;
*(_DWORD *)(v3 + 48) = 0;
*(_QWORD *)(v3 + 32) = a1;
return v3;
}
}
return 0LL;
}
| lf_pinbox_get_pins:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R15D,dword ptr [RDI + 0x3c]
LAB_0012ba39:
MOV R14D,R15D
AND R14D,0xffff
JZ 0x0012ba76
MOV RDI,RBX
MOV ESI,R14D
CALL 0x001471a0
MOV RCX,RAX
MOV EAX,dword ptr [RAX + 0x34]
MOV EDX,R15D
AND EDX,0xffff0000
ADD EDX,EAX
ADD EDX,0x10000
MOV EAX,R15D
CMPXCHG.LOCK dword ptr [RBX + 0x3c],EDX
MOV R15D,EAX
JNZ 0x0012ba39
JMP 0x0012ba9f
LAB_0012ba76:
PUSH 0x1
POP R14
XADD.LOCK dword ptr [RBX + 0x40],R14D
INC R14D
CMP R14D,0xffff
JA 0x0012bab9
MOV RDI,RBX
MOV ESI,R14D
CALL 0x0012babd
TEST RAX,RAX
JZ 0x0012bab9
MOV RCX,RAX
LAB_0012ba9f:
MOV dword ptr [RCX + 0x34],R14D
AND dword ptr [RCX + 0x30],0x0
MOV qword ptr [RCX + 0x20],RBX
LAB_0012baab:
MOV RAX,RCX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0012bab9:
XOR ECX,ECX
JMP 0x0012baab
|
long lf_pinbox_get_pins(long param_1)
{
int *piVar1;
uint uVar2;
int iVar3;
long lVar4;
uint uVar5;
uint uVar6;
bool bVar7;
uVar6 = *(uint *)(param_1 + 0x3c);
do {
uVar5 = uVar6 & 0xffff;
if (uVar5 == 0) {
LOCK();
piVar1 = (int *)(param_1 + 0x40);
iVar3 = *piVar1;
*piVar1 = *piVar1 + 1;
UNLOCK();
uVar5 = iVar3 + 1;
if ((0xffff < uVar5) || (lVar4 = lf_dynarray_lvalue(param_1,uVar5), lVar4 == 0)) {
return 0;
}
break;
}
lVar4 = lf_dynarray_value(param_1,uVar5);
LOCK();
uVar2 = *(uint *)(param_1 + 0x3c);
bVar7 = uVar6 == uVar2;
if (bVar7) {
*(uint *)(param_1 + 0x3c) = (uVar6 & 0xffff0000) + *(int *)(lVar4 + 0x34) + 0x10000;
uVar2 = uVar6;
}
uVar6 = uVar2;
UNLOCK();
} while (!bVar7);
*(uint *)(lVar4 + 0x34) = uVar5;
*(int4 *)(lVar4 + 0x30) = 0;
*(long *)(lVar4 + 0x20) = param_1;
return lVar4;
}
| |
41,614 | DrawRectangleGradientEx | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rshapes.c | void DrawRectangleGradientEx(Rectangle rec, Color topLeft, Color bottomLeft, Color topRight, Color bottomRight)
{
rlSetTexture(GetShapesTexture().id);
Rectangle shapeRect = GetShapesTextureRectangle();
rlBegin(RL_QUADS);
rlNormal3f(0.0f, 0.0f, 1.0f);
// NOTE: Default raylib font character 95 is a white square
rlColor4ub(topLeft.r, topLeft.g, topLeft.b, topLeft.a);
rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
rlVertex2f(rec.x, rec.y);
rlColor4ub(bottomLeft.r, bottomLeft.g, bottomLeft.b, bottomLeft.a);
rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
rlVertex2f(rec.x, rec.y + rec.height);
rlColor4ub(topRight.r, topRight.g, topRight.b, topRight.a);
rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
rlVertex2f(rec.x + rec.width, rec.y + rec.height);
rlColor4ub(bottomRight.r, bottomRight.g, bottomRight.b, bottomRight.a);
rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
rlVertex2f(rec.x + rec.width, rec.y);
rlEnd();
rlSetTexture(0);
} | O2 | c | DrawRectangleGradientEx:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %esi, %ebp
movl %edi, %r13d
movaps %xmm1, 0x40(%rsp)
movaps %xmm0, 0x70(%rsp)
movl %edi, %r15d
shrl $0x8, %r15d
movl %edi, %r12d
shrl $0x10, %r12d
movl %edi, %eax
shrl $0x18, %eax
movl %eax, 0x60(%rsp)
movl %esi, %r14d
shrl $0x8, %r14d
movl %esi, %ebx
shrl $0x10, %ebx
movl %esi, %eax
shrl $0x18, %eax
movl %eax, 0x50(%rsp)
movl %edx, (%rsp)
movl %edx, %eax
shrl $0x8, %eax
movl %eax, 0x8(%rsp)
movl %edx, %eax
shrl $0x10, %eax
movl %eax, 0x4(%rsp)
movl %edx, %eax
shrl $0x18, %eax
movl %eax, 0xc(%rsp)
movl %ecx, 0x10(%rsp)
movl %ecx, %eax
shrl $0x8, %eax
movl %eax, 0x18(%rsp)
movl %ecx, %eax
shrl $0x10, %eax
movl %eax, 0x14(%rsp)
movl %ecx, %eax
shrl $0x18, %eax
movl %eax, 0x1c(%rsp)
movl 0xbaa21(%rip), %edi # 0x1228a0
callq 0x52bc9
movsd 0xbaa34(%rip), %xmm0 # 0x1228c0
movaps %xmm0, 0x20(%rsp)
movsd 0xbaa2f(%rip), %xmm0 # 0x1228c8
movaps %xmm0, 0x30(%rsp)
pushq $0x7
popq %rdi
callq 0x51283
movss 0x517ee(%rip), %xmm2 # 0xb969c
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x52a34
movl $0xff, %eax
andl %eax, %r13d
andl %eax, %r15d
andl %eax, %r12d
movl %r13d, %edi
movl %r15d, %esi
movl %r12d, %edx
movl 0x60(%rsp), %ecx
callq 0x52b4f
cvtsi2ssl 0xba9c3(%rip), %xmm1 # 0x1228a4
movaps 0x20(%rsp), %xmm3
movaps %xmm3, %xmm0
divss %xmm1, %xmm0
cvtsi2ssl 0xba9b3(%rip), %xmm2 # 0x1228a8
movaps %xmm3, %xmm1
shufps $0x55, %xmm3, %xmm1 # xmm1 = xmm1[1,1],xmm3[1,1]
movaps %xmm1, 0x60(%rsp)
divss %xmm2, %xmm1
callq 0x52a23
movaps 0x70(%rsp), %xmm0
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1 # xmm1 = xmm1[1,1],xmm0[1,1]
movaps %xmm1, 0x80(%rsp)
callq 0x529f9
movl $0xff, %eax
andl %eax, %ebp
andl %eax, %r14d
andl %eax, %ebx
movl %ebp, %edi
movl %r14d, %esi
movl %ebx, %edx
movl 0x50(%rsp), %ecx
callq 0x52b4f
cvtsi2ssl 0xba95d(%rip), %xmm1 # 0x1228a4
movaps 0x20(%rsp), %xmm2
movaps %xmm2, %xmm0
divss %xmm1, %xmm0
movaps 0x30(%rsp), %xmm1
addps %xmm2, %xmm1
movaps %xmm1, 0x30(%rsp)
cvtsi2ssl 0xba940(%rip), %xmm2 # 0x1228a8
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
movaps %xmm1, 0x20(%rsp)
divss %xmm2, %xmm1
callq 0x52a23
movaps 0x40(%rsp), %xmm1
movaps 0x70(%rsp), %xmm0
addps %xmm0, %xmm1
movaps %xmm1, 0x40(%rsp)
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
movaps %xmm1, 0x50(%rsp)
callq 0x529f9
movl $0xff, %eax
movl (%rsp), %edi
andl %eax, %edi
movl 0x8(%rsp), %esi
andl %eax, %esi
movl 0x4(%rsp), %edx
andl %eax, %edx
movl $0xff, %ebx
movl 0xc(%rsp), %ecx
callq 0x52b4f
cvtsi2ssl 0xba8de(%rip), %xmm1 # 0x1228a4
movaps 0x30(%rsp), %xmm0
divss %xmm1, %xmm0
cvtsi2ssl 0xba8d1(%rip), %xmm2 # 0x1228a8
movaps 0x20(%rsp), %xmm1
divss %xmm2, %xmm1
callq 0x52a23
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
callq 0x529f9
movl 0x10(%rsp), %edi
andl %ebx, %edi
movl 0x18(%rsp), %esi
andl %ebx, %esi
movl 0x14(%rsp), %edx
andl %ebx, %edx
movl 0x1c(%rsp), %ecx
callq 0x52b4f
cvtsi2ssl 0xba88d(%rip), %xmm1 # 0x1228a4
movaps 0x30(%rsp), %xmm0
divss %xmm1, %xmm0
cvtsi2ssl 0xba880(%rip), %xmm2 # 0x1228a8
movaps 0x60(%rsp), %xmm1
divss %xmm2, %xmm1
callq 0x52a23
movaps 0x40(%rsp), %xmm0
movaps 0x80(%rsp), %xmm1
callq 0x529f9
callq 0x5265a
xorl %edi, %edi
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x52bc9
| DrawRectangleGradientEx:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov ebp, esi
mov r13d, edi
movaps [rsp+0C8h+var_88], xmm1
movaps [rsp+0C8h+var_58], xmm0
mov r15d, edi
shr r15d, 8
mov r12d, edi
shr r12d, 10h
mov eax, edi
shr eax, 18h
mov dword ptr [rsp+0C8h+var_68], eax
mov r14d, esi
shr r14d, 8
mov ebx, esi
shr ebx, 10h
mov eax, esi
shr eax, 18h
mov dword ptr [rsp+0C8h+var_78], eax
mov [rsp+0C8h+var_C8], edx
mov eax, edx
shr eax, 8
mov [rsp+0C8h+var_C0], eax
mov eax, edx
shr eax, 10h
mov [rsp+0C8h+var_C4], eax
mov eax, edx
shr eax, 18h
mov [rsp+0C8h+var_BC], eax
mov [rsp+0C8h+var_B8], ecx
mov eax, ecx
shr eax, 8
mov [rsp+0C8h+var_B0], eax
mov eax, ecx
shr eax, 10h
mov [rsp+0C8h+var_B4], eax
mov eax, ecx
shr eax, 18h
mov [rsp+0C8h+var_AC], eax
mov edi, dword ptr cs:texShapes
call rlSetTexture
movsd xmm0, qword ptr cs:texShapesRec
movaps [rsp+0C8h+var_A8], xmm0
movsd xmm0, qword ptr cs:texShapesRec+8
movaps [rsp+0C8h+var_98], xmm0
push 7
pop rdi
call rlBegin
movss xmm2, cs:dword_B969C
xorps xmm0, xmm0
xorps xmm1, xmm1
call rlNormal3f
mov eax, 0FFh
and r13d, eax
and r15d, eax
and r12d, eax
mov edi, r13d
mov esi, r15d
mov edx, r12d
mov ecx, dword ptr [rsp+0C8h+var_68]
call rlColor4ub
cvtsi2ss xmm1, dword ptr cs:texShapes+4
movaps xmm3, [rsp+0C8h+var_A8]
movaps xmm0, xmm3
divss xmm0, xmm1
cvtsi2ss xmm2, dword ptr cs:texShapes+8
movaps xmm1, xmm3
shufps xmm1, xmm3, 55h ; 'U'
movaps [rsp+0C8h+var_68], xmm1
divss xmm1, xmm2
call rlTexCoord2f
movaps xmm0, [rsp+0C8h+var_58]
movaps xmm1, xmm0
shufps xmm1, xmm0, 55h ; 'U'
movaps [rsp+0C8h+var_48], xmm1
call rlVertex2f
mov eax, 0FFh
and ebp, eax
and r14d, eax
and ebx, eax
mov edi, ebp
mov esi, r14d
mov edx, ebx
mov ecx, dword ptr [rsp+0C8h+var_78]
call rlColor4ub
cvtsi2ss xmm1, dword ptr cs:texShapes+4
movaps xmm2, [rsp+0C8h+var_A8]
movaps xmm0, xmm2
divss xmm0, xmm1
movaps xmm1, [rsp+0C8h+var_98]
addps xmm1, xmm2
movaps [rsp+0C8h+var_98], xmm1
cvtsi2ss xmm2, dword ptr cs:texShapes+8
shufps xmm1, xmm1, 55h ; 'U'
movaps [rsp+0C8h+var_A8], xmm1
divss xmm1, xmm2
call rlTexCoord2f
movaps xmm1, [rsp+0C8h+var_88]
movaps xmm0, [rsp+0C8h+var_58]
addps xmm1, xmm0
movaps [rsp+0C8h+var_88], xmm1
shufps xmm1, xmm1, 55h ; 'U'
movaps [rsp+0C8h+var_78], xmm1
call rlVertex2f
mov eax, 0FFh
mov edi, [rsp+0C8h+var_C8]
and edi, eax
mov esi, [rsp+0C8h+var_C0]
and esi, eax
mov edx, [rsp+0C8h+var_C4]
and edx, eax
mov ebx, 0FFh
mov ecx, [rsp+0C8h+var_BC]
call rlColor4ub
cvtsi2ss xmm1, dword ptr cs:texShapes+4
movaps xmm0, [rsp+0C8h+var_98]
divss xmm0, xmm1
cvtsi2ss xmm2, dword ptr cs:texShapes+8
movaps xmm1, [rsp+0C8h+var_A8]
divss xmm1, xmm2
call rlTexCoord2f
movaps xmm0, [rsp+0C8h+var_88]
movaps xmm1, [rsp+0C8h+var_78]
call rlVertex2f
mov edi, [rsp+0C8h+var_B8]
and edi, ebx
mov esi, [rsp+0C8h+var_B0]
and esi, ebx
mov edx, [rsp+0C8h+var_B4]
and edx, ebx
mov ecx, [rsp+0C8h+var_AC]
call rlColor4ub
cvtsi2ss xmm1, dword ptr cs:texShapes+4
movaps xmm0, [rsp+0C8h+var_98]
divss xmm0, xmm1
cvtsi2ss xmm2, dword ptr cs:texShapes+8
movaps xmm1, [rsp+0C8h+var_68]
divss xmm1, xmm2
call rlTexCoord2f
movaps xmm0, [rsp+0C8h+var_88]
movaps xmm1, [rsp+0C8h+var_48]
call rlVertex2f
call rlEnd
xor edi, edi
add rsp, 98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp rlSetTexture
| long long DrawRectangleGradientEx(
int a1,
long long a2,
unsigned int a3,
unsigned int a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
__m128 v12; // xmm3
__m128 v13; // xmm2
float v14; // xmm0_4
long long v15; // rdx
double v16; // xmm0_8
double v17; // xmm4_8
double v18; // xmm5_8
char v20; // [rsp+0h] [rbp-C8h]
unsigned int v21; // [rsp+4h] [rbp-C4h]
unsigned int v22; // [rsp+8h] [rbp-C0h]
unsigned int v23; // [rsp+Ch] [rbp-BCh]
unsigned __int8 v24; // [rsp+10h] [rbp-B8h]
unsigned int v25; // [rsp+14h] [rbp-B4h]
unsigned int v26; // [rsp+18h] [rbp-B0h]
unsigned int v27; // [rsp+1Ch] [rbp-ACh]
__m128 v28; // [rsp+20h] [rbp-A8h]
__m128 v29; // [rsp+30h] [rbp-98h]
__m128 v30; // [rsp+30h] [rbp-98h]
__m128 v31; // [rsp+40h] [rbp-88h]
__m128 v32; // [rsp+50h] [rbp-78h]
float v33; // [rsp+60h] [rbp-68h]
__m128 v35; // [rsp+80h] [rbp-48h]
v20 = a3;
v22 = a3 >> 8;
v21 = HIWORD(a3);
v23 = HIBYTE(a3);
v24 = a4;
v26 = a4 >> 8;
v25 = HIWORD(a4);
v27 = HIBYTE(a4);
rlSetTexture(texShapes, a2, *(double *)a5.m128_u64, a6, a7, a8, a9, a10, a11, a12);
v28 = (__m128)(unsigned long long)texShapesRec;
v29 = (__m128)*((unsigned long long *)&texShapesRec + 1);
rlBegin(7);
rlNormal3f((__m128)0LL, (__m128)0LL, (__m128)0x3F800000u);
rlColor4ub(a1, SBYTE1(a1), SBYTE2(a1), SHIBYTE(a1));
v12 = v28;
v33 = _mm_shuffle_ps(v28, v28, 85).m128_f32[0];
rlTexCoord2f(v28.m128_f32[0] / (float)SDWORD1(texShapes), v33 / (float)SDWORD2(texShapes));
v35 = _mm_shuffle_ps(a5, a5, 85);
rlVertex2f(a5, v35);
rlColor4ub(a2, SBYTE1(a2), SBYTE2(a2), SBYTE3(a2));
v13 = v28;
v14 = v28.m128_f32[0] / (float)SDWORD1(texShapes);
v30 = _mm_add_ps(v29, v28);
v28.m128_f32[0] = _mm_shuffle_ps(v30, v30, 85).m128_f32[0];
rlTexCoord2f(v14, v28.m128_f32[0] / (float)SDWORD2(texShapes));
v31 = _mm_add_ps(a6, a5);
v32 = _mm_shuffle_ps(v31, v31, 85);
rlVertex2f(a5, v32);
rlColor4ub(v20, v22, v21, v23);
rlTexCoord2f(v30.m128_f32[0] / (float)SDWORD1(texShapes), v28.m128_f32[0] / (float)SDWORD2(texShapes));
rlVertex2f(v31, v32);
rlColor4ub(v24, v26, v25, v27);
v13.m128_f32[0] = (float)SDWORD2(texShapes);
rlTexCoord2f(v30.m128_f32[0] / (float)SDWORD1(texShapes), v33 / (float)SDWORD2(texShapes));
rlVertex2f(v31, v35);
v16 = rlEnd(v24, (unsigned __int8)v26, v15);
return rlSetTexture(0, (unsigned __int8)v26, v16, v35, v13, v12, v17, v18, a11, a12);
}
| DrawRectangleGradientEx:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV EBP,ESI
MOV R13D,EDI
MOVAPS xmmword ptr [RSP + 0x40],XMM1
MOVAPS xmmword ptr [RSP + 0x70],XMM0
MOV R15D,EDI
SHR R15D,0x8
MOV R12D,EDI
SHR R12D,0x10
MOV EAX,EDI
SHR EAX,0x18
MOV dword ptr [RSP + 0x60],EAX
MOV R14D,ESI
SHR R14D,0x8
MOV EBX,ESI
SHR EBX,0x10
MOV EAX,ESI
SHR EAX,0x18
MOV dword ptr [RSP + 0x50],EAX
MOV dword ptr [RSP],EDX
MOV EAX,EDX
SHR EAX,0x8
MOV dword ptr [RSP + 0x8],EAX
MOV EAX,EDX
SHR EAX,0x10
MOV dword ptr [RSP + 0x4],EAX
MOV EAX,EDX
SHR EAX,0x18
MOV dword ptr [RSP + 0xc],EAX
MOV dword ptr [RSP + 0x10],ECX
MOV EAX,ECX
SHR EAX,0x8
MOV dword ptr [RSP + 0x18],EAX
MOV EAX,ECX
SHR EAX,0x10
MOV dword ptr [RSP + 0x14],EAX
MOV EAX,ECX
SHR EAX,0x18
MOV dword ptr [RSP + 0x1c],EAX
MOV EDI,dword ptr [0x002228a0]
CALL 0x00152bc9
MOVSD XMM0,qword ptr [0x002228c0]
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVSD XMM0,qword ptr [0x002228c8]
MOVAPS xmmword ptr [RSP + 0x30],XMM0
PUSH 0x7
POP RDI
CALL 0x00151283
MOVSS XMM2,dword ptr [0x001b969c]
XORPS XMM0,XMM0
XORPS XMM1,XMM1
CALL 0x00152a34
MOV EAX,0xff
AND R13D,EAX
AND R15D,EAX
AND R12D,EAX
MOV EDI,R13D
MOV ESI,R15D
MOV EDX,R12D
MOV ECX,dword ptr [RSP + 0x60]
CALL 0x00152b4f
CVTSI2SS XMM1,dword ptr [0x002228a4]
MOVAPS XMM3,xmmword ptr [RSP + 0x20]
MOVAPS XMM0,XMM3
DIVSS XMM0,XMM1
CVTSI2SS XMM2,dword ptr [0x002228a8]
MOVAPS XMM1,XMM3
SHUFPS XMM1,XMM3,0x55
MOVAPS xmmword ptr [RSP + 0x60],XMM1
DIVSS XMM1,XMM2
CALL 0x00152a23
MOVAPS XMM0,xmmword ptr [RSP + 0x70]
MOVAPS XMM1,XMM0
SHUFPS XMM1,XMM0,0x55
MOVAPS xmmword ptr [RSP + 0x80],XMM1
CALL 0x001529f9
MOV EAX,0xff
AND EBP,EAX
AND R14D,EAX
AND EBX,EAX
MOV EDI,EBP
MOV ESI,R14D
MOV EDX,EBX
MOV ECX,dword ptr [RSP + 0x50]
CALL 0x00152b4f
CVTSI2SS XMM1,dword ptr [0x002228a4]
MOVAPS XMM2,xmmword ptr [RSP + 0x20]
MOVAPS XMM0,XMM2
DIVSS XMM0,XMM1
MOVAPS XMM1,xmmword ptr [RSP + 0x30]
ADDPS XMM1,XMM2
MOVAPS xmmword ptr [RSP + 0x30],XMM1
CVTSI2SS XMM2,dword ptr [0x002228a8]
SHUFPS XMM1,XMM1,0x55
MOVAPS xmmword ptr [RSP + 0x20],XMM1
DIVSS XMM1,XMM2
CALL 0x00152a23
MOVAPS XMM1,xmmword ptr [RSP + 0x40]
MOVAPS XMM0,xmmword ptr [RSP + 0x70]
ADDPS XMM1,XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM1
SHUFPS XMM1,XMM1,0x55
MOVAPS xmmword ptr [RSP + 0x50],XMM1
CALL 0x001529f9
MOV EAX,0xff
MOV EDI,dword ptr [RSP]
AND EDI,EAX
MOV ESI,dword ptr [RSP + 0x8]
AND ESI,EAX
MOV EDX,dword ptr [RSP + 0x4]
AND EDX,EAX
MOV EBX,0xff
MOV ECX,dword ptr [RSP + 0xc]
CALL 0x00152b4f
CVTSI2SS XMM1,dword ptr [0x002228a4]
MOVAPS XMM0,xmmword ptr [RSP + 0x30]
DIVSS XMM0,XMM1
CVTSI2SS XMM2,dword ptr [0x002228a8]
MOVAPS XMM1,xmmword ptr [RSP + 0x20]
DIVSS XMM1,XMM2
CALL 0x00152a23
MOVAPS XMM0,xmmword ptr [RSP + 0x40]
MOVAPS XMM1,xmmword ptr [RSP + 0x50]
CALL 0x001529f9
MOV EDI,dword ptr [RSP + 0x10]
AND EDI,EBX
MOV ESI,dword ptr [RSP + 0x18]
AND ESI,EBX
MOV EDX,dword ptr [RSP + 0x14]
AND EDX,EBX
MOV ECX,dword ptr [RSP + 0x1c]
CALL 0x00152b4f
CVTSI2SS XMM1,dword ptr [0x002228a4]
MOVAPS XMM0,xmmword ptr [RSP + 0x30]
DIVSS XMM0,XMM1
CVTSI2SS XMM2,dword ptr [0x002228a8]
MOVAPS XMM1,xmmword ptr [RSP + 0x60]
DIVSS XMM1,XMM2
CALL 0x00152a23
MOVAPS XMM0,xmmword ptr [RSP + 0x40]
MOVAPS XMM1,xmmword ptr [RSP + 0x80]
CALL 0x001529f9
CALL 0x0015265a
XOR EDI,EDI
ADD RSP,0x98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00152bc9
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void DrawRectangleGradientEx
(int8 param_1,int8 param_2,uint param_3,int8 param_4,
int8 param_5,int8 param_6)
{
int8 uVar1;
int8 uVar2;
float fVar3;
float fVar4;
int4 local_a8;
int4 uStack_a4;
int4 local_98;
int4 uStack_94;
fVar3 = (float)((ulong)param_1 >> 0x20);
rlSetTexture(texShapes);
uVar2 = DAT_002228c8;
uVar1 = texShapesRec;
rlBegin(7);
rlNormal3f(0,0,DAT_001b969c);
rlColor4ub(param_3 & 0xff,param_3 >> 8 & 0xff,param_3 >> 0x10 & 0xff,param_3 >> 0x18);
local_a8 = (float)uVar1;
uStack_a4 = (float)((ulong)uVar1 >> 0x20);
rlTexCoord2f(local_a8 / (float)_DAT_002228a4,uStack_a4 / (float)_DAT_002228a8);
rlVertex2f();
rlColor4ub((uint)param_4 & 0xff,(uint)((ulong)param_4 >> 8) & 0xff,
(uint)((ulong)param_4 >> 0x10) & 0xff,(uint)((ulong)param_4 >> 0x18) & 0xff);
local_98 = (float)uVar2;
uStack_94 = (float)((ulong)uVar2 >> 0x20);
rlTexCoord2f(local_a8 / (float)_DAT_002228a4,(uStack_94 + uStack_a4) / (float)_DAT_002228a8);
fVar4 = (float)param_2 + (float)param_1;
rlVertex2f();
rlColor4ub((uint)param_5 & 0xff,(uint)((ulong)param_5 >> 8) & 0xff,
(uint)((ulong)param_5 >> 0x10) & 0xff,(uint)((ulong)param_5 >> 0x18) & 0xff);
rlTexCoord2f((local_98 + local_a8) / (float)_DAT_002228a4,
(uStack_94 + uStack_a4) / (float)_DAT_002228a8);
rlVertex2f(fVar4,(float)((ulong)param_2 >> 0x20) + fVar3);
rlColor4ub((uint)param_6 & 0xff,(uint)((ulong)param_6 >> 8) & 0xff,
(uint)((ulong)param_6 >> 0x10) & 0xff,(uint)((ulong)param_6 >> 0x18) & 0xff);
rlTexCoord2f((local_98 + local_a8) / (float)_DAT_002228a4,uStack_a4 / (float)_DAT_002228a8);
rlVertex2f(fVar4,fVar3);
rlEnd();
rlSetTexture(0);
return;
}
| |
41,615 | DrawRectangleGradientEx | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rshapes.c | void DrawRectangleGradientEx(Rectangle rec, Color topLeft, Color bottomLeft, Color topRight, Color bottomRight)
{
rlSetTexture(GetShapesTexture().id);
Rectangle shapeRect = GetShapesTextureRectangle();
rlBegin(RL_QUADS);
rlNormal3f(0.0f, 0.0f, 1.0f);
// NOTE: Default raylib font character 95 is a white square
rlColor4ub(topLeft.r, topLeft.g, topLeft.b, topLeft.a);
rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
rlVertex2f(rec.x, rec.y);
rlColor4ub(bottomLeft.r, bottomLeft.g, bottomLeft.b, bottomLeft.a);
rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
rlVertex2f(rec.x, rec.y + rec.height);
rlColor4ub(topRight.r, topRight.g, topRight.b, topRight.a);
rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
rlVertex2f(rec.x + rec.width, rec.y + rec.height);
rlColor4ub(bottomRight.r, bottomRight.g, bottomRight.b, bottomRight.a);
rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
rlVertex2f(rec.x + rec.width, rec.y);
rlEnd();
rlSetTexture(0);
} | O3 | c | DrawRectangleGradientEx:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %esi, %ebp
movl %edi, %r13d
movaps %xmm1, 0x40(%rsp)
movaps %xmm0, 0x70(%rsp)
movl %edi, %r15d
shrl $0x8, %r15d
movl %edi, %r12d
shrl $0x10, %r12d
movl %edi, %eax
shrl $0x18, %eax
movl %eax, 0x60(%rsp)
movl %esi, %r14d
shrl $0x8, %r14d
movl %esi, %ebx
shrl $0x10, %ebx
movl %esi, %eax
shrl $0x18, %eax
movl %eax, 0x50(%rsp)
movl %edx, (%rsp)
movl %edx, %eax
shrl $0x8, %eax
movl %eax, 0x8(%rsp)
movl %edx, %eax
shrl $0x10, %eax
movl %eax, 0x4(%rsp)
movl %edx, %eax
shrl $0x18, %eax
movl %eax, 0xc(%rsp)
movl %ecx, 0x10(%rsp)
movl %ecx, %eax
shrl $0x8, %eax
movl %eax, 0x18(%rsp)
movl %ecx, %eax
shrl $0x10, %eax
movl %eax, 0x14(%rsp)
movl %ecx, %eax
shrl $0x18, %eax
movl %eax, 0x1c(%rsp)
movl 0xbc0bd(%rip), %edi # 0x1368a0
callq 0x62932
movsd 0xbc0d0(%rip), %xmm0 # 0x1368c0
movaps %xmm0, 0x20(%rsp)
movsd 0xbc0cb(%rip), %xmm0 # 0x1368c8
movaps %xmm0, 0x30(%rsp)
movl $0x7, %edi
callq 0x60fc5
movss 0x59308(%rip), %xmm2 # 0xd3b1c
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x6279a
movl $0xff, %eax
andl %eax, %r13d
andl %eax, %r15d
andl %eax, %r12d
movl %r13d, %edi
movl %r15d, %esi
movl %r12d, %edx
movl 0x60(%rsp), %ecx
callq 0x628b8
xorps %xmm1, %xmm1
cvtsi2ssl 0xbc05a(%rip), %xmm1 # 0x1368a4
movaps 0x20(%rsp), %xmm3
movaps %xmm3, %xmm0
divss %xmm1, %xmm0
xorps %xmm2, %xmm2
cvtsi2ssl 0xbc047(%rip), %xmm2 # 0x1368a8
movaps %xmm3, %xmm1
shufps $0x55, %xmm3, %xmm1 # xmm1 = xmm1[1,1],xmm3[1,1]
movaps %xmm1, 0x60(%rsp)
divss %xmm2, %xmm1
callq 0x62789
movaps 0x70(%rsp), %xmm0
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1 # xmm1 = xmm1[1,1],xmm0[1,1]
movaps %xmm1, 0x80(%rsp)
callq 0x6275f
movl $0xff, %eax
andl %eax, %ebp
andl %eax, %r14d
andl %eax, %ebx
movl %ebp, %edi
movl %r14d, %esi
movl %ebx, %edx
movl 0x50(%rsp), %ecx
callq 0x628b8
xorps %xmm1, %xmm1
cvtsi2ssl 0xbbfee(%rip), %xmm1 # 0x1368a4
movaps 0x20(%rsp), %xmm2
movaps %xmm2, %xmm0
divss %xmm1, %xmm0
movaps 0x30(%rsp), %xmm1
addps %xmm2, %xmm1
movaps %xmm1, 0x30(%rsp)
xorps %xmm2, %xmm2
cvtsi2ssl 0xbbfce(%rip), %xmm2 # 0x1368a8
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
movaps %xmm1, 0x20(%rsp)
divss %xmm2, %xmm1
callq 0x62789
movaps 0x40(%rsp), %xmm1
movaps 0x70(%rsp), %xmm0
addps %xmm0, %xmm1
movaps %xmm1, 0x40(%rsp)
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
movaps %xmm1, 0x50(%rsp)
callq 0x6275f
movl $0xff, %eax
movl (%rsp), %edi
andl %eax, %edi
movl 0x8(%rsp), %esi
andl %eax, %esi
movl 0x4(%rsp), %edx
andl %eax, %edx
movl $0xff, %ebx
movl 0xc(%rsp), %ecx
callq 0x628b8
xorps %xmm1, %xmm1
cvtsi2ssl 0xbbf69(%rip), %xmm1 # 0x1368a4
movaps 0x30(%rsp), %xmm0
divss %xmm1, %xmm0
xorps %xmm2, %xmm2
cvtsi2ssl 0xbbf59(%rip), %xmm2 # 0x1368a8
movaps 0x20(%rsp), %xmm1
divss %xmm2, %xmm1
callq 0x62789
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
callq 0x6275f
movl 0x10(%rsp), %edi
andl %ebx, %edi
movl 0x18(%rsp), %esi
andl %ebx, %esi
movl 0x14(%rsp), %edx
andl %ebx, %edx
movl 0x1c(%rsp), %ecx
callq 0x628b8
xorps %xmm1, %xmm1
cvtsi2ssl 0xbbf12(%rip), %xmm1 # 0x1368a4
movaps 0x30(%rsp), %xmm0
divss %xmm1, %xmm0
xorps %xmm2, %xmm2
cvtsi2ssl 0xbbf02(%rip), %xmm2 # 0x1368a8
movaps 0x60(%rsp), %xmm1
divss %xmm2, %xmm1
callq 0x62789
movaps 0x40(%rsp), %xmm0
movaps 0x80(%rsp), %xmm1
callq 0x6275f
callq 0x623c4
xorl %edi, %edi
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x62932
| DrawRectangleGradientEx:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov ebp, esi
mov r13d, edi
movaps [rsp+0C8h+var_88], xmm1
movaps [rsp+0C8h+var_58], xmm0
mov r15d, edi
shr r15d, 8
mov r12d, edi
shr r12d, 10h
mov eax, edi
shr eax, 18h
mov dword ptr [rsp+0C8h+var_68], eax
mov r14d, esi
shr r14d, 8
mov ebx, esi
shr ebx, 10h
mov eax, esi
shr eax, 18h
mov dword ptr [rsp+0C8h+var_78], eax
mov [rsp+0C8h+var_C8], edx
mov eax, edx
shr eax, 8
mov [rsp+0C8h+var_C0], eax
mov eax, edx
shr eax, 10h
mov [rsp+0C8h+var_C4], eax
mov eax, edx
shr eax, 18h
mov [rsp+0C8h+var_BC], eax
mov [rsp+0C8h+var_B8], ecx
mov eax, ecx
shr eax, 8
mov [rsp+0C8h+var_B0], eax
mov eax, ecx
shr eax, 10h
mov [rsp+0C8h+var_B4], eax
mov eax, ecx
shr eax, 18h
mov [rsp+0C8h+var_AC], eax
mov edi, dword ptr cs:texShapes
call rlSetTexture
movsd xmm0, qword ptr cs:texShapesRec
movaps [rsp+0C8h+var_A8], xmm0
movsd xmm0, qword ptr cs:texShapesRec+8
movaps [rsp+0C8h+var_98], xmm0
mov edi, 7
call rlBegin
movss xmm2, cs:dword_D3B1C
xorps xmm0, xmm0
xorps xmm1, xmm1
call rlNormal3f
mov eax, 0FFh
and r13d, eax
and r15d, eax
and r12d, eax
mov edi, r13d
mov esi, r15d
mov edx, r12d
mov ecx, dword ptr [rsp+0C8h+var_68]
call rlColor4ub
xorps xmm1, xmm1
cvtsi2ss xmm1, dword ptr cs:texShapes+4
movaps xmm3, [rsp+0C8h+var_A8]
movaps xmm0, xmm3
divss xmm0, xmm1
xorps xmm2, xmm2
cvtsi2ss xmm2, dword ptr cs:texShapes+8
movaps xmm1, xmm3
shufps xmm1, xmm3, 55h ; 'U'
movaps [rsp+0C8h+var_68], xmm1
divss xmm1, xmm2
call rlTexCoord2f
movaps xmm0, [rsp+0C8h+var_58]
movaps xmm1, xmm0
shufps xmm1, xmm0, 55h ; 'U'
movaps [rsp+0C8h+var_48], xmm1
call rlVertex2f
mov eax, 0FFh
and ebp, eax
and r14d, eax
and ebx, eax
mov edi, ebp
mov esi, r14d
mov edx, ebx
mov ecx, dword ptr [rsp+0C8h+var_78]
call rlColor4ub
xorps xmm1, xmm1
cvtsi2ss xmm1, dword ptr cs:texShapes+4
movaps xmm2, [rsp+0C8h+var_A8]
movaps xmm0, xmm2
divss xmm0, xmm1
movaps xmm1, [rsp+0C8h+var_98]
addps xmm1, xmm2
movaps [rsp+0C8h+var_98], xmm1
xorps xmm2, xmm2
cvtsi2ss xmm2, dword ptr cs:texShapes+8
shufps xmm1, xmm1, 55h ; 'U'
movaps [rsp+0C8h+var_A8], xmm1
divss xmm1, xmm2
call rlTexCoord2f
movaps xmm1, [rsp+0C8h+var_88]
movaps xmm0, [rsp+0C8h+var_58]
addps xmm1, xmm0
movaps [rsp+0C8h+var_88], xmm1
shufps xmm1, xmm1, 55h ; 'U'
movaps [rsp+0C8h+var_78], xmm1
call rlVertex2f
mov eax, 0FFh
mov edi, [rsp+0C8h+var_C8]
and edi, eax
mov esi, [rsp+0C8h+var_C0]
and esi, eax
mov edx, [rsp+0C8h+var_C4]
and edx, eax
mov ebx, 0FFh
mov ecx, [rsp+0C8h+var_BC]
call rlColor4ub
xorps xmm1, xmm1
cvtsi2ss xmm1, dword ptr cs:texShapes+4
movaps xmm0, [rsp+0C8h+var_98]
divss xmm0, xmm1
xorps xmm2, xmm2
cvtsi2ss xmm2, dword ptr cs:texShapes+8
movaps xmm1, [rsp+0C8h+var_A8]
divss xmm1, xmm2
call rlTexCoord2f
movaps xmm0, [rsp+0C8h+var_88]
movaps xmm1, [rsp+0C8h+var_78]
call rlVertex2f
mov edi, [rsp+0C8h+var_B8]
and edi, ebx
mov esi, [rsp+0C8h+var_B0]
and esi, ebx
mov edx, [rsp+0C8h+var_B4]
and edx, ebx
mov ecx, [rsp+0C8h+var_AC]
call rlColor4ub
xorps xmm1, xmm1
cvtsi2ss xmm1, dword ptr cs:texShapes+4
movaps xmm0, [rsp+0C8h+var_98]
divss xmm0, xmm1
xorps xmm2, xmm2
cvtsi2ss xmm2, dword ptr cs:texShapes+8
movaps xmm1, [rsp+0C8h+var_68]
divss xmm1, xmm2
call rlTexCoord2f
movaps xmm0, [rsp+0C8h+var_88]
movaps xmm1, [rsp+0C8h+var_48]
call rlVertex2f
call rlEnd
xor edi, edi
add rsp, 98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp rlSetTexture
| long long DrawRectangleGradientEx(
int a1,
long long a2,
unsigned int a3,
unsigned int a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
__m128 v12; // xmm3
float v13; // xmm0_4
__m128 v14; // xmm2
double v15; // xmm0_8
double v16; // xmm4_8
double v17; // xmm5_8
char v19; // [rsp+0h] [rbp-C8h]
unsigned int v20; // [rsp+4h] [rbp-C4h]
unsigned int v21; // [rsp+8h] [rbp-C0h]
unsigned int v22; // [rsp+Ch] [rbp-BCh]
char v23; // [rsp+10h] [rbp-B8h]
unsigned int v24; // [rsp+14h] [rbp-B4h]
unsigned int v25; // [rsp+18h] [rbp-B0h]
unsigned int v26; // [rsp+1Ch] [rbp-ACh]
__m128 v27; // [rsp+20h] [rbp-A8h]
__m128 v28; // [rsp+30h] [rbp-98h]
__m128 v29; // [rsp+30h] [rbp-98h]
__m128 v30; // [rsp+40h] [rbp-88h]
__m128 v31; // [rsp+50h] [rbp-78h]
float v32; // [rsp+60h] [rbp-68h]
__m128 v34; // [rsp+80h] [rbp-48h]
v19 = a3;
v21 = a3 >> 8;
v20 = HIWORD(a3);
v22 = HIBYTE(a3);
v23 = a4;
v25 = a4 >> 8;
v24 = HIWORD(a4);
v26 = HIBYTE(a4);
rlSetTexture(texShapes, a2, *(double *)a5.m128_u64, a6, a7, a8, a9, a10, a11, a12);
v27 = (__m128)(unsigned long long)texShapesRec;
v28 = (__m128)*((unsigned long long *)&texShapesRec + 1);
rlBegin(7);
rlNormal3f((__m128)0LL, (__m128)0LL, (__m128)0x3F800000u);
rlColor4ub(a1, SBYTE1(a1), SBYTE2(a1), SHIBYTE(a1));
v12 = v27;
v32 = _mm_shuffle_ps(v27, v27, 85).m128_f32[0];
rlTexCoord2f(v27.m128_f32[0] / (float)SDWORD1(texShapes), v32 / (float)SDWORD2(texShapes));
v34 = _mm_shuffle_ps(a5, a5, 85);
rlVertex2f(a5, v34);
rlColor4ub(a2, SBYTE1(a2), SBYTE2(a2), SBYTE3(a2));
v13 = v27.m128_f32[0] / (float)SDWORD1(texShapes);
v29 = _mm_add_ps(v28, v27);
v27.m128_f32[0] = _mm_shuffle_ps(v29, v29, 85).m128_f32[0];
rlTexCoord2f(v13, v27.m128_f32[0] / (float)SDWORD2(texShapes));
v30 = _mm_add_ps(a6, a5);
v31 = _mm_shuffle_ps(v30, v30, 85);
rlVertex2f(a5, v31);
rlColor4ub(v19, v21, v20, v22);
rlTexCoord2f(v29.m128_f32[0] / (float)SDWORD1(texShapes), v27.m128_f32[0] / (float)SDWORD2(texShapes));
rlVertex2f(v30, v31);
rlColor4ub(v23, v25, v24, v26);
v14 = 0LL;
v14.m128_f32[0] = (float)SDWORD2(texShapes);
rlTexCoord2f(v29.m128_f32[0] / (float)SDWORD1(texShapes), v32 / (float)SDWORD2(texShapes));
rlVertex2f(v30, v34);
v15 = rlEnd(*(double *)v30.m128_u64, *(double *)v34.m128_u64);
return rlSetTexture(0, (unsigned __int8)v25, v15, v34, v14, v12, v16, v17, a11, a12);
}
| DrawRectangleGradientEx:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV EBP,ESI
MOV R13D,EDI
MOVAPS xmmword ptr [RSP + 0x40],XMM1
MOVAPS xmmword ptr [RSP + 0x70],XMM0
MOV R15D,EDI
SHR R15D,0x8
MOV R12D,EDI
SHR R12D,0x10
MOV EAX,EDI
SHR EAX,0x18
MOV dword ptr [RSP + 0x60],EAX
MOV R14D,ESI
SHR R14D,0x8
MOV EBX,ESI
SHR EBX,0x10
MOV EAX,ESI
SHR EAX,0x18
MOV dword ptr [RSP + 0x50],EAX
MOV dword ptr [RSP],EDX
MOV EAX,EDX
SHR EAX,0x8
MOV dword ptr [RSP + 0x8],EAX
MOV EAX,EDX
SHR EAX,0x10
MOV dword ptr [RSP + 0x4],EAX
MOV EAX,EDX
SHR EAX,0x18
MOV dword ptr [RSP + 0xc],EAX
MOV dword ptr [RSP + 0x10],ECX
MOV EAX,ECX
SHR EAX,0x8
MOV dword ptr [RSP + 0x18],EAX
MOV EAX,ECX
SHR EAX,0x10
MOV dword ptr [RSP + 0x14],EAX
MOV EAX,ECX
SHR EAX,0x18
MOV dword ptr [RSP + 0x1c],EAX
MOV EDI,dword ptr [0x002368a0]
CALL 0x00162932
MOVSD XMM0,qword ptr [0x002368c0]
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVSD XMM0,qword ptr [0x002368c8]
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOV EDI,0x7
CALL 0x00160fc5
MOVSS XMM2,dword ptr [0x001d3b1c]
XORPS XMM0,XMM0
XORPS XMM1,XMM1
CALL 0x0016279a
MOV EAX,0xff
AND R13D,EAX
AND R15D,EAX
AND R12D,EAX
MOV EDI,R13D
MOV ESI,R15D
MOV EDX,R12D
MOV ECX,dword ptr [RSP + 0x60]
CALL 0x001628b8
XORPS XMM1,XMM1
CVTSI2SS XMM1,dword ptr [0x002368a4]
MOVAPS XMM3,xmmword ptr [RSP + 0x20]
MOVAPS XMM0,XMM3
DIVSS XMM0,XMM1
XORPS XMM2,XMM2
CVTSI2SS XMM2,dword ptr [0x002368a8]
MOVAPS XMM1,XMM3
SHUFPS XMM1,XMM3,0x55
MOVAPS xmmword ptr [RSP + 0x60],XMM1
DIVSS XMM1,XMM2
CALL 0x00162789
MOVAPS XMM0,xmmword ptr [RSP + 0x70]
MOVAPS XMM1,XMM0
SHUFPS XMM1,XMM0,0x55
MOVAPS xmmword ptr [RSP + 0x80],XMM1
CALL 0x0016275f
MOV EAX,0xff
AND EBP,EAX
AND R14D,EAX
AND EBX,EAX
MOV EDI,EBP
MOV ESI,R14D
MOV EDX,EBX
MOV ECX,dword ptr [RSP + 0x50]
CALL 0x001628b8
XORPS XMM1,XMM1
CVTSI2SS XMM1,dword ptr [0x002368a4]
MOVAPS XMM2,xmmword ptr [RSP + 0x20]
MOVAPS XMM0,XMM2
DIVSS XMM0,XMM1
MOVAPS XMM1,xmmword ptr [RSP + 0x30]
ADDPS XMM1,XMM2
MOVAPS xmmword ptr [RSP + 0x30],XMM1
XORPS XMM2,XMM2
CVTSI2SS XMM2,dword ptr [0x002368a8]
SHUFPS XMM1,XMM1,0x55
MOVAPS xmmword ptr [RSP + 0x20],XMM1
DIVSS XMM1,XMM2
CALL 0x00162789
MOVAPS XMM1,xmmword ptr [RSP + 0x40]
MOVAPS XMM0,xmmword ptr [RSP + 0x70]
ADDPS XMM1,XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM1
SHUFPS XMM1,XMM1,0x55
MOVAPS xmmword ptr [RSP + 0x50],XMM1
CALL 0x0016275f
MOV EAX,0xff
MOV EDI,dword ptr [RSP]
AND EDI,EAX
MOV ESI,dword ptr [RSP + 0x8]
AND ESI,EAX
MOV EDX,dword ptr [RSP + 0x4]
AND EDX,EAX
MOV EBX,0xff
MOV ECX,dword ptr [RSP + 0xc]
CALL 0x001628b8
XORPS XMM1,XMM1
CVTSI2SS XMM1,dword ptr [0x002368a4]
MOVAPS XMM0,xmmword ptr [RSP + 0x30]
DIVSS XMM0,XMM1
XORPS XMM2,XMM2
CVTSI2SS XMM2,dword ptr [0x002368a8]
MOVAPS XMM1,xmmword ptr [RSP + 0x20]
DIVSS XMM1,XMM2
CALL 0x00162789
MOVAPS XMM0,xmmword ptr [RSP + 0x40]
MOVAPS XMM1,xmmword ptr [RSP + 0x50]
CALL 0x0016275f
MOV EDI,dword ptr [RSP + 0x10]
AND EDI,EBX
MOV ESI,dword ptr [RSP + 0x18]
AND ESI,EBX
MOV EDX,dword ptr [RSP + 0x14]
AND EDX,EBX
MOV ECX,dword ptr [RSP + 0x1c]
CALL 0x001628b8
XORPS XMM1,XMM1
CVTSI2SS XMM1,dword ptr [0x002368a4]
MOVAPS XMM0,xmmword ptr [RSP + 0x30]
DIVSS XMM0,XMM1
XORPS XMM2,XMM2
CVTSI2SS XMM2,dword ptr [0x002368a8]
MOVAPS XMM1,xmmword ptr [RSP + 0x60]
DIVSS XMM1,XMM2
CALL 0x00162789
MOVAPS XMM0,xmmword ptr [RSP + 0x40]
MOVAPS XMM1,xmmword ptr [RSP + 0x80]
CALL 0x0016275f
CALL 0x001623c4
XOR EDI,EDI
ADD RSP,0x98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00162932
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void DrawRectangleGradientEx
(int8 param_1,int8 param_2,uint param_3,int8 param_4,
int8 param_5,int8 param_6)
{
int8 uVar1;
int8 uVar2;
float fVar3;
float fVar4;
int4 local_a8;
int4 uStack_a4;
int4 local_98;
int4 uStack_94;
fVar3 = (float)((ulong)param_1 >> 0x20);
rlSetTexture(texShapes);
uVar2 = DAT_002368c8;
uVar1 = texShapesRec;
rlBegin(7);
rlNormal3f(0,0,DAT_001d3b1c);
rlColor4ub(param_3 & 0xff,param_3 >> 8 & 0xff,param_3 >> 0x10 & 0xff,param_3 >> 0x18);
local_a8 = (float)uVar1;
uStack_a4 = (float)((ulong)uVar1 >> 0x20);
rlTexCoord2f(local_a8 / (float)_DAT_002368a4,uStack_a4 / (float)_DAT_002368a8);
rlVertex2f();
rlColor4ub((uint)param_4 & 0xff,(uint)((ulong)param_4 >> 8) & 0xff,
(uint)((ulong)param_4 >> 0x10) & 0xff,(uint)((ulong)param_4 >> 0x18) & 0xff);
local_98 = (float)uVar2;
uStack_94 = (float)((ulong)uVar2 >> 0x20);
rlTexCoord2f(local_a8 / (float)_DAT_002368a4,(uStack_94 + uStack_a4) / (float)_DAT_002368a8);
fVar4 = (float)param_2 + (float)param_1;
rlVertex2f();
rlColor4ub((uint)param_5 & 0xff,(uint)((ulong)param_5 >> 8) & 0xff,
(uint)((ulong)param_5 >> 0x10) & 0xff,(uint)((ulong)param_5 >> 0x18) & 0xff);
rlTexCoord2f((local_98 + local_a8) / (float)_DAT_002368a4,
(uStack_94 + uStack_a4) / (float)_DAT_002368a8);
rlVertex2f(fVar4,(float)((ulong)param_2 >> 0x20) + fVar3);
rlColor4ub((uint)param_6 & 0xff,(uint)((ulong)param_6 >> 8) & 0xff,
(uint)((ulong)param_6 >> 0x10) & 0xff,(uint)((ulong)param_6 >> 0x18) & 0xff);
rlTexCoord2f((local_98 + local_a8) / (float)_DAT_002368a4,uStack_a4 / (float)_DAT_002368a8);
rlVertex2f(fVar4,fVar3);
rlEnd();
rlSetTexture(0);
return;
}
| |
41,616 | remove_pin | eloqsql/storage/maria/ma_pagecache.c | static void remove_pin(PAGECACHE_BLOCK_LINK *block, my_bool any
#ifdef DBUG_OFF
__attribute__((unused))
#endif
)
{
DBUG_ENTER("remove_pin");
DBUG_PRINT("enter", ("block: %p pins: %u any: %d", block, block->pins,
(int)any));
PCBLOCK_INFO(block);
DBUG_ASSERT(block->pins > 0);
block->pins--;
#ifndef DBUG_OFF
{
PAGECACHE_PIN_INFO *info= info_find(block->pin_list, my_thread_var, any);
DBUG_ASSERT(info != 0);
info_unlink(info);
my_free(info);
}
#endif
DBUG_VOID_RETURN;
} | O0 | c | remove_pin:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
jmp 0x5df80
jmp 0x5df82
jmp 0x5df84
jmp 0x5df86
jmp 0x5df88
movq -0x8(%rbp), %rax
movl 0x64(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x64(%rax)
jmp 0x5df97
popq %rbp
retq
nopl (%rax)
| remove_pin:
push rbp
mov rbp, rsp
mov al, sil
mov [rbp+var_8], rdi
mov [rbp+var_9], al
jmp short $+2
loc_5DF80:
jmp short $+2
loc_5DF82:
jmp short $+2
loc_5DF84:
jmp short $+2
loc_5DF86:
jmp short $+2
loc_5DF88:
mov rax, [rbp+var_8]
mov ecx, [rax+64h]
add ecx, 0FFFFFFFFh
mov [rax+64h], ecx
jmp short $+2
loc_5DF97:
pop rbp
retn
| long long remove_pin(long long a1)
{
long long result; // rax
result = a1;
--*(_DWORD *)(a1 + 100);
return result;
}
| remove_pin:
PUSH RBP
MOV RBP,RSP
MOV AL,SIL
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],AL
JMP 0x0015df80
LAB_0015df80:
JMP 0x0015df82
LAB_0015df82:
JMP 0x0015df84
LAB_0015df84:
JMP 0x0015df86
LAB_0015df86:
JMP 0x0015df88
LAB_0015df88:
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x64]
ADD ECX,-0x1
MOV dword ptr [RAX + 0x64],ECX
JMP 0x0015df97
LAB_0015df97:
POP RBP
RET
|
void remove_pin(long param_1)
{
*(int *)(param_1 + 100) = *(int *)(param_1 + 100) + -1;
return;
}
| |
41,617 | js_c_function_data_call | bluesky950520[P]quickjs/quickjs.c | static JSValue js_c_function_data_call(JSContext *ctx, JSValue func_obj,
JSValue this_val,
int argc, JSValue *argv, int flags)
{
JSCFunctionDataRecord *s = JS_GetOpaque(func_obj, JS_CLASS_C_FUNCTION_DATA);
JSValue *arg_buf;
int i;
/* XXX: could add the function on the stack for debug */
if (unlikely(argc < s->length)) {
arg_buf = alloca(sizeof(arg_buf[0]) * s->length);
for(i = 0; i < argc; i++)
arg_buf[i] = argv[i];
for(i = argc; i < s->length; i++)
arg_buf[i] = JS_UNDEFINED;
} else {
arg_buf = argv;
}
return s->func(ctx, this_val, argc, arg_buf, s->magic, s->data);
} | O0 | c | js_c_function_data_call:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rsi, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x28(%rbp)
movq %rdi, -0x38(%rbp)
movl %r9d, -0x3c(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0xf, %edx
callq 0x38350
movq %rax, -0x48(%rbp)
movl -0x3c(%rbp), %eax
movq -0x48(%rbp), %rcx
movzbl 0x8(%rcx), %ecx
cmpl %ecx, %eax
setl %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x22f01
movq -0x48(%rbp), %rax
movzbl 0x8(%rax), %eax
shll $0x4, %eax
movl %eax, %ecx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jge 0x22eb2
movq -0x50(%rbp), %rax
movslq -0x54(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x10(%rbp), %rcx
movslq -0x54(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x22e73
movl -0x3c(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
movq -0x48(%rbp), %rcx
movzbl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0x22eff
movq -0x50(%rbp), %rax
movslq -0x54(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, -0x68(%rbp)
movq $0x3, -0x60(%rbp)
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
movq -0x60(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x22eb8
jmp 0x22f09
movq 0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %r11
movq (%r11), %rax
movq -0x38(%rbp), %rdi
movl -0x3c(%rbp), %ecx
movq -0x50(%rbp), %r8
movzwl 0xa(%r11), %r9d
addq $0x10, %r11
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
subq $0x10, %rsp
movq %rsp, %r10
movq %r11, (%r10)
callq *%rax
addq $0x10, %rsp
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| js_c_function_data_call:
push rbp
mov rbp, rsp
sub rsp, 70h
mov eax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov [rbp+var_20], rsi
mov [rbp+var_18], rdx
mov [rbp+var_30], rcx
mov [rbp+var_28], r8
mov [rbp+var_38], rdi
mov [rbp+var_3C], r9d
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_18]
mov edx, 0Fh
call JS_GetOpaque
mov [rbp+var_48], rax
mov eax, [rbp+var_3C]
mov rcx, [rbp+var_48]
movzx ecx, byte ptr [rcx+8]
cmp eax, ecx
setl al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz loc_22F01
mov rax, [rbp+var_48]
movzx eax, byte ptr [rax+8]
shl eax, 4
mov ecx, eax
mov rax, rsp
sub rax, rcx
mov rsp, rax
mov [rbp+var_50], rax
mov [rbp+var_54], 0
loc_22E73:
mov eax, [rbp+var_54]
cmp eax, [rbp+var_3C]
jge short loc_22EB2
mov rax, [rbp+var_50]
movsxd rcx, [rbp+var_54]
shl rcx, 4
add rax, rcx
mov rcx, [rbp+arg_0]
movsxd rdx, [rbp+var_54]
shl rdx, 4
add rcx, rdx
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov eax, [rbp+var_54]
add eax, 1
mov [rbp+var_54], eax
jmp short loc_22E73
loc_22EB2:
mov eax, [rbp+var_3C]
mov [rbp+var_54], eax
loc_22EB8:
mov eax, [rbp+var_54]
mov rcx, [rbp+var_48]
movzx ecx, byte ptr [rcx+8]
cmp eax, ecx
jge short loc_22EFF
mov rax, [rbp+var_50]
movsxd rcx, [rbp+var_54]
shl rcx, 4
add rax, rcx
mov dword ptr [rbp+var_68], 0
mov [rbp+var_60], 3
mov rcx, [rbp+var_68]
mov [rax], rcx
mov rcx, [rbp+var_60]
mov [rax+8], rcx
mov eax, [rbp+var_54]
add eax, 1
mov [rbp+var_54], eax
jmp short loc_22EB8
loc_22EFF:
jmp short loc_22F09
loc_22F01:
mov rax, [rbp+arg_0]
mov [rbp+var_50], rax
loc_22F09:
mov r11, [rbp+var_48]
mov rax, [r11]
mov rdi, [rbp+var_38]
mov ecx, [rbp+var_3C]
mov r8, [rbp+var_50]
movzx r9d, word ptr [r11+0Ah]
add r11, 10h
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_28]
sub rsp, 10h
mov r10, rsp
mov [r10], r11
call rax
add rsp, 10h
mov [rbp+var_10], rax
mov [rbp+var_8], rdx
mov rax, [rbp+var_10]
mov rdx, [rbp+var_8]
mov rsp, rbp
pop rbp
retn
| long long js_c_function_data_call(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
int a6,
long long *a7)
{
long long *v7; // rax
long long *v8; // rcx
long long *v9; // rax
long long v11; // [rsp+0h] [rbp-70h] BYREF
long long v12; // [rsp+8h] [rbp-68h]
long long v13; // [rsp+10h] [rbp-60h]
int i; // [rsp+1Ch] [rbp-54h]
long long *v15; // [rsp+20h] [rbp-50h]
long long Opaque; // [rsp+28h] [rbp-48h]
int v17; // [rsp+34h] [rbp-3Ch]
long long v18; // [rsp+38h] [rbp-38h]
long long v19; // [rsp+40h] [rbp-30h]
long long v20; // [rsp+48h] [rbp-28h]
long long v21; // [rsp+50h] [rbp-20h]
long long v22; // [rsp+58h] [rbp-18h]
v21 = a2;
v22 = a3;
v19 = a4;
v20 = a5;
v18 = a1;
v17 = a6;
Opaque = JS_GetOpaque(a2, a3, 15LL);
if ( v17 >= *(unsigned __int8 *)(Opaque + 8) )
{
v15 = a7;
}
else
{
v15 = &v11 - 2 * (unsigned int)*(unsigned __int8 *)(Opaque + 8);
for ( i = 0; i < v17; ++i )
{
v7 = &v15[2 * i];
v8 = &a7[2 * i];
*v7 = *v8;
v7[1] = v8[1];
}
for ( i = v17; i < *(unsigned __int8 *)(Opaque + 8); ++i )
{
v9 = &v15[2 * i];
LODWORD(v12) = 0;
v13 = 3LL;
*v9 = v12;
v9[1] = v13;
}
}
return (*(long long ( **)(long long, long long, long long, _QWORD, long long *, _QWORD, long long))Opaque)(
v18,
v19,
v20,
(unsigned int)v17,
v15,
*(unsigned __int16 *)(Opaque + 10),
Opaque + 16);
}
| js_c_function_data_call:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV EAX,dword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x30],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],R9D
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,0xf
CALL 0x00138350
MOV qword ptr [RBP + -0x48],RAX
MOV EAX,dword ptr [RBP + -0x3c]
MOV RCX,qword ptr [RBP + -0x48]
MOVZX ECX,byte ptr [RCX + 0x8]
CMP EAX,ECX
SETL AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x00122f01
MOV RAX,qword ptr [RBP + -0x48]
MOVZX EAX,byte ptr [RAX + 0x8]
SHL EAX,0x4
MOV ECX,EAX
MOV RAX,RSP
SUB RAX,RCX
MOV RSP,RAX
MOV qword ptr [RBP + -0x50],RAX
MOV dword ptr [RBP + -0x54],0x0
LAB_00122e73:
MOV EAX,dword ptr [RBP + -0x54]
CMP EAX,dword ptr [RBP + -0x3c]
JGE 0x00122eb2
MOV RAX,qword ptr [RBP + -0x50]
MOVSXD RCX,dword ptr [RBP + -0x54]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RBP + 0x10]
MOVSXD RDX,dword ptr [RBP + -0x54]
SHL RDX,0x4
ADD RCX,RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV EAX,dword ptr [RBP + -0x54]
ADD EAX,0x1
MOV dword ptr [RBP + -0x54],EAX
JMP 0x00122e73
LAB_00122eb2:
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x54],EAX
LAB_00122eb8:
MOV EAX,dword ptr [RBP + -0x54]
MOV RCX,qword ptr [RBP + -0x48]
MOVZX ECX,byte ptr [RCX + 0x8]
CMP EAX,ECX
JGE 0x00122eff
MOV RAX,qword ptr [RBP + -0x50]
MOVSXD RCX,dword ptr [RBP + -0x54]
SHL RCX,0x4
ADD RAX,RCX
MOV dword ptr [RBP + -0x68],0x0
MOV qword ptr [RBP + -0x60],0x3
MOV RCX,qword ptr [RBP + -0x68]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x60]
MOV qword ptr [RAX + 0x8],RCX
MOV EAX,dword ptr [RBP + -0x54]
ADD EAX,0x1
MOV dword ptr [RBP + -0x54],EAX
JMP 0x00122eb8
LAB_00122eff:
JMP 0x00122f09
LAB_00122f01:
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x50],RAX
LAB_00122f09:
MOV R11,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [R11]
MOV RDI,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x3c]
MOV R8,qword ptr [RBP + -0x50]
MOVZX R9D,word ptr [R11 + 0xa]
ADD R11,0x10
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x28]
SUB RSP,0x10
MOV R10,RSP
MOV qword ptr [R10],R11
CALL RAX
ADD RSP,0x10
MOV qword ptr [RBP + -0x10],RAX
MOV qword ptr [RBP + -0x8],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
MOV RSP,RBP
POP RBP
RET
|
int1 [16]
js_c_function_data_call
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int param_6,long *param_7)
{
int2 uVar1;
code *pcVar2;
int1 auVar3 [16];
long *plVar4;
int iVar5;
int8 uVar6;
int8 uVar7;
int8 uVar8;
long *plVar9;
long lStack_78;
int4 local_70;
uint uStack_6c;
int8 local_68;
int local_5c;
long *local_58;
int8 *local_50;
int local_44;
int8 local_40;
int8 local_38;
int8 local_30;
int8 local_28;
int8 local_20;
plVar9 = &lStack_78;
local_44 = param_6;
local_40 = param_1;
local_38 = param_4;
local_30 = param_5;
local_28 = param_2;
local_20 = param_3;
local_50 = (int8 *)JS_GetOpaque(param_2,param_3,0xf);
uVar8 = local_30;
uVar7 = local_38;
uVar6 = local_40;
iVar5 = local_44;
if (local_44 < (int)(uint)*(byte *)(local_50 + 1)) {
plVar9 = &lStack_78 + (ulong)*(byte *)(local_50 + 1) * -2;
for (local_5c = 0; local_5c < local_44; local_5c = local_5c + 1) {
plVar9[(long)local_5c * 2] = param_7[(long)local_5c * 2];
(plVar9 + (long)local_5c * 2)[1] = (param_7 + (long)local_5c * 2)[1];
}
for (local_5c = local_44; local_58 = plVar9, local_5c < (int)(uint)*(byte *)(local_50 + 1);
local_5c = local_5c + 1) {
local_70 = 0;
local_68 = 3;
plVar9[(long)local_5c * 2] = (ulong)uStack_6c << 0x20;
(plVar9 + (long)local_5c * 2)[1] = 3;
}
}
else {
local_58 = param_7;
}
plVar4 = local_58;
pcVar2 = (code *)*local_50;
uVar1 = *(int2 *)((long)local_50 + 10);
plVar9[-2] = (long)(local_50 + 2);
plVar9[-3] = 0x122f38;
auVar3 = (*pcVar2)(uVar6,uVar7,uVar8,iVar5,plVar4,uVar1);
return auVar3;
}
| |
41,618 | my_numcells_eucjpms | eloqsql/strings/ctype-eucjpms.c | static
size_t my_numcells_eucjpms(CHARSET_INFO *cs __attribute__((unused)),
const char *str, const char *str_end)
{
size_t clen;
const uchar *b= (const uchar *) str;
const uchar *e= (const uchar *) str_end;
for (clen= 0; b < e; )
{
if (*b == 0x8E)
{
clen++;
b+= 2;
}
else if (*b == 0x8F)
{
clen+= 2;
b+= 3;
}
else if (*b & 0x80)
{
clen+= 2;
b+= 2;
}
else
{
clen++;
b++;
}
}
return clen;
} | O3 | c | my_numcells_eucjpms:
cmpq %rdx, %rsi
jae 0xb42d9
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movzbl (%rsi), %edi
cmpl $0x8e, %edi
je 0xb42b2
cmpl $0x8f, %edi
jne 0xb42be
movl $0x3, %edi
movl $0x2, %ecx
jmp 0xb42cc
movl $0x2, %edi
movl $0x1, %ecx
jmp 0xb42cc
xorl %ecx, %ecx
testb %dil, %dil
sets %cl
incq %rcx
movq %rcx, %rdi
addq %rcx, %rax
addq %rdi, %rsi
cmpq %rdx, %rsi
jb 0xb4293
popq %rbp
retq
xorl %eax, %eax
retq
| my_numcells_eucjpms:
cmp rsi, rdx
jnb short loc_B42D9
push rbp
mov rbp, rsp
xor eax, eax
loc_B4293:
movzx edi, byte ptr [rsi]
cmp edi, 8Eh
jz short loc_B42B2
cmp edi, 8Fh
jnz short loc_B42BE
mov edi, 3
mov ecx, 2
jmp short loc_B42CC
loc_B42B2:
mov edi, 2
mov ecx, 1
jmp short loc_B42CC
loc_B42BE:
xor ecx, ecx
test dil, dil
sets cl
inc rcx
mov rdi, rcx
loc_B42CC:
add rax, rcx
add rsi, rdi
cmp rsi, rdx
jb short loc_B4293
pop rbp
retn
loc_B42D9:
xor eax, eax
retn
| long long my_numcells_eucjpms(long long a1, unsigned __int8 *a2, unsigned long long a3)
{
long long result; // rax
int v4; // edi
long long v5; // rdi
long long v6; // rcx
if ( (unsigned long long)a2 >= a3 )
return 0LL;
result = 0LL;
do
{
v4 = *a2;
if ( v4 == 142 )
{
v5 = 2LL;
v6 = 1LL;
}
else if ( v4 == 143 )
{
v5 = 3LL;
v6 = 2LL;
}
else
{
v6 = ((v4 & 0x80u) != 0) + 1LL;
v5 = v6;
}
result += v6;
a2 += v5;
}
while ( (unsigned long long)a2 < a3 );
return result;
}
| my_numcells_eucjpms:
CMP RSI,RDX
JNC 0x001b42d9
PUSH RBP
MOV RBP,RSP
XOR EAX,EAX
LAB_001b4293:
MOVZX EDI,byte ptr [RSI]
CMP EDI,0x8e
JZ 0x001b42b2
CMP EDI,0x8f
JNZ 0x001b42be
MOV EDI,0x3
MOV ECX,0x2
JMP 0x001b42cc
LAB_001b42b2:
MOV EDI,0x2
MOV ECX,0x1
JMP 0x001b42cc
LAB_001b42be:
XOR ECX,ECX
TEST DIL,DIL
SETS CL
INC RCX
MOV RDI,RCX
LAB_001b42cc:
ADD RAX,RCX
ADD RSI,RDI
CMP RSI,RDX
JC 0x001b4293
POP RBP
RET
LAB_001b42d9:
XOR EAX,EAX
RET
|
long my_numcells_eucjpms(int8 param_1,char *param_2,char *param_3)
{
char cVar1;
long lVar2;
long lVar3;
long lVar4;
if (param_2 < param_3) {
lVar2 = 0;
do {
cVar1 = *param_2;
if (cVar1 == -0x72) {
lVar4 = 2;
lVar3 = 1;
}
else if (cVar1 == -0x71) {
lVar3 = 2;
lVar4 = 3;
}
else {
lVar3 = (ulong)(cVar1 < '\0') + 1;
lVar4 = lVar3;
}
lVar2 = lVar2 + lVar3;
param_2 = param_2 + lVar4;
} while (param_2 < param_3);
return lVar2;
}
return 0;
}
| |
41,619 | composition_destination_atop | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-blend.c | static void composition_destination_atop(uint32_t* dest, int length, const uint32_t* src, uint32_t const_alpha)
{
if(const_alpha == 255) {
for(int i = 0; i < length; i++) {
uint32_t s = src[i];
uint32_t d = dest[i];
dest[i] = INTERPOLATE_PIXEL(d, plutovg_alpha(s), s, plutovg_alpha(~d));
}
} else {
uint32_t cia = 255 - const_alpha;
for(int i = 0; i < length; i++) {
uint32_t s = BYTE_MUL(src[i], const_alpha);
uint32_t d = dest[i];
uint32_t a = plutovg_alpha(s) + cia;
dest[i] = INTERPOLATE_PIXEL(d, a, s, plutovg_alpha(~d));
}
}
} | O1 | c | composition_destination_atop:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
cmpl $0xff, %ecx
jne 0x21f6d
testl %esi, %esi
jle 0x22046
movl %esi, %eax
xorl %ecx, %ecx
movl $0xff00ff, %esi # imm = 0xFF00FF
movl $0x800080, %r8d # imm = 0x800080
movl (%rdx,%rcx,4), %r9d
movl (%rdi,%rcx,4), %r11d
movl %r9d, %ebp
shrl $0x18, %ebp
movl %r11d, %ebx
notl %ebx
shrl $0x18, %ebx
movl %r11d, %r14d
andl %esi, %r14d
imull %ebp, %r14d
movl %r9d, %r10d
andl %esi, %r10d
imull %ebx, %r10d
addl %r14d, %r10d
movl %r10d, %r14d
shrl $0x8, %r14d
andl %esi, %r14d
addl %r8d, %r10d
addl %r14d, %r10d
shrl $0x8, %r10d
andl %esi, %r10d
shrl $0x8, %r11d
andl %esi, %r11d
imull %ebp, %r11d
shrl $0x8, %r9d
andl %esi, %r9d
imull %ebx, %r9d
addl %r11d, %r9d
movl %r9d, %r11d
shrl $0x8, %r11d
andl %esi, %r11d
addl %r8d, %r9d
addl %r11d, %r9d
andl $0xff00ff00, %r9d # imm = 0xFF00FF00
orl %r10d, %r9d
movl %r9d, (%rdi,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x21ee1
jmp 0x22046
testl %esi, %esi
jle 0x22046
movl %esi, %eax
xorl %esi, %esi
movl $0xff00ff, %r8d # imm = 0xFF00FF
movl $0x800080, %r9d # imm = 0x800080
movl (%rdx,%rsi,4), %r10d
movl %r10d, %r11d
andl %r8d, %r11d
imull %ecx, %r11d
movl %r11d, %ebx
shrl $0x8, %ebx
andl %r8d, %ebx
addl %r9d, %r11d
addl %ebx, %r11d
shrl $0x8, %r11d
andl %r8d, %r11d
shrl $0x8, %r10d
andl %r8d, %r10d
imull %ecx, %r10d
movl %r10d, %ebx
shrl $0x8, %ebx
andl %r8d, %ebx
addl %r9d, %r10d
addl %ebx, %r10d
movl (%rdi,%rsi,4), %ebx
movl %r10d, %ebp
shrl $0x18, %ebp
subl %ecx, %ebp
addl $0xff, %ebp
movl %ebx, %r14d
notl %r14d
shrl $0x18, %r14d
movl %ebx, %r15d
andl %r8d, %r15d
imull %ebp, %r15d
imull %r14d, %r11d
addl %r15d, %r11d
movl %r11d, %r15d
shrl $0x8, %r15d
andl %r8d, %r15d
addl %r9d, %r11d
addl %r15d, %r11d
shrl $0x8, %r11d
andl %r8d, %r11d
shrl $0x8, %ebx
andl %r8d, %ebx
imull %ebp, %ebx
shrl $0x8, %r10d
andl %r8d, %r10d
imull %r14d, %r10d
addl %ebx, %r10d
movl %r10d, %ebx
shrl $0x8, %ebx
andl %r8d, %ebx
addl %r9d, %r10d
addl %ebx, %r10d
andl $0xff00ff00, %r10d # imm = 0xFF00FF00
orl %r11d, %r10d
movl %r10d, (%rdi,%rsi,4)
incq %rsi
cmpq %rsi, %rax
jne 0x21f85
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| composition_destination_atop:
push rbp
push r15
push r14
push rbx
cmp ecx, 0FFh
jnz loc_21F6D
test esi, esi
jle loc_22046
mov eax, esi
xor ecx, ecx
mov esi, 0FF00FFh
mov r8d, 800080h
loc_21EE1:
mov r9d, [rdx+rcx*4]
mov r11d, [rdi+rcx*4]
mov ebp, r9d
shr ebp, 18h
mov ebx, r11d
not ebx
shr ebx, 18h
mov r14d, r11d
and r14d, esi
imul r14d, ebp
mov r10d, r9d
and r10d, esi
imul r10d, ebx
add r10d, r14d
mov r14d, r10d
shr r14d, 8
and r14d, esi
add r10d, r8d
add r10d, r14d
shr r10d, 8
and r10d, esi
shr r11d, 8
and r11d, esi
imul r11d, ebp
shr r9d, 8
and r9d, esi
imul r9d, ebx
add r9d, r11d
mov r11d, r9d
shr r11d, 8
and r11d, esi
add r9d, r8d
add r9d, r11d
and r9d, 0FF00FF00h
or r9d, r10d
mov [rdi+rcx*4], r9d
inc rcx
cmp rax, rcx
jnz loc_21EE1
jmp loc_22046
loc_21F6D:
test esi, esi
jle loc_22046
mov eax, esi
xor esi, esi
mov r8d, 0FF00FFh
mov r9d, 800080h
loc_21F85:
mov r10d, [rdx+rsi*4]
mov r11d, r10d
and r11d, r8d
imul r11d, ecx
mov ebx, r11d
shr ebx, 8
and ebx, r8d
add r11d, r9d
add r11d, ebx
shr r11d, 8
and r11d, r8d
shr r10d, 8
and r10d, r8d
imul r10d, ecx
mov ebx, r10d
shr ebx, 8
and ebx, r8d
add r10d, r9d
add r10d, ebx
mov ebx, [rdi+rsi*4]
mov ebp, r10d
shr ebp, 18h
sub ebp, ecx
add ebp, 0FFh
mov r14d, ebx
not r14d
shr r14d, 18h
mov r15d, ebx
and r15d, r8d
imul r15d, ebp
imul r11d, r14d
add r11d, r15d
mov r15d, r11d
shr r15d, 8
and r15d, r8d
add r11d, r9d
add r11d, r15d
shr r11d, 8
and r11d, r8d
shr ebx, 8
and ebx, r8d
imul ebx, ebp
shr r10d, 8
and r10d, r8d
imul r10d, r14d
add r10d, ebx
mov ebx, r10d
shr ebx, 8
and ebx, r8d
add r10d, r9d
add r10d, ebx
and r10d, 0FF00FF00h
or r10d, r11d
mov [rdi+rsi*4], r10d
inc rsi
cmp rax, rsi
jnz loc_21F85
loc_22046:
pop rbx
pop r14
pop r15
pop rbp
retn
| void composition_destination_atop(long long a1, int a2, long long a3, int a4)
{
long long i; // rcx
int v5; // ebp
unsigned int v6; // ebx
long long v7; // rax
long long j; // rsi
unsigned int v9; // ebp
unsigned int v10; // r14d
if ( a4 == 255 )
{
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
{
v5 = HIBYTE(*(_DWORD *)(a3 + 4 * i));
v6 = (unsigned int)~*(_DWORD *)(a1 + 4 * i) >> 24;
*(_DWORD *)(a1 + 4 * i) = (((((v5 * (*(_DWORD *)(a1 + 4 * i) & 0xFF00FF)
+ v6 * (*(_DWORD *)(a3 + 4 * i) & 0xFF00FF)) >> 8) & 0xFF00FF)
+ v5 * (*(_DWORD *)(a1 + 4 * i) & 0xFF00FF)
+ v6 * (*(_DWORD *)(a3 + 4 * i) & 0xFF00FF)
+ 8388736) >> 8) & 0xFF00FF | ((((v5 * ((*(_DWORD *)(a1 + 4 * i) >> 8) & 0xFF00FF)
+ v6 * ((*(_DWORD *)(a3 + 4 * i) >> 8) & 0xFF00FF)) >> 8) & 0xFF00FF)
+ v5 * ((*(_DWORD *)(a1 + 4 * i) >> 8) & 0xFF00FF)
+ v6 * ((*(_DWORD *)(a3 + 4 * i) >> 8) & 0xFF00FF)
+ 8388736) & 0xFF00FF00;
}
}
}
else if ( a2 > 0 )
{
v7 = (unsigned int)a2;
for ( j = 0LL; j != v7; ++j )
{
v9 = (((((a4 * ((*(_DWORD *)(a3 + 4 * j) >> 8) & 0xFF00FFu)) >> 8) & 0xFF00FF)
+ a4 * ((*(_DWORD *)(a3 + 4 * j) >> 8) & 0xFF00FF)
+ 8388736) >> 24)
- a4
+ 255;
v10 = (unsigned int)~*(_DWORD *)(a1 + 4 * j) >> 24;
*(_DWORD *)(a1 + 4 * j) = (((((v9 * (*(_DWORD *)(a1 + 4 * j) & 0xFF00FF)
+ v10
* ((((((a4 * (*(_DWORD *)(a3 + 4 * j) & 0xFF00FFu)) >> 8) & 0xFF00FF)
+ a4 * (*(_DWORD *)(a3 + 4 * j) & 0xFF00FF)
+ 8388736) >> 8) & 0xFF00FF)) >> 8) & 0xFF00FF)
+ v9 * (*(_DWORD *)(a1 + 4 * j) & 0xFF00FF)
+ v10
* ((((((a4 * (*(_DWORD *)(a3 + 4 * j) & 0xFF00FFu)) >> 8) & 0xFF00FF)
+ a4 * (*(_DWORD *)(a3 + 4 * j) & 0xFF00FF)
+ 8388736) >> 8) & 0xFF00FF)
+ 8388736) >> 8) & 0xFF00FF | ((((v9 * ((*(_DWORD *)(a1 + 4 * j) >> 8) & 0xFF00FF)
+ v10
* ((((((a4 * ((*(_DWORD *)(a3 + 4 * j) >> 8) & 0xFF00FFu)) >> 8) & 0xFF00FF)
+ a4 * ((*(_DWORD *)(a3 + 4 * j) >> 8) & 0xFF00FF)
+ 8388736) >> 8) & 0xFF00FF)) >> 8) & 0xFF00FF)
+ v9 * ((*(_DWORD *)(a1 + 4 * j) >> 8) & 0xFF00FF)
+ v10
* ((((((a4 * ((*(_DWORD *)(a3 + 4 * j) >> 8) & 0xFF00FFu)) >> 8) & 0xFF00FF)
+ a4 * ((*(_DWORD *)(a3 + 4 * j) >> 8) & 0xFF00FF)
+ 8388736) >> 8) & 0xFF00FF)
+ 8388736) & 0xFF00FF00;
}
}
}
| composition_destination_atop:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
CMP ECX,0xff
JNZ 0x00121f6d
TEST ESI,ESI
JLE 0x00122046
MOV EAX,ESI
XOR ECX,ECX
MOV ESI,0xff00ff
MOV R8D,0x800080
LAB_00121ee1:
MOV R9D,dword ptr [RDX + RCX*0x4]
MOV R11D,dword ptr [RDI + RCX*0x4]
MOV EBP,R9D
SHR EBP,0x18
MOV EBX,R11D
NOT EBX
SHR EBX,0x18
MOV R14D,R11D
AND R14D,ESI
IMUL R14D,EBP
MOV R10D,R9D
AND R10D,ESI
IMUL R10D,EBX
ADD R10D,R14D
MOV R14D,R10D
SHR R14D,0x8
AND R14D,ESI
ADD R10D,R8D
ADD R10D,R14D
SHR R10D,0x8
AND R10D,ESI
SHR R11D,0x8
AND R11D,ESI
IMUL R11D,EBP
SHR R9D,0x8
AND R9D,ESI
IMUL R9D,EBX
ADD R9D,R11D
MOV R11D,R9D
SHR R11D,0x8
AND R11D,ESI
ADD R9D,R8D
ADD R9D,R11D
AND R9D,0xff00ff00
OR R9D,R10D
MOV dword ptr [RDI + RCX*0x4],R9D
INC RCX
CMP RAX,RCX
JNZ 0x00121ee1
JMP 0x00122046
LAB_00121f6d:
TEST ESI,ESI
JLE 0x00122046
MOV EAX,ESI
XOR ESI,ESI
MOV R8D,0xff00ff
MOV R9D,0x800080
LAB_00121f85:
MOV R10D,dword ptr [RDX + RSI*0x4]
MOV R11D,R10D
AND R11D,R8D
IMUL R11D,ECX
MOV EBX,R11D
SHR EBX,0x8
AND EBX,R8D
ADD R11D,R9D
ADD R11D,EBX
SHR R11D,0x8
AND R11D,R8D
SHR R10D,0x8
AND R10D,R8D
IMUL R10D,ECX
MOV EBX,R10D
SHR EBX,0x8
AND EBX,R8D
ADD R10D,R9D
ADD R10D,EBX
MOV EBX,dword ptr [RDI + RSI*0x4]
MOV EBP,R10D
SHR EBP,0x18
SUB EBP,ECX
ADD EBP,0xff
MOV R14D,EBX
NOT R14D
SHR R14D,0x18
MOV R15D,EBX
AND R15D,R8D
IMUL R15D,EBP
IMUL R11D,R14D
ADD R11D,R15D
MOV R15D,R11D
SHR R15D,0x8
AND R15D,R8D
ADD R11D,R9D
ADD R11D,R15D
SHR R11D,0x8
AND R11D,R8D
SHR EBX,0x8
AND EBX,R8D
IMUL EBX,EBP
SHR R10D,0x8
AND R10D,R8D
IMUL R10D,R14D
ADD R10D,EBX
MOV EBX,R10D
SHR EBX,0x8
AND EBX,R8D
ADD R10D,R9D
ADD R10D,EBX
AND R10D,0xff00ff00
OR R10D,R11D
MOV dword ptr [RDI + RSI*0x4],R10D
INC RSI
CMP RAX,RSI
JNZ 0x00121f85
LAB_00122046:
POP RBX
POP R14
POP R15
POP RBP
RET
|
void composition_destination_atop(long param_1,uint param_2,long param_3,int param_4)
{
ulong uVar1;
int iVar2;
uint uVar3;
uint uVar4;
uint uVar5;
if (param_4 == 0xff) {
if (0 < (int)param_2) {
uVar1 = 0;
do {
uVar3 = *(uint *)(param_3 + uVar1 * 4);
uVar5 = *(uint *)(param_1 + uVar1 * 4);
uVar4 = (uVar3 & 0xff00ff) * (~uVar5 >> 0x18) + (uVar5 & 0xff00ff) * (uVar3 >> 0x18);
uVar3 = (uVar3 >> 8 & 0xff00ff) * (~uVar5 >> 0x18) +
(uVar5 >> 8 & 0xff00ff) * (uVar3 >> 0x18);
*(uint *)(param_1 + uVar1 * 4) =
uVar3 + 0x800080 + (uVar3 >> 8 & 0xff00ff) & 0xff00ff00 |
uVar4 + 0x800080 + (uVar4 >> 8 & 0xff00ff) >> 8 & 0xff00ff;
uVar1 = uVar1 + 1;
} while (param_2 != uVar1);
}
}
else if (0 < (int)param_2) {
uVar1 = 0;
do {
uVar3 = *(uint *)(param_3 + uVar1 * 4);
uVar4 = (uVar3 & 0xff00ff) * param_4;
uVar3 = (uVar3 >> 8 & 0xff00ff) * param_4;
uVar5 = uVar3 + 0x800080 + (uVar3 >> 8 & 0xff00ff);
uVar3 = *(uint *)(param_1 + uVar1 * 4);
iVar2 = ((uVar5 >> 0x18) - param_4) + 0xff;
uVar4 = (uVar4 + 0x800080 + (uVar4 >> 8 & 0xff00ff) >> 8 & 0xff00ff) * (~uVar3 >> 0x18) +
(uVar3 & 0xff00ff) * iVar2;
uVar3 = (uVar5 >> 8 & 0xff00ff) * (~uVar3 >> 0x18) + (uVar3 >> 8 & 0xff00ff) * iVar2;
*(uint *)(param_1 + uVar1 * 4) =
uVar3 + 0x800080 + (uVar3 >> 8 & 0xff00ff) & 0xff00ff00 |
uVar4 + 0x800080 + (uVar4 >> 8 & 0xff00ff) >> 8 & 0xff00ff;
uVar1 = uVar1 + 1;
} while (param_2 != uVar1);
}
return;
}
| |
41,620 | my_block_write | eloqsql/mysys/mf_iocache.c | int my_block_write(IO_CACHE *info, const uchar *Buffer, size_t Count,
my_off_t pos)
{
size_t length;
int error=0;
/*
Assert that we cannot come here with a shared cache. If we do one
day, we might need to add a call to copy_to_read_buffer().
*/
DBUG_ASSERT(!info->share);
DBUG_ASSERT(!(info->myflags & MY_ENCRYPT));
if (pos < info->pos_in_file)
{
/* Of no overlap, write everything without buffering */
if (pos + Count <= info->pos_in_file)
return (int)mysql_file_pwrite(info->file, Buffer, Count, pos,
info->myflags | MY_NABP);
/* Write the part of the block that is before buffer */
length= (uint) (info->pos_in_file - pos);
if (mysql_file_pwrite(info->file, Buffer, length, pos, info->myflags | MY_NABP))
info->error= error= -1;
Buffer+=length;
pos+= length;
Count-= length;
}
/* Check if we want to write inside the used part of the buffer.*/
length= (size_t) (info->write_end - info->buffer);
if (pos < info->pos_in_file + length)
{
size_t offset= (size_t) (pos - info->pos_in_file);
length-=offset;
if (length > Count)
length=Count;
memcpy(info->buffer+offset, Buffer, length);
Buffer+=length;
Count-= length;
/* Fix length of buffer if the new data was larger */
if (info->buffer+length > info->write_pos)
info->write_pos=info->buffer+length;
if (!Count)
return (error);
}
/* Write at the end of the current buffer; This is the normal case */
if (_my_b_write(info, Buffer, Count))
error= -1;
return error;
} | O3 | c | my_block_write:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r15
movq %rdi, %r12
movq (%rdi), %r13
xorl %r14d, %r14d
cmpq %rcx, %r13
jbe 0x9b1c3
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
leaq (%r15,%rdx), %rax
cmpq %r13, %rax
jbe 0x9b154
subl %r15d, %r13d
movl 0xd4(%r12), %ebx
movq 0xf8(%r12), %r14
orq $0x4, %r14
leaq 0x2f5dd8(%rip), %rax # 0x390ed8
movq (%rax), %rax
leaq -0x88(%rbp), %rdi
movl %ebx, %esi
movl $0x7, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x9b242
movl %ebx, %edi
movq -0x30(%rbp), %rsi
movq %r13, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xa796a
movq %rax, %rbx
testq %rbx, %rbx
movq -0x38(%rbp), %rdx
je 0x9b1af
movl $0xffffffff, 0xe4(%r12) # imm = 0xFFFFFFFF
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
jmp 0x9b1b2
movl 0xd4(%r12), %r13d
movq 0xf8(%r12), %r14
orq $0x4, %r14
leaq 0x2f5d69(%rip), %r12 # 0x390ed8
movq (%r12), %rax
leaq -0x88(%rbp), %rdi
movl %r13d, %esi
movl $0x7, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x9b2a4
movl %r13d, %edi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xa796a
movq %rax, %r14
jmp 0x9b230
xorl %r14d, %r14d
movq -0x30(%rbp), %rsi
addq %r13, %rsi
addq %r13, %r15
subq %r13, %rdx
movq (%r12), %r13
movq 0x20(%r12), %rdi
movq 0x48(%r12), %rbx
subq %rdi, %rbx
leaq (%rbx,%r13), %rax
cmpq %rax, %r15
jae 0x9b21c
subq %r13, %r15
subq %r15, %rbx
cmpq %rdx, %rbx
cmovaeq %rdx, %rbx
addq %r15, %rdi
movq %rsi, %r13
movq %rdx, %r15
movq %rbx, %rdx
callq 0x2a0a0
movq %r15, %rdx
subq %rbx, %rdx
movq 0x20(%r12), %rax
addq %rbx, %rax
cmpq 0x40(%r12), %rax
jbe 0x9b211
movq %rax, 0x40(%r12)
testq %rdx, %rdx
je 0x9b230
movq %r13, %rsi
addq %rbx, %rsi
movq %r12, %rdi
callq 0x9a617
xorl %ecx, %ecx
negl %eax
sbbl %ecx, %ecx
orl %r14d, %ecx
movl %ecx, %r14d
movl %r14d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rcx
leaq 0x2f5c8c(%rip), %rax # 0x390ed8
movq (%rax), %rax
leaq 0x496f5(%rip), %rdx # 0xe494b
movq %rcx, -0x40(%rbp)
movq %rcx, %rdi
movq %r13, %rsi
movl $0x676, %ecx # imm = 0x676
callq *0x210(%rax)
movl %ebx, %edi
movq -0x30(%rbp), %rsi
movq %r13, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xa796a
movq %rax, %rbx
xorl %esi, %esi
testq %rax, %rax
cmoveq %r13, %rsi
leaq 0x2f5c46(%rip), %rax # 0x390ed8
movq (%rax), %rax
movq -0x40(%rbp), %rdi
callq *0x218(%rax)
jmp 0x9b137
movq %rax, %rbx
movq (%r12), %rax
leaq 0x49699(%rip), %rdx # 0xe494b
movq %rbx, %rdi
movq -0x38(%rbp), %rsi
movl $0x673, %ecx # imm = 0x673
callq *0x210(%rax)
movl %r13d, %edi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %r13
movq %r13, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xa796a
movq %rax, %r14
xorl %esi, %esi
testq %rax, %rax
cmoveq %r13, %rsi
movq (%r12), %rax
movq %rbx, %rdi
callq *0x218(%rax)
jmp 0x9b230
| my_block_write:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r15, rcx
mov r12, rdi
mov r13, [rdi]
xor r14d, r14d
cmp r13, rcx
jbe loc_9B1C3
mov [rbp+var_30], rsi
mov [rbp+var_38], rdx
lea rax, [r15+rdx]
cmp rax, r13
jbe short loc_9B154
sub r13d, r15d
mov ebx, [r12+0D4h]
mov r14, [r12+0F8h]
or r14, 4
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_88]
mov esi, ebx
mov edx, 7
call qword ptr [rax+158h]
test rax, rax
jnz loc_9B242
mov edi, ebx
mov rsi, [rbp+var_30]
mov rdx, r13
mov rcx, r15
mov r8, r14
call my_pwrite
mov rbx, rax
loc_9B137:
test rbx, rbx
mov rdx, [rbp+var_38]
jz short loc_9B1AF
mov dword ptr [r12+0E4h], 0FFFFFFFFh
mov r14d, 0FFFFFFFFh
jmp short loc_9B1B2
loc_9B154:
mov r13d, [r12+0D4h]
mov r14, [r12+0F8h]
or r14, 4
lea r12, PSI_server
mov rax, [r12]
lea rdi, [rbp+var_88]
mov esi, r13d
mov edx, 7
call qword ptr [rax+158h]
test rax, rax
jnz loc_9B2A4
mov edi, r13d
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_38]
mov rcx, r15
mov r8, r14
call my_pwrite
mov r14, rax
jmp loc_9B230
loc_9B1AF:
xor r14d, r14d
loc_9B1B2:
mov rsi, [rbp+var_30]
add rsi, r13
add r15, r13
sub rdx, r13
mov r13, [r12]
loc_9B1C3:
mov rdi, [r12+20h]
mov rbx, [r12+48h]
sub rbx, rdi
lea rax, [rbx+r13]
cmp r15, rax
jnb short loc_9B21C
sub r15, r13
sub rbx, r15
cmp rbx, rdx
cmovnb rbx, rdx
add rdi, r15
mov r13, rsi
mov r15, rdx
mov rdx, rbx
call _memcpy
mov rdx, r15
sub rdx, rbx
mov rax, [r12+20h]
add rax, rbx
cmp rax, [r12+40h]
jbe short loc_9B211
mov [r12+40h], rax
loc_9B211:
test rdx, rdx
jz short loc_9B230
mov rsi, r13
add rsi, rbx
loc_9B21C:
mov rdi, r12
call _my_b_write
xor ecx, ecx
neg eax
sbb ecx, ecx
or ecx, r14d
mov r14d, ecx
loc_9B230:
mov eax, r14d
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_9B242:
mov rcx, rax
lea rax, PSI_server
mov rax, [rax]
lea rdx, aWorkspaceLlm4b_22; "/workspace/llm4binary/github2025/eloqsq"...
mov [rbp+var_40], rcx
mov rdi, rcx
mov rsi, r13
mov ecx, 676h
call qword ptr [rax+210h]
mov edi, ebx
mov rsi, [rbp+var_30]
mov rdx, r13
mov rcx, r15
mov r8, r14
call my_pwrite
mov rbx, rax
xor esi, esi
test rax, rax
cmovz rsi, r13
lea rax, PSI_server
mov rax, [rax]
mov rdi, [rbp+var_40]
call qword ptr [rax+218h]
jmp loc_9B137
loc_9B2A4:
mov rbx, rax
mov rax, [r12]
lea rdx, aWorkspaceLlm4b_22; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rbx
mov rsi, [rbp+var_38]
mov ecx, 673h
call qword ptr [rax+210h]
mov edi, r13d
mov rsi, [rbp+var_30]
mov r13, [rbp+var_38]
mov rdx, r13
mov rcx, r15
mov r8, r14
call my_pwrite
mov r14, rax
xor esi, esi
test rax, rax
cmovz rsi, r13
mov rax, [r12]
mov rdi, rbx
call qword ptr [rax+218h]
jmp loc_9B230
| long long my_block_write(long long a1, const char *a2, unsigned long long a3, unsigned long long a4)
{
unsigned long long v4; // r15
unsigned long long v6; // r13
long long v7; // r14
long long v8; // r13
unsigned int v9; // ebx
long long v10; // r14
long long v11; // rax
long long v12; // rbx
unsigned long long v13; // rdx
unsigned int v14; // r13d
long long v15; // rax
long long v16; // rdi
long long v17; // rbx
long long v18; // r15
unsigned long long v19; // rbx
long long v20; // rdi
unsigned long long v21; // r15
unsigned long long v22; // rax
long long v24; // rsi
long long v25; // rbx
long long v26; // rdi
unsigned long long v27; // r13
unsigned long long v28; // rsi
_BYTE v29[72]; // [rsp+8h] [rbp-88h] BYREF
long long v30; // [rsp+50h] [rbp-40h]
unsigned long long v31; // [rsp+58h] [rbp-38h]
const char *v32; // [rsp+60h] [rbp-30h]
v4 = a4;
v6 = *(_QWORD *)a1;
LODWORD(v7) = 0;
if ( *(_QWORD *)a1 > a4 )
{
v32 = a2;
v31 = a3;
if ( a4 + a3 <= v6 )
{
v14 = *(_DWORD *)(a1 + 212);
v7 = *(_QWORD *)(a1 + 248) | 4LL;
v15 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v29, v14, 7LL);
if ( v15 )
{
v25 = v15;
((void ( *)(long long, unsigned long long, const char *, long long))PSI_server[66])(
v15,
v31,
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
1651LL);
v26 = v14;
v27 = v31;
v7 = my_pwrite(v26, v32, v31, v4, v7);
v28 = 0LL;
if ( !v7 )
v28 = v27;
((void ( *)(long long, unsigned long long))PSI_server[67])(v25, v28);
}
else
{
LODWORD(v7) = my_pwrite(v14, v32, v31, v4, v7);
}
return (unsigned int)v7;
}
v8 = (unsigned int)(v6 - a4);
v9 = *(_DWORD *)(a1 + 212);
v10 = *(_QWORD *)(a1 + 248) | 4LL;
v11 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v29, v9, 7LL);
if ( v11 )
{
v30 = v11;
((void ( *)(long long, long long, const char *, long long))PSI_server[66])(
v11,
v8,
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
1654LL);
v12 = my_pwrite(v9, v32, v8, v4, v10);
v24 = 0LL;
if ( !v12 )
v24 = v8;
((void ( *)(long long, long long))PSI_server[67])(v30, v24);
}
else
{
v12 = my_pwrite(v9, v32, v8, v4, v10);
}
v13 = v31;
if ( v12 )
{
*(_DWORD *)(a1 + 228) = -1;
LODWORD(v7) = -1;
}
else
{
LODWORD(v7) = 0;
}
a2 = &v32[v8];
v4 += v8;
a3 = v13 - v8;
v6 = *(_QWORD *)a1;
}
v16 = *(_QWORD *)(a1 + 32);
v17 = *(_QWORD *)(a1 + 72) - v16;
if ( v4 >= v17 + v6 )
{
LABEL_18:
LODWORD(v7) = (unsigned int)my_b_write(a1, a2, a3) != 0 ? -1 : v7;
return (unsigned int)v7;
}
v18 = v4 - v6;
v19 = v17 - v18;
if ( v19 >= a3 )
v19 = a3;
v20 = v18 + v16;
v21 = a3;
memcpy(v20, a2, v19);
a3 = v21 - v19;
v22 = v19 + *(_QWORD *)(a1 + 32);
if ( v22 > *(_QWORD *)(a1 + 64) )
*(_QWORD *)(a1 + 64) = v22;
if ( a3 )
{
a2 += v19;
goto LABEL_18;
}
return (unsigned int)v7;
}
| my_block_write:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R15,RCX
MOV R12,RDI
MOV R13,qword ptr [RDI]
XOR R14D,R14D
CMP R13,RCX
JBE 0x0019b1c3
MOV qword ptr [RBP + -0x30],RSI
MOV qword ptr [RBP + -0x38],RDX
LEA RAX,[R15 + RDX*0x1]
CMP RAX,R13
JBE 0x0019b154
SUB R13D,R15D
MOV EBX,dword ptr [R12 + 0xd4]
MOV R14,qword ptr [R12 + 0xf8]
OR R14,0x4
LEA RAX,[0x490ed8]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x88]
MOV ESI,EBX
MOV EDX,0x7
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0019b242
MOV EDI,EBX
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,R13
MOV RCX,R15
MOV R8,R14
CALL 0x001a796a
MOV RBX,RAX
LAB_0019b137:
TEST RBX,RBX
MOV RDX,qword ptr [RBP + -0x38]
JZ 0x0019b1af
MOV dword ptr [R12 + 0xe4],0xffffffff
MOV R14D,0xffffffff
JMP 0x0019b1b2
LAB_0019b154:
MOV R13D,dword ptr [R12 + 0xd4]
MOV R14,qword ptr [R12 + 0xf8]
OR R14,0x4
LEA R12,[0x490ed8]
MOV RAX,qword ptr [R12]
LEA RDI,[RBP + -0x88]
MOV ESI,R13D
MOV EDX,0x7
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0019b2a4
MOV EDI,R13D
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x38]
MOV RCX,R15
MOV R8,R14
CALL 0x001a796a
MOV R14,RAX
JMP 0x0019b230
LAB_0019b1af:
XOR R14D,R14D
LAB_0019b1b2:
MOV RSI,qword ptr [RBP + -0x30]
ADD RSI,R13
ADD R15,R13
SUB RDX,R13
MOV R13,qword ptr [R12]
LAB_0019b1c3:
MOV RDI,qword ptr [R12 + 0x20]
MOV RBX,qword ptr [R12 + 0x48]
SUB RBX,RDI
LEA RAX,[RBX + R13*0x1]
CMP R15,RAX
JNC 0x0019b21c
SUB R15,R13
SUB RBX,R15
CMP RBX,RDX
CMOVNC RBX,RDX
ADD RDI,R15
MOV R13,RSI
MOV R15,RDX
MOV RDX,RBX
CALL 0x0012a0a0
MOV RDX,R15
SUB RDX,RBX
MOV RAX,qword ptr [R12 + 0x20]
ADD RAX,RBX
CMP RAX,qword ptr [R12 + 0x40]
JBE 0x0019b211
MOV qword ptr [R12 + 0x40],RAX
LAB_0019b211:
TEST RDX,RDX
JZ 0x0019b230
MOV RSI,R13
ADD RSI,RBX
LAB_0019b21c:
MOV RDI,R12
CALL 0x0019a617
XOR ECX,ECX
NEG EAX
SBB ECX,ECX
OR ECX,R14D
MOV R14D,ECX
LAB_0019b230:
MOV EAX,R14D
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0019b242:
MOV RCX,RAX
LEA RAX,[0x490ed8]
MOV RAX,qword ptr [RAX]
LEA RDX,[0x1e494b]
MOV qword ptr [RBP + -0x40],RCX
MOV RDI,RCX
MOV RSI,R13
MOV ECX,0x676
CALL qword ptr [RAX + 0x210]
MOV EDI,EBX
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,R13
MOV RCX,R15
MOV R8,R14
CALL 0x001a796a
MOV RBX,RAX
XOR ESI,ESI
TEST RAX,RAX
CMOVZ RSI,R13
LEA RAX,[0x490ed8]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x40]
CALL qword ptr [RAX + 0x218]
JMP 0x0019b137
LAB_0019b2a4:
MOV RBX,RAX
MOV RAX,qword ptr [R12]
LEA RDX,[0x1e494b]
MOV RDI,RBX
MOV RSI,qword ptr [RBP + -0x38]
MOV ECX,0x673
CALL qword ptr [RAX + 0x210]
MOV EDI,R13D
MOV RSI,qword ptr [RBP + -0x30]
MOV R13,qword ptr [RBP + -0x38]
MOV RDX,R13
MOV RCX,R15
MOV R8,R14
CALL 0x001a796a
MOV R14,RAX
XOR ESI,ESI
TEST RAX,RAX
CMOVZ RSI,R13
MOV RAX,qword ptr [R12]
MOV RDI,RBX
CALL qword ptr [RAX + 0x218]
JMP 0x0019b230
|
ulong my_block_write(ulong *param_1,void *param_2,ulong param_3,ulong param_4)
{
int4 uVar1;
int iVar2;
long lVar3;
ulong uVar4;
ulong uVar5;
ulong uVar6;
int1 local_90 [72];
long local_48;
ulong local_40;
void *local_38;
uVar5 = *param_1;
uVar6 = 0;
if (param_4 < uVar5) {
local_40 = param_3;
local_38 = param_2;
if (param_4 + param_3 <= uVar5) {
uVar1 = *(int4 *)((long)param_1 + 0xd4);
uVar5 = param_1[0x1f];
lVar3 = (**(code **)(PSI_server + 0x158))(local_90,uVar1,7);
if (lVar3 == 0) {
uVar6 = my_pwrite(uVar1,local_38,local_40,param_4,uVar5 | 4);
}
else {
(**(code **)(PSI_server + 0x210))
(lVar3,local_40,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
0x673);
uVar4 = local_40;
uVar6 = my_pwrite(uVar1,local_38,local_40,param_4,uVar5 | 4);
uVar5 = 0;
if (uVar6 == 0) {
uVar5 = uVar4;
}
(**(code **)(PSI_server + 0x218))(lVar3,uVar5);
}
goto LAB_0019b230;
}
param_3 = (ulong)(uint)((int)uVar5 - (int)param_4);
uVar1 = *(int4 *)((long)param_1 + 0xd4);
uVar5 = param_1[0x1f];
lVar3 = (**(code **)(PSI_server + 0x158))(local_90,uVar1,7);
if (lVar3 == 0) {
lVar3 = my_pwrite(uVar1,local_38,param_3,param_4,uVar5 | 4);
}
else {
local_48 = lVar3;
(**(code **)(PSI_server + 0x210))
(lVar3,param_3,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x676);
lVar3 = my_pwrite(uVar1,local_38,param_3,param_4,uVar5 | 4);
uVar5 = 0;
if (lVar3 == 0) {
uVar5 = param_3;
}
(**(code **)(PSI_server + 0x218))(local_48,uVar5);
}
if (lVar3 == 0) {
uVar6 = 0;
}
else {
*(int4 *)((long)param_1 + 0xe4) = 0xffffffff;
uVar6 = 0xffffffff;
}
param_2 = (void *)((long)local_38 + param_3);
param_4 = param_4 + param_3;
param_3 = local_40 - param_3;
uVar5 = *param_1;
}
lVar3 = param_1[9] - param_1[4];
if (param_4 < lVar3 + uVar5) {
uVar4 = lVar3 - (param_4 - uVar5);
if (param_3 <= uVar4) {
uVar4 = param_3;
}
memcpy((void *)(param_1[4] + (param_4 - uVar5)),param_2,uVar4);
if (param_1[8] < param_1[4] + uVar4) {
param_1[8] = param_1[4] + uVar4;
}
if (param_3 == uVar4) goto LAB_0019b230;
param_2 = (void *)((long)param_2 + uVar4);
}
iVar2 = _my_b_write(param_1,param_2);
uVar6 = (ulong)(-(uint)(iVar2 != 0) | (uint)uVar6);
LAB_0019b230:
return uVar6 & 0xffffffff;
}
| |
41,621 | pfs_set_transaction_xa_state_v1 | eloqsql/storage/perfschema/pfs.cc | void pfs_set_transaction_xa_state_v1(PSI_transaction_locker *locker,
int xa_state)
{
PSI_transaction_locker_state *state= reinterpret_cast<PSI_transaction_locker_state*> (locker);
assert(state != NULL);
if (state->m_flags & STATE_FLAG_EVENT)
{
PFS_events_transactions *pfs= reinterpret_cast<PFS_events_transactions*> (state->m_transaction);
assert(pfs != NULL);
pfs->m_xa_state= (enum_xa_transaction_state)xa_state;
pfs->m_xa= true;
}
return;
} | O0 | cpp | pfs_set_transaction_xa_state_v1:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x501a2
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x118(%rax)
movq -0x20(%rbp), %rax
movb $0x1, 0x78(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
| pfs_set_transaction_xa_state_v1:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov eax, [rax]
and eax, 4
cmp eax, 0
jz short loc_501A2
mov rax, [rbp+var_18]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov ecx, [rbp+var_C]
mov rax, [rbp+var_20]
mov [rax+118h], ecx
mov rax, [rbp+var_20]
mov byte ptr [rax+78h], 1
loc_501A2:
pop rbp
retn
| long long pfs_set_transaction_xa_state_v1(long long a1, int a2)
{
long long result; // rax
long long v3; // [rsp+0h] [rbp-20h]
result = *(_DWORD *)a1 & 4;
if ( (_DWORD)result )
{
v3 = *(_QWORD *)(a1 + 40);
*(_DWORD *)(v3 + 280) = a2;
result = v3;
*(_BYTE *)(v3 + 120) = 1;
}
return result;
}
| pfs_set_transaction_xa_state_v1:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
AND EAX,0x4
CMP EAX,0x0
JZ 0x001501a2
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV ECX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x118],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x78],0x1
LAB_001501a2:
POP RBP
RET
|
void pfs_set_transaction_xa_state_v1(uint *param_1,int4 param_2)
{
long lVar1;
if ((*param_1 & 4) != 0) {
lVar1 = *(long *)(param_1 + 10);
*(int4 *)(lVar1 + 0x118) = param_2;
*(int1 *)(lVar1 + 0x78) = 1;
}
return;
}
| |
41,622 | JS_ThrowTypeErrorOrFalse | bluesky950520[P]quickjs/quickjs.c | static int __attribute__((format(printf, 3, 4))) JS_ThrowTypeErrorOrFalse(JSContext *ctx, int flags, const char *fmt, ...)
{
va_list ap;
if ((flags & JS_PROP_THROW) ||
((flags & JS_PROP_THROW_STRICT) && is_strict_mode(ctx))) {
va_start(ap, fmt);
JS_ThrowError(ctx, JS_TYPE_ERROR, fmt, ap);
va_end(ap);
return -1;
} else {
return FALSE;
}
} | O0 | c | JS_ThrowTypeErrorOrFalse:
subq $0xf8, %rsp
testb %al, %al
je 0x3446c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdi, 0xe8(%rsp)
movl %esi, 0xe4(%rsp)
movq %rdx, 0xd8(%rsp)
movl 0xe4(%rsp), %eax
andl $0x4000, %eax # imm = 0x4000
cmpl $0x0, %eax
jne 0x344ca
movl 0xe4(%rsp), %eax
andl $0x8000, %eax # imm = 0x8000
cmpl $0x0, %eax
je 0x34539
movq 0xe8(%rsp), %rdi
callq 0x36c80
cmpl $0x0, %eax
je 0x34539
leaq 0xc0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0x100(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq 0xe8(%rsp), %rdi
movq 0xd8(%rsp), %rdx
leaq 0xc0(%rsp), %rcx
movl $0x4, %esi
callq 0x2be80
movq %rax, 0xb0(%rsp)
movq %rdx, 0xb8(%rsp)
leaq 0xc0(%rsp), %rax
movl $0xffffffff, 0xf4(%rsp) # imm = 0xFFFFFFFF
jmp 0x34544
movl $0x0, 0xf4(%rsp)
movl 0xf4(%rsp), %eax
addq $0xf8, %rsp
retq
nopw %cs:(%rax,%rax)
| JS_ThrowTypeErrorOrFalse:
sub rsp, 0F8h
test al, al
jz short loc_3446C
movaps [rsp+0F8h+var_C8], xmm0
movaps [rsp+0F8h+var_B8], xmm1
movaps [rsp+0F8h+var_A8], xmm2
movaps [rsp+0F8h+var_98], xmm3
movaps [rsp+0F8h+var_88], xmm4
movaps [rsp+0F8h+var_78], xmm5
movaps [rsp+0F8h+var_68], xmm6
movaps [rsp+0F8h+var_58], xmm7
loc_3446C:
mov [rsp+0F8h+var_D0], r9
mov [rsp+0F8h+var_D8], r8
mov [rsp+0F8h+var_E0], rcx
mov [rsp+0F8h+var_10], rdi
mov [rsp+0F8h+var_14], esi
mov [rsp+0F8h+var_20], rdx
mov eax, [rsp+0F8h+var_14]
and eax, 4000h
cmp eax, 0
jnz short loc_344CA
mov eax, [rsp+0F8h+var_14]
and eax, 8000h
cmp eax, 0
jz loc_34539
mov rdi, [rsp+0F8h+var_10]
call is_strict_mode
cmp eax, 0
jz short loc_34539
loc_344CA:
lea rax, [rsp+0F8h+var_38]
mov rcx, rsp
mov [rax+10h], rcx
lea rcx, [rsp+0F8h+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 18h
mov rdi, [rsp+0F8h+var_10]
mov rdx, [rsp+0F8h+var_20]
lea rcx, [rsp+0F8h+var_38]
mov esi, 4
call JS_ThrowError
mov [rsp+0F8h+var_48], rax
mov [rsp+0F8h+var_40], rdx
lea rax, [rsp+0F8h+var_38]
mov [rsp+0F8h+var_4], 0FFFFFFFFh
jmp short loc_34544
loc_34539:
mov [rsp+0F8h+var_4], 0
loc_34544:
mov eax, [rsp+0F8h+var_4]
add rsp, 0F8h
retn
| long long JS_ThrowTypeErrorOrFalse(long long a1, int a2, long long a3, ...)
{
va_list va; // [rsp+C0h] [rbp-38h] BYREF
long long v5; // [rsp+D8h] [rbp-20h]
int v6; // [rsp+E4h] [rbp-14h]
long long v7; // [rsp+E8h] [rbp-10h]
v7 = a1;
v6 = a2;
v5 = a3;
if ( (a2 & 0x4000) != 0 || (v6 & 0x8000) != 0 && (unsigned int)is_strict_mode(v7) )
{
va_start(va, a3);
JS_ThrowError(v7, 4u, v5, (long long)va);
return (unsigned int)-1;
}
else
{
return 0;
}
}
| JS_ThrowTypeErrorOrFalse:
SUB RSP,0xf8
TEST AL,AL
JZ 0x0013446c
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM1
MOVAPS xmmword ptr [RSP + 0x50],XMM2
MOVAPS xmmword ptr [RSP + 0x60],XMM3
MOVAPS xmmword ptr [RSP + 0x70],XMM4
MOVAPS xmmword ptr [RSP + 0x80],XMM5
MOVAPS xmmword ptr [RSP + 0x90],XMM6
MOVAPS xmmword ptr [RSP + 0xa0],XMM7
LAB_0013446c:
MOV qword ptr [RSP + 0x28],R9
MOV qword ptr [RSP + 0x20],R8
MOV qword ptr [RSP + 0x18],RCX
MOV qword ptr [RSP + 0xe8],RDI
MOV dword ptr [RSP + 0xe4],ESI
MOV qword ptr [RSP + 0xd8],RDX
MOV EAX,dword ptr [RSP + 0xe4]
AND EAX,0x4000
CMP EAX,0x0
JNZ 0x001344ca
MOV EAX,dword ptr [RSP + 0xe4]
AND EAX,0x8000
CMP EAX,0x0
JZ 0x00134539
MOV RDI,qword ptr [RSP + 0xe8]
CALL 0x00136c80
CMP EAX,0x0
JZ 0x00134539
LAB_001344ca:
LEA RAX,[RSP + 0xc0]
MOV RCX,RSP
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RSP + 0x100]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x18
MOV RDI,qword ptr [RSP + 0xe8]
MOV RDX,qword ptr [RSP + 0xd8]
LEA RCX,[RSP + 0xc0]
MOV ESI,0x4
CALL 0x0012be80
MOV qword ptr [RSP + 0xb0],RAX
MOV qword ptr [RSP + 0xb8],RDX
LEA RAX,[RSP + 0xc0]
MOV dword ptr [RSP + 0xf4],0xffffffff
JMP 0x00134544
LAB_00134539:
MOV dword ptr [RSP + 0xf4],0x0
LAB_00134544:
MOV EAX,dword ptr [RSP + 0xf4]
ADD RSP,0xf8
RET
|
int4
JS_ThrowTypeErrorOrFalse
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int8 param_9,uint param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
int iVar1;
int1 auStack_f8 [24];
int8 local_e0;
int8 local_d8;
int8 local_d0;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int4 local_38;
int4 local_34;
int1 *local_30;
int1 *local_28;
int8 local_20;
uint local_14;
int8 local_10;
int4 local_4;
if (in_AL != '\0') {
local_c8 = param_1;
local_b8 = param_2;
local_a8 = param_3;
local_98 = param_4;
local_88 = param_5;
local_78 = param_6;
local_68 = param_7;
local_58 = param_8;
}
local_e0 = param_12;
local_d8 = param_13;
local_d0 = param_14;
local_20 = param_11;
local_14 = param_10;
local_10 = param_9;
if ((param_10 & 0x4000) == 0) {
if ((param_10 & 0x8000) != 0) {
iVar1 = is_strict_mode(param_9);
if (iVar1 != 0) goto LAB_001344ca;
}
local_4 = 0;
}
else {
LAB_001344ca:
local_30 = &stack0x00000008;
local_34 = 0x30;
local_38 = 0x18;
local_28 = auStack_f8;
JS_ThrowError(local_10,4,local_20,&local_38);
local_4 = 0xffffffff;
}
return local_4;
}
| |
41,623 | JS_ThrowTypeErrorOrFalse | bluesky950520[P]quickjs/quickjs.c | static int __attribute__((format(printf, 3, 4))) JS_ThrowTypeErrorOrFalse(JSContext *ctx, int flags, const char *fmt, ...)
{
va_list ap;
if ((flags & JS_PROP_THROW) ||
((flags & JS_PROP_THROW_STRICT) && is_strict_mode(ctx))) {
va_start(ap, fmt);
JS_ThrowError(ctx, JS_TYPE_ERROR, fmt, ap);
va_end(ap);
return -1;
} else {
return FALSE;
}
} | O1 | c | JS_ThrowTypeErrorOrFalse:
subq $0xd8, %rsp
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x2561f
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
btl $0xe, %esi
jb 0x25642
xorl %eax, %eax
testw %si, %si
jns 0x25676
movq 0x18(%rdi), %rcx
movq 0x108(%rcx), %rcx
testq %rcx, %rcx
je 0x25676
cmpl $0x0, 0x40(%rcx)
jns 0x25676
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000018, %rax # imm = 0x3000000018
movq %rax, (%rcx)
movl $0x4, %esi
callq 0x2183c
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0xd8, %rsp
retq
| JS_ThrowTypeErrorOrFalse:
sub rsp, 0D8h
mov [rsp+0D8h+var_A0], rcx
mov [rsp+0D8h+var_98], r8
mov [rsp+0D8h+var_90], r9
test al, al
jz short loc_2561F
movaps [rsp+0D8h+var_88], xmm0
movaps [rsp+0D8h+var_78], xmm1
movaps [rsp+0D8h+var_68], xmm2
movaps [rsp+0D8h+var_58], xmm3
movaps [rsp+0D8h+var_48], xmm4
movaps [rsp+0D8h+var_38], xmm5
movaps [rsp+0D8h+var_28], xmm6
movaps [rsp+0D8h+var_18], xmm7
loc_2561F:
bt esi, 0Eh
jb short loc_25642
xor eax, eax
test si, si
jns short loc_25676
mov rcx, [rdi+18h]
mov rcx, [rcx+108h]
test rcx, rcx
jz short loc_25676
cmp dword ptr [rcx+40h], 0
jns short loc_25676
loc_25642:
lea rax, [rsp+0D8h+var_B8]
mov rcx, rsp
mov [rcx+10h], rax
lea rax, [rsp+0D8h+arg_0]
mov [rcx+8], rax
mov rax, 3000000018h
mov [rcx], rax
mov esi, 4
call JS_ThrowError
mov eax, 0FFFFFFFFh
loc_25676:
add rsp, 0D8h
retn
| long long JS_ThrowTypeErrorOrFalse(long long a1, __int16 a2, long long a3, ...)
{
long long result; // rax
long long v4; // rcx
va_list va; // [rsp+0h] [rbp-D8h] BYREF
if ( (a2 & 0x4000) != 0
|| (result = 0LL, a2 < 0) && (v4 = *(_QWORD *)(*(_QWORD *)(a1 + 24) + 264LL)) != 0 && *(int *)(v4 + 64) < 0 )
{
va_start(va, a3);
JS_ThrowError(a1, 4LL, a3, (long long)va);
return 0xFFFFFFFFLL;
}
return result;
}
| JS_ThrowTypeErrorOrFalse:
SUB RSP,0xd8
MOV qword ptr [RSP + 0x38],RCX
MOV qword ptr [RSP + 0x40],R8
MOV qword ptr [RSP + 0x48],R9
TEST AL,AL
JZ 0x0012561f
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM1
MOVAPS xmmword ptr [RSP + 0x70],XMM2
MOVAPS xmmword ptr [RSP + 0x80],XMM3
MOVAPS xmmword ptr [RSP + 0x90],XMM4
MOVAPS xmmword ptr [RSP + 0xa0],XMM5
MOVAPS xmmword ptr [RSP + 0xb0],XMM6
MOVAPS xmmword ptr [RSP + 0xc0],XMM7
LAB_0012561f:
BT ESI,0xe
JC 0x00125642
XOR EAX,EAX
TEST SI,SI
JNS 0x00125676
MOV RCX,qword ptr [RDI + 0x18]
MOV RCX,qword ptr [RCX + 0x108]
TEST RCX,RCX
JZ 0x00125676
CMP dword ptr [RCX + 0x40],0x0
JNS 0x00125676
LAB_00125642:
LEA RAX,[RSP + 0x20]
MOV RCX,RSP
MOV qword ptr [RCX + 0x10],RAX
LEA RAX,[RSP + 0xe0]
MOV qword ptr [RCX + 0x8],RAX
MOV RAX,0x3000000018
MOV qword ptr [RCX],RAX
MOV ESI,0x4
CALL 0x0012183c
MOV EAX,0xffffffff
LAB_00125676:
ADD RSP,0xd8
RET
|
int8 JS_ThrowTypeErrorOrFalse(long param_1,uint param_2)
{
long lVar1;
int8 uVar2;
if (((param_2 >> 0xe & 1) != 0) ||
(((uVar2 = 0, (short)param_2 < 0 &&
(lVar1 = *(long *)(*(long *)(param_1 + 0x18) + 0x108), lVar1 != 0)) &&
(*(int *)(lVar1 + 0x40) < 0)))) {
JS_ThrowError(param_1,4);
uVar2 = 0xffffffff;
}
return uVar2;
}
| |
41,624 | JS_ThrowTypeErrorOrFalse | bluesky950520[P]quickjs/quickjs.c | static int __attribute__((format(printf, 3, 4))) JS_ThrowTypeErrorOrFalse(JSContext *ctx, int flags, const char *fmt, ...)
{
va_list ap;
if ((flags & JS_PROP_THROW) ||
((flags & JS_PROP_THROW_STRICT) && is_strict_mode(ctx))) {
va_start(ap, fmt);
JS_ThrowError(ctx, JS_TYPE_ERROR, fmt, ap);
va_end(ap);
return -1;
} else {
return FALSE;
}
} | O3 | c | JS_ThrowTypeErrorOrFalse:
subq $0xd8, %rsp
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x25c6a
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
btl $0xe, %esi
jb 0x25c8d
xorl %eax, %eax
testw %si, %si
jns 0x25cc1
movq 0x18(%rdi), %rcx
movq 0x108(%rcx), %rcx
testq %rcx, %rcx
je 0x25cc1
cmpl $0x0, 0x40(%rcx)
jns 0x25cc1
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000018, %rax # imm = 0x3000000018
movq %rax, (%rcx)
movl $0x4, %esi
callq 0x2204d
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0xd8, %rsp
retq
| JS_ThrowTypeErrorOrFalse:
sub rsp, 0D8h
mov [rsp+0D8h+var_A0], rcx
mov [rsp+0D8h+var_98], r8
mov [rsp+0D8h+var_90], r9
test al, al
jz short loc_25C6A
movaps [rsp+0D8h+var_88], xmm0
movaps [rsp+0D8h+var_78], xmm1
movaps [rsp+0D8h+var_68], xmm2
movaps [rsp+0D8h+var_58], xmm3
movaps [rsp+0D8h+var_48], xmm4
movaps [rsp+0D8h+var_38], xmm5
movaps [rsp+0D8h+var_28], xmm6
movaps [rsp+0D8h+var_18], xmm7
loc_25C6A:
bt esi, 0Eh
jb short loc_25C8D
xor eax, eax
test si, si
jns short loc_25CC1
mov rcx, [rdi+18h]
mov rcx, [rcx+108h]
test rcx, rcx
jz short loc_25CC1
cmp dword ptr [rcx+40h], 0
jns short loc_25CC1
loc_25C8D:
lea rax, [rsp+0D8h+var_B8]
mov rcx, rsp
mov [rcx+10h], rax
lea rax, [rsp+0D8h+arg_0]
mov [rcx+8], rax
mov rax, 3000000018h
mov [rcx], rax
mov esi, 4
call JS_ThrowError
mov eax, 0FFFFFFFFh
loc_25CC1:
add rsp, 0D8h
retn
| long long JS_ThrowTypeErrorOrFalse(long long a1, __int16 a2, long long a3, ...)
{
long long result; // rax
long long v4; // rcx
va_list va; // [rsp+0h] [rbp-D8h] BYREF
if ( (a2 & 0x4000) != 0
|| (result = 0LL, a2 < 0) && (v4 = *(_QWORD *)(*(_QWORD *)(a1 + 24) + 264LL)) != 0 && *(int *)(v4 + 64) < 0 )
{
va_start(va, a3);
JS_ThrowError(a1, 4LL, a3, (long long)va);
return 0xFFFFFFFFLL;
}
return result;
}
| JS_ThrowTypeErrorOrFalse:
SUB RSP,0xd8
MOV qword ptr [RSP + 0x38],RCX
MOV qword ptr [RSP + 0x40],R8
MOV qword ptr [RSP + 0x48],R9
TEST AL,AL
JZ 0x00125c6a
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM1
MOVAPS xmmword ptr [RSP + 0x70],XMM2
MOVAPS xmmword ptr [RSP + 0x80],XMM3
MOVAPS xmmword ptr [RSP + 0x90],XMM4
MOVAPS xmmword ptr [RSP + 0xa0],XMM5
MOVAPS xmmword ptr [RSP + 0xb0],XMM6
MOVAPS xmmword ptr [RSP + 0xc0],XMM7
LAB_00125c6a:
BT ESI,0xe
JC 0x00125c8d
XOR EAX,EAX
TEST SI,SI
JNS 0x00125cc1
MOV RCX,qword ptr [RDI + 0x18]
MOV RCX,qword ptr [RCX + 0x108]
TEST RCX,RCX
JZ 0x00125cc1
CMP dword ptr [RCX + 0x40],0x0
JNS 0x00125cc1
LAB_00125c8d:
LEA RAX,[RSP + 0x20]
MOV RCX,RSP
MOV qword ptr [RCX + 0x10],RAX
LEA RAX,[RSP + 0xe0]
MOV qword ptr [RCX + 0x8],RAX
MOV RAX,0x3000000018
MOV qword ptr [RCX],RAX
MOV ESI,0x4
CALL 0x0012204d
MOV EAX,0xffffffff
LAB_00125cc1:
ADD RSP,0xd8
RET
|
int8 JS_ThrowTypeErrorOrFalse(long param_1,uint param_2)
{
long lVar1;
int8 uVar2;
if (((param_2 >> 0xe & 1) != 0) ||
(((uVar2 = 0, (short)param_2 < 0 &&
(lVar1 = *(long *)(*(long *)(param_1 + 0x18) + 0x108), lVar1 != 0)) &&
(*(int *)(lVar1 + 0x40) < 0)))) {
JS_ThrowError(param_1,4);
uVar2 = 0xffffffff;
}
return uVar2;
}
| |
41,625 | evmone::Result evmone::instr::core::log<0ul>(evmone::StackTop, long, evmone::ExecutionState&) | corpus-core[P]colibri-stateless/build_O0/_deps/evmone_external-src/lib/evmone/instructions.hpp | inline Result log(StackTop stack, int64_t gas_left, ExecutionState& state) noexcept
{
static_assert(NumTopics <= 4);
if (state.in_static_mode())
return {EVMC_STATIC_MODE_VIOLATION, 0};
const auto& offset = stack.pop();
const auto& size = stack.pop();
if (!check_memory(gas_left, state.memory, offset, size))
return {EVMC_OUT_OF_GAS, gas_left};
const auto o = static_cast<size_t>(offset);
const auto s = static_cast<size_t>(size);
const auto cost = int64_t(s) * 8;
if ((gas_left -= cost) < 0)
return {EVMC_OUT_OF_GAS, gas_left};
std::array<evmc::bytes32, NumTopics> topics; // NOLINT(cppcoreguidelines-pro-type-member-init)
for (auto& topic : topics)
topic = intx::be::store<evmc::bytes32>(stack.pop());
const auto data = s != 0 ? &state.memory[o] : nullptr;
state.host.emit_log(state.msg->recipient, data, s, topics.data(), NumTopics);
return {EVMC_SUCCESS, gas_left};
} | O0 | cpp | evmone::Result evmone::instr::core::log<0ul>(evmone::StackTop, long, evmone::ExecutionState&):
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6b0b0
testb $0x1, %al
jne 0x6ef86
jmp 0x6ef9a
movl $0xb, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
jmp 0x6f1e8
leaq -0x18(%rbp), %rdi
callq 0x611b0
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x611b0
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
leaq -0x20(%rbp), %rdi
callq 0x68460
testb $0x1, %al
jne 0x6efe5
movl $0x3, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6f1e8
movq -0x30(%rbp), %rdi
callq 0x68550
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x68550
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jge 0x6f034
movl $0x3, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6f1e8
leaq -0xb0(%rbp), %rdi
callq 0x6f200
leaq -0xb0(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rdi
callq 0x6f290
movq %rax, -0xc0(%rbp)
movq -0xb8(%rbp), %rdi
callq 0x6f2b0
movq %rax, -0xc8(%rbp)
movq -0xc0(%rbp), %rax
cmpq -0xc8(%rbp), %rax
je 0x6f0f0
movq -0xc0(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x611b0
movq %rax, %rsi
leaq -0xf0(%rbp), %rdi
callq 0x6aee0
movq -0xd0(%rbp), %rax
movq -0xf0(%rbp), %rcx
movq %rcx, (%rax)
movq -0xe8(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0xd8(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0xc0(%rbp), %rax
addq $0x20, %rax
movq %rax, -0xc0(%rbp)
jmp 0x6f074
cmpq $0x0, -0x48(%rbp)
je 0x6f111
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x40(%rbp), %rsi
callq 0x60120
movq %rax, -0x128(%rbp)
jmp 0x6f11c
xorl %eax, %eax
movq %rax, -0x128(%rbp)
jmp 0x6f11c
movq -0x128(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0x28(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x140(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rcx
movq %rcx, -0x120(%rbp)
movq 0x20(%rax), %rcx
movq %rcx, -0x118(%rbp)
movl 0x28(%rax), %eax
movl %eax, -0x110(%rbp)
leaq -0x10c(%rbp), %rdi
leaq -0x120(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl 0x10(%rax), %eax
movl %eax, 0x10(%rsp)
callq 0x386f0
movq -0xf8(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x130(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x6f2d0
movq -0x140(%rbp), %rdi
movq -0x138(%rbp), %rdx
movq -0x130(%rbp), %rcx
movq %rax, %r8
leaq -0x10c(%rbp), %rsi
movl $0x3, %r9d
callq 0x3b880
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x160, %rsp # imm = 0x160
popq %rbp
retq
nopl (%rax,%rax)
| _ZN6evmone5instr4core3logILm3EEENS_6ResultENS_8StackTopElRNS_14ExecutionStateE:
push rbp
mov rbp, rsp
sub rsp, 160h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov rdi, [rbp+var_28]; this
call _ZNK6evmone14ExecutionState14in_static_modeEv; evmone::ExecutionState::in_static_mode(void)
test al, 1
jnz short loc_6EF86
jmp short loc_6EF9A
loc_6EF86:
mov [rbp+var_10], 0Bh
mov [rbp+var_8], 0
jmp loc_6F1E8
loc_6EF9A:
lea rdi, [rbp+var_18]; this
call _ZN6evmone8StackTop3popEv; evmone::StackTop::pop(void)
mov [rbp+var_30], rax
lea rdi, [rbp+var_18]; this
call _ZN6evmone8StackTop3popEv; evmone::StackTop::pop(void)
mov [rbp+var_38], rax
mov rsi, [rbp+var_28]
add rsi, 8
mov rdx, [rbp+var_30]
mov rcx, [rbp+var_38]
lea rdi, [rbp+var_20]
call _ZN6evmone12check_memoryERlRNS_6MemoryERKN4intx4uintILj256EEES7_; evmone::check_memory(long &,evmone::Memory &,intx::uint<256u> const&,intx::uint<256u> const&)
test al, 1
jnz short loc_6EFE5
mov [rbp+var_10], 3
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
jmp loc_6F1E8
loc_6EFE5:
mov rdi, [rbp+var_30]
call _ZNK4intx4uintILj256EEcvT_ImvEEv; intx::uint<256u>::operator ulong<ulong,void>(void)
mov [rbp+var_40], rax
mov rdi, [rbp+var_38]
call _ZNK4intx4uintILj256EEcvT_ImvEEv; intx::uint<256u>::operator ulong<ulong,void>(void)
mov [rbp+var_48], rax
mov rax, [rbp+var_48]
shl rax, 3
mov [rbp+var_50], rax
mov rcx, [rbp+var_50]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
cmp rax, 0
jge short loc_6F034
mov [rbp+var_10], 3
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
jmp loc_6F1E8
loc_6F034:
lea rdi, [rbp+var_B0]
call _ZNSt5arrayIN4evmc7bytes32ELm3EEC2Ev; std::array<evmc::bytes32,3ul>::array(void)
lea rax, [rbp+var_B0]
mov [rbp+var_B8], rax
mov rdi, [rbp+var_B8]
call _ZNSt5arrayIN4evmc7bytes32ELm3EE5beginEv; std::array<evmc::bytes32,3ul>::begin(void)
mov [rbp+var_C0], rax
mov rdi, [rbp+var_B8]
call _ZNSt5arrayIN4evmc7bytes32ELm3EE3endEv; std::array<evmc::bytes32,3ul>::end(void)
mov [rbp+var_C8], rax
loc_6F074:
mov rax, [rbp+var_C0]
cmp rax, [rbp+var_C8]
jz short loc_6F0F0
mov rax, [rbp+var_C0]
mov [rbp+var_D0], rax
lea rdi, [rbp+var_18]; this
call _ZN6evmone8StackTop3popEv; evmone::StackTop::pop(void)
mov rsi, rax
lea rdi, [rbp+var_F0]
call _ZN4intx2be5storeIN4evmc7bytes32ENS_4uintILj256EEEEET_RKT0_; intx::be::store<evmc::bytes32,intx::uint<256u>>(intx::uint<256u> const&)
mov rax, [rbp+var_D0]
mov rcx, [rbp+var_F0]
mov [rax], rcx
mov rcx, [rbp+var_E8]
mov [rax+8], rcx
mov rcx, [rbp+var_E0]
mov [rax+10h], rcx
mov rcx, [rbp+var_D8]
mov [rax+18h], rcx
mov rax, [rbp+var_C0]
add rax, 20h ; ' '
mov [rbp+var_C0], rax
jmp short loc_6F074
loc_6F0F0:
cmp [rbp+var_48], 0
jz short loc_6F111
mov rdi, [rbp+var_28]
add rdi, 8
mov rsi, [rbp+var_40]
call _ZN6evmone6MemoryixEm; evmone::Memory::operator[](ulong)
mov [rbp+var_128], rax
jmp short loc_6F11C
loc_6F111:
xor eax, eax
mov [rbp+var_128], rax
jmp short $+2
loc_6F11C:
mov rax, [rbp+var_128]
mov [rbp+var_F8], rax
mov rax, [rbp+var_28]
add rax, 28h ; '('
mov [rbp+var_140], rax
mov rax, [rbp+var_28]
mov rax, [rax+20h]
mov rcx, [rax+18h]
mov [rbp+var_120], rcx
mov rcx, [rax+20h]
mov [rbp+var_118], rcx
mov eax, [rax+28h]
mov [rbp+var_110], eax
lea rdi, [rbp+var_10C]
lea rax, [rbp+var_120]
mov rcx, [rax]
mov [rsp+160h+var_160], rcx
mov rcx, [rax+8]
mov [rsp+160h+var_158], rcx
mov eax, [rax+10h]
mov [rsp+160h+var_150], eax
call _ZN4evmc7addressC2E12evmc_address; evmc::address::address(evmc_address)
mov rax, [rbp+var_F8]
mov [rbp+var_138], rax
mov rax, [rbp+var_48]
mov [rbp+var_130], rax
lea rdi, [rbp+var_B0]
call _ZNSt5arrayIN4evmc7bytes32ELm3EE4dataEv; std::array<evmc::bytes32,3ul>::data(void)
mov rdi, [rbp+var_140]
mov rdx, [rbp+var_138]
mov rcx, [rbp+var_130]
mov r8, rax
lea rsi, [rbp+var_10C]
mov r9d, 3
call _ZN4evmc11HostContext8emit_logERKNS_7addressEPKhmPKNS_7bytes32Em; evmc::HostContext::emit_log(evmc::address const&,uchar const*,ulong,evmc::bytes32 const*,ulong)
mov [rbp+var_10], 0
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
loc_6F1E8:
mov eax, [rbp+var_10]
mov rdx, [rbp+var_8]
add rsp, 160h
pop rbp
retn
| long long evmone::instr::core::log<3ul>(long long a1, long long a2, evmone::ExecutionState *a3)
{
long long v3; // rsi
int v4; // edx
int v5; // r8d
int v6; // r9d
_QWORD *v7; // rax
long long v8; // rax
char *v10; // [rsp+20h] [rbp-140h]
long long v11; // [rsp+28h] [rbp-138h]
long long v12; // [rsp+30h] [rbp-130h]
long long v13; // [rsp+38h] [rbp-128h]
_BYTE v14[20]; // [rsp+54h] [rbp-10Ch] BYREF
long long v15; // [rsp+68h] [rbp-F8h]
_QWORD v16[4]; // [rsp+70h] [rbp-F0h] BYREF
_QWORD *v17; // [rsp+90h] [rbp-D0h]
long long v18; // [rsp+98h] [rbp-C8h]
long long v19; // [rsp+A0h] [rbp-C0h]
_BYTE *v20; // [rsp+A8h] [rbp-B8h]
_BYTE v21[96]; // [rsp+B0h] [rbp-B0h] BYREF
long long v22; // [rsp+110h] [rbp-50h]
long long v23; // [rsp+118h] [rbp-48h]
long long v24; // [rsp+120h] [rbp-40h]
long long v25; // [rsp+128h] [rbp-38h]
long long v26; // [rsp+130h] [rbp-30h]
evmone::ExecutionState *v27; // [rsp+138h] [rbp-28h]
long long v28; // [rsp+140h] [rbp-20h] BYREF
long long v29; // [rsp+148h] [rbp-18h] BYREF
unsigned int v30; // [rsp+150h] [rbp-10h]
long long v31; // [rsp+158h] [rbp-8h]
v29 = a1;
v28 = a2;
v27 = a3;
if ( evmone::ExecutionState::in_static_mode(a3) )
{
v30 = 11;
v31 = 0LL;
}
else
{
v26 = evmone::StackTop::pop((evmone::StackTop *)&v29);
v25 = evmone::StackTop::pop((evmone::StackTop *)&v29);
LODWORD(v3) = (_DWORD)v27 + 8;
if ( (evmone::check_memory((long long)&v28, (long long)v27 + 8, v26, v25) & 1) != 0 )
{
v24 = intx::uint<256u>::operator unsigned long<unsigned long,void>(v26);
v23 = intx::uint<256u>::operator unsigned long<unsigned long,void>(v25);
v22 = 8 * v23;
v28 -= 8 * v23;
if ( v28 >= 0 )
{
std::array<evmc::bytes32,3ul>::array(v21);
v20 = v21;
v19 = std::array<evmc::bytes32,3ul>::begin(v21);
v18 = std::array<evmc::bytes32,3ul>::end(v21);
while ( v19 != v18 )
{
v17 = (_QWORD *)v19;
v3 = evmone::StackTop::pop((evmone::StackTop *)&v29);
intx::be::store<evmc::bytes32,intx::uint<256u>>(v16, v3);
v7 = v17;
*v17 = v16[0];
v7[1] = v16[1];
v7[2] = v16[2];
v7[3] = v16[3];
v19 += 32LL;
}
if ( v23 )
{
LODWORD(v3) = v24;
v13 = evmone::Memory::operator[]((long long)v27 + 8, v24);
}
else
{
v13 = 0LL;
}
v15 = v13;
v10 = (char *)v27 + 40;
evmc::address::address(
(long long)v14,
v3,
v4,
*(_QWORD *)(*((_QWORD *)v27 + 4) + 32LL),
v5,
v6,
*(_QWORD *)(*((_QWORD *)v27 + 4) + 24LL),
*(_QWORD *)(*((_QWORD *)v27 + 4) + 32LL),
*(_DWORD *)(*((_QWORD *)v27 + 4) + 40LL));
v11 = v15;
v12 = v23;
v8 = std::array<evmc::bytes32,3ul>::data(v21);
evmc::HostContext::emit_log((long long)v10, (long long)v14, v11, v12, v8, 3LL);
v30 = 0;
v31 = v28;
}
else
{
v30 = 3;
v31 = v28;
}
}
else
{
v30 = 3;
v31 = v28;
}
}
return v30;
}
| log<3ul>:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x160
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x0016b0b0
TEST AL,0x1
JNZ 0x0016ef86
JMP 0x0016ef9a
LAB_0016ef86:
MOV dword ptr [RBP + -0x10],0xb
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0016f1e8
LAB_0016ef9a:
LEA RDI,[RBP + -0x18]
CALL 0x001611b0
MOV qword ptr [RBP + -0x30],RAX
LEA RDI,[RBP + -0x18]
CALL 0x001611b0
MOV qword ptr [RBP + -0x38],RAX
MOV RSI,qword ptr [RBP + -0x28]
ADD RSI,0x8
MOV RDX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x38]
LEA RDI,[RBP + -0x20]
CALL 0x00168460
TEST AL,0x1
JNZ 0x0016efe5
MOV dword ptr [RBP + -0x10],0x3
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0016f1e8
LAB_0016efe5:
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00168550
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x00168550
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x48]
SHL RAX,0x3
MOV qword ptr [RBP + -0x50],RAX
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JGE 0x0016f034
MOV dword ptr [RBP + -0x10],0x3
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0016f1e8
LAB_0016f034:
LEA RDI,[RBP + -0xb0]
CALL 0x0016f200
LEA RAX,[RBP + -0xb0]
MOV qword ptr [RBP + -0xb8],RAX
MOV RDI,qword ptr [RBP + -0xb8]
CALL 0x0016f290
MOV qword ptr [RBP + -0xc0],RAX
MOV RDI,qword ptr [RBP + -0xb8]
CALL 0x0016f2b0
MOV qword ptr [RBP + -0xc8],RAX
LAB_0016f074:
MOV RAX,qword ptr [RBP + -0xc0]
CMP RAX,qword ptr [RBP + -0xc8]
JZ 0x0016f0f0
MOV RAX,qword ptr [RBP + -0xc0]
MOV qword ptr [RBP + -0xd0],RAX
LEA RDI,[RBP + -0x18]
CALL 0x001611b0
MOV RSI,RAX
LEA RDI,[RBP + -0xf0]
CALL 0x0016aee0
MOV RAX,qword ptr [RBP + -0xd0]
MOV RCX,qword ptr [RBP + -0xf0]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0xe8]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0xe0]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0xd8]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0xc0]
ADD RAX,0x20
MOV qword ptr [RBP + -0xc0],RAX
JMP 0x0016f074
LAB_0016f0f0:
CMP qword ptr [RBP + -0x48],0x0
JZ 0x0016f111
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x8
MOV RSI,qword ptr [RBP + -0x40]
CALL 0x00160120
MOV qword ptr [RBP + -0x128],RAX
JMP 0x0016f11c
LAB_0016f111:
XOR EAX,EAX
MOV qword ptr [RBP + -0x128],RAX
JMP 0x0016f11c
LAB_0016f11c:
MOV RAX,qword ptr [RBP + -0x128]
MOV qword ptr [RBP + -0xf8],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x28
MOV qword ptr [RBP + -0x140],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x120],RCX
MOV RCX,qword ptr [RAX + 0x20]
MOV qword ptr [RBP + -0x118],RCX
MOV EAX,dword ptr [RAX + 0x28]
MOV dword ptr [RBP + -0x110],EAX
LEA RDI,[RBP + -0x10c]
LEA RAX,[RBP + -0x120]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV EAX,dword ptr [RAX + 0x10]
MOV dword ptr [RSP + 0x10],EAX
CALL 0x001386f0
MOV RAX,qword ptr [RBP + -0xf8]
MOV qword ptr [RBP + -0x138],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x130],RAX
LEA RDI,[RBP + -0xb0]
CALL 0x0016f2d0
MOV RDI,qword ptr [RBP + -0x140]
MOV RDX,qword ptr [RBP + -0x138]
MOV RCX,qword ptr [RBP + -0x130]
MOV R8,RAX
LEA RSI,[RBP + -0x10c]
MOV R9D,0x3
CALL 0x0013b880
MOV dword ptr [RBP + -0x10],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
LAB_0016f1e8:
MOV EAX,dword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
ADD RSP,0x160
POP RBP
RET
|
/* evmone::Result evmone::instr::core::log<3ul>(evmone::StackTop, long, evmone::ExecutionState&) */
int1 [16]
evmone::instr::core::log<3ul>(int8 param_1,long param_2,ExecutionState *param_3)
{
uchar *puVar1;
ulong uVar2;
uint *puVar3;
HostContext *this;
bytes32 *pbVar4;
int1 auVar5 [16];
uchar *local_130;
address local_114 [20];
uchar *local_100;
int8 local_f8;
int8 local_f0;
int8 local_e8;
int8 local_e0;
int8 *local_d8;
int8 *local_d0;
int8 *local_c8;
array<evmc::bytes32,3ul> *local_c0;
array<evmc::bytes32,3ul> local_b8 [96];
long local_58;
ulong local_50;
ulong local_48;
uint *local_40;
uint *local_38;
ExecutionState *local_30;
long local_28;
int8 local_20;
uint local_18;
long local_10;
local_30 = param_3;
local_28 = param_2;
local_20 = param_1;
uVar2 = ExecutionState::in_static_mode(param_3);
if ((uVar2 & 1) == 0) {
local_38 = (uint *)StackTop::pop((StackTop *)&local_20);
local_40 = (uint *)StackTop::pop((StackTop *)&local_20);
uVar2 = check_memory(&local_28,(Memory *)(local_30 + 8),local_38,local_40);
if ((uVar2 & 1) == 0) {
local_18 = 3;
local_10 = local_28;
}
else {
local_48 = intx::uint::operator_cast_to_unsigned_long(local_38);
local_50 = intx::uint::operator_cast_to_unsigned_long(local_40);
local_58 = local_50 * 8;
local_28 = local_28 + local_50 * -8;
if (local_28 < 0) {
local_18 = 3;
local_10 = local_28;
}
else {
std::array<evmc::bytes32,3ul>::array(local_b8);
local_c0 = local_b8;
local_c8 = (int8 *)std::array<evmc::bytes32,3ul>::begin(local_c0);
local_d0 = (int8 *)std::array<evmc::bytes32,3ul>::end(local_c0);
for (; local_c8 != local_d0; local_c8 = local_c8 + 4) {
local_d8 = local_c8;
puVar3 = (uint *)StackTop::pop((StackTop *)&local_20);
intx::be::store<evmc::bytes32,intx::uint<256u>>((be *)&local_f8,puVar3);
*local_d8 = local_f8;
local_d8[1] = local_f0;
local_d8[2] = local_e8;
local_d8[3] = local_e0;
}
if (local_50 == 0) {
local_130 = (uchar *)0x0;
}
else {
local_130 = (uchar *)Memory::operator[]((Memory *)(local_30 + 8),local_48);
}
local_100 = local_130;
this = (HostContext *)(local_30 + 0x28);
evmc::address::address(local_114);
uVar2 = local_50;
puVar1 = local_100;
pbVar4 = (bytes32 *)std::array<evmc::bytes32,3ul>::data(local_b8);
evmc::HostContext::emit_log(this,local_114,puVar1,uVar2,pbVar4,3);
local_18 = 0;
local_10 = local_28;
}
}
}
else {
local_18 = 0xb;
local_10 = 0;
}
auVar5._4_4_ = 0;
auVar5._0_4_ = local_18;
auVar5._8_8_ = local_10;
return auVar5;
}
| |
41,626 | rapidcsv::Converter<int>::ToVal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&) const | Andrewchistyakov[P]flashcards_lyc/src/rapidcsv.h | void ToVal(const std::string& pStr, T& pVal) const
{
try
{
if (typeid(T) == typeid(int))
{
pVal = static_cast<T>(std::stoi(pStr));
return;
}
else if (typeid(T) == typeid(long))
{
pVal = static_cast<T>(std::stol(pStr));
return;
}
else if (typeid(T) == typeid(long long))
{
pVal = static_cast<T>(std::stoll(pStr));
return;
}
else if (typeid(T) == typeid(unsigned))
{
pVal = static_cast<T>(std::stoul(pStr));
return;
}
else if (typeid(T) == typeid(unsigned long))
{
pVal = static_cast<T>(std::stoul(pStr));
return;
}
else if (typeid(T) == typeid(unsigned long long))
{
pVal = static_cast<T>(std::stoull(pStr));
return;
}
}
catch (...)
{
if (!mConverterParams.mHasDefaultConverter)
{
throw;
}
else
{
pVal = static_cast<T>(mConverterParams.mDefaultInteger);
return;
}
}
try
{
if (mConverterParams.mNumericLocale)
{
if (typeid(T) == typeid(float))
{
pVal = static_cast<T>(std::stof(pStr));
return;
}
else if (typeid(T) == typeid(double))
{
pVal = static_cast<T>(std::stod(pStr));
return;
}
else if (typeid(T) == typeid(long double))
{
pVal = static_cast<T>(std::stold(pStr));
return;
}
}
else
{
if ((typeid(T) == typeid(float)) ||
(typeid(T) == typeid(double)) ||
(typeid(T) == typeid(long double)))
{
std::istringstream iss(pStr);
iss.imbue(std::locale::classic());
iss >> pVal;
if (iss.fail() || iss.bad() || !iss.eof())
{
throw std::invalid_argument("istringstream: no conversion");
}
return;
}
}
}
catch (...)
{
if (!mConverterParams.mHasDefaultConverter)
{
throw;
}
else
{
pVal = static_cast<T>(mConverterParams.mDefaultFloat);
return;
}
}
if (typeid(T) == typeid(char))
{
pVal = static_cast<T>(pStr[0]);
return;
}
else
{
throw no_converter();
}
} | O3 | c | rapidcsv::Converter<int>::ToVal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq (%rsi), %r12
callq 0xb050
movq %rax, %r15
movl (%rax), %ebp
movl $0x0, (%rax)
movq %rsp, %r13
movq %r12, %rdi
movq %r13, %rsi
movl $0xa, %edx
callq 0xb5c0
cmpq %r12, (%r13)
je 0x1f8e3
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x1f8ef
movl (%r15), %ecx
cmpl $0x22, %ecx
je 0x1f8ef
testl %ecx, %ecx
jne 0x1f8d2
movl %ebp, (%r15)
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ca68(%rip), %rdi # 0x3c352
callq 0xb210
leaq 0x1ca5c(%rip), %rdi # 0x3c352
callq 0xb610
cmpl $0x0, (%r15)
jne 0x1f904
movl %ebp, (%r15)
movq %rax, %rdi
callq 0xb160
movq (%r14), %rax
cmpb $0x0, (%rax)
je 0x1f92c
movl 0x20(%rax), %eax
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb6e0
callq 0xb620
movq %rax, %rbx
callq 0xb6e0
movq %rbx, %rdi
callq 0xb780
movq %rax, %rdi
callq 0x1049a
| _ZNK8rapidcsv9ConverterIiE5ToValERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERi:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdx
mov r14, rdi
mov r12, [rsi]
call ___errno_location
mov r15, rax
mov ebp, [rax]
mov dword ptr [rax], 0
mov r13, rsp
mov rdi, r12
mov rsi, r13
mov edx, 0Ah
call _strtol
cmp [r13+0], r12
jz short loc_1F8E3
movsxd rcx, eax
cmp rcx, rax
jnz short loc_1F8EF
mov ecx, [r15]
cmp ecx, 22h ; '"'
jz short loc_1F8EF
test ecx, ecx
jnz short loc_1F8D2
mov [r15], ebp
loc_1F8D2:
mov [rbx], eax
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1F8E3:
lea rdi, aStoi; "stoi"
call __ZSt24__throw_invalid_argumentPKc; std::__throw_invalid_argument(char const*)
loc_1F8EF:
lea rdi, aStoi; "stoi"
call __ZSt20__throw_out_of_rangePKc; std::__throw_out_of_range(char const*)
cmp dword ptr [r15], 0
jnz short loc_1F904
mov [r15], ebp
loc_1F904:
mov rdi, rax; void *
call ___cxa_begin_catch
mov rax, [r14]
cmp byte ptr [rax], 0
jz short loc_1F92C
mov eax, [rax+20h]
mov [rbx], eax
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp ___cxa_end_catch
loc_1F92C:
call ___cxa_rethrow
mov rbx, rax
call ___cxa_end_catch
mov rdi, rbx
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
| long long rapidcsv::Converter<int>::ToVal(long long a1, long long *a2, _DWORD *a3)
{
long long v3; // rax
long long v5; // r12
int *v6; // r15
int v7; // ebp
long long result; // rax
long long v9; // [rsp-8h] [rbp-38h] BYREF
v9 = v3;
v5 = *a2;
v6 = (int *)__errno_location();
v7 = *v6;
*v6 = 0;
result = strtol(v5, &v9, 10LL);
if ( v9 == v5 )
{
std::__throw_invalid_argument("stoi");
goto LABEL_8;
}
if ( (int)result != result || *v6 == 34 )
LABEL_8:
std::__throw_out_of_range("stoi");
if ( !*v6 )
*v6 = v7;
*a3 = result;
return result;
}
| ToVal:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RDI
MOV R12,qword ptr [RSI]
CALL 0x0010b050
MOV R15,RAX
MOV EBP,dword ptr [RAX]
MOV dword ptr [RAX],0x0
MOV R13,RSP
MOV RDI,R12
MOV RSI,R13
MOV EDX,0xa
CALL 0x0010b5c0
CMP qword ptr [R13],R12
JZ 0x0011f8e3
MOVSXD RCX,EAX
CMP RCX,RAX
JNZ 0x0011f8ef
MOV ECX,dword ptr [R15]
CMP ECX,0x22
JZ 0x0011f8ef
TEST ECX,ECX
JNZ 0x0011f8d2
MOV dword ptr [R15],EBP
LAB_0011f8d2:
MOV dword ptr [RBX],EAX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0011f8e3:
LEA RDI,[0x13c352]
CALL 0x0010b210
LAB_0011f8ef:
LEA RDI,[0x13c352]
CALL 0x0010b610
LAB_0011f8fb:
CMP dword ptr [R15],0x0
JNZ 0x0011f904
MOV dword ptr [R15],EBP
LAB_0011f904:
MOV RDI,RAX
CALL 0x0010b160
MOV RAX,qword ptr [R14]
CMP byte ptr [RAX],0x0
JZ 0x0011f92c
MOV EAX,dword ptr [RAX + 0x20]
MOV dword ptr [RBX],EAX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0010b6e0
LAB_0011f92c:
CALL 0x0010b620
LAB_0011f931:
MOV RBX,RAX
LAB_0011f934:
CALL 0x0010b6e0
LAB_0011f939:
MOV RDI,RBX
CALL 0x0010b780
|
/* rapidcsv::Converter<int>::ToVal(std::__cxx11::string const&, int&) const */
void __thiscall rapidcsv::Converter<int>::ToVal(Converter<int> *this,string *param_1,int *param_2)
{
int iVar1;
char *__nptr;
char *in_RAX;
int *piVar2;
long lVar3;
int8 uVar4;
char *local_38;
__nptr = *(char **)param_1;
local_38 = in_RAX;
piVar2 = __errno_location();
iVar1 = *piVar2;
*piVar2 = 0;
lVar3 = strtol(__nptr,&local_38,10);
if (local_38 == __nptr) {
/* try { // try from 0011f8e3 to 0011f8fa has its CatchHandler @ 0011f8fb */
std::__throw_invalid_argument("stoi");
}
else if (((int)lVar3 == lVar3) && (*piVar2 != 0x22)) {
if (*piVar2 == 0) {
*piVar2 = iVar1;
}
*param_2 = (int)lVar3;
return;
}
uVar4 = std::__throw_out_of_range("stoi");
/* catch(type#1 @ 00000000) { ... } // from try @ 0011f8e3 with catch @ 0011f8fb
*/
if (*piVar2 == 0) {
*piVar2 = iVar1;
}
__cxa_begin_catch(uVar4);
if (**(char **)this != '\0') {
*param_2 = *(int *)(*(char **)this + 0x20);
__cxa_end_catch();
return;
}
/* try { // try from 0011f92c to 0011f930 has its CatchHandler @ 0011f931 */
uVar4 = __cxa_rethrow();
/* catch(type#1 @ 00000000) { ... } // from try @ 0011f92c with catch @ 0011f931
*/
/* try { // try from 0011f934 to 0011f938 has its CatchHandler @ 0011f941 */
__cxa_end_catch();
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar4);
}
| |
41,627 | mi_unique_hash | eloqsql/storage/myisam/mi_unique.c | ha_checksum mi_unique_hash(MI_UNIQUEDEF *def, const uchar *record)
{
const uchar *pos, *end;
ha_checksum crc= 0;
ulong seed1=0, seed2= 4;
HA_KEYSEG *keyseg;
for (keyseg=def->seg ; keyseg < def->end ; keyseg++)
{
enum ha_base_keytype type=(enum ha_base_keytype) keyseg->type;
uint length=keyseg->length;
if (keyseg->null_bit)
{
if (record[keyseg->null_pos] & keyseg->null_bit)
{
/*
Change crc in a way different from an empty string or 0.
(This is an optimisation; The code will work even if this isn't
done)
*/
crc=((crc << 8) + 511+
(crc >> (8*sizeof(ha_checksum)-8)));
continue;
}
}
pos= record+keyseg->start;
if (keyseg->flag & HA_VAR_LENGTH_PART)
{
uint pack_length= keyseg->bit_start;
uint tmp_length= (pack_length == 1 ? (uint) *(uchar*) pos :
uint2korr(pos));
pos+= pack_length; /* Skip VARCHAR length */
set_if_smaller(length,tmp_length);
}
else if (keyseg->flag & HA_BLOB_PART)
{
uint tmp_length=_mi_calc_blob_length(keyseg->bit_start,pos);
memcpy((char**) &pos, pos+keyseg->bit_start, sizeof(char*));
if (!length || length > tmp_length)
length=tmp_length; /* The whole blob */
}
end= pos+length;
if (type == HA_KEYTYPE_TEXT || type == HA_KEYTYPE_VARTEXT1 ||
type == HA_KEYTYPE_VARTEXT2)
{
my_ci_hash_sort(keyseg->charset,
(const uchar*) pos, length,
&seed1, &seed2);
crc^= seed1;
}
else
while (pos != end)
crc=((crc << 8) +
(((uchar) *(uchar*) pos++))) +
(crc >> (8*sizeof(ha_checksum)-8));
}
return crc;
} | O0 | c | mi_unique_hash:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x4, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xc6108
movq -0x40(%rbp), %rax
movzbl 0x18(%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rax
movzwl 0x14(%rax), %eax
movl %eax, -0x48(%rbp)
movq -0x40(%rbp), %rax
cmpb $0x0, 0x19(%rax)
je 0xc5fb0
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movl 0xc(%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x40(%rbp), %rcx
movzbl 0x19(%rcx), %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xc5fae
movl -0x24(%rbp), %eax
shll $0x8, %eax
addl $0x1ff, %eax # imm = 0x1FF
movl -0x24(%rbp), %ecx
shrl $0x18, %ecx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
jmp 0xc60f7
jmp 0xc5fb0
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movl 0x8(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x40(%rbp), %rax
movzwl 0x12(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xc6021
movq -0x40(%rbp), %rax
movzbl 0x1a(%rax), %eax
movl %eax, -0x4c(%rbp)
cmpl $0x1, -0x4c(%rbp)
jne 0xc5fef
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x58(%rbp)
jmp 0xc5ff9
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x58(%rbp)
movl -0x58(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x4c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x50(%rbp), %eax
jbe 0xc601d
movl -0x50(%rbp), %eax
movl %eax, -0x48(%rbp)
jmp 0xc601f
jmp 0xc6074
movq -0x40(%rbp), %rax
movzwl 0x12(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0xc6072
movq -0x40(%rbp), %rax
movzbl 0x1a(%rax), %edi
movq -0x18(%rbp), %rsi
callq 0xac3c0
movl %eax, -0x54(%rbp)
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movzbl 0x1a(%rcx), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x48(%rbp)
je 0xc606a
movl -0x48(%rbp), %eax
cmpl -0x54(%rbp), %eax
jbe 0xc6070
movl -0x54(%rbp), %eax
movl %eax, -0x48(%rbp)
jmp 0xc6072
jmp 0xc6074
movq -0x18(%rbp), %rax
movl -0x48(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpl $0x1, -0x44(%rbp)
je 0xc6094
cmpl $0xf, -0x44(%rbp)
je 0xc6094
cmpl $0x11, -0x44(%rbp)
jne 0xc60c0
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movl -0x48(%rbp), %eax
movl %eax, %edx
leaq -0x30(%rbp), %rcx
leaq -0x38(%rbp), %r8
callq 0xc6120
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
xorq %rcx, %rax
movl %eax, -0x24(%rbp)
jmp 0xc60f5
jmp 0xc60c2
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0xc60f3
movl -0x24(%rbp), %eax
shll $0x8, %eax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movzbl (%rcx), %ecx
addl %ecx, %eax
movl -0x24(%rbp), %ecx
shrl $0x18, %ecx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
jmp 0xc60c2
jmp 0xc60f5
jmp 0xc60f7
movq -0x40(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x40(%rbp)
jmp 0xc5f43
movl -0x24(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| mi_unique_hash:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_24], 0
mov [rbp+var_30], 0
mov [rbp+var_38], 4
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_40], rax
loc_C5F43:
mov rax, [rbp+var_40]
mov rcx, [rbp+var_8]
cmp rax, [rcx+10h]
jnb loc_C6108
mov rax, [rbp+var_40]
movzx eax, byte ptr [rax+18h]
mov [rbp+var_44], eax
mov rax, [rbp+var_40]
movzx eax, word ptr [rax+14h]
mov [rbp+var_48], eax
mov rax, [rbp+var_40]
cmp byte ptr [rax+19h], 0
jz short loc_C5FB0
mov rax, [rbp+var_10]
mov rcx, [rbp+var_40]
mov ecx, [rcx+0Ch]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_40]
movzx ecx, byte ptr [rcx+19h]
and eax, ecx
cmp eax, 0
jz short loc_C5FAE
mov eax, [rbp+var_24]
shl eax, 8
add eax, 1FFh
mov ecx, [rbp+var_24]
shr ecx, 18h
add eax, ecx
mov [rbp+var_24], eax
jmp loc_C60F7
loc_C5FAE:
jmp short $+2
loc_C5FB0:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_40]
mov ecx, [rcx+8]
add rax, rcx
mov [rbp+var_18], rax
mov rax, [rbp+var_40]
movzx eax, word ptr [rax+12h]
and eax, 8
cmp eax, 0
jz short loc_C6021
mov rax, [rbp+var_40]
movzx eax, byte ptr [rax+1Ah]
mov [rbp+var_4C], eax
cmp [rbp+var_4C], 1
jnz short loc_C5FEF
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
mov [rbp+var_58], eax
jmp short loc_C5FF9
loc_C5FEF:
mov rax, [rbp+var_18]
movzx eax, word ptr [rax]
mov [rbp+var_58], eax
loc_C5FF9:
mov eax, [rbp+var_58]
mov [rbp+var_50], eax
mov ecx, [rbp+var_4C]
mov rax, [rbp+var_18]
mov ecx, ecx
add rax, rcx
mov [rbp+var_18], rax
mov eax, [rbp+var_48]
cmp eax, [rbp+var_50]
jbe short loc_C601D
mov eax, [rbp+var_50]
mov [rbp+var_48], eax
loc_C601D:
jmp short $+2
loc_C601F:
jmp short loc_C6074
loc_C6021:
mov rax, [rbp+var_40]
movzx eax, word ptr [rax+12h]
and eax, 20h
cmp eax, 0
jz short loc_C6072
mov rax, [rbp+var_40]
movzx edi, byte ptr [rax+1Ah]
mov rsi, [rbp+var_18]
call _mi_calc_blob_length
mov [rbp+var_54], eax
mov rax, [rbp+var_18]
mov rcx, [rbp+var_40]
movzx ecx, byte ptr [rcx+1Ah]
movsxd rcx, ecx
mov rax, [rax+rcx]
mov [rbp+var_18], rax
cmp [rbp+var_48], 0
jz short loc_C606A
mov eax, [rbp+var_48]
cmp eax, [rbp+var_54]
jbe short loc_C6070
loc_C606A:
mov eax, [rbp+var_54]
mov [rbp+var_48], eax
loc_C6070:
jmp short $+2
loc_C6072:
jmp short $+2
loc_C6074:
mov rax, [rbp+var_18]
mov ecx, [rbp+var_48]
add rax, rcx
mov [rbp+var_20], rax
cmp [rbp+var_44], 1
jz short loc_C6094
cmp [rbp+var_44], 0Fh
jz short loc_C6094
cmp [rbp+var_44], 11h
jnz short loc_C60C0
loc_C6094:
mov rax, [rbp+var_40]
mov rdi, [rax]
mov rsi, [rbp+var_18]
mov eax, [rbp+var_48]
mov edx, eax
lea rcx, [rbp+var_30]
lea r8, [rbp+var_38]
call my_ci_hash_sort_0
mov rcx, [rbp+var_30]
mov eax, [rbp+var_24]
xor rax, rcx
mov [rbp+var_24], eax
jmp short loc_C60F5
loc_C60C0:
jmp short $+2
loc_C60C2:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jz short loc_C60F3
mov eax, [rbp+var_24]
shl eax, 8
mov rcx, [rbp+var_18]
mov rdx, rcx
add rdx, 1
mov [rbp+var_18], rdx
movzx ecx, byte ptr [rcx]
add eax, ecx
mov ecx, [rbp+var_24]
shr ecx, 18h
add eax, ecx
mov [rbp+var_24], eax
jmp short loc_C60C2
loc_C60F3:
jmp short $+2
loc_C60F5:
jmp short $+2
loc_C60F7:
mov rax, [rbp+var_40]
add rax, 20h ; ' '
mov [rbp+var_40], rax
jmp loc_C5F43
loc_C6108:
mov eax, [rbp+var_24]
add rsp, 60h
pop rbp
retn
| long long mi_unique_hash(long long a1, long long a2)
{
unsigned __int8 *v2; // rcx
unsigned int v4; // [rsp+8h] [rbp-58h]
unsigned int v5; // [rsp+Ch] [rbp-54h]
unsigned int v6; // [rsp+18h] [rbp-48h]
int v7; // [rsp+1Ch] [rbp-44h]
unsigned long long i; // [rsp+20h] [rbp-40h]
long long v9; // [rsp+28h] [rbp-38h] BYREF
long long v10; // [rsp+30h] [rbp-30h] BYREF
unsigned int v11; // [rsp+3Ch] [rbp-24h]
unsigned __int8 *v12; // [rsp+40h] [rbp-20h]
unsigned __int8 *v13; // [rsp+48h] [rbp-18h]
long long v14; // [rsp+50h] [rbp-10h]
long long v15; // [rsp+58h] [rbp-8h]
v15 = a1;
v14 = a2;
v11 = 0;
v10 = 0LL;
v9 = 4LL;
for ( i = *(_QWORD *)(a1 + 8); i < *(_QWORD *)(v15 + 16); i += 32LL )
{
v7 = *(unsigned __int8 *)(i + 24);
v6 = *(unsigned __int16 *)(i + 20);
if ( *(_BYTE *)(i + 25) && (*(_BYTE *)(i + 25) & *(_BYTE *)(v14 + *(unsigned int *)(i + 12))) != 0 )
{
v11 = HIBYTE(v11) + (v11 << 8) + 511;
}
else
{
v13 = (unsigned __int8 *)(*(unsigned int *)(i + 8) + v14);
if ( (*(_WORD *)(i + 18) & 8) != 0 )
{
if ( *(_BYTE *)(i + 26) == 1 )
v4 = *v13;
else
v4 = *(unsigned __int16 *)v13;
v13 += *(unsigned __int8 *)(i + 26);
if ( v6 > v4 )
v6 = v4;
}
else if ( (*(_WORD *)(i + 18) & 0x20) != 0 )
{
v5 = mi_calc_blob_length(*(unsigned __int8 *)(i + 26), v13);
v13 = *(unsigned __int8 **)&v13[*(unsigned __int8 *)(i + 26)];
if ( !v6 || v6 > v5 )
v6 = v5;
}
v12 = &v13[v6];
if ( v7 == 1 || v7 == 15 || v7 == 17 )
{
my_ci_hash_sort_0(*(_QWORD *)i, v13, v6, &v10, &v9);
v11 ^= v10;
}
else
{
while ( v13 != v12 )
{
v2 = v13++;
v11 = HIBYTE(v11) + *v2 + (v11 << 8);
}
}
}
}
return v11;
}
| mi_unique_hash:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x24],0x0
MOV qword ptr [RBP + -0x30],0x0
MOV qword ptr [RBP + -0x38],0x4
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x40],RAX
LAB_001c5f43:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x10]
JNC 0x001c6108
MOV RAX,qword ptr [RBP + -0x40]
MOVZX EAX,byte ptr [RAX + 0x18]
MOV dword ptr [RBP + -0x44],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOVZX EAX,word ptr [RAX + 0x14]
MOV dword ptr [RBP + -0x48],EAX
MOV RAX,qword ptr [RBP + -0x40]
CMP byte ptr [RAX + 0x19],0x0
JZ 0x001c5fb0
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RCX + 0xc]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x40]
MOVZX ECX,byte ptr [RCX + 0x19]
AND EAX,ECX
CMP EAX,0x0
JZ 0x001c5fae
MOV EAX,dword ptr [RBP + -0x24]
SHL EAX,0x8
ADD EAX,0x1ff
MOV ECX,dword ptr [RBP + -0x24]
SHR ECX,0x18
ADD EAX,ECX
MOV dword ptr [RBP + -0x24],EAX
JMP 0x001c60f7
LAB_001c5fae:
JMP 0x001c5fb0
LAB_001c5fb0:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RCX + 0x8]
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOVZX EAX,word ptr [RAX + 0x12]
AND EAX,0x8
CMP EAX,0x0
JZ 0x001c6021
MOV RAX,qword ptr [RBP + -0x40]
MOVZX EAX,byte ptr [RAX + 0x1a]
MOV dword ptr [RBP + -0x4c],EAX
CMP dword ptr [RBP + -0x4c],0x1
JNZ 0x001c5fef
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x58],EAX
JMP 0x001c5ff9
LAB_001c5fef:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX]
MOV dword ptr [RBP + -0x58],EAX
LAB_001c5ff9:
MOV EAX,dword ptr [RBP + -0x58]
MOV dword ptr [RBP + -0x50],EAX
MOV ECX,dword ptr [RBP + -0x4c]
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV EAX,dword ptr [RBP + -0x48]
CMP EAX,dword ptr [RBP + -0x50]
JBE 0x001c601d
MOV EAX,dword ptr [RBP + -0x50]
MOV dword ptr [RBP + -0x48],EAX
LAB_001c601d:
JMP 0x001c601f
LAB_001c601f:
JMP 0x001c6074
LAB_001c6021:
MOV RAX,qword ptr [RBP + -0x40]
MOVZX EAX,word ptr [RAX + 0x12]
AND EAX,0x20
CMP EAX,0x0
JZ 0x001c6072
MOV RAX,qword ptr [RBP + -0x40]
MOVZX EDI,byte ptr [RAX + 0x1a]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001ac3c0
MOV dword ptr [RBP + -0x54],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x40]
MOVZX ECX,byte ptr [RCX + 0x1a]
MOVSXD RCX,ECX
MOV RAX,qword ptr [RAX + RCX*0x1]
MOV qword ptr [RBP + -0x18],RAX
CMP dword ptr [RBP + -0x48],0x0
JZ 0x001c606a
MOV EAX,dword ptr [RBP + -0x48]
CMP EAX,dword ptr [RBP + -0x54]
JBE 0x001c6070
LAB_001c606a:
MOV EAX,dword ptr [RBP + -0x54]
MOV dword ptr [RBP + -0x48],EAX
LAB_001c6070:
JMP 0x001c6072
LAB_001c6072:
JMP 0x001c6074
LAB_001c6074:
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x48]
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
CMP dword ptr [RBP + -0x44],0x1
JZ 0x001c6094
CMP dword ptr [RBP + -0x44],0xf
JZ 0x001c6094
CMP dword ptr [RBP + -0x44],0x11
JNZ 0x001c60c0
LAB_001c6094:
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x48]
MOV EDX,EAX
LEA RCX,[RBP + -0x30]
LEA R8,[RBP + -0x38]
CALL 0x001c6120
MOV RCX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RBP + -0x24]
XOR RAX,RCX
MOV dword ptr [RBP + -0x24],EAX
JMP 0x001c60f5
LAB_001c60c0:
JMP 0x001c60c2
LAB_001c60c2:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x001c60f3
MOV EAX,dword ptr [RBP + -0x24]
SHL EAX,0x8
MOV RCX,qword ptr [RBP + -0x18]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
MOVZX ECX,byte ptr [RCX]
ADD EAX,ECX
MOV ECX,dword ptr [RBP + -0x24]
SHR ECX,0x18
ADD EAX,ECX
MOV dword ptr [RBP + -0x24],EAX
JMP 0x001c60c2
LAB_001c60f3:
JMP 0x001c60f5
LAB_001c60f5:
JMP 0x001c60f7
LAB_001c60f7:
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x20
MOV qword ptr [RBP + -0x40],RAX
JMP 0x001c5f43
LAB_001c6108:
MOV EAX,dword ptr [RBP + -0x24]
ADD RSP,0x60
POP RBP
RET
|
uint mi_unique_hash(long param_1,long param_2)
{
char cVar1;
uint uVar2;
uint local_60;
uint local_50;
int8 *local_48;
int8 local_40;
int8 local_38;
uint local_2c;
ushort *local_28;
ushort *local_20;
long local_18;
long local_10;
local_2c = 0;
local_38 = 0;
local_40 = 4;
local_18 = param_2;
local_10 = param_1;
for (local_48 = *(int8 **)(param_1 + 8); local_48 < *(int8 **)(local_10 + 0x10);
local_48 = local_48 + 4) {
cVar1 = *(char *)(local_48 + 3);
local_50 = (uint)*(ushort *)((long)local_48 + 0x14);
if ((*(char *)((long)local_48 + 0x19) == '\0') ||
((*(byte *)(local_18 + (ulong)*(uint *)((long)local_48 + 0xc)) &
*(byte *)((long)local_48 + 0x19)) == 0)) {
local_20 = (ushort *)(local_18 + (ulong)*(uint *)(local_48 + 1));
if ((*(ushort *)((long)local_48 + 0x12) & 8) == 0) {
if ((*(ushort *)((long)local_48 + 0x12) & 0x20) != 0) {
uVar2 = _mi_calc_blob_length(*(int1 *)((long)local_48 + 0x1a),local_20);
local_20 = *(ushort **)
((long)local_20 + (long)(int)(uint)*(byte *)((long)local_48 + 0x1a));
if ((local_50 == 0) || (uVar2 < local_50)) {
local_50 = uVar2;
}
}
}
else {
if (*(byte *)((long)local_48 + 0x1a) == 1) {
local_60 = (uint)(byte)*local_20;
}
else {
local_60 = (uint)*local_20;
}
local_20 = (ushort *)((long)local_20 + (ulong)(uint)*(byte *)((long)local_48 + 0x1a));
if (local_60 < local_50) {
local_50 = local_60;
}
}
local_28 = (ushort *)((long)local_20 + (ulong)local_50);
if (((cVar1 == '\x01') || (cVar1 == '\x0f')) || (cVar1 == '\x11')) {
my_ci_hash_sort(*local_48,local_20,local_50,&local_38,&local_40);
local_2c = local_2c ^ (uint)local_38;
}
else {
for (; local_20 != local_28; local_20 = (ushort *)((long)local_20 + 1)) {
local_2c = local_2c * 0x100 + (uint)(byte)*local_20 + (local_2c >> 0x18);
}
}
}
else {
local_2c = local_2c * 0x100 + 0x1ff + (local_2c >> 0x18);
}
}
return local_2c;
}
| |
41,628 | mi_readinfo | eloqsql/storage/myisam/mi_locking.c | int _mi_readinfo(register MI_INFO *info, int lock_type, int check_keybuffer)
{
DBUG_ENTER("_mi_readinfo");
if (info->lock_type == F_UNLCK)
{
MYISAM_SHARE *share=info->s;
if (!share->tot_locks)
{
if (my_lock(share->kfile,lock_type,0L,F_TO_EOF,
info->lock_wait | MY_SEEK_NOT_DONE))
DBUG_RETURN(1);
if (mi_state_info_read_dsk(share->kfile, &share->state, 1))
{
int error= my_errno ? my_errno : HA_ERR_FILE_TOO_SHORT;
(void) my_lock(share->kfile,F_UNLCK,0L,F_TO_EOF,
MYF(MY_SEEK_NOT_DONE));
my_errno= error;
DBUG_RETURN(1);
}
}
if (check_keybuffer)
(void) _mi_test_if_changed(info);
info->invalidator=info->s->invalidator;
}
else if (lock_type == F_WRLCK && info->lock_type == F_RDLCK)
{
my_errno=EACCES; /* Not allowed to change */
DBUG_RETURN(-1); /* when have read_lock() */
}
DBUG_RETURN(0);
} | O3 | c | mi_readinfo:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x1f4(%rdi), %ecx
cmpl $0x2, %ecx
jne 0x7c65b
movl %edx, %r15d
movq %rdi, %r14
movq (%rdi), %rbx
cmpl $0x0, 0x368(%rbx)
je 0x7c67a
testl %r15d, %r15d
je 0x7c643
movq %r14, %rdi
callq 0x7c40a
movq (%r14), %rax
movq 0x2f0(%rax), %rax
movq %rax, 0x148(%r14)
xorl %eax, %eax
jmp 0x7c6f7
xorl $0x1, %esi
xorl %eax, %eax
orl %ecx, %esi
jne 0x7c6f7
callq 0xa1ab2
movl $0xd, (%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x7c6f7
movl 0x350(%rbx), %edi
movq 0x330(%r14), %r8
orq $0x20, %r8
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x9fae4
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x7c6f7
movl 0x350(%rbx), %edi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x7ff90
testl %eax, %eax
je 0x7c636
callq 0xa1ab2
cmpl $0x0, (%rax)
je 0x7c6ca
callq 0xa1ab2
movl (%rax), %r14d
jmp 0x7c6d0
movl $0xaf, %r14d
movl 0x350(%rbx), %edi
movl $0x20, %r8d
movl $0x2, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x9fae4
callq 0xa1ab2
movl %r14d, (%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| _mi_readinfo:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov ecx, [rdi+1F4h]
cmp ecx, 2
jnz short loc_7C65B
mov r15d, edx
mov r14, rdi
mov rbx, [rdi]
cmp dword ptr [rbx+368h], 0
jz short loc_7C67A
loc_7C636:
test r15d, r15d
jz short loc_7C643
mov rdi, r14
call _mi_test_if_changed
loc_7C643:
mov rax, [r14]
mov rax, [rax+2F0h]
mov [r14+148h], rax
xor eax, eax
jmp loc_7C6F7
loc_7C65B:
xor esi, 1
xor eax, eax
or esi, ecx
jnz loc_7C6F7
call _my_thread_var
mov dword ptr [rax], 0Dh
mov eax, 0FFFFFFFFh
jmp short loc_7C6F7
loc_7C67A:
mov edi, [rbx+350h]
mov r8, [r14+330h]
or r8, 20h
xor edx, edx
xor ecx, ecx
call my_lock
mov ecx, eax
mov eax, 1
test ecx, ecx
jnz short loc_7C6F7
mov edi, [rbx+350h]
mov rsi, rbx
mov edx, 1
call mi_state_info_read_dsk
test eax, eax
jz short loc_7C636
call _my_thread_var
cmp dword ptr [rax], 0
jz short loc_7C6CA
call _my_thread_var
mov r14d, [rax]
jmp short loc_7C6D0
loc_7C6CA:
mov r14d, 0AFh
loc_7C6D0:
mov edi, [rbx+350h]
mov r8d, 20h ; ' '
mov esi, 2
xor edx, edx
xor ecx, ecx
call my_lock
call _my_thread_var
mov [rax], r14d
mov eax, 1
loc_7C6F7:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long mi_readinfo(long long *a1, long long a2, int a3)
{
int v3; // ecx
long long v6; // rbx
long long result; // rax
int v8; // ecx
long long v9; // rdi
int v10; // r14d
long long v11; // rdi
v3 = *((_DWORD *)a1 + 125);
if ( v3 == 2 )
{
v6 = *a1;
if ( *(_DWORD *)(*a1 + 872) )
goto LABEL_3;
v8 = my_lock(*(unsigned int *)(v6 + 848), a2, 0LL, 0LL, a1[102] | 0x20);
result = 1LL;
if ( v8 )
return result;
v9 = *(unsigned int *)(v6 + 848);
if ( !(unsigned int)mi_state_info_read_dsk(v9, v6, 1LL) )
{
LABEL_3:
if ( a3 )
mi_test_if_changed(a1);
a1[41] = *(_QWORD *)(*a1 + 752);
return 0LL;
}
else
{
if ( *(_DWORD *)my_thread_var(v9) )
v10 = *(_DWORD *)my_thread_var(v9);
else
v10 = 175;
v11 = *(unsigned int *)(v6 + 848);
my_lock(v11, 2LL, 0LL, 0LL, 32LL);
*(_DWORD *)my_thread_var(v11) = v10;
return 1LL;
}
}
else
{
result = 0LL;
if ( !(v3 | (unsigned int)a2 ^ 1) )
{
*(_DWORD *)my_thread_var(a1) = 13;
return 0xFFFFFFFFLL;
}
}
return result;
}
| _mi_readinfo:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV ECX,dword ptr [RDI + 0x1f4]
CMP ECX,0x2
JNZ 0x0017c65b
MOV R15D,EDX
MOV R14,RDI
MOV RBX,qword ptr [RDI]
CMP dword ptr [RBX + 0x368],0x0
JZ 0x0017c67a
LAB_0017c636:
TEST R15D,R15D
JZ 0x0017c643
MOV RDI,R14
CALL 0x0017c40a
LAB_0017c643:
MOV RAX,qword ptr [R14]
MOV RAX,qword ptr [RAX + 0x2f0]
MOV qword ptr [R14 + 0x148],RAX
XOR EAX,EAX
JMP 0x0017c6f7
LAB_0017c65b:
XOR ESI,0x1
XOR EAX,EAX
OR ESI,ECX
JNZ 0x0017c6f7
CALL 0x001a1ab2
MOV dword ptr [RAX],0xd
MOV EAX,0xffffffff
JMP 0x0017c6f7
LAB_0017c67a:
MOV EDI,dword ptr [RBX + 0x350]
MOV R8,qword ptr [R14 + 0x330]
OR R8,0x20
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0019fae4
MOV ECX,EAX
MOV EAX,0x1
TEST ECX,ECX
JNZ 0x0017c6f7
MOV EDI,dword ptr [RBX + 0x350]
MOV RSI,RBX
MOV EDX,0x1
CALL 0x0017ff90
TEST EAX,EAX
JZ 0x0017c636
CALL 0x001a1ab2
CMP dword ptr [RAX],0x0
JZ 0x0017c6ca
CALL 0x001a1ab2
MOV R14D,dword ptr [RAX]
JMP 0x0017c6d0
LAB_0017c6ca:
MOV R14D,0xaf
LAB_0017c6d0:
MOV EDI,dword ptr [RBX + 0x350]
MOV R8D,0x20
MOV ESI,0x2
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0019fae4
CALL 0x001a1ab2
MOV dword ptr [RAX],R14D
MOV EAX,0x1
LAB_0017c6f7:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int8 _mi_readinfo(long *param_1,int8 param_2,int param_3)
{
long lVar1;
int iVar2;
int *piVar3;
int4 *puVar4;
int4 uVar5;
if (*(int *)((long)param_1 + 500) != 2) {
if ((int)param_2 != 1 || *(int *)((long)param_1 + 500) != 0) {
return 0;
}
puVar4 = (int4 *)_my_thread_var();
*puVar4 = 0xd;
return 0xffffffff;
}
lVar1 = *param_1;
if (*(int *)(lVar1 + 0x368) == 0) {
iVar2 = my_lock(*(int4 *)(lVar1 + 0x350),param_2,0,0,param_1[0x66] | 0x20);
if (iVar2 != 0) {
return 1;
}
iVar2 = mi_state_info_read_dsk(*(int4 *)(lVar1 + 0x350),lVar1,1);
if (iVar2 != 0) {
piVar3 = (int *)_my_thread_var();
if (*piVar3 == 0) {
uVar5 = 0xaf;
}
else {
puVar4 = (int4 *)_my_thread_var();
uVar5 = *puVar4;
}
my_lock(*(int4 *)(lVar1 + 0x350),2,0,0,0x20);
puVar4 = (int4 *)_my_thread_var();
*puVar4 = uVar5;
return 1;
}
}
if (param_3 != 0) {
_mi_test_if_changed(param_1);
}
param_1[0x29] = *(long *)(*param_1 + 0x2f0);
return 0;
}
| |
41,629 | maria_init_bulk_insert | eloqsql/storage/maria/ma_write.c | int maria_init_bulk_insert(MARIA_HA *info, size_t cache_size, ha_rows rows)
{
MARIA_SHARE *share= info->s;
MARIA_KEYDEF *key=share->keyinfo;
bulk_insert_param *params;
uint i, num_keys, total_keylength;
ulonglong key_map;
DBUG_ENTER("_ma_init_bulk_insert");
DBUG_PRINT("enter",("cache_size: %lu", (ulong) cache_size));
DBUG_ASSERT(!info->bulk_insert &&
(!rows || rows >= MARIA_MIN_ROWS_TO_USE_BULK_INSERT));
maria_clear_all_keys_active(key_map);
for (i=total_keylength=num_keys=0 ; i < share->base.keys ; i++)
{
if (! (key[i].flag & HA_NOSAME) && (share->base.auto_key != i + 1) &&
maria_is_key_active(share->state.key_map, i))
{
num_keys++;
maria_set_key_active(key_map, i);
total_keylength+=key[i].maxlength+TREE_ELEMENT_EXTRA_SIZE;
}
}
if (num_keys==0 ||
num_keys * (size_t) MARIA_MIN_SIZE_BULK_INSERT_TREE > cache_size)
DBUG_RETURN(0);
if (rows && rows*total_keylength < cache_size)
cache_size= (size_t)rows;
else
cache_size/=total_keylength*16;
info->bulk_insert=(TREE *)
my_malloc(PSI_INSTRUMENT_ME, (sizeof(TREE)*share->base.keys+
sizeof(bulk_insert_param)*num_keys),MYF(0));
if (!info->bulk_insert)
DBUG_RETURN(HA_ERR_OUT_OF_MEM);
params=(bulk_insert_param *)(info->bulk_insert+share->base.keys);
for (i=0 ; i < share->base.keys ; i++)
{
if (maria_is_key_active(key_map, i))
{
params->info=info;
params->keynr=i;
/* Only allocate a 16'th of the buffer at a time */
init_tree(&info->bulk_insert[i],
cache_size * key[i].maxlength,
cache_size * key[i].maxlength, 0,
(qsort_cmp2) keys_compare, keys_free, (void *)params++, MYF(0));
}
else
info->bulk_insert[i].root=0;
}
DBUG_RETURN(0);
} | O0 | c | maria_init_bulk_insert:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x570(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x66c20
jmp 0x66c22
jmp 0x66c24
movq $0x0, -0x50(%rbp)
movl $0x0, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x3e8(%rcx), %eax
jae 0x66d13
movq -0x30(%rbp), %rax
movl -0x3c(%rbp), %ecx
imulq $0x118, %rcx, %rcx # imm = 0x118
addq %rcx, %rax
movzwl 0xa2(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x66d03
movq -0x28(%rbp), %rax
movl 0x3ec(%rax), %eax
movl -0x3c(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
je 0x66d03
movq -0x28(%rbp), %rax
movq 0x140(%rax), %rax
movl -0x3c(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x66cb6
movb $0x1, %al
testb $0x1, %al
jne 0x66cbe
jmp 0x66d03
xorl %eax, %eax
testb $0x1, %al
jne 0x66cbe
jmp 0x66d03
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
orq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
movl -0x3c(%rbp), %ecx
imulq $0x118, %rcx, %rcx # imm = 0x118
addq %rcx, %rax
movzwl 0xae(%rax), %eax
movl %eax, %ecx
addq $0x20, %rcx
movl -0x44(%rbp), %eax
addq %rcx, %rax
movl %eax, -0x44(%rbp)
jmp 0x66d05
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x66c41
cmpl $0x0, -0x40(%rbp)
je 0x66d26
movl -0x40(%rbp), %eax
shlq $0xe, %rax
cmpq -0x18(%rbp), %rax
jbe 0x66d34
jmp 0x66d28
movl $0x0, -0x4(%rbp)
jmp 0x66f06
cmpq $0x0, -0x20(%rbp)
je 0x66d56
movq -0x20(%rbp), %rax
movl -0x44(%rbp), %ecx
imulq %rcx, %rax
cmpq -0x18(%rbp), %rax
jae 0x66d56
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x66d6d
movl -0x44(%rbp), %eax
shll $0x4, %eax
movl %eax, %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movl 0x3e8(%rax), %eax
imulq $0x298, %rax, %rsi # imm = 0x298
movl -0x40(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rsi
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0xf9ff0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x310(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x310(%rax)
jne 0x66dbd
jmp 0x66db1
movl $0x80, -0x4(%rbp)
jmp 0x66f06
movq -0x10(%rbp), %rax
movq 0x310(%rax), %rax
movq -0x28(%rbp), %rcx
movl 0x3e8(%rcx), %ecx
imulq $0x298, %rcx, %rcx # imm = 0x298
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x3e8(%rcx), %eax
jae 0x66efd
movq -0x50(%rbp), %rax
movl -0x3c(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x66e20
movb $0x1, %al
testb $0x1, %al
jne 0x66e2b
jmp 0x66ece
xorl %eax, %eax
testb $0x1, %al
jne 0x66e2b
jmp 0x66ece
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movl -0x3c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x310(%rax), %rdi
movl -0x3c(%rbp), %eax
imulq $0x298, %rax, %rax # imm = 0x298
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rax
movl -0x3c(%rbp), %ecx
imulq $0x118, %rcx, %rcx # imm = 0x118
addq %rcx, %rax
movzwl 0xae(%rax), %eax
imulq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rax
movl -0x3c(%rbp), %ecx
imulq $0x118, %rcx, %rcx # imm = 0x118
addq %rcx, %rax
movzwl 0xae(%rax), %eax
imulq %rax, %rdx
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x38(%rbp)
xorl %ecx, %ecx
leaq 0x60(%rip), %r8 # 0x66f10
leaq 0xb9(%rip), %r9 # 0x66f70
xorl %r10d, %r10d
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x100c90
jmp 0x66eed
movq -0x10(%rbp), %rax
movq 0x310(%rax), %rax
movl -0x3c(%rbp), %ecx
imulq $0x298, %rcx, %rcx # imm = 0x298
addq %rcx, %rax
movq $0x0, (%rax)
jmp 0x66eef
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x66de7
jmp 0x66eff
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
| maria_init_bulk_insert:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov rax, [rax+570h]
mov [rbp+var_30], rax
jmp short $+2
loc_66C20:
jmp short $+2
loc_66C22:
jmp short $+2
loc_66C24:
mov [rbp+var_50], 0
mov [rbp+var_40], 0
mov [rbp+var_44], 0
mov [rbp+var_3C], 0
loc_66C41:
mov eax, [rbp+var_3C]
mov rcx, [rbp+var_28]
cmp eax, [rcx+3E8h]
jnb loc_66D13
mov rax, [rbp+var_30]
mov ecx, [rbp+var_3C]
imul rcx, 118h
add rax, rcx
movzx eax, word ptr [rax+0A2h]
and eax, 1
cmp eax, 0
jnz loc_66D03
mov rax, [rbp+var_28]
mov eax, [rax+3ECh]
mov ecx, [rbp+var_3C]
add ecx, 1
cmp eax, ecx
jz short loc_66D03
mov rax, [rbp+var_28]
mov rax, [rax+140h]
mov ecx, [rbp+var_3C]
mov edx, 1
shl rdx, cl
mov rcx, rdx
and rax, rcx
cmp rax, 0
jz short loc_66CB6
mov al, 1
test al, 1
jnz short loc_66CBE
jmp short loc_66D03
loc_66CB6:
xor eax, eax
test al, 1
jnz short loc_66CBE
jmp short loc_66D03
loc_66CBE:
mov eax, [rbp+var_40]
add eax, 1
mov [rbp+var_40], eax
mov eax, [rbp+var_3C]
mov ecx, eax
mov eax, 1
shl rax, cl
or rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_30]
mov ecx, [rbp+var_3C]
imul rcx, 118h
add rax, rcx
movzx eax, word ptr [rax+0AEh]
mov ecx, eax
add rcx, 20h ; ' '
mov eax, [rbp+var_44]
add rax, rcx
mov [rbp+var_44], eax
loc_66D03:
jmp short $+2
loc_66D05:
mov eax, [rbp+var_3C]
add eax, 1
mov [rbp+var_3C], eax
jmp loc_66C41
loc_66D13:
cmp [rbp+var_40], 0
jz short loc_66D26
mov eax, [rbp+var_40]
shl rax, 0Eh
cmp rax, [rbp+var_18]
jbe short loc_66D34
loc_66D26:
jmp short $+2
loc_66D28:
mov [rbp+var_4], 0
jmp loc_66F06
loc_66D34:
cmp [rbp+var_20], 0
jz short loc_66D56
mov rax, [rbp+var_20]
mov ecx, [rbp+var_44]
imul rax, rcx
cmp rax, [rbp+var_18]
jnb short loc_66D56
mov rax, [rbp+var_20]
mov [rbp+var_18], rax
jmp short loc_66D6D
loc_66D56:
mov eax, [rbp+var_44]
shl eax, 4
mov eax, eax
mov ecx, eax
mov rax, [rbp+var_18]
xor edx, edx
div rcx
mov [rbp+var_18], rax
loc_66D6D:
mov rax, [rbp+var_28]
mov eax, [rax+3E8h]
imul rsi, rax, 298h
mov eax, [rbp+var_40]
shl rax, 4
add rsi, rax
xor edi, edi
xor eax, eax
mov edx, eax
call my_malloc
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+310h], rcx
mov rax, [rbp+var_10]
cmp qword ptr [rax+310h], 0
jnz short loc_66DBD
jmp short $+2
loc_66DB1:
mov [rbp+var_4], 80h
jmp loc_66F06
loc_66DBD:
mov rax, [rbp+var_10]
mov rax, [rax+310h]
mov rcx, [rbp+var_28]
mov ecx, [rcx+3E8h]
imul rcx, 298h
add rax, rcx
mov [rbp+var_38], rax
mov [rbp+var_3C], 0
loc_66DE7:
mov eax, [rbp+var_3C]
mov rcx, [rbp+var_28]
cmp eax, [rcx+3E8h]
jnb loc_66EFD
mov rax, [rbp+var_50]
mov ecx, [rbp+var_3C]
mov edx, 1
shl rdx, cl
mov rcx, rdx
and rax, rcx
cmp rax, 0
jz short loc_66E20
mov al, 1
test al, 1
jnz short loc_66E2B
jmp loc_66ECE
loc_66E20:
xor eax, eax
test al, 1
jnz short loc_66E2B
jmp loc_66ECE
loc_66E2B:
mov rcx, [rbp+var_10]
mov rax, [rbp+var_38]
mov [rax], rcx
mov ecx, [rbp+var_3C]
mov rax, [rbp+var_38]
mov [rax+8], ecx
mov rax, [rbp+var_10]
mov rdi, [rax+310h]
mov eax, [rbp+var_3C]
imul rax, 298h
add rdi, rax
mov rsi, [rbp+var_18]
mov rax, [rbp+var_30]
mov ecx, [rbp+var_3C]
imul rcx, 118h
add rax, rcx
movzx eax, word ptr [rax+0AEh]
imul rsi, rax
mov rdx, [rbp+var_18]
mov rax, [rbp+var_30]
mov ecx, [rbp+var_3C]
imul rcx, 118h
add rax, rcx
movzx eax, word ptr [rax+0AEh]
imul rdx, rax
mov rax, [rbp+var_38]
mov rcx, rax
add rcx, 10h
mov [rbp+var_38], rcx
xor ecx, ecx
lea r8, keys_compare
lea r9, keys_free
xor r10d, r10d
mov [rsp+60h+var_60], rax
mov [rsp+60h+var_58], 0
call init_tree
jmp short loc_66EED
loc_66ECE:
mov rax, [rbp+var_10]
mov rax, [rax+310h]
mov ecx, [rbp+var_3C]
imul rcx, 298h
add rax, rcx
mov qword ptr [rax], 0
loc_66EED:
jmp short $+2
loc_66EEF:
mov eax, [rbp+var_3C]
add eax, 1
mov [rbp+var_3C], eax
jmp loc_66DE7
loc_66EFD:
jmp short $+2
loc_66EFF:
mov [rbp+var_4], 0
loc_66F06:
mov eax, [rbp+var_4]
add rsp, 60h
pop rbp
retn
| long long maria_init_bulk_insert(_QWORD *a1, unsigned long long a2, long long a3)
{
long long v3; // rax
long long v5; // [rsp+10h] [rbp-50h]
unsigned int v6; // [rsp+1Ch] [rbp-44h]
unsigned int v7; // [rsp+20h] [rbp-40h]
unsigned int i; // [rsp+24h] [rbp-3Ch]
unsigned int j; // [rsp+24h] [rbp-3Ch]
long long v10; // [rsp+28h] [rbp-38h]
long long v11; // [rsp+30h] [rbp-30h]
long long v12; // [rsp+38h] [rbp-28h]
unsigned long long v13; // [rsp+48h] [rbp-18h]
v12 = *a1;
v11 = *(_QWORD *)(*a1 + 1392LL);
v5 = 0LL;
v7 = 0;
v6 = 0;
for ( i = 0; i < *(_DWORD *)(v12 + 1000); ++i )
{
if ( (*(_WORD *)(280LL * i + v11 + 162) & 1) == 0
&& *(_DWORD *)(v12 + 1004) != i + 1
&& ((1LL << i) & *(_QWORD *)(v12 + 320)) != 0 )
{
++v7;
v5 |= 1LL << i;
v6 += *(unsigned __int16 *)(280LL * i + v11 + 174) + 32;
}
}
if ( v7 && (unsigned long long)v7 << 14 <= a2 )
{
if ( a3 && (unsigned long long)v6 * a3 < a2 )
LODWORD(v13) = a3;
else
v13 = a2 / (16 * v6);
a1[98] = my_malloc(0LL, 16LL * v7 + 664LL * *(unsigned int *)(v12 + 1000), 0LL);
if ( a1[98] )
{
v10 = 664LL * *(unsigned int *)(v12 + 1000) + a1[98];
for ( j = 0; j < *(_DWORD *)(v12 + 1000); ++j )
{
if ( ((1LL << j) & v5) != 0 )
{
*(_QWORD *)v10 = a1;
*(_DWORD *)(v10 + 8) = j;
v3 = v10;
v10 += 16LL;
init_tree(
664 * j + *((_DWORD *)a1 + 196),
*(unsigned __int16 *)(280LL * j + v11 + 174) * (_DWORD)v13,
*(unsigned __int16 *)(280LL * j + v11 + 174) * (_DWORD)v13,
0,
(unsigned int)keys_compare,
(unsigned int)keys_free,
v3,
0LL);
}
else
{
*(_QWORD *)(664LL * j + a1[98]) = 0LL;
}
}
return 0;
}
else
{
return 128;
}
}
else
{
return 0;
}
}
| maria_init_bulk_insert:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x570]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00166c20
LAB_00166c20:
JMP 0x00166c22
LAB_00166c22:
JMP 0x00166c24
LAB_00166c24:
MOV qword ptr [RBP + -0x50],0x0
MOV dword ptr [RBP + -0x40],0x0
MOV dword ptr [RBP + -0x44],0x0
MOV dword ptr [RBP + -0x3c],0x0
LAB_00166c41:
MOV EAX,dword ptr [RBP + -0x3c]
MOV RCX,qword ptr [RBP + -0x28]
CMP EAX,dword ptr [RCX + 0x3e8]
JNC 0x00166d13
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RBP + -0x3c]
IMUL RCX,RCX,0x118
ADD RAX,RCX
MOVZX EAX,word ptr [RAX + 0xa2]
AND EAX,0x1
CMP EAX,0x0
JNZ 0x00166d03
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX + 0x3ec]
MOV ECX,dword ptr [RBP + -0x3c]
ADD ECX,0x1
CMP EAX,ECX
JZ 0x00166d03
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x140]
MOV ECX,dword ptr [RBP + -0x3c]
MOV EDX,0x1
SHL RDX,CL
MOV RCX,RDX
AND RAX,RCX
CMP RAX,0x0
JZ 0x00166cb6
MOV AL,0x1
TEST AL,0x1
JNZ 0x00166cbe
JMP 0x00166d03
LAB_00166cb6:
XOR EAX,EAX
TEST AL,0x1
JNZ 0x00166cbe
JMP 0x00166d03
LAB_00166cbe:
MOV EAX,dword ptr [RBP + -0x40]
ADD EAX,0x1
MOV dword ptr [RBP + -0x40],EAX
MOV EAX,dword ptr [RBP + -0x3c]
MOV ECX,EAX
MOV EAX,0x1
SHL RAX,CL
OR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RBP + -0x3c]
IMUL RCX,RCX,0x118
ADD RAX,RCX
MOVZX EAX,word ptr [RAX + 0xae]
MOV ECX,EAX
ADD RCX,0x20
MOV EAX,dword ptr [RBP + -0x44]
ADD RAX,RCX
MOV dword ptr [RBP + -0x44],EAX
LAB_00166d03:
JMP 0x00166d05
LAB_00166d05:
MOV EAX,dword ptr [RBP + -0x3c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x00166c41
LAB_00166d13:
CMP dword ptr [RBP + -0x40],0x0
JZ 0x00166d26
MOV EAX,dword ptr [RBP + -0x40]
SHL RAX,0xe
CMP RAX,qword ptr [RBP + -0x18]
JBE 0x00166d34
LAB_00166d26:
JMP 0x00166d28
LAB_00166d28:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00166f06
LAB_00166d34:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x00166d56
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x44]
IMUL RAX,RCX
CMP RAX,qword ptr [RBP + -0x18]
JNC 0x00166d56
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00166d6d
LAB_00166d56:
MOV EAX,dword ptr [RBP + -0x44]
SHL EAX,0x4
MOV EAX,EAX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x18]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x18],RAX
LAB_00166d6d:
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX + 0x3e8]
IMUL RSI,RAX,0x298
MOV EAX,dword ptr [RBP + -0x40]
SHL RAX,0x4
ADD RSI,RAX
XOR EDI,EDI
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001f9ff0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x310],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x310],0x0
JNZ 0x00166dbd
JMP 0x00166db1
LAB_00166db1:
MOV dword ptr [RBP + -0x4],0x80
JMP 0x00166f06
LAB_00166dbd:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x310]
MOV RCX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RCX + 0x3e8]
IMUL RCX,RCX,0x298
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV dword ptr [RBP + -0x3c],0x0
LAB_00166de7:
MOV EAX,dword ptr [RBP + -0x3c]
MOV RCX,qword ptr [RBP + -0x28]
CMP EAX,dword ptr [RCX + 0x3e8]
JNC 0x00166efd
MOV RAX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RBP + -0x3c]
MOV EDX,0x1
SHL RDX,CL
MOV RCX,RDX
AND RAX,RCX
CMP RAX,0x0
JZ 0x00166e20
MOV AL,0x1
TEST AL,0x1
JNZ 0x00166e2b
JMP 0x00166ece
LAB_00166e20:
XOR EAX,EAX
TEST AL,0x1
JNZ 0x00166e2b
JMP 0x00166ece
LAB_00166e2b:
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
MOV ECX,dword ptr [RBP + -0x3c]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x8],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x310]
MOV EAX,dword ptr [RBP + -0x3c]
IMUL RAX,RAX,0x298
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RBP + -0x3c]
IMUL RCX,RCX,0x118
ADD RAX,RCX
MOVZX EAX,word ptr [RAX + 0xae]
IMUL RSI,RAX
MOV RDX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RBP + -0x3c]
IMUL RCX,RCX,0x118
ADD RAX,RCX
MOVZX EAX,word ptr [RAX + 0xae]
IMUL RDX,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,RAX
ADD RCX,0x10
MOV qword ptr [RBP + -0x38],RCX
XOR ECX,ECX
LEA R8,[0x166f10]
LEA R9,[0x166f70]
XOR R10D,R10D
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],0x0
CALL 0x00200c90
JMP 0x00166eed
LAB_00166ece:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x310]
MOV ECX,dword ptr [RBP + -0x3c]
IMUL RCX,RCX,0x298
ADD RAX,RCX
MOV qword ptr [RAX],0x0
LAB_00166eed:
JMP 0x00166eef
LAB_00166eef:
MOV EAX,dword ptr [RBP + -0x3c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x00166de7
LAB_00166efd:
JMP 0x00166eff
LAB_00166eff:
MOV dword ptr [RBP + -0x4],0x0
LAB_00166f06:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x60
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x00166e1b) */
/* WARNING: Removing unreachable block (ram,0x00166cb4) */
int4 maria_init_bulk_insert(long *param_1,ulong param_2,ulong param_3)
{
long lVar1;
long lVar2;
long lVar3;
ulong local_58;
uint local_4c;
uint local_48;
uint local_44;
int8 *local_40;
ulong local_20;
int4 local_c;
lVar1 = *param_1;
lVar2 = *(long *)(lVar1 + 0x570);
local_58 = 0;
local_48 = 0;
local_4c = 0;
for (local_44 = 0; local_44 < *(uint *)(lVar1 + 1000); local_44 = local_44 + 1) {
if ((((*(ushort *)(lVar2 + (ulong)local_44 * 0x118 + 0xa2) & 1) == 0) &&
(*(int *)(lVar1 + 0x3ec) != local_44 + 1)) &&
((*(ulong *)(lVar1 + 0x140) & 1L << ((byte)local_44 & 0x3f)) != 0)) {
local_48 = local_48 + 1;
local_58 = 1L << ((byte)local_44 & 0x3f) | local_58;
local_4c = local_4c + *(ushort *)(lVar2 + (ulong)local_44 * 0x118 + 0xae) + 0x20;
}
}
if ((local_48 == 0) || (param_2 < (ulong)local_48 << 0xe)) {
local_c = 0;
}
else {
if ((param_3 == 0) || (local_20 = param_3, param_2 <= param_3 * local_4c)) {
local_20 = param_2 / (local_4c << 4);
}
lVar3 = my_malloc(0,(ulong)*(uint *)(lVar1 + 1000) * 0x298 + (ulong)local_48 * 0x10,0);
param_1[0x62] = lVar3;
if (param_1[0x62] == 0) {
local_c = 0x80;
}
else {
local_40 = (int8 *)(param_1[0x62] + (ulong)*(uint *)(lVar1 + 1000) * 0x298);
for (local_44 = 0; local_44 < *(uint *)(lVar1 + 1000); local_44 = local_44 + 1) {
if ((local_58 & 1L << ((byte)local_44 & 0x3f)) == 0) {
*(int8 *)(param_1[0x62] + (ulong)local_44 * 0x298) = 0;
}
else {
*local_40 = param_1;
*(uint *)(local_40 + 1) = local_44;
init_tree(param_1[0x62] + (ulong)local_44 * 0x298,
local_20 * *(ushort *)(lVar2 + (ulong)local_44 * 0x118 + 0xae),
local_20 * *(ushort *)(lVar2 + (ulong)local_44 * 0x118 + 0xae),0,keys_compare,
keys_free,local_40,0);
local_40 = local_40 + 2;
}
}
local_c = 0;
}
}
return local_c;
}
| |
41,630 | intern_filename | eloqsql/mysys/mf_pack.c | char *intern_filename(char *to, const char *from)
{
size_t length, to_length;
char buff[FN_REFLEN + 1];
if (from == to)
{ /* Dirname may destroy from */
(void) strnmov(buff, from, FN_REFLEN);
from=buff;
}
length= dirname_part(to, from, &to_length); /* Copy dirname & fix chars */
(void) strnmov(to + to_length, from + length, FN_REFLEN - to_length);
return (to);
} | O0 | c | intern_filename:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x218(%rbp)
movq %rsi, -0x220(%rbp)
movq -0x220(%rbp), %rax
cmpq -0x218(%rbp), %rax
jne 0xe8c3c
leaq -0x210(%rbp), %rdi
movq -0x220(%rbp), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x14e060
leaq -0x210(%rbp), %rax
movq %rax, -0x220(%rbp)
movq -0x218(%rbp), %rdi
movq -0x220(%rbp), %rsi
leaq -0x230(%rbp), %rdx
callq 0xdf5b0
movq %rax, -0x228(%rbp)
movq -0x218(%rbp), %rdi
movq -0x230(%rbp), %rax
addq %rax, %rdi
movq -0x220(%rbp), %rsi
movq -0x228(%rbp), %rcx
addq %rcx, %rsi
movl $0x200, %edx # imm = 0x200
subq %rax, %rdx
callq 0x14e060
movq -0x218(%rbp), %rax
movq %rax, -0x238(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xe8cbc
movq -0x238(%rbp), %rax
addq $0x240, %rsp # imm = 0x240
popq %rbp
retq
callq 0x2a260
nopw %cs:(%rax,%rax)
| intern_filename:
push rbp
mov rbp, rsp
sub rsp, 240h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_218], rdi
mov [rbp+var_220], rsi
mov rax, [rbp+var_220]
cmp rax, [rbp+var_218]
jnz short loc_E8C3C
lea rdi, [rbp+var_210]
mov rsi, [rbp+var_220]
mov edx, 200h
call strnmov
lea rax, [rbp+var_210]
mov [rbp+var_220], rax
loc_E8C3C:
mov rdi, [rbp+var_218]
mov rsi, [rbp+var_220]
lea rdx, [rbp+var_230]
call dirname_part
mov [rbp+var_228], rax
mov rdi, [rbp+var_218]
mov rax, [rbp+var_230]
add rdi, rax
mov rsi, [rbp+var_220]
mov rcx, [rbp+var_228]
add rsi, rcx
mov edx, 200h
sub rdx, rax
call strnmov
mov rax, [rbp+var_218]
mov [rbp+var_238], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_E8CBC
mov rax, [rbp+var_238]
add rsp, 240h
pop rbp
retn
loc_E8CBC:
call ___stack_chk_fail
| long long intern_filename(long long a1, _BYTE *a2)
{
long long v3; // [rsp+10h] [rbp-230h] BYREF
long long v4; // [rsp+18h] [rbp-228h]
_BYTE *v5; // [rsp+20h] [rbp-220h]
long long v6; // [rsp+28h] [rbp-218h]
_BYTE v7[520]; // [rsp+30h] [rbp-210h] BYREF
unsigned long long v8; // [rsp+238h] [rbp-8h]
v8 = __readfsqword(0x28u);
v6 = a1;
v5 = a2;
if ( a2 == (_BYTE *)a1 )
{
strnmov(v7, v5, 512LL);
v5 = v7;
}
v4 = dirname_part(v6, v5, &v3);
strnmov(v3 + v6, &v5[v4], 512 - v3);
return v6;
}
| intern_filename:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x240
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x218],RDI
MOV qword ptr [RBP + -0x220],RSI
MOV RAX,qword ptr [RBP + -0x220]
CMP RAX,qword ptr [RBP + -0x218]
JNZ 0x001e8c3c
LEA RDI,[RBP + -0x210]
MOV RSI,qword ptr [RBP + -0x220]
MOV EDX,0x200
CALL 0x0024e060
LEA RAX,[RBP + -0x210]
MOV qword ptr [RBP + -0x220],RAX
LAB_001e8c3c:
MOV RDI,qword ptr [RBP + -0x218]
MOV RSI,qword ptr [RBP + -0x220]
LEA RDX,[RBP + -0x230]
CALL 0x001df5b0
MOV qword ptr [RBP + -0x228],RAX
MOV RDI,qword ptr [RBP + -0x218]
MOV RAX,qword ptr [RBP + -0x230]
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x220]
MOV RCX,qword ptr [RBP + -0x228]
ADD RSI,RCX
MOV EDX,0x200
SUB RDX,RAX
CALL 0x0024e060
MOV RAX,qword ptr [RBP + -0x218]
MOV qword ptr [RBP + -0x238],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001e8cbc
MOV RAX,qword ptr [RBP + -0x238]
ADD RSP,0x240
POP RBP
RET
LAB_001e8cbc:
CALL 0x0012a260
|
int1 * intern_filename(int1 *param_1,int1 *param_2)
{
long in_FS_OFFSET;
long local_238;
long local_230;
int1 *local_228;
int1 *local_220;
int1 local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_228 = param_2;
local_220 = param_1;
if (param_2 == param_1) {
strnmov(local_218,param_2,0x200);
local_228 = local_218;
}
local_230 = dirname_part(local_220,local_228,&local_238);
strnmov(local_220 + local_238,local_228 + local_230,0x200 - local_238);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_220;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
41,631 | intern_filename | eloqsql/mysys/mf_pack.c | char *intern_filename(char *to, const char *from)
{
size_t length, to_length;
char buff[FN_REFLEN + 1];
if (from == to)
{ /* Dirname may destroy from */
(void) strnmov(buff, from, FN_REFLEN);
from=buff;
}
length= dirname_part(to, from, &to_length); /* Copy dirname & fix chars */
(void) strnmov(to + to_length, from + length, FN_REFLEN - to_length);
return (to);
} | O3 | c | intern_filename:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
cmpq %rdi, %rsi
jne 0x9b13f
leaq -0x230(%rbp), %r15
movl $0x200, %edx # imm = 0x200
movq %r15, %rdi
movq %r14, %rsi
callq 0xd7378
movq %r15, %r14
leaq -0x238(%rbp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x948f5
movq (%r15), %rcx
leaq (%rbx,%rcx), %rdi
addq %rax, %r14
movl $0x200, %edx # imm = 0x200
subq %rcx, %rdx
movq %r14, %rsi
callq 0xd7378
movq %fs:0x28, %rax
cmpq -0x20(%rbp), %rax
jne 0x9b18e
movq %rbx, %rax
addq $0x228, %rsp # imm = 0x228
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x29260
| intern_filename:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 228h
mov r14, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_20], rax
cmp rsi, rdi
jnz short loc_9B13F
lea r15, [rbp+var_230]
mov edx, 200h
mov rdi, r15
mov rsi, r14
call strnmov
mov r14, r15
loc_9B13F:
lea r15, [rbp+var_238]
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call dirname_part
mov rcx, [r15]
lea rdi, [rbx+rcx]
add r14, rax
mov edx, 200h
sub rdx, rcx
mov rsi, r14
call strnmov
mov rax, fs:28h
cmp rax, [rbp+var_20]
jnz short loc_9B18E
mov rax, rbx
add rsp, 228h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_9B18E:
call ___stack_chk_fail
| long long intern_filename(long long a1, _BYTE *a2)
{
_BYTE *v2; // r14
long long v3; // rax
long long v5; // [rsp+8h] [rbp-238h] BYREF
_BYTE v6[528]; // [rsp+10h] [rbp-230h] BYREF
unsigned long long v7; // [rsp+220h] [rbp-20h]
v2 = a2;
v7 = __readfsqword(0x28u);
if ( a2 == (_BYTE *)a1 )
{
strnmov(v6, a2, 512LL);
v2 = v6;
}
v3 = dirname_part(a1, v2, &v5);
strnmov(a1 + v5, &v2[v3], 512 - v5);
return a1;
}
| intern_filename:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x228
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
CMP RSI,RDI
JNZ 0x0019b13f
LEA R15,[RBP + -0x230]
MOV EDX,0x200
MOV RDI,R15
MOV RSI,R14
CALL 0x001d7378
MOV R14,R15
LAB_0019b13f:
LEA R15,[RBP + -0x238]
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
CALL 0x001948f5
MOV RCX,qword ptr [R15]
LEA RDI,[RBX + RCX*0x1]
ADD R14,RAX
MOV EDX,0x200
SUB RDX,RCX
MOV RSI,R14
CALL 0x001d7378
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x0019b18e
MOV RAX,RBX
ADD RSP,0x228
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0019b18e:
CALL 0x00129260
|
int1 * intern_filename(int1 *param_1,int1 *param_2)
{
long lVar1;
int1 *puVar2;
long in_FS_OFFSET;
long local_240;
int1 local_238 [528];
long local_28;
local_28 = *(long *)(in_FS_OFFSET + 0x28);
puVar2 = param_2;
if (param_2 == param_1) {
puVar2 = local_238;
strnmov(puVar2,param_2,0x200);
}
lVar1 = dirname_part(param_1,puVar2,&local_240);
strnmov(param_1 + local_240,puVar2 + lVar1,0x200 - local_240);
if (*(long *)(in_FS_OFFSET + 0x28) == local_28) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
41,632 | nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | llama.cpp/common/json.hpp | T& operator[](const key_type& key)
{
return emplace(key, T{}).first->second;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x40(%rsp), %r14
movq $0x0, 0x8(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%r14)
movaps %xmm0, -0x30(%r14)
movaps %xmm0, -0x20(%r14)
movaps %xmm0, -0x10(%r14)
movb $0x0, (%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x8508e
movq %r14, %rdi
movl $0x1, %esi
callq 0x8508e
movq %rsp, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xc0b6e
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x8508e
movq %r14, %rdi
callq 0x897a8
leaq 0x38(%rsp), %rdi
callq 0x70982
leaq 0x28(%rsp), %rdi
callq 0x70982
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x70982
movq -0x10(%r14), %rdi
testq %rdi, %rdi
je 0xc0b4a
movq 0xa1473(%rip), %rax # 0x161f98
cmpb $0x0, (%rax)
je 0xc0b35
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0xc0b3f
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0xc0b4a
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x10, %rbx
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xb60d0
movq %rbx, %rdi
callq 0x20ae0
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEEixERSJ_:
push r15
push r14
push rbx
sub rsp, 50h
mov rbx, rsi
mov r15, rdi
lea r14, [rsp+68h+var_28]
mov qword ptr [r14+8], 0
xorps xmm0, xmm0
movaps xmmword ptr [r14-40h], xmm0
movaps xmmword ptr [r14-30h], xmm0
movaps xmmword ptr [r14-20h], xmm0
movaps xmmword ptr [r14-10h], xmm0
mov byte ptr [r14], 0
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdx, rsp
mov rdi, r15
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceERSJ_OSF_; nlohmann::json_abi_v3_11_3::ordered_map<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>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>::emplace(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,minja::Value&&)
mov rbx, rax
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()
lea rdi, [rsp+68h+var_30]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+68h+var_40]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea r14, [rsp+68h+var_50]
mov rdi, r14
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, [r14-10h]
test rdi, rdi
jz short loc_C0B4A
mov rax, cs:_ZTISt19_Sp_make_shared_tag; `typeinfo for'std::_Sp_make_shared_tag
cmp byte ptr [rax], 0
jz short loc_C0B35
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_C0B3F
loc_C0B35:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_C0B3F:
cmp eax, 1
jnz short loc_C0B4A
mov rax, [rdi]
call qword ptr [rax+18h]
loc_C0B4A:
add rbx, 10h
mov rax, rbx
add rsp, 50h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rdi, rsp; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rdi, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::ordered_map<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>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::operator[](
long long a1,
long long a2)
{
long long v2; // rbx
long long v3; // rdi
signed __int32 v4; // eax
__int128 v6; // [rsp+0h] [rbp-68h] BYREF
__int128 v7; // [rsp+10h] [rbp-58h] BYREF
__int128 v8; // [rsp+20h] [rbp-48h] BYREF
__int128 v9; // [rsp+30h] [rbp-38h] BYREF
char v10[8]; // [rsp+40h] [rbp-28h] BYREF
long long v11; // [rsp+48h] [rbp-20h]
v11 = 0LL;
v6 = 0LL;
v7 = 0LL;
v8 = 0LL;
v9 = 0LL;
v10[0] = 0;
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(v10);
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(v10);
v2 = nlohmann::json_abi_v3_11_3::ordered_map<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>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::emplace(
a1,
a2,
&v6);
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(v10);
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(v10);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((volatile signed __int32 **)&v9 + 1);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((volatile signed __int32 **)&v8 + 1);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((volatile signed __int32 **)&v7 + 1);
v3 = *((_QWORD *)&v6 + 1);
if ( *((_QWORD *)&v6 + 1) )
{
if ( _libc_single_threaded )
{
v4 = *(_DWORD *)(*((_QWORD *)&v6 + 1) + 12LL);
*(_DWORD *)(*((_QWORD *)&v6 + 1) + 12LL) = v4 - 1;
}
else
{
v4 = _InterlockedExchangeAdd((volatile signed __int32 *)(*((_QWORD *)&v6 + 1) + 12LL), 0xFFFFFFFF);
}
if ( v4 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v3 + 24LL))(v3, 0LL);
}
return v2 + 16;
}
| operator[]:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV RBX,RSI
MOV R15,RDI
LEA R14,[RSP + 0x40]
MOV qword ptr [R14 + 0x8],0x0
XORPS XMM0,XMM0
MOVAPS xmmword ptr [R14 + -0x40],XMM0
MOVAPS xmmword ptr [R14 + -0x30],XMM0
MOVAPS xmmword ptr [R14 + -0x20],XMM0
MOVAPS xmmword ptr [R14 + -0x10],XMM0
MOV byte ptr [R14],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x0018508e
MOV RDI,R14
MOV ESI,0x1
CALL 0x0018508e
LAB_001c0ad1:
MOV RDX,RSP
MOV RDI,R15
MOV RSI,RBX
CALL 0x001c0b6e
LAB_001c0adf:
MOV RBX,RAX
MOV RDI,R14
XOR ESI,ESI
CALL 0x0018508e
MOV RDI,R14
CALL 0x001897a8
LEA RDI,[RSP + 0x38]
CALL 0x00170982
LEA RDI,[RSP + 0x28]
CALL 0x00170982
LEA R14,[RSP + 0x18]
MOV RDI,R14
CALL 0x00170982
MOV RDI,qword ptr [R14 + -0x10]
TEST RDI,RDI
JZ 0x001c0b4a
MOV RAX,qword ptr [0x00261f98]
CMP byte ptr [RAX],0x0
JZ 0x001c0b35
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001c0b3f
LAB_001c0b35:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001c0b3f:
CMP EAX,0x1
JNZ 0x001c0b4a
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_001c0b4a:
ADD RBX,0x10
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R14
POP R15
RET
|
/* nlohmann::json_abi_v3_11_3::ordered_map<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>, minja::Value,
std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >,
std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const, minja::Value> >
>::operator[](nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&) */
long __thiscall
nlohmann::json_abi_v3_11_3::
ordered_map<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>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::operator[](ordered_map<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>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*this,basic_json *param_1)
{
int *piVar1;
int iVar2;
long lVar3;
bool bVar4;
int8 local_68;
long *plStack_60;
int8 local_58;
int8 uStack_50;
int8 local_48;
int8 uStack_40;
int8 local_38;
int8 uStack_30;
data local_28 [8];
int8 local_20;
local_20 = 0;
local_68 = 0;
plStack_60 = (long *)0x0;
local_58 = 0;
uStack_50 = 0;
local_48 = 0;
uStack_40 = 0;
local_38 = 0;
uStack_30 = 0;
local_28[0] = (data)0x0;
bVar4 = SUB81(local_28,0);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar4);
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(bVar4);
/* try { // try from 001c0ad1 to 001c0ade has its CatchHandler @ 001c0b5b */
lVar3 = emplace(this,param_1,(Value *)&local_68);
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(bVar4);
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_28);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&uStack_30);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&uStack_40);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&uStack_50);
if (plStack_60 != (long *)0x0) {
if (*PTR___libc_single_threaded_00261f98 == '\0') {
LOCK();
piVar1 = (int *)((long)plStack_60 + 0xc);
iVar2 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar2 = *(int *)((long)plStack_60 + 0xc);
*(int *)((long)plStack_60 + 0xc) = iVar2 + -1;
}
if (iVar2 == 1) {
(**(code **)(*plStack_60 + 0x18))();
}
}
return lVar3 + 0x10;
}
| |
41,633 | mysql_stmt_free_result_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_stmt_free_result_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_stmt_free_result,
(parms->stmt),
parms->stmt->mysql,
my_bool,
r_my_bool)
} | O0 | c | mysql_stmt_free_result_start_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x29de0
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| mysql_stmt_free_result_start_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+38h]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
call mysql_stmt_free_result
mov [rbp+var_11], al
mov cl, [rbp+var_11]
mov rax, [rbp+var_20]
mov [rax+8], cl
mov rax, [rbp+var_20]
mov dword ptr [rax], 0
add rsp, 20h
pop rbp
retn
| long long mysql_stmt_free_result_start_internal(long long *a1)
{
long long result; // rax
long long v2; // [rsp+0h] [rbp-20h]
v2 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(*a1 + 56) + 1152LL) + 40LL);
*(_BYTE *)(v2 + 8) = mysql_stmt_free_result(*a1);
result = v2;
*(_DWORD *)v2 = 0;
return result;
}
| mysql_stmt_free_result_start_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x00129de0
MOV byte ptr [RBP + -0x11],AL
MOV CL,byte ptr [RBP + -0x11]
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x8],CL
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
ADD RSP,0x20
POP RBP
RET
|
void mysql_stmt_free_result_start_internal(long *param_1)
{
int4 *puVar1;
int1 uVar2;
puVar1 = *(int4 **)(*(long *)(*(long *)(*param_1 + 0x38) + 0x480) + 0x28);
uVar2 = mysql_stmt_free_result(*param_1);
*(int1 *)(puVar1 + 2) = uVar2;
*puVar1 = 0;
return;
}
| |
41,634 | stmt_unbuffered_fetch | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | static int stmt_unbuffered_fetch(MYSQL_STMT *stmt, uchar **row)
{
ulong pkt_len;
pkt_len= ma_net_safe_read(stmt->mysql);
if (pkt_len == packet_error)
{
stmt->fetch_row_func= stmt_unbuffered_eof;
return(1);
}
if (stmt->mysql->net.read_pos[0] == 254)
{
*row = NULL;
stmt->fetch_row_func= stmt_unbuffered_eof;
return(MYSQL_NO_DATA);
}
else
*row = stmt->mysql->net.read_pos;
stmt->result.rows++;
return(0);
} | O3 | c | stmt_unbuffered_fetch:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0x156e7
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmpq %rcx, %rax
jne 0x1ecf0
leaq 0x3e0d(%rip), %rax # 0x22aef
movq %rax, 0x348(%rbx)
movl $0x1, %eax
jmp 0x1ed25
movq 0x38(%rbx), %rax
movq 0x20(%rax), %rax
cmpb $-0x2, (%rax)
jne 0x1ed19
movq $0x0, (%r14)
leaq 0x3de4(%rip), %rax # 0x22aef
movq %rax, 0x348(%rbx)
movl $0x64, %eax
jmp 0x1ed25
movq %rax, (%r14)
incq 0xc8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
| stmt_unbuffered_fetch:
push rbp
mov rbp, rsp
push r14
push rbx
mov r14, rsi
mov rbx, rdi
mov rdi, [rdi+38h]
call ma_net_safe_read
mov ecx, 0FFFFFFFFh
cmp rax, rcx
jnz short loc_1ECF0
lea rax, stmt_unbuffered_eof
mov [rbx+348h], rax
mov eax, 1
jmp short loc_1ED25
loc_1ECF0:
mov rax, [rbx+38h]
mov rax, [rax+20h]
cmp byte ptr [rax], 0FEh
jnz short loc_1ED19
mov qword ptr [r14], 0
lea rax, stmt_unbuffered_eof
mov [rbx+348h], rax
mov eax, 64h ; 'd'
jmp short loc_1ED25
loc_1ED19:
mov [r14], rax
inc qword ptr [rbx+0C8h]
xor eax, eax
loc_1ED25:
pop rbx
pop r14
pop rbp
retn
| long long stmt_unbuffered_fetch(long long *a1, _QWORD *a2, long long a3, long long a4, unsigned long long a5, int a6)
{
_BYTE *v7; // rax
if ( ma_net_safe_read(a1[7], (long long)a2, a3, a4, a5, a6) == 0xFFFFFFFF )
{
a1[105] = (long long)stmt_unbuffered_eof;
return 1LL;
}
else
{
v7 = *(_BYTE **)(a1[7] + 32);
if ( *v7 == 0xFE )
{
*a2 = 0LL;
a1[105] = (long long)stmt_unbuffered_eof;
return 100LL;
}
else
{
*a2 = v7;
++a1[25];
return 0LL;
}
}
}
| stmt_unbuffered_fetch:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x38]
CALL 0x001156e7
MOV ECX,0xffffffff
CMP RAX,RCX
JNZ 0x0011ecf0
LEA RAX,[0x122aef]
MOV qword ptr [RBX + 0x348],RAX
MOV EAX,0x1
JMP 0x0011ed25
LAB_0011ecf0:
MOV RAX,qword ptr [RBX + 0x38]
MOV RAX,qword ptr [RAX + 0x20]
CMP byte ptr [RAX],0xfe
JNZ 0x0011ed19
MOV qword ptr [R14],0x0
LEA RAX,[0x122aef]
MOV qword ptr [RBX + 0x348],RAX
MOV EAX,0x64
JMP 0x0011ed25
LAB_0011ed19:
MOV qword ptr [R14],RAX
INC qword ptr [RBX + 0xc8]
XOR EAX,EAX
LAB_0011ed25:
POP RBX
POP R14
POP RBP
RET
|
int8 stmt_unbuffered_fetch(long param_1,int8 *param_2)
{
char *pcVar1;
long lVar2;
int8 uVar3;
lVar2 = ma_net_safe_read(*(int8 *)(param_1 + 0x38));
if (lVar2 == 0xffffffff) {
*(code **)(param_1 + 0x348) = stmt_unbuffered_eof;
uVar3 = 1;
}
else {
pcVar1 = *(char **)(*(long *)(param_1 + 0x38) + 0x20);
if (*pcVar1 == -2) {
*param_2 = 0;
*(code **)(param_1 + 0x348) = stmt_unbuffered_eof;
uVar3 = 100;
}
else {
*param_2 = pcVar1;
*(long *)(param_1 + 200) = *(long *)(param_1 + 200) + 1;
uVar3 = 0;
}
}
return uVar3;
}
| |
41,635 | ma_control_file_write_and_force | eloqsql/storage/maria/ma_control_file.c | int ma_control_file_write_and_force(LSN last_checkpoint_lsn_arg,
uint32 last_logno_arg,
TrID max_trid_arg,
uint8 recovery_failures_arg)
{
uchar buffer[CF_MAX_SIZE];
uint32 sum;
my_bool no_need_sync;
DBUG_ENTER("ma_control_file_write_and_force");
/*
We don't need to sync if this is just an increase of
recovery_failures: it's even good if that counter is not increased on disk
in case of power or hardware failure (less false positives when removing
logs).
*/
no_need_sync= ((last_checkpoint_lsn == last_checkpoint_lsn_arg) &&
(last_logno == last_logno_arg) &&
(max_trid_in_control_file == max_trid_arg) &&
(recovery_failures_arg > 0));
if (control_file_fd < 0)
DBUG_RETURN(1);
#ifndef DBUG_OFF
if (maria_multi_threaded)
translog_lock_handler_assert_owner();
#endif
lsn_store(buffer + CF_LSN_OFFSET, last_checkpoint_lsn_arg);
int4store(buffer + CF_FILENO_OFFSET, last_logno_arg);
transid_store(buffer + CF_MAX_TRID_OFFSET, max_trid_arg);
(buffer + CF_RECOV_FAIL_OFFSET)[0]= recovery_failures_arg;
if (cf_changeable_size > CF_CHANGEABLE_TOTAL_SIZE)
{
/*
More room than needed for us. Must be a newer version. Clear part which
we cannot maintain, so that any future version notices we didn't
maintain its extra data.
*/
uint zeroed= cf_changeable_size - CF_CHANGEABLE_TOTAL_SIZE;
char msg[150];
bzero(buffer + CF_CHANGEABLE_TOTAL_SIZE, zeroed);
my_snprintf(msg, sizeof(msg),
"Control file must be from a newer version; zero-ing out %u"
" unknown bytes in control file at offset %u", zeroed,
cf_changeable_size + cf_create_time_size);
ma_message_no_user(ME_WARNING, msg);
}
else
{
/* not enough room for what we need to store: enlarge */
cf_changeable_size= CF_CHANGEABLE_TOTAL_SIZE;
}
/* Note that the create-time portion is not touched */
/* Checksum is stored first */
compile_time_assert(CF_CHECKSUM_OFFSET == 0);
sum= my_checksum(0, buffer + CF_CHECKSUM_SIZE,
cf_changeable_size - CF_CHECKSUM_SIZE);
int4store(buffer, sum);
if (my_pwrite(control_file_fd, buffer, cf_changeable_size,
cf_create_time_size, MYF(MY_FNABP | MY_WME)) ||
(!no_need_sync && mysql_file_sync(control_file_fd, MYF(MY_WME))))
DBUG_RETURN(1);
last_checkpoint_lsn= last_checkpoint_lsn_arg;
last_logno= last_logno_arg;
max_trid_in_control_file= max_trid_arg;
recovery_failures= recovery_failures_arg;
cf_changeable_size= CF_CHANGEABLE_TOTAL_SIZE; /* no more warning */
DBUG_RETURN(0);
} | O3 | c | ma_control_file_write_and_force:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2b8, %rsp # imm = 0x2B8
movl %ecx, %r12d
movq %rdx, %r14
movq %rdi, %r13
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
cmpq %rdi, 0x3b8c7e(%rip) # 0x3fbf00
setne %al
cmpl %esi, 0x3b8c7d(%rip) # 0x3fbf08
setne %dl
cmpq %r14, 0x3b8c7b(%rip) # 0x3fbf10
setne %dil
testl %ecx, %ecx
sete %cl
movl $0x1, %r15d
cmpl $0x0, 0x33fee5(%rip) # 0x383190
js 0x4346e
movb %dil, -0x2d1(%rbp)
movb %dl, -0x2d2(%rbp)
movb %cl, -0x2d3(%rbp)
movb %al, -0x2d4(%rbp)
movq %r13, %rax
shrq $0x20, %rax
leaq -0x22c(%rbp), %r15
movb %al, (%r15)
movq %r13, %rax
shrq $0x28, %rax
movb %al, 0x1(%r15)
movq %r13, %rax
shrq $0x30, %rax
movb %al, 0x2(%r15)
movl %r13d, 0x3(%r15)
movl %esi, 0x7(%r15)
movl %r14d, 0xb(%r15)
movq %r14, %rax
shrq $0x20, %rax
movw %ax, 0xf(%r15)
movb %r12b, 0x11(%r15)
movl 0x3b8c0d(%rip), %ebx # 0x3fbf20
cmpl $0x17, %ebx
movl %esi, -0x2dc(%rbp)
jb 0x43396
movl %r12d, -0x2d8(%rbp)
leal -0x16(%rbx), %r12d
leaq -0x21a(%rbp), %rdi
movl $0x1ea, %ecx # imm = 0x1EA
xorl %esi, %esi
movq %r12, %rdx
callq 0x297d0
addl 0x3b8bd7(%rip), %ebx # 0x3fbf1c
leaq 0x95782(%rip), %rdx # 0xd8ace
leaq -0x2d0(%rbp), %rdi
movl $0x96, %esi
movl %r12d, %ecx
movl -0x2d8(%rbp), %r12d
movl %ebx, %r8d
xorl %eax, %eax
callq 0xd665e
leaq 0x957c1(%rip), %rsi # 0xd8b34
movl $0x800, %edx # imm = 0x800
movl $0xa8, %edi
leaq -0x2d0(%rbp), %rcx
xorl %eax, %eax
callq 0x9dc21
movl 0x3b8b8f(%rip), %edx # 0x3fbf20
addl $-0x4, %edx
jmp 0x433a5
movl $0x16, 0x3b8b80(%rip) # 0x3fbf20
movl $0x12, %edx
xorl %edi, %edi
movq %r15, %rsi
callq 0xa7838
leaq -0x230(%rbp), %rsi
movl %eax, (%rsi)
movl 0x33fdd2(%rip), %edi # 0x383190
movl 0x3b8b5c(%rip), %edx # 0x3fbf20
movl 0x3b8b52(%rip), %ecx # 0x3fbf1c
movl $0x12, %r8d
callq 0xa00b2
testq %rax, %rax
je 0x433e5
movl $0x1, %r15d
jmp 0x4346e
movb -0x2d4(%rbp), %al
orb -0x2d2(%rbp), %al
movb -0x2d3(%rbp), %cl
orb -0x2d1(%rbp), %cl
orb %al, %cl
movl $0x1, %r15d
je 0x43440
movl 0x33fd83(%rip), %ebx # 0x383190
leaq 0x341bfc(%rip), %rax # 0x385010
movq (%rax), %rax
leaq -0x2d0(%rbp), %rdi
movl %ebx, %esi
movl $0x10, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x43492
movl $0x10, %esi
movl %ebx, %edi
callq 0xa0d68
testl %eax, %eax
jne 0x4346e
movq %r13, 0x3b8ab9(%rip) # 0x3fbf00
movl -0x2dc(%rbp), %eax
movl %eax, 0x3b8ab5(%rip) # 0x3fbf08
movq %r14, 0x3b8ab6(%rip) # 0x3fbf10
movb %r12b, 0x3b8ab7(%rip) # 0x3fbf18
movl $0x16, 0x3b8ab5(%rip) # 0x3fbf20
xorl %r15d, %r15d
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x434b1
movl %r15d, %eax
addq $0x2b8, %rsp # imm = 0x2B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x2e0(%rbp), %r15
movq %rax, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x2a779
movl (%r15), %eax
movl $0x1, %r15d
jmp 0x4343c
callq 0x29260
| ma_control_file_write_and_force:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 2B8h
mov r12d, ecx
mov r14, rdx
mov r13, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
cmp cs:last_checkpoint_lsn, rdi
setnz al
cmp cs:last_logno, esi
setnz dl
cmp cs:max_trid_in_control_file, r14
setnz dil
test ecx, ecx
setz cl
mov r15d, 1
cmp cs:control_file_fd, 0
js loc_4346E
mov [rbp+var_2D1], dil
mov [rbp+var_2D2], dl
mov [rbp+var_2D3], cl
mov [rbp+var_2D4], al
mov rax, r13
shr rax, 20h
lea r15, [rbp+var_22C]
mov [r15], al
mov rax, r13
shr rax, 28h
mov [r15+1], al
mov rax, r13
shr rax, 30h
mov [r15+2], al
mov [r15+3], r13d
mov [r15+7], esi
mov [r15+0Bh], r14d
mov rax, r14
shr rax, 20h
mov [r15+0Fh], ax
mov [r15+11h], r12b
mov ebx, cs:cf_changeable_size
cmp ebx, 17h
mov [rbp+var_2DC], esi
jb short loc_43396
mov [rbp+var_2D8], r12d
lea r12d, [rbx-16h]
lea rdi, [rbp+var_21A]
mov ecx, 1EAh
xor esi, esi
mov rdx, r12
call ___memset_chk
add ebx, cs:cf_create_time_size
lea rdx, aControlFileMus; "Control file must be from a newer versi"...
lea rdi, [rbp+var_2D0]
mov esi, 96h
mov ecx, r12d
mov r12d, [rbp+var_2D8]
mov r8d, ebx
xor eax, eax
call my_snprintf
lea rsi, aAriaEngineS; "Aria engine: %s"
mov edx, 800h
mov edi, 0A8h
lea rcx, [rbp+var_2D0]
xor eax, eax
call my_printf_error
mov edx, cs:cf_changeable_size
add edx, 0FFFFFFFCh
jmp short loc_433A5
loc_43396:
mov cs:cf_changeable_size, 16h
mov edx, 12h
loc_433A5:
xor edi, edi
mov rsi, r15
call my_checksum
lea rsi, [rbp+var_230]
mov [rsi], eax
mov edi, cs:control_file_fd
mov edx, cs:cf_changeable_size
mov ecx, cs:cf_create_time_size
mov r8d, 12h
call my_pwrite
test rax, rax
jz short loc_433E5
mov r15d, 1
jmp loc_4346E
loc_433E5:
mov al, [rbp+var_2D4]
or al, [rbp+var_2D2]
mov cl, [rbp+var_2D3]
or cl, [rbp+var_2D1]
or cl, al
mov r15d, 1
jz short loc_43440
mov ebx, cs:control_file_fd
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_2D0]
mov esi, ebx
mov edx, 10h
call qword ptr [rax+158h]
test rax, rax
jnz short loc_43492
mov esi, 10h
mov edi, ebx
call my_sync
loc_4343C:
test eax, eax
jnz short loc_4346E
loc_43440:
mov cs:last_checkpoint_lsn, r13
mov eax, [rbp+var_2DC]
mov cs:last_logno, eax
mov cs:max_trid_in_control_file, r14
mov cs:recovery_failures, r12b
mov cs:cf_changeable_size, 16h
xor r15d, r15d
loc_4346E:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_434B1
mov eax, r15d
add rsp, 2B8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_43492:
lea r15, [rbp+var_2E0]
mov rdi, rax
mov esi, ebx
mov rdx, r15
call ma_control_file_write_and_force_cold_1
mov eax, [r15]
mov r15d, 1
jmp short loc_4343C
loc_434B1:
call ___stack_chk_fail
| long long ma_control_file_write_and_force(long long a1, int a2, long long a3, int a4)
{
int v4; // r12d
bool v6; // cl
unsigned int v7; // r15d
int v8; // ebx
int v9; // ecx
int v10; // r9d
int v11; // r8d
int v12; // r9d
long long v13; // rdx
long long v14; // rcx
unsigned int v15; // ebx
long long v16; // rax
int v17; // eax
int v19; // [rsp+0h] [rbp-2E0h] BYREF
int v20; // [rsp+4h] [rbp-2DCh]
int v21; // [rsp+8h] [rbp-2D8h]
int v22; // [rsp+Ch] [rbp-2D4h]
_BYTE v23[160]; // [rsp+10h] [rbp-2D0h] BYREF
int v24; // [rsp+B0h] [rbp-230h] BYREF
_BYTE v25[3]; // [rsp+B4h] [rbp-22Ch] BYREF
int v26; // [rsp+B7h] [rbp-229h]
int v27; // [rsp+BBh] [rbp-225h]
int v28; // [rsp+BFh] [rbp-221h]
__int16 v29; // [rsp+C3h] [rbp-21Dh]
char v30; // [rsp+C5h] [rbp-21Bh]
char v31[490]; // [rsp+C6h] [rbp-21Ah] BYREF
unsigned long long v32; // [rsp+2B0h] [rbp-30h]
v4 = a4;
v32 = __readfsqword(0x28u);
v6 = a4 == 0;
v7 = 1;
if ( control_file_fd >= 0 )
{
HIBYTE(v22) = max_trid_in_control_file != a3;
BYTE2(v22) = last_logno != a2;
BYTE1(v22) = v6;
LOBYTE(v22) = last_checkpoint_lsn != a1;
v25[0] = BYTE4(a1);
v25[1] = BYTE5(a1);
v25[2] = BYTE6(a1);
v26 = a1;
v27 = a2;
v28 = a3;
v29 = WORD2(a3);
v30 = v4;
v8 = cf_changeable_size;
v20 = a2;
if ( (unsigned int)cf_changeable_size < 0x17 )
{
cf_changeable_size = 22;
v13 = 18LL;
}
else
{
v21 = v4;
v4 = cf_changeable_size - 22;
__memset_chk(v31, 0LL, (unsigned int)(cf_changeable_size - 22), 490LL);
v9 = v4;
LOBYTE(v4) = v21;
my_snprintf(
(unsigned int)v23,
150,
(unsigned int)"Control file must be from a newer version; zero-ing out %u unknown bytes in control file at offset %u",
v9,
cf_create_time_size + v8,
v10,
v19);
my_printf_error(168, (unsigned int)"Aria engine: %s", 2048, (unsigned int)v23, v11, v12);
v13 = (unsigned int)(cf_changeable_size - 4);
}
v24 = my_checksum(0LL, v25, v13);
if ( my_pwrite(
(unsigned int)control_file_fd,
&v24,
(unsigned int)cf_changeable_size,
(unsigned int)cf_create_time_size,
18LL) )
{
return 1;
}
else
{
v7 = 1;
if ( !v22
|| ((v15 = control_file_fd,
LOBYTE(v14) = BYTE2(v22) | v22 | HIBYTE(v22) | BYTE1(v22),
(v16 = ((long long ( *)(_BYTE *, _QWORD, long long, long long))PSI_server[43])(
v23,
(unsigned int)control_file_fd,
16LL,
v14)) != 0)
? (ma_control_file_write_and_force_cold_1(v16, v15, &v19), v17 = v19, v7 = 1)
: (v17 = my_sync(v15, 16LL)),
!v17) )
{
last_checkpoint_lsn = a1;
last_logno = v20;
max_trid_in_control_file = a3;
recovery_failures = v4;
cf_changeable_size = 22;
return 0;
}
}
}
return v7;
}
| ma_control_file_write_and_force:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x2b8
MOV R12D,ECX
MOV R14,RDX
MOV R13,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [0x004fbf00],RDI
SETNZ AL
CMP dword ptr [0x004fbf08],ESI
SETNZ DL
CMP qword ptr [0x004fbf10],R14
SETNZ DIL
TEST ECX,ECX
SETZ CL
MOV R15D,0x1
CMP dword ptr [0x00483190],0x0
JS 0x0014346e
MOV byte ptr [RBP + -0x2d1],DIL
MOV byte ptr [RBP + -0x2d2],DL
MOV byte ptr [RBP + -0x2d3],CL
MOV byte ptr [RBP + -0x2d4],AL
MOV RAX,R13
SHR RAX,0x20
LEA R15,[RBP + -0x22c]
MOV byte ptr [R15],AL
MOV RAX,R13
SHR RAX,0x28
MOV byte ptr [R15 + 0x1],AL
MOV RAX,R13
SHR RAX,0x30
MOV byte ptr [R15 + 0x2],AL
MOV dword ptr [R15 + 0x3],R13D
MOV dword ptr [R15 + 0x7],ESI
MOV dword ptr [R15 + 0xb],R14D
MOV RAX,R14
SHR RAX,0x20
MOV word ptr [R15 + 0xf],AX
MOV byte ptr [R15 + 0x11],R12B
MOV EBX,dword ptr [0x004fbf20]
CMP EBX,0x17
MOV dword ptr [RBP + -0x2dc],ESI
JC 0x00143396
MOV dword ptr [RBP + -0x2d8],R12D
LEA R12D,[RBX + -0x16]
LEA RDI,[RBP + -0x21a]
MOV ECX,0x1ea
XOR ESI,ESI
MOV RDX,R12
CALL 0x001297d0
ADD EBX,dword ptr [0x004fbf1c]
LEA RDX,[0x1d8ace]
LEA RDI,[RBP + -0x2d0]
MOV ESI,0x96
MOV ECX,R12D
MOV R12D,dword ptr [RBP + -0x2d8]
MOV R8D,EBX
XOR EAX,EAX
CALL 0x001d665e
LEA RSI,[0x1d8b34]
MOV EDX,0x800
MOV EDI,0xa8
LEA RCX,[RBP + -0x2d0]
XOR EAX,EAX
CALL 0x0019dc21
MOV EDX,dword ptr [0x004fbf20]
ADD EDX,-0x4
JMP 0x001433a5
LAB_00143396:
MOV dword ptr [0x004fbf20],0x16
MOV EDX,0x12
LAB_001433a5:
XOR EDI,EDI
MOV RSI,R15
CALL 0x001a7838
LEA RSI,[RBP + -0x230]
MOV dword ptr [RSI],EAX
MOV EDI,dword ptr [0x00483190]
MOV EDX,dword ptr [0x004fbf20]
MOV ECX,dword ptr [0x004fbf1c]
MOV R8D,0x12
CALL 0x001a00b2
TEST RAX,RAX
JZ 0x001433e5
MOV R15D,0x1
JMP 0x0014346e
LAB_001433e5:
MOV AL,byte ptr [RBP + -0x2d4]
OR AL,byte ptr [RBP + -0x2d2]
MOV CL,byte ptr [RBP + -0x2d3]
OR CL,byte ptr [RBP + -0x2d1]
OR CL,AL
MOV R15D,0x1
JZ 0x00143440
MOV EBX,dword ptr [0x00483190]
LEA RAX,[0x485010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x2d0]
MOV ESI,EBX
MOV EDX,0x10
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00143492
MOV ESI,0x10
MOV EDI,EBX
CALL 0x001a0d68
LAB_0014343c:
TEST EAX,EAX
JNZ 0x0014346e
LAB_00143440:
MOV qword ptr [0x004fbf00],R13
MOV EAX,dword ptr [RBP + -0x2dc]
MOV dword ptr [0x004fbf08],EAX
MOV qword ptr [0x004fbf10],R14
MOV byte ptr [0x004fbf18],R12B
MOV dword ptr [0x004fbf20],0x16
XOR R15D,R15D
LAB_0014346e:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001434b1
MOV EAX,R15D
ADD RSP,0x2b8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00143492:
LEA R15,[RBP + -0x2e0]
MOV RDI,RAX
MOV ESI,EBX
MOV RDX,R15
CALL 0x0012a779
MOV EAX,dword ptr [R15]
MOV R15D,0x1
JMP 0x0014343c
LAB_001434b1:
CALL 0x00129260
|
int8 ma_control_file_write_and_force(long param_1,int param_2,long param_3,int param_4)
{
uint uVar1;
long lVar2;
int iVar3;
int8 uVar4;
long in_FS_OFFSET;
int local_2e8;
int local_2e4;
int local_2e0;
char local_2dc;
char local_2db;
char local_2da;
char local_2d9;
int1 local_2d8 [160];
int4 local_238;
int1 local_234;
int1 local_233;
int1 local_232;
int4 local_231;
int local_22d;
int4 local_229;
int2 local_225;
int1 local_223;
int1 local_222 [490];
long local_38;
uVar1 = cf_changeable_size;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = 1;
if (-1 < control_file_fd) {
local_234 = (int1)((ulong)param_1 >> 0x20);
local_233 = (int1)((ulong)param_1 >> 0x28);
local_232 = (int1)((ulong)param_1 >> 0x30);
local_231 = (int4)param_1;
local_229 = (int4)param_3;
local_225 = (int2)((ulong)param_3 >> 0x20);
local_223 = (int1)param_4;
local_2e4 = param_2;
local_2dc = last_checkpoint_lsn != param_1;
local_2db = param_4 == 0;
local_2da = last_logno != param_2;
local_2d9 = max_trid_in_control_file != param_3;
local_22d = param_2;
if (cf_changeable_size < 0x17) {
cf_changeable_size = 0x16;
iVar3 = 0x12;
}
else {
iVar3 = cf_changeable_size - 0x16;
local_2e0 = param_4;
__memset_chk(local_222,0,iVar3,0x1ea);
param_4 = local_2e0;
my_snprintf(local_2d8,0x96,
"Control file must be from a newer version; zero-ing out %u unknown bytes in control file at offset %u"
,iVar3,uVar1 + cf_create_time_size);
my_printf_error(0xa8,"Aria engine: %s",0x800,local_2d8);
iVar3 = cf_changeable_size - 4;
}
local_238 = my_checksum(0,&local_234,iVar3);
lVar2 = my_pwrite(control_file_fd,&local_238,cf_changeable_size,cf_create_time_size,0x12);
iVar3 = control_file_fd;
if (lVar2 == 0) {
if ((local_2db != '\0' || local_2d9 != '\0') || (local_2dc != '\0' || local_2da != '\0')) {
lVar2 = (**(code **)(PSI_server + 0x158))(local_2d8,control_file_fd,0x10);
if (lVar2 == 0) {
local_2e8 = my_sync(iVar3,0x10);
}
else {
ma_control_file_write_and_force_cold_1(lVar2,iVar3,&local_2e8);
}
uVar4 = 1;
if (local_2e8 != 0) goto LAB_0014346e;
}
last_logno = local_2e4;
recovery_failures = (int1)param_4;
cf_changeable_size = 0x16;
uVar4 = 0;
last_checkpoint_lsn = param_1;
max_trid_in_control_file = param_3;
}
else {
uVar4 = 1;
}
}
LAB_0014346e:
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return uVar4;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
41,636 | write_hook_for_undo_bulk_insert | eloqsql/storage/maria/ma_blockrec.c | my_bool write_hook_for_undo_bulk_insert(enum translog_record_type type
__attribute__ ((unused)),
TRN *trn, MARIA_HA *tbl_info,
LSN *lsn, void *hook_arg)
{
/*
We are going to call maria_delete_all_rows(), but without logging and
syncing, as an optimization (if we crash before commit, the UNDO will
empty; if we crash after commit, we have flushed and forced the files).
Status still needs to be reset under log mutex, in case of a concurrent
checkpoint.
*/
_ma_reset_status(tbl_info);
return write_hook_for_undo(type, trn, tbl_info, lsn, hook_arg);
} | O0 | c | write_hook_for_undo_bulk_insert:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x765b0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x59cb0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| write_hook_for_undo_bulk_insert:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rdi, [rbp+var_18]
call _ma_reset_status
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
mov r8, [rbp+var_28]
call write_hook_for_undo
add rsp, 30h
pop rbp
retn
| long long write_hook_for_undo_bulk_insert(unsigned int a1, long long a2, long long a3, _QWORD *a4)
{
ma_reset_status(a3);
return write_hook_for_undo(a1, a2, a3, a4);
}
| write_hook_for_undo_bulk_insert:
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 qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001765b0
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x28]
CALL 0x00159cb0
ADD RSP,0x30
POP RBP
RET
|
void write_hook_for_undo_bulk_insert
(int4 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5)
{
_ma_reset_status(param_3);
write_hook_for_undo(param_1,param_2,param_3,param_4,param_5);
return;
}
| |
41,637 | pvio_socket_set_timeout | eloqsql/libmariadb/plugins/pvio/pvio_socket.c | my_bool pvio_socket_set_timeout(MARIADB_PVIO *pvio, enum enum_pvio_timeout type, int timeout)
{
struct st_pvio_socket *csock= NULL;
if (!pvio)
return 1;
csock= (struct st_pvio_socket *)pvio->data;
pvio->timeout[type]= (timeout > 0) ? timeout * 1000 : -1;
if (csock)
return pvio_socket_change_timeout(pvio, type, timeout * 1000);
return 0;
} | O3 | c | pvio_socket_set_timeout:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2e70d
movl %edx, %eax
imull $0x3e8, %edx, %edx # imm = 0x3E8
testl %eax, %eax
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovgl %edx, %eax
movl %esi, %ecx
cmpq $0x0, (%rdi)
movl %eax, 0x24(%rdi,%rcx,4)
je 0x2e711
popq %rbp
jmp 0x2f364
movb $0x1, %al
jmp 0x2e713
xorl %eax, %eax
popq %rbp
retq
| pvio_socket_set_timeout:
push rbp
mov rbp, rsp
test rdi, rdi
jz short loc_2E70D
mov eax, edx
imul edx, 3E8h
test eax, eax
mov eax, 0FFFFFFFFh
cmovg eax, edx
mov ecx, esi
cmp qword ptr [rdi], 0
mov [rdi+rcx*4+24h], eax
jz short loc_2E711
pop rbp
jmp pvio_socket_change_timeout
loc_2E70D:
mov al, 1
jmp short loc_2E713
loc_2E711:
xor eax, eax
loc_2E713:
pop rbp
retn
| char pvio_socket_set_timeout(_QWORD *a1, unsigned int a2, int a3)
{
int v4; // edx
bool v5; // cc
int v6; // eax
bool v7; // zf
if ( !a1 )
return 1;
v4 = 1000 * a3;
v5 = a3 <= 0;
v6 = -1;
if ( !v5 )
v6 = v4;
v7 = *a1 == 0LL;
*((_DWORD *)a1 + a2 + 9) = v6;
if ( v7 )
return 0;
else
return pvio_socket_change_timeout();
}
| pvio_socket_set_timeout:
PUSH RBP
MOV RBP,RSP
TEST RDI,RDI
JZ 0x0012e70d
MOV EAX,EDX
IMUL EDX,EDX,0x3e8
TEST EAX,EAX
MOV EAX,0xffffffff
CMOVG EAX,EDX
MOV ECX,ESI
CMP qword ptr [RDI],0x0
MOV dword ptr [RDI + RCX*0x4 + 0x24],EAX
JZ 0x0012e711
POP RBP
JMP 0x0012f364
LAB_0012e70d:
MOV AL,0x1
JMP 0x0012e713
LAB_0012e711:
XOR EAX,EAX
LAB_0012e713:
POP RBP
RET
|
int8 pvio_socket_set_timeout(long *param_1,uint param_2,int param_3)
{
long lVar1;
int iVar2;
int8 uVar3;
if (param_1 == (long *)0x0) {
uVar3 = 1;
}
else {
iVar2 = -1;
if (0 < param_3) {
iVar2 = param_3 * 1000;
}
lVar1 = *param_1;
*(int *)((long)param_1 + (ulong)param_2 * 4 + 0x24) = iVar2;
if (lVar1 != 0) {
uVar3 = pvio_socket_change_timeout();
return uVar3;
}
uVar3 = 0;
}
return uVar3;
}
| |
41,638 | cs_enter | eloqsql/strings/ctype.c | static int cs_enter(MY_XML_PARSER *st,const char *attr, size_t len)
{
struct my_cs_file_info *i= (struct my_cs_file_info *)st->user_data;
const struct my_cs_file_section_st *s= cs_file_sec(attr,len);
int state= s ? s->state : 0;
switch (state) {
case 0:
i->loader->reporter(WARNING_LEVEL, "Unknown LDML tag: '%.*s'", len, attr);
break;
case _CS_CHARSET:
my_charset_file_reset_charset(i);
break;
case _CS_COLLATION:
my_charset_file_reset_collation(i);
break;
case _CS_RESET:
return tailoring_append(st, " &", 0, NULL);
default:
break;
}
return MY_XML_OK;
} | O3 | c | cs_enter:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq 0x140(%rdi), %rbx
leaq 0x2b4195(%rip), %r13 # 0x38b2e0
leaq 0xb07e(%rip), %r12 # 0xe21d0
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x291c0
testl %eax, %eax
jne 0xd716b
cmpb $0x0, (%r12,%r15)
je 0xd71ab
movq 0x18(%r13), %r12
addq $0x10, %r13
testq %r12, %r12
jne 0xd7152
movq 0x7a8(%rbx), %r8
leaq 0xeda2(%rip), %rsi # 0xe5f28
movl $0x1, %edi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq *0xa0(%r8)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl (%r13), %eax
cmpl $0x8, %eax
jg 0xd71d5
testl %eax, %eax
je 0xd7178
cmpl $0x8, %eax
jne 0xd719a
addq $0x6e0, %rbx # imm = 0x6E0
movl $0xc8, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x292a0
jmp 0xd719a
cmpl $0x9, %eax
je 0xd7202
cmpl $0x12d, %eax # imm = 0x12D
jne 0xd719a
leaq 0xed59(%rip), %rsi # 0xe5f41
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd83a4
movq $0x0, 0x690(%rbx)
movb $0x0, 0x6a0(%rbx)
jmp 0xd719a
| cs_enter:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rdx
mov r14, rsi
mov rbx, [rdi+140h]
lea r13, sec
lea r12, aIndexXml+6; "xml"
loc_D7152:
mov rdi, r14
mov rsi, r12
mov rdx, r15
call _strncmp
test eax, eax
jnz short loc_D716B
cmp byte ptr [r12+r15], 0
jz short loc_D71AB
loc_D716B:
mov r12, [r13+18h]
add r13, 10h
test r12, r12
jnz short loc_D7152
loc_D7178:
mov r8, [rbx+7A8h]
lea rsi, aUnknownLdmlTag; "Unknown LDML tag: '%.*s'"
mov edi, 1
mov rdx, r15
mov rcx, r14
xor eax, eax
call qword ptr [r8+0A0h]
loc_D719A:
xor eax, eax
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_D71AB:
mov eax, [r13+0]
cmp eax, 8
jg short loc_D71D5
test eax, eax
jz short loc_D7178
cmp eax, 8
jnz short loc_D719A
add rbx, 6E0h
mov edx, 0C8h
mov rdi, rbx
xor esi, esi
call _memset
jmp short loc_D719A
loc_D71D5:
cmp eax, 9
jz short loc_D7202
cmp eax, 12Dh
jnz short loc_D719A
lea rsi, asc_E5F41; " &"
mov rdi, rbx
xor edx, edx
xor ecx, ecx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp tailoring_append
loc_D7202:
mov qword ptr [rbx+690h], 0
mov byte ptr [rbx+6A0h], 0
jmp short loc_D719A
| long long cs_enter(long long a1, const char *a2, long long a3, long long a4)
{
long long v5; // rbx
char *v6; // r13
char *v7; // r12
int v9; // eax
v5 = *(_QWORD *)(a1 + 320);
v6 = (char *)&sec;
v7 = "xml";
while ( (unsigned int)strncmp(a2, v7, a3, a4) || v7[a3] )
{
v7 = (char *)*((_QWORD *)v6 + 3);
v6 += 16;
if ( !v7 )
goto LABEL_5;
}
v9 = *(_DWORD *)v6;
if ( *(int *)v6 <= 8 )
{
if ( v9 )
{
if ( v9 == 8 )
memset(v5 + 1760, 0LL, 200LL);
}
else
{
LABEL_5:
(*(void (**)(long long, const char *, ...))(*(_QWORD *)(v5 + 1960) + 160LL))(
1LL,
"Unknown LDML tag: '%.*s'",
a3,
a2);
}
return 0LL;
}
if ( v9 == 9 )
{
*(_QWORD *)(v5 + 1680) = 0LL;
*(_BYTE *)(v5 + 1696) = 0;
return 0LL;
}
if ( v9 != 301 )
return 0LL;
return tailoring_append(v5, " &", 0LL, 0LL);
}
| cs_enter:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV R14,RSI
MOV RBX,qword ptr [RDI + 0x140]
LEA R13,[0x48b2e0]
LEA R12,[0x1e21d0]
LAB_001d7152:
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
CALL 0x001291c0
TEST EAX,EAX
JNZ 0x001d716b
CMP byte ptr [R12 + R15*0x1],0x0
JZ 0x001d71ab
LAB_001d716b:
MOV R12,qword ptr [R13 + 0x18]
ADD R13,0x10
TEST R12,R12
JNZ 0x001d7152
LAB_001d7178:
MOV R8,qword ptr [RBX + 0x7a8]
LEA RSI,[0x1e5f28]
MOV EDI,0x1
MOV RDX,R15
MOV RCX,R14
XOR EAX,EAX
CALL qword ptr [R8 + 0xa0]
LAB_001d719a:
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001d71ab:
MOV EAX,dword ptr [R13]
CMP EAX,0x8
JG 0x001d71d5
TEST EAX,EAX
JZ 0x001d7178
CMP EAX,0x8
JNZ 0x001d719a
ADD RBX,0x6e0
MOV EDX,0xc8
MOV RDI,RBX
XOR ESI,ESI
CALL 0x001292a0
JMP 0x001d719a
LAB_001d71d5:
CMP EAX,0x9
JZ 0x001d7202
CMP EAX,0x12d
JNZ 0x001d719a
LEA RSI,[0x1e5f41]
MOV RDI,RBX
XOR EDX,EDX
XOR ECX,ECX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001d83a4
LAB_001d7202:
MOV qword ptr [RBX + 0x690],0x0
MOV byte ptr [RBX + 0x6a0],0x0
JMP 0x001d719a
|
int8 cs_enter(long param_1,char *param_2,size_t param_3)
{
long lVar1;
int iVar2;
int8 uVar3;
char *__s2;
int *piVar4;
lVar1 = *(long *)(param_1 + 0x140);
piVar4 = &sec;
__s2 = "xml";
while ((iVar2 = strncmp(param_2,__s2,param_3), iVar2 != 0 || (__s2[param_3] != '\0'))) {
__s2 = *(char **)(piVar4 + 6);
piVar4 = piVar4 + 4;
if (__s2 == (char *)0x0) {
LAB_001d7178:
(**(code **)(*(long *)(lVar1 + 0x7a8) + 0xa0))(1,"Unknown LDML tag: \'%.*s\'",param_3,param_2)
;
return 0;
}
}
iVar2 = *piVar4;
if (8 < iVar2) {
if (iVar2 == 9) {
*(int8 *)(lVar1 + 0x690) = 0;
*(int1 *)(lVar1 + 0x6a0) = 0;
return 0;
}
if (iVar2 != 0x12d) {
return 0;
}
uVar3 = tailoring_append(lVar1,&DAT_001e5f41,0,0);
return uVar3;
}
if (iVar2 != 0) {
if (iVar2 != 8) {
return 0;
}
memset((void *)(lVar1 + 0x6e0),0,200);
return 0;
}
goto LAB_001d7178;
}
| |
41,639 | OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::addMeshControlVertex(int) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/irregularPatchBuilder.cpp | void
IrregularPatchBuilder::addMeshControlVertex(Index meshVertIndex) {
if (_controlVertMap.find(meshVertIndex) == _controlVertMap.end()) {
int newLocalVertIndex = (int) _controlVerts.size();
_controlVertMap[meshVertIndex] = newLocalVertIndex;
_controlVerts.push_back(meshVertIndex);
}
} | O2 | cpp | OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::addMeshControlVertex(int):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x4(%rsp), %rax
movl %esi, (%rax)
leaq 0xe0(%rdi), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x554a0
leaq 0xe8(%r14), %rcx
cmpq %rcx, %rax
jne 0x98975
leaq 0x110(%r14), %r15
movq 0x118(%r14), %r12
subq 0x110(%r14), %r12
shrq $0x2, %r12
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x511d0
movl %r12d, (%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0x4f610
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| _ZN10OpenSubdiv6v3_6_03Bfr21IrregularPatchBuilder20addMeshControlVertexEi:
push r15
push r14
push r12
push rbx
push rax
mov r14, rdi
lea rax, [rsp+28h+var_24]
mov [rax], esi
lea rbx, [rdi+0E0h]
mov rdi, rbx
mov rsi, rax
call __ZNSt8_Rb_treeIiSt4pairIKiiESt10_Select1stIS2_ESt4lessIiESaIS2_EE4findERS1_; std::_Rb_tree<int,std::pair<int const,int>,std::_Select1st<std::pair<int const,int>>,std::less<int>,std::allocator<std::pair<int const,int>>>::find(int const&)
lea rcx, [r14+0E8h]
cmp rax, rcx
jnz short loc_98975
lea r15, [r14+110h]
mov r12, [r14+118h]
sub r12, [r14+110h]
shr r12, 2
lea r14, [rsp+28h+var_24]
mov rdi, rbx
mov rsi, r14
call __ZNSt3mapIiiSt4lessIiESaISt4pairIKiiEEEixERS3_; std::map<int,int>::operator[](int const&)
mov [rax], r12d
mov rdi, r15
mov rsi, r14
call __ZNSt6vectorIiSaIiEE9push_backERKi; std::vector<int>::push_back(int const&)
loc_98975:
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder * OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::addMeshControlVertex(
OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder *this,
int a2)
{
OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder *result; // rax
long long v3; // r12
_DWORD v4[9]; // [rsp+0h] [rbp-24h] BYREF
v4[0] = a2;
result = (OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder *)std::_Rb_tree<int,std::pair<int const,int>,std::_Select1st<std::pair<int const,int>>,std::less<int>,std::allocator<std::pair<int const,int>>>::find(
(char *)this + 224,
v4);
if ( result == (OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder *)((char *)this + 232) )
{
v3 = (*((_QWORD *)this + 35) - *((_QWORD *)this + 34)) >> 2;
*(_DWORD *)std::map<int,int>::operator[]((char *)this + 224, v4) = v3;
return (OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder *)std::vector<int>::push_back((char *)this + 272, v4);
}
return result;
}
| addMeshControlVertex:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDI
LEA RAX,[RSP + 0x4]
MOV dword ptr [RAX],ESI
LEA RBX,[RDI + 0xe0]
MOV RDI,RBX
MOV RSI,RAX
CALL 0x001554a0
LEA RCX,[R14 + 0xe8]
CMP RAX,RCX
JNZ 0x00198975
LEA R15,[R14 + 0x110]
MOV R12,qword ptr [R14 + 0x118]
SUB R12,qword ptr [R14 + 0x110]
SHR R12,0x2
LEA R14,[RSP + 0x4]
MOV RDI,RBX
MOV RSI,R14
CALL 0x001511d0
MOV dword ptr [RAX],R12D
MOV RDI,R15
MOV RSI,R14
CALL 0x0014f610
LAB_00198975:
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::addMeshControlVertex(int) */
void OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::addMeshControlVertex(int param_1)
{
long lVar1;
long lVar2;
int4 *puVar3;
int4 in_register_0000003c;
long lVar4;
int local_24;
lVar4 = CONCAT44(in_register_0000003c,param_1);
lVar2 = std::
_Rb_tree<int,std::pair<int_const,int>,std::_Select1st<std::pair<int_const,int>>,std::less<int>,std::allocator<std::pair<int_const,int>>>
::find((_Rb_tree<int,std::pair<int_const,int>,std::_Select1st<std::pair<int_const,int>>,std::less<int>,std::allocator<std::pair<int_const,int>>>
*)(lVar4 + 0xe0),&local_24);
if (lVar2 == lVar4 + 0xe8) {
lVar2 = *(long *)(lVar4 + 0x118);
lVar1 = *(long *)(lVar4 + 0x110);
puVar3 = (int4 *)
std::map<int,int,std::less<int>,std::allocator<std::pair<int_const,int>>>::operator[]
((map<int,int,std::less<int>,std::allocator<std::pair<int_const,int>>> *)
(lVar4 + 0xe0),&local_24);
*puVar3 = (int)((ulong)(lVar2 - lVar1) >> 2);
std::vector<int,std::allocator<int>>::push_back
((vector<int,std::allocator<int>> *)(lVar4 + 0x110),&local_24);
}
return;
}
| |
41,640 | OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::addMeshControlVertex(int) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/irregularPatchBuilder.cpp | void
IrregularPatchBuilder::addMeshControlVertex(Index meshVertIndex) {
if (_controlVertMap.find(meshVertIndex) == _controlVertMap.end()) {
int newLocalVertIndex = (int) _controlVerts.size();
_controlVertMap[meshVertIndex] = newLocalVertIndex;
_controlVerts.push_back(meshVertIndex);
}
} | O3 | cpp | OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::addMeshControlVertex(int):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, 0x4(%rsp)
movq 0xf0(%rdi), %rax
testq %rax, %rax
je 0x8c2c6
leaq 0xe8(%rbx), %rdx
movq %rdx, %rcx
xorl %edi, %edi
cmpl %esi, 0x20(%rax)
setl %dil
cmovgeq %rax, %rcx
movq 0x10(%rax,%rdi,8), %rax
testq %rax, %rax
jne 0x8c2a5
cmpq %rdx, %rcx
je 0x8c2c6
cmpl %esi, 0x20(%rcx)
jle 0x8c323
leaq 0xe0(%rbx), %rdi
movq 0x118(%rbx), %r14
subq 0x110(%rbx), %r14
shrq $0x2, %r14
leaq 0x4(%rsp), %rsi
callq 0x394b0
movl %r14d, (%rax)
movq 0x118(%rbx), %rsi
cmpq 0x120(%rbx), %rsi
je 0x8c30f
movl 0x4(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x118(%rbx)
jmp 0x8c323
addq $0x110, %rbx # imm = 0x110
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0x38ba0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| _ZN10OpenSubdiv6v3_6_03Bfr21IrregularPatchBuilder20addMeshControlVertexEi:
push r14
push rbx
push rax
mov rbx, rdi
mov [rsp+18h+var_14], esi
mov rax, [rdi+0F0h]
test rax, rax
jz short loc_8C2C6
lea rdx, [rbx+0E8h]
mov rcx, rdx
loc_8C2A5:
xor edi, edi
cmp [rax+20h], esi
setl dil
cmovge rcx, rax
mov rax, [rax+rdi*8+10h]
test rax, rax
jnz short loc_8C2A5
cmp rcx, rdx
jz short loc_8C2C6
cmp [rcx+20h], esi
jle short loc_8C323
loc_8C2C6:
lea rdi, [rbx+0E0h]
mov r14, [rbx+118h]
sub r14, [rbx+110h]
shr r14, 2
lea rsi, [rsp+18h+var_14]
call __ZNSt3mapIiiSt4lessIiESaISt4pairIKiiEEEixERS3_; std::map<int,int>::operator[](int const&)
mov [rax], r14d
mov rsi, [rbx+118h]
cmp rsi, [rbx+120h]
jz short loc_8C30F
mov eax, [rsp+18h+var_14]
mov [rsi], eax
add rsi, 4
mov [rbx+118h], rsi
jmp short loc_8C323
loc_8C30F:
add rbx, 110h
lea rdx, [rsp+18h+var_14]
mov rdi, rbx
call __ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_; std::vector<int>::_M_realloc_insert<int const&>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,int const&)
loc_8C323:
add rsp, 8
pop rbx
pop r14
retn
| long long OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::addMeshControlVertex(
OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder *this,
int a2)
{
long long result; // rax
_DWORD *v3; // rcx
long long v4; // r14
_DWORD *v5; // rsi
_DWORD v6[5]; // [rsp+0h] [rbp-14h] BYREF
v6[0] = a2;
result = *((_QWORD *)this + 30);
if ( !result )
goto LABEL_8;
v3 = (_DWORD *)((char *)this + 232);
do
{
if ( *(_DWORD *)(result + 32) >= a2 )
v3 = (_DWORD *)result;
result = *(_QWORD *)(result + 8LL * (*(_DWORD *)(result + 32) < a2) + 16);
}
while ( result );
if ( v3 == (_DWORD *)((char *)this + 232) || v3[8] > a2 )
{
LABEL_8:
v4 = (*((_QWORD *)this + 35) - *((_QWORD *)this + 34)) >> 2;
*(_DWORD *)std::map<int,int>::operator[]((char *)this + 224, v6) = v4;
v5 = (_DWORD *)*((_QWORD *)this + 35);
if ( v5 == *((_DWORD **)this + 36) )
{
return std::vector<int>::_M_realloc_insert<int const&>((char *)this + 272, v5, v6);
}
else
{
result = v6[0];
*v5 = v6[0];
*((_QWORD *)this + 35) = v5 + 1;
}
}
return result;
}
| addMeshControlVertex:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV dword ptr [RSP + 0x4],ESI
MOV RAX,qword ptr [RDI + 0xf0]
TEST RAX,RAX
JZ 0x0018c2c6
LEA RDX,[RBX + 0xe8]
MOV RCX,RDX
LAB_0018c2a5:
XOR EDI,EDI
CMP dword ptr [RAX + 0x20],ESI
SETL DIL
CMOVGE RCX,RAX
MOV RAX,qword ptr [RAX + RDI*0x8 + 0x10]
TEST RAX,RAX
JNZ 0x0018c2a5
CMP RCX,RDX
JZ 0x0018c2c6
CMP dword ptr [RCX + 0x20],ESI
JLE 0x0018c323
LAB_0018c2c6:
LEA RDI,[RBX + 0xe0]
MOV R14,qword ptr [RBX + 0x118]
SUB R14,qword ptr [RBX + 0x110]
SHR R14,0x2
LEA RSI,[RSP + 0x4]
CALL 0x001394b0
MOV dword ptr [RAX],R14D
MOV RSI,qword ptr [RBX + 0x118]
CMP RSI,qword ptr [RBX + 0x120]
JZ 0x0018c30f
MOV EAX,dword ptr [RSP + 0x4]
MOV dword ptr [RSI],EAX
ADD RSI,0x4
MOV qword ptr [RBX + 0x118],RSI
JMP 0x0018c323
LAB_0018c30f:
ADD RBX,0x110
LEA RDX,[RSP + 0x4]
MOV RDI,RBX
CALL 0x00138ba0
LAB_0018c323:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::addMeshControlVertex(int) */
void __thiscall
OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::addMeshControlVertex
(IrregularPatchBuilder *this,int param_1)
{
long lVar1;
long lVar2;
int *piVar3;
IrregularPatchBuilder *pIVar4;
int4 *puVar5;
IrregularPatchBuilder *pIVar6;
int local_14;
pIVar4 = *(IrregularPatchBuilder **)(this + 0xf0);
if (pIVar4 != (IrregularPatchBuilder *)0x0) {
pIVar6 = this + 0xe8;
do {
if (param_1 <= *(int *)(pIVar4 + 0x20)) {
pIVar6 = pIVar4;
}
pIVar4 = *(IrregularPatchBuilder **)
(pIVar4 + (ulong)(*(int *)(pIVar4 + 0x20) < param_1) * 8 + 0x10);
} while (pIVar4 != (IrregularPatchBuilder *)0x0);
if ((pIVar6 != this + 0xe8) && (*(int *)(pIVar6 + 0x20) <= param_1)) {
return;
}
}
lVar1 = *(long *)(this + 0x118);
lVar2 = *(long *)(this + 0x110);
local_14 = param_1;
puVar5 = (int4 *)
std::map<int,int,std::less<int>,std::allocator<std::pair<int_const,int>>>::operator[]
((map<int,int,std::less<int>,std::allocator<std::pair<int_const,int>>> *)
(this + 0xe0),&local_14);
*puVar5 = (int)((ulong)(lVar1 - lVar2) >> 2);
piVar3 = *(int **)(this + 0x118);
if (piVar3 == *(int **)(this + 0x120)) {
std::vector<int,std::allocator<int>>::_M_realloc_insert<int_const&>
((vector<int,std::allocator<int>> *)(this + 0x110),piVar3,&local_14);
}
else {
*piVar3 = local_14;
*(int **)(this + 0x118) = piVar3 + 1;
}
return;
}
| |
41,641 | add_export_entry2 | bluesky950520[P]quickjs/quickjs.c | static JSExportEntry *add_export_entry2(JSContext *ctx,
JSParseState *s, JSModuleDef *m,
JSAtom local_name, JSAtom export_name,
JSExportTypeEnum export_type)
{
JSExportEntry *me;
if (find_export_entry(ctx, m, export_name)) {
char buf1[ATOM_GET_STR_BUF_SIZE];
if (s) {
js_parse_error(s, "duplicate exported name '%s'",
JS_AtomGetStr(ctx, buf1, sizeof(buf1), export_name));
} else {
JS_ThrowSyntaxErrorAtom(ctx, "duplicate exported name '%s'", export_name);
}
return NULL;
}
if (js_resize_array(ctx, (void **)&m->export_entries,
sizeof(JSExportEntry),
&m->export_entries_size,
m->export_entries_count + 1))
return NULL;
me = &m->export_entries[m->export_entries_count++];
memset(me, 0, sizeof(*me));
me->local_name = JS_DupAtom(ctx, local_name);
me->export_name = JS_DupAtom(ctx, export_name);
me->export_type = export_type;
return me;
} | O2 | c | add_export_entry2:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %ebp
movl %r8d, %ebx
movl %ecx, %r15d
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq %rdx, %rdi
movl %r8d, %esi
callq 0x2910e
testq %rax, %rax
je 0x28ff4
testq %r13, %r13
je 0x29079
movq %rsp, %rsi
movq %r14, %rdi
movl %ebx, %edx
callq 0x2f335
leaq 0x5d6a2(%rip), %rsi # 0x86684
movq %r13, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x28457
jmp 0x2908a
leaq 0x28(%r12), %rsi
leaq 0x34(%r12), %rcx
movl 0x30(%r12), %r8d
incl %r8d
pushq $0x20
popq %rdx
movq %r14, %rdi
callq 0x3b0ef
testl %eax, %eax
jne 0x2908a
movq 0x28(%r12), %rcx
movslq 0x30(%r12), %rdx
leal 0x1(%rdx), %eax
movl %eax, 0x30(%r12)
shlq $0x5, %rdx
leaq (%rcx,%rdx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rcx,%rdx)
movups %xmm0, (%rcx,%rdx)
cmpl $0xe0, %r15d
jl 0x29055
movq 0x18(%r14), %rcx
movq 0x68(%rcx), %rcx
movl %r15d, %edx
movq (%rcx,%rdx,8), %rcx
incl (%rcx)
movl %r15d, 0x14(%rax)
cmpl $0xe0, %ebx
jl 0x29071
movq 0x18(%r14), %rcx
movq 0x68(%rcx), %rcx
movl %ebx, %edx
movq (%rcx,%rdx,8), %rcx
incl (%rcx)
movl %ebx, 0x18(%rax)
movl %ebp, 0x10(%rax)
jmp 0x2908c
leaq 0x5d604(%rip), %rdx # 0x86684
movq %r14, %rdi
movl %ebx, %esi
callq 0x394c3
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| add_export_entry2:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov ebp, r9d
mov ebx, r8d
mov r15d, ecx
mov r12, rdx
mov r13, rsi
mov r14, rdi
mov rdi, rdx
mov esi, r8d
call find_export_entry
test rax, rax
jz short loc_28FF4
test r13, r13
jz loc_29079
mov rsi, rsp
mov rdi, r14
mov edx, ebx
call JS_AtomGetStr
lea rsi, aDuplicateExpor; "duplicate exported name '%s'"
mov rdi, r13
mov rdx, rax
xor eax, eax
call js_parse_error
jmp loc_2908A
loc_28FF4:
lea rsi, [r12+28h]
lea rcx, [r12+34h]
mov r8d, [r12+30h]
inc r8d
push 20h ; ' '
pop rdx
mov rdi, r14
call js_resize_array
test eax, eax
jnz short loc_2908A
mov rcx, [r12+28h]
movsxd rdx, dword ptr [r12+30h]
lea eax, [rdx+1]
mov [r12+30h], eax
shl rdx, 5
lea rax, [rcx+rdx]
xorps xmm0, xmm0
movups xmmword ptr [rcx+rdx+10h], xmm0
movups xmmword ptr [rcx+rdx], xmm0
cmp r15d, 0E0h
jl short loc_29055
mov rcx, [r14+18h]
mov rcx, [rcx+68h]
mov edx, r15d
mov rcx, [rcx+rdx*8]
inc dword ptr [rcx]
loc_29055:
mov [rax+14h], r15d
cmp ebx, 0E0h
jl short loc_29071
mov rcx, [r14+18h]
mov rcx, [rcx+68h]
mov edx, ebx
mov rcx, [rcx+rdx*8]
inc dword ptr [rcx]
loc_29071:
mov [rax+18h], ebx
mov [rax+10h], ebp
jmp short loc_2908C
loc_29079:
lea rdx, aDuplicateExpor; "duplicate exported name '%s'"
mov rdi, r14
mov esi, ebx
call __JS_ThrowSyntaxErrorAtom
loc_2908A:
xor eax, eax
loc_2908C:
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long add_export_entry2(
long long a1,
long long *a2,
long long a3,
int a4,
unsigned int a5,
int a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14)
{
const char *v18; // rcx
long long Str; // rax
long long v20; // rcx
long long v21; // r8
long long v22; // r9
__m128 v23; // xmm4
__m128 v24; // xmm5
long long v25; // rcx
long long v26; // rdx
long long result; // rax
_DWORD *v28; // rcx
_DWORD *v29; // rcx
char v30[120]; // [rsp+0h] [rbp-78h] BYREF
if ( find_export_entry(a3, a5) )
{
if ( a2 )
{
Str = JS_AtomGetStr(a1, v30, a5);
js_parse_error(
a2,
(long long)"duplicate exported name '%s'",
Str,
v20,
v21,
v22,
a7,
a8,
a9,
a10,
v23,
v24,
a13,
a14,
v30[0]);
}
else
{
_JS_ThrowSyntaxErrorAtom(a1, a5, "duplicate exported name '%s'", v18);
}
return 0LL;
}
if ( (unsigned int)js_resize_array(a1, a3 + 40, 32LL, a3 + 52, (unsigned int)(*(_DWORD *)(a3 + 48) + 1)) )
return 0LL;
v25 = *(_QWORD *)(a3 + 40);
v26 = *(int *)(a3 + 48);
*(_DWORD *)(a3 + 48) = v26 + 1;
result = v25 + 32 * v26;
*(_OWORD *)(result + 16) = 0LL;
*(_OWORD *)result = 0LL;
if ( a4 >= 224 )
{
v28 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL) + 8LL * (unsigned int)a4);
++*v28;
}
*(_DWORD *)(result + 20) = a4;
if ( (int)a5 >= 224 )
{
v29 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL) + 8LL * a5);
++*v29;
}
*(_DWORD *)(result + 24) = a5;
*(_DWORD *)(result + 16) = a6;
return result;
}
| add_export_entry2:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV EBP,R9D
MOV EBX,R8D
MOV R15D,ECX
MOV R12,RDX
MOV R13,RSI
MOV R14,RDI
MOV RDI,RDX
MOV ESI,R8D
CALL 0x0012910e
TEST RAX,RAX
JZ 0x00128ff4
TEST R13,R13
JZ 0x00129079
MOV RSI,RSP
MOV RDI,R14
MOV EDX,EBX
CALL 0x0012f335
LEA RSI,[0x186684]
MOV RDI,R13
MOV RDX,RAX
XOR EAX,EAX
CALL 0x00128457
JMP 0x0012908a
LAB_00128ff4:
LEA RSI,[R12 + 0x28]
LEA RCX,[R12 + 0x34]
MOV R8D,dword ptr [R12 + 0x30]
INC R8D
PUSH 0x20
POP RDX
MOV RDI,R14
CALL 0x0013b0ef
TEST EAX,EAX
JNZ 0x0012908a
MOV RCX,qword ptr [R12 + 0x28]
MOVSXD RDX,dword ptr [R12 + 0x30]
LEA EAX,[RDX + 0x1]
MOV dword ptr [R12 + 0x30],EAX
SHL RDX,0x5
LEA RAX,[RCX + RDX*0x1]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RCX + RDX*0x1 + 0x10],XMM0
MOVUPS xmmword ptr [RCX + RDX*0x1],XMM0
CMP R15D,0xe0
JL 0x00129055
MOV RCX,qword ptr [R14 + 0x18]
MOV RCX,qword ptr [RCX + 0x68]
MOV EDX,R15D
MOV RCX,qword ptr [RCX + RDX*0x8]
INC dword ptr [RCX]
LAB_00129055:
MOV dword ptr [RAX + 0x14],R15D
CMP EBX,0xe0
JL 0x00129071
MOV RCX,qword ptr [R14 + 0x18]
MOV RCX,qword ptr [RCX + 0x68]
MOV EDX,EBX
MOV RCX,qword ptr [RCX + RDX*0x8]
INC dword ptr [RCX]
LAB_00129071:
MOV dword ptr [RAX + 0x18],EBX
MOV dword ptr [RAX + 0x10],EBP
JMP 0x0012908c
LAB_00129079:
LEA RDX,[0x186684]
MOV RDI,R14
MOV ESI,EBX
CALL 0x001394c3
LAB_0012908a:
XOR EAX,EAX
LAB_0012908c:
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long add_export_entry2(long param_1,long param_2,long param_3,uint param_4,uint param_5,
int4 param_6)
{
int8 *puVar1;
long lVar2;
int *piVar3;
int iVar4;
long lVar5;
int8 uVar6;
long lVar7;
ulong uVar8;
int1 auStack_78 [72];
uVar8 = (ulong)param_5;
lVar5 = find_export_entry(param_3,param_5);
if (lVar5 == 0) {
iVar4 = js_resize_array(param_1,param_3 + 0x28,0x20,param_3 + 0x34,*(int *)(param_3 + 0x30) + 1)
;
if (iVar4 == 0) {
lVar2 = *(long *)(param_3 + 0x28);
iVar4 = *(int *)(param_3 + 0x30);
*(int *)(param_3 + 0x30) = iVar4 + 1;
lVar7 = (long)iVar4 * 0x20;
lVar5 = lVar2 + lVar7;
puVar1 = (int8 *)(lVar2 + 0x10 + lVar7);
*puVar1 = 0;
puVar1[1] = 0;
*(int8 *)(lVar2 + lVar7) = 0;
((int8 *)(lVar2 + lVar7))[1] = 0;
if (0xdf < (int)param_4) {
piVar3 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + (ulong)param_4 * 8);
*piVar3 = *piVar3 + 1;
}
*(uint *)(lVar5 + 0x14) = param_4;
if (0xdf < (int)param_5) {
piVar3 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + uVar8 * 8);
*piVar3 = *piVar3 + 1;
}
*(uint *)(lVar5 + 0x18) = param_5;
*(int4 *)(lVar5 + 0x10) = param_6;
return lVar5;
}
}
else if (param_2 == 0) {
__JS_ThrowSyntaxErrorAtom(param_1,uVar8,"duplicate exported name \'%s\'");
}
else {
uVar6 = JS_AtomGetStr(param_1,auStack_78,uVar8);
js_parse_error(param_2,"duplicate exported name \'%s\'",uVar6);
}
return 0;
}
| |
41,642 | ggml_gallocr_alloc_graph | monkey531[P]llama/ggml/src/ggml-alloc.c | bool ggml_gallocr_alloc_graph(ggml_gallocr_t galloc, struct ggml_cgraph * graph) {
if (ggml_gallocr_needs_realloc(galloc, graph)) {
if (galloc->n_buffers == 1) {
#ifndef NDEBUG
GGML_LOG_DEBUG("%s: reallocating buffers automatically\n", __func__);
#endif
if (!ggml_gallocr_reserve(galloc, graph)) {
return false;
}
} else {
#ifndef NDEBUG
GGML_LOG_DEBUG("%s: cannot reallocate multi buffer graph automatically, call reserve\n", __func__);
#endif
return false;
}
}
// reset buffers
for (int i = 0; i < galloc->n_buffers; i++) {
if (galloc->buffers[i] != NULL) {
ggml_backend_buffer_reset(galloc->buffers[i]);
}
}
// allocate the graph tensors from the previous assignments
// leafs
for (int i = 0; i < graph->n_leafs; i++) {
struct ggml_tensor * leaf = graph->leafs[i];
struct leaf_alloc * leaf_alloc = &galloc->leaf_allocs[i];
ggml_gallocr_init_tensor(galloc, leaf, &leaf_alloc->leaf);
}
// nodes
for (int i = 0; i < graph->n_nodes; i++) {
struct ggml_tensor * node = graph->nodes[i];
struct node_alloc * node_alloc = &galloc->node_allocs[i];
for (int j = 0; j < GGML_MAX_SRC; j++) {
struct ggml_tensor * src = node->src[j];
if (src == NULL) {
continue;
}
ggml_gallocr_init_tensor(galloc, src, &node_alloc->src[j]);
}
ggml_gallocr_init_tensor(galloc, node, &node_alloc->dst);
}
return true;
} | O0 | c | ggml_gallocr_alloc_graph:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x5be70
testb $0x1, %al
jne 0x5bc93
jmp 0x5bcc9
movq 0x48(%rsp), %rax
cmpl $0x1, 0x18(%rax)
jne 0x5bcbd
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x45330
testb $0x1, %al
jne 0x5bcbb
movb $0x0, 0x57(%rsp)
jmp 0x5be57
jmp 0x5bcc7
movb $0x0, 0x57(%rsp)
jmp 0x5be57
jmp 0x5bcc9
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movq 0x48(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x5bd1a
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x3c(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x5bd0b
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x3c(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x44640
jmp 0x5bd0d
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x5bcd1
movl $0x0, 0x38(%rsp)
movl 0x38(%rsp), %eax
movq 0x40(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x5bd82
movq 0x40(%rsp), %rax
movq 0x28(%rax), %rax
movslq 0x38(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq 0x50(%rax), %rax
movslq 0x38(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x5bfc0
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x5bd22
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x40(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x5be52
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq 0x40(%rax), %rax
movslq 0x24(%rsp), %rcx
imulq $0x108, %rcx, %rcx # imm = 0x108
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0xa, 0xc(%rsp)
jge 0x5be2e
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq 0x98(%rax,%rcx,8), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x5bdfe
jmp 0x5be21
movq 0x48(%rsp), %rdi
movq (%rsp), %rsi
movq 0x10(%rsp), %rdx
addq $0x18, %rdx
movslq 0xc(%rsp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdx
callq 0x5bfc0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5bdd8
movq 0x48(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x5bfc0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x5bd8a
movb $0x1, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
| ggml_gallocr_alloc_graph:
sub rsp, 58h
mov [rsp+58h+var_10], rdi
mov [rsp+58h+var_18], rsi
mov rdi, [rsp+58h+var_10]
mov rsi, [rsp+58h+var_18]
call ggml_gallocr_needs_realloc
test al, 1
jnz short loc_5BC93
jmp short loc_5BCC9
loc_5BC93:
mov rax, [rsp+58h+var_10]
cmp dword ptr [rax+18h], 1
jnz short loc_5BCBD
mov rdi, [rsp+58h+var_10]
mov rsi, [rsp+58h+var_18]
call _ggml_gallocr_reserve
test al, 1
jnz short loc_5BCBB
mov [rsp+58h+var_1], 0
jmp loc_5BE57
loc_5BCBB:
jmp short loc_5BCC7
loc_5BCBD:
mov [rsp+58h+var_1], 0
jmp loc_5BE57
loc_5BCC7:
jmp short $+2
loc_5BCC9:
mov [rsp+58h+var_1C], 0
loc_5BCD1:
mov eax, [rsp+58h+var_1C]
mov rcx, [rsp+58h+var_10]
cmp eax, [rcx+18h]
jge short loc_5BD1A
mov rax, [rsp+58h+var_10]
mov rax, [rax+8]
movsxd rcx, [rsp+58h+var_1C]
cmp qword ptr [rax+rcx*8], 0
jz short loc_5BD0B
mov rax, [rsp+58h+var_10]
mov rax, [rax+8]
movsxd rcx, [rsp+58h+var_1C]
mov rdi, [rax+rcx*8]
call _ggml_backend_buffer_reset
loc_5BD0B:
jmp short $+2
loc_5BD0D:
mov eax, [rsp+58h+var_1C]
add eax, 1
mov [rsp+58h+var_1C], eax
jmp short loc_5BCD1
loc_5BD1A:
mov [rsp+58h+var_20], 0
loc_5BD22:
mov eax, [rsp+58h+var_20]
mov rcx, [rsp+58h+var_18]
cmp eax, [rcx+8]
jge short loc_5BD82
mov rax, [rsp+58h+var_18]
mov rax, [rax+28h]
movsxd rcx, [rsp+58h+var_20]
mov rax, [rax+rcx*8]
mov [rsp+58h+var_28], rax
mov rax, [rsp+58h+var_10]
mov rax, [rax+50h]
movsxd rcx, [rsp+58h+var_20]
imul rcx, 18h
add rax, rcx
mov [rsp+58h+var_30], rax
mov rdi, [rsp+58h+var_10]
mov rsi, [rsp+58h+var_28]
mov rdx, [rsp+58h+var_30]
call ggml_gallocr_init_tensor
mov eax, [rsp+58h+var_20]
add eax, 1
mov [rsp+58h+var_20], eax
jmp short loc_5BD22
loc_5BD82:
mov [rsp+58h+var_34], 0
loc_5BD8A:
mov eax, [rsp+58h+var_34]
mov rcx, [rsp+58h+var_18]
cmp eax, [rcx+4]
jge loc_5BE52
mov rax, [rsp+58h+var_18]
mov rax, [rax+10h]
movsxd rcx, [rsp+58h+var_34]
mov rax, [rax+rcx*8]
mov [rsp+58h+var_40], rax
mov rax, [rsp+58h+var_10]
mov rax, [rax+40h]
movsxd rcx, [rsp+58h+var_34]
imul rcx, 108h
add rax, rcx
mov [rsp+58h+var_48], rax
mov [rsp+58h+var_4C], 0
loc_5BDD8:
cmp [rsp+58h+var_4C], 0Ah
jge short loc_5BE2E
mov rax, [rsp+58h+var_40]
movsxd rcx, [rsp+58h+var_4C]
mov rax, [rax+rcx*8+98h]
mov [rsp+58h+var_58], rax
cmp [rsp+58h+var_58], 0
jnz short loc_5BDFE
jmp short loc_5BE21
loc_5BDFE:
mov rdi, [rsp+58h+var_10]
mov rsi, [rsp+58h+var_58]
mov rdx, [rsp+58h+var_48]
add rdx, 18h
movsxd rax, [rsp+58h+var_4C]
imul rax, 18h
add rdx, rax
call ggml_gallocr_init_tensor
loc_5BE21:
mov eax, [rsp+58h+var_4C]
add eax, 1
mov [rsp+58h+var_4C], eax
jmp short loc_5BDD8
loc_5BE2E:
mov rdi, [rsp+58h+var_10]
mov rsi, [rsp+58h+var_40]
mov rdx, [rsp+58h+var_48]
call ggml_gallocr_init_tensor
mov eax, [rsp+58h+var_34]
add eax, 1
mov [rsp+58h+var_34], eax
jmp loc_5BD8A
loc_5BE52:
mov [rsp+58h+var_1], 1
loc_5BE57:
mov al, [rsp+58h+var_1]
and al, 1
add rsp, 58h
retn
| char ggml_gallocr_alloc_graph(long long a1, long long a2)
{
long long v3; // [rsp+0h] [rbp-58h]
int m; // [rsp+Ch] [rbp-4Ch]
long long v5; // [rsp+10h] [rbp-48h]
long long v6; // [rsp+18h] [rbp-40h]
int k; // [rsp+24h] [rbp-34h]
int j; // [rsp+38h] [rbp-20h]
int i; // [rsp+3Ch] [rbp-1Ch]
if ( (ggml_gallocr_needs_realloc(a1, a2) & 1) == 0 )
goto LABEL_7;
if ( *(_DWORD *)(a1 + 24) != 1 )
return 0;
if ( (ggml_gallocr_reserve(a1, a2) & 1) == 0 )
return 0;
LABEL_7:
for ( i = 0; i < *(_DWORD *)(a1 + 24); ++i )
{
if ( *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL * i) )
ggml_backend_buffer_reset(*(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL * i));
}
for ( j = 0; j < *(_DWORD *)(a2 + 8); ++j )
ggml_gallocr_init_tensor(a1, *(_QWORD *)(*(_QWORD *)(a2 + 40) + 8LL * j), 24LL * j + *(_QWORD *)(a1 + 80));
for ( k = 0; k < *(_DWORD *)(a2 + 4); ++k )
{
v6 = *(_QWORD *)(*(_QWORD *)(a2 + 16) + 8LL * k);
v5 = 264LL * k + *(_QWORD *)(a1 + 64);
for ( m = 0; m < 10; ++m )
{
v3 = *(_QWORD *)(v6 + 8LL * m + 152);
if ( v3 )
ggml_gallocr_init_tensor(a1, v3, 24LL * m + v5 + 24);
}
ggml_gallocr_init_tensor(a1, v6, v5);
}
return 1;
}
| ggml_gallocr_alloc_graph:
SUB RSP,0x58
MOV qword ptr [RSP + 0x48],RDI
MOV qword ptr [RSP + 0x40],RSI
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RSP + 0x40]
CALL 0x0015be70
TEST AL,0x1
JNZ 0x0015bc93
JMP 0x0015bcc9
LAB_0015bc93:
MOV RAX,qword ptr [RSP + 0x48]
CMP dword ptr [RAX + 0x18],0x1
JNZ 0x0015bcbd
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RSP + 0x40]
CALL 0x00145330
TEST AL,0x1
JNZ 0x0015bcbb
MOV byte ptr [RSP + 0x57],0x0
JMP 0x0015be57
LAB_0015bcbb:
JMP 0x0015bcc7
LAB_0015bcbd:
MOV byte ptr [RSP + 0x57],0x0
JMP 0x0015be57
LAB_0015bcc7:
JMP 0x0015bcc9
LAB_0015bcc9:
MOV dword ptr [RSP + 0x3c],0x0
LAB_0015bcd1:
MOV EAX,dword ptr [RSP + 0x3c]
MOV RCX,qword ptr [RSP + 0x48]
CMP EAX,dword ptr [RCX + 0x18]
JGE 0x0015bd1a
MOV RAX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RAX + 0x8]
MOVSXD RCX,dword ptr [RSP + 0x3c]
CMP qword ptr [RAX + RCX*0x8],0x0
JZ 0x0015bd0b
MOV RAX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RAX + 0x8]
MOVSXD RCX,dword ptr [RSP + 0x3c]
MOV RDI,qword ptr [RAX + RCX*0x8]
CALL 0x00144640
LAB_0015bd0b:
JMP 0x0015bd0d
LAB_0015bd0d:
MOV EAX,dword ptr [RSP + 0x3c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x3c],EAX
JMP 0x0015bcd1
LAB_0015bd1a:
MOV dword ptr [RSP + 0x38],0x0
LAB_0015bd22:
MOV EAX,dword ptr [RSP + 0x38]
MOV RCX,qword ptr [RSP + 0x40]
CMP EAX,dword ptr [RCX + 0x8]
JGE 0x0015bd82
MOV RAX,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RAX + 0x28]
MOVSXD RCX,dword ptr [RSP + 0x38]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RAX + 0x50]
MOVSXD RCX,dword ptr [RSP + 0x38]
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x28]
CALL 0x0015bfc0
MOV EAX,dword ptr [RSP + 0x38]
ADD EAX,0x1
MOV dword ptr [RSP + 0x38],EAX
JMP 0x0015bd22
LAB_0015bd82:
MOV dword ptr [RSP + 0x24],0x0
LAB_0015bd8a:
MOV EAX,dword ptr [RSP + 0x24]
MOV RCX,qword ptr [RSP + 0x40]
CMP EAX,dword ptr [RCX + 0x4]
JGE 0x0015be52
MOV RAX,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RAX + 0x10]
MOVSXD RCX,dword ptr [RSP + 0x24]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RAX + 0x40]
MOVSXD RCX,dword ptr [RSP + 0x24]
IMUL RCX,RCX,0x108
ADD RAX,RCX
MOV qword ptr [RSP + 0x10],RAX
MOV dword ptr [RSP + 0xc],0x0
LAB_0015bdd8:
CMP dword ptr [RSP + 0xc],0xa
JGE 0x0015be2e
MOV RAX,qword ptr [RSP + 0x18]
MOVSXD RCX,dword ptr [RSP + 0xc]
MOV RAX,qword ptr [RAX + RCX*0x8 + 0x98]
MOV qword ptr [RSP],RAX
CMP qword ptr [RSP],0x0
JNZ 0x0015bdfe
JMP 0x0015be21
LAB_0015bdfe:
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x10]
ADD RDX,0x18
MOVSXD RAX,dword ptr [RSP + 0xc]
IMUL RAX,RAX,0x18
ADD RDX,RAX
CALL 0x0015bfc0
LAB_0015be21:
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
JMP 0x0015bdd8
LAB_0015be2e:
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x10]
CALL 0x0015bfc0
MOV EAX,dword ptr [RSP + 0x24]
ADD EAX,0x1
MOV dword ptr [RSP + 0x24],EAX
JMP 0x0015bd8a
LAB_0015be52:
MOV byte ptr [RSP + 0x57],0x1
LAB_0015be57:
MOV AL,byte ptr [RSP + 0x57]
AND AL,0x1
ADD RSP,0x58
RET
|
int1 ggml_gallocr_alloc_graph(long param_1,long param_2)
{
long lVar1;
long lVar2;
ulong uVar3;
long lVar4;
int local_4c;
int local_34;
int local_20;
int local_1c;
uVar3 = ggml_gallocr_needs_realloc(param_1,param_2);
if ((uVar3 & 1) != 0) {
if (*(int *)(param_1 + 0x18) != 1) {
return 0;
}
uVar3 = ggml_gallocr_reserve(param_1,param_2);
if ((uVar3 & 1) == 0) {
return 0;
}
}
for (local_1c = 0; local_1c < *(int *)(param_1 + 0x18); local_1c = local_1c + 1) {
if (*(long *)(*(long *)(param_1 + 8) + (long)local_1c * 8) != 0) {
ggml_backend_buffer_reset(*(int8 *)(*(long *)(param_1 + 8) + (long)local_1c * 8));
}
}
for (local_20 = 0; local_20 < *(int *)(param_2 + 8); local_20 = local_20 + 1) {
ggml_gallocr_init_tensor
(param_1,*(int8 *)(*(long *)(param_2 + 0x28) + (long)local_20 * 8),
*(long *)(param_1 + 0x50) + (long)local_20 * 0x18);
}
for (local_34 = 0; local_34 < *(int *)(param_2 + 4); local_34 = local_34 + 1) {
lVar1 = *(long *)(*(long *)(param_2 + 0x10) + (long)local_34 * 8);
lVar4 = *(long *)(param_1 + 0x40) + (long)local_34 * 0x108;
for (local_4c = 0; local_4c < 10; local_4c = local_4c + 1) {
lVar2 = *(long *)(lVar1 + 0x98 + (long)local_4c * 8);
if (lVar2 != 0) {
ggml_gallocr_init_tensor(param_1,lVar2,lVar4 + 0x18 + (long)local_4c * 0x18);
}
}
ggml_gallocr_init_tensor(param_1,lVar1,lVar4);
}
return 1;
}
| |
41,643 | ma_find_half_pos | eloqsql/storage/maria/ma_write.c | uchar *_ma_find_half_pos(MARIA_KEY *key, MARIA_PAGE *ma_page,
uchar **after_key)
{
uint keys, length, key_ref_length, page_flag, nod_flag;
uchar *page, *end, *lastpos;
MARIA_HA *info= ma_page->info;
MARIA_SHARE *share= info->s;
MARIA_KEYDEF *keyinfo= key->keyinfo;
DBUG_ENTER("_ma_find_half_pos");
nod_flag= ma_page->node;
key_ref_length= share->keypage_header + nod_flag;
page_flag= ma_page->flag;
length= ma_page->size - key_ref_length;
page= ma_page->buff+ key_ref_length; /* Point to first key */
if (!(keyinfo->flag &
(HA_PACK_KEY | HA_SPACE_PACK_USED | HA_VAR_LENGTH_KEY |
HA_BINARY_PACK_KEY)) && !(page_flag & KEYPAGE_FLAG_HAS_TRANSID))
{
key_ref_length= keyinfo->keylength+nod_flag;
key->data_length= keyinfo->keylength - info->s->rec_reflength;
key->ref_length= info->s->rec_reflength;
key->flag= 0;
keys=length/(key_ref_length*2);
end=page+keys*key_ref_length;
*after_key=end+key_ref_length;
memcpy(key->data, end, key_ref_length);
DBUG_RETURN(end);
}
end=page+length/2-key_ref_length; /* This is aprox. half */
key->data[0]= 0; /* Safety */
do
{
lastpos=page;
if (!(length= (*keyinfo->get_key)(key, page_flag, nod_flag, &page)))
DBUG_RETURN(0);
} while (page < end);
*after_key= page;
DBUG_PRINT("exit",("returns: %p page: %p half: %p",
lastpos, page, end));
DBUG_RETURN(lastpos);
} | O3 | c | ma_find_half_pos:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r8
movq (%rsi), %rbx
movq (%rbx), %rcx
movq 0x8(%rdi), %r11
movl 0x28(%rsi), %r10d
movl 0x744(%rcx), %edx
addl %r10d, %edx
movl 0x2c(%rsi), %r9d
movl 0x20(%rsi), %eax
subl %edx, %eax
movq 0x10(%rsi), %r14
addq %rdx, %r14
movq %r14, -0x38(%rbp)
testb $0x2e, 0xa2(%r11)
sete %sil
movl %r9d, -0x2c(%rbp)
testb $0x2, %r9b
sete %r9b
andb %sil, %r9b
cmpb $0x1, %r9b
jne 0x58c13
movzwl 0xaa(%r11), %edx
addl %edx, %r10d
subl 0x740(%rcx), %edx
movl %edx, 0x10(%rdi)
movq (%rbx), %rcx
movl 0x740(%rcx), %ecx
movl %ecx, 0x14(%rdi)
movl $0x0, 0x18(%rdi)
leal (%r10,%r10), %ecx
xorl %edx, %edx
divl %ecx
imull %r10d, %eax
addq %rax, %r14
leaq (%r14,%r10), %rax
movq %rax, (%r8)
movq (%rdi), %rdi
movq %r14, %rsi
movq %r10, %rdx
callq 0x2a0a0
movq %r14, %r12
jmp 0x58c69
movq %r8, -0x40(%rbp)
shrl %eax
addq %r14, %rax
subq %rdx, %rax
movq %rax, -0x48(%rbp)
movq (%rdi), %rax
movb $0x0, (%rax)
movq %r14, %r12
movq %rdi, %r15
movl -0x2c(%rbp), %esi
movq %r10, %rbx
movl %r10d, %edx
leaq -0x38(%rbp), %rcx
movq %r11, %r13
callq *0xe0(%r11)
testl %eax, %eax
je 0x58c66
movq -0x38(%rbp), %r14
cmpq -0x48(%rbp), %r14
movq %r15, %rdi
movq %rbx, %r10
movq %r13, %r11
jb 0x58c29
movq -0x40(%rbp), %rax
movq %r14, (%rax)
jmp 0x58c69
xorl %r12d, %r12d
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ma_find_half_pos:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r8, rdx
mov rbx, [rsi]
mov rcx, [rbx]
mov r11, [rdi+8]
mov r10d, [rsi+28h]
mov edx, [rcx+744h]
add edx, r10d
mov r9d, [rsi+2Ch]
mov eax, [rsi+20h]
sub eax, edx
mov r14, [rsi+10h]
add r14, rdx
mov [rbp+var_38], r14
test byte ptr [r11+0A2h], 2Eh
setz sil
mov [rbp+var_2C], r9d
test r9b, 2
setz r9b
and r9b, sil
cmp r9b, 1
jnz short loc_58C13
movzx edx, word ptr [r11+0AAh]
add r10d, edx
sub edx, [rcx+740h]
mov [rdi+10h], edx
mov rcx, [rbx]
mov ecx, [rcx+740h]
mov [rdi+14h], ecx
mov dword ptr [rdi+18h], 0
lea ecx, [r10+r10]
xor edx, edx
div ecx
imul eax, r10d
add r14, rax
lea rax, [r14+r10]
mov [r8], rax
mov rdi, [rdi]
mov rsi, r14
mov rdx, r10
call _memcpy
mov r12, r14
jmp short loc_58C69
loc_58C13:
mov [rbp+var_40], r8
shr eax, 1
add rax, r14
sub rax, rdx
mov [rbp+var_48], rax
mov rax, [rdi]
mov byte ptr [rax], 0
loc_58C29:
mov r12, r14
mov r15, rdi
mov esi, [rbp+var_2C]
mov rbx, r10
mov edx, r10d
lea rcx, [rbp+var_38]
mov r13, r11
call qword ptr [r11+0E0h]
test eax, eax
jz short loc_58C66
mov r14, [rbp+var_38]
cmp r14, [rbp+var_48]
mov rdi, r15
mov r10, rbx
mov r11, r13
jb short loc_58C29
mov rax, [rbp+var_40]
mov [rax], r14
jmp short loc_58C69
loc_58C66:
xor r12d, r12d
loc_58C69:
mov rax, r12
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ma_find_half_pos(long long a1, long long **a2, unsigned long long *a3)
{
long long *v4; // rbx
long long v5; // rcx
long long v6; // r11
long long v7; // r10
long long v8; // rdx
unsigned int v9; // r9d
unsigned int v10; // eax
long long v11; // r14
bool v12; // si
int v13; // edx
long long v14; // r10
long long v15; // r14
long long v16; // r12
long long v17; // rbx
long long v18; // r13
unsigned long long v20; // [rsp+8h] [rbp-48h]
unsigned long long *v21; // [rsp+10h] [rbp-40h]
unsigned long long v22; // [rsp+18h] [rbp-38h] BYREF
unsigned int v23; // [rsp+24h] [rbp-2Ch]
v4 = *a2;
v5 = **a2;
v6 = *(_QWORD *)(a1 + 8);
v7 = *((unsigned int *)a2 + 10);
v8 = (unsigned int)(v7 + *(_DWORD *)(v5 + 1860));
v9 = *((_DWORD *)a2 + 11);
v10 = *((_DWORD *)a2 + 8) - v8;
v11 = (long long)a2[2] + v8;
v22 = v11;
v12 = (*(_BYTE *)(v6 + 162) & 0x2E) == 0;
v23 = v9;
if ( v12 && (v9 & 2) == 0 )
{
v13 = *(unsigned __int16 *)(v6 + 170);
v14 = (unsigned int)(v13 + v7);
*(_DWORD *)(a1 + 16) = v13 - *(_DWORD *)(v5 + 1856);
*(_DWORD *)(a1 + 20) = *(_DWORD *)(*v4 + 1856);
*(_DWORD *)(a1 + 24) = 0;
v15 = (unsigned int)v14 * (v10 / (2 * (int)v14)) + v11;
*a3 = v15 + v14;
memcpy(*(_QWORD *)a1, v15, v14);
return v15;
}
else
{
v21 = a3;
v20 = v11 + (v10 >> 1) - v8;
**(_BYTE **)a1 = 0;
while ( 1 )
{
v16 = v11;
v17 = v7;
v18 = v6;
if ( !(*(unsigned int ( **)(long long, _QWORD, _QWORD, unsigned long long *))(v6 + 224))(
a1,
v23,
(unsigned int)v7,
&v22) )
break;
v11 = v22;
v7 = v17;
v6 = v18;
if ( v22 >= v20 )
{
*v21 = v22;
return v16;
}
}
return 0LL;
}
}
| _ma_find_half_pos:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R8,RDX
MOV RBX,qword ptr [RSI]
MOV RCX,qword ptr [RBX]
MOV R11,qword ptr [RDI + 0x8]
MOV R10D,dword ptr [RSI + 0x28]
MOV EDX,dword ptr [RCX + 0x744]
ADD EDX,R10D
MOV R9D,dword ptr [RSI + 0x2c]
MOV EAX,dword ptr [RSI + 0x20]
SUB EAX,EDX
MOV R14,qword ptr [RSI + 0x10]
ADD R14,RDX
MOV qword ptr [RBP + -0x38],R14
TEST byte ptr [R11 + 0xa2],0x2e
SETZ SIL
MOV dword ptr [RBP + -0x2c],R9D
TEST R9B,0x2
SETZ R9B
AND R9B,SIL
CMP R9B,0x1
JNZ 0x00158c13
MOVZX EDX,word ptr [R11 + 0xaa]
ADD R10D,EDX
SUB EDX,dword ptr [RCX + 0x740]
MOV dword ptr [RDI + 0x10],EDX
MOV RCX,qword ptr [RBX]
MOV ECX,dword ptr [RCX + 0x740]
MOV dword ptr [RDI + 0x14],ECX
MOV dword ptr [RDI + 0x18],0x0
LEA ECX,[R10 + R10*0x1]
XOR EDX,EDX
DIV ECX
IMUL EAX,R10D
ADD R14,RAX
LEA RAX,[R14 + R10*0x1]
MOV qword ptr [R8],RAX
MOV RDI,qword ptr [RDI]
MOV RSI,R14
MOV RDX,R10
CALL 0x0012a0a0
MOV R12,R14
JMP 0x00158c69
LAB_00158c13:
MOV qword ptr [RBP + -0x40],R8
SHR EAX,0x1
ADD RAX,R14
SUB RAX,RDX
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RDI]
MOV byte ptr [RAX],0x0
LAB_00158c29:
MOV R12,R14
MOV R15,RDI
MOV ESI,dword ptr [RBP + -0x2c]
MOV RBX,R10
MOV EDX,R10D
LEA RCX,[RBP + -0x38]
MOV R13,R11
CALL qword ptr [R11 + 0xe0]
TEST EAX,EAX
JZ 0x00158c66
MOV R14,qword ptr [RBP + -0x38]
CMP R14,qword ptr [RBP + -0x48]
MOV RDI,R15
MOV R10,RBX
MOV R11,R13
JC 0x00158c29
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX],R14
JMP 0x00158c69
LAB_00158c66:
XOR R12D,R12D
LAB_00158c69:
MOV RAX,R12
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void * _ma_find_half_pos(int8 *param_1,int8 *param_2,long *param_3)
{
int iVar1;
long *plVar2;
long lVar3;
long lVar4;
int iVar5;
void *pvVar6;
uint uVar7;
uint uVar8;
void *__src;
void *local_40;
uint local_34;
plVar2 = (long *)*param_2;
lVar3 = *plVar2;
lVar4 = param_1[1];
iVar1 = *(int *)(param_2 + 5);
uVar7 = *(int *)(lVar3 + 0x744) + iVar1;
local_34 = *(uint *)((long)param_2 + 0x2c);
iVar5 = *(int *)(param_2 + 4);
local_40 = (void *)(param_2[2] + (ulong)uVar7);
if ((local_34 & 2) == 0 && (*(byte *)(lVar4 + 0xa2) & 0x2e) == 0) {
uVar8 = iVar1 + (uint)*(ushort *)(lVar4 + 0xaa);
*(uint *)(param_1 + 2) = (uint)*(ushort *)(lVar4 + 0xaa) - *(int *)(lVar3 + 0x740);
*(int4 *)((long)param_1 + 0x14) = *(int4 *)(*plVar2 + 0x740);
*(int4 *)(param_1 + 3) = 0;
__src = (void *)((long)local_40 + (ulong)(((iVar5 - uVar7) / (uVar8 * 2)) * uVar8));
*param_3 = (long)__src + (ulong)uVar8;
memcpy((void *)*param_1,__src,(ulong)uVar8);
}
else {
pvVar6 = (void *)((long)local_40 + ((ulong)(iVar5 - uVar7 >> 1) - (ulong)uVar7));
*(int1 *)*param_1 = 0;
do {
__src = local_40;
iVar5 = (**(code **)(lVar4 + 0xe0))(param_1,local_34,iVar1,&local_40);
if (iVar5 == 0) {
return (void *)0x0;
}
} while (local_40 < pvVar6);
*param_3 = (long)local_40;
}
return __src;
}
| |
41,644 | fmt::v10::appender fmt::v10::detail::write_ptr<char, fmt::v10::appender, unsigned long>(fmt::v10::appender, unsigned long, fmt::v10::format_specs<char> const*) | aimrt_mujoco_sim/_deps/fmt-src/include/fmt/format.h | auto write_ptr(OutputIt out, UIntPtr value, const format_specs<Char>* specs)
-> OutputIt {
int num_digits = count_digits<4>(value);
auto size = to_unsigned(num_digits) + size_t(2);
auto write = [=](reserve_iterator<OutputIt> it) {
*it++ = static_cast<Char>('0');
*it++ = static_cast<Char>('x');
return format_uint<4, Char>(it, value, num_digits);
};
return specs ? write_padded<align::right>(out, *specs, size, write)
: base_iterator(out, write(reserve(out, size)));
} | O3 | c | fmt::v10::appender fmt::v10::detail::write_ptr<char, fmt::v10::appender, unsigned long>(fmt::v10::appender, unsigned long, fmt::v10::format_specs<char> const*):
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movq %rsi, %rcx
movq %rsi, %rax
shrq $0x4, %rax
incq %r15
cmpq $0xf, %rcx
movq %rax, %rcx
ja 0xa2901
movq %r14, 0x20(%rsp)
movl %r15d, 0x28(%rsp)
testq %rdx, %rdx
je 0xa293f
addq $0x2, %r15
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movq %rdx, %rsi
movq %r15, %rdx
movq %r15, %rcx
callq 0xa2a3a
jmp 0xa2a2a
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%rbx)
jae 0xa295d
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%rbx), %rcx
movq %rsi, 0x10(%rbx)
movb $0x30, (%rcx,%rax)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%rbx)
jae 0xa2987
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%rbx), %rcx
movq %rsi, 0x10(%rbx)
movb $0x78, (%rcx,%rax)
movq 0x10(%rbx), %rax
leaq (%rax,%r15), %rcx
cmpq %rcx, 0x18(%rbx)
jb 0xa29e1
movq %rcx, 0x10(%rbx)
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0xa29e1
addq %rax, %rcx
leaq (%r15,%rcx), %rax
decq %rax
leaq 0x187ce4(%rip), %rcx # 0x22a6a3
movq %r14, %rdx
movl %r14d, %esi
andl $0xf, %esi
movb (%rsi,%rcx), %sil
movb %sil, (%rax)
shrq $0x4, %rdx
decq %rax
cmpq $0x10, %r14
movq %rdx, %r14
jae 0xa29c2
jmp 0xa2a2d
leaq (%rsp,%r15), %rax
decq %rax
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movb $0x0, 0x10(%rsp)
leaq (%rsp,%r15), %rsi
leaq 0x187ca4(%rip), %rcx # 0x22a6a3
movq %r14, %rdx
movl %r14d, %edi
andl $0xf, %edi
movb (%rdi,%rcx), %dil
movb %dil, (%rax)
shrq $0x4, %rdx
decq %rax
cmpq $0xf, %r14
movq %rdx, %r14
ja 0xa2a02
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x9931e
movq %rax, %rbx
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
| _ZN3fmt3v106detail9write_ptrIcNS0_8appenderEmEET0_S4_T1_PKNS0_12format_specsIT_EE:
push r15
push r14
push rbx
sub rsp, 30h
mov r14, rsi
mov rbx, rdi
xor r15d, r15d
mov rcx, rsi
mov rax, rsi
loc_A2901:
shr rax, 4
inc r15
cmp rcx, 0Fh
mov rcx, rax
ja short loc_A2901
mov [rsp+48h+var_28], r14
mov [rsp+48h+var_20], r15d
test rdx, rdx
jz short loc_A293F
add r15, 2
lea r8, [rsp+48h+var_28]
mov rdi, rbx
mov rsi, rdx
mov rdx, r15
mov rcx, r15
call _ZN3fmt3v106detail12write_paddedILNS0_5align4typeE2ENS0_8appenderEcRZNS1_9write_ptrIcS5_mEET0_S7_T1_PKNS0_12format_specsIT_EEEUlS5_E_EES7_S7_RKNS9_IS8_EEmmOT2_; fmt::v10::detail::write_padded<(fmt::v10::align::type)2,fmt::v10::appender,char,fmt::v10::detail::write_ptr<char,fmt::v10::appender,ulong>(fmt::v10::appender,ulong,fmt::v10::format_specs<char> const*)::{lambda(fmt::v10::appender)#1} &>(fmt::v10::appender,fmt::v10::format_specs<ulong> const&,ulong,ulong,fmt::v10::detail::write_ptr<char,fmt::v10::appender,ulong>(fmt::v10::appender,ulong,fmt::v10::format_specs<char> const*)::{lambda(fmt::v10::appender)#1} &)
jmp loc_A2A2A
loc_A293F:
mov rax, [rbx+10h]
lea rsi, [rax+1]
cmp [rbx+18h], rsi
jnb short loc_A295D
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax]
mov rax, [rbx+10h]
lea rsi, [rax+1]
loc_A295D:
mov rcx, [rbx+8]
mov [rbx+10h], rsi
mov byte ptr [rcx+rax], 30h ; '0'
mov rax, [rbx+10h]
lea rsi, [rax+1]
cmp [rbx+18h], rsi
jnb short loc_A2987
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax]
mov rax, [rbx+10h]
lea rsi, [rax+1]
loc_A2987:
mov rcx, [rbx+8]
mov [rbx+10h], rsi
mov byte ptr [rcx+rax], 78h ; 'x'
mov rax, [rbx+10h]
lea rcx, [rax+r15]
cmp [rbx+18h], rcx
jb short loc_A29E1
mov [rbx+10h], rcx
mov rcx, [rbx+8]
test rcx, rcx
jz short loc_A29E1
add rcx, rax
lea rax, [r15+rcx]
dec rax
lea rcx, a0123456789abcd_0; "0123456789abcdef"
mov rdx, r14
loc_A29C2:
mov esi, r14d
and esi, 0Fh
mov sil, [rsi+rcx]
mov [rax], sil
shr rdx, 4
dec rax
cmp r14, 10h
mov r14, rdx
jnb short loc_A29C2
jmp short loc_A2A2D
loc_A29E1:
lea rax, [rsp+r15+48h+var_48]
dec rax
xorps xmm0, xmm0
movaps [rsp+48h+var_48], xmm0
mov [rsp+48h+var_38], 0
lea rsi, [rsp+r15+48h+var_48]
lea rcx, a0123456789abcd_0; "0123456789abcdef"
mov rdx, r14
loc_A2A02:
mov edi, r14d
and edi, 0Fh
mov dil, [rdi+rcx]
mov [rax], dil
shr rdx, 4
dec rax
cmp r14, 0Fh
mov r14, rdx
ja short loc_A2A02
mov rdi, rsp
mov rdx, rbx
call _ZN3fmt3v106detail17copy_str_noinlineIcPcNS0_8appenderEEET1_T0_S6_S5_; fmt::v10::detail::copy_str_noinline<char,char *,fmt::v10::appender>(char *,char *,fmt::v10::appender)
loc_A2A2A:
mov rbx, rax
loc_A2A2D:
mov rax, rbx
add rsp, 30h
pop rbx
pop r14
pop r15
retn
| long long fmt::v10::detail::write_ptr<char,fmt::v10::appender,unsigned long>(
long long a1,
unsigned long long a2,
long long a3)
{
unsigned long long v3; // r14
long long v4; // rbx
long long v5; // r15
unsigned long long v6; // rcx
unsigned long long v7; // rax
bool v8; // cc
long long v10; // rax
long long v11; // rsi
long long v12; // rcx
long long v13; // rax
long long v14; // rsi
long long v15; // rcx
long long v16; // rax
long long v17; // rcx
_BYTE *v18; // rax
unsigned long long v19; // rdx
bool v20; // cf
_BYTE *v21; // rax
unsigned long long v22; // rdx
__int128 v24; // [rsp+0h] [rbp-48h] BYREF
char v25; // [rsp+10h] [rbp-38h]
unsigned long long v26; // [rsp+20h] [rbp-28h] BYREF
int v27; // [rsp+28h] [rbp-20h]
v3 = a2;
v4 = a1;
v5 = 0LL;
v6 = a2;
v7 = a2;
do
{
v7 >>= 4;
++v5;
v8 = v6 <= 0xF;
v6 = v7;
}
while ( !v8 );
v26 = a2;
v27 = v5;
if ( a3 )
return fmt::v10::detail::write_padded<(fmt::v10::align::type)2,fmt::v10::appender,char,fmt::v10::appender fmt::v10::detail::write_ptr<char,fmt::v10::appender,unsigned long>(fmt::v10::appender,unsigned long,fmt::v10::format_specs<char> const*)::{lambda(fmt::v10::appender)#1} &>(
a1,
a3,
v5 + 2,
v5 + 2,
&v26);
v10 = *(_QWORD *)(a1 + 16);
v11 = v10 + 1;
if ( *(_QWORD *)(a1 + 24) < (unsigned long long)(v10 + 1) )
{
(**(void ( ***)(long long, long long, _QWORD, unsigned long long))a1)(a1, v11, 0LL, v6);
v10 = *(_QWORD *)(a1 + 16);
v11 = v10 + 1;
}
v12 = *(_QWORD *)(a1 + 8);
*(_QWORD *)(a1 + 16) = v11;
*(_BYTE *)(v12 + v10) = 48;
v13 = *(_QWORD *)(a1 + 16);
v14 = v13 + 1;
if ( *(_QWORD *)(a1 + 24) < (unsigned long long)(v13 + 1) )
{
(**(void ( ***)(long long))a1)(a1);
v13 = *(_QWORD *)(a1 + 16);
v14 = v13 + 1;
}
v15 = *(_QWORD *)(a1 + 8);
*(_QWORD *)(a1 + 16) = v14;
*(_BYTE *)(v15 + v13) = 120;
v16 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 24) < (unsigned long long)(v16 + v5)
|| (*(_QWORD *)(a1 + 16) = v16 + v5, (v17 = *(_QWORD *)(a1 + 8)) == 0) )
{
v21 = (char *)&v24 + v5 - 1;
v24 = 0LL;
v25 = 0;
v22 = v3;
do
{
*v21 = a0123456789abcd_0[v3 & 0xF];
v22 >>= 4;
--v21;
v8 = v3 <= 0xF;
v3 = v22;
}
while ( !v8 );
return fmt::v10::detail::copy_str_noinline<char,char *,fmt::v10::appender>((long long)&v24, (long long)&v24 + v5, a1);
}
v18 = (_BYTE *)(v5 + v16 + v17 - 1);
v19 = v3;
do
{
*v18 = a0123456789abcd_0[v3 & 0xF];
v19 >>= 4;
--v18;
v20 = v3 < 0x10;
v3 = v19;
}
while ( !v20 );
return v4;
}
| write_ptr<char,fmt::v10::appender,unsigned_long>:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RSI
MOV RBX,RDI
XOR R15D,R15D
MOV RCX,RSI
MOV RAX,RSI
LAB_001a2901:
SHR RAX,0x4
INC R15
CMP RCX,0xf
MOV RCX,RAX
JA 0x001a2901
MOV qword ptr [RSP + 0x20],R14
MOV dword ptr [RSP + 0x28],R15D
TEST RDX,RDX
JZ 0x001a293f
ADD R15,0x2
LEA R8,[RSP + 0x20]
MOV RDI,RBX
MOV RSI,RDX
MOV RDX,R15
MOV RCX,R15
CALL 0x001a2a3a
JMP 0x001a2a2a
LAB_001a293f:
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
CMP qword ptr [RBX + 0x18],RSI
JNC 0x001a295d
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX]
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
LAB_001a295d:
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RBX + 0x10],RSI
MOV byte ptr [RCX + RAX*0x1],0x30
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
CMP qword ptr [RBX + 0x18],RSI
JNC 0x001a2987
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX]
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
LAB_001a2987:
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RBX + 0x10],RSI
MOV byte ptr [RCX + RAX*0x1],0x78
MOV RAX,qword ptr [RBX + 0x10]
LEA RCX,[RAX + R15*0x1]
CMP qword ptr [RBX + 0x18],RCX
JC 0x001a29e1
MOV qword ptr [RBX + 0x10],RCX
MOV RCX,qword ptr [RBX + 0x8]
TEST RCX,RCX
JZ 0x001a29e1
ADD RCX,RAX
LEA RAX,[R15 + RCX*0x1]
DEC RAX
LEA RCX,[0x32a6a3]
MOV RDX,R14
LAB_001a29c2:
MOV ESI,R14D
AND ESI,0xf
MOV SIL,byte ptr [RSI + RCX*0x1]
MOV byte ptr [RAX],SIL
SHR RDX,0x4
DEC RAX
CMP R14,0x10
MOV R14,RDX
JNC 0x001a29c2
JMP 0x001a2a2d
LAB_001a29e1:
LEA RAX,[RSP + R15*0x1]
DEC RAX
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOV byte ptr [RSP + 0x10],0x0
LEA RSI,[RSP + R15*0x1]
LEA RCX,[0x32a6a3]
MOV RDX,R14
LAB_001a2a02:
MOV EDI,R14D
AND EDI,0xf
MOV DIL,byte ptr [RDI + RCX*0x1]
MOV byte ptr [RAX],DIL
SHR RDX,0x4
DEC RAX
CMP R14,0xf
MOV R14,RDX
JA 0x001a2a02
MOV RDI,RSP
MOV RDX,RBX
CALL 0x0019931e
LAB_001a2a2a:
MOV RBX,RAX
LAB_001a2a2d:
MOV RAX,RBX
ADD RSP,0x30
POP RBX
POP R14
POP R15
RET
|
/* fmt::v10::appender fmt::v10::detail::write_ptr<char, fmt::v10::appender, unsigned
long>(fmt::v10::appender, unsigned long, fmt::v10::format_specs<char> const*) */
int8 *
fmt::v10::detail::write_ptr<char,fmt::v10::appender,unsigned_long>
(int8 *param_1,ulong param_2,long param_3)
{
int8 *puVar1;
long lVar2;
char *pcVar3;
ulong uVar4;
long lVar5;
long lVar6;
bool bVar7;
int8 local_48;
int8 uStack_40;
int1 local_38;
ulong local_28;
int4 local_20;
uVar4 = param_2;
lVar6 = 0;
do {
lVar5 = lVar6;
lVar6 = lVar5 + 1;
bVar7 = 0xf < uVar4;
uVar4 = uVar4 >> 4;
} while (bVar7);
local_20 = (int4)lVar6;
local_28 = param_2;
if (param_3 == 0) {
lVar2 = param_1[2];
uVar4 = lVar2 + 1;
if ((ulong)param_1[3] < uVar4) {
(**(code **)*param_1)(param_1);
lVar2 = param_1[2];
uVar4 = lVar2 + 1;
}
param_1[2] = uVar4;
*(int1 *)(param_1[1] + lVar2) = 0x30;
lVar2 = param_1[2];
uVar4 = lVar2 + 1;
if ((ulong)param_1[3] < uVar4) {
(**(code **)*param_1)(param_1);
lVar2 = param_1[2];
uVar4 = lVar2 + 1;
}
param_1[2] = uVar4;
*(int1 *)(param_1[1] + lVar2) = 0x78;
lVar2 = param_1[2];
uVar4 = lVar2 + lVar6;
if (uVar4 <= (ulong)param_1[3]) {
param_1[2] = uVar4;
if (param_1[1] != 0) {
pcVar3 = (char *)(lVar6 + param_1[1] + lVar2);
do {
pcVar3 = pcVar3 + -1;
*pcVar3 = "0123456789abcdef"[(uint)param_2 & 0xf];
bVar7 = 0xf < param_2;
param_2 = param_2 >> 4;
} while (bVar7);
return param_1;
}
}
pcVar3 = (char *)((long)&local_48 + lVar5 + 1);
local_48 = 0;
uStack_40 = 0;
local_38 = 0;
do {
pcVar3 = pcVar3 + -1;
*pcVar3 = "0123456789abcdef"[(uint)param_2 & 0xf];
bVar7 = 0xf < param_2;
param_2 = param_2 >> 4;
} while (bVar7);
puVar1 = (int8 *)
copy_str_noinline<char,char*,fmt::v10::appender>
(&local_48,(long)&local_48 + lVar5 + 1,param_1);
}
else {
puVar1 = (int8 *)
write_padded<(fmt::v10::align::type)2,fmt::v10::appender,char,fmt::v10::detail::write_ptr<char,fmt::v10::appender,unsigned_long>(fmt::v10::appender,unsigned_long,fmt::v10::format_specs<char>const*)::_lambda(fmt::v10::appender)_1_&>
(param_1,param_3,lVar5 + 3,lVar5 + 3,&local_28);
}
return puVar1;
}
| |
41,645 | JS_AddIntrinsicMapSet | bluesky950520[P]quickjs/quickjs.c | void JS_AddIntrinsicMapSet(JSContext *ctx)
{
int i;
JSValue obj1;
char buf[ATOM_GET_STR_BUF_SIZE];
for(i = 0; i < 4; i++) {
const char *name = JS_AtomGetStr(ctx, buf, sizeof(buf),
JS_ATOM_Map + i);
int class_id = JS_CLASS_MAP + i;
ctx->class_proto[class_id] = JS_NewObject(ctx);
JS_SetPropertyFunctionList(ctx, ctx->class_proto[class_id],
js_map_proto_funcs_ptr[i],
js_map_proto_funcs_count[i]);
obj1 = JS_NewCFunctionMagic(ctx, js_map_constructor, name, 0,
JS_CFUNC_constructor_magic, i);
if (class_id == JS_CLASS_MAP)
JS_SetPropertyFunctionList(ctx, obj1, js_map_funcs, countof(js_map_funcs));
else if (class_id == JS_CLASS_SET)
JS_SetPropertyFunctionList(ctx, obj1, js_set_funcs, countof(js_set_funcs));
JS_NewGlobalCConstructor2(ctx, obj1, name, ctx->class_proto[class_id]);
}
for(i = 0; i < 2; i++) {
ctx->class_proto[JS_CLASS_MAP_ITERATOR + i] =
JS_NewObjectProto(ctx, ctx->class_proto[JS_CLASS_ITERATOR]);
JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_MAP_ITERATOR + i],
js_map_proto_funcs_ptr[i + 4],
js_map_proto_funcs_count[i + 4]);
}
} | O0 | c | JS_AddIntrinsicMapSet:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movl $0x0, 0xac(%rsp)
cmpl $0x4, 0xac(%rsp)
jge 0x26589
movq 0xb0(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movl 0xac(%rsp), %ecx
addl $0xb4, %ecx
movl $0x40, %edx
callq 0x52b00
movq %rax, 0x48(%rsp)
movl 0xac(%rsp), %eax
addl $0x23, %eax
movl %eax, 0x44(%rsp)
movq 0xb0(%rsp), %rax
movq 0x40(%rax), %rax
movslq 0x44(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x2a570
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, (%rax)
movq 0x38(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0xb0(%rsp), %rdi
movq 0xb0(%rsp), %rax
movq 0x40(%rax), %rax
movslq 0x44(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq 0xac(%rsp), %rdx
leaq 0x10a925(%rip), %rcx # 0x130d80
movq (%rcx,%rdx,8), %rcx
movslq 0xac(%rsp), %rsi
leaq 0xe6502(%rip), %rdx # 0x10c970
movzbl (%rdx,%rsi), %r8d
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x4cb00
movq 0xb0(%rsp), %rdi
movq 0x48(%rsp), %rdx
movl 0xac(%rsp), %r9d
leaq 0x2c715(%rip), %rsi # 0x52bb0
xorl %ecx, %ecx
movl $0x3, %r8d
callq 0x52b40
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0xa0(%rsp)
cmpl $0x23, 0x44(%rsp)
jne 0x264ff
movq 0xb0(%rsp), %rdi
movq 0x98(%rsp), %rsi
movq 0xa0(%rsp), %rdx
leaq 0x10c12e(%rip), %rcx # 0x132620
movl $0x2, %r8d
callq 0x4cb00
jmp 0x26532
cmpl $0x24, 0x44(%rsp)
jne 0x26530
movq 0xb0(%rsp), %rdi
movq 0x98(%rsp), %rsi
movq 0xa0(%rsp), %rdx
leaq 0x10c13b(%rip), %rcx # 0x132660
movl $0x1, %r8d
callq 0x4cb00
jmp 0x26532
movq 0xb0(%rsp), %rdi
movq 0x48(%rsp), %rcx
movq 0xb0(%rsp), %rax
movq 0x40(%rax), %rax
movslq 0x44(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq 0x98(%rsp), %rsi
movq 0xa0(%rsp), %rdx
movq (%rax), %r8
movq 0x8(%rax), %r9
callq 0x535e0
movl 0xac(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xac(%rsp)
jmp 0x2639a
movl $0x0, 0xac(%rsp)
cmpl $0x2, 0xac(%rsp)
jge 0x2668a
movq 0xb0(%rsp), %rax
movq 0x40(%rax), %rax
movl 0xac(%rsp), %ecx
addl $0x2a, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0xb0(%rsp), %rdi
movq 0xb0(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x270(%rax), %rsi
movq 0x278(%rax), %rdx
callq 0x2a4d0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0xb0(%rsp), %rdi
movq 0xb0(%rsp), %rax
movq 0x40(%rax), %rax
movl 0xac(%rsp), %ecx
addl $0x2a, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0xac(%rsp), %ecx
addl $0x4, %ecx
movslq %ecx, %rdx
leaq 0x10a735(%rip), %rcx # 0x130d80
movq (%rcx,%rdx,8), %rcx
movl 0xac(%rsp), %edx
addl $0x4, %edx
movslq %edx, %rsi
leaq 0xe630d(%rip), %rdx # 0x10c970
movzbl (%rdx,%rsi), %r8d
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x4cb00
movl 0xac(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xac(%rsp)
jmp 0x26594
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
| JS_AddIntrinsicMapSet:
sub rsp, 0B8h
mov [rsp+0B8h+var_8], rdi
mov [rsp+0B8h+var_C], 0
loc_2639A:
cmp [rsp+0B8h+var_C], 4
jge loc_26589
mov rdi, [rsp+0B8h+var_8]
lea rsi, [rsp+0B8h+var_68]
mov ecx, [rsp+0B8h+var_C]
add ecx, 0B4h
mov edx, 40h ; '@'
call JS_AtomGetStr
mov [rsp+0B8h+var_70], rax
mov eax, [rsp+0B8h+var_C]
add eax, 23h ; '#'
mov [rsp+0B8h+var_74], eax
mov rax, [rsp+0B8h+var_8]
mov rax, [rax+40h]
movsxd rcx, [rsp+0B8h+var_74]
shl rcx, 4
add rax, rcx
mov [rsp+0B8h+var_B0], rax
mov rdi, [rsp+0B8h+var_8]
call JS_NewObject
mov rcx, rax
mov rax, [rsp+0B8h+var_B0]
mov [rsp+0B8h+var_88], rcx
mov [rsp+0B8h+var_80], rdx
mov rcx, [rsp+0B8h+var_88]
mov [rax], rcx
mov rcx, [rsp+0B8h+var_80]
mov [rax+8], rcx
mov rdi, [rsp+0B8h+var_8]
mov rax, [rsp+0B8h+var_8]
mov rax, [rax+40h]
movsxd rcx, [rsp+0B8h+var_74]
shl rcx, 4
add rax, rcx
movsxd rdx, [rsp+0B8h+var_C]
lea rcx, js_map_proto_funcs_ptr
mov rcx, [rcx+rdx*8]
movsxd rsi, [rsp+0B8h+var_C]
lea rdx, js_map_proto_funcs_count
movzx r8d, byte ptr [rdx+rsi]
mov rsi, [rax]
mov rdx, [rax+8]
call JS_SetPropertyFunctionList
mov rdi, [rsp+0B8h+var_8]
mov rdx, [rsp+0B8h+var_70]
mov r9d, [rsp+0B8h+var_C]
lea rsi, js_map_constructor
xor ecx, ecx
mov r8d, 3
call JS_NewCFunctionMagic
mov [rsp+0B8h+var_98], rax
mov [rsp+0B8h+var_90], rdx
mov rax, [rsp+0B8h+var_98]
mov [rsp+0B8h+var_20], rax
mov rax, [rsp+0B8h+var_90]
mov [rsp+0B8h+var_18], rax
cmp [rsp+0B8h+var_74], 23h ; '#'
jnz short loc_264FF
mov rdi, [rsp+0B8h+var_8]
mov rsi, [rsp+0B8h+var_20]
mov rdx, [rsp+0B8h+var_18]
lea rcx, js_map_funcs
mov r8d, 2
call JS_SetPropertyFunctionList
jmp short loc_26532
loc_264FF:
cmp [rsp+0B8h+var_74], 24h ; '$'
jnz short loc_26530
mov rdi, [rsp+0B8h+var_8]
mov rsi, [rsp+0B8h+var_20]
mov rdx, [rsp+0B8h+var_18]
lea rcx, js_set_funcs
mov r8d, 1
call JS_SetPropertyFunctionList
loc_26530:
jmp short $+2
loc_26532:
mov rdi, [rsp+0B8h+var_8]
mov rcx, [rsp+0B8h+var_70]
mov rax, [rsp+0B8h+var_8]
mov rax, [rax+40h]
movsxd rdx, [rsp+0B8h+var_74]
shl rdx, 4
add rax, rdx
mov rsi, [rsp+0B8h+var_20]
mov rdx, [rsp+0B8h+var_18]
mov r8, [rax]
mov r9, [rax+8]
call JS_NewGlobalCConstructor2
mov eax, [rsp+0B8h+var_C]
add eax, 1
mov [rsp+0B8h+var_C], eax
jmp loc_2639A
loc_26589:
mov [rsp+0B8h+var_C], 0
loc_26594:
cmp [rsp+0B8h+var_C], 2
jge loc_2668A
mov rax, [rsp+0B8h+var_8]
mov rax, [rax+40h]
mov ecx, [rsp+0B8h+var_C]
add ecx, 2Ah ; '*'
movsxd rcx, ecx
shl rcx, 4
add rax, rcx
mov [rsp+0B8h+var_B8], rax
mov rdi, [rsp+0B8h+var_8]
mov rax, [rsp+0B8h+var_8]
mov rax, [rax+40h]
mov rsi, [rax+270h]
mov rdx, [rax+278h]
call JS_NewObjectProto
mov rcx, rax
mov rax, [rsp+0B8h+var_B8]
mov [rsp+0B8h+var_A8], rcx
mov [rsp+0B8h+var_A0], rdx
mov rcx, [rsp+0B8h+var_A8]
mov [rax], rcx
mov rcx, [rsp+0B8h+var_A0]
mov [rax+8], rcx
mov rdi, [rsp+0B8h+var_8]
mov rax, [rsp+0B8h+var_8]
mov rax, [rax+40h]
mov ecx, [rsp+0B8h+var_C]
add ecx, 2Ah ; '*'
movsxd rcx, ecx
shl rcx, 4
add rax, rcx
mov ecx, [rsp+0B8h+var_C]
add ecx, 4
movsxd rdx, ecx
lea rcx, js_map_proto_funcs_ptr
mov rcx, [rcx+rdx*8]
mov edx, [rsp+0B8h+var_C]
add edx, 4
movsxd rsi, edx
lea rdx, js_map_proto_funcs_count
movzx r8d, byte ptr [rdx+rsi]
mov rsi, [rax]
mov rdx, [rax+8]
call JS_SetPropertyFunctionList
mov eax, [rsp+0B8h+var_C]
add eax, 1
mov [rsp+0B8h+var_C], eax
jmp loc_26594
loc_2668A:
add rsp, 0B8h
retn
| void JS_AddIntrinsicMapSet(long long a1)
{
long long v1; // rdx
_QWORD *v2; // rax
long long v3; // rdx
_QWORD *v4; // rax
long long v5; // rdx
_QWORD *v6; // rax
_QWORD *v7; // [rsp+0h] [rbp-B8h]
_QWORD *v8; // [rsp+8h] [rbp-B0h]
int v9; // [rsp+44h] [rbp-74h]
long long Str; // [rsp+48h] [rbp-70h]
_BYTE v11[72]; // [rsp+50h] [rbp-68h] BYREF
long long v12; // [rsp+98h] [rbp-20h]
long long v13; // [rsp+A0h] [rbp-18h]
int i; // [rsp+ACh] [rbp-Ch]
long long v15; // [rsp+B0h] [rbp-8h]
v15 = a1;
for ( i = 0; i < 4; ++i )
{
Str = JS_AtomGetStr(v15, v11, 64LL, (unsigned int)(i + 180));
v9 = i + 35;
v8 = (_QWORD *)(16LL * (i + 35) + *(_QWORD *)(v15 + 64));
*v8 = JS_NewObject(v15);
v8[1] = v1;
v2 = (_QWORD *)(16LL * v9 + *(_QWORD *)(v15 + 64));
JS_SetPropertyFunctionList(v15, *v2, v2[1], (&js_map_proto_funcs_ptr)[i], js_map_proto_funcs_count[i]);
v12 = JS_NewCFunctionMagic(v15, js_map_constructor, Str, 0LL, 3LL, (unsigned int)i);
v13 = v3;
if ( v9 == 35 )
{
JS_SetPropertyFunctionList(v15, v12, v13, &js_map_funcs, 2LL);
}
else if ( v9 == 36 )
{
JS_SetPropertyFunctionList(v15, v12, v13, &js_set_funcs, 1LL);
}
v4 = (_QWORD *)(16LL * v9 + *(_QWORD *)(v15 + 64));
JS_NewGlobalCConstructor2(v15, v12, v13, Str, *v4, v4[1]);
}
for ( i = 0; i < 2; ++i )
{
v7 = (_QWORD *)(16LL * (i + 42) + *(_QWORD *)(v15 + 64));
*v7 = JS_NewObjectProto(v15, *(_QWORD *)(*(_QWORD *)(v15 + 64) + 624LL), *(_QWORD *)(*(_QWORD *)(v15 + 64) + 632LL));
v7[1] = v5;
v6 = (_QWORD *)(16LL * (i + 42) + *(_QWORD *)(v15 + 64));
JS_SetPropertyFunctionList(v15, *v6, v6[1], (&js_map_proto_funcs_ptr)[i + 4], js_map_proto_funcs_count[i + 4]);
}
}
| JS_AddIntrinsicMapSet:
SUB RSP,0xb8
MOV qword ptr [RSP + 0xb0],RDI
MOV dword ptr [RSP + 0xac],0x0
LAB_0012639a:
CMP dword ptr [RSP + 0xac],0x4
JGE 0x00126589
MOV RDI,qword ptr [RSP + 0xb0]
LEA RSI,[RSP + 0x50]
MOV ECX,dword ptr [RSP + 0xac]
ADD ECX,0xb4
MOV EDX,0x40
CALL 0x00152b00
MOV qword ptr [RSP + 0x48],RAX
MOV EAX,dword ptr [RSP + 0xac]
ADD EAX,0x23
MOV dword ptr [RSP + 0x44],EAX
MOV RAX,qword ptr [RSP + 0xb0]
MOV RAX,qword ptr [RAX + 0x40]
MOVSXD RCX,dword ptr [RSP + 0x44]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0xb0]
CALL 0x0012a570
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x30],RCX
MOV qword ptr [RSP + 0x38],RDX
MOV RCX,qword ptr [RSP + 0x30]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x38]
MOV qword ptr [RAX + 0x8],RCX
MOV RDI,qword ptr [RSP + 0xb0]
MOV RAX,qword ptr [RSP + 0xb0]
MOV RAX,qword ptr [RAX + 0x40]
MOVSXD RCX,dword ptr [RSP + 0x44]
SHL RCX,0x4
ADD RAX,RCX
MOVSXD RDX,dword ptr [RSP + 0xac]
LEA RCX,[0x230d80]
MOV RCX,qword ptr [RCX + RDX*0x8]
MOVSXD RSI,dword ptr [RSP + 0xac]
LEA RDX,[0x20c970]
MOVZX R8D,byte ptr [RDX + RSI*0x1]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x0014cb00
MOV RDI,qword ptr [RSP + 0xb0]
MOV RDX,qword ptr [RSP + 0x48]
MOV R9D,dword ptr [RSP + 0xac]
LEA RSI,[0x152bb0]
XOR ECX,ECX
MOV R8D,0x3
CALL 0x00152b40
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],RDX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x98],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0xa0],RAX
CMP dword ptr [RSP + 0x44],0x23
JNZ 0x001264ff
MOV RDI,qword ptr [RSP + 0xb0]
MOV RSI,qword ptr [RSP + 0x98]
MOV RDX,qword ptr [RSP + 0xa0]
LEA RCX,[0x232620]
MOV R8D,0x2
CALL 0x0014cb00
JMP 0x00126532
LAB_001264ff:
CMP dword ptr [RSP + 0x44],0x24
JNZ 0x00126530
MOV RDI,qword ptr [RSP + 0xb0]
MOV RSI,qword ptr [RSP + 0x98]
MOV RDX,qword ptr [RSP + 0xa0]
LEA RCX,[0x232660]
MOV R8D,0x1
CALL 0x0014cb00
LAB_00126530:
JMP 0x00126532
LAB_00126532:
MOV RDI,qword ptr [RSP + 0xb0]
MOV RCX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RSP + 0xb0]
MOV RAX,qword ptr [RAX + 0x40]
MOVSXD RDX,dword ptr [RSP + 0x44]
SHL RDX,0x4
ADD RAX,RDX
MOV RSI,qword ptr [RSP + 0x98]
MOV RDX,qword ptr [RSP + 0xa0]
MOV R8,qword ptr [RAX]
MOV R9,qword ptr [RAX + 0x8]
CALL 0x001535e0
MOV EAX,dword ptr [RSP + 0xac]
ADD EAX,0x1
MOV dword ptr [RSP + 0xac],EAX
JMP 0x0012639a
LAB_00126589:
MOV dword ptr [RSP + 0xac],0x0
LAB_00126594:
CMP dword ptr [RSP + 0xac],0x2
JGE 0x0012668a
MOV RAX,qword ptr [RSP + 0xb0]
MOV RAX,qword ptr [RAX + 0x40]
MOV ECX,dword ptr [RSP + 0xac]
ADD ECX,0x2a
MOVSXD RCX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0xb0]
MOV RAX,qword ptr [RSP + 0xb0]
MOV RAX,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RAX + 0x270]
MOV RDX,qword ptr [RAX + 0x278]
CALL 0x0012a4d0
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x10],RCX
MOV qword ptr [RSP + 0x18],RDX
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x8],RCX
MOV RDI,qword ptr [RSP + 0xb0]
MOV RAX,qword ptr [RSP + 0xb0]
MOV RAX,qword ptr [RAX + 0x40]
MOV ECX,dword ptr [RSP + 0xac]
ADD ECX,0x2a
MOVSXD RCX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV ECX,dword ptr [RSP + 0xac]
ADD ECX,0x4
MOVSXD RDX,ECX
LEA RCX,[0x230d80]
MOV RCX,qword ptr [RCX + RDX*0x8]
MOV EDX,dword ptr [RSP + 0xac]
ADD EDX,0x4
MOVSXD RSI,EDX
LEA RDX,[0x20c970]
MOVZX R8D,byte ptr [RDX + RSI*0x1]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x0014cb00
MOV EAX,dword ptr [RSP + 0xac]
ADD EAX,0x1
MOV dword ptr [RSP + 0xac],EAX
JMP 0x00126594
LAB_0012668a:
ADD RSP,0xb8
RET
|
void JS_AddIntrinsicMapSet(long param_1)
{
long lVar1;
int iVar2;
int8 uVar3;
int8 *puVar4;
int1 auVar5 [16];
int1 local_68 [72];
int1 local_20 [16];
int local_c;
long local_8;
local_8 = param_1;
for (local_c = 0; local_c < 4; local_c = local_c + 1) {
uVar3 = JS_AtomGetStr(local_8,local_68,0x40,local_c + 0xb4);
iVar2 = local_c + 0x23;
lVar1 = *(long *)(local_8 + 0x40);
auVar5 = JS_NewObject(local_8);
*(int1 (*) [16])(lVar1 + (long)iVar2 * 0x10) = auVar5;
puVar4 = (int8 *)(*(long *)(local_8 + 0x40) + (long)iVar2 * 0x10);
JS_SetPropertyFunctionList
(local_8,*puVar4,puVar4[1],*(int8 *)(js_map_proto_funcs_ptr + (long)local_c * 8)
,*(int1 *)((long)&js_map_proto_funcs_count + (long)local_c));
auVar5 = JS_NewCFunctionMagic(local_8,js_map_constructor,uVar3,0,3,local_c);
local_20 = auVar5;
if (iVar2 == 0x23) {
JS_SetPropertyFunctionList(local_8,auVar5._0_8_,auVar5._8_8_,js_map_funcs,2);
}
else if (iVar2 == 0x24) {
JS_SetPropertyFunctionList(local_8,auVar5._0_8_,auVar5._8_8_,js_set_funcs,1);
}
puVar4 = (int8 *)(*(long *)(local_8 + 0x40) + (long)iVar2 * 0x10);
JS_NewGlobalCConstructor2(local_8,local_20._0_8_,local_20._8_8_,uVar3,*puVar4,puVar4[1]);
}
for (local_c = 0; local_c < 2; local_c = local_c + 1) {
lVar1 = *(long *)(local_8 + 0x40);
iVar2 = local_c + 0x2a;
auVar5 = JS_NewObjectProto(local_8,*(int8 *)(*(long *)(local_8 + 0x40) + 0x270),
*(int8 *)(*(long *)(local_8 + 0x40) + 0x278));
*(int1 (*) [16])(lVar1 + (long)iVar2 * 0x10) = auVar5;
puVar4 = (int8 *)(*(long *)(local_8 + 0x40) + (long)(local_c + 0x2a) * 0x10);
JS_SetPropertyFunctionList
(local_8,*puVar4,puVar4[1],
*(int8 *)(js_map_proto_funcs_ptr + (long)(local_c + 4) * 8),
*(int1 *)((long)&js_map_proto_funcs_count + (long)(local_c + 4)));
}
return;
}
| |
41,646 | JS_AddIntrinsicMapSet | bluesky950520[P]quickjs/quickjs.c | void JS_AddIntrinsicMapSet(JSContext *ctx)
{
int i;
JSValue obj1;
char buf[ATOM_GET_STR_BUF_SIZE];
for(i = 0; i < 4; i++) {
const char *name = JS_AtomGetStr(ctx, buf, sizeof(buf),
JS_ATOM_Map + i);
int class_id = JS_CLASS_MAP + i;
ctx->class_proto[class_id] = JS_NewObject(ctx);
JS_SetPropertyFunctionList(ctx, ctx->class_proto[class_id],
js_map_proto_funcs_ptr[i],
js_map_proto_funcs_count[i]);
obj1 = JS_NewCFunctionMagic(ctx, js_map_constructor, name, 0,
JS_CFUNC_constructor_magic, i);
if (class_id == JS_CLASS_MAP)
JS_SetPropertyFunctionList(ctx, obj1, js_map_funcs, countof(js_map_funcs));
else if (class_id == JS_CLASS_SET)
JS_SetPropertyFunctionList(ctx, obj1, js_set_funcs, countof(js_set_funcs));
JS_NewGlobalCConstructor2(ctx, obj1, name, ctx->class_proto[class_id]);
}
for(i = 0; i < 2; i++) {
ctx->class_proto[JS_CLASS_MAP_ITERATOR + i] =
JS_NewObjectProto(ctx, ctx->class_proto[JS_CLASS_ITERATOR]);
JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_MAP_ITERATOR + i],
js_map_proto_funcs_ptr[i + 4],
js_map_proto_funcs_count[i + 4]);
}
} | O1 | c | JS_AddIntrinsicMapSet:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x48(%rdi), %rax
movq %rax, 0x18(%rsp)
xorl %r15d, %r15d
xorl %ebp, %ebp
movq 0x18(%rbx), %rdi
movl %ebp, %edx
orl $0xb4, %edx
leaq 0x20(%rsp), %rsi
callq 0x221f0
movq %rax, %r13
movq 0x40(%rbx), %r14
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x20f05
movq %rax, 0x230(%r14,%r15,2)
movq %rdx, 0x238(%r14,%r15,2)
movq 0x40(%rbx), %rax
leaq 0xa9063(%rip), %rcx # 0xc7cb0
movq (%r15,%rcx), %rcx
leaq 0x7ebfc(%rip), %rdx # 0x9d854
movzbl (%rbp,%rdx), %r8d
movq 0x230(%rax,%r15,2), %rsi
movq 0x238(%rax,%r15,2), %rdx
movq %rbx, %rdi
callq 0x32c67
movq 0x18(%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
leaq 0x16e80(%rip), %rsi # 0x35b0c
movq %r13, %rdx
xorl %ecx, %ecx
movl $0x3, %r8d
movl %ebp, %r9d
callq 0x21006
movq %rax, %r12
movq %rdx, %r14
testq %r15, %r15
je 0x1ecc8
cmpq $0x8, %r15
jne 0x1ece3
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
leaq 0xaa8c0(%rip), %rcx # 0xc9580
movl $0x1, %r8d
jmp 0x1ecde
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
leaq 0xaa868(%rip), %rcx # 0xc9540
movl $0x2, %r8d
callq 0x32c67
movq 0x40(%rbx), %rax
movq 0x230(%rax,%r15,2), %r8
movq 0x238(%rax,%r15,2), %r9
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x361aa
incq %rbp
addq $0x8, %r15
cmpq $0x20, %r15
jne 0x1ec00
leaq 0x7eb38(%rip), %r14 # 0x9d858
xorl %r15d, %r15d
leaq 0xa8f86(%rip), %r13 # 0xc7cb0
movq 0x40(%rbx), %r12
movq 0x270(%r12), %rsi
movq 0x278(%r12), %rdx
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x20f05
movq %rax, 0x2a0(%r12,%r15,2)
movq %rdx, 0x2a8(%r12,%r15,2)
movq 0x40(%rbx), %rax
movq 0x20(%r15,%r13), %rcx
movzbl (%r14), %r8d
movq 0x2a0(%rax,%r15,2), %rsi
movq 0x2a8(%rax,%r15,2), %rdx
movq %rbx, %rdi
callq 0x32c67
addq $0x8, %r15
incq %r14
cmpq $0x8, %r15
je 0x1ed2a
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| JS_AddIntrinsicMapSet:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov rbx, rdi
lea rax, [rdi+48h]
mov [rsp+98h+var_80], rax
xor r15d, r15d
xor ebp, ebp
loc_1EC00:
mov rdi, [rbx+18h]
mov edx, ebp
or edx, 0B4h
lea rsi, [rsp+98h+var_78]
call JS_AtomGetStrRT
mov r13, rax
mov r14, [rbx+40h]
mov rsi, [r14+10h]
mov rdx, [r14+18h]
mov rdi, rbx
mov ecx, 1
call JS_NewObjectProtoClass
mov [r14+r15*2+230h], rax
mov [r14+r15*2+238h], rdx
mov rax, [rbx+40h]
lea rcx, js_map_proto_funcs_ptr
mov rcx, [r15+rcx]
lea rdx, js_map_proto_funcs_count
movzx r8d, byte ptr [rbp+rdx+0]
mov rsi, [rax+r15*2+230h]
mov rdx, [rax+r15*2+238h]
mov rdi, rbx
call JS_SetPropertyFunctionList
mov rax, [rsp+98h+var_80]
movups xmm0, xmmword ptr [rax]
movups [rsp+98h+var_98], xmm0
mov rdi, rbx
lea rsi, js_map_constructor
mov rdx, r13
xor ecx, ecx
mov r8d, 3
mov r9d, ebp
call JS_NewCFunction3
mov r12, rax
mov r14, rdx
test r15, r15
jz short loc_1ECC8
cmp r15, 8
jnz short loc_1ECE3
mov rdi, rbx
mov rsi, r12
mov rdx, r14
lea rcx, js_set_funcs
mov r8d, 1
jmp short loc_1ECDE
loc_1ECC8:
mov rdi, rbx
mov rsi, r12
mov rdx, r14
lea rcx, js_map_funcs
mov r8d, 2
loc_1ECDE:
call JS_SetPropertyFunctionList
loc_1ECE3:
mov rax, [rbx+40h]
mov r8, [rax+r15*2+230h]
mov r9, [rax+r15*2+238h]
mov rdi, rbx
mov rsi, r12
mov rdx, r14
mov rcx, r13
call JS_NewGlobalCConstructor2
inc rbp
add r15, 8
cmp r15, 20h ; ' '
jnz loc_1EC00
lea r14, unk_9D858
xor r15d, r15d
lea r13, js_map_proto_funcs_ptr
loc_1ED2A:
mov r12, [rbx+40h]
mov rsi, [r12+270h]
mov rdx, [r12+278h]
mov rdi, rbx
mov ecx, 1
call JS_NewObjectProtoClass
mov [r12+r15*2+2A0h], rax
mov [r12+r15*2+2A8h], rdx
mov rax, [rbx+40h]
mov rcx, [r15+r13+20h]
movzx r8d, byte ptr [r14]
mov rsi, [rax+r15*2+2A0h]
mov rdx, [rax+r15*2+2A8h]
mov rdi, rbx
call JS_SetPropertyFunctionList
add r15, 8
inc r14
cmp r15, 8
jz short loc_1ED2A
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long JS_AddIntrinsicMapSet(_QWORD *a1)
{
unsigned long long v2; // r15
long long v3; // rbp
long long StrRT; // r13
long long v5; // r14
long long v6; // rdx
long long v7; // rax
long long v8; // rdx
long long v9; // r12
long long v10; // r14
_QWORD *v11; // rdi
long long v12; // rsi
char **v13; // rcx
long long v14; // r8
unsigned __int8 *v15; // r14
unsigned long long v16; // r15
long long v17; // r12
long long v18; // rdx
long long result; // rax
long long *v20; // [rsp+18h] [rbp-80h]
char v21[120]; // [rsp+20h] [rbp-78h] BYREF
v20 = a1 + 9;
v2 = 0LL;
v3 = 0LL;
do
{
StrRT = JS_AtomGetStrRT(a1[3], v21, (unsigned int)v3 | 0xB4);
v5 = a1[8];
*(_QWORD *)(v5 + 2 * v2 + 560) = JS_NewObjectProtoClass(a1, *(_QWORD *)(v5 + 16), *(_QWORD *)(v5 + 24), 1LL);
*(_QWORD *)(v5 + 2 * v2 + 568) = v6;
JS_SetPropertyFunctionList(
a1,
*(_QWORD *)(a1[8] + 2 * v2 + 560),
*(_QWORD *)(a1[8] + 2 * v2 + 568),
(&js_map_proto_funcs_ptr)[v2 / 8],
js_map_proto_funcs_count[v3]);
v7 = JS_NewCFunction3((_DWORD)a1, (unsigned int)js_map_constructor, StrRT, 0, 3, v3, *v20, v20[1]);
v9 = v7;
v10 = v8;
if ( v2 )
{
if ( v2 != 8 )
goto LABEL_7;
v11 = a1;
v12 = v7;
v13 = &js_set_funcs;
v14 = 1LL;
}
else
{
v11 = a1;
v12 = v7;
v13 = &js_map_funcs;
v14 = 2LL;
}
JS_SetPropertyFunctionList(v11, v12, v8, v13, v14);
LABEL_7:
JS_NewGlobalCConstructor2(a1, v9, v10, StrRT, *(_QWORD *)(a1[8] + 2 * v2 + 560), *(_QWORD *)(a1[8] + 2 * v2 + 568));
++v3;
v2 += 8LL;
}
while ( v2 != 32 );
v15 = (unsigned __int8 *)&unk_9D858;
v16 = 0LL;
do
{
v17 = a1[8];
*(_QWORD *)(v17 + 2 * v16 + 672) = JS_NewObjectProtoClass(a1, *(_QWORD *)(v17 + 624), *(_QWORD *)(v17 + 632), 1LL);
*(_QWORD *)(v17 + 2 * v16 + 680) = v18;
result = JS_SetPropertyFunctionList(
a1,
*(_QWORD *)(a1[8] + 2 * v16 + 672),
*(_QWORD *)(a1[8] + 2 * v16 + 680),
(&js_map_proto_funcs_ptr)[v16 / 8 + 4],
*v15);
v16 += 8LL;
++v15;
}
while ( v16 == 8 );
return result;
}
| JS_AddIntrinsicMapSet:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV RBX,RDI
LEA RAX,[RDI + 0x48]
MOV qword ptr [RSP + 0x18],RAX
XOR R15D,R15D
XOR EBP,EBP
LAB_0011ec00:
MOV RDI,qword ptr [RBX + 0x18]
MOV EDX,EBP
OR EDX,0xb4
LEA RSI,[RSP + 0x20]
CALL 0x001221f0
MOV R13,RAX
MOV R14,qword ptr [RBX + 0x40]
MOV RSI,qword ptr [R14 + 0x10]
MOV RDX,qword ptr [R14 + 0x18]
MOV RDI,RBX
MOV ECX,0x1
CALL 0x00120f05
MOV qword ptr [R14 + R15*0x2 + 0x230],RAX
MOV qword ptr [R14 + R15*0x2 + 0x238],RDX
MOV RAX,qword ptr [RBX + 0x40]
LEA RCX,[0x1c7cb0]
MOV RCX,qword ptr [R15 + RCX*0x1]
LEA RDX,[0x19d854]
MOVZX R8D,byte ptr [RBP + RDX*0x1]
MOV RSI,qword ptr [RAX + R15*0x2 + 0x230]
MOV RDX,qword ptr [RAX + R15*0x2 + 0x238]
MOV RDI,RBX
CALL 0x00132c67
MOV RAX,qword ptr [RSP + 0x18]
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,RBX
LEA RSI,[0x135b0c]
MOV RDX,R13
XOR ECX,ECX
MOV R8D,0x3
MOV R9D,EBP
CALL 0x00121006
MOV R12,RAX
MOV R14,RDX
TEST R15,R15
JZ 0x0011ecc8
CMP R15,0x8
JNZ 0x0011ece3
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R14
LEA RCX,[0x1c9580]
MOV R8D,0x1
JMP 0x0011ecde
LAB_0011ecc8:
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R14
LEA RCX,[0x1c9540]
MOV R8D,0x2
LAB_0011ecde:
CALL 0x00132c67
LAB_0011ece3:
MOV RAX,qword ptr [RBX + 0x40]
MOV R8,qword ptr [RAX + R15*0x2 + 0x230]
MOV R9,qword ptr [RAX + R15*0x2 + 0x238]
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R14
MOV RCX,R13
CALL 0x001361aa
INC RBP
ADD R15,0x8
CMP R15,0x20
JNZ 0x0011ec00
LEA R14,[0x19d858]
XOR R15D,R15D
LEA R13,[0x1c7cb0]
LAB_0011ed2a:
MOV R12,qword ptr [RBX + 0x40]
MOV RSI,qword ptr [R12 + 0x270]
MOV RDX,qword ptr [R12 + 0x278]
MOV RDI,RBX
MOV ECX,0x1
CALL 0x00120f05
MOV qword ptr [R12 + R15*0x2 + 0x2a0],RAX
MOV qword ptr [R12 + R15*0x2 + 0x2a8],RDX
MOV RAX,qword ptr [RBX + 0x40]
MOV RCX,qword ptr [R15 + R13*0x1 + 0x20]
MOVZX R8D,byte ptr [R14]
MOV RSI,qword ptr [RAX + R15*0x2 + 0x2a0]
MOV RDX,qword ptr [RAX + R15*0x2 + 0x2a8]
MOV RDI,RBX
CALL 0x00132c67
ADD R15,0x8
INC R14
CMP R15,0x8
JZ 0x0011ed2a
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void JS_AddIntrinsicMapSet(long param_1)
{
long lVar1;
int8 uVar2;
int1 *puVar3;
ulong uVar4;
int8 uVar5;
long lVar6;
int1 auVar7 [16];
int1 local_78 [72];
lVar6 = 0;
uVar4 = 0;
do {
uVar2 = JS_AtomGetStrRT(*(int8 *)(param_1 + 0x18),local_78,(uint)uVar4 | 0xb4);
lVar1 = *(long *)(param_1 + 0x40);
auVar7 = JS_NewObjectProtoClass
(param_1,*(int8 *)(lVar1 + 0x10),*(int8 *)(lVar1 + 0x18),1);
*(long *)(lVar1 + 0x230 + lVar6 * 2) = auVar7._0_8_;
*(long *)(lVar1 + 0x238 + lVar6 * 2) = auVar7._8_8_;
JS_SetPropertyFunctionList
(param_1,*(int8 *)(*(long *)(param_1 + 0x40) + 0x230 + lVar6 * 2),
*(int8 *)(*(long *)(param_1 + 0x40) + 0x238 + lVar6 * 2),
*(int8 *)((long)&js_map_proto_funcs_ptr + lVar6),
(&js_map_proto_funcs_count)[uVar4]);
auVar7 = JS_NewCFunction3(param_1,js_map_constructor,uVar2,0,3,uVar4 & 0xffffffff,
*(int4 *)(param_1 + 0x48),*(int4 *)(param_1 + 0x50));
if (lVar6 == 0) {
puVar3 = js_map_funcs;
uVar5 = 2;
LAB_0011ecde:
JS_SetPropertyFunctionList(param_1,auVar7._0_8_,auVar7._8_8_,puVar3,uVar5);
}
else if (lVar6 == 8) {
puVar3 = js_set_funcs;
uVar5 = 1;
goto LAB_0011ecde;
}
JS_NewGlobalCConstructor2
(param_1,auVar7._0_8_,auVar7._8_8_,uVar2,
*(int8 *)(*(long *)(param_1 + 0x40) + 0x230 + lVar6 * 2),
*(int8 *)(*(long *)(param_1 + 0x40) + 0x238 + lVar6 * 2));
uVar4 = uVar4 + 1;
lVar6 = lVar6 + 8;
if (lVar6 == 0x20) {
puVar3 = &DAT_0019d858;
lVar6 = 0;
do {
lVar1 = *(long *)(param_1 + 0x40);
auVar7 = JS_NewObjectProtoClass
(param_1,*(int8 *)(lVar1 + 0x270),*(int8 *)(lVar1 + 0x278),1)
;
*(long *)(lVar1 + 0x2a0 + lVar6 * 2) = auVar7._0_8_;
*(long *)(lVar1 + 0x2a8 + lVar6 * 2) = auVar7._8_8_;
JS_SetPropertyFunctionList
(param_1,*(int8 *)(*(long *)(param_1 + 0x40) + 0x2a0 + lVar6 * 2),
*(int8 *)(*(long *)(param_1 + 0x40) + 0x2a8 + lVar6 * 2),
*(int8 *)((long)&PTR_js_map_iterator_proto_funcs_001c7cd0 + lVar6),*puVar3)
;
lVar6 = lVar6 + 8;
puVar3 = puVar3 + 1;
} while (lVar6 == 8);
return;
}
} while( true );
}
| |
41,647 | ma_change_bitmap_page | eloqsql/storage/maria/ma_bitmap.c | static my_bool _ma_change_bitmap_page(MARIA_HA *info,
MARIA_FILE_BITMAP *bitmap,
pgcache_page_no_t page)
{
DBUG_ENTER("_ma_change_bitmap_page");
_ma_check_bitmap(bitmap);
/*
We have to mark the file changed here, as otherwise the following
read/write to pagecache may force a page out from this file, which would
cause _ma_mark_file_changed() to be called with bitmaplock hold!
*/
_ma_bitmap_mark_file_changed(info->s, 1);
if (bitmap->changed)
{
if (write_changed_bitmap(info->s, bitmap))
DBUG_RETURN(1);
bitmap->changed= 0;
}
DBUG_RETURN(_ma_read_bitmap_page(info, bitmap, page));
} | O0 | c | ma_change_bitmap_page:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
jmp 0x43176
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0x41c90
movq -0x18(%rbp), %rax
cmpb $0x0, 0x20(%rax)
je 0x431b5
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x41d60
cmpb $0x0, %al
je 0x431ad
jmp 0x431a7
movb $0x1, -0x1(%rbp)
jmp 0x431cb
movq -0x18(%rbp), %rax
movb $0x0, 0x20(%rax)
jmp 0x431b7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x45780
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ma_change_bitmap_page:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
jmp short $+2
loc_43176:
mov rax, [rbp+var_10]
mov rdi, [rax]
mov esi, 1
call _ma_bitmap_mark_file_changed
mov rax, [rbp+var_18]
cmp byte ptr [rax+20h], 0
jz short loc_431B5
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rsi, [rbp+var_18]
call write_changed_bitmap
cmp al, 0
jz short loc_431AD
jmp short $+2
loc_431A7:
mov [rbp+var_1], 1
jmp short loc_431CB
loc_431AD:
mov rax, [rbp+var_18]
mov byte ptr [rax+20h], 0
loc_431B5:
jmp short $+2
loc_431B7:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call _ma_read_bitmap_page
mov [rbp+var_1], al
loc_431CB:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char ma_change_bitmap_page(long long *a1, long long a2, long long a3)
{
ma_bitmap_mark_file_changed(*a1, 1);
if ( !*(_BYTE *)(a2 + 32) )
return ma_read_bitmap_page(a1, a2, a3);
if ( !write_changed_bitmap(*a1, a2) )
{
*(_BYTE *)(a2 + 32) = 0;
return ma_read_bitmap_page(a1, a2, a3);
}
return 1;
}
| _ma_change_bitmap_page:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
JMP 0x00143176
LAB_00143176:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV ESI,0x1
CALL 0x00141c90
MOV RAX,qword ptr [RBP + -0x18]
CMP byte ptr [RAX + 0x20],0x0
JZ 0x001431b5
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00141d60
CMP AL,0x0
JZ 0x001431ad
JMP 0x001431a7
LAB_001431a7:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001431cb
LAB_001431ad:
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x20],0x0
LAB_001431b5:
JMP 0x001431b7
LAB_001431b7:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x00145780
MOV byte ptr [RBP + -0x1],AL
LAB_001431cb:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 _ma_change_bitmap_page(int8 *param_1,long param_2,int8 param_3)
{
char cVar1;
int1 uVar2;
_ma_bitmap_mark_file_changed(*param_1,1);
if (*(char *)(param_2 + 0x20) != '\0') {
cVar1 = write_changed_bitmap(*param_1,param_2);
if (cVar1 != '\0') {
return 1;
}
*(int1 *)(param_2 + 0x20) = 0;
}
uVar2 = _ma_read_bitmap_page(param_1,param_2,param_3);
return uVar2;
}
| |
41,648 | bool minja::Value::get<bool>() const | monkey531[P]llama/common/minja.hpp | T get() const {
if (is_primitive()) return primitive_.get<T>();
throw std::runtime_error("get<T> not defined for this value type: " + dump());
} | O2 | cpp | bool minja::Value::get<bool>() const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
callq 0x64378
testb %al, %al
je 0x64d2e
addq $0x40, %r14
movq %r14, %rdi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x64f14
pushq $0x10
popq %rdi
callq 0x23470
movq %rax, %rbx
movq %rsp, %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x64388
leaq 0x4ffe7(%rip), %rsi # 0xb4d37
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x59ae2
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x23e30
xorl %ebp, %ebp
movq 0x9a272(%rip), %rsi # 0xfefe8
movq 0x9a1cb(%rip), %rdx # 0xfef48
movq %rbx, %rdi
callq 0x23f00
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x241c8
jmp 0x64d9a
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x241c8
testb %bpl, %bpl
jne 0x64dac
jmp 0x64db4
movq %rax, %r14
movq %rbx, %rdi
callq 0x236a0
movq %r14, %rdi
callq 0x23f80
| _ZNK5minja5Value3getIbEET_v:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rdi
call _ZNK5minja5Value12is_primitiveEv; minja::Value::is_primitive(void)
test al, al
jz short loc_64D2E
add r14, 40h ; '@'
mov rdi, r14
add rsp, 40h
pop rbx
pop r14
pop rbp
jmp _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIbTnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
loc_64D2E:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r14
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aGetTNotDefined; "get<T> not defined for this value type:"...
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rdi, [rsp+58h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_64D9A
mov r14, rax
mov bpl, 1
loc_64D9A:
mov rdi, rsp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_64DAC
jmp short loc_64DB4
mov r14, rax
loc_64DAC:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_64DB4:
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::get<bool>(minja::Value *a1)
{
void *exception; // rbx
_BYTE v3[32]; // [rsp+0h] [rbp-58h] BYREF
_BYTE v4[56]; // [rsp+20h] [rbp-38h] BYREF
if ( !minja::Value::is_primitive(a1) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v3, (long long)a1, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v4, (long long)"get<T> not defined for this value type: ", (long long)v3);
std::runtime_error::runtime_error(exception, v4);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIbTnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE((char *)a1 + 64);
}
| get<bool>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
CALL 0x00164378
TEST AL,AL
JZ 0x00164d2e
ADD R14,0x40
MOV RDI,R14
ADD RSP,0x40
POP RBX
POP R14
POP RBP
JMP 0x00164f14
LAB_00164d2e:
PUSH 0x10
POP RDI
CALL 0x00123470
MOV RBX,RAX
LAB_00164d39:
MOV RDI,RSP
PUSH -0x1
POP RDX
MOV RSI,R14
XOR ECX,ECX
CALL 0x00164388
LAB_00164d49:
LEA RSI,[0x1b4d37]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x00159ae2
MOV BPL,0x1
LAB_00164d60:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00123e30
XOR EBP,EBP
MOV RSI,qword ptr [0x001fefe8]
MOV RDX,qword ptr [0x001fef48]
MOV RDI,RBX
CALL 0x00123f00
|
/* bool minja::Value::get<bool>() const */
bool __thiscall minja::Value::get<bool>(Value *this)
{
runtime_error *this_00;
char cVar1;
bool bVar2;
int1 auStack_58 [32];
string local_38 [32];
cVar1 = is_primitive(this);
if (cVar1 != '\0') {
bVar2 = (bool)_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIbTnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
(this + 0x40);
return bVar2;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00164d39 to 00164d48 has its CatchHandler @ 00164da9 */
dump_abi_cxx11_((int)auStack_58,SUB81(this,0));
/* try { // try from 00164d49 to 00164d5c has its CatchHandler @ 00164d94 */
std::operator+((char *)local_38,(string *)"get<T> not defined for this value type: ");
/* try { // try from 00164d60 to 00164d84 has its CatchHandler @ 00164d85 */
std::runtime_error::runtime_error(this_00,local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_001fefe8,PTR__runtime_error_001fef48);
}
| |
41,649 | google::protobuf::StringValue::MergeImpl(google::protobuf::Message&, google::protobuf::Message const&) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/wrappers.pb.cc | void StringValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
auto* const _this = static_cast<StringValue*>(&to_msg);
auto& from = static_cast<const StringValue&>(from_msg);
// @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.StringValue)
GOOGLE_DCHECK_NE(&from, _this);
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
if (!from._internal_value().empty()) {
_this->_internal_set_value(from._internal_value());
}
_this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
} | O0 | cpp | google::protobuf::StringValue::MergeImpl(google::protobuf::Message&, google::protobuf::Message const&):
subq $0x108, %rsp # imm = 0x108
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x90(%rsp)
xorl %eax, %eax
testb $0x1, %al
jne 0x465232
jmp 0x4652dc
movq 0x90(%rsp), %rax
movq 0x98(%rsp), %rcx
movb $0x0, 0x57(%rsp)
cmpq %rcx, %rax
je 0x46524e
jmp 0x46529e
leaq 0x19142a(%rip), %rdx # 0x5f667f
leaq 0x58(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movl $0x3, %esi
movl $0x6a5, %ecx # imm = 0x6A5
callq 0x3ef0b0
movq 0x28(%rsp), %rdi
movb $0x1, 0x57(%rsp)
leaq 0x1896cb(%rip), %rsi # 0x5ee94a
callq 0x3ee970
movq %rax, 0x30(%rsp)
jmp 0x46528b
movq 0x30(%rsp), %rsi
leaq 0x43(%rsp), %rdi
callq 0x3eeb20
jmp 0x46529c
jmp 0x46529e
testb $0x1, 0x57(%rsp)
jne 0x4652a7
jmp 0x4652b1
leaq 0x58(%rsp), %rdi
callq 0x3ef0f0
jmp 0x465227
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x4652cd
jmp 0x4652d7
leaq 0x58(%rsp), %rdi
callq 0x3ef0f0
jmp 0x465467
movl $0x0, 0x3c(%rsp)
movq 0x90(%rsp), %rdi
callq 0x467ef0
movq %rax, %rdi
callq 0x18fb80
testb $0x1, %al
jne 0x465364
movq 0x98(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x90(%rsp), %rdi
callq 0x467ef0
movq 0x10(%rsp), %rcx
movq %rcx, 0xf0(%rsp)
movq %rax, 0xe8(%rsp)
movq 0xf0(%rsp), %rdi
movq %rdi, %rax
addq $0x10, %rax
movq %rax, 0x18(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x1d8160
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rax, %rdx
callq 0x3bce10
movq 0x98(%rsp), %rcx
addq $0x8, %rcx
movq 0x90(%rsp), %rax
addq $0x8, %rax
movq %rcx, 0xb8(%rsp)
movq %rax, 0xb0(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x100(%rsp)
movq 0x100(%rsp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x46545f
movq 0xb0(%rsp), %rax
movq %rax, 0xd0(%rsp)
movq $0x0, 0xc8(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, (%rsp)
movq %rax, 0xe0(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0xf8(%rsp)
movq 0xf8(%rsp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x46543e
movq (%rsp), %rdi
callq 0x3b8270
addq $0x8, %rax
movq %rax, 0xd8(%rsp)
jmp 0x46544d
callq *0xc8(%rsp)
movq %rax, 0xd8(%rsp)
movq 0x8(%rsp), %rdi
movq 0xd8(%rsp), %rsi
callq 0x3b8100
addq $0x108, %rsp # imm = 0x108
retq
movq 0x48(%rsp), %rdi
callq 0x198ce0
nopw %cs:(%rax,%rax)
| _ZN6google8protobuf11StringValue9MergeImplERNS0_7MessageERKS2_:
sub rsp, 108h
mov [rsp+108h+var_60], rdi
mov [rsp+108h+var_68], rsi
mov rax, [rsp+108h+var_60]
mov [rsp+108h+var_70], rax
mov rax, [rsp+108h+var_68]
mov [rsp+108h+var_78], rax
loc_465227:
xor eax, eax
test al, 1
jnz short loc_465232
jmp loc_4652DC
loc_465232:
mov rax, [rsp+108h+var_78]
mov rcx, [rsp+108h+var_70]
mov [rsp+108h+var_B1], 0
cmp rax, rcx
jz short loc_46524E
jmp short loc_46529E
loc_46524E:
lea rdx, aWorkspaceLlm4b_39; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+108h+var_B0]
mov [rsp+108h+var_E0], rdi
mov esi, 3
mov ecx, 6A5h
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+108h+var_E0]
mov [rsp+108h+var_B1], 1
lea rsi, aCheckFailedFro; "CHECK failed: (&from) != (_this): "
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+108h+var_D8], rax
jmp short $+2
loc_46528B:
mov rsi, [rsp+108h+var_D8]
lea rdi, [rsp+108h+var_C5]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_46529C:
jmp short $+2
loc_46529E:
test [rsp+108h+var_B1], 1
jnz short loc_4652A7
jmp short loc_4652B1
loc_4652A7:
lea rdi, [rsp+108h+var_B0]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_4652B1:
jmp loc_465227
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
test [rsp+arg_4F], 1
jnz short loc_4652CD
jmp short loc_4652D7
loc_4652CD:
lea rdi, [rsp+arg_50]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_4652D7:
jmp loc_465467
loc_4652DC:
mov [rsp+108h+var_CC], 0
mov rdi, [rsp+108h+var_78]
call _ZNK6google8protobuf11StringValue15_internal_valueB5cxx11Ev; google::protobuf::StringValue::_internal_value(void)
mov rdi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz short loc_465364
mov rax, [rsp+108h+var_70]
mov [rsp+108h+var_F8], rax
mov rdi, [rsp+108h+var_78]
call _ZNK6google8protobuf11StringValue15_internal_valueB5cxx11Ev; google::protobuf::StringValue::_internal_value(void)
mov rcx, [rsp+108h+var_F8]
mov [rsp+108h+var_18], rcx
mov [rsp+108h+var_20], rax
mov rdi, [rsp+108h+var_18]; this
mov rax, rdi
add rax, 10h
mov qword ptr [rsp+108h+var_F0], rax
mov rax, [rsp+108h+var_20]
mov qword ptr [rsp+108h+var_E8], rax
call _ZNK6google8protobuf11MessageLite21GetArenaForAllocationEv; google::protobuf::MessageLite::GetArenaForAllocation(void)
mov rdi, qword ptr [rsp+108h+var_F0]; int
mov rsi, qword ptr [rsp+108h+var_E8]; int
mov rdx, rax; int
call _ZN6google8protobuf8internal14ArenaStringPtr3SetERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPNS0_5ArenaE; google::protobuf::internal::ArenaStringPtr::Set(std::string const&,google::protobuf::Arena *)
loc_465364:
mov rcx, [rsp+108h+var_70]
add rcx, 8
mov rax, [rsp+108h+var_78]
add rax, 8
mov [rsp+108h+var_50], rcx
mov [rsp+108h+var_58], rax
mov rax, [rsp+108h+var_50]
mov [rsp+108h+var_100], rax
mov rax, [rsp+108h+var_58]
mov [rsp+108h+var_48], rax
mov rax, [rsp+108h+var_48]
mov [rsp+108h+var_8], rax
mov rax, [rsp+108h+var_8]
mov rax, [rax]
and rax, 1
cmp rax, 0
jz loc_46545F
mov rax, [rsp+108h+var_58]
mov [rsp+108h+var_38], rax
mov [rsp+108h+var_40], 0
mov rax, [rsp+108h+var_38]
mov [rsp+108h+var_108], rax
mov [rsp+108h+var_28], rax
mov rax, [rsp+108h+var_28]
mov [rsp+108h+var_10], rax
mov rax, [rsp+108h+var_10]
mov rax, [rax]
and rax, 1
cmp rax, 0
jz short loc_46543E
mov rdi, [rsp+108h+var_108]
call _ZNK6google8protobuf8internal16InternalMetadata8PtrValueINS2_9ContainerINS0_15UnknownFieldSetEEEEEPT_v; google::protobuf::internal::InternalMetadata::PtrValue<google::protobuf::internal::InternalMetadata::Container<google::protobuf::UnknownFieldSet>>(void)
add rax, 8
mov qword ptr [rsp+108h+var_30], rax
jmp short loc_46544D
loc_46543E:
call [rsp+108h+var_40]
mov qword ptr [rsp+108h+var_30], rax
loc_46544D:
mov rdi, [rsp+108h+var_100]; void *
mov rsi, qword ptr [rsp+108h+var_30]; int
call _ZN6google8protobuf8internal16InternalMetadata11DoMergeFromINS0_15UnknownFieldSetEEEvRKT_; google::protobuf::internal::InternalMetadata::DoMergeFrom<google::protobuf::UnknownFieldSet>(google::protobuf::UnknownFieldSet const&)
loc_46545F:
add rsp, 108h
retn
loc_465467:
mov rdi, [rsp+arg_40]
call __Unwind_Resume
| long long google::protobuf::StringValue::MergeImpl(
google::protobuf::StringValue *this,
google::protobuf::Message *a2,
const google::protobuf::Message *a3)
{
char *v3; // rdi
int ArenaForAllocation; // eax
long long result; // rax
google::protobuf::Message *v6; // [rsp+20h] [rbp-E8h]
google::protobuf::Message *v7; // [rsp+90h] [rbp-78h]
_QWORD *v9; // [rsp+B0h] [rbp-58h]
int v10[2]; // [rsp+D8h] [rbp-30h]
v7 = a2;
v3 = (char *)google::protobuf::StringValue::_internal_value[abi:cxx11](a2);
if ( (std::string::empty(v3) & 1) == 0 )
{
v6 = (google::protobuf::Message *)google::protobuf::StringValue::_internal_value[abi:cxx11](a2);
ArenaForAllocation = google::protobuf::MessageLite::GetArenaForAllocation(this);
v3 = (char *)this + 16;
a2 = v6;
google::protobuf::internal::ArenaStringPtr::Set((_DWORD)this + 16, (int)v6, ArenaForAllocation);
}
v9 = (_QWORD *)((char *)v7 + 8);
result = *((_QWORD *)v7 + 1) & 1LL;
if ( result )
{
if ( (*v9 & 1LL) != 0 )
*(_QWORD *)v10 = google::protobuf::internal::InternalMetadata::PtrValue<google::protobuf::internal::InternalMetadata::Container<google::protobuf::UnknownFieldSet>>(v9)
+ 8;
else
v10[0] = ((long long ( *)(char *, google::protobuf::Message *))dword_0)(v3, a2);
return google::protobuf::internal::InternalMetadata::DoMergeFrom<google::protobuf::UnknownFieldSet>(
(char *)this + 8,
v10[0]);
}
return result;
}
| _M_const_cast:
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
MOV RAX,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RAX]
LEA RDI,[RSP + 0x10]
CALL 0x00464660
MOV RAX,qword ptr [RSP + 0x10]
ADD RSP,0x18
RET
|
/* std::_Rb_tree_const_iterator<std::shared_ptr<YAML::detail::node> >::_M_const_cast() const */
int8 __thiscall
std::_Rb_tree_const_iterator<std::shared_ptr<YAML::detail::node>>::_M_const_cast
(_Rb_tree_const_iterator<std::shared_ptr<YAML::detail::node>> *this)
{
int8 local_8;
_Rb_tree_iterator<std::shared_ptr<YAML::detail::node>>::_Rb_tree_iterator
((_Rb_tree_iterator<std::shared_ptr<YAML::detail::node>> *)&local_8,
*(_Rb_tree_node_base **)this);
return local_8;
}
| |
41,650 | google::protobuf::StringValue::MergeImpl(google::protobuf::Message&, google::protobuf::Message const&) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/wrappers.pb.cc | void StringValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
auto* const _this = static_cast<StringValue*>(&to_msg);
auto& from = static_cast<const StringValue&>(from_msg);
// @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.StringValue)
GOOGLE_DCHECK_NE(&from, _this);
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
if (!from._internal_value().empty()) {
_this->_internal_set_value(from._internal_value());
}
_this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
} | O3 | cpp | google::protobuf::StringValue::MergeImpl(google::protobuf::Message&, google::protobuf::Message const&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
andq $-0x4, %rsi
cmpq $0x0, 0x8(%rsi)
je 0x16ac85
leaq 0x10(%rbx), %rdi
movq 0x8(%rbx), %rax
movq %rax, %rdx
andq $-0x4, %rdx
testb $0x1, %al
jne 0x16acb2
callq 0x130f4e
movq 0x8(%r14), %rsi
testb $0x1, %sil
jne 0x16ac97
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x8, %rbx
andq $-0x4, %rsi
addq $0x8, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12febe
movq (%rdx), %rdx
jmp 0x16ac80
nop
| _ZN6google8protobuf11StringValue9MergeImplERNS0_7MessageERKS2_:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rsi, [rsi+10h]
and rsi, 0FFFFFFFFFFFFFFFCh
cmp qword ptr [rsi+8], 0
jz short loc_16AC85
lea rdi, [rbx+10h]
mov rax, [rbx+8]
mov rdx, rax
and rdx, 0FFFFFFFFFFFFFFFCh
test al, 1
jnz short loc_16ACB2
loc_16AC80:
call _ZN6google8protobuf8internal14ArenaStringPtr3SetERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPNS0_5ArenaE; google::protobuf::internal::ArenaStringPtr::Set(std::string const&,google::protobuf::Arena *)
loc_16AC85:
mov rsi, [r14+8]
test sil, 1
jnz short loc_16AC97
add rsp, 8
pop rbx
pop r14
retn
loc_16AC97:
add rbx, 8
and rsi, 0FFFFFFFFFFFFFFFCh
add rsi, 8
mov rdi, rbx
add rsp, 8
pop rbx
pop r14
jmp _ZN6google8protobuf8internal16InternalMetadata11DoMergeFromINS0_15UnknownFieldSetEEEvRKT_; google::protobuf::internal::InternalMetadata::DoMergeFrom<google::protobuf::UnknownFieldSet>(google::protobuf::UnknownFieldSet const&)
loc_16ACB2:
mov rdx, [rdx]
jmp short loc_16AC80
| long long google::protobuf::StringValue::MergeImpl(
google::protobuf::StringValue *this,
google::protobuf::Message *a2,
const google::protobuf::Message *a3)
{
_QWORD *v5; // rsi
long long *v6; // rdi
google::protobuf::Arena *v7; // rdx
long long result; // rax
long long v9; // rsi
v5 = (_QWORD *)(*((_QWORD *)a2 + 2) & 0xFFFFFFFFFFFFFFFCLL);
if ( v5[1] )
{
v6 = (long long *)((char *)this + 16);
v7 = (google::protobuf::Arena *)(*((_QWORD *)this + 1) & 0xFFFFFFFFFFFFFFFCLL);
if ( (*((_QWORD *)this + 1) & 1) != 0 )
v7 = *(google::protobuf::Arena **)v7;
result = google::protobuf::internal::ArenaStringPtr::Set(v6, v5, v7);
}
v9 = *((_QWORD *)a2 + 1);
if ( (v9 & 1) != 0 )
return google::protobuf::internal::InternalMetadata::DoMergeFrom<google::protobuf::UnknownFieldSet>(
(long long *)this + 1,
(const google::protobuf::UnknownFieldSet *)((v9 & 0xFFFFFFFFFFFFFFFCLL) + 8));
return result;
}
| |||
41,651 | mi_ck_write | eloqsql/storage/myisam/mi_write.c | int _mi_ck_write(MI_INFO *info, uint keynr, uchar *key, uint key_length)
{
DBUG_ENTER("_mi_ck_write");
if (info->bulk_insert && is_tree_inited(&info->bulk_insert[keynr]))
{
DBUG_RETURN(_mi_ck_write_tree(info, keynr, key, key_length));
}
else
{
DBUG_RETURN(_mi_ck_write_btree(info, keynr, key, key_length));
}
} | O3 | c | mi_ck_write:
movq %rdi, %rax
movq 0x80(%rdi), %rdi
testq %rdi, %rdi
je 0x8914e
movl %esi, %r8d
imulq $0x298, %r8, %r8 # imm = 0x298
cmpq $0x0, (%rdi,%r8)
je 0x8914e
pushq %rbp
movq %rsp, %rbp
addq %r8, %rdi
movq (%rax), %rax
addl 0x338(%rax), %ecx
movq 0x230(%rdi), %rax
movq %rdx, %rsi
movl %ecx, %edx
movq %rax, %rcx
callq 0xa572e
xorl %ecx, %ecx
testq %rax, %rax
sete %cl
shll $0x7, %ecx
movl %ecx, %eax
popq %rbp
retq
movq %rax, %rdi
jmp 0x8919b
| _mi_ck_write:
mov rax, rdi
mov rdi, [rdi+80h]
test rdi, rdi
jz short loc_8914E
mov r8d, esi
imul r8, 298h
cmp qword ptr [rdi+r8], 0
jz short loc_8914E
push rbp
mov rbp, rsp
add rdi, r8
mov rax, [rax]
add ecx, [rax+338h]
mov rax, [rdi+230h]
mov rsi, rdx
mov edx, ecx
mov rcx, rax
call tree_insert
xor ecx, ecx
test rax, rax
setz cl
shl ecx, 7
mov eax, ecx
pop rbp
retn
loc_8914E:
mov rdi, rax
jmp _mi_ck_write_btree
| long long mi_ck_write(_QWORD *a1, unsigned int a2, long long a3, int a4)
{
long long v5; // rdi
long long v6; // r8
v5 = a1[16];
if ( v5 && (v6 = 664LL * a2, *(_QWORD *)(v5 + v6)) )
return (unsigned __int8)(tree_insert(
v6 + v5,
a3,
(unsigned int)(*(_DWORD *)(*a1 + 824LL) + a4),
*(_QWORD *)(v6 + v5 + 560)) == 0) << 7;
else
return mi_ck_write_btree(a1);
}
| _mi_ck_write:
MOV RAX,RDI
MOV RDI,qword ptr [RDI + 0x80]
TEST RDI,RDI
JZ 0x0018914e
MOV R8D,ESI
IMUL R8,R8,0x298
CMP qword ptr [RDI + R8*0x1],0x0
JZ 0x0018914e
PUSH RBP
MOV RBP,RSP
ADD RDI,R8
MOV RAX,qword ptr [RAX]
ADD ECX,dword ptr [RAX + 0x338]
MOV RAX,qword ptr [RDI + 0x230]
MOV RSI,RDX
MOV EDX,ECX
MOV RCX,RAX
CALL 0x001a572e
XOR ECX,ECX
TEST RAX,RAX
SETZ CL
SHL ECX,0x7
MOV EAX,ECX
POP RBP
RET
LAB_0018914e:
MOV RDI,RAX
JMP 0x0018919b
|
long _mi_ck_write(long *param_1,ulong param_2,int8 param_3,int param_4)
{
long lVar1;
long lVar2;
lVar1 = param_1[0x10];
if ((lVar1 != 0) && (lVar2 = (param_2 & 0xffffffff) * 0x298, *(long *)(lVar1 + lVar2) != 0)) {
lVar1 = lVar1 + lVar2;
lVar1 = tree_insert(lVar1,param_3,param_4 + *(int *)(*param_1 + 0x338),
*(int8 *)(lVar1 + 0x230));
return (ulong)(lVar1 == 0) << 7;
}
lVar1 = _mi_ck_write_btree(param_1);
return lVar1;
}
| |
41,652 | LefDefParser::lefiNonDefault::propValue(int) const | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiNonDefault.cpp | const char *
lefiNonDefault::propValue(int index) const
{
char msg[160];
if (index < 0 || index >= numProps_) {
sprintf(msg, "ERROR (LEFPARS-1408): The index number %d given for the NONDEFAULT PROPERTY is invalid.\nValid index is from 0 to %d", index, numProps_);
lefiError(0, 1408, msg);
return 0;
}
return values_[index];
} | O0 | cpp | LefDefParser::lefiNonDefault::propValue(int) const:
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movl %esi, 0xb4(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0xb4(%rsp)
jl 0x2e8c1
movq 0x8(%rsp), %rcx
movl 0xb4(%rsp), %eax
cmpl 0xf0(%rcx), %eax
jl 0x2e905
movq 0x8(%rsp), %rax
leaq 0x10(%rsp), %rdi
movl 0xb4(%rsp), %edx
movl 0xf0(%rax), %ecx
leaq 0x4b327(%rip), %rsi # 0x79c06
movb $0x0, %al
callq 0x2050
leaq 0x10(%rsp), %rdx
xorl %edi, %edi
movl $0x580, %esi # imm = 0x580
callq 0x3f4e0
movq $0x0, 0xc0(%rsp)
jmp 0x2e925
movq 0x8(%rsp), %rax
movq 0x100(%rax), %rax
movslq 0xb4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0xc0(%rsp)
movq 0xc0(%rsp), %rax
addq $0xc8, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZNK12LefDefParser14lefiNonDefault9propValueEi:
sub rsp, 0C8h
mov [rsp+0C8h+var_10], rdi
mov [rsp+0C8h+var_14], esi
mov rax, [rsp+0C8h+var_10]
mov [rsp+0C8h+var_C0], rax
cmp [rsp+0C8h+var_14], 0
jl short loc_2E8C1
mov rcx, [rsp+0C8h+var_C0]
mov eax, [rsp+0C8h+var_14]
cmp eax, [rcx+0F0h]
jl short loc_2E905
loc_2E8C1:
mov rax, [rsp+0C8h+var_C0]
lea rdi, [rsp+0C8h+var_B8]
mov edx, [rsp+0C8h+var_14]
mov ecx, [rax+0F0h]
lea rsi, aErrorLefpars14_9; "ERROR (LEFPARS-1408): The index number "...
mov al, 0
call _sprintf
lea rdx, [rsp+0C8h+var_B8]; int
xor edi, edi; this
mov esi, 580h; int
call _ZN12LefDefParser9lefiErrorEiiPKc; LefDefParser::lefiError(int,int,char const*)
mov [rsp+0C8h+var_8], 0
jmp short loc_2E925
loc_2E905:
mov rax, [rsp+0C8h+var_C0]
mov rax, [rax+100h]
movsxd rcx, [rsp+0C8h+var_14]
mov rax, [rax+rcx*8]
mov [rsp+0C8h+var_8], rax
loc_2E925:
mov rax, [rsp+0C8h+var_8]
add rsp, 0C8h
retn
| long long LefDefParser::lefiNonDefault::propValue(LefDefParser::lefiNonDefault *this, int a2)
{
const char *v2; // rcx
int v4[41]; // [rsp+10h] [rbp-B8h] BYREF
int v5; // [rsp+B4h] [rbp-14h]
LefDefParser::lefiNonDefault *v6; // [rsp+B8h] [rbp-10h]
v6 = this;
v5 = a2;
if ( a2 >= 0 && v5 < *((_DWORD *)this + 60) )
return *(_QWORD *)(*((_QWORD *)this + 32) + 8LL * v5);
sprintf(
v4,
"ERROR (LEFPARS-1408): The index number %d given for the NONDEFAULT PROPERTY is invalid.\n"
"Valid index is from 0 to %d",
v5,
*((_DWORD *)this + 60));
LefDefParser::lefiError(0LL, 1408, (int)v4, v2);
return 0LL;
}
| propValue:
SUB RSP,0xc8
MOV qword ptr [RSP + 0xb8],RDI
MOV dword ptr [RSP + 0xb4],ESI
MOV RAX,qword ptr [RSP + 0xb8]
MOV qword ptr [RSP + 0x8],RAX
CMP dword ptr [RSP + 0xb4],0x0
JL 0x0012e8c1
MOV RCX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RSP + 0xb4]
CMP EAX,dword ptr [RCX + 0xf0]
JL 0x0012e905
LAB_0012e8c1:
MOV RAX,qword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x10]
MOV EDX,dword ptr [RSP + 0xb4]
MOV ECX,dword ptr [RAX + 0xf0]
LEA RSI,[0x179c06]
MOV AL,0x0
CALL 0x00102050
LEA RDX,[RSP + 0x10]
XOR EDI,EDI
MOV ESI,0x580
CALL 0x0013f4e0
MOV qword ptr [RSP + 0xc0],0x0
JMP 0x0012e925
LAB_0012e905:
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x100]
MOVSXD RCX,dword ptr [RSP + 0xb4]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RSP + 0xc0],RAX
LAB_0012e925:
MOV RAX,qword ptr [RSP + 0xc0]
ADD RSP,0xc8
RET
|
/* LefDefParser::lefiNonDefault::propValue(int) const */
int8 __thiscall LefDefParser::lefiNonDefault::propValue(lefiNonDefault *this,int param_1)
{
char local_b8 [164];
int local_14;
lefiNonDefault *local_10;
int8 local_8;
if ((param_1 < 0) || (*(int *)(this + 0xf0) <= param_1)) {
local_14 = param_1;
local_10 = this;
sprintf(local_b8,
"ERROR (LEFPARS-1408): The index number %d given for the NONDEFAULT PROPERTY is invalid.\nValid index is from 0 to %d"
,(ulong)(uint)param_1,(ulong)*(uint *)(this + 0xf0));
lefiError(0,0x580,local_b8);
local_8 = 0;
}
else {
local_8 = *(int8 *)(*(long *)(this + 0x100) + (long)param_1 * 8);
}
return local_8;
}
| |
41,653 | uf_varchar1 | eloqsql/storage/myisam/mi_packrec.c | static void uf_varchar1(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
uchar *to, uchar *end __attribute__((unused)))
{
if (get_bit(bit_buff))
to[0]= 0; /* Zero lengths */
else
{
ulong length=get_bits(bit_buff,rec->space_length_bits);
*to= (uchar) length;
decode_bytes(rec,bit_buff,to+1,to+1+length);
}
} | O3 | c | uf_varchar1:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x4(%rsi), %eax
testl %eax, %eax
je 0x84922
movl (%r14), %r13d
decl %eax
movl %eax, 0x4(%r14)
btl %eax, %r13d
jae 0x8493f
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x832a9
movl $0x1f, 0x4(%r14)
movl (%r14), %r13d
movl $0x1f, %eax
testl %r13d, %r13d
js 0x84910
movl 0x1c(%r15), %r12d
movl %eax, %ecx
subl %r12d, %ecx
jae 0x84984
subl %eax, %r12d
movl %eax, %eax
leaq 0x5e3fa(%rip), %rcx # 0xe2d50
andl (%rcx,%rax,4), %r13d
movl %r12d, %ecx
shll %cl, %r13d
movq %r14, %rdi
callq 0x832a9
movl $0x20, %eax
subl %r12d, %eax
movl %eax, 0x4(%r14)
movl (%r14), %eax
negl %r12d
movl %r12d, %ecx
shrl %cl, %eax
addl %eax, %r13d
jmp 0x8499a
movl %ecx, 0x4(%r14)
shrl %cl, %r13d
movl 0x1c(%r15), %eax
leaq 0x5e3ba(%rip), %rcx # 0xe2d50
andl (%rcx,%rax,4), %r13d
movl %r13d, %eax
movb %r13b, (%rbx)
leaq (%rbx,%rax), %rcx
incq %rcx
incq %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x83b9a
| uf_varchar1_0:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov eax, [rsi+4]
test eax, eax
jz short loc_84922
mov r13d, [r14]
dec eax
mov [r14+4], eax
bt r13d, eax
jnb short loc_8493F
loc_84910:
mov byte ptr [rbx], 0
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_84922:
mov rdi, r14
call fill_buffer_0
mov dword ptr [r14+4], 1Fh
mov r13d, [r14]
mov eax, 1Fh
test r13d, r13d
js short loc_84910
loc_8493F:
mov r12d, [r15+1Ch]
mov ecx, eax
sub ecx, r12d
jnb short loc_84984
sub r12d, eax
mov eax, eax
lea rcx, mask_0
and r13d, [rcx+rax*4]
mov ecx, r12d
shl r13d, cl
mov rdi, r14
call fill_buffer_0
mov eax, 20h ; ' '
sub eax, r12d
mov [r14+4], eax
mov eax, [r14]
neg r12d
mov ecx, r12d
shr eax, cl
add r13d, eax
jmp short loc_8499A
loc_84984:
mov [r14+4], ecx
shr r13d, cl
mov eax, [r15+1Ch]
lea rcx, mask_0
and r13d, [rcx+rax*4]
loc_8499A:
mov eax, r13d
mov [rbx], r13b
lea rcx, [rbx+rax]
inc rcx
inc rbx
mov rdi, r15
mov rsi, r14
mov rdx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp decode_bytes_0
| long long uf_varchar1_0(long long a1, unsigned int *a2, _BYTE *a3)
{
unsigned int v4; // eax
unsigned int v5; // r13d
long long result; // rax
unsigned int v7; // r12d
unsigned int v8; // ecx
int v9; // r12d
int v10; // r13d
unsigned int v11; // r13d
v4 = a2[1];
if ( v4 )
{
v5 = *a2;
result = v4 - 1;
a2[1] = result;
if ( _bittest((const int *)&v5, result) )
{
LABEL_3:
*a3 = 0;
return result;
}
}
else
{
fill_buffer_0((long long)a2);
a2[1] = 31;
v5 = *a2;
result = 31LL;
if ( (*a2 & 0x80000000) != 0 )
goto LABEL_3;
}
v7 = *(_DWORD *)(a1 + 28);
v8 = result - v7;
if ( (unsigned int)result >= v7 )
{
a2[1] = v8;
v11 = mask_0[*(unsigned int *)(a1 + 28)] & (v5 >> v8);
}
else
{
v9 = v7 - result;
v10 = (mask_0[(unsigned int)result] & v5) << v9;
fill_buffer_0((long long)a2);
a2[1] = 32 - v9;
v11 = (*a2 >> -(char)v9) + v10;
}
*a3 = v11;
return (long long)decode_bytes_0(a1, (long long)a2, a3 + 1, &a3[v11 + 1]);
}
| uf_varchar1:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV EAX,dword ptr [RSI + 0x4]
TEST EAX,EAX
JZ 0x00184922
MOV R13D,dword ptr [R14]
DEC EAX
MOV dword ptr [R14 + 0x4],EAX
BT R13D,EAX
JNC 0x0018493f
LAB_00184910:
MOV byte ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00184922:
MOV RDI,R14
CALL 0x001832a9
MOV dword ptr [R14 + 0x4],0x1f
MOV R13D,dword ptr [R14]
MOV EAX,0x1f
TEST R13D,R13D
JS 0x00184910
LAB_0018493f:
MOV R12D,dword ptr [R15 + 0x1c]
MOV ECX,EAX
SUB ECX,R12D
JNC 0x00184984
SUB R12D,EAX
MOV EAX,EAX
LEA RCX,[0x1e2d50]
AND R13D,dword ptr [RCX + RAX*0x4]
MOV ECX,R12D
SHL R13D,CL
MOV RDI,R14
CALL 0x001832a9
MOV EAX,0x20
SUB EAX,R12D
MOV dword ptr [R14 + 0x4],EAX
MOV EAX,dword ptr [R14]
NEG R12D
MOV ECX,R12D
SHR EAX,CL
ADD R13D,EAX
JMP 0x0018499a
LAB_00184984:
MOV dword ptr [R14 + 0x4],ECX
SHR R13D,CL
MOV EAX,dword ptr [R15 + 0x1c]
LEA RCX,[0x1e2d50]
AND R13D,dword ptr [RCX + RAX*0x4]
LAB_0018499a:
MOV EAX,R13D
MOV byte ptr [RBX],R13B
LEA RCX,[RBX + RAX*0x1]
INC RCX
INC RBX
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00183b9a
|
void uf_varchar1(long param_1,uint *param_2,int1 *param_3)
{
uint uVar1;
uint uVar2;
uint uVar3;
byte bVar4;
uint uVar5;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar5 = *param_2;
uVar3 = 0x1f;
if (-1 < (int)uVar5) goto LAB_0018493f;
}
else {
uVar5 = *param_2;
uVar3 = param_2[1] - 1;
param_2[1] = uVar3;
if ((uVar5 >> (uVar3 & 0x1f) & 1) == 0) {
LAB_0018493f:
uVar1 = *(uint *)(param_1 + 0x1c);
if (uVar3 < uVar1) {
uVar2 = (&mask)[uVar3];
bVar4 = (byte)(uVar1 - uVar3);
fill_buffer(param_2);
param_2[1] = 0x20 - (uVar1 - uVar3);
uVar5 = ((uVar5 & uVar2) << (bVar4 & 0x1f)) + (*param_2 >> (-bVar4 & 0x1f));
}
else {
param_2[1] = uVar3 - uVar1;
uVar5 = uVar5 >> ((byte)(uVar3 - uVar1) & 0x1f) & (&mask)[*(uint *)(param_1 + 0x1c)];
}
*param_3 = (char)uVar5;
decode_bytes(param_1,param_2,param_3 + 1,param_3 + (ulong)uVar5 + 1);
return;
}
}
*param_3 = 0;
return;
}
| |
41,654 | js_parse_cond_expr | bluesky950520[P]quickjs/quickjs.c | static __exception int js_parse_cond_expr(JSParseState *s, int parse_flags)
{
int label1, label2;
if (js_parse_coalesce_expr(s, parse_flags))
return -1;
if (s->token.val == '?') {
if (next_token(s))
return -1;
label1 = emit_goto(s, OP_if_false, -1);
if (js_parse_assign_expr(s))
return -1;
if (js_parse_expect(s, ':'))
return -1;
label2 = emit_goto(s, OP_goto, -1);
emit_label(s, label1);
if (js_parse_assign_expr2(s, parse_flags & PF_IN_ACCEPTED))
return -1;
emit_label(s, label2);
}
return 0;
} | O0 | c | js_parse_cond_expr:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0xaff40
cmpl $0x0, %eax
je 0xafe5d
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0xaff33
movq 0x18(%rsp), %rax
cmpl $0x3f, 0x20(%rax)
jne 0xaff2b
movq 0x18(%rsp), %rdi
callq 0x9cfc0
cmpl $0x0, %eax
je 0xafe88
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0xaff33
movq 0x18(%rsp), %rdi
movl $0x69, %esi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0xa6dd0
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xa6e60
cmpl $0x0, %eax
je 0xafeb9
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0xaff33
movq 0x18(%rsp), %rdi
movl $0x3a, %esi
callq 0xa5570
cmpl $0x0, %eax
je 0xafed7
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0xaff33
movq 0x18(%rsp), %rdi
movl $0x6b, %esi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0xa6dd0
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0xa6fd0
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
andl $0x1, %esi
callq 0xaeda0
cmpl $0x0, %eax
je 0xaff1d
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0xaff33
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0xa6fd0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
| js_parse_cond_expr:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_14], esi
mov rdi, [rsp+28h+var_10]
mov esi, [rsp+28h+var_14]
call js_parse_coalesce_expr
cmp eax, 0
jz short loc_AFE5D
mov [rsp+28h+var_4], 0FFFFFFFFh
jmp loc_AFF33
loc_AFE5D:
mov rax, [rsp+28h+var_10]
cmp dword ptr [rax+20h], 3Fh ; '?'
jnz loc_AFF2B
mov rdi, [rsp+28h+var_10]
call next_token
cmp eax, 0
jz short loc_AFE88
mov [rsp+28h+var_4], 0FFFFFFFFh
jmp loc_AFF33
loc_AFE88:
mov rdi, [rsp+28h+var_10]
mov esi, 69h ; 'i'
mov edx, 0FFFFFFFFh
call emit_goto
mov [rsp+28h+var_18], eax
mov rdi, [rsp+28h+var_10]
call js_parse_assign_expr
cmp eax, 0
jz short loc_AFEB9
mov [rsp+28h+var_4], 0FFFFFFFFh
jmp short loc_AFF33
loc_AFEB9:
mov rdi, [rsp+28h+var_10]
mov esi, 3Ah ; ':'
call js_parse_expect
cmp eax, 0
jz short loc_AFED7
mov [rsp+28h+var_4], 0FFFFFFFFh
jmp short loc_AFF33
loc_AFED7:
mov rdi, [rsp+28h+var_10]
mov esi, 6Bh ; 'k'
mov edx, 0FFFFFFFFh
call emit_goto
mov [rsp+28h+var_1C], eax
mov rdi, [rsp+28h+var_10]
mov esi, [rsp+28h+var_18]
call emit_label
mov rdi, [rsp+28h+var_10]
mov esi, [rsp+28h+var_14]
and esi, 1
call js_parse_assign_expr2
cmp eax, 0
jz short loc_AFF1D
mov [rsp+28h+var_4], 0FFFFFFFFh
jmp short loc_AFF33
loc_AFF1D:
mov rdi, [rsp+28h+var_10]
mov esi, [rsp+28h+var_1C]
call emit_label
loc_AFF2B:
mov [rsp+28h+var_4], 0
loc_AFF33:
mov eax, [rsp+28h+var_4]
add rsp, 28h
retn
| long long js_parse_cond_expr(
long long a1,
unsigned int a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
double v10; // xmm4_8
double v11; // xmm5_8
long long v12; // rdx
long long v13; // rcx
long long v14; // r8
long long v15; // r9
__m128 v16; // xmm4
__m128 v17; // xmm5
long long v18; // rdx
long long v19; // rcx
long long v20; // r8
long long v21; // r9
__m128 v22; // xmm4
__m128 v23; // xmm5
int v25; // [rsp+Ch] [rbp-1Ch]
int v26; // [rsp+10h] [rbp-18h]
if ( !(unsigned int)js_parse_coalesce_expr(a1, a2) )
{
if ( *(_DWORD *)(a1 + 32) == 63 )
{
if ( (unsigned int)next_token((long long *)a1, a3, a4, a5, a6, v10, v11, a9, a10) )
return (unsigned int)-1;
v26 = emit_goto(a1, 105, -1);
if ( (unsigned int)js_parse_assign_expr(a1) )
return (unsigned int)-1;
if ( (unsigned int)js_parse_expect(a1, 58, v12, a3, a4, a5, a6, v16, v17, a9, a10, v13, v14, v15) )
return (unsigned int)-1;
v25 = emit_goto(a1, 107, -1);
emit_label(a1, v26);
if ( (unsigned int)js_parse_assign_expr2(a1, a2 & 1, v18, v19, v20, v21, a3, a4, a5, a6, v22, v23, a9, a10) )
return (unsigned int)-1;
emit_label(a1, v25);
}
return 0;
}
return (unsigned int)-1;
}
| js_parse_cond_expr:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV dword ptr [RSP + 0x14],ESI
MOV RDI,qword ptr [RSP + 0x18]
MOV ESI,dword ptr [RSP + 0x14]
CALL 0x001aff40
CMP EAX,0x0
JZ 0x001afe5d
MOV dword ptr [RSP + 0x24],0xffffffff
JMP 0x001aff33
LAB_001afe5d:
MOV RAX,qword ptr [RSP + 0x18]
CMP dword ptr [RAX + 0x20],0x3f
JNZ 0x001aff2b
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x0019cfc0
CMP EAX,0x0
JZ 0x001afe88
MOV dword ptr [RSP + 0x24],0xffffffff
JMP 0x001aff33
LAB_001afe88:
MOV RDI,qword ptr [RSP + 0x18]
MOV ESI,0x69
MOV EDX,0xffffffff
CALL 0x001a6dd0
MOV dword ptr [RSP + 0x10],EAX
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001a6e60
CMP EAX,0x0
JZ 0x001afeb9
MOV dword ptr [RSP + 0x24],0xffffffff
JMP 0x001aff33
LAB_001afeb9:
MOV RDI,qword ptr [RSP + 0x18]
MOV ESI,0x3a
CALL 0x001a5570
CMP EAX,0x0
JZ 0x001afed7
MOV dword ptr [RSP + 0x24],0xffffffff
JMP 0x001aff33
LAB_001afed7:
MOV RDI,qword ptr [RSP + 0x18]
MOV ESI,0x6b
MOV EDX,0xffffffff
CALL 0x001a6dd0
MOV dword ptr [RSP + 0xc],EAX
MOV RDI,qword ptr [RSP + 0x18]
MOV ESI,dword ptr [RSP + 0x10]
CALL 0x001a6fd0
MOV RDI,qword ptr [RSP + 0x18]
MOV ESI,dword ptr [RSP + 0x14]
AND ESI,0x1
CALL 0x001aeda0
CMP EAX,0x0
JZ 0x001aff1d
MOV dword ptr [RSP + 0x24],0xffffffff
JMP 0x001aff33
LAB_001aff1d:
MOV RDI,qword ptr [RSP + 0x18]
MOV ESI,dword ptr [RSP + 0xc]
CALL 0x001a6fd0
LAB_001aff2b:
MOV dword ptr [RSP + 0x24],0x0
LAB_001aff33:
MOV EAX,dword ptr [RSP + 0x24]
ADD RSP,0x28
RET
|
int4 js_parse_cond_expr(long param_1,uint param_2)
{
int iVar1;
int4 uVar2;
int4 uVar3;
iVar1 = js_parse_coalesce_expr(param_1,param_2);
if (iVar1 != 0) {
return 0xffffffff;
}
if (*(int *)(param_1 + 0x20) == 0x3f) {
iVar1 = next_token(param_1);
if (iVar1 != 0) {
return 0xffffffff;
}
uVar2 = emit_goto(param_1,0x69,0xffffffff);
iVar1 = js_parse_assign_expr(param_1);
if (iVar1 != 0) {
return 0xffffffff;
}
iVar1 = js_parse_expect(param_1,0x3a);
if (iVar1 != 0) {
return 0xffffffff;
}
uVar3 = emit_goto(param_1,0x6b,0xffffffff);
emit_label(param_1,uVar2);
iVar1 = js_parse_assign_expr2(param_1,param_2 & 1);
if (iVar1 != 0) {
return 0xffffffff;
}
emit_label(param_1,uVar3);
}
return 0;
}
| |
41,655 | PFS_buffer_default_array<PFS_program>::allocate(pfs_dirty_state*) | eloqsql/storage/perfschema/pfs_buffer_container.h | value_type *allocate(pfs_dirty_state *dirty_state)
{
uint index;
uint monotonic;
uint monotonic_max;
value_type *pfs;
if (m_full)
return NULL;
monotonic= PFS_atomic::add_u32(& m_monotonic.m_u32, 1);
monotonic_max= monotonic + static_cast<uint>(m_max);
while (monotonic < monotonic_max)
{
index= monotonic % m_max;
pfs= m_ptr + index;
if (pfs->m_lock.free_to_dirty(dirty_state))
{
return pfs;
}
monotonic= PFS_atomic::add_u32(& m_monotonic.m_u32, 1);
}
m_full= true;
return NULL;
} | O0 | c | PFS_buffer_default_array<PFS_program>::allocate(pfs_dirty_state*):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, (%rax)
je 0x4c33a
movq $0x0, -0x8(%rbp)
jmp 0x4c3dc
movq -0x38(%rbp), %rdi
addq $0x4, %rdi
movl $0x1, %esi
callq 0x2d580
movq -0x38(%rbp), %rcx
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq 0x50(%rcx), %rcx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x4c3cd
movq -0x38(%rbp), %rcx
movl -0x20(%rbp), %eax
xorl %edx, %edx
divq 0x50(%rcx)
movq -0x38(%rbp), %rax
movl %edx, %ecx
movl %ecx, -0x1c(%rbp)
movq 0x48(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x9c0, %rcx, %rcx # imm = 0x9C0
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x7e0, %rdi # imm = 0x7E0
movq -0x18(%rbp), %rsi
callq 0x2d670
testb $0x1, %al
jne 0x4c3ac
jmp 0x4c3b6
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4c3dc
movq -0x38(%rbp), %rdi
addq $0x4, %rdi
movl $0x1, %esi
callq 0x2d580
movl %eax, -0x20(%rbp)
jmp 0x4c35f
movq -0x38(%rbp), %rax
movb $0x1, (%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN24PFS_buffer_default_arrayI8PFS_userE8allocateEP15pfs_dirty_state:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
test byte ptr [rax], 1
jz short loc_4C33A
mov [rbp+var_8], 0
jmp loc_4C3DC
loc_4C33A:
mov rdi, [rbp+var_38]
add rdi, 4; this
mov esi, (offset dword_0+1); unsigned int *
call _ZN10PFS_atomic7add_u32EPjj; PFS_atomic::add_u32(uint *,uint)
mov rcx, [rbp+var_38]
mov [rbp+var_20], eax
mov eax, [rbp+var_20]
mov rcx, [rcx+50h]
add eax, ecx
mov [rbp+var_24], eax
loc_4C35F:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_24]
jnb short loc_4C3CD
mov rcx, [rbp+var_38]
mov eax, [rbp+var_20]
xor edx, edx
div qword ptr [rcx+50h]
mov rax, [rbp+var_38]
mov ecx, edx
mov [rbp+var_1C], ecx
mov rax, [rax+48h]
mov ecx, [rbp+var_1C]
imul rcx, 9C0h
add rax, rcx
mov [rbp+var_30], rax
mov rdi, [rbp+var_30]
add rdi, 7E0h
mov rsi, [rbp+var_18]
call _ZN8pfs_lock13free_to_dirtyEP15pfs_dirty_state; pfs_lock::free_to_dirty(pfs_dirty_state *)
test al, 1
jnz short loc_4C3AC
jmp short loc_4C3B6
loc_4C3AC:
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
jmp short loc_4C3DC
loc_4C3B6:
mov rdi, [rbp+var_38]
add rdi, 4; this
mov esi, (offset dword_0+1); unsigned int *
call _ZN10PFS_atomic7add_u32EPjj; PFS_atomic::add_u32(uint *,uint)
mov [rbp+var_20], eax
jmp short loc_4C35F
loc_4C3CD:
mov rax, [rbp+var_38]
mov byte ptr [rax], 1
mov [rbp+var_8], 0
loc_4C3DC:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| unsigned long long PFS_buffer_default_array<PFS_user>::allocate(long long a1, unsigned int *a2)
{
unsigned long long v3; // [rsp+10h] [rbp-30h]
unsigned int v4; // [rsp+1Ch] [rbp-24h]
unsigned int v5; // [rsp+20h] [rbp-20h]
if ( (*(_BYTE *)a1 & 1) != 0 )
return 0LL;
v5 = PFS_atomic::add_u32((PFS_atomic *)(a1 + 4), (unsigned int *)((char *)&dword_0 + 1));
v4 = *(_QWORD *)(a1 + 80) + v5;
while ( v5 < v4 )
{
v3 = 2496 * ((unsigned long long)v5 % *(_QWORD *)(a1 + 80)) + *(_QWORD *)(a1 + 72);
if ( (pfs_lock::free_to_dirty((PFS_atomic *)(v3 + 2016), a2) & 1) != 0 )
return v3;
v5 = PFS_atomic::add_u32((PFS_atomic *)(a1 + 4), (unsigned int *)((char *)&dword_0 + 1));
}
*(_BYTE *)a1 = 1;
return 0LL;
}
| allocate:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
TEST byte ptr [RAX],0x1
JZ 0x0014c33a
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0014c3dc
LAB_0014c33a:
MOV RDI,qword ptr [RBP + -0x38]
ADD RDI,0x4
MOV ESI,0x1
CALL 0x0012d580
MOV RCX,qword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x20]
MOV RCX,qword ptr [RCX + 0x50]
ADD EAX,ECX
MOV dword ptr [RBP + -0x24],EAX
LAB_0014c35f:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x24]
JNC 0x0014c3cd
MOV RCX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x20]
XOR EDX,EDX
DIV qword ptr [RCX + 0x50]
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,EDX
MOV dword ptr [RBP + -0x1c],ECX
MOV RAX,qword ptr [RAX + 0x48]
MOV ECX,dword ptr [RBP + -0x1c]
IMUL RCX,RCX,0x9c0
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x7e0
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0012d670
TEST AL,0x1
JNZ 0x0014c3ac
JMP 0x0014c3b6
LAB_0014c3ac:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0014c3dc
LAB_0014c3b6:
MOV RDI,qword ptr [RBP + -0x38]
ADD RDI,0x4
MOV ESI,0x1
CALL 0x0012d580
MOV dword ptr [RBP + -0x20],EAX
JMP 0x0014c35f
LAB_0014c3cd:
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],0x1
MOV qword ptr [RBP + -0x8],0x0
LAB_0014c3dc:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
/* PFS_buffer_default_array<PFS_user>::allocate(pfs_dirty_state*) */
long __thiscall
PFS_buffer_default_array<PFS_user>::allocate
(PFS_buffer_default_array<PFS_user> *this,pfs_dirty_state *param_1)
{
uint uVar1;
long lVar2;
ulong uVar3;
uint local_28;
if (((byte)*this & 1) == 0) {
local_28 = PFS_atomic::add_u32((uint *)(this + 4),1);
uVar1 = local_28 + (int)*(int8 *)(this + 0x50);
while (local_28 < uVar1) {
lVar2 = *(long *)(this + 0x48) +
((ulong)local_28 % *(ulong *)(this + 0x50) & 0xffffffff) * 0x9c0;
uVar3 = pfs_lock::free_to_dirty((pfs_lock *)(lVar2 + 0x7e0),param_1);
if ((uVar3 & 1) != 0) {
return lVar2;
}
local_28 = PFS_atomic::add_u32((uint *)(this + 4),1);
}
*this = (PFS_buffer_default_array<PFS_user>)0x1;
}
return 0;
}
| |
41,656 | PFS_buffer_default_array<PFS_program>::allocate(pfs_dirty_state*) | eloqsql/storage/perfschema/pfs_buffer_container.h | value_type *allocate(pfs_dirty_state *dirty_state)
{
uint index;
uint monotonic;
uint monotonic_max;
value_type *pfs;
if (m_full)
return NULL;
monotonic= PFS_atomic::add_u32(& m_monotonic.m_u32, 1);
monotonic_max= monotonic + static_cast<uint>(m_max);
while (monotonic < monotonic_max)
{
index= monotonic % m_max;
pfs= m_ptr + index;
if (pfs->m_lock.free_to_dirty(dirty_state))
{
return pfs;
}
monotonic= PFS_atomic::add_u32(& m_monotonic.m_u32, 1);
}
m_full= true;
return NULL;
} | O3 | c | PFS_buffer_default_array<PFS_program>::allocate(pfs_dirty_state*):
cmpb $0x0, (%rdi)
je 0x3f76f
xorl %ecx, %ecx
jmp 0x3f7c3
pushq %rbp
movq %rsp, %rbp
movl $0x1, %eax
lock
xaddl %eax, 0x4(%rdi)
movl 0x50(%rdi), %r8d
addl %eax, %r8d
cmpl %r8d, %eax
jae 0x3f7bd
movl %eax, %eax
xorl %edx, %edx
divq 0x50(%rdi)
movq 0x48(%rdi), %rcx
imulq $0x1c0, %rdx, %rdx # imm = 0x1C0
movl (%rcx,%rdx), %eax
testb $0x3, %al
jne 0x3f7b1
addq %rdx, %rcx
movl %eax, %edx
orl $0x1, %edx
lock
cmpxchgl %edx, (%rcx)
je 0x3f7c7
movl $0x1, %eax
lock
xaddl %eax, 0x4(%rdi)
jmp 0x3f784
movb $0x1, (%rdi)
xorl %ecx, %ecx
popq %rbp
movq %rcx, %rax
retq
movl %edx, (%rsi)
jmp 0x3f7c2
nop
| _ZN24PFS_buffer_default_arrayI16PFS_setup_objectE8allocateEP15pfs_dirty_state:
cmp byte ptr [rdi], 0
jz short loc_3F76F
xor ecx, ecx
jmp short loc_3F7C3
loc_3F76F:
push rbp
mov rbp, rsp
mov eax, 1
lock xadd [rdi+4], eax
mov r8d, [rdi+50h]
add r8d, eax
loc_3F784:
cmp eax, r8d
jnb short loc_3F7BD
mov eax, eax
xor edx, edx
div qword ptr [rdi+50h]
mov rcx, [rdi+48h]
imul rdx, 1C0h
mov eax, [rcx+rdx]
test al, 3
jnz short loc_3F7B1
add rcx, rdx
mov edx, eax
or edx, 1
lock cmpxchg [rcx], edx
jz short loc_3F7C7
loc_3F7B1:
mov eax, 1
lock xadd [rdi+4], eax
jmp short loc_3F784
loc_3F7BD:
mov byte ptr [rdi], 1
xor ecx, ecx
loc_3F7C2:
pop rbp
loc_3F7C3:
mov rax, rcx
retn
loc_3F7C7:
mov [rsi], edx
jmp short loc_3F7C2
| volatile signed __int32 * PFS_buffer_default_array<PFS_setup_object>::allocate(
long long a1,
signed __int32 *a2)
{
volatile signed __int32 *v2; // rcx
unsigned __int32 v3; // eax
unsigned __int32 v4; // r8d
long long v5; // rcx
unsigned long long v6; // rdx
signed __int32 v7; // eax
if ( *(_BYTE *)a1 )
return 0LL;
v3 = _InterlockedExchangeAdd((volatile signed __int32 *)(a1 + 4), 1u);
v4 = v3 + *(_DWORD *)(a1 + 80);
while ( 1 )
{
if ( v3 >= v4 )
{
*(_BYTE *)a1 = 1;
return 0LL;
}
v5 = *(_QWORD *)(a1 + 72);
v6 = 448 * ((unsigned long long)v3 % *(_QWORD *)(a1 + 80));
v7 = *(_DWORD *)(v5 + v6);
if ( (v7 & 3) == 0 )
{
v2 = (volatile signed __int32 *)(v6 + v5);
if ( v7 == _InterlockedCompareExchange(v2, v7 | 1, v7) )
break;
}
v3 = _InterlockedExchangeAdd((volatile signed __int32 *)(a1 + 4), 1u);
}
*a2 = v7 | 1;
return v2;
}
| allocate:
CMP byte ptr [RDI],0x0
JZ 0x0013f76f
XOR ECX,ECX
JMP 0x0013f7c3
LAB_0013f76f:
PUSH RBP
MOV RBP,RSP
MOV EAX,0x1
XADD.LOCK dword ptr [RDI + 0x4],EAX
MOV R8D,dword ptr [RDI + 0x50]
ADD R8D,EAX
LAB_0013f784:
CMP EAX,R8D
JNC 0x0013f7bd
MOV EAX,EAX
XOR EDX,EDX
DIV qword ptr [RDI + 0x50]
MOV RCX,qword ptr [RDI + 0x48]
IMUL RDX,RDX,0x1c0
MOV EAX,dword ptr [RCX + RDX*0x1]
TEST AL,0x3
JNZ 0x0013f7b1
ADD RCX,RDX
MOV EDX,EAX
OR EDX,0x1
CMPXCHG.LOCK dword ptr [RCX],EDX
JZ 0x0013f7c7
LAB_0013f7b1:
MOV EAX,0x1
XADD.LOCK dword ptr [RDI + 0x4],EAX
JMP 0x0013f784
LAB_0013f7bd:
MOV byte ptr [RDI],0x1
XOR ECX,ECX
LAB_0013f7c2:
POP RBP
LAB_0013f7c3:
MOV RAX,RCX
RET
LAB_0013f7c7:
MOV dword ptr [RSI],EDX
JMP 0x0013f7c2
|
/* PFS_buffer_default_array<PFS_setup_object>::allocate(pfs_dirty_state*) */
uint * __thiscall
PFS_buffer_default_array<PFS_setup_object>::allocate
(PFS_buffer_default_array<PFS_setup_object> *this,pfs_dirty_state *param_1)
{
PFS_buffer_default_array<PFS_setup_object> *pPVar1;
uint uVar2;
uint uVar3;
uint *puVar4;
long lVar5;
uint uVar6;
if (*this == (PFS_buffer_default_array<PFS_setup_object>)0x0) {
LOCK();
pPVar1 = this + 4;
uVar3 = *(uint *)pPVar1;
*(uint *)pPVar1 = *(uint *)pPVar1 + 1;
UNLOCK();
uVar6 = *(int *)(this + 0x50) + uVar3;
while (uVar3 < uVar6) {
lVar5 = ((ulong)uVar3 % *(ulong *)(this + 0x50)) * 0x1c0;
uVar3 = *(uint *)(*(long *)(this + 0x48) + lVar5);
if ((uVar3 & 3) == 0) {
puVar4 = (uint *)(*(long *)(this + 0x48) + lVar5);
LOCK();
uVar2 = *puVar4;
if (uVar3 == uVar2) {
*puVar4 = uVar3 | 1;
}
UNLOCK();
if (uVar3 == uVar2) {
*(uint *)param_1 = uVar3 | 1;
return puVar4;
}
}
LOCK();
pPVar1 = this + 4;
uVar3 = *(uint *)pPVar1;
*(uint *)pPVar1 = *(uint *)pPVar1 + 1;
UNLOCK();
}
*this = (PFS_buffer_default_array<PFS_setup_object>)0x1;
}
return (uint *)0x0;
}
| |
41,657 | stmt_causes_implicit_commit(THD*, unsigned int) | eloqsql/sql/sql_parse.cc | bool stmt_causes_implicit_commit(THD *thd, uint mask)
{
LEX *lex= thd->lex;
bool skip= FALSE;
DBUG_ENTER("stmt_causes_implicit_commit");
if (!(sql_command_flags[lex->sql_command] & mask))
DBUG_RETURN(FALSE);
switch (lex->sql_command) {
case SQLCOM_ALTER_TABLE:
case SQLCOM_ALTER_SEQUENCE:
/* If ALTER TABLE of non-temporary table, do implicit commit */
skip= (lex->tmp_table());
break;
case SQLCOM_DROP_TABLE:
case SQLCOM_DROP_SEQUENCE:
case SQLCOM_CREATE_TABLE:
case SQLCOM_CREATE_SEQUENCE:
/*
If CREATE TABLE of non-temporary table and the table is not part
if a BEGIN GTID ... COMMIT group, do a implicit commit.
This ensures that CREATE ... SELECT will in the same GTID group on the
master and slave.
*/
skip= (lex->tmp_table() ||
(thd->variables.option_bits & OPTION_GTID_BEGIN));
break;
case SQLCOM_SET_OPTION:
skip= lex->autocommit ? FALSE : TRUE;
break;
default:
break;
}
DBUG_RETURN(!skip);
} | O0 | cpp | stmt_causes_implicit_commit(THD*, unsigned int):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %ecx
leaq 0x13e1b51(%rip), %rax # 0x1cd1260
movl (%rax,%rcx,4), %eax
andl -0x14(%rbp), %eax
cmpl $0x0, %eax
jne 0x8ef725
jmp 0x8ef71c
movb $0x0, -0x1(%rbp)
jmp 0x8ef7eb
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
subl $0x1, %eax
je 0x8ef77f
jmp 0x8ef736
movl -0x28(%rbp), %eax
subl $0x3, %eax
je 0x8ef76f
jmp 0x8ef740
movl -0x28(%rbp), %eax
subl $0x9, %eax
je 0x8ef77f
jmp 0x8ef74a
movl -0x28(%rbp), %eax
subl $0x1f, %eax
je 0x8ef7b9
jmp 0x8ef754
movl -0x28(%rbp), %eax
addl $0xffffff6d, %eax # imm = 0xFFFFFF6D
subl $0x2, %eax
jb 0x8ef77f
jmp 0x8ef763
movl -0x28(%rbp), %eax
subl $0x95, %eax
jne 0x8ef7dd
jmp 0x8ef76f
movq -0x20(%rbp), %rdi
callq 0x821fa0
andb $0x1, %al
movb %al, -0x21(%rbp)
jmp 0x8ef7df
movq -0x20(%rbp), %rdi
callq 0x821fa0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x8ef7af
movq -0x10(%rbp), %rax
movq 0x8a8(%rax), %rax
andq $0x2000000, %rax # imm = 0x2000000
cmpq $0x0, %rax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movb %al, -0x21(%rbp)
jmp 0x8ef7df
movq -0x20(%rbp), %rax
movb 0x17c4(%rax), %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x21(%rbp)
jmp 0x8ef7df
jmp 0x8ef7df
jmp 0x8ef7e1
movb -0x21(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _Z27stmt_causes_implicit_commitP3THDj:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov [rbp+var_20], rax
mov [rbp+var_21], 0
mov rax, [rbp+var_20]
mov eax, [rax+8]
mov ecx, eax
lea rax, sql_command_flags
mov eax, [rax+rcx*4]
and eax, [rbp+var_14]
cmp eax, 0
jnz short loc_8EF725
jmp short $+2
loc_8EF71C:
mov [rbp+var_1], 0
jmp loc_8EF7EB
loc_8EF725:
mov rax, [rbp+var_20]
mov eax, [rax+8]
mov [rbp+var_28], eax
sub eax, 1
jz short loc_8EF77F
jmp short $+2
loc_8EF736:
mov eax, [rbp+var_28]
sub eax, 3
jz short loc_8EF76F
jmp short $+2
loc_8EF740:
mov eax, [rbp+var_28]
sub eax, 9
jz short loc_8EF77F
jmp short $+2
loc_8EF74A:
mov eax, [rbp+var_28]
sub eax, 1Fh
jz short loc_8EF7B9
jmp short $+2
loc_8EF754:
mov eax, [rbp+var_28]
add eax, 0FFFFFF6Dh
sub eax, 2
jb short loc_8EF77F
jmp short $+2
loc_8EF763:
mov eax, [rbp+var_28]
sub eax, 95h
jnz short loc_8EF7DD
jmp short $+2
loc_8EF76F:
mov rdi, [rbp+var_20]; this
call _ZNK3LEX9tmp_tableEv; LEX::tmp_table(void)
and al, 1
mov [rbp+var_21], al
jmp short loc_8EF7DF
loc_8EF77F:
mov rdi, [rbp+var_20]; this
call _ZNK3LEX9tmp_tableEv; LEX::tmp_table(void)
mov cl, al
mov al, 1
test cl, 1
mov [rbp+var_29], al
jnz short loc_8EF7AF
mov rax, [rbp+var_10]
mov rax, [rax+8A8h]
and rax, 2000000h
cmp rax, 0
setnz al
mov [rbp+var_29], al
loc_8EF7AF:
mov al, [rbp+var_29]
and al, 1
mov [rbp+var_21], al
jmp short loc_8EF7DF
loc_8EF7B9:
mov rax, [rbp+var_20]
mov dl, [rax+17C4h]
mov eax, 1
xor ecx, ecx
test dl, 1
cmovnz eax, ecx
cmp eax, 0
setnz al
and al, 1
mov [rbp+var_21], al
jmp short loc_8EF7DF
loc_8EF7DD:
jmp short $+2
loc_8EF7DF:
jmp short $+2
loc_8EF7E1:
mov al, [rbp+var_21]
xor al, 0FFh
and al, 1
mov [rbp+var_1], al
loc_8EF7EB:
mov al, [rbp+var_1]
and al, 1
add rsp, 30h
pop rbp
retn
| bool stmt_causes_implicit_commit(THD *a1, int a2)
{
bool v3; // [rsp+7h] [rbp-29h]
int v4; // [rsp+8h] [rbp-28h]
char v5; // [rsp+Fh] [rbp-21h]
LEX *v6; // [rsp+10h] [rbp-20h]
v6 = (LEX *)*((_QWORD *)a1 + 11);
v5 = 0;
if ( (a2 & sql_command_flags[*((unsigned int *)v6 + 2)]) != 0 )
{
v4 = *((_DWORD *)v6 + 2);
if ( v4 != 1 )
{
if ( v4 == 3 )
goto LABEL_9;
if ( v4 != 9 )
{
if ( v4 == 31 )
{
v5 = (*((_BYTE *)v6 + 6084) & 1) == 0;
return (v5 & 1) == 0;
}
if ( (unsigned int)(v4 - 147) >= 2 )
{
if ( v4 != 149 )
return (v5 & 1) == 0;
LABEL_9:
v5 = LEX::tmp_table(v6) & 1;
return (v5 & 1) == 0;
}
}
}
v3 = 1;
if ( (LEX::tmp_table(v6) & 1) == 0 )
v3 = (*((_QWORD *)a1 + 277) & 0x2000000LL) != 0;
v5 = v3;
return (v5 & 1) == 0;
}
return 0;
}
| is_expensive_processor:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
XOR EAX,EAX
AND AL,0x1
POP RBP
RET
|
/* Item::is_expensive_processor(void*) */
int8 Item::is_expensive_processor(void *param_1)
{
return 0;
}
| |
41,658 | google::protobuf::Any::SharedDtor() | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/any.pb.cc | inline void Any::SharedDtor() {
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
_impl_.type_url_.Destroy();
_impl_.value_.Destroy();
_impl_._any_metadata_.~AnyMetadata();
} | O0 | cpp | google::protobuf::Any::SharedDtor():
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
xorl %eax, %eax
testb $0x1, %al
jne 0x49466e
jmp 0x494710
movq 0x18(%rsp), %rdi
callq 0x1d8160
movb $0x0, 0x37(%rsp)
cmpq $0x0, %rax
jne 0x494685
jmp 0x4946d5
leaq 0x163da3(%rip), %rdx # 0x5f842f
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x3, %esi
movl $0xaf, %ecx
callq 0x3ef0b0
movq 0x8(%rsp), %rdi
movb $0x1, 0x37(%rsp)
leaq 0x15a421(%rip), %rsi # 0x5eead7
callq 0x3ee970
movq %rax, 0x10(%rsp)
jmp 0x4946c2
movq 0x10(%rsp), %rsi
leaq 0x23(%rsp), %rdi
callq 0x3eeb20
jmp 0x4946d3
jmp 0x4946d5
testb $0x1, 0x37(%rsp)
jne 0x4946de
jmp 0x4946e8
leaq 0x38(%rsp), %rdi
callq 0x3ef0f0
jmp 0x494663
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x494704
jmp 0x49470e
leaq 0x38(%rsp), %rdi
callq 0x3ef0f0
jmp 0x494735
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
callq 0x3bd860
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
addq $0x8, %rdi
callq 0x3bd860
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x198ce0
nop
| _ZN6google8protobuf3Any10SharedDtorEv:
sub rsp, 78h
mov [rsp+78h+var_8], rdi
mov rax, [rsp+78h+var_8]
mov [rsp+78h+var_60], rax
loc_494663:
xor eax, eax
test al, 1
jnz short loc_49466E
jmp loc_494710
loc_49466E:
mov rdi, [rsp+78h+var_60]; this
call _ZNK6google8protobuf11MessageLite21GetArenaForAllocationEv; google::protobuf::MessageLite::GetArenaForAllocation(void)
mov [rsp+78h+var_41], 0
cmp rax, 0
jnz short loc_494685
jmp short loc_4946D5
loc_494685:
lea rdx, aWorkspaceLlm4b_46; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+78h+var_40]
mov [rsp+78h+var_70], rdi
mov esi, 3
mov ecx, 0AFh
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+78h+var_70]
mov [rsp+78h+var_41], 1
lea rsi, aCheckFailedGet; "CHECK failed: GetArenaForAllocation() ="...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+78h+var_68], rax
jmp short $+2
loc_4946C2:
mov rsi, [rsp+78h+var_68]
lea rdi, [rsp+78h+var_55]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_4946D3:
jmp short $+2
loc_4946D5:
test [rsp+78h+var_41], 1
jnz short loc_4946DE
jmp short loc_4946E8
loc_4946DE:
lea rdi, [rsp+78h+var_40]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_4946E8:
jmp loc_494663
mov rcx, rax
mov eax, edx
mov [rsp+arg_20], rcx
mov [rsp+arg_1C], eax
test [rsp+arg_2F], 1
jnz short loc_494704
jmp short loc_49470E
loc_494704:
lea rdi, [rsp+arg_30]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_49470E:
jmp short loc_494735
loc_494710:
mov rdi, [rsp+78h+var_60]
add rdi, 10h; this
call _ZN6google8protobuf8internal14ArenaStringPtr7DestroyEv; google::protobuf::internal::ArenaStringPtr::Destroy(void)
mov rdi, [rsp+78h+var_60]
add rdi, 10h
add rdi, 8; this
call _ZN6google8protobuf8internal14ArenaStringPtr7DestroyEv; google::protobuf::internal::ArenaStringPtr::Destroy(void)
add rsp, 78h
retn
loc_494735:
mov rdi, [rsp+arg_20]
call __Unwind_Resume
| long long google::protobuf::Any::SharedDtor(google::protobuf::Any *this)
{
google::protobuf::Any *v2; // [rsp+70h] [rbp-8h]
v2 = this;
google::protobuf::internal::ArenaStringPtr::Destroy((google::protobuf::Any *)((char *)this + 16));
return google::protobuf::internal::ArenaStringPtr::Destroy((google::protobuf::Any *)((char *)this + 24));
}
| pause:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x00496be0
ADD RSP,0x18
RET
|
/* tbb::detail::r1::outermost_worker_waiter::pause(tbb::detail::r1::arena_slot&) */
void tbb::detail::r1::outermost_worker_waiter::pause(arena_slot *param_1)
{
r1::waiter_base::pause((waiter_base *)param_1);
return;
}
| |
41,659 | JS_ToPrimitiveFree | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_ToPrimitiveFree(JSContext *ctx, JSValue val, int hint)
{
int i;
BOOL force_ordinary;
JSAtom method_name;
JSValue method, ret;
if (JS_VALUE_GET_TAG(val) != JS_TAG_OBJECT)
return val;
force_ordinary = hint & HINT_FORCE_ORDINARY;
hint &= ~HINT_FORCE_ORDINARY;
if (!force_ordinary) {
method = JS_GetProperty(ctx, val, JS_ATOM_Symbol_toPrimitive);
if (JS_IsException(method))
goto exception;
/* ECMA says *If exoticToPrim is not undefined* but tests in
test262 use null as a non callable converter */
if (!JS_IsUndefined(method) && !JS_IsNull(method)) {
JSAtom atom;
JSValue arg;
switch(hint) {
case HINT_STRING:
atom = JS_ATOM_string;
break;
case HINT_NUMBER:
atom = JS_ATOM_number;
break;
default:
case HINT_NONE:
atom = JS_ATOM_default;
break;
}
arg = JS_AtomToString(ctx, atom);
ret = JS_CallFree(ctx, method, val, 1, &arg);
JS_FreeValue(ctx, arg);
if (JS_IsException(ret))
goto exception;
JS_FreeValue(ctx, val);
if (JS_VALUE_GET_TAG(ret) != JS_TAG_OBJECT)
return ret;
JS_FreeValue(ctx, ret);
return JS_ThrowTypeError(ctx, "toPrimitive");
}
}
if (hint != HINT_STRING)
hint = HINT_NUMBER;
for(i = 0; i < 2; i++) {
if ((i ^ hint) == 0) {
method_name = JS_ATOM_toString;
} else {
method_name = JS_ATOM_valueOf;
}
method = JS_GetProperty(ctx, val, method_name);
if (JS_IsException(method))
goto exception;
if (JS_IsFunction(ctx, method)) {
ret = JS_CallFree(ctx, method, val, 0, NULL);
if (JS_IsException(ret))
goto exception;
if (JS_VALUE_GET_TAG(ret) != JS_TAG_OBJECT) {
JS_FreeValue(ctx, val);
return ret;
}
JS_FreeValue(ctx, ret);
} else {
JS_FreeValue(ctx, method);
}
}
JS_ThrowTypeError(ctx, "toPrimitive");
exception:
JS_FreeValue(ctx, val);
return JS_EXCEPTION;
} | O0 | c | JS_ToPrimitiveFree:
subq $0xe8, %rsp
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rdi, 0xc0(%rsp)
movl %ecx, 0xbc(%rsp)
movq 0xd0(%rsp), %rax
cmpl $-0x1, %eax
je 0x68158
movq 0xc8(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0xe0(%rsp)
jmp 0x68632
movl 0xbc(%rsp), %eax
andl $0x10, %eax
movl %eax, 0xb4(%rsp)
movl 0xbc(%rsp), %eax
andl $-0x11, %eax
movl %eax, 0xbc(%rsp)
cmpl $0x0, 0xb4(%rsp)
jne 0x683d8
movq 0xc0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
movl $0xd3, %ecx
callq 0x30070
movq %rax, 0x80(%rsp)
movq %rdx, 0x88(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0xa0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0x681f9
jmp 0x685fe
movq 0xa0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0x34550
cmpl $0x0, %eax
jne 0x683d6
movq 0xa0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0x34530
cmpl $0x0, %eax
jne 0x683d6
movl 0xbc(%rsp), %eax
movl %eax, 0x14(%rsp)
testl %eax, %eax
je 0x6825c
jmp 0x68246
movl 0x14(%rsp), %eax
subl $0x1, %eax
je 0x68266
jmp 0x68251
movl 0x14(%rsp), %eax
subl $0x2, %eax
je 0x68272
jmp 0x68270
movl $0x49, 0x7c(%rsp)
jmp 0x6827a
movl $0x47, 0x7c(%rsp)
jmp 0x6827a
jmp 0x68272
movl $0x16, 0x7c(%rsp)
movq 0xc0(%rsp), %rdi
movl 0x7c(%rsp), %esi
callq 0x2f2f0
movq %rax, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0xc0(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
movq 0xc8(%rsp), %rcx
movq 0xd0(%rsp), %r8
movl $0x1, %r9d
leaq 0x68(%rsp), %rax
movq %rax, (%rsp)
callq 0x34570
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0xc0(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0x29f80
movq 0x90(%rsp), %rdi
movq 0x98(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0x6833f
jmp 0x685fe
movq 0xc0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
callq 0x29f80
movq 0x98(%rsp), %rax
cmpl $-0x1, %eax
je 0x6838e
movq 0x90(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0xe0(%rsp)
jmp 0x68632
movq 0xc0(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
callq 0x29f80
movq 0xc0(%rsp), %rdi
leaq 0xac05d(%rip), %rsi # 0x114417
movb $0x0, %al
callq 0x335f0
movq %rax, 0xd8(%rsp)
movq %rdx, 0xe0(%rsp)
jmp 0x68632
jmp 0x683d8
cmpl $0x0, 0xbc(%rsp)
je 0x683ed
movl $0x1, 0xbc(%rsp)
movl $0x0, 0xb8(%rsp)
cmpl $0x2, 0xb8(%rsp)
jge 0x685de
movl 0xb8(%rsp), %eax
xorl 0xbc(%rsp), %eax
cmpl $0x0, %eax
jne 0x68426
movl $0x38, 0xb0(%rsp)
jmp 0x68431
movl $0x3a, 0xb0(%rsp)
movq 0xc0(%rsp), %rdi
movl 0xb0(%rsp), %ecx
movq 0xc8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
callq 0x30070
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0xa0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0x68498
jmp 0x685fe
movq 0xc0(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
callq 0x34800
cmpl $0x0, %eax
je 0x685a9
movq 0xc0(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
movq 0xc8(%rsp), %rcx
movq 0xd0(%rsp), %r8
xorl %r9d, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0x34570
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x90(%rsp), %rdi
movq 0x98(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0x6853b
jmp 0x685fe
movq 0x98(%rsp), %rax
cmpl $-0x1, %eax
je 0x6858a
movq 0xc0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
callq 0x29f80
movq 0x90(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0xe0(%rsp)
jmp 0x68632
movq 0xc0(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
callq 0x29f80
jmp 0x685c6
movq 0xc0(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
callq 0x29f80
jmp 0x685c8
movl 0xb8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xb8(%rsp)
jmp 0x683f8
movq 0xc0(%rsp), %rdi
leaq 0xabe2a(%rip), %rsi # 0x114417
movb $0x0, %al
callq 0x335f0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0xc0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
callq 0x29f80
movl $0x0, 0xd8(%rsp)
movq $0x6, 0xe0(%rsp)
movq 0xd8(%rsp), %rax
movq 0xe0(%rsp), %rdx
addq $0xe8, %rsp
retq
nopw (%rax,%rax)
| JS_ToPrimitiveFree:
sub rsp, 0E8h
mov [rsp+0E8h+var_20], rsi
mov [rsp+0E8h+var_18], rdx
mov [rsp+0E8h+var_28], rdi
mov [rsp+0E8h+var_2C], ecx
mov rax, [rsp+0E8h+var_18]
cmp eax, 0FFFFFFFFh
jz short loc_68158
mov rax, [rsp+0E8h+var_20]
mov [rsp+0E8h+var_10], rax
mov rax, [rsp+0E8h+var_18]
mov [rsp+0E8h+var_8], rax
jmp loc_68632
loc_68158:
mov eax, [rsp+0E8h+var_2C]
and eax, 10h
mov [rsp+0E8h+var_34], eax
mov eax, [rsp+0E8h+var_2C]
and eax, 0FFFFFFEFh
mov [rsp+0E8h+var_2C], eax
cmp [rsp+0E8h+var_34], 0
jnz loc_683D8
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_20]
mov rdx, [rsp+0E8h+var_18]
mov ecx, 0D3h
call JS_GetProperty
mov [rsp+0E8h+var_68], rax
mov [rsp+0E8h+var_60], rdx
mov rax, [rsp+0E8h+var_68]
mov [rsp+0E8h+var_48], rax
mov rax, [rsp+0E8h+var_60]
mov [rsp+0E8h+var_40], rax
mov rdi, [rsp+0E8h+var_48]
mov rsi, [rsp+0E8h+var_40]
call JS_IsException_1
cmp eax, 0
jz short loc_681F9
jmp loc_685FE
loc_681F9:
mov rdi, [rsp+0E8h+var_48]
mov rsi, [rsp+0E8h+var_40]
call JS_IsUndefined_1
cmp eax, 0
jnz loc_683D6
mov rdi, [rsp+0E8h+var_48]
mov rsi, [rsp+0E8h+var_40]
call JS_IsNull_1
cmp eax, 0
jnz loc_683D6
mov eax, [rsp+0E8h+var_2C]
mov [rsp+0E8h+var_D4], eax
test eax, eax
jz short loc_6825C
jmp short $+2
loc_68246:
mov eax, [rsp+0E8h+var_D4]
sub eax, 1
jz short loc_68266
jmp short $+2
loc_68251:
mov eax, [rsp+0E8h+var_D4]
sub eax, 2
jz short loc_68272
jmp short loc_68270
loc_6825C:
mov [rsp+0E8h+var_6C], 49h ; 'I'
jmp short loc_6827A
loc_68266:
mov [rsp+0E8h+var_6C], 47h ; 'G'
jmp short loc_6827A
loc_68270:
jmp short $+2
loc_68272:
mov [rsp+0E8h+var_6C], 16h
loc_6827A:
mov rdi, [rsp+0E8h+var_28]
mov esi, [rsp+0E8h+var_6C]
call JS_AtomToString
mov [rsp+0E8h+var_90], rax
mov [rsp+0E8h+var_88], rdx
mov rax, [rsp+0E8h+var_90]
mov [rsp+0E8h+var_80], rax
mov rax, [rsp+0E8h+var_88]
mov [rsp+0E8h+var_78], rax
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_48]
mov rdx, [rsp+0E8h+var_40]
mov rcx, [rsp+0E8h+var_20]
mov r8, [rsp+0E8h+var_18]
mov r9d, 1
lea rax, [rsp+0E8h+var_80]
mov [rsp+0E8h+var_E8], rax
call JS_CallFree
mov [rsp+0E8h+var_A0], rax
mov [rsp+0E8h+var_98], rdx
mov rax, [rsp+0E8h+var_A0]
mov [rsp+0E8h+var_58], rax
mov rax, [rsp+0E8h+var_98]
mov [rsp+0E8h+var_50], rax
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_80]
mov rdx, [rsp+0E8h+var_78]
call JS_FreeValue
mov rdi, [rsp+0E8h+var_58]
mov rsi, [rsp+0E8h+var_50]
call JS_IsException_1
cmp eax, 0
jz short loc_6833F
jmp loc_685FE
loc_6833F:
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_20]
mov rdx, [rsp+0E8h+var_18]
call JS_FreeValue
mov rax, [rsp+0E8h+var_50]
cmp eax, 0FFFFFFFFh
jz short loc_6838E
mov rax, [rsp+0E8h+var_58]
mov [rsp+0E8h+var_10], rax
mov rax, [rsp+0E8h+var_50]
mov [rsp+0E8h+var_8], rax
jmp loc_68632
loc_6838E:
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_58]
mov rdx, [rsp+0E8h+var_50]
call JS_FreeValue
mov rdi, [rsp+0E8h+var_28]
lea rsi, aToprimitive; "toPrimitive"
mov al, 0
call JS_ThrowTypeError
mov [rsp+0E8h+var_10], rax
mov [rsp+0E8h+var_8], rdx
jmp loc_68632
loc_683D6:
jmp short $+2
loc_683D8:
cmp [rsp+0E8h+var_2C], 0
jz short loc_683ED
mov [rsp+0E8h+var_2C], 1
loc_683ED:
mov [rsp+0E8h+var_30], 0
loc_683F8:
cmp [rsp+0E8h+var_30], 2
jge loc_685DE
mov eax, [rsp+0E8h+var_30]
xor eax, [rsp+0E8h+var_2C]
cmp eax, 0
jnz short loc_68426
mov [rsp+0E8h+var_38], 38h ; '8'
jmp short loc_68431
loc_68426:
mov [rsp+0E8h+var_38], 3Ah ; ':'
loc_68431:
mov rdi, [rsp+0E8h+var_28]
mov ecx, [rsp+0E8h+var_38]
mov rsi, [rsp+0E8h+var_20]
mov rdx, [rsp+0E8h+var_18]
call JS_GetProperty
mov [rsp+0E8h+var_B0], rax
mov [rsp+0E8h+var_A8], rdx
mov rax, [rsp+0E8h+var_B0]
mov [rsp+0E8h+var_48], rax
mov rax, [rsp+0E8h+var_A8]
mov [rsp+0E8h+var_40], rax
mov rdi, [rsp+0E8h+var_48]
mov rsi, [rsp+0E8h+var_40]
call JS_IsException_1
cmp eax, 0
jz short loc_68498
jmp loc_685FE
loc_68498:
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_48]
mov rdx, [rsp+0E8h+var_40]
call JS_IsFunction
cmp eax, 0
jz loc_685A9
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_48]
mov rdx, [rsp+0E8h+var_40]
mov rcx, [rsp+0E8h+var_20]
mov r8, [rsp+0E8h+var_18]
xor r9d, r9d
xor eax, eax
mov [rsp+0E8h+var_E8], 0
call JS_CallFree
mov [rsp+0E8h+var_C0], rax
mov [rsp+0E8h+var_B8], rdx
mov rax, [rsp+0E8h+var_C0]
mov [rsp+0E8h+var_58], rax
mov rax, [rsp+0E8h+var_B8]
mov [rsp+0E8h+var_50], rax
mov rdi, [rsp+0E8h+var_58]
mov rsi, [rsp+0E8h+var_50]
call JS_IsException_1
cmp eax, 0
jz short loc_6853B
jmp loc_685FE
loc_6853B:
mov rax, [rsp+0E8h+var_50]
cmp eax, 0FFFFFFFFh
jz short loc_6858A
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_20]
mov rdx, [rsp+0E8h+var_18]
call JS_FreeValue
mov rax, [rsp+0E8h+var_58]
mov [rsp+0E8h+var_10], rax
mov rax, [rsp+0E8h+var_50]
mov [rsp+0E8h+var_8], rax
jmp loc_68632
loc_6858A:
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_58]
mov rdx, [rsp+0E8h+var_50]
call JS_FreeValue
jmp short loc_685C6
loc_685A9:
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_48]
mov rdx, [rsp+0E8h+var_40]
call JS_FreeValue
loc_685C6:
jmp short $+2
loc_685C8:
mov eax, [rsp+0E8h+var_30]
add eax, 1
mov [rsp+0E8h+var_30], eax
jmp loc_683F8
loc_685DE:
mov rdi, [rsp+0E8h+var_28]
lea rsi, aToprimitive; "toPrimitive"
mov al, 0
call JS_ThrowTypeError
mov [rsp+0E8h+var_D0], rax
mov [rsp+0E8h+var_C8], rdx
loc_685FE:
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_20]
mov rdx, [rsp+0E8h+var_18]
call JS_FreeValue
mov dword ptr [rsp+0E8h+var_10], 0
mov [rsp+0E8h+var_8], 6
loc_68632:
mov rax, [rsp+0E8h+var_10]
mov rdx, [rsp+0E8h+var_8]
add rsp, 0E8h
retn
| long long JS_ToPrimitiveFree(
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 v14; // rdx
long long v15; // rdx
long long v16; // rdx
long long v17; // rdx
long long v18; // rcx
long long v19; // r8
long long v20; // r9
__m128 v21; // xmm4
__m128 v22; // xmm5
long long v23; // rdx
long long v24; // rdx
long long v25; // rdx
char v27; // [rsp+0h] [rbp-E8h]
char v28; // [rsp+0h] [rbp-E8h]
long long v29; // [rsp+68h] [rbp-80h] BYREF
long long v30; // [rsp+70h] [rbp-78h]
unsigned int v31; // [rsp+7Ch] [rbp-6Ch]
long long Property; // [rsp+80h] [rbp-68h]
long long v33; // [rsp+88h] [rbp-60h]
long long v34; // [rsp+90h] [rbp-58h]
long long v35; // [rsp+98h] [rbp-50h]
long long v36; // [rsp+A0h] [rbp-48h]
long long v37; // [rsp+A8h] [rbp-40h]
int v38; // [rsp+B0h] [rbp-38h]
int v39; // [rsp+B4h] [rbp-34h]
int i; // [rsp+B8h] [rbp-30h]
int v41; // [rsp+BCh] [rbp-2Ch]
long long v42; // [rsp+C0h] [rbp-28h]
long long v43; // [rsp+C8h] [rbp-20h]
long long v44; // [rsp+D0h] [rbp-18h]
long long v45; // [rsp+D8h] [rbp-10h]
long long v46; // [rsp+E0h] [rbp-8h]
v43 = a2;
v44 = a3;
v42 = a1;
v41 = a4;
if ( (_DWORD)a3 != -1 )
{
v45 = v43;
v46 = v44;
return v45;
}
v39 = v41 & 0x10;
v41 &= ~0x10u;
if ( v39 )
goto LABEL_16;
Property = JS_GetProperty(v42, v43, v44, 211);
v33 = v14;
v36 = Property;
v37 = v14;
if ( JS_IsException_1(Property, v14) )
{
LABEL_30:
JS_FreeValue(v42, v43, v44);
LODWORD(v45) = 0;
v46 = 6LL;
return v45;
}
if ( JS_IsUndefined_1(v36, v37) || JS_IsNull_1(v36, v37) )
{
LABEL_16:
v41 = v41 != 0;
for ( i = 0; i < 2; ++i )
{
if ( v41 != i )
v38 = 58;
else
v38 = 56;
v36 = JS_GetProperty(v42, v43, v44, v38);
v37 = v24;
if ( JS_IsException_1(v36, v24) )
goto LABEL_30;
if ( (unsigned int)JS_IsFunction(v42, v36, v37) )
{
v34 = JS_CallFree(v42, v36, v37, v43, v44, 0, 0LL);
v35 = v25;
if ( JS_IsException_1(v34, v25) )
goto LABEL_30;
if ( (_DWORD)v35 != -1 )
{
JS_FreeValue(v42, v43, v44);
v45 = v34;
v46 = v35;
return v45;
}
JS_FreeValue(v42, v34, v35);
}
else
{
JS_FreeValue(v42, v36, v37);
}
}
JS_ThrowTypeError(v42, (long long)"toPrimitive", a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v27);
goto LABEL_30;
}
if ( v41 )
{
if ( v41 == 1 )
v31 = 71;
else
v31 = 22;
}
else
{
v31 = 73;
}
v29 = JS_AtomToString(v42, v31);
v30 = v15;
v34 = JS_CallFree(v42, v36, v37, v43, v44, 1, (long long)&v29);
v35 = v16;
JS_FreeValue(v42, v29, v30);
if ( JS_IsException_1(v34, v35) )
goto LABEL_30;
JS_FreeValue(v42, v43, v44);
if ( (_DWORD)v35 == -1 )
{
JS_FreeValue(v42, v34, v35);
v45 = JS_ThrowTypeError(v42, (long long)"toPrimitive", v17, v18, v19, v20, a7, a8, a9, a10, v21, v22, a13, a14, v28);
v46 = v23;
}
else
{
v45 = v34;
v46 = v35;
}
return v45;
}
| JS_ToPrimitiveFree:
SUB RSP,0xe8
MOV qword ptr [RSP + 0xc8],RSI
MOV qword ptr [RSP + 0xd0],RDX
MOV qword ptr [RSP + 0xc0],RDI
MOV dword ptr [RSP + 0xbc],ECX
MOV RAX,qword ptr [RSP + 0xd0]
CMP EAX,-0x1
JZ 0x00168158
MOV RAX,qword ptr [RSP + 0xc8]
MOV qword ptr [RSP + 0xd8],RAX
MOV RAX,qword ptr [RSP + 0xd0]
MOV qword ptr [RSP + 0xe0],RAX
JMP 0x00168632
LAB_00168158:
MOV EAX,dword ptr [RSP + 0xbc]
AND EAX,0x10
MOV dword ptr [RSP + 0xb4],EAX
MOV EAX,dword ptr [RSP + 0xbc]
AND EAX,0xffffffef
MOV dword ptr [RSP + 0xbc],EAX
CMP dword ptr [RSP + 0xb4],0x0
JNZ 0x001683d8
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0xc8]
MOV RDX,qword ptr [RSP + 0xd0]
MOV ECX,0xd3
CALL 0x00130070
MOV qword ptr [RSP + 0x80],RAX
MOV qword ptr [RSP + 0x88],RDX
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0xa0],RAX
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0xa8],RAX
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0xa8]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x001681f9
JMP 0x001685fe
LAB_001681f9:
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0xa8]
CALL 0x00134550
CMP EAX,0x0
JNZ 0x001683d6
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0xa8]
CALL 0x00134530
CMP EAX,0x0
JNZ 0x001683d6
MOV EAX,dword ptr [RSP + 0xbc]
MOV dword ptr [RSP + 0x14],EAX
TEST EAX,EAX
JZ 0x0016825c
JMP 0x00168246
LAB_00168246:
MOV EAX,dword ptr [RSP + 0x14]
SUB EAX,0x1
JZ 0x00168266
JMP 0x00168251
LAB_00168251:
MOV EAX,dword ptr [RSP + 0x14]
SUB EAX,0x2
JZ 0x00168272
JMP 0x00168270
LAB_0016825c:
MOV dword ptr [RSP + 0x7c],0x49
JMP 0x0016827a
LAB_00168266:
MOV dword ptr [RSP + 0x7c],0x47
JMP 0x0016827a
LAB_00168270:
JMP 0x00168272
LAB_00168272:
MOV dword ptr [RSP + 0x7c],0x16
LAB_0016827a:
MOV RDI,qword ptr [RSP + 0xc0]
MOV ESI,dword ptr [RSP + 0x7c]
CALL 0x0012f2f0
MOV qword ptr [RSP + 0x58],RAX
MOV qword ptr [RSP + 0x60],RDX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x70],RAX
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0xa0]
MOV RDX,qword ptr [RSP + 0xa8]
MOV RCX,qword ptr [RSP + 0xc8]
MOV R8,qword ptr [RSP + 0xd0]
MOV R9D,0x1
LEA RAX,[RSP + 0x68]
MOV qword ptr [RSP],RAX
CALL 0x00134570
MOV qword ptr [RSP + 0x48],RAX
MOV qword ptr [RSP + 0x50],RDX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x90],RAX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x98],RAX
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x70]
CALL 0x00129f80
MOV RDI,qword ptr [RSP + 0x90]
MOV RSI,qword ptr [RSP + 0x98]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x0016833f
JMP 0x001685fe
LAB_0016833f:
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0xc8]
MOV RDX,qword ptr [RSP + 0xd0]
CALL 0x00129f80
MOV RAX,qword ptr [RSP + 0x98]
CMP EAX,-0x1
JZ 0x0016838e
MOV RAX,qword ptr [RSP + 0x90]
MOV qword ptr [RSP + 0xd8],RAX
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0xe0],RAX
JMP 0x00168632
LAB_0016838e:
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0x90]
MOV RDX,qword ptr [RSP + 0x98]
CALL 0x00129f80
MOV RDI,qword ptr [RSP + 0xc0]
LEA RSI,[0x214417]
MOV AL,0x0
CALL 0x001335f0
MOV qword ptr [RSP + 0xd8],RAX
MOV qword ptr [RSP + 0xe0],RDX
JMP 0x00168632
LAB_001683d6:
JMP 0x001683d8
LAB_001683d8:
CMP dword ptr [RSP + 0xbc],0x0
JZ 0x001683ed
MOV dword ptr [RSP + 0xbc],0x1
LAB_001683ed:
MOV dword ptr [RSP + 0xb8],0x0
LAB_001683f8:
CMP dword ptr [RSP + 0xb8],0x2
JGE 0x001685de
MOV EAX,dword ptr [RSP + 0xb8]
XOR EAX,dword ptr [RSP + 0xbc]
CMP EAX,0x0
JNZ 0x00168426
MOV dword ptr [RSP + 0xb0],0x38
JMP 0x00168431
LAB_00168426:
MOV dword ptr [RSP + 0xb0],0x3a
LAB_00168431:
MOV RDI,qword ptr [RSP + 0xc0]
MOV ECX,dword ptr [RSP + 0xb0]
MOV RSI,qword ptr [RSP + 0xc8]
MOV RDX,qword ptr [RSP + 0xd0]
CALL 0x00130070
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x40],RDX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0xa0],RAX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0xa8],RAX
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0xa8]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x00168498
JMP 0x001685fe
LAB_00168498:
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0xa0]
MOV RDX,qword ptr [RSP + 0xa8]
CALL 0x00134800
CMP EAX,0x0
JZ 0x001685a9
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0xa0]
MOV RDX,qword ptr [RSP + 0xa8]
MOV RCX,qword ptr [RSP + 0xc8]
MOV R8,qword ptr [RSP + 0xd0]
XOR R9D,R9D
XOR EAX,EAX
MOV qword ptr [RSP],0x0
CALL 0x00134570
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x30],RDX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x90],RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x98],RAX
MOV RDI,qword ptr [RSP + 0x90]
MOV RSI,qword ptr [RSP + 0x98]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x0016853b
JMP 0x001685fe
LAB_0016853b:
MOV RAX,qword ptr [RSP + 0x98]
CMP EAX,-0x1
JZ 0x0016858a
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0xc8]
MOV RDX,qword ptr [RSP + 0xd0]
CALL 0x00129f80
MOV RAX,qword ptr [RSP + 0x90]
MOV qword ptr [RSP + 0xd8],RAX
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0xe0],RAX
JMP 0x00168632
LAB_0016858a:
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0x90]
MOV RDX,qword ptr [RSP + 0x98]
CALL 0x00129f80
JMP 0x001685c6
LAB_001685a9:
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0xa0]
MOV RDX,qword ptr [RSP + 0xa8]
CALL 0x00129f80
LAB_001685c6:
JMP 0x001685c8
LAB_001685c8:
MOV EAX,dword ptr [RSP + 0xb8]
ADD EAX,0x1
MOV dword ptr [RSP + 0xb8],EAX
JMP 0x001683f8
LAB_001685de:
MOV RDI,qword ptr [RSP + 0xc0]
LEA RSI,[0x214417]
MOV AL,0x0
CALL 0x001335f0
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
LAB_001685fe:
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0xc8]
MOV RDX,qword ptr [RSP + 0xd0]
CALL 0x00129f80
MOV dword ptr [RSP + 0xd8],0x0
MOV qword ptr [RSP + 0xe0],0x6
LAB_00168632:
MOV RAX,qword ptr [RSP + 0xd8]
MOV RDX,qword ptr [RSP + 0xe0]
ADD RSP,0xe8
RET
|
int1 [16]
JS_ToPrimitiveFree(int8 param_1,int8 param_2,int8 param_3,uint param_4)
{
int iVar1;
int1 auVar2 [16];
int1 local_80 [16];
int4 local_6c;
int1 local_68 [16];
int1 local_58 [16];
int1 local_48 [16];
int4 local_38;
uint local_34;
uint local_30;
uint local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
if ((int)param_3 != -1) {
local_10 = (int4)param_2;
uStack_c = (int4)((ulong)param_2 >> 0x20);
local_8 = param_3;
goto LAB_00168632;
}
local_34 = param_4 & 0x10;
local_2c = param_4 & 0xffffffef;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
if (local_34 == 0) {
local_68 = JS_GetProperty(param_1,param_2,param_3,0xd3);
local_48 = local_68;
iVar1 = JS_IsException(local_68._0_8_,local_68._8_8_);
if (iVar1 == 0) {
iVar1 = JS_IsUndefined(local_48._0_8_,local_48._8_8_);
if (iVar1 == 0) {
iVar1 = JS_IsNull(local_48._0_8_,local_48._8_8_);
if (iVar1 == 0) {
if (local_2c == 0) {
local_6c = 0x49;
}
else if (local_2c == 1) {
local_6c = 0x47;
}
else {
local_6c = 0x16;
}
local_80 = JS_AtomToString(local_28,local_6c);
local_58 = JS_CallFree(local_28,local_48._0_8_,local_48._8_8_,local_20,local_18,1,local_80
);
JS_FreeValue(local_28,local_80._0_8_,local_80._8_8_);
iVar1 = JS_IsException(local_58._0_8_,local_58._8_8_);
if (iVar1 == 0) {
JS_FreeValue(local_28,local_20,local_18);
if (local_58._8_4_ == -1) {
JS_FreeValue(local_28,local_58._0_8_,local_58._8_8_);
auVar2 = JS_ThrowTypeError(local_28,"toPrimitive");
local_8 = auVar2._8_8_;
local_10 = auVar2._0_4_;
uStack_c = auVar2._4_4_;
}
else {
local_10 = local_58._0_4_;
uStack_c = local_58._4_4_;
local_8 = local_58._8_8_;
}
goto LAB_00168632;
}
goto LAB_001685fe;
}
}
goto LAB_001683d8;
}
}
else {
LAB_001683d8:
if (local_2c != 0) {
local_2c = 1;
}
for (local_30 = 0; (int)local_30 < 2; local_30 = local_30 + 1) {
if (local_30 == local_2c) {
local_38 = 0x38;
}
else {
local_38 = 0x3a;
}
auVar2 = JS_GetProperty(local_28,local_20,local_18,local_38);
local_48 = auVar2;
iVar1 = JS_IsException(auVar2._0_8_,auVar2._8_8_);
if (iVar1 != 0) goto LAB_001685fe;
iVar1 = JS_IsFunction(local_28,local_48._0_8_,local_48._8_8_);
if (iVar1 == 0) {
JS_FreeValue(local_28,local_48._0_8_,local_48._8_8_);
}
else {
auVar2 = JS_CallFree(local_28,local_48._0_8_,local_48._8_8_,local_20,local_18,0,0);
local_58 = auVar2;
iVar1 = JS_IsException(auVar2._0_8_,auVar2._8_8_);
if (iVar1 != 0) goto LAB_001685fe;
if (local_58._8_4_ != -1) {
JS_FreeValue(local_28,local_20,local_18);
local_10 = local_58._0_4_;
uStack_c = local_58._4_4_;
local_8 = local_58._8_8_;
goto LAB_00168632;
}
JS_FreeValue(local_28,local_58._0_8_,local_58._8_8_);
}
}
JS_ThrowTypeError(local_28,"toPrimitive");
}
LAB_001685fe:
JS_FreeValue(local_28,local_20,local_18);
local_10 = 0;
local_8 = 6;
LAB_00168632:
auVar2._4_4_ = uStack_c;
auVar2._0_4_ = local_10;
auVar2._8_8_ = local_8;
return auVar2;
}
| |
41,660 | JS_ToPrimitiveFree | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_ToPrimitiveFree(JSContext *ctx, JSValue val, int hint)
{
int i;
BOOL force_ordinary;
JSAtom method_name;
JSValue method, ret;
if (JS_VALUE_GET_TAG(val) != JS_TAG_OBJECT)
return val;
force_ordinary = hint & HINT_FORCE_ORDINARY;
hint &= ~HINT_FORCE_ORDINARY;
if (!force_ordinary) {
method = JS_GetProperty(ctx, val, JS_ATOM_Symbol_toPrimitive);
if (JS_IsException(method))
goto exception;
/* ECMA says *If exoticToPrim is not undefined* but tests in
test262 use null as a non callable converter */
if (!JS_IsUndefined(method) && !JS_IsNull(method)) {
JSAtom atom;
JSValue arg;
switch(hint) {
case HINT_STRING:
atom = JS_ATOM_string;
break;
case HINT_NUMBER:
atom = JS_ATOM_number;
break;
default:
case HINT_NONE:
atom = JS_ATOM_default;
break;
}
arg = JS_AtomToString(ctx, atom);
ret = JS_CallFree(ctx, method, val, 1, &arg);
JS_FreeValue(ctx, arg);
if (JS_IsException(ret))
goto exception;
JS_FreeValue(ctx, val);
if (JS_VALUE_GET_TAG(ret) != JS_TAG_OBJECT)
return ret;
JS_FreeValue(ctx, ret);
return JS_ThrowTypeError(ctx, "toPrimitive");
}
}
if (hint != HINT_STRING)
hint = HINT_NUMBER;
for(i = 0; i < 2; i++) {
if ((i ^ hint) == 0) {
method_name = JS_ATOM_toString;
} else {
method_name = JS_ATOM_valueOf;
}
method = JS_GetProperty(ctx, val, method_name);
if (JS_IsException(method))
goto exception;
if (JS_IsFunction(ctx, method)) {
ret = JS_CallFree(ctx, method, val, 0, NULL);
if (JS_IsException(ret))
goto exception;
if (JS_VALUE_GET_TAG(ret) != JS_TAG_OBJECT) {
JS_FreeValue(ctx, val);
return ret;
}
JS_FreeValue(ctx, ret);
} else {
JS_FreeValue(ctx, method);
}
}
JS_ThrowTypeError(ctx, "toPrimitive");
exception:
JS_FreeValue(ctx, val);
return JS_EXCEPTION;
} | O2 | c | JS_ToPrimitiveFree:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbp
cmpl $-0x1, %r14d
jne 0x3a382
movq %rdi, %r15
movl %ecx, %ebx
andl $-0x11, %ebx
testb $0x10, %cl
movq %rbp, 0x10(%rsp)
jne 0x3a2f0
movq %r15, %rdi
movq %rbp, %rsi
movq %r14, %rdx
movl $0xd3, %ecx
callq 0x1ebf3
movq %rax, %r12
leal -0x2(%rdx), %eax
cmpl $0x2, %eax
jae 0x3a3c9
xorl %ebp, %ebp
testl %ebx, %ebx
setne %bpl
xorl %ebx, %ebx
cmpl $0x2, %ebx
je 0x3a47b
xorl %eax, %eax
cmpl %ebx, %ebp
setne %al
leal 0x38(,%rax,2), %ecx
movq %r15, %rdi
movq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x1ebf3
movq %rdx, %r12
cmpl $0x6, %r12d
je 0x3a48c
movq %rax, %r13
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x20a2d
testl %eax, %eax
je 0x3a36d
andq $0x0, (%rsp)
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x10(%rsp), %rcx
movq %r14, %r8
xorl %r9d, %r9d
callq 0x2093e
movq %rax, %r13
movq %rdx, %r12
cmpl $-0x1, %r12d
jne 0x3a394
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1bbce
incl %ebx
jmp 0x3a2fa
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rbp, %rcx
jmp 0x3a4a4
cmpl $0x6, %r12d
je 0x3a48c
movq %r15, %rdi
movq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x1bbce
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %r13, %rcx
andq %rax, %rcx
movq %r13, %rbp
movq %r12, %r14
jmp 0x3a4a4
movq %rdx, %r13
cmpl $0x6, %r13d
je 0x3a48c
cmpl $0x1, %ebx
pushq $0x47
popq %rax
pushq $0x16
popq %rcx
cmovel %eax, %ecx
testl %ebx, %ebx
pushq $0x49
popq %rsi
cmovnel %ecx, %esi
movq %r15, %rdi
callq 0x1e540
leaq 0x18(%rsp), %rbx
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
movq %rbx, (%rsp)
pushq $0x1
popq %r9
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq 0x10(%rsp), %rbp
movq %rbp, %rcx
movq %r14, %r8
callq 0x2093e
movq %rax, %r13
movq %rdx, %r12
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x1bbce
movl %r12d, %ebx
cmpq $0x6, %rbx
je 0x3a48c
movq %r15, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x1bbce
cmpl $-0x1, %ebx
jne 0x3a3ae
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1bbce
leaq 0x4ef12(%rip), %rsi # 0x8937b
xorl %ebp, %ebp
movq %r15, %rdi
xorl %eax, %eax
callq 0x201fd
pushq $0x6
popq %r14
jmp 0x3a4a2
leaq 0x4eef9(%rip), %rsi # 0x8937b
movq %r15, %rdi
xorl %eax, %eax
callq 0x201fd
movq %r15, %rdi
movq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x1bbce
pushq $0x6
popq %r14
xorl %ebp, %ebp
xorl %ecx, %ecx
movl %ebp, %eax
orq %rcx, %rax
movq %r14, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| JS_ToPrimitiveFree:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rdx
mov rbp, rsi
cmp r14d, 0FFFFFFFFh
jnz loc_3A382
mov r15, rdi
mov ebx, ecx
and ebx, 0FFFFFFEFh
test cl, 10h
mov [rsp+58h+var_48], rbp
jnz short loc_3A2F0
mov rdi, r15
mov rsi, rbp
mov rdx, r14
mov ecx, 0D3h
call JS_GetProperty
mov r12, rax
lea eax, [rdx-2]
cmp eax, 2
jnb loc_3A3C9
loc_3A2F0:
xor ebp, ebp
test ebx, ebx
setnz bpl
xor ebx, ebx
loc_3A2FA:
cmp ebx, 2
jz loc_3A47B
xor eax, eax
cmp ebp, ebx
setnz al
lea ecx, ds:38h[rax*2]
mov rdi, r15
mov rsi, [rsp+58h+var_48]
mov rdx, r14
call JS_GetProperty
mov r12, rdx
cmp r12d, 6
jz loc_3A48C
mov r13, rax
mov rdi, r15
mov rsi, rax
mov rdx, r12
call JS_IsFunction
test eax, eax
jz short loc_3A36D
and [rsp+58h+var_58], 0
mov rdi, r15
mov rsi, r13
mov rdx, r12
mov rcx, [rsp+58h+var_48]
mov r8, r14
xor r9d, r9d
call JS_CallFree
mov r13, rax
mov r12, rdx
cmp r12d, 0FFFFFFFFh
jnz short loc_3A394
loc_3A36D:
mov rdi, r15
mov rsi, r13
mov rdx, r12
call JS_FreeValue
inc ebx
jmp loc_3A2FA
loc_3A382:
mov rcx, 0FFFFFFFF00000000h
and rcx, rbp
jmp loc_3A4A4
loc_3A394:
cmp r12d, 6
jz loc_3A48C
mov rdi, r15
mov rsi, [rsp+58h+var_48]
mov rdx, r14
call JS_FreeValue
loc_3A3AE:
mov rax, 0FFFFFFFF00000000h
mov rcx, r13
and rcx, rax
mov rbp, r13
mov r14, r12
jmp loc_3A4A4
loc_3A3C9:
mov r13, rdx
cmp r13d, 6
jz loc_3A48C
cmp ebx, 1
push 47h ; 'G'
pop rax
push 16h
pop rcx
cmovz ecx, eax
test ebx, ebx
push 49h ; 'I'
pop rsi
cmovnz esi, ecx
mov rdi, r15
call JS_AtomToString
lea rbx, [rsp+58h+var_40]
mov [rbx], rax
mov [rbx+8], rdx
mov [rsp+58h+var_58], rbx
push 1
pop r9
mov rdi, r15
mov rsi, r12
mov rdx, r13
mov rbp, [rsp+58h+var_48]
mov rcx, rbp
mov r8, r14
call JS_CallFree
mov r13, rax
mov r12, rdx
mov rsi, [rbx]
mov rdx, [rbx+8]
mov rdi, r15
call JS_FreeValue
mov ebx, r12d
cmp rbx, 6
jz short loc_3A48C
mov rdi, r15
mov rsi, rbp
mov rdx, r14
call JS_FreeValue
cmp ebx, 0FFFFFFFFh
jnz loc_3A3AE
mov rdi, r15
mov rsi, r13
mov rdx, r12
call JS_FreeValue
lea rsi, aToprimitive; "toPrimitive"
xor ebp, ebp
mov rdi, r15
xor eax, eax
call JS_ThrowTypeError
push 6
pop r14
jmp short loc_3A4A2
loc_3A47B:
lea rsi, aToprimitive; "toPrimitive"
mov rdi, r15
xor eax, eax
call JS_ThrowTypeError
loc_3A48C:
mov rdi, r15
mov rsi, [rsp+58h+var_48]
mov rdx, r14
call JS_FreeValue
push 6
pop r14
xor ebp, ebp
loc_3A4A2:
xor ecx, ecx
loc_3A4A4:
mov eax, ebp
or rax, rcx
mov rdx, r14
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long JS_ToPrimitiveFree(
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 v15; // ebp
int v16; // ebx
long long v17; // r12
int v18; // ebp
int i; // ebx
long long Property; // rax
long long v21; // rdx
long long v22; // r12
long long v23; // r13
long long v24; // rdx
unsigned long long v25; // rcx
long long v26; // r13
int v27; // ecx
int v28; // esi
long long v29; // rdx
long long v30; // rdx
long long v31; // r12
long long v32; // rdx
long long v33; // rcx
long long v34; // r8
long long v35; // r9
__m128 v36; // xmm4
__m128 v37; // xmm5
char v39; // [rsp+0h] [rbp-58h]
char v40; // [rsp+0h] [rbp-58h]
long long v42; // [rsp+18h] [rbp-40h] BYREF
long long v43; // [rsp+20h] [rbp-38h]
v15 = a2;
if ( (_DWORD)a3 == -1 )
{
v16 = a4 & 0xFFFFFFEF;
if ( (a4 & 0x10) != 0 || (v17 = JS_GetProperty(a1, a2, -1, 211), (unsigned int)(a3 - 2) < 2) )
{
v18 = v16 != 0;
for ( i = 0; ; ++i )
{
if ( i == 2 )
{
JS_ThrowTypeError(a1, (long long)"toPrimitive", a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v39);
goto LABEL_23;
}
Property = JS_GetProperty(a1, a2, a3, 2 * (unsigned int)(v18 != i) + 56);
v22 = v21;
if ( (_DWORD)v21 == 6 )
goto LABEL_23;
v23 = Property;
if ( (unsigned int)JS_IsFunction(a1, Property, v21) )
{
v23 = JS_CallFree(a1, v23, v22, a2, a3, 0, 0LL);
v22 = v24;
if ( (_DWORD)v24 != -1 )
break;
}
JS_FreeValue(a1, v23, v22);
}
if ( (_DWORD)v24 == 6 )
goto LABEL_23;
JS_FreeValue(a1, a2, a3);
goto LABEL_13;
}
v26 = a3;
if ( (_DWORD)a3 == 6 )
goto LABEL_23;
v27 = 22;
if ( v16 == 1 )
v27 = 71;
v28 = 73;
if ( v16 )
v28 = v27;
v42 = JS_AtomToString(a1, v28);
v43 = v29;
v23 = JS_CallFree(a1, v17, v26, a2, a3, 1, (long long)&v42);
v31 = v30;
JS_FreeValue(a1, v42, v43);
if ( (unsigned int)v31 == 6LL )
{
LABEL_23:
JS_FreeValue(a1, a2, a3);
v15 = 0;
}
else
{
JS_FreeValue(a1, a2, a3);
if ( (_DWORD)v31 != -1 )
{
LABEL_13:
v25 = v23 & 0xFFFFFFFF00000000LL;
v15 = v23;
return v25 | v15;
}
JS_FreeValue(a1, v23, v31);
v15 = 0;
JS_ThrowTypeError(a1, (long long)"toPrimitive", v32, v33, v34, v35, a7, a8, a9, a10, v36, v37, a13, a14, v40);
}
v25 = 0LL;
return v25 | v15;
}
v25 = a2 & 0xFFFFFFFF00000000LL;
return v25 | v15;
}
| JS_ToPrimitiveFree:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RDX
MOV RBP,RSI
CMP R14D,-0x1
JNZ 0x0013a382
MOV R15,RDI
MOV EBX,ECX
AND EBX,0xffffffef
TEST CL,0x10
MOV qword ptr [RSP + 0x10],RBP
JNZ 0x0013a2f0
MOV RDI,R15
MOV RSI,RBP
MOV RDX,R14
MOV ECX,0xd3
CALL 0x0011ebf3
MOV R12,RAX
LEA EAX,[RDX + -0x2]
CMP EAX,0x2
JNC 0x0013a3c9
LAB_0013a2f0:
XOR EBP,EBP
TEST EBX,EBX
SETNZ BPL
XOR EBX,EBX
LAB_0013a2fa:
CMP EBX,0x2
JZ 0x0013a47b
XOR EAX,EAX
CMP EBP,EBX
SETNZ AL
LEA ECX,[0x38 + RAX*0x2]
MOV RDI,R15
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,R14
CALL 0x0011ebf3
MOV R12,RDX
CMP R12D,0x6
JZ 0x0013a48c
MOV R13,RAX
MOV RDI,R15
MOV RSI,RAX
MOV RDX,R12
CALL 0x00120a2d
TEST EAX,EAX
JZ 0x0013a36d
AND qword ptr [RSP],0x0
MOV RDI,R15
MOV RSI,R13
MOV RDX,R12
MOV RCX,qword ptr [RSP + 0x10]
MOV R8,R14
XOR R9D,R9D
CALL 0x0012093e
MOV R13,RAX
MOV R12,RDX
CMP R12D,-0x1
JNZ 0x0013a394
LAB_0013a36d:
MOV RDI,R15
MOV RSI,R13
MOV RDX,R12
CALL 0x0011bbce
INC EBX
JMP 0x0013a2fa
LAB_0013a382:
MOV RCX,-0x100000000
AND RCX,RBP
JMP 0x0013a4a4
LAB_0013a394:
CMP R12D,0x6
JZ 0x0013a48c
MOV RDI,R15
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,R14
CALL 0x0011bbce
LAB_0013a3ae:
MOV RAX,-0x100000000
MOV RCX,R13
AND RCX,RAX
MOV RBP,R13
MOV R14,R12
JMP 0x0013a4a4
LAB_0013a3c9:
MOV R13,RDX
CMP R13D,0x6
JZ 0x0013a48c
CMP EBX,0x1
PUSH 0x47
POP RAX
PUSH 0x16
POP RCX
CMOVZ ECX,EAX
TEST EBX,EBX
PUSH 0x49
POP RSI
CMOVNZ ESI,ECX
MOV RDI,R15
CALL 0x0011e540
LEA RBX,[RSP + 0x18]
MOV qword ptr [RBX],RAX
MOV qword ptr [RBX + 0x8],RDX
MOV qword ptr [RSP],RBX
PUSH 0x1
POP R9
MOV RDI,R15
MOV RSI,R12
MOV RDX,R13
MOV RBP,qword ptr [RSP + 0x10]
MOV RCX,RBP
MOV R8,R14
CALL 0x0012093e
MOV R13,RAX
MOV R12,RDX
MOV RSI,qword ptr [RBX]
MOV RDX,qword ptr [RBX + 0x8]
MOV RDI,R15
CALL 0x0011bbce
MOV EBX,R12D
CMP RBX,0x6
JZ 0x0013a48c
MOV RDI,R15
MOV RSI,RBP
MOV RDX,R14
CALL 0x0011bbce
CMP EBX,-0x1
JNZ 0x0013a3ae
MOV RDI,R15
MOV RSI,R13
MOV RDX,R12
CALL 0x0011bbce
LEA RSI,[0x18937b]
XOR EBP,EBP
MOV RDI,R15
XOR EAX,EAX
CALL 0x001201fd
PUSH 0x6
POP R14
JMP 0x0013a4a2
LAB_0013a47b:
LEA RSI,[0x18937b]
MOV RDI,R15
XOR EAX,EAX
CALL 0x001201fd
LAB_0013a48c:
MOV RDI,R15
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,R14
CALL 0x0011bbce
PUSH 0x6
POP R14
XOR EBP,EBP
LAB_0013a4a2:
XOR ECX,ECX
LAB_0013a4a4:
MOV EAX,EBP
OR RAX,RCX
MOV RDX,R14
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16]
JS_ToPrimitiveFree(int8 param_1,ulong param_2,int8 param_3,uint param_4)
{
int8 uVar1;
int8 uVar2;
int iVar3;
uint uVar4;
int1 auVar5 [16];
int1 auVar6 [16];
int1 local_40 [16];
auVar5._8_8_ = param_3;
auVar5._0_8_ = param_2;
if ((int)param_3 != -1) {
param_2 = param_2 & 0xffffffff00000000;
goto LAB_0013a4a4;
}
if ((param_4 & 0x10) == 0) {
auVar5 = JS_GetProperty(param_1,param_2,param_3,0xd3);
if (auVar5._8_4_ - 2U < 2) goto LAB_0013a2f0;
if (auVar5._8_4_ == 6) goto LAB_0013a48c;
uVar1 = 0x16;
if ((param_4 & 0xffffffef) == 1) {
uVar1 = 0x47;
}
uVar2 = 0x49;
if ((param_4 & 0xffffffef) != 0) {
uVar2 = uVar1;
}
local_40 = JS_AtomToString(param_1,uVar2);
auVar5 = JS_CallFree(param_1,auVar5._0_8_,auVar5._8_8_,param_2,param_3,1,local_40);
JS_FreeValue(param_1,local_40._0_8_,local_40._8_8_);
if ((auVar5._8_8_ & 0xffffffff) == 6) goto LAB_0013a48c;
JS_FreeValue(param_1,param_2,param_3);
if (auVar5._8_4_ != -1) {
LAB_0013a3ae:
param_2 = auVar5._0_8_ & 0xffffffff00000000;
goto LAB_0013a4a4;
}
JS_FreeValue(param_1,auVar5._0_8_,auVar5._8_8_);
JS_ThrowTypeError(param_1,"toPrimitive");
}
else {
LAB_0013a2f0:
for (uVar4 = 0; uVar4 != 2; uVar4 = uVar4 + 1) {
auVar5 = JS_GetProperty(param_1,param_2,param_3,
(((param_4 & 0xffffffef) != 0) != uVar4) * '\x02' + '8');
if (auVar5._8_4_ == 6) goto LAB_0013a48c;
iVar3 = JS_IsFunction(param_1,auVar5._0_8_,auVar5._8_8_);
if (iVar3 != 0) {
auVar5 = JS_CallFree(param_1,auVar5._0_8_,auVar5._8_8_,param_2,param_3,0,0);
if (auVar5._8_4_ != -1) {
if (auVar5._8_4_ == 6) goto LAB_0013a48c;
JS_FreeValue(param_1,param_2,param_3);
goto LAB_0013a3ae;
}
}
JS_FreeValue(param_1,auVar5._0_8_,auVar5._8_8_);
}
JS_ThrowTypeError(param_1,"toPrimitive");
LAB_0013a48c:
JS_FreeValue(param_1,param_2,param_3);
}
auVar5 = ZEXT816(6) << 0x40;
param_2 = 0;
LAB_0013a4a4:
auVar6._0_8_ = auVar5._0_8_ & 0xffffffff | param_2;
auVar6._8_8_ = auVar5._8_8_;
return auVar6;
}
| |
41,661 | maria_page_filler_set_none | eloqsql/storage/maria/ma_pagecrc.c | my_bool maria_page_filler_set_none(PAGECACHE_IO_HOOK_ARGS *args
__attribute__((unused)))
{
#ifdef HAVE_valgrind
uchar *page= args->page;
MARIA_SHARE *share= (MARIA_SHARE *)args->data;
int4store_aligned(page + share->block_size - CRC_SIZE,
0);
#endif
return 0;
} | O0 | c | maria_page_filler_set_none:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
popq %rbp
retq
nopl (%rax)
| maria_page_filler_set_none:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
xor eax, eax
pop rbp
retn
| long long maria_page_filler_set_none()
{
return 0LL;
}
| maria_page_filler_set_none:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
XOR EAX,EAX
POP RBP
RET
|
int8 maria_page_filler_set_none(void)
{
return 0;
}
| |
41,662 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [3], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [3], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/json.hpp | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | O1 | cpp | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [3], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [3], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r13
movq %r8, %r14
movq %rcx, %r12
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r15
movq %rdx, 0x10(%rsp)
movq %rdx, %rdi
callq 0x1b400
addq %rax, %r15
addq 0x8(%r12), %r15
movq %r14, 0x8(%rsp)
movq %r14, %rdi
callq 0x1b400
addq %rax, %r15
addq 0x8(%r13), %r15
movq 0x50(%rsp), %rax
addq 0x8(%rax), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1bda0
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
movq %rbx, %rdi
callq 0x1b270
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0x1c120
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x1b270
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0x1c120
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %rbx, %rdi
callq 0x1b270
movq 0x50(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x1b270
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x6130c
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x1b8f0
movq %r14, %rdi
callq 0x1bfd0
| _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJS8_RA12_KcS8_RA3_S9_S8_RKS8_EEET_DpOT0_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r13, r9
mov r14, r8
mov r12, rcx
mov rbp, rsi
mov rbx, rdi
lea rax, [rdi+10h]
mov [rsp+48h+var_48], rax
mov [rdi], rax
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov r15, [rsi+8]
mov [rsp+48h+var_38], rdx
mov rdi, rdx
call _strlen
add r15, rax
add r15, [r12+8]
mov [rsp+48h+var_40], r14
mov rdi, r14
call _strlen
add r15, rax
add r15, [r13+8]
mov rax, [rsp+48h+arg_0]
add r15, [rax+8]
mov rdi, rbx
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rsi, [rbp+0]
mov rdx, [rbp+8]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rdi, rbx
mov rsi, [rsp+48h+var_38]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [r12]
mov rdx, [r12+8]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rdi, rbx
mov rsi, [rsp+48h+var_40]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [r13+0]
mov rdx, [r13+8]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rax, [rsp+48h+arg_0]
mov rsi, [rax]
mov rdx, [rax+8]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, [rsp+0]
jz short loc_6130C
mov rax, [rsp+0]
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_6130C:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::concat<std::string,std::string,char const(&)[12],std::string,char const(&)[3],std::string,std::string const&>(
long long a1,
_QWORD *a2,
long long a3,
_QWORD *a4,
long long a5,
_QWORD *a6,
_QWORD *a7)
{
long long v10; // r15
long long v11; // r15
long long v12; // rax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v10 = a2[1];
v11 = a4[1] + strlen(a3) + v10;
v12 = strlen(a5);
std::string::reserve(a1, a7[1] + a6[1] + v12 + v11);
std::string::_M_append(a1, *a2, a2[1]);
std::string::append(a1, a3);
std::string::_M_append(a1, *a4, a4[1]);
std::string::append(a1, a5);
std::string::_M_append(a1, *a6, a6[1]);
std::string::_M_append(a1, *a7, a7[1]);
return a1;
}
| concat<std::__cxx11::string,std::__cxx11::string,char_const(&)[12],std::__cxx11::string,char_const(&)[3],std::__cxx11::string,std::__cxx11::string_const&>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R13,R9
MOV R14,R8
MOV R12,RCX
MOV RBP,RSI
MOV RBX,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RSP],RAX
MOV qword ptr [RDI],RAX
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV R15,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x10],RDX
MOV RDI,RDX
CALL 0x0011b400
ADD R15,RAX
ADD R15,qword ptr [R12 + 0x8]
MOV qword ptr [RSP + 0x8],R14
MOV RDI,R14
CALL 0x0011b400
ADD R15,RAX
ADD R15,qword ptr [R13 + 0x8]
MOV RAX,qword ptr [RSP + 0x50]
ADD R15,qword ptr [RAX + 0x8]
LAB_00161275:
MOV RDI,RBX
MOV RSI,R15
CALL 0x0011bda0
MOV RSI,qword ptr [RBP]
MOV RDX,qword ptr [RBP + 0x8]
MOV RDI,RBX
CALL 0x0011b270
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x10]
CALL 0x0011c120
MOV RSI,qword ptr [R12]
MOV RDX,qword ptr [R12 + 0x8]
MOV RDI,RBX
CALL 0x0011b270
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x0011c120
MOV RSI,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
MOV RDI,RBX
CALL 0x0011b270
MOV RAX,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
MOV RDI,RBX
CALL 0x0011b270
LAB_001612df:
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* std::__cxx11::string nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,
std::__cxx11::string, char const (&) [12], std::__cxx11::string, char const (&) [3],
std::__cxx11::string, std::__cxx11::string const&>(std::__cxx11::string&&, char const (&) [12],
std::__cxx11::string&&, char const (&) [3], std::__cxx11::string&&, std::__cxx11::string const&)
*/
detail * __thiscall
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,std::__cxx11::string,char_const(&)[12],std::__cxx11::string,char_const(&)[3],std::__cxx11::string,std::__cxx11::string_const&>
(detail *this,string *param_1,char *param_2,string *param_3,char *param_4,string *param_5,
string *param_6)
{
*(detail **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (detail)0x0;
strlen(param_2);
strlen(param_4);
/* try { // try from 00161275 to 001612de has its CatchHandler @ 001612f1 */
std::__cxx11::string::reserve((ulong)this);
std::__cxx11::string::_M_append((char *)this,*(ulong *)param_1);
std::__cxx11::string::append((char *)this);
std::__cxx11::string::_M_append((char *)this,*(ulong *)param_3);
std::__cxx11::string::append((char *)this);
std::__cxx11::string::_M_append((char *)this,*(ulong *)param_5);
std::__cxx11::string::_M_append((char *)this,*(ulong *)param_6);
return this;
}
| |
41,663 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [3], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [3], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/json.hpp | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | O2 | cpp | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [3], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [3], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x7e02f
movq %rbx, %rdi
movq %rax, %rsi
callq 0x23db0
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x7e056
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x24208
movq %r14, %rdi
callq 0x23fd0
| _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA6_KcS8_RA12_S9_EEET_DpOT0_:
push r15
push r14
push r12
push rbx
push rax
mov r14, rcx
mov r15, rdx
mov r12, rsi
mov rbx, rdi
lea rax, [rdi+10h]
mov [rdi], rax
and qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rdi, rsi
mov rsi, rdx
mov rdx, rcx
call _ZN8nlohmann16json_abi_v3_11_36detail13concat_lengthIJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEA12_cEEEmPKcDpRKT_; nlohmann::json_abi_v3_11_3::detail::concat_length<std::string,char [12]>(char const*,std::string,char [12] const&)
mov rdi, rbx
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rdi, rbx
mov rsi, r12
mov rdx, r15
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail11concat_intoINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA6_KcJS8_RA12_S9_ETnNSt9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSF_OSG_DpOT1_
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
mov r14, rax
mov rdi, rbx; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(
long long a1,
long long a2,
long long a3,
long long a4)
{
long long v6; // rax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v6 = nlohmann::json_abi_v3_11_3::detail::concat_length<std::string,char [12]>(a2, a3, a4);
std::string::reserve(a1, v6);
ZN8nlohmann16json_abi_v3_11_36detail11concat_intoINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA6_KcJS8_RA12_S9_ETnNSt9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSF_OSG_DpOT1_(
a1,
a2,
a3,
a4);
return a1;
}
| concat<std::__cxx11::string,char_const(&)[6],std::__cxx11::string,char_const(&)[12]>:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RCX
MOV R15,RDX
MOV R12,RSI
MOV RBX,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
AND qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
LAB_0017dfe3:
MOV RDI,RSI
MOV RSI,RDX
MOV RDX,RCX
CALL 0x0017e02f
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00123db0
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R15
MOV RCX,R14
CALL 0x0017e056
LAB_0017e00d:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* std::__cxx11::string nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string, char const
(&) [6], std::__cxx11::string, char const (&) [12]>(char const (&) [6], std::__cxx11::string&&,
char const (&) [12]) */
detail * __thiscall
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[6],std::__cxx11::string,char_const(&)[12]>
(detail *this,char *param_1,string *param_2,char *param_3)
{
*(detail **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (detail)0x0;
/* try { // try from 0017dfe3 to 0017e00c has its CatchHandler @ 0017e01c */
concat_length<std::__cxx11::string,char[12]>(param_1,param_2,param_3);
std::__cxx11::string::reserve((ulong)this);
_ZN8nlohmann16json_abi_v3_11_36detail11concat_intoINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA6_KcJS8_RA12_S9_ETnNSt9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSF_OSG_DpOT1_
(this,param_1,param_2,param_3);
return this;
}
| |
41,664 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [3], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [3], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/json.hpp | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | O3 | cpp | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [3], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [3], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x1a400
movq %rax, %rbp
addq 0x8(%r12), %rbp
movq %r15, %rdi
callq 0x1a400
addq %rax, %rbp
addq 0x8(%r14), %rbp
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x1ada0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1b120
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x1a270
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1b120
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x1a270
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x60c80
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x1a8f0
movq %r14, %rdi
callq 0x1afd0
| _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA10_KcS8_SB_S8_EEET_DpOT0_:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, r8
mov r15, rcx
mov r12, rdx
mov r13, rsi
mov rbx, rdi
lea rax, [rdi+10h]
mov [rsp+38h+var_38], rax
mov [rdi], rax
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rdi, rsi
call _strlen
mov rbp, rax
add rbp, [r12+8]
mov rdi, r15
call _strlen
add rbp, rax
add rbp, [r14+8]
mov rdi, rbx
mov rsi, rbp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rdi, rbx
mov rsi, r13
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [r12]
mov rdx, [r12+8]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rdi, rbx
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [r14]
mov rdx, [r14+8]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, [rsp+0]
jz short loc_60C80
mov rax, [rsp+0]
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_60C80:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[10],std::string,char const(&)[10],std::string>(
long long a1,
long long a2,
_QWORD *a3,
long long a4,
_QWORD *a5)
{
long long v8; // rbp
long long v9; // rax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v8 = a3[1] + strlen(a2);
v9 = strlen(a4);
std::string::reserve(a1, a5[1] + v9 + v8);
std::string::append(a1, a2);
std::string::_M_append(a1, *a3, a3[1]);
std::string::append(a1, a4);
std::string::_M_append(a1, *a5, a5[1]);
return a1;
}
| concat<std::__cxx11::string,char_const(&)[10],std::__cxx11::string,char_const(&)[10],std::__cxx11::string>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R8
MOV R15,RCX
MOV R12,RDX
MOV R13,RSI
MOV RBX,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RSP],RAX
MOV qword ptr [RDI],RAX
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RDI,RSI
CALL 0x0011a400
MOV RBP,RAX
ADD RBP,qword ptr [R12 + 0x8]
MOV RDI,R15
CALL 0x0011a400
ADD RBP,RAX
ADD RBP,qword ptr [R14 + 0x8]
LAB_00160c12:
MOV RDI,RBX
MOV RSI,RBP
CALL 0x0011ada0
MOV RDI,RBX
MOV RSI,R13
CALL 0x0011b120
MOV RSI,qword ptr [R12]
MOV RDX,qword ptr [R12 + 0x8]
MOV RDI,RBX
CALL 0x0011a270
MOV RDI,RBX
MOV RSI,R15
CALL 0x0011b120
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
MOV RDI,RBX
CALL 0x0011a270
LAB_00160c53:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* std::__cxx11::string nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string, char const
(&) [10], std::__cxx11::string, char const (&) [10], std::__cxx11::string >(char const (&) [10],
std::__cxx11::string&&, char const (&) [10], std::__cxx11::string&&) */
detail * __thiscall
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[10],std::__cxx11::string,char_const(&)[10],std::__cxx11::string>
(detail *this,char *param_1,string *param_2,char *param_3,string *param_4)
{
*(detail **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (detail)0x0;
strlen(param_1);
strlen(param_3);
/* try { // try from 00160c12 to 00160c52 has its CatchHandler @ 00160c65 */
std::__cxx11::string::reserve((ulong)this);
std::__cxx11::string::append((char *)this);
std::__cxx11::string::_M_append((char *)this,*(ulong *)param_2);
std::__cxx11::string::append((char *)this);
std::__cxx11::string::_M_append((char *)this,*(ulong *)param_4);
return this;
}
| |
41,665 | js_get_fast_array_element | bluesky950520[P]quickjs/quickjs.c | static BOOL js_get_fast_array_element(JSContext *ctx, JSObject *p,
uint32_t idx, JSValue *pval)
{
switch(p->class_id) {
case JS_CLASS_ARRAY:
case JS_CLASS_ARGUMENTS:
if (unlikely(idx >= p->u.array.count)) return FALSE;
*pval = js_dup(p->u.array.u.values[idx]);
return TRUE;
case JS_CLASS_INT8_ARRAY:
if (unlikely(idx >= p->u.array.count)) return FALSE;
*pval = js_int32(p->u.array.u.int8_ptr[idx]);
return TRUE;
case JS_CLASS_UINT8C_ARRAY:
case JS_CLASS_UINT8_ARRAY:
if (unlikely(idx >= p->u.array.count)) return FALSE;
*pval = js_int32(p->u.array.u.uint8_ptr[idx]);
return TRUE;
case JS_CLASS_INT16_ARRAY:
if (unlikely(idx >= p->u.array.count)) return FALSE;
*pval = js_int32(p->u.array.u.int16_ptr[idx]);
return TRUE;
case JS_CLASS_UINT16_ARRAY:
if (unlikely(idx >= p->u.array.count)) return FALSE;
*pval = js_int32(p->u.array.u.uint16_ptr[idx]);
return TRUE;
case JS_CLASS_INT32_ARRAY:
if (unlikely(idx >= p->u.array.count)) return FALSE;
*pval = js_int32(p->u.array.u.int32_ptr[idx]);
return TRUE;
case JS_CLASS_UINT32_ARRAY:
if (unlikely(idx >= p->u.array.count)) return FALSE;
*pval = js_uint32(p->u.array.u.uint32_ptr[idx]);
return TRUE;
case JS_CLASS_BIG_INT64_ARRAY:
if (unlikely(idx >= p->u.array.count)) return FALSE;
*pval = JS_NewBigInt64(ctx, p->u.array.u.int64_ptr[idx]);
return TRUE;
case JS_CLASS_BIG_UINT64_ARRAY:
if (unlikely(idx >= p->u.array.count)) return FALSE;
*pval = JS_NewBigUint64(ctx, p->u.array.u.uint64_ptr[idx]);
return TRUE;
case JS_CLASS_FLOAT16_ARRAY:
if (unlikely(idx >= p->u.array.count)) return FALSE;
*pval = js_float64(fromfp16(p->u.array.u.fp16_ptr[idx]));
return TRUE;
case JS_CLASS_FLOAT32_ARRAY:
if (unlikely(idx >= p->u.array.count)) return FALSE;
*pval = js_float64(p->u.array.u.float_ptr[idx]);
return TRUE;
case JS_CLASS_FLOAT64_ARRAY:
if (unlikely(idx >= p->u.array.count)) return FALSE;
*pval = js_float64(p->u.array.u.double_ptr[idx]);
return TRUE;
default:
return FALSE;
}
} | O3 | c | js_get_fast_array_element:
pushq %rbp
pushq %rbx
pushq %rax
movq %rcx, %rbx
movzwl 0x6(%rsi), %ecx
xorl %eax, %eax
addl $-0x2, %ecx
cmpl $0x1e, %ecx
ja 0xfb7f
leaq 0x8e4c8(%rip), %r8 # 0x9de74
movslq (%r8,%rcx,4), %rcx
addq %r8, %rcx
jmpq *%rcx
cmpl %edx, 0x40(%rsi)
jbe 0xfb7f
movq 0x38(%rsi), %rcx
movl %edx, %edx
shlq $0x4, %rdx
movq (%rcx,%rdx), %rax
movq 0x8(%rcx,%rdx), %rdx
cmpl $-0x9, %edx
jb 0xfa76
incl (%rax)
jmp 0xfa76
cmpl %edx, 0x40(%rsi)
jbe 0xfb7f
movq 0x38(%rsi), %rax
movl %edx, %ecx
movzbl (%rax,%rcx), %eax
jmp 0xfae0
cmpl %edx, 0x40(%rsi)
jbe 0xfb7f
movq 0x38(%rsi), %rax
movl %edx, %ecx
movsbq (%rax,%rcx), %rax
jmp 0xfac9
cmpl %edx, 0x40(%rsi)
jbe 0xfb7f
movq 0x38(%rsi), %rax
movl %edx, %ecx
movq (%rax,%rcx,8), %rsi
callq 0x27d6d
jmp 0xfa76
cmpl %edx, 0x40(%rsi)
jbe 0xfb7f
movq 0x38(%rsi), %rax
movl %edx, %ecx
movq (%rax,%rcx,8), %rax
movq %rax, (%rbx)
jmp 0xfb75
cmpl %edx, 0x40(%rsi)
jbe 0xfb7f
movq 0x38(%rsi), %rax
movl %edx, %ecx
movl (%rax,%rcx,4), %eax
jmp 0xfae0
cmpl %edx, 0x40(%rsi)
jbe 0xfb7f
movq 0x38(%rsi), %rax
movl %edx, %ecx
movq (%rax,%rcx,8), %rsi
callq 0xffed
movq %rax, (%rbx)
jmp 0xfb78
cmpl %edx, 0x40(%rsi)
jbe 0xfb7f
movq 0x38(%rsi), %rax
movl %edx, %ecx
movslq (%rax,%rcx,4), %rax
xorl %ecx, %ecx
movl %eax, %edx
cvtsi2sd %rdx, %xmm0
testq %rax, %rax
movq %xmm0, %rsi
cmovnsq %rax, %rsi
pushq $0x7
popq %rdx
cmovnsq %rcx, %rdx
movq %rsi, (%rbx)
jmp 0xfb78
cmpl %edx, 0x40(%rsi)
jbe 0xfb7f
movq 0x38(%rsi), %rax
movl %edx, %ecx
movswq (%rax,%rcx,2), %rax
movl %eax, %eax
jmp 0xfae0
cmpl %edx, 0x40(%rsi)
jbe 0xfb7f
movq 0x38(%rsi), %rax
movl %edx, %ecx
movzwl (%rax,%rcx,2), %eax
movq %rax, (%rbx)
xorl %edx, %edx
jmp 0xfb78
cmpl %edx, 0x40(%rsi)
jbe 0xfb7f
movq 0x38(%rsi), %rax
movl %edx, %ecx
cvtss2sd (%rax,%rcx,4), %xmm0
jmp 0xfb71
cmpl %edx, 0x40(%rsi)
jbe 0xfb7f
movq 0x38(%rsi), %rax
movl %edx, %ecx
movzwl (%rax,%rcx,2), %ebp
movl $0x7c00, %edx # imm = 0x7C00
movl %ebp, %eax
andl %edx, %eax
movl %ebp, %ecx
andl $0x3ff, %ecx # imm = 0x3FF
cmpl %edx, %eax
jne 0xfb39
xorl %eax, %eax
testl %ecx, %ecx
sete %al
leaq 0x904ae(%rip), %rcx # 0x9ffe0
movsd (%rcx,%rax,8), %xmm0
jmp 0xfb64
cvtsi2sd %ecx, %xmm0
mulsd 0x905fb(%rip), %xmm0 # 0xa0140
movl %eax, %edi
shrl $0xa, %edi
addl $-0xf, %edi
testl %eax, %eax
je 0xfb59
addsd 0x905cf(%rip), %xmm0 # 0xa0128
pushq $-0xe
popq %rax
cmovel %eax, %edi
callq 0xe660
testw %bp, %bp
jns 0xfb71
xorpd 0x9047f(%rip), %xmm0 # 0x9fff0
movsd %xmm0, (%rbx)
pushq $0x7
popq %rdx
movq %rdx, 0x8(%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| js_get_fast_array_element:
push rbp
push rbx
push rax
mov rbx, rcx
movzx ecx, word ptr [rsi+6]
xor eax, eax
add ecx, 0FFFFFFFEh; switch 31 cases
cmp ecx, 1Eh
ja def_F9B3; jumptable 000000000000F9B3 default case, cases 3-7,9-20
lea r8, jpt_F9B3
movsxd rcx, ds:(jpt_F9B3 - 9DE74h)[r8+rcx*4]
add rcx, r8
jmp rcx; switch jump
loc_F9B5:
cmp [rsi+40h], edx; jumptable 000000000000F9B3 cases 2,8
jbe def_F9B3; jumptable 000000000000F9B3 default case, cases 3-7,9-20
mov rcx, [rsi+38h]
mov edx, edx
shl rdx, 4
mov rax, [rcx+rdx]
mov rdx, [rcx+rdx+8]
cmp edx, 0FFFFFFF7h
jb loc_FA76
inc dword ptr [rax]
jmp loc_FA76
loc_F9E1:
cmp [rsi+40h], edx; jumptable 000000000000F9B3 cases 21,23
jbe def_F9B3; jumptable 000000000000F9B3 default case, cases 3-7,9-20
mov rax, [rsi+38h]
mov ecx, edx
movzx eax, byte ptr [rax+rcx]
jmp loc_FAE0
loc_F9F9:
cmp [rsi+40h], edx; jumptable 000000000000F9B3 case 22
jbe def_F9B3; jumptable 000000000000F9B3 default case, cases 3-7,9-20
mov rax, [rsi+38h]
mov ecx, edx
movsx rax, byte ptr [rax+rcx]
jmp loc_FAC9
loc_FA12:
cmp [rsi+40h], edx; jumptable 000000000000F9B3 case 28
jbe def_F9B3; jumptable 000000000000F9B3 default case, cases 3-7,9-20
mov rax, [rsi+38h]
mov ecx, edx
mov rsi, [rax+rcx*8]
call JS_NewBigInt64
jmp short loc_FA76
loc_FA2C:
cmp [rsi+40h], edx; jumptable 000000000000F9B3 case 32
jbe def_F9B3; jumptable 000000000000F9B3 default case, cases 3-7,9-20
mov rax, [rsi+38h]
mov ecx, edx
mov rax, [rax+rcx*8]
mov [rbx], rax
jmp loc_FB75
loc_FA47:
cmp [rsi+40h], edx; jumptable 000000000000F9B3 case 26
jbe def_F9B3; jumptable 000000000000F9B3 default case, cases 3-7,9-20
mov rax, [rsi+38h]
mov ecx, edx
mov eax, [rax+rcx*4]
jmp loc_FAE0
loc_FA5E:
cmp [rsi+40h], edx; jumptable 000000000000F9B3 case 29
jbe def_F9B3; jumptable 000000000000F9B3 default case, cases 3-7,9-20
mov rax, [rsi+38h]
mov ecx, edx
mov rsi, [rax+rcx*8]
call JS_NewBigUint64
loc_FA76:
mov [rbx], rax
jmp loc_FB78
loc_FA7E:
cmp [rsi+40h], edx; jumptable 000000000000F9B3 case 27
jbe def_F9B3; jumptable 000000000000F9B3 default case, cases 3-7,9-20
mov rax, [rsi+38h]
mov ecx, edx
movsxd rax, dword ptr [rax+rcx*4]
xor ecx, ecx
mov edx, eax
cvtsi2sd xmm0, rdx
test rax, rax
movq rsi, xmm0
cmovns rsi, rax
push 7
pop rdx
cmovns rdx, rcx
mov [rbx], rsi
jmp loc_FB78
loc_FAB5:
cmp [rsi+40h], edx; jumptable 000000000000F9B3 case 24
jbe def_F9B3; jumptable 000000000000F9B3 default case, cases 3-7,9-20
mov rax, [rsi+38h]
mov ecx, edx
movsx rax, word ptr [rax+rcx*2]
loc_FAC9:
mov eax, eax
jmp short loc_FAE0
loc_FACD:
cmp [rsi+40h], edx; jumptable 000000000000F9B3 case 25
jbe def_F9B3; jumptable 000000000000F9B3 default case, cases 3-7,9-20
mov rax, [rsi+38h]
mov ecx, edx
movzx eax, word ptr [rax+rcx*2]
loc_FAE0:
mov [rbx], rax
xor edx, edx
jmp loc_FB78
loc_FAEA:
cmp [rsi+40h], edx; jumptable 000000000000F9B3 case 31
jbe def_F9B3; jumptable 000000000000F9B3 default case, cases 3-7,9-20
mov rax, [rsi+38h]
mov ecx, edx
cvtss2sd xmm0, dword ptr [rax+rcx*4]
jmp short loc_FB71
loc_FB00:
cmp [rsi+40h], edx; jumptable 000000000000F9B3 case 30
jbe short def_F9B3; jumptable 000000000000F9B3 default case, cases 3-7,9-20
mov rax, [rsi+38h]
mov ecx, edx
movzx ebp, word ptr [rax+rcx*2]
mov edx, 7C00h
mov eax, ebp
and eax, edx
mov ecx, ebp
and ecx, 3FFh
cmp eax, edx
jnz short loc_FB39
xor eax, eax
test ecx, ecx
setz al
lea rcx, unk_9FFE0
movsd xmm0, qword ptr [rcx+rax*8]
jmp short loc_FB64
loc_FB39:
cvtsi2sd xmm0, ecx
mulsd xmm0, cs:qword_A0140
mov edi, eax
shr edi, 0Ah
add edi, 0FFFFFFF1h
test eax, eax
jz short loc_FB59
addsd xmm0, cs:qword_A0128
loc_FB59:
push 0FFFFFFFFFFFFFFF2h
pop rax
cmovz edi, eax
call _scalbn
loc_FB64:
test bp, bp
jns short loc_FB71
xorpd xmm0, cs:xmmword_9FFF0
loc_FB71:
movsd qword ptr [rbx], xmm0
loc_FB75:
push 7
pop rdx
loc_FB78:
mov [rbx+8], rdx
push 1
pop rax
def_F9B3:
add rsp, 8; jumptable 000000000000F9B3 default case, cases 3-7,9-20
pop rbx
pop rbp
retn
| long long js_get_fast_array_element(long long a1, long long a2, unsigned int a3, double *a4)
{
long long result; // rax
long long v6; // rcx
long long v7; // rdx
_DWORD *v8; // rax
long long v9; // rdx
long long v10; // rax
long long v11; // rax
double v12; // rsi
double v13; // xmm0_8
__int16 v14; // bp
int v15; // ecx
long long v16; // rdi
result = 0LL;
switch ( *(_WORD *)(a2 + 6) )
{
case 2:
case 8:
if ( *(_DWORD *)(a2 + 64) > a3 )
{
v6 = *(_QWORD *)(a2 + 56);
v7 = 16LL * a3;
v8 = *(_DWORD **)(v6 + v7);
v9 = *(_QWORD *)(v6 + v7 + 8);
if ( (unsigned int)v9 >= 0xFFFFFFF7 )
++*v8;
goto LABEL_17;
}
break;
case 0x15:
case 0x17:
if ( *(_DWORD *)(a2 + 64) > a3 )
{
v10 = *(unsigned __int8 *)(*(_QWORD *)(a2 + 56) + a3);
goto LABEL_29;
}
break;
case 0x16:
if ( *(_DWORD *)(a2 + 64) > a3 )
{
LODWORD(v10) = *(char *)(*(_QWORD *)(a2 + 56) + a3);
goto LABEL_26;
}
break;
case 0x18:
if ( *(_DWORD *)(a2 + 64) > a3 )
{
LODWORD(v10) = *(__int16 *)(*(_QWORD *)(a2 + 56) + 2LL * a3);
LABEL_26:
v10 = (unsigned int)v10;
goto LABEL_29;
}
break;
case 0x19:
if ( *(_DWORD *)(a2 + 64) > a3 )
{
v10 = *(unsigned __int16 *)(*(_QWORD *)(a2 + 56) + 2LL * a3);
goto LABEL_29;
}
break;
case 0x1A:
if ( *(_DWORD *)(a2 + 64) > a3 )
{
v10 = *(unsigned int *)(*(_QWORD *)(a2 + 56) + 4LL * a3);
LABEL_29:
*(_QWORD *)a4 = v10;
v9 = 0LL;
goto LABEL_43;
}
break;
case 0x1B:
if ( *(_DWORD *)(a2 + 64) > a3 )
{
v11 = *(int *)(*(_QWORD *)(a2 + 56) + 4LL * a3);
v12 = (double)*(int *)(*(_QWORD *)(a2 + 56) + 4LL * a3);
if ( v11 >= 0 )
v12 = *(double *)&v11;
v9 = 7LL;
if ( v11 >= 0 )
v9 = 0LL;
*a4 = v12;
goto LABEL_43;
}
break;
case 0x1C:
if ( *(_DWORD *)(a2 + 64) > a3 )
{
v8 = (_DWORD *)JS_NewBigInt64(a1, *(_QWORD *)(*(_QWORD *)(a2 + 56) + 8LL * a3));
goto LABEL_17;
}
break;
case 0x1D:
if ( *(_DWORD *)(a2 + 64) > a3 )
{
v8 = (_DWORD *)JS_NewBigUint64(a1, *(_QWORD *)(*(_QWORD *)(a2 + 56) + 8LL * a3));
LABEL_17:
*(_QWORD *)a4 = v8;
goto LABEL_43;
}
break;
case 0x1E:
if ( *(_DWORD *)(a2 + 64) > a3 )
{
v14 = *(_WORD *)(*(_QWORD *)(a2 + 56) + 2LL * a3);
v15 = v14 & 0x3FF;
if ( (v14 & 0x7C00) == 0x7C00 )
{
v13 = dbl_9FFE0[v15 == 0];
}
else
{
v13 = (double)v15 * 0.0009765625;
v16 = ((unsigned __int16)(v14 & 0x7C00) >> 10) - 15;
if ( (v14 & 0x7C00) != 0 )
v13 = v13 + 1.0;
else
v16 = 4294967282LL;
scalbn(v16, v13);
}
if ( v14 < 0 )
v13 = -v13;
goto LABEL_41;
}
break;
case 0x1F:
if ( *(_DWORD *)(a2 + 64) > a3 )
{
v13 = *(float *)(*(_QWORD *)(a2 + 56) + 4LL * a3);
LABEL_41:
*a4 = v13;
goto LABEL_42;
}
break;
case 0x20:
if ( *(_DWORD *)(a2 + 64) > a3 )
{
*a4 = *(double *)(*(_QWORD *)(a2 + 56) + 8LL * a3);
LABEL_42:
v9 = 7LL;
LABEL_43:
*((_QWORD *)a4 + 1) = v9;
result = 1LL;
}
break;
default:
return result;
}
return result;
}
| js_get_fast_array_element:
PUSH RBP
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOVZX ECX,word ptr [RSI + 0x6]
XOR EAX,EAX
ADD ECX,-0x2
CMP ECX,0x1e
JA 0x0010fb7f
LEA R8,[0x19de74]
MOVSXD RCX,dword ptr [R8 + RCX*0x4]
ADD RCX,R8
switchD:
JMP RCX
caseD_2:
CMP dword ptr [RSI + 0x40],EDX
JBE 0x0010fb7f
MOV RCX,qword ptr [RSI + 0x38]
MOV EDX,EDX
SHL RDX,0x4
MOV RAX,qword ptr [RCX + RDX*0x1]
MOV RDX,qword ptr [RCX + RDX*0x1 + 0x8]
CMP EDX,-0x9
JC 0x0010fa76
INC dword ptr [RAX]
JMP 0x0010fa76
caseD_15:
CMP dword ptr [RSI + 0x40],EDX
JBE 0x0010fb7f
MOV RAX,qword ptr [RSI + 0x38]
MOV ECX,EDX
MOVZX EAX,byte ptr [RAX + RCX*0x1]
JMP 0x0010fae0
caseD_16:
CMP dword ptr [RSI + 0x40],EDX
JBE 0x0010fb7f
MOV RAX,qword ptr [RSI + 0x38]
MOV ECX,EDX
MOVSX RAX,byte ptr [RAX + RCX*0x1]
JMP 0x0010fac9
caseD_1c:
CMP dword ptr [RSI + 0x40],EDX
JBE 0x0010fb7f
MOV RAX,qword ptr [RSI + 0x38]
MOV ECX,EDX
MOV RSI,qword ptr [RAX + RCX*0x8]
CALL 0x00127d6d
JMP 0x0010fa76
caseD_20:
CMP dword ptr [RSI + 0x40],EDX
JBE 0x0010fb7f
MOV RAX,qword ptr [RSI + 0x38]
MOV ECX,EDX
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBX],RAX
JMP 0x0010fb75
caseD_1a:
CMP dword ptr [RSI + 0x40],EDX
JBE 0x0010fb7f
MOV RAX,qword ptr [RSI + 0x38]
MOV ECX,EDX
MOV EAX,dword ptr [RAX + RCX*0x4]
JMP 0x0010fae0
caseD_1d:
CMP dword ptr [RSI + 0x40],EDX
JBE 0x0010fb7f
MOV RAX,qword ptr [RSI + 0x38]
MOV ECX,EDX
MOV RSI,qword ptr [RAX + RCX*0x8]
CALL 0x0010ffed
LAB_0010fa76:
MOV qword ptr [RBX],RAX
JMP 0x0010fb78
caseD_1b:
CMP dword ptr [RSI + 0x40],EDX
JBE 0x0010fb7f
MOV RAX,qword ptr [RSI + 0x38]
MOV ECX,EDX
MOVSXD RAX,dword ptr [RAX + RCX*0x4]
XOR ECX,ECX
MOV EDX,EAX
CVTSI2SD XMM0,RDX
TEST RAX,RAX
MOVQ RSI,XMM0
CMOVNS RSI,RAX
PUSH 0x7
POP RDX
CMOVNS RDX,RCX
MOV qword ptr [RBX],RSI
JMP 0x0010fb78
caseD_18:
CMP dword ptr [RSI + 0x40],EDX
JBE 0x0010fb7f
MOV RAX,qword ptr [RSI + 0x38]
MOV ECX,EDX
MOVSX RAX,word ptr [RAX + RCX*0x2]
LAB_0010fac9:
MOV EAX,EAX
JMP 0x0010fae0
caseD_19:
CMP dword ptr [RSI + 0x40],EDX
JBE 0x0010fb7f
MOV RAX,qword ptr [RSI + 0x38]
MOV ECX,EDX
MOVZX EAX,word ptr [RAX + RCX*0x2]
LAB_0010fae0:
MOV qword ptr [RBX],RAX
XOR EDX,EDX
JMP 0x0010fb78
caseD_1f:
CMP dword ptr [RSI + 0x40],EDX
JBE 0x0010fb7f
MOV RAX,qword ptr [RSI + 0x38]
MOV ECX,EDX
CVTSS2SD XMM0,dword ptr [RAX + RCX*0x4]
JMP 0x0010fb71
caseD_1e:
CMP dword ptr [RSI + 0x40],EDX
JBE 0x0010fb7f
MOV RAX,qword ptr [RSI + 0x38]
MOV ECX,EDX
MOVZX EBP,word ptr [RAX + RCX*0x2]
MOV EDX,0x7c00
MOV EAX,EBP
AND EAX,EDX
MOV ECX,EBP
AND ECX,0x3ff
CMP EAX,EDX
JNZ 0x0010fb39
XOR EAX,EAX
TEST ECX,ECX
SETZ AL
LEA RCX,[0x19ffe0]
MOVSD XMM0,qword ptr [RCX + RAX*0x8]
JMP 0x0010fb64
LAB_0010fb39:
CVTSI2SD XMM0,ECX
MULSD XMM0,qword ptr [0x001a0140]
MOV EDI,EAX
SHR EDI,0xa
ADD EDI,-0xf
TEST EAX,EAX
JZ 0x0010fb59
ADDSD XMM0,qword ptr [0x001a0128]
LAB_0010fb59:
PUSH -0xe
POP RAX
CMOVZ EDI,EAX
CALL 0x0010e660
LAB_0010fb64:
TEST BP,BP
JNS 0x0010fb71
XORPD XMM0,xmmword ptr [0x0019fff0]
LAB_0010fb71:
MOVSD qword ptr [RBX],XMM0
LAB_0010fb75:
PUSH 0x7
POP RDX
LAB_0010fb78:
MOV qword ptr [RBX + 0x8],RDX
PUSH 0x1
POP RAX
caseD_3:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 js_get_fast_array_element(int8 param_1,long param_2,uint param_3,double *param_4)
{
ushort uVar1;
int *piVar2;
int1 auVar3 [16];
uint uVar4;
int8 uVar5;
double dVar6;
double dVar7;
int __n;
double dVar8;
int1 auVar9 [16];
uVar5 = 0;
switch(*(int2 *)(param_2 + 6)) {
case 2:
case 8:
if (*(uint *)(param_2 + 0x40) <= param_3) {
return 0;
}
piVar2 = *(int **)(*(long *)(param_2 + 0x38) + (ulong)param_3 * 0x10);
uVar5 = *(int8 *)(*(long *)(param_2 + 0x38) + 8 + (ulong)param_3 * 0x10);
auVar3._8_8_ = uVar5;
auVar3._0_8_ = piVar2;
auVar9._8_8_ = uVar5;
auVar9._0_8_ = piVar2;
if (0xfffffff6 < (uint)uVar5) {
*piVar2 = *piVar2 + 1;
auVar9 = auVar3;
}
goto LAB_0010fa76;
default:
goto switchD_0010f9b3_caseD_3;
case 0x15:
case 0x17:
if (*(uint *)(param_2 + 0x40) <= param_3) {
return 0;
}
dVar8 = (double)(ulong)*(byte *)(*(long *)(param_2 + 0x38) + (ulong)param_3);
break;
case 0x16:
if (*(uint *)(param_2 + 0x40) <= param_3) {
return 0;
}
uVar4 = (uint)*(char *)(*(long *)(param_2 + 0x38) + (ulong)param_3);
goto LAB_0010fac9;
case 0x18:
if (*(uint *)(param_2 + 0x40) <= param_3) {
return 0;
}
uVar4 = (uint)*(short *)(*(long *)(param_2 + 0x38) + (ulong)param_3 * 2);
LAB_0010fac9:
dVar8 = (double)(ulong)uVar4;
break;
case 0x19:
if (*(uint *)(param_2 + 0x40) <= param_3) {
return 0;
}
dVar8 = (double)(ulong)*(ushort *)(*(long *)(param_2 + 0x38) + (ulong)param_3 * 2);
break;
case 0x1a:
if (*(uint *)(param_2 + 0x40) <= param_3) {
return 0;
}
dVar8 = (double)(ulong)*(uint *)(*(long *)(param_2 + 0x38) + (ulong)param_3 * 4);
break;
case 0x1b:
if (*(uint *)(param_2 + 0x40) <= param_3) {
return 0;
}
uVar4 = *(uint *)(*(long *)(param_2 + 0x38) + (ulong)param_3 * 4);
dVar6 = (double)(long)(int)uVar4;
dVar7 = (double)uVar4;
if (-1 < (long)dVar6) {
dVar7 = dVar6;
}
dVar8 = 3.45845952088873e-323;
if (-1 < (long)dVar6) {
dVar8 = 0.0;
}
*param_4 = dVar7;
goto LAB_0010fb78;
case 0x1c:
if (*(uint *)(param_2 + 0x40) <= param_3) {
return 0;
}
auVar9 = JS_NewBigInt64(param_1,*(int8 *)(*(long *)(param_2 + 0x38) + (ulong)param_3 * 8))
;
goto LAB_0010fa76;
case 0x1d:
if (*(uint *)(param_2 + 0x40) <= param_3) {
return 0;
}
auVar9 = JS_NewBigUint64(param_1,*(int8 *)(*(long *)(param_2 + 0x38) + (ulong)param_3 * 8)
);
LAB_0010fa76:
dVar8 = auVar9._8_8_;
*param_4 = auVar9._0_8_;
goto LAB_0010fb78;
case 0x1e:
if (*(uint *)(param_2 + 0x40) <= param_3) {
return 0;
}
uVar1 = *(ushort *)(*(long *)(param_2 + 0x38) + (ulong)param_3 * 2);
if ((uVar1 & 0x7c00) == 0x7c00) {
dVar8 = *(double *)(&DAT_0019ffe0 + (ulong)((uVar1 & 0x3ff) == 0) * 8);
}
else {
dVar8 = (double)(uVar1 & 0x3ff) * _DAT_001a0140;
__n = ((uVar1 & 0x7c00) >> 10) - 0xf;
if ((uVar1 & 0x7c00) == 0) {
__n = -0xe;
}
else {
dVar8 = dVar8 + DAT_001a0128;
}
dVar8 = scalbn(dVar8,__n);
}
if ((short)uVar1 < 0) {
dVar8 = (double)((ulong)dVar8 ^ _DAT_0019fff0);
}
goto LAB_0010fb71;
case 0x1f:
if (*(uint *)(param_2 + 0x40) <= param_3) {
return 0;
}
dVar8 = (double)*(float *)(*(long *)(param_2 + 0x38) + (ulong)param_3 * 4);
LAB_0010fb71:
*param_4 = dVar8;
LAB_0010fb75:
dVar8 = 3.45845952088873e-323;
goto LAB_0010fb78;
case 0x20:
if (*(uint *)(param_2 + 0x40) <= param_3) {
return 0;
}
*param_4 = *(double *)(*(long *)(param_2 + 0x38) + (ulong)param_3 * 8);
goto LAB_0010fb75;
}
*param_4 = dVar8;
dVar8 = 0.0;
LAB_0010fb78:
param_4[1] = dVar8;
uVar5 = 1;
switchD_0010f9b3_caseD_3:
return uVar5;
}
| |
41,666 | LefDefParser::lefwMacroObsLayer(char const*, double) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp | int
lefwMacroObsLayer(const char *layerName,
double spacing)
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (!lefwDidInit)
return LEFW_BAD_ORDER;
if (!lefwIsMacroObs)
return LEFW_BAD_ORDER;
if (!layerName || layerName == 0 || *layerName == 0)
return LEFW_BAD_DATA;
if (lefwWidthVal)
return LEFW_BAD_DATA;
if (lefwWriteEncrypt) {
encPrint(lefwFile, (char*) " LAYER %s ", layerName);
if (spacing)
encPrint(lefwFile, (char*) "SPACING %.11g ", spacing);
encPrint(lefwFile, (char*) ";\n");
} else {
fprintf(lefwFile, " LAYER %s ", layerName);
if (spacing)
fprintf(lefwFile, "SPACING %.11g ", spacing);
fprintf(lefwFile, ";\n");
}
lefwLines++;
lefwIsMacroObsLayer = 1;
lefwSpacingVal = 1;
return LEFW_OK;
} | O0 | cpp | LefDefParser::lefwMacroObsLayer(char const*, double):
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movsd %xmm0, (%rsp)
leaq 0x9426b(%rip), %rax # 0xc5250
cmpq $0x0, (%rax)
jne 0x30ff8
movl $0x1, 0x14(%rsp)
jmp 0x31171
leaq 0x944a5(%rip), %rax # 0xc54a4
cmpl $0x0, (%rax)
jne 0x31011
movl $0x2, 0x14(%rsp)
jmp 0x31171
leaq 0x944d0(%rip), %rax # 0xc54e8
cmpl $0x0, (%rax)
jne 0x3102a
movl $0x2, 0x14(%rsp)
jmp 0x31171
cmpq $0x0, 0x8(%rsp)
je 0x31047
cmpq $0x0, 0x8(%rsp)
je 0x31047
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x31054
movl $0x3, 0x14(%rsp)
jmp 0x31171
cmpl $0x0, 0x94519(%rip) # 0xc5574
je 0x3106a
movl $0x3, 0x14(%rsp)
jmp 0x31171
cmpl $0x0, 0x944cb(%rip) # 0xc553c
je 0x310d9
leaq 0x941d6(%rip), %rax # 0xc5250
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x6330d(%rip), %rsi # 0x94396
movb $0x0, %al
callq 0x8bf50
movsd (%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x310a2
jp 0x310a2
jmp 0x310bf
leaq 0x941a7(%rip), %rax # 0xc5250
movq (%rax), %rdi
movsd (%rsp), %xmm0
leaq 0x61cc6(%rip), %rsi # 0x92d7e
movb $0x1, %al
callq 0x8bf50
leaq 0x9418a(%rip), %rax # 0xc5250
movq (%rax), %rdi
leaq 0x61749(%rip), %rsi # 0x92819
movb $0x0, %al
callq 0x8bf50
jmp 0x3113d
leaq 0x94170(%rip), %rax # 0xc5250
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x632a7(%rip), %rsi # 0x94396
movb $0x0, %al
callq 0x2370
movsd (%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x31108
jp 0x31108
jmp 0x31125
leaq 0x94141(%rip), %rax # 0xc5250
movq (%rax), %rdi
movsd (%rsp), %xmm0
leaq 0x61c60(%rip), %rsi # 0x92d7e
movb $0x1, %al
callq 0x2370
leaq 0x94124(%rip), %rax # 0xc5250
movq (%rax), %rdi
leaq 0x616e3(%rip), %rsi # 0x92819
movb $0x0, %al
callq 0x2370
leaq 0x94358(%rip), %rax # 0xc549c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x9434c(%rip), %rax # 0xc549c
movl %ecx, (%rax)
leaq 0x94393(%rip), %rax # 0xc54ec
movl $0x1, (%rax)
movl $0x1, 0x94407(%rip) # 0xc5570
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| _ZN12LefDefParser17lefwMacroObsLayerEPKcd:
sub rsp, 18h
mov [rsp+18h+var_10], rdi
movsd [rsp+18h+var_18], xmm0
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
cmp qword ptr [rax], 0
jnz short loc_30FF8
mov [rsp+18h+var_4], 1
jmp loc_31171
loc_30FF8:
lea rax, _ZN12LefDefParser11lefwDidInitE; LefDefParser::lefwDidInit
cmp dword ptr [rax], 0
jnz short loc_31011
mov [rsp+18h+var_4], 2
jmp loc_31171
loc_31011:
lea rax, _ZN12LefDefParser14lefwIsMacroObsE; LefDefParser::lefwIsMacroObs
cmp dword ptr [rax], 0
jnz short loc_3102A
mov [rsp+18h+var_4], 2
jmp loc_31171
loc_3102A:
cmp [rsp+18h+var_10], 0
jz short loc_31047
cmp [rsp+18h+var_10], 0
jz short loc_31047
mov rax, [rsp+18h+var_10]
movsx eax, byte ptr [rax]
cmp eax, 0
jnz short loc_31054
loc_31047:
mov [rsp+18h+var_4], 3
jmp loc_31171
loc_31054:
cmp cs:_ZN12LefDefParserL12lefwWidthValE, 0; LefDefParser::lefwWidthVal
jz short loc_3106A
mov [rsp+18h+var_4], 3
jmp loc_31171
loc_3106A:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 0; LefDefParser::lefwWriteEncrypt
jz short loc_310D9
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
mov rdx, [rsp+18h+var_10]
lea rsi, aLayerS_2+3; " LAYER %s "
mov al, 0
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
movsd xmm0, [rsp+18h+var_18]
xorps xmm1, xmm1
ucomisd xmm0, xmm1
jnz short loc_310A2
jp short loc_310A2
jmp short loc_310BF
loc_310A2:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+18h+var_18]
lea rsi, aSpacing11g_0+3; "SPACING %.11g "
mov al, 1
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
loc_310BF:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
lea rsi, aDividercharS+11h; ";\n"
mov al, 0
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_3113D
loc_310D9:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
mov rdx, [rsp+18h+var_10]
lea rsi, aLayerS_2+3; " LAYER %s "
mov al, 0
call _fprintf
movsd xmm0, [rsp+18h+var_18]
xorps xmm1, xmm1
ucomisd xmm0, xmm1
jnz short loc_31108
jp short loc_31108
jmp short loc_31125
loc_31108:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+18h+var_18]
lea rsi, aSpacing11g_0+3; "SPACING %.11g "
mov al, 1
call _fprintf
loc_31125:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
lea rsi, aDividercharS+11h; ";\n"
mov al, 0
call _fprintf
loc_3113D:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov [rax], ecx
lea rax, _ZN12LefDefParser19lefwIsMacroObsLayerE; LefDefParser::lefwIsMacroObsLayer
mov dword ptr [rax], 1
mov cs:_ZN12LefDefParserL14lefwSpacingValE, 1; LefDefParser::lefwSpacingVal
mov [rsp+18h+var_4], 0
loc_31171:
mov eax, [rsp+18h+var_4]
add rsp, 18h
retn
| long long LefDefParser::lefwMacroObsLayer(
LefDefParser *this,
const char *a2,
double a3,
long long a4,
int a5,
int a6,
int a7)
{
int v7; // edx
int v8; // ecx
int v9; // r8d
int v10; // r9d
if ( *(_QWORD *)&LefDefParser::lefwFile )
{
if ( LefDefParser::lefwDidInit )
{
if ( LefDefParser::lefwIsMacroObs )
{
if ( this && *(_BYTE *)this )
{
if ( LefDefParser::lefwWidthVal )
{
return 3;
}
else
{
if ( LefDefParser::lefwWriteEncrypt )
{
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)" LAYER %s ", (_DWORD)this, a5, a6, a7);
if ( a3 != 0.0 )
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)"SPACING %.11g ", v7, v8, v9, v10);
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)";\n", v7, v8, v9, v10);
}
else
{
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " LAYER %s ", (const char *)this);
if ( a3 != 0.0 )
fprintf(*(_QWORD *)&LefDefParser::lefwFile, "SPACING %.11g ", a3);
fprintf(*(_QWORD *)&LefDefParser::lefwFile, ";\n");
}
++LefDefParser::lefwLines;
LefDefParser::lefwIsMacroObsLayer = 1;
LefDefParser::lefwSpacingVal = 1;
return 0;
}
}
else
{
return 3;
}
}
else
{
return 2;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
| lefwMacroObsLayer:
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
MOVSD qword ptr [RSP],XMM0
LEA RAX,[0x1c5250]
CMP qword ptr [RAX],0x0
JNZ 0x00130ff8
MOV dword ptr [RSP + 0x14],0x1
JMP 0x00131171
LAB_00130ff8:
LEA RAX,[0x1c54a4]
CMP dword ptr [RAX],0x0
JNZ 0x00131011
MOV dword ptr [RSP + 0x14],0x2
JMP 0x00131171
LAB_00131011:
LEA RAX,[0x1c54e8]
CMP dword ptr [RAX],0x0
JNZ 0x0013102a
MOV dword ptr [RSP + 0x14],0x2
JMP 0x00131171
LAB_0013102a:
CMP qword ptr [RSP + 0x8],0x0
JZ 0x00131047
CMP qword ptr [RSP + 0x8],0x0
JZ 0x00131047
MOV RAX,qword ptr [RSP + 0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JNZ 0x00131054
LAB_00131047:
MOV dword ptr [RSP + 0x14],0x3
JMP 0x00131171
LAB_00131054:
CMP dword ptr [0x001c5574],0x0
JZ 0x0013106a
MOV dword ptr [RSP + 0x14],0x3
JMP 0x00131171
LAB_0013106a:
CMP dword ptr [0x001c553c],0x0
JZ 0x001310d9
LEA RAX,[0x1c5250]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RSP + 0x8]
LEA RSI,[0x194396]
MOV AL,0x0
CALL 0x0018bf50
MOVSD XMM0,qword ptr [RSP]
XORPS XMM1,XMM1
UCOMISD XMM0,XMM1
JNZ 0x001310a2
JP 0x001310a2
JMP 0x001310bf
LAB_001310a2:
LEA RAX,[0x1c5250]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP]
LEA RSI,[0x192d7e]
MOV AL,0x1
CALL 0x0018bf50
LAB_001310bf:
LEA RAX,[0x1c5250]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x192819]
MOV AL,0x0
CALL 0x0018bf50
JMP 0x0013113d
LAB_001310d9:
LEA RAX,[0x1c5250]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RSP + 0x8]
LEA RSI,[0x194396]
MOV AL,0x0
CALL 0x00102370
MOVSD XMM0,qword ptr [RSP]
XORPS XMM1,XMM1
UCOMISD XMM0,XMM1
JNZ 0x00131108
JP 0x00131108
JMP 0x00131125
LAB_00131108:
LEA RAX,[0x1c5250]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP]
LEA RSI,[0x192d7e]
MOV AL,0x1
CALL 0x00102370
LAB_00131125:
LEA RAX,[0x1c5250]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x192819]
MOV AL,0x0
CALL 0x00102370
LAB_0013113d:
LEA RAX,[0x1c549c]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x1c549c]
MOV dword ptr [RAX],ECX
LEA RAX,[0x1c54ec]
MOV dword ptr [RAX],0x1
MOV dword ptr [0x001c5570],0x1
MOV dword ptr [RSP + 0x14],0x0
LAB_00131171:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x18
RET
|
/* LefDefParser::lefwMacroObsLayer(char const*, double) */
int4 LefDefParser::lefwMacroObsLayer(char *param_1,double param_2)
{
int4 local_4;
if (lefwFile == (_IO_FILE *)0x0) {
local_4 = 1;
}
else if (lefwDidInit == 0) {
local_4 = 2;
}
else if (lefwIsMacroObs == 0) {
local_4 = 2;
}
else if (((param_1 == (char *)0x0) || (param_1 == (char *)0x0)) || (*param_1 == '\0')) {
local_4 = 3;
}
else if (lefwWidthVal == 0) {
if (lefwWriteEncrypt == 0) {
fprintf(lefwFile," LAYER %s ",param_1);
if ((param_2 != 0.0) || (NAN(param_2))) {
fprintf(lefwFile,"SPACING %.11g ",param_2);
}
fprintf(lefwFile,";\n");
}
else {
encPrint(lefwFile," LAYER %s ",param_1);
if ((param_2 != 0.0) || (NAN(param_2))) {
encPrint(lefwFile,"SPACING %.11g ",param_2);
}
encPrint(lefwFile,";\n");
}
lefwLines = lefwLines + 1;
lefwIsMacroObsLayer = 1;
lefwSpacingVal = 1;
local_4 = 0;
}
else {
local_4 = 3;
}
return local_4;
}
| |
41,667 | Settings::setCount(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | 666mxvbee[P]BattleShip/lib/Settings/Settings.cpp | std::string Settings::setCount(const std::string& cmd) {
std::lock_guard<std::mutex> lock(settings_mutex);
std::stringstream ss(cmd);
int typeShip;
uint64_t count;
if (!(ss >> typeShip >> count)) {
return "failed";
}
if (typeShip < 1 || typeShip > 4) {
return "failed";
}
shipCounts[typeShip] = count;
return "ok";
} | O1 | cpp | Settings::setCount(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x5520
testl %eax, %eax
jne 0x67a8
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
movl $0x18, %edx
callq 0x5560
leaq 0x18(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x5210
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x51d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x6714
leaq 0x10(%r14), %rax
movq %rax, (%r14)
leaq 0x13b05(%rip), %rsi # 0x1a208
leaq 0x13b04(%rip), %rdx # 0x1a20e
movq %r14, %rdi
callq 0x603a
jmp 0x6772
movl 0xc(%rsp), %eax
addl $-0x5, %eax
cmpl $-0x5, %eax
ja 0x673f
leaq 0x10(%r14), %rax
movq %rax, (%r14)
leaq 0x13ada(%rip), %rsi # 0x1a208
leaq 0x13ad9(%rip), %rdx # 0x1a20e
movq %r14, %rdi
callq 0x603a
jmp 0x6772
movq 0x10(%rsp), %r15
leaq 0x60(%rbx), %rdi
leaq 0xc(%rsp), %rsi
callq 0x73bc
movq %r15, (%rax)
leaq 0x10(%r14), %rax
movq %rax, (%r14)
leaq 0x13aa2(%rip), %rsi # 0x1a205
leaq 0x13a9d(%rip), %rdx # 0x1a207
movq %r14, %rdi
callq 0x603a
movq 0x1e7df(%rip), %rsi # 0x24f58
leaq 0x18(%rsp), %rdi
callq 0x52e0
leaq 0x98(%rsp), %rdi
callq 0x50f0
movq %rbx, %rdi
callq 0x52f0
movq %r14, %rax
addq $0x1a0, %rsp # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x5260
jmp 0x67ba
jmp 0x67ba
jmp 0x67ba
movq %rax, %r14
jmp 0x67db
movq %rax, %r14
movq 0x1e794(%rip), %rsi # 0x24f58
leaq 0x18(%rsp), %rdi
callq 0x52e0
leaq 0x98(%rsp), %rdi
callq 0x50f0
movq %rbx, %rdi
callq 0x52f0
movq %r14, %rdi
callq 0x5600
nop
| _ZN8Settings8setCountERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push rbx
sub rsp, 1A0h
mov r15, rdx
mov rbx, rsi
mov r14, rdi
mov rdi, rsi
call _pthread_mutex_lock
test eax, eax
jnz loc_67A8
lea rdi, [rsp+1B8h+var_1A0]
mov rsi, r15
mov edx, 18h
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1ERKNS_12basic_stringIcS2_S3_EESt13_Ios_Openmode; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(std::string const&,std::_Ios_Openmode)
lea rdi, [rsp+1B8h+var_1A0]
lea rsi, [rsp+1B8h+var_1AC]
call __ZNSirsERi; std::istream::operator>>(int &)
lea rsi, [rsp+1B8h+var_1A8]
mov rdi, rax
call __ZNSi10_M_extractImEERSiRT_; std::istream::_M_extract<ulong>(ulong &)
mov rcx, [rax]
mov rcx, [rcx-18h]
test byte ptr [rax+rcx+20h], 5
jz short loc_6714
lea rax, [r14+10h]
mov [r14], rax
lea rsi, aFailed; "failed"
lea rdx, aFailed+6; ""
mov rdi, r14
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)
jmp short loc_6772
loc_6714:
mov eax, [rsp+1B8h+var_1AC]
add eax, 0FFFFFFFBh
cmp eax, 0FFFFFFFBh
ja short loc_673F
lea rax, [r14+10h]
mov [r14], rax
lea rsi, aFailed; "failed"
lea rdx, aFailed+6; ""
mov rdi, r14
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)
jmp short loc_6772
loc_673F:
mov r15, [rsp+1B8h+var_1A8]
lea rdi, [rbx+60h]
lea rsi, [rsp+1B8h+var_1AC]
call _ZNSt3mapIimSt4lessIiESaISt4pairIKimEEEixERS3_; std::map<int,ulong>::operator[](int const&)
mov [rax], r15
lea rax, [r14+10h]
mov [r14], rax
lea rsi, aOk; "ok"
lea rdx, aOk+2; ""
mov rdi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
loc_6772:
mov rsi, cs:_ZTTNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+1B8h+var_1A0]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED2Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
lea rdi, [rsp+1B8h+var_120]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rdi, rbx
call _pthread_mutex_unlock
mov rax, r14
add rsp, 1A0h
pop rbx
pop r14
pop r15
retn
loc_67A8:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
jmp short loc_67BA
jmp short loc_67BA
jmp short loc_67BA
mov r14, rax
jmp short loc_67DB
loc_67BA:
mov r14, rax
mov rsi, cs:_ZTTNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+1B8h+var_1A0]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED2Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
lea rdi, [rsp+1B8h+var_120]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
loc_67DB:
mov rdi, rbx
call _pthread_mutex_unlock
mov rdi, r14
call __Unwind_Resume
| _QWORD * Settings::setCount(_QWORD *a1, long long a2, long long a3)
{
int v4; // eax
long long v5; // rax
_QWORD *v6; // rax
long long v7; // r15
int v9; // [rsp+Ch] [rbp-1ACh] BYREF
long long v10; // [rsp+10h] [rbp-1A8h] BYREF
_BYTE v11[128]; // [rsp+18h] [rbp-1A0h] BYREF
_BYTE v12[288]; // [rsp+98h] [rbp-120h] BYREF
v4 = pthread_mutex_lock(a2);
if ( v4 )
std::__throw_system_error(v4);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v11, a3, 24LL);
v5 = std::istream::operator>>(v11, &v9);
v6 = (_QWORD *)std::istream::_M_extract<unsigned long>(v5, &v10);
if ( (*((_BYTE *)v6 + *(_QWORD *)(*v6 - 24LL) + 32) & 5) != 0 || (unsigned int)(v9 - 5) <= 0xFFFFFFFB )
{
*a1 = a1 + 2;
std::string::_M_construct<char const*>(a1, "failed", (long long)"");
}
else
{
v7 = v10;
*(_QWORD *)std::map<int,unsigned long>::operator[](a2 + 96, &v9) = v7;
*a1 = a1 + 2;
std::string::_M_construct<char const*>(a1, "ok", (long long)"");
}
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream(
v11,
&`VTT for'std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>);
std::ios_base::~ios_base((std::ios_base *)v12);
pthread_mutex_unlock(a2);
return a1;
}
| setCount:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x1a0
MOV R15,RDX
MOV RBX,RSI
MOV R14,RDI
MOV RDI,RSI
CALL 0x00105520
TEST EAX,EAX
JNZ 0x001067a8
LAB_001066b9:
LEA RDI,[RSP + 0x18]
MOV RSI,R15
MOV EDX,0x18
CALL 0x00105560
LAB_001066cb:
LEA RDI,[RSP + 0x18]
LEA RSI,[RSP + 0xc]
CALL 0x00105210
LEA RSI,[RSP + 0x10]
MOV RDI,RAX
CALL 0x001051d0
MOV RCX,qword ptr [RAX]
MOV RCX,qword ptr [RCX + -0x18]
TEST byte ptr [RAX + RCX*0x1 + 0x20],0x5
JZ 0x00106714
LEA RAX,[R14 + 0x10]
MOV qword ptr [R14],RAX
LAB_001066fc:
LEA RSI,[0x11a208]
LEA RDX,[0x11a20e]
MOV RDI,R14
CALL 0x0010603a
JMP 0x00106772
LAB_00106714:
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,-0x5
CMP EAX,-0x5
JA 0x0010673f
LEA RAX,[R14 + 0x10]
MOV qword ptr [R14],RAX
LAB_00106727:
LEA RSI,[0x11a208]
LEA RDX,[0x11a20e]
MOV RDI,R14
CALL 0x0010603a
JMP 0x00106772
LAB_0010673f:
MOV R15,qword ptr [RSP + 0x10]
LEA RDI,[RBX + 0x60]
LAB_00106748:
LEA RSI,[RSP + 0xc]
CALL 0x001073bc
MOV qword ptr [RAX],R15
LEA RAX,[R14 + 0x10]
MOV qword ptr [R14],RAX
LAB_0010675c:
LEA RSI,[0x11a205]
LEA RDX,[0x11a207]
MOV RDI,R14
CALL 0x0010603a
LAB_00106772:
MOV RSI,qword ptr [0x00124f58]
LEA RDI,[RSP + 0x18]
CALL 0x001052e0
LEA RDI,[RSP + 0x98]
CALL 0x001050f0
MOV RDI,RBX
CALL 0x001052f0
MOV RAX,R14
ADD RSP,0x1a0
POP RBX
POP R14
POP R15
RET
LAB_001067a8:
MOV EDI,EAX
CALL 0x00105260
|
/* Settings::setCount(std::__cxx11::string const&) */
string * Settings::setCount(string *param_1)
{
int iVar1;
ulong *puVar2;
istream *piVar3;
int8 *puVar4;
pthread_mutex_t *in_RSI;
int local_1ac;
int8 local_1a8;
stringstream local_1a0 [128];
ios_base local_120 [264];
iVar1 = pthread_mutex_lock(in_RSI);
if (iVar1 == 0) {
/* try { // try from 001066b9 to 001066ca has its CatchHandler @ 001067b5 */
std::__cxx11::stringstream::stringstream(local_1a0);
/* try { // try from 001066cb to 001066e6 has its CatchHandler @ 001067ba */
puVar2 = (ulong *)std::istream::operator>>((istream *)local_1a0,&local_1ac);
piVar3 = std::istream::_M_extract<unsigned_long>(puVar2);
if (((byte)piVar3[*(long *)(*(long *)piVar3 + -0x18) + 0x20] & 5) == 0) {
if (local_1ac - 5U < 0xfffffffc) {
*(string **)param_1 = param_1 + 0x10;
/* try { // try from 00106727 to 0010673c has its CatchHandler @ 001067b1 */
std::__cxx11::string::_M_construct<char_const*>(param_1,"failed","");
}
else {
/* try { // try from 00106748 to 00106751 has its CatchHandler @ 001067ba */
puVar4 = (int8 *)
std::
map<int,unsigned_long,std::less<int>,std::allocator<std::pair<int_const,unsigned_long>>>
::operator[]((map<int,unsigned_long,std::less<int>,std::allocator<std::pair<int_const,unsigned_long>>>
*)((long)in_RSI + 0x60),&local_1ac);
*puVar4 = local_1a8;
*(string **)param_1 = param_1 + 0x10;
/* try { // try from 0010675c to 00106771 has its CatchHandler @ 001067af */
std::__cxx11::string::_M_construct<char_const*>(param_1,&DAT_0011a205,&DAT_0011a207);
}
}
else {
*(string **)param_1 = param_1 + 0x10;
/* try { // try from 001066fc to 00106711 has its CatchHandler @ 001067b3 */
std::__cxx11::string::_M_construct<char_const*>(param_1,"failed","");
}
std::__cxx11::stringstream::~stringstream(local_1a0);
std::ios_base::~ios_base(local_120);
pthread_mutex_unlock(in_RSI);
return param_1;
}
/* WARNING: Subroutine does not return */
std::__throw_system_error(iVar1);
}
| |
41,668 | Settings::setCount(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | 666mxvbee[P]BattleShip/lib/Settings/Settings.cpp | std::string Settings::setCount(const std::string& cmd) {
std::lock_guard<std::mutex> lock(settings_mutex);
std::stringstream ss(cmd);
int typeShip;
uint64_t count;
if (!(ss >> typeShip >> count)) {
return "failed";
}
if (typeShip < 1 || typeShip > 4) {
return "failed";
}
shipCounts[typeShip] = count;
return "ok";
} | O2 | cpp | Settings::setCount(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x6d3c
leaq 0x18(%rsp), %rdi
pushq $0x18
popq %rdx
movq %r15, %rsi
callq 0x5510
leaq 0x18(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x5210
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x51d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x6179
leaq 0x1109e(%rip), %rsi # 0x17208
leaq 0xb(%rsp), %rdx
movq %r14, %rdi
callq 0x6a32
jmp 0x61c5
movl 0xc(%rsp), %eax
addl $-0x5, %eax
cmpl $-0x5, %eax
ja 0x619b
leaq 0x1107c(%rip), %rsi # 0x17208
leaq 0xb(%rsp), %rdx
movq %r14, %rdi
callq 0x6a32
jmp 0x61c5
movq 0x10(%rsp), %r15
leaq 0x60(%rbx), %rdi
leaq 0xc(%rsp), %rsi
callq 0x6b48
movq %r15, (%rax)
leaq 0x1104d(%rip), %rsi # 0x17205
leaq 0xb(%rsp), %rdx
movq %r14, %rdi
callq 0x6a32
leaq 0x18(%rsp), %rdi
callq 0x52d0
movq %rbx, %rdi
callq 0x52e0
movq %r14, %rax
addq $0x1a0, %rsp # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x61f2
jmp 0x61f2
jmp 0x61f2
movq %rax, %r14
jmp 0x61ff
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x52d0
movq %rbx, %rdi
callq 0x52e0
movq %r14, %rdi
callq 0x55b0
nop
| _ZN8Settings8setCountERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push rbx
sub rsp, 1A0h
mov r15, rdx
mov rbx, rsi
mov r14, rdi
mov rdi, rsi; this
call _ZNSt5mutex4lockEv; std::mutex::lock(void)
lea rdi, [rsp+1B8h+var_1A0]
push 18h
pop rdx
mov rsi, r15
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1ERKNS_12basic_stringIcS2_S3_EESt13_Ios_Openmode; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(std::string const&,std::_Ios_Openmode)
lea rdi, [rsp+1B8h+var_1A0]
lea rsi, [rsp+1B8h+var_1AC]
call __ZNSirsERi; std::istream::operator>>(int &)
lea rsi, [rsp+1B8h+var_1A8]
mov rdi, rax
call __ZNSi10_M_extractImEERSiRT_; std::istream::_M_extract<ulong>(ulong &)
mov rcx, [rax]
mov rcx, [rcx-18h]
test byte ptr [rax+rcx+20h], 5
jz short loc_6179
lea rsi, aFailed; "failed"
lea rdx, [rsp+1B8h+var_1AD]
mov rdi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short loc_61C5
loc_6179:
mov eax, [rsp+1B8h+var_1AC]
add eax, 0FFFFFFFBh
cmp eax, 0FFFFFFFBh
ja short loc_619B
lea rsi, aFailed; "failed"
lea rdx, [rsp+1B8h+var_1AD]
mov rdi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short loc_61C5
loc_619B:
mov r15, [rsp+1B8h+var_1A8]
lea rdi, [rbx+60h]
lea rsi, [rsp+1B8h+var_1AC]
call _ZNSt3mapIimSt4lessIiESaISt4pairIKimEEEixERS3_; std::map<int,ulong>::operator[](int const&)
mov [rax], r15
lea rsi, aOk; "ok"
lea rdx, [rsp+1B8h+var_1AD]
mov rdi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
loc_61C5:
lea rdi, [rsp+1B8h+var_1A0]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
mov rdi, rbx
call _pthread_mutex_unlock
mov rax, r14
add rsp, 1A0h
pop rbx
pop r14
pop r15
retn
jmp short loc_61F2
jmp short loc_61F2
jmp short loc_61F2
mov r14, rax
jmp short loc_61FF
loc_61F2:
mov r14, rax
lea rdi, [rsp+arg_10]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
loc_61FF:
mov rdi, rbx
call _pthread_mutex_unlock
mov rdi, r14
call __Unwind_Resume
| long long Settings::setCount(long long a1, std::mutex *a2, long long a3)
{
long long v4; // rax
_QWORD *v5; // rax
long long v6; // r15
char v8; // [rsp+Bh] [rbp-1ADh] BYREF
int v9; // [rsp+Ch] [rbp-1ACh] BYREF
long long v10; // [rsp+10h] [rbp-1A8h] BYREF
_BYTE v11[416]; // [rsp+18h] [rbp-1A0h] BYREF
std::mutex::lock(a2);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v11, a3, 24LL);
v4 = std::istream::operator>>(v11, &v9);
v5 = (_QWORD *)std::istream::_M_extract<unsigned long>(v4, &v10);
if ( (*((_BYTE *)v5 + *(_QWORD *)(*v5 - 24LL) + 32) & 5) != 0 || (unsigned int)(v9 - 5) <= 0xFFFFFFFB )
{
std::string::basic_string<std::allocator<char>>(a1, "failed", &v8);
}
else
{
v6 = v10;
*(_QWORD *)std::map<int,unsigned long>::operator[]((char *)a2 + 96, &v9) = v6;
std::string::basic_string<std::allocator<char>>(a1, "ok", &v8);
}
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream(v11);
pthread_mutex_unlock(a2);
return a1;
}
| setCount:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x1a0
MOV R15,RDX
MOV RBX,RSI
MOV R14,RDI
MOV RDI,RSI
CALL 0x00106d3c
LAB_00106129:
LEA RDI,[RSP + 0x18]
PUSH 0x18
POP RDX
MOV RSI,R15
CALL 0x00105510
LAB_00106139:
LEA RDI,[RSP + 0x18]
LEA RSI,[RSP + 0xc]
CALL 0x00105210
LEA RSI,[RSP + 0x10]
MOV RDI,RAX
CALL 0x001051d0
MOV RCX,qword ptr [RAX]
MOV RCX,qword ptr [RCX + -0x18]
TEST byte ptr [RAX + RCX*0x1 + 0x20],0x5
JZ 0x00106179
LAB_00106163:
LEA RSI,[0x117208]
LEA RDX,[RSP + 0xb]
MOV RDI,R14
CALL 0x00106a32
JMP 0x001061c5
LAB_00106179:
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,-0x5
CMP EAX,-0x5
JA 0x0010619b
LAB_00106185:
LEA RSI,[0x117208]
LEA RDX,[RSP + 0xb]
MOV RDI,R14
CALL 0x00106a32
JMP 0x001061c5
LAB_0010619b:
MOV R15,qword ptr [RSP + 0x10]
LEA RDI,[RBX + 0x60]
LAB_001061a4:
LEA RSI,[RSP + 0xc]
CALL 0x00106b48
MOV qword ptr [RAX],R15
LAB_001061b1:
LEA RSI,[0x117205]
LEA RDX,[RSP + 0xb]
MOV RDI,R14
CALL 0x00106a32
LAB_001061c5:
LEA RDI,[RSP + 0x18]
CALL 0x001052d0
MOV RDI,RBX
CALL 0x001052e0
MOV RAX,R14
ADD RSP,0x1a0
POP RBX
POP R14
POP R15
RET
|
/* Settings::setCount(std::__cxx11::string const&) */
string * Settings::setCount(string *param_1)
{
ulong *puVar1;
istream *piVar2;
int8 *puVar3;
pthread_mutex_t *in_RSI;
allocator local_1ad;
int local_1ac;
int8 local_1a8;
stringstream local_1a0 [392];
std::mutex::lock();
/* try { // try from 00106129 to 00106138 has its CatchHandler @ 001061ed */
std::__cxx11::stringstream::stringstream(local_1a0);
/* try { // try from 00106139 to 00106154 has its CatchHandler @ 001061f2 */
puVar1 = (ulong *)std::istream::operator>>((istream *)local_1a0,&local_1ac);
piVar2 = std::istream::_M_extract<unsigned_long>(puVar1);
if (((byte)piVar2[*(long *)(*(long *)piVar2 + -0x18) + 0x20] & 5) == 0) {
if (local_1ac - 5U < 0xfffffffc) {
/* try { // try from 00106185 to 00106198 has its CatchHandler @ 001061e9 */
std::__cxx11::string::string<std::allocator<char>>(param_1,"failed",&local_1ad);
}
else {
/* try { // try from 001061a4 to 001061ad has its CatchHandler @ 001061f2 */
puVar3 = (int8 *)
std::
map<int,unsigned_long,std::less<int>,std::allocator<std::pair<int_const,unsigned_long>>>
::operator[]((map<int,unsigned_long,std::less<int>,std::allocator<std::pair<int_const,unsigned_long>>>
*)((long)in_RSI + 0x60),&local_1ac);
*puVar3 = local_1a8;
/* try { // try from 001061b1 to 001061c4 has its CatchHandler @ 001061e7 */
std::__cxx11::string::string<std::allocator<char>>(param_1,"ok",&local_1ad);
}
}
else {
/* try { // try from 00106163 to 00106176 has its CatchHandler @ 001061eb */
std::__cxx11::string::string<std::allocator<char>>(param_1,"failed",&local_1ad);
}
std::__cxx11::stringstream::~stringstream(local_1a0);
pthread_mutex_unlock(in_RSI);
return param_1;
}
| |
41,669 | Settings::setCount(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | 666mxvbee[P]BattleShip/lib/Settings/Settings.cpp | std::string Settings::setCount(const std::string& cmd) {
std::lock_guard<std::mutex> lock(settings_mutex);
std::stringstream ss(cmd);
int typeShip;
uint64_t count;
if (!(ss >> typeShip >> count)) {
return "failed";
}
if (typeShip < 1 || typeShip > 4) {
return "failed";
}
shipCounts[typeShip] = count;
return "ok";
} | O3 | cpp | Settings::setCount(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x5520
testl %eax, %eax
jne 0x675c
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
movl $0x18, %edx
callq 0x5560
leaq 0x18(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x5210
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x51d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x66c8
leaq 0x10(%r14), %rax
movq %rax, (%r14)
leaq 0x13b51(%rip), %rsi # 0x1a208
leaq 0x13b50(%rip), %rdx # 0x1a20e
movq %r14, %rdi
callq 0x5fea
jmp 0x6726
movl 0xc(%rsp), %eax
addl $-0x5, %eax
cmpl $-0x5, %eax
ja 0x66f3
leaq 0x10(%r14), %rax
movq %rax, (%r14)
leaq 0x13b26(%rip), %rsi # 0x1a208
leaq 0x13b25(%rip), %rdx # 0x1a20e
movq %r14, %rdi
callq 0x5fea
jmp 0x6726
movq 0x10(%rsp), %r15
leaq 0x60(%rbx), %rdi
leaq 0xc(%rsp), %rsi
callq 0x7368
movq %r15, (%rax)
leaq 0x10(%r14), %rax
movq %rax, (%r14)
leaq 0x13aee(%rip), %rsi # 0x1a205
leaq 0x13ae9(%rip), %rdx # 0x1a207
movq %r14, %rdi
callq 0x5fea
movq 0x1e82b(%rip), %rsi # 0x24f58
leaq 0x18(%rsp), %rdi
callq 0x52e0
leaq 0x98(%rsp), %rdi
callq 0x50f0
movq %rbx, %rdi
callq 0x52f0
movq %r14, %rax
addq $0x1a0, %rsp # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x5260
jmp 0x676e
jmp 0x676e
jmp 0x676e
movq %rax, %r14
jmp 0x678f
movq %rax, %r14
movq 0x1e7e0(%rip), %rsi # 0x24f58
leaq 0x18(%rsp), %rdi
callq 0x52e0
leaq 0x98(%rsp), %rdi
callq 0x50f0
movq %rbx, %rdi
callq 0x52f0
movq %r14, %rdi
callq 0x5600
nop
| _ZN8Settings8setCountERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push rbx
sub rsp, 1A0h
mov r15, rdx
mov rbx, rsi
mov r14, rdi
mov rdi, rsi
call _pthread_mutex_lock
test eax, eax
jnz loc_675C
lea rdi, [rsp+1B8h+var_1A0]
mov rsi, r15
mov edx, 18h
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1ERKNS_12basic_stringIcS2_S3_EESt13_Ios_Openmode; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(std::string const&,std::_Ios_Openmode)
lea rdi, [rsp+1B8h+var_1A0]
lea rsi, [rsp+1B8h+var_1AC]
call __ZNSirsERi; std::istream::operator>>(int &)
lea rsi, [rsp+1B8h+var_1A8]
mov rdi, rax
call __ZNSi10_M_extractImEERSiRT_; std::istream::_M_extract<ulong>(ulong &)
mov rcx, [rax]
mov rcx, [rcx-18h]
test byte ptr [rax+rcx+20h], 5
jz short loc_66C8
lea rax, [r14+10h]
mov [r14], rax
lea rsi, aFailed; "failed"
lea rdx, aFailed+6; ""
mov rdi, r14
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)
jmp short loc_6726
loc_66C8:
mov eax, [rsp+1B8h+var_1AC]
add eax, 0FFFFFFFBh
cmp eax, 0FFFFFFFBh
ja short loc_66F3
lea rax, [r14+10h]
mov [r14], rax
lea rsi, aFailed; "failed"
lea rdx, aFailed+6; ""
mov rdi, r14
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)
jmp short loc_6726
loc_66F3:
mov r15, [rsp+1B8h+var_1A8]
lea rdi, [rbx+60h]
lea rsi, [rsp+1B8h+var_1AC]
call _ZNSt3mapIimSt4lessIiESaISt4pairIKimEEEixERS3_; std::map<int,ulong>::operator[](int const&)
mov [rax], r15
lea rax, [r14+10h]
mov [r14], rax
lea rsi, aOk; "ok"
lea rdx, aOk+2; ""
mov rdi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
loc_6726:
mov rsi, cs:_ZTTNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+1B8h+var_1A0]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED2Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
lea rdi, [rsp+1B8h+var_120]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rdi, rbx
call _pthread_mutex_unlock
mov rax, r14
add rsp, 1A0h
pop rbx
pop r14
pop r15
retn
loc_675C:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
jmp short loc_676E
jmp short loc_676E
jmp short loc_676E
mov r14, rax
jmp short loc_678F
loc_676E:
mov r14, rax
mov rsi, cs:_ZTTNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+1B8h+var_1A0]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED2Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
lea rdi, [rsp+1B8h+var_120]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
loc_678F:
mov rdi, rbx
call _pthread_mutex_unlock
mov rdi, r14
call __Unwind_Resume
| _QWORD * Settings::setCount(_QWORD *a1, long long a2, long long a3)
{
int v4; // eax
long long v5; // rax
_QWORD *v6; // rax
long long v7; // r15
int v9; // [rsp+Ch] [rbp-1ACh] BYREF
long long v10; // [rsp+10h] [rbp-1A8h] BYREF
_BYTE v11[128]; // [rsp+18h] [rbp-1A0h] BYREF
_BYTE v12[288]; // [rsp+98h] [rbp-120h] BYREF
v4 = pthread_mutex_lock(a2);
if ( v4 )
std::__throw_system_error(v4);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v11, a3, 24LL);
v5 = std::istream::operator>>(v11, &v9);
v6 = (_QWORD *)std::istream::_M_extract<unsigned long>(v5, &v10);
if ( (*((_BYTE *)v6 + *(_QWORD *)(*v6 - 24LL) + 32) & 5) != 0 || (unsigned int)(v9 - 5) <= 0xFFFFFFFB )
{
*a1 = a1 + 2;
std::string::_M_construct<char const*>((long long)a1, "failed", (long long)"");
}
else
{
v7 = v10;
*(_QWORD *)std::map<int,unsigned long>::operator[](a2 + 96, &v9) = v7;
*a1 = a1 + 2;
std::string::_M_construct<char const*>((long long)a1, "ok", (long long)"");
}
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream(
v11,
&`VTT for'std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>);
std::ios_base::~ios_base((std::ios_base *)v12);
pthread_mutex_unlock(a2);
return a1;
}
| setCount:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x1a0
MOV R15,RDX
MOV RBX,RSI
MOV R14,RDI
MOV RDI,RSI
CALL 0x00105520
TEST EAX,EAX
JNZ 0x0010675c
LAB_0010666d:
LEA RDI,[RSP + 0x18]
MOV RSI,R15
MOV EDX,0x18
CALL 0x00105560
LAB_0010667f:
LEA RDI,[RSP + 0x18]
LEA RSI,[RSP + 0xc]
CALL 0x00105210
LEA RSI,[RSP + 0x10]
MOV RDI,RAX
CALL 0x001051d0
MOV RCX,qword ptr [RAX]
MOV RCX,qword ptr [RCX + -0x18]
TEST byte ptr [RAX + RCX*0x1 + 0x20],0x5
JZ 0x001066c8
LEA RAX,[R14 + 0x10]
MOV qword ptr [R14],RAX
LAB_001066b0:
LEA RSI,[0x11a208]
LEA RDX,[0x11a20e]
MOV RDI,R14
CALL 0x00105fea
JMP 0x00106726
LAB_001066c8:
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,-0x5
CMP EAX,-0x5
JA 0x001066f3
LEA RAX,[R14 + 0x10]
MOV qword ptr [R14],RAX
LAB_001066db:
LEA RSI,[0x11a208]
LEA RDX,[0x11a20e]
MOV RDI,R14
CALL 0x00105fea
JMP 0x00106726
LAB_001066f3:
MOV R15,qword ptr [RSP + 0x10]
LEA RDI,[RBX + 0x60]
LAB_001066fc:
LEA RSI,[RSP + 0xc]
CALL 0x00107368
MOV qword ptr [RAX],R15
LEA RAX,[R14 + 0x10]
MOV qword ptr [R14],RAX
LAB_00106710:
LEA RSI,[0x11a205]
LEA RDX,[0x11a207]
MOV RDI,R14
CALL 0x00105fea
LAB_00106726:
MOV RSI,qword ptr [0x00124f58]
LEA RDI,[RSP + 0x18]
CALL 0x001052e0
LEA RDI,[RSP + 0x98]
CALL 0x001050f0
MOV RDI,RBX
CALL 0x001052f0
MOV RAX,R14
ADD RSP,0x1a0
POP RBX
POP R14
POP R15
RET
LAB_0010675c:
MOV EDI,EAX
CALL 0x00105260
|
/* Settings::setCount(std::__cxx11::string const&) */
string * Settings::setCount(string *param_1)
{
int iVar1;
ulong *puVar2;
istream *piVar3;
int8 *puVar4;
pthread_mutex_t *in_RSI;
int local_1ac;
int8 local_1a8;
stringstream local_1a0 [128];
ios_base local_120 [264];
iVar1 = pthread_mutex_lock(in_RSI);
if (iVar1 == 0) {
/* try { // try from 0010666d to 0010667e has its CatchHandler @ 00106769 */
std::__cxx11::stringstream::stringstream(local_1a0);
/* try { // try from 0010667f to 0010669a has its CatchHandler @ 0010676e */
puVar2 = (ulong *)std::istream::operator>>((istream *)local_1a0,&local_1ac);
piVar3 = std::istream::_M_extract<unsigned_long>(puVar2);
if (((byte)piVar3[*(long *)(*(long *)piVar3 + -0x18) + 0x20] & 5) == 0) {
if (local_1ac - 5U < 0xfffffffc) {
*(string **)param_1 = param_1 + 0x10;
/* try { // try from 001066db to 001066f0 has its CatchHandler @ 00106765 */
std::__cxx11::string::_M_construct<char_const*>(param_1,"failed","");
}
else {
/* try { // try from 001066fc to 00106705 has its CatchHandler @ 0010676e */
puVar4 = (int8 *)
std::
map<int,unsigned_long,std::less<int>,std::allocator<std::pair<int_const,unsigned_long>>>
::operator[]((map<int,unsigned_long,std::less<int>,std::allocator<std::pair<int_const,unsigned_long>>>
*)((long)in_RSI + 0x60),&local_1ac);
*puVar4 = local_1a8;
*(string **)param_1 = param_1 + 0x10;
/* try { // try from 00106710 to 00106725 has its CatchHandler @ 00106763 */
std::__cxx11::string::_M_construct<char_const*>(param_1,&DAT_0011a205,&DAT_0011a207);
}
}
else {
*(string **)param_1 = param_1 + 0x10;
/* try { // try from 001066b0 to 001066c5 has its CatchHandler @ 00106767 */
std::__cxx11::string::_M_construct<char_const*>(param_1,"failed","");
}
std::__cxx11::stringstream::~stringstream(local_1a0);
std::ios_base::~ios_base(local_120);
pthread_mutex_unlock(in_RSI);
return param_1;
}
/* WARNING: Subroutine does not return */
std::__throw_system_error(iVar1);
}
| |
41,670 | delete_prepared_stmt(PFS_prepared_stmt*) | eloqsql/storage/perfschema/pfs_prepared_stmt.cc | void delete_prepared_stmt(PFS_prepared_stmt *pfs)
{
global_prepared_stmt_container.deallocate(pfs);
return;
} | O3 | cpp | delete_prepared_stmt(PFS_prepared_stmt*):
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movl (%rdi), %ecx
andl $-0x4, %ecx
xchgl %ecx, (%rdi)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x3823b2(%rip), %rax # 0x3c3e58
movb %cl, 0x9(%rax)
popq %rbp
retq
nop
| _Z20delete_prepared_stmtP17PFS_prepared_stmt:
push rbp
mov rbp, rsp
mov rax, [rdi+8]
mov ecx, [rdi]
and ecx, 0FFFFFFFCh
xchg ecx, [rdi]
xor ecx, ecx
mov [rax], cl
lea rax, global_prepared_stmt_container
mov [rax+9], cl
pop rbp
retn
| long long * delete_prepared_stmt(PFS_prepared_stmt *a1)
{
_BYTE *v1; // rax
long long *result; // rax
v1 = (_BYTE *)*((_QWORD *)a1 + 1);
_InterlockedExchange((volatile __int32 *)a1, *(_DWORD *)a1 & 0xFFFFFFFC);
*v1 = 0;
result = global_prepared_stmt_container;
BYTE1(global_prepared_stmt_container[1]) = 0;
return result;
}
| delete_prepared_stmt:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI + 0x8]
MOV ECX,dword ptr [RDI]
AND ECX,0xfffffffc
XCHG dword ptr [RDI],ECX
XOR ECX,ECX
MOV byte ptr [RAX],CL
LEA RAX,[0x4c3e58]
MOV byte ptr [RAX + 0x9],CL
POP RBP
RET
|
/* delete_prepared_stmt(PFS_prepared_stmt*) */
void delete_prepared_stmt(PFS_prepared_stmt *param_1)
{
LOCK();
*(uint *)param_1 = *(uint *)param_1 & 0xfffffffc;
UNLOCK();
**(int1 **)(param_1 + 8) = 0;
global_prepared_stmt_container[9] = 0;
return;
}
| |
41,671 | long minja::Value::get<long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long) const | monkey531[P]llama/common/./minja.hpp | T get(const std::string & key, T default_value) const {
if (!contains(key)) return default_value;
return at(key).get<T>();
} | O1 | cpp | long minja::Value::get<long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long) const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x566b4
testb %al, %al
je 0x72f6a
movq %rsp, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x43cba
movq %r14, %rdi
movq %rbx, %rsi
callq 0x56278
movq %rax, %rdi
callq 0x3f0b2
movq %rax, %rbx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3efdc
movq %r14, %rdi
callq 0x4bfb8
movq -0x8(%r14), %rdi
testq %rdi, %rdi
je 0x72f16
callq 0x30e64
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x72f25
callq 0x30e64
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x72f34
callq 0x30e64
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x72f6a
movq 0x8005b(%rip), %rax # 0xf2fa0
cmpb $0x0, (%rax)
je 0x72f55
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x72f5f
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x72f6a
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3ef50
movq %rbx, %rdi
callq 0x18b90
| _ZNK5minja5Value3getIlEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES2_:
push r15
push r14
push rbx
sub rsp, 50h
mov rbx, rdx
mov r15, rsi
mov r14, rdi
call _ZNK5minja5Value8containsERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::contains(std::string const&)
test al, al
jz loc_72F6A
mov rbx, rsp
mov rdi, rbx
mov rsi, r15
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
mov rdi, r14; this
mov rsi, rbx; minja::Value *
call _ZN5minja5Value2atERKS0_; minja::Value::at(minja::Value const&)
mov rdi, rax
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
mov rbx, rax
lea r14, [rsp+68h+var_28]
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_72F16
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_72F16:
mov rdi, [rsp+68h+var_40]
test rdi, rdi
jz short loc_72F25
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_72F25:
mov rdi, [rsp+68h+var_50]
test rdi, rdi
jz short loc_72F34
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_72F34:
mov rdi, [rsp+68h+var_60]
test rdi, rdi
jz short loc_72F6A
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_72F55
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_72F5F
loc_72F55:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_72F5F:
cmp eax, 1
jnz short loc_72F6A
mov rax, [rdi]
call qword ptr [rax+18h]
loc_72F6A:
mov rax, rbx
add rsp, 50h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rdi, rsp; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rdi, rbx
call __Unwind_Resume
| long long minja::Value::get<long>(minja::Value *this, long long a2, long long a3)
{
unsigned long long v4; // rax
long long v5; // rdi
signed __int32 v6; // eax
__int128 v8; // [rsp+0h] [rbp-68h] BYREF
volatile signed __int32 *v9; // [rsp+18h] [rbp-50h]
volatile signed __int32 *v10; // [rsp+28h] [rbp-40h]
volatile signed __int32 *v11; // [rsp+38h] [rbp-30h]
void *v12[5]; // [rsp+40h] [rbp-28h] BYREF
if ( minja::Value::contains((long long)this) )
{
minja::Value::Value(&v8);
v4 = minja::Value::at(this, (const minja::Value *)&v8);
a3 = minja::Value::get<long>(v4);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v12);
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(v12);
if ( v11 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v11);
if ( v10 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v10);
if ( v9 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v9);
v5 = *((_QWORD *)&v8 + 1);
if ( *((_QWORD *)&v8 + 1) )
{
if ( _libc_single_threaded )
{
v6 = *(_DWORD *)(*((_QWORD *)&v8 + 1) + 12LL);
*(_DWORD *)(*((_QWORD *)&v8 + 1) + 12LL) = v6 - 1;
}
else
{
v6 = _InterlockedExchangeAdd((volatile signed __int32 *)(*((_QWORD *)&v8 + 1) + 12LL), 0xFFFFFFFF);
}
if ( v6 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v5 + 24LL))(v5, 0LL);
}
}
return a3;
}
| get<long>:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV RBX,RDX
MOV R15,RSI
MOV R14,RDI
CALL 0x001566b4
TEST AL,AL
JZ 0x00172f6a
MOV RBX,RSP
MOV RDI,RBX
MOV RSI,R15
CALL 0x00143cba
LAB_00172edb:
MOV RDI,R14
MOV RSI,RBX
CALL 0x00156278
MOV RDI,RAX
CALL 0x0013f0b2
LAB_00172eee:
MOV RBX,RAX
LEA R14,[RSP + 0x40]
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013efdc
MOV RDI,R14
CALL 0x0014bfb8
MOV RDI,qword ptr [R14 + -0x8]
TEST RDI,RDI
JZ 0x00172f16
CALL 0x00130e64
LAB_00172f16:
MOV RDI,qword ptr [RSP + 0x28]
TEST RDI,RDI
JZ 0x00172f25
CALL 0x00130e64
LAB_00172f25:
MOV RDI,qword ptr [RSP + 0x18]
TEST RDI,RDI
JZ 0x00172f34
CALL 0x00130e64
LAB_00172f34:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x00172f6a
MOV RAX,qword ptr [0x001f2fa0]
CMP byte ptr [RAX],0x0
JZ 0x00172f55
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x00172f5f
LAB_00172f55:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_00172f5f:
CMP EAX,0x1
JNZ 0x00172f6a
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_00172f6a:
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R14
POP R15
RET
|
/* long minja::Value::get<long>(std::__cxx11::string const&, long) const */
long __thiscall minja::Value::get<long>(Value *this,string *param_1,long param_2)
{
int *piVar1;
char cVar2;
int iVar3;
Value *this_00;
Value aVStack_68 [8];
long *local_60;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_50;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_40;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_30;
data local_28 [16];
cVar2 = contains(this,param_1);
if (cVar2 != '\0') {
Value(aVStack_68,param_1);
/* try { // try from 00172edb to 00172eed has its CatchHandler @ 00172f77 */
this_00 = (Value *)at(this,aVStack_68);
param_2 = get<long>(this_00);
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_28,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_28);
if (local_30 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_30);
}
if (local_40 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_40);
}
if (local_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 != (long *)0x0) {
if (*PTR___libc_single_threaded_001f2fa0 == '\0') {
LOCK();
piVar1 = (int *)((long)local_60 + 0xc);
iVar3 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)((long)local_60 + 0xc);
*(int *)((long)local_60 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
(**(code **)(*local_60 + 0x18))();
}
}
}
return param_2;
}
| |
41,672 | long minja::Value::get<long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long) const | monkey531[P]llama/common/./minja.hpp | T get(const std::string & key, T default_value) const {
if (!contains(key)) return default_value;
return at(key).get<T>();
} | O3 | cpp | long minja::Value::get<long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long) const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x54c40
testb %al, %al
je 0x7125e
movq %rsp, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x425aa
movq %r14, %rdi
movq %rbx, %rsi
callq 0x547e2
movq %rax, %rdi
callq 0x3da46
movq %rax, %rbx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3d970
movq %r14, %rdi
callq 0x4a5c0
movq -0x8(%r14), %rdi
testq %rdi, %rdi
je 0x7120a
callq 0x2f80e
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x71219
callq 0x2f80e
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x71228
callq 0x2f80e
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x7125e
movq 0x7ed67(%rip), %rax # 0xeffa0
cmpb $0x0, (%rax)
je 0x71249
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x71253
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x7125e
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3d8e4
movq %rbx, %rdi
callq 0x18b90
| _ZNK5minja5Value3getIlEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES2_:
push r15
push r14
push rbx
sub rsp, 50h
mov rbx, rdx
mov r15, rsi
mov r14, rdi
call _ZNK5minja5Value8containsERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::contains(std::string const&)
test al, al
jz loc_7125E
mov rbx, rsp
mov rdi, rbx
mov rsi, r15
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
mov rdi, r14; this
mov rsi, rbx; minja::Value *
call _ZN5minja5Value2atERKS0_; minja::Value::at(minja::Value const&)
mov rdi, rax
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
mov rbx, rax
lea r14, [rsp+68h+var_28]
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_7120A
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_7120A:
mov rdi, [rsp+68h+var_40]
test rdi, rdi
jz short loc_71219
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_71219:
mov rdi, [rsp+68h+var_50]
test rdi, rdi
jz short loc_71228
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_71228:
mov rdi, [rsp+68h+var_60]
test rdi, rdi
jz short loc_7125E
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_71249
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_71253
loc_71249:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_71253:
cmp eax, 1
jnz short loc_7125E
mov rax, [rdi]
call qword ptr [rax+18h]
loc_7125E:
mov rax, rbx
add rsp, 50h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rdi, rsp; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rdi, rbx
call __Unwind_Resume
| long long minja::Value::get<long>(minja::Value *this, long long a2, long long a3)
{
unsigned long long v4; // rax
long long v5; // rdi
signed __int32 v6; // eax
__int128 v8; // [rsp+0h] [rbp-68h] BYREF
volatile signed __int32 *v9; // [rsp+18h] [rbp-50h]
volatile signed __int32 *v10; // [rsp+28h] [rbp-40h]
volatile signed __int32 *v11; // [rsp+38h] [rbp-30h]
void **v12[5]; // [rsp+40h] [rbp-28h] BYREF
if ( minja::Value::contains((long long)this) )
{
minja::Value::Value(&v8);
v4 = minja::Value::at(this, (const minja::Value *)&v8);
a3 = minja::Value::get<long>(v4);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v12);
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(v12);
if ( v11 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v11);
if ( v10 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v10);
if ( v9 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v9);
v5 = *((_QWORD *)&v8 + 1);
if ( *((_QWORD *)&v8 + 1) )
{
if ( _libc_single_threaded )
{
v6 = *(_DWORD *)(*((_QWORD *)&v8 + 1) + 12LL);
*(_DWORD *)(*((_QWORD *)&v8 + 1) + 12LL) = v6 - 1;
}
else
{
v6 = _InterlockedExchangeAdd((volatile signed __int32 *)(*((_QWORD *)&v8 + 1) + 12LL), 0xFFFFFFFF);
}
if ( v6 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v5 + 24LL))(v5, 0LL);
}
}
return a3;
}
| get<long>:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV RBX,RDX
MOV R15,RSI
MOV R14,RDI
CALL 0x00154c40
TEST AL,AL
JZ 0x0017125e
MOV RBX,RSP
MOV RDI,RBX
MOV RSI,R15
CALL 0x001425aa
LAB_001711cf:
MOV RDI,R14
MOV RSI,RBX
CALL 0x001547e2
MOV RDI,RAX
CALL 0x0013da46
LAB_001711e2:
MOV RBX,RAX
LEA R14,[RSP + 0x40]
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013d970
MOV RDI,R14
CALL 0x0014a5c0
MOV RDI,qword ptr [R14 + -0x8]
TEST RDI,RDI
JZ 0x0017120a
CALL 0x0012f80e
LAB_0017120a:
MOV RDI,qword ptr [RSP + 0x28]
TEST RDI,RDI
JZ 0x00171219
CALL 0x0012f80e
LAB_00171219:
MOV RDI,qword ptr [RSP + 0x18]
TEST RDI,RDI
JZ 0x00171228
CALL 0x0012f80e
LAB_00171228:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x0017125e
MOV RAX,qword ptr [0x001effa0]
CMP byte ptr [RAX],0x0
JZ 0x00171249
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x00171253
LAB_00171249:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_00171253:
CMP EAX,0x1
JNZ 0x0017125e
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_0017125e:
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R14
POP R15
RET
|
/* long minja::Value::get<long>(std::__cxx11::string const&, long) const */
long __thiscall minja::Value::get<long>(Value *this,string *param_1,long param_2)
{
int *piVar1;
char cVar2;
int iVar3;
Value *this_00;
Value aVStack_68 [8];
long *local_60;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_50;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_40;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_30;
data local_28 [16];
cVar2 = contains(this,param_1);
if (cVar2 != '\0') {
Value(aVStack_68,param_1);
/* try { // try from 001711cf to 001711e1 has its CatchHandler @ 0017126b */
this_00 = (Value *)at(this,aVStack_68);
param_2 = get<long>(this_00);
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_28,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_28);
if (local_30 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_30);
}
if (local_40 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_40);
}
if (local_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 != (long *)0x0) {
if (*PTR___libc_single_threaded_001effa0 == '\0') {
LOCK();
piVar1 = (int *)((long)local_60 + 0xc);
iVar3 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)((long)local_60 + 0xc);
*(int *)((long)local_60 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
(**(code **)(*local_60 + 0x18))();
}
}
}
return param_2;
}
| |
41,673 | ulight::css::match_ident_like_token(std::basic_string_view<char8_t, std::char_traits<char8_t>>) | ulight/src/main/cpp/css.cpp | Ident_Result match_ident_like_token(std::u8string_view str)
{
// https://www.w3.org/TR/css-syntax-3/#consume-ident-like-token
// We deviate from the CSS algorithm in the regard that we don't consume the following
// parenthesis or the following URL, just the identifier.
const std::size_t length = match_ident_sequence(str);
const std::u8string_view result = str.substr(length);
if (length == str.length() || str[length] != u8'(') {
return { .length = length, .type = Ident_Type::ident };
}
if (equals_ascii_ignore_case(result, u8"url")) {
return { .length = length, .type = Ident_Type::url };
}
return { .length = length, .type = Ident_Type::function };
} | O0 | cpp | ulight::css::match_ident_like_token(std::basic_string_view<char8_t, std::char_traits<char8_t>>):
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xe0c0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq $-0x1, %rdx
callq 0xb1d0
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6d60
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
je 0xe22f
movq -0x28(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0xb3a0
movzbl (%rax), %eax
cmpl $0x28, %eax
je 0xe23d
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movb $0x0, -0x8(%rbp)
jmp 0xe292
movq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x68(%rbp), %rdi
leaq 0xdfe4(%rip), %rsi # 0x1c23c
callq 0x6d80
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq -0x60(%rbp), %rcx
callq 0xf6d0
testb $0x1, %al
jne 0xe278
jmp 0xe286
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movb $0x2, -0x8(%rbp)
jmp 0xe292
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movb $0x1, -0x8(%rbp)
movq -0x10(%rbp), %rax
movb -0x8(%rbp), %dl
addq $0x70, %rsp
popq %rbp
retq
nop
| _ZN6ulight3css22match_ident_like_tokenESt17basic_string_viewIDuSt11char_traitsIDuEE:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_20], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_20]
mov [rbp+var_38], rax
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_30]
call _ZN6ulight3css20match_ident_sequenceESt17basic_string_viewIDuSt11char_traitsIDuEE; ulight::css::match_ident_sequence(std::u8string_view)
mov [rbp+var_28], rax
mov rsi, [rbp+var_28]
lea rdi, [rbp+var_20]
mov rdx, 0FFFFFFFFFFFFFFFFh
call _ZNKSt17basic_string_viewIDuSt11char_traitsIDuEE6substrEmm; std::u8string_view::substr(ulong,ulong)
mov [rbp+var_48], rax
mov [rbp+var_40], rdx
mov rax, [rbp+var_28]
mov [rbp+var_70], rax
lea rdi, [rbp+var_20]
call _ZNKSt17basic_string_viewIDuSt11char_traitsIDuEE6lengthEv; std::u8string_view::length(void)
mov rcx, rax
mov rax, [rbp+var_70]
cmp rax, rcx
jz short loc_E22F
mov rsi, [rbp+var_28]
lea rdi, [rbp+var_20]
call _ZNKSt17basic_string_viewIDuSt11char_traitsIDuEEixEm; std::u8string_view::operator[](ulong)
movzx eax, byte ptr [rax]
cmp eax, 28h ; '('
jz short loc_E23D
loc_E22F:
mov rax, [rbp+var_28]
mov [rbp+var_10], rax
mov [rbp+var_8], 0
jmp short loc_E292
loc_E23D:
mov rax, [rbp+var_48]
mov [rbp+var_58], rax
mov rax, [rbp+var_40]
mov [rbp+var_50], rax
lea rdi, [rbp+var_68]
lea rsi, aUrl; "url"
call _ZNSt17basic_string_viewIDuSt11char_traitsIDuEEC2EPKDu; std::u8string_view::basic_string_view(char8_t const*)
mov rdi, [rbp+var_58]
mov rsi, [rbp+var_50]
mov rdx, [rbp+var_68]
mov rcx, [rbp+var_60]
call _ZN6ulight24equals_ascii_ignore_caseESt17basic_string_viewIDuSt11char_traitsIDuEES3_; ulight::equals_ascii_ignore_case(std::u8string_view,std::u8string_view)
test al, 1
jnz short loc_E278
jmp short loc_E286
loc_E278:
mov rax, [rbp+var_28]
mov [rbp+var_10], rax
mov [rbp+var_8], 2
jmp short loc_E292
loc_E286:
mov rax, [rbp+var_28]
mov [rbp+var_10], rax
mov [rbp+var_8], 1
loc_E292:
mov rax, [rbp+var_10]
mov dl, [rbp+var_8]
add rsp, 70h
pop rbp
retn
| unsigned long long ulight::css::match_ident_like_token(long long a1, long long a2)
{
long long v2; // rdx
long long v4[2]; // [rsp+8h] [rbp-68h] BYREF
long long v5; // [rsp+18h] [rbp-58h]
long long v6; // [rsp+20h] [rbp-50h]
long long v7; // [rsp+28h] [rbp-48h]
long long v8; // [rsp+30h] [rbp-40h]
long long v9; // [rsp+38h] [rbp-38h]
long long v10; // [rsp+40h] [rbp-30h]
unsigned long long matched; // [rsp+48h] [rbp-28h]
_QWORD v12[2]; // [rsp+50h] [rbp-20h] BYREF
unsigned long long v13; // [rsp+60h] [rbp-10h]
char v14; // [rsp+68h] [rbp-8h]
v12[0] = a1;
v12[1] = a2;
v9 = a1;
v10 = a2;
matched = ulight::css::match_ident_sequence(a1, a2);
v7 = std::u8string_view::substr(v12, matched, -1LL);
v8 = v2;
if ( matched != std::u8string_view::length((long long)v12)
&& *(_BYTE *)std::u8string_view::operator[]((long long)v12, matched) == 40 )
{
v5 = v7;
v6 = v8;
std::u8string_view::basic_string_view(v4, (long long)"url");
if ( (ulight::equals_ascii_ignore_case(v5, v6, v4[0], v4[1]) & 1) != 0 )
{
v13 = matched;
v14 = 2;
}
else
{
v13 = matched;
v14 = 1;
}
}
else
{
v13 = matched;
v14 = 0;
}
return v13;
}
| match_ident_like_token:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x20],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x0010e0c0
MOV qword ptr [RBP + -0x28],RAX
MOV RSI,qword ptr [RBP + -0x28]
LEA RDI,[RBP + -0x20]
MOV RDX,-0x1
CALL 0x0010b1d0
MOV qword ptr [RBP + -0x48],RAX
MOV qword ptr [RBP + -0x40],RDX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x70],RAX
LEA RDI,[RBP + -0x20]
CALL 0x00106d60
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x70]
CMP RAX,RCX
JZ 0x0010e22f
MOV RSI,qword ptr [RBP + -0x28]
LEA RDI,[RBP + -0x20]
CALL 0x0010b3a0
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x28
JZ 0x0010e23d
LAB_0010e22f:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x10],RAX
MOV byte ptr [RBP + -0x8],0x0
JMP 0x0010e292
LAB_0010e23d:
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x50],RAX
LEA RDI,[RBP + -0x68]
LEA RSI,[0x11c23c]
CALL 0x00106d80
MOV RDI,qword ptr [RBP + -0x58]
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x60]
CALL 0x0010f6d0
TEST AL,0x1
JNZ 0x0010e278
JMP 0x0010e286
LAB_0010e278:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x10],RAX
MOV byte ptr [RBP + -0x8],0x2
JMP 0x0010e292
LAB_0010e286:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x10],RAX
MOV byte ptr [RBP + -0x8],0x1
LAB_0010e292:
MOV RAX,qword ptr [RBP + -0x10]
MOV DL,byte ptr [RBP + -0x8]
ADD RSP,0x70
POP RBP
RET
|
/* ulight::css::match_ident_like_token(std::basic_string_view<char8_t, std::char_traits<char8_t> >)
*/
int1 [16] __thiscall ulight::css::match_ident_like_token(css *this,int8 param_2)
{
ulong uVar1;
int8 uVar2;
int1 auVar3 [16];
int8 local_70;
int8 local_68;
int1 local_60 [16];
int1 local_50 [16];
css *local_40;
int8 local_38;
ulong local_30;
css *local_28;
int8 local_20;
ulong local_18;
int1 local_10;
local_40 = this;
local_38 = param_2;
local_28 = this;
local_20 = param_2;
local_30 = match_ident_sequence(this,param_2);
local_50 = std::basic_string_view<char8_t,std::char_traits<char8_t>>::substr
((basic_string_view<char8_t,std::char_traits<char8_t>> *)&local_28,local_30,
0xffffffffffffffff);
uVar1 = local_30;
auVar3 = std::basic_string_view<char8_t,std::char_traits<char8_t>>::length
((basic_string_view<char8_t,std::char_traits<char8_t>> *)&local_28);
uVar2 = auVar3._8_8_;
if (uVar1 != auVar3._0_8_) {
auVar3 = std::basic_string_view<char8_t,std::char_traits<char8_t>>::operator[]
((basic_string_view<char8_t,std::char_traits<char8_t>> *)&local_28,local_30);
uVar2 = auVar3._8_8_;
if (*auVar3._0_8_ == '(') {
local_60 = local_50;
std::basic_string_view<char8_t,std::char_traits<char8_t>>::basic_string_view
((basic_string_view<char8_t,std::char_traits<char8_t>> *)&local_70,"url");
auVar3 = equals_ascii_ignore_case(local_60._0_8_,local_60._8_8_,local_70,local_68);
uVar2 = auVar3._8_8_;
if ((auVar3 & (int1 [16])0x1) == (int1 [16])0x0) {
local_18 = local_30;
local_10 = 1;
}
else {
local_18 = local_30;
local_10 = 2;
}
goto LAB_0010e292;
}
}
local_18 = local_30;
local_10 = 0;
LAB_0010e292:
auVar3._9_7_ = (int7)((ulong)uVar2 >> 8);
auVar3[8] = local_10;
auVar3._0_8_ = local_18;
return auVar3;
}
| |
41,674 | OpenSubdiv::v3_6_0::Bfr::Surface<double>::computeIrregularPatchPoints(double*, OpenSubdiv::v3_6_0::Bfr::Surface<double>::PointDescriptor const&) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/surface.cpp | void
Surface<REAL>::computeIrregularPatchPoints(REAL pointData[],
PointDescriptor const & pointDesc) const {
//
// An "irregular patch" may be represented by a regular patch in
// rare cases, so be sure there are patch points to compute:
//
internal::IrregularPatchType const & irregPatch = getIrregPatch();
int numControlPoints = GetNumControlPoints();
int numPatchPoints = irregPatch.GetNumPointsTotal();
if (numPatchPoints == numControlPoints) return;
//
// Assemble parameters of the point combination operation and apply:
//
typedef points::CombineConsecutive<REAL> PointCombiner;
typename PointCombiner::Parameters combParams;
combParams.pointData = pointData;
combParams.pointSize = pointDesc.size;
combParams.pointStride = pointDesc.stride;
combParams.srcCount = numControlPoints;
combParams.resultCount = numPatchPoints - numControlPoints;
combParams.resultData = pointData + pointDesc.stride * numControlPoints;
combParams.weightData = irregPatch.GetStencilMatrix<REAL>();
PointCombiner::Apply(combParams);
} | O0 | cpp | OpenSubdiv::v3_6_0::Bfr::Surface<double>::computeIrregularPatchPoints(double*, OpenSubdiv::v3_6_0::Bfr::Surface<double>::PointDescriptor const&) const:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xd6480
movq -0x58(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0xce660
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd2340
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jne 0x1adf77
jmp 0x1adfd4
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x28(%rbp), %eax
subl -0x24(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
imull -0x24(%rbp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0xca480
movq %rax, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xc6210
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ZNK10OpenSubdiv6v3_6_03Bfr7SurfaceIdE27computeIrregularPatchPointsEPdRKNS3_15PointDescriptorE:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rdi, [rbp+var_8]
mov [rbp+var_58], rdi
call __ZNK10OpenSubdiv6v3_6_03Bfr7SurfaceIdE13getIrregPatchEv; OpenSubdiv::v3_6_0::Bfr::Surface<double>::getIrregPatch(void)
mov rdi, [rbp+var_58]
mov [rbp+var_20], rax
call __ZNK10OpenSubdiv6v3_6_03Bfr7SurfaceIdE19GetNumControlPointsEv; OpenSubdiv::v3_6_0::Bfr::Surface<double>::GetNumControlPoints(void)
mov [rbp+var_24], eax
mov rdi, [rbp+var_20]; this
call __ZNK10OpenSubdiv6v3_6_03Bfr9PatchTree17GetNumPointsTotalEv; OpenSubdiv::v3_6_0::Bfr::PatchTree::GetNumPointsTotal(void)
mov [rbp+var_28], eax
mov eax, [rbp+var_28]
cmp eax, [rbp+var_24]
jnz short loc_1ADF77
jmp short loc_1ADFD4
loc_1ADF77:
mov rax, [rbp+var_10]
mov [rbp+var_50], rax
mov rax, [rbp+var_18]
mov eax, [rax]
mov [rbp+var_48], eax
mov rax, [rbp+var_18]
mov eax, [rax+4]
mov [rbp+var_44], eax
mov eax, [rbp+var_24]
mov [rbp+var_40], eax
mov eax, [rbp+var_28]
sub eax, [rbp+var_24]
mov [rbp+var_3C], eax
mov rax, [rbp+var_10]
mov rcx, [rbp+var_18]
mov ecx, [rcx+4]
imul ecx, [rbp+var_24]
movsxd rcx, ecx
shl rcx, 3
add rax, rcx
mov [rbp+var_38], rax
mov rdi, [rbp+var_20]
call __ZNK10OpenSubdiv6v3_6_03Bfr9PatchTree16GetStencilMatrixIdEEPKT_v; OpenSubdiv::v3_6_0::Bfr::PatchTree::GetStencilMatrix<double>(void)
mov [rbp+var_30], rax
lea rdi, [rbp+var_50]
call __ZN10OpenSubdiv6v3_6_03Bfr6points18CombineConsecutiveIdE5ApplyERKNS4_10ParametersE; OpenSubdiv::v3_6_0::Bfr::points::CombineConsecutive<double>::Apply(OpenSubdiv::v3_6_0::Bfr::points::CombineConsecutive<double>::Parameters const&)
loc_1ADFD4:
add rsp, 60h
pop rbp
retn
| long long OpenSubdiv::v3_6_0::Bfr::Surface<double>::computeIrregularPatchPoints(
OpenSubdiv::v3_6_0::Bfr::internal::SurfaceData *a1,
long long a2,
int *a3)
{
long long result; // rax
long long v4; // [rsp+10h] [rbp-50h] BYREF
int v5; // [rsp+18h] [rbp-48h]
int v6; // [rsp+1Ch] [rbp-44h]
int v7; // [rsp+20h] [rbp-40h]
int v8; // [rsp+24h] [rbp-3Ch]
long long v9; // [rsp+28h] [rbp-38h]
long long Stencil; // [rsp+30h] [rbp-30h]
unsigned int NumPointsTotal; // [rsp+38h] [rbp-28h]
int NumControlPoints; // [rsp+3Ch] [rbp-24h]
OpenSubdiv::v3_6_0::Bfr::PatchTree *IrregPatch; // [rsp+40h] [rbp-20h]
int *v14; // [rsp+48h] [rbp-18h]
long long v15; // [rsp+50h] [rbp-10h]
OpenSubdiv::v3_6_0::Bfr::internal::SurfaceData *v16; // [rsp+58h] [rbp-8h]
v16 = a1;
v15 = a2;
v14 = a3;
IrregPatch = (OpenSubdiv::v3_6_0::Bfr::PatchTree *)OpenSubdiv::v3_6_0::Bfr::Surface<double>::getIrregPatch(a1);
NumControlPoints = OpenSubdiv::v3_6_0::Bfr::Surface<double>::GetNumControlPoints(a1);
NumPointsTotal = OpenSubdiv::v3_6_0::Bfr::PatchTree::GetNumPointsTotal(IrregPatch);
result = NumPointsTotal;
if ( NumPointsTotal != NumControlPoints )
{
v4 = v15;
v5 = *v14;
v6 = v14[1];
v7 = NumControlPoints;
v8 = NumPointsTotal - NumControlPoints;
v9 = 8LL * NumControlPoints * v14[1] + v15;
Stencil = OpenSubdiv::v3_6_0::Bfr::PatchTree::GetStencilMatrix<double>(IrregPatch);
return OpenSubdiv::v3_6_0::Bfr::points::CombineConsecutive<double>::Apply(&v4);
}
return result;
}
| |||
41,675 | OpenSubdiv::v3_6_0::Bfr::Surface<double>::computeIrregularPatchPoints(double*, OpenSubdiv::v3_6_0::Bfr::Surface<double>::PointDescriptor const&) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/surface.cpp | void
Surface<REAL>::computeIrregularPatchPoints(REAL pointData[],
PointDescriptor const & pointDesc) const {
//
// An "irregular patch" may be represented by a regular patch in
// rare cases, so be sure there are patch points to compute:
//
internal::IrregularPatchType const & irregPatch = getIrregPatch();
int numControlPoints = GetNumControlPoints();
int numPatchPoints = irregPatch.GetNumPointsTotal();
if (numPatchPoints == numControlPoints) return;
//
// Assemble parameters of the point combination operation and apply:
//
typedef points::CombineConsecutive<REAL> PointCombiner;
typename PointCombiner::Parameters combParams;
combParams.pointData = pointData;
combParams.pointSize = pointDesc.size;
combParams.pointStride = pointDesc.stride;
combParams.srcCount = numControlPoints;
combParams.resultCount = numPatchPoints - numControlPoints;
combParams.resultData = pointData + pointDesc.stride * numControlPoints;
combParams.weightData = irregPatch.GetStencilMatrix<REAL>();
PointCombiner::Apply(combParams);
} | O3 | cpp | OpenSubdiv::v3_6_0::Bfr::Surface<double>::computeIrregularPatchPoints(double*, OpenSubdiv::v3_6_0::Bfr::Surface<double>::PointDescriptor const&) const:
subq $0x28, %rsp
movq 0x70(%rdi), %rax
movl 0x8(%rdi), %ecx
movl 0x24(%rax), %edi
addl 0x1c(%rax), %edi
subl %ecx, %edi
je 0x9a691
movq %rsi, (%rsp)
movl (%rdx), %r8d
movl %r8d, 0x8(%rsp)
movl 0x4(%rdx), %edx
movl %edx, 0xc(%rsp)
movl %ecx, 0x10(%rsp)
movl %edi, 0x14(%rsp)
imull %ecx, %edx
movslq %edx, %rcx
leaq (%rsi,%rcx,8), %rcx
movq %rcx, 0x18(%rsp)
movq 0x98(%rax), %rcx
cmpq 0xa0(%rax), %rcx
je 0x9a696
movq %rsp, %rdi
movq %rcx, 0x20(%rdi)
callq 0x38a90
addq $0x28, %rsp
retq
leaq 0x282a3(%rip), %rdi # 0xc2940
leaq 0x282ba(%rip), %rsi # 0xc295e
leaq 0x28313(%rip), %rcx # 0xc29be
movl $0xd2, %edx
callq 0x39540
nop
| _ZNK10OpenSubdiv6v3_6_03Bfr7SurfaceIdE27computeIrregularPatchPointsEPdRKNS3_15PointDescriptorE:
sub rsp, 28h
mov rax, [rdi+70h]
mov ecx, [rdi+8]
mov edi, [rax+24h]
add edi, [rax+1Ch]
sub edi, ecx
jz short loc_9A691
mov [rsp+28h+var_28], rsi
mov r8d, [rdx]
mov [rsp+28h+var_20], r8d
mov edx, [rdx+4]
mov [rsp+28h+var_1C], edx
mov [rsp+28h+var_18], ecx
mov [rsp+28h+var_14], edi
imul edx, ecx
movsxd rcx, edx
lea rcx, [rsi+rcx*8]
mov [rsp+28h+var_10], rcx
mov rcx, [rax+98h]
cmp rcx, [rax+0A0h]
jz short loc_9A696
mov rdi, rsp
mov [rdi+20h], rcx
call __ZN10OpenSubdiv6v3_6_03Bfr6points18CombineConsecutiveIdE5ApplyERKNS4_10ParametersE; OpenSubdiv::v3_6_0::Bfr::points::CombineConsecutive<double>::Apply(OpenSubdiv::v3_6_0::Bfr::points::CombineConsecutive<double>::Parameters const&)
loc_9A691:
add rsp, 28h
retn
loc_9A696:
lea rdi, aStencilmatrixd; "!_stencilMatrixDouble.empty()"
lea rsi, aWorkspaceLlm4b_39; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aConstStdVector; "const std::vector<double> &OpenSubdiv::"...
mov edx, 0D2h
call ___assert_fail
| long long OpenSubdiv::v3_6_0::Bfr::Surface<double>::computeIrregularPatchPoints(
long long a1,
long long a2,
int *a3)
{
long long result; // rax
int v4; // ecx
int v5; // edi
long long v6; // [rsp+0h] [rbp-28h] BYREF
int v7; // [rsp+8h] [rbp-20h]
int v8; // [rsp+Ch] [rbp-1Ch]
int v9; // [rsp+10h] [rbp-18h]
int v10; // [rsp+14h] [rbp-14h]
long long v11; // [rsp+18h] [rbp-10h]
long long v12; // [rsp+20h] [rbp-8h]
result = *(_QWORD *)(a1 + 112);
v4 = *(_DWORD *)(a1 + 8);
v5 = *(_DWORD *)(result + 28) + *(_DWORD *)(result + 36) - v4;
if ( v5 )
{
v6 = a2;
v7 = *a3;
v8 = a3[1];
v9 = v4;
v10 = v5;
v11 = a2 + 8LL * v4 * v8;
if ( *(_QWORD *)(result + 152) == *(_QWORD *)(result + 160) )
__assert_fail(
"!_stencilMatrixDouble.empty()",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/../bfr/patchTree.h",
210LL,
"const std::vector<double> &OpenSubdiv::v3_6_0::Bfr::PatchTree::getStencilMatrix() const");
v12 = *(_QWORD *)(result + 152);
return OpenSubdiv::v3_6_0::Bfr::points::CombineConsecutive<double>::Apply(&v6);
}
return result;
}
| computeIrregularPatchPoints:
SUB RSP,0x28
MOV RAX,qword ptr [RDI + 0x70]
MOV ECX,dword ptr [RDI + 0x8]
MOV EDI,dword ptr [RAX + 0x24]
ADD EDI,dword ptr [RAX + 0x1c]
SUB EDI,ECX
JZ 0x0019a691
MOV qword ptr [RSP],RSI
MOV R8D,dword ptr [RDX]
MOV dword ptr [RSP + 0x8],R8D
MOV EDX,dword ptr [RDX + 0x4]
MOV dword ptr [RSP + 0xc],EDX
MOV dword ptr [RSP + 0x10],ECX
MOV dword ptr [RSP + 0x14],EDI
IMUL EDX,ECX
MOVSXD RCX,EDX
LEA RCX,[RSI + RCX*0x8]
MOV qword ptr [RSP + 0x18],RCX
MOV RCX,qword ptr [RAX + 0x98]
CMP RCX,qword ptr [RAX + 0xa0]
JZ 0x0019a696
MOV RDI,RSP
MOV qword ptr [RDI + 0x20],RCX
CALL 0x00138a90
LAB_0019a691:
ADD RSP,0x28
RET
LAB_0019a696:
LEA RDI,[0x1c2940]
LEA RSI,[0x1c295e]
LEA RCX,[0x1c29be]
MOV EDX,0xd2
CALL 0x00139540
|
/* OpenSubdiv::v3_6_0::Bfr::Surface<double>::computeIrregularPatchPoints(double*,
OpenSubdiv::v3_6_0::Bfr::Surface<double>::PointDescriptor const&) const */
void __thiscall
OpenSubdiv::v3_6_0::Bfr::Surface<double>::computeIrregularPatchPoints
(Surface<double> *this,double *param_1,PointDescriptor *param_2)
{
long lVar1;
double *local_28;
int4 local_20;
int local_1c;
int local_18;
int local_14;
double *local_10;
long local_8;
lVar1 = *(long *)(this + 0x70);
local_18 = *(int *)(this + 8);
local_14 = (*(int *)(lVar1 + 0x24) + *(int *)(lVar1 + 0x1c)) - local_18;
if (local_14 != 0) {
local_20 = *(int4 *)param_2;
local_1c = *(int *)(param_2 + 4);
local_10 = param_1 + local_1c * local_18;
local_8 = *(long *)(lVar1 + 0x98);
local_28 = param_1;
if (local_8 == *(long *)(lVar1 + 0xa0)) {
/* WARNING: Subroutine does not return */
__assert_fail("!_stencilMatrixDouble.empty()",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/../bfr/patchTree.h"
,0xd2,
"const std::vector<double> &OpenSubdiv::v3_6_0::Bfr::PatchTree::getStencilMatrix() const"
);
}
points::CombineConsecutive<double>::Apply((Parameters *)&local_28);
}
return;
}
| |
41,676 | my_cset_init_8bit | eloqsql/strings/ctype-simple.c | static my_bool
my_cset_init_8bit(struct charset_info_st *cs, MY_CHARSET_LOADER *loader)
{
cs->state|= my_8bit_charset_flags_from_data(cs);
cs->caseup_multiply= 1;
cs->casedn_multiply= 1;
cs->pad_char= ' ';
if (!cs->to_lower || !cs->to_upper || !cs->m_ctype || !cs->tab_to_uni)
return TRUE;
return create_fromuni(cs, loader);
} | O0 | c | my_cset_init_8bit:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x54f40
movl %eax, %ecx
movq -0x10(%rbp), %rax
orl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x94(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x95(%rax)
movq -0x10(%rbp), %rax
movb $0x20, 0xb0(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x55d02
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x55d02
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x55d02
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
jne 0x55d08
movb $0x1, -0x1(%rbp)
jmp 0x55d18
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x55df0
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_cset_init_8bit:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rdi, [rbp+var_10]
call my_8bit_charset_flags_from_data
mov ecx, eax
mov rax, [rbp+var_10]
or ecx, [rax+0Ch]
mov [rax+0Ch], ecx
mov rax, [rbp+var_10]
mov byte ptr [rax+94h], 1
mov rax, [rbp+var_10]
mov byte ptr [rax+95h], 1
mov rax, [rbp+var_10]
mov byte ptr [rax+0B0h], 20h ; ' '
mov rax, [rbp+var_10]
cmp qword ptr [rax+48h], 0
jz short loc_55D02
mov rax, [rbp+var_10]
cmp qword ptr [rax+50h], 0
jz short loc_55D02
mov rax, [rbp+var_10]
cmp qword ptr [rax+40h], 0
jz short loc_55D02
mov rax, [rbp+var_10]
cmp qword ptr [rax+68h], 0
jnz short loc_55D08
loc_55D02:
mov [rbp+var_1], 1
jmp short loc_55D18
loc_55D08:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call create_fromuni
mov [rbp+var_1], al
loc_55D18:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char my_cset_init_8bit(long long a1, long long a2)
{
*(_DWORD *)(a1 + 12) |= my_8bit_charset_flags_from_data(a1);
*(_BYTE *)(a1 + 148) = 1;
*(_BYTE *)(a1 + 149) = 1;
*(_BYTE *)(a1 + 176) = 32;
if ( *(_QWORD *)(a1 + 72) && *(_QWORD *)(a1 + 80) && *(_QWORD *)(a1 + 64) && *(_QWORD *)(a1 + 104) )
return create_fromuni(a1, a2);
else
return 1;
}
| my_cset_init_8bit:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00154f40
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
OR ECX,dword ptr [RAX + 0xc]
MOV dword ptr [RAX + 0xc],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x94],0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x95],0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0xb0],0x20
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x48],0x0
JZ 0x00155d02
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x50],0x0
JZ 0x00155d02
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x40],0x0
JZ 0x00155d02
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x68],0x0
JNZ 0x00155d08
LAB_00155d02:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00155d18
LAB_00155d08:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00155df0
MOV byte ptr [RBP + -0x1],AL
LAB_00155d18:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 my_cset_init_8bit(long param_1,int8 param_2)
{
uint uVar1;
int1 local_9;
uVar1 = my_8bit_charset_flags_from_data(param_1);
*(uint *)(param_1 + 0xc) = uVar1 | *(uint *)(param_1 + 0xc);
*(int1 *)(param_1 + 0x94) = 1;
*(int1 *)(param_1 + 0x95) = 1;
*(int1 *)(param_1 + 0xb0) = 0x20;
if ((((*(long *)(param_1 + 0x48) == 0) || (*(long *)(param_1 + 0x50) == 0)) ||
(*(long *)(param_1 + 0x40) == 0)) || (*(long *)(param_1 + 0x68) == 0)) {
local_9 = 1;
}
else {
local_9 = create_fromuni(param_1,param_2);
}
return local_9;
}
| |
41,677 | JS_RegExpExec | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_RegExpExec(JSContext *ctx, JSValue r, JSValue s)
{
JSValue method, ret;
method = JS_GetProperty(ctx, r, JS_ATOM_exec);
if (JS_IsException(method))
return method;
if (JS_IsFunction(ctx, method)) {
ret = JS_CallFree(ctx, method, r, 1, &s);
if (JS_IsException(ret))
return ret;
if (!JS_IsObject(ret) && !JS_IsNull(ret)) {
JS_FreeValue(ctx, ret);
return JS_ThrowTypeError(ctx, "RegExp exec method must return an object or null");
}
return ret;
}
JS_FreeValue(ctx, method);
return js_regexp_exec(ctx, r, 1, &s);
} | O1 | c | JS_RegExpExec:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %rcx, (%rsp)
movq %r8, 0x8(%rsp)
movl $0x87, %ecx
movq %rsi, %r8
movq %rdx, %r9
pushq $0x0
pushq $0x0
callq 0x2238f
addq $0x10, %rsp
movq %rax, %r14
movq %rdx, %r15
cmpl $0x6, %r15d
je 0x4ac39
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x221aa
testl %eax, %eax
je 0x4ac13
subq $0x8, %rsp
leaq 0x8(%rsp), %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r13, %rcx
movq %r12, %r8
movl $0x1, %r9d
pushq %rax
callq 0x22089
addq $0x10, %rsp
movq %rax, %r14
movq %rdx, %r15
movl %r15d, %eax
incl %eax
cmpl $0x7, %eax
ja 0x4abe8
movl $0x89, %ecx
btl %eax, %ecx
jb 0x4ac39
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1ccb2
leaq 0x538c5(%rip), %rsi # 0x9e4c3
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21953
movl $0x6, %r15d
jmp 0x4ac39
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1ccb2
movq %rsp, %r8
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x47195
movq %rax, %r14
movq %rdx, %r15
movq %r14, %rax
movq %r15, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| JS_RegExpExec:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov r12, rdx
mov r13, rsi
mov rbx, rdi
mov [rsp+38h+var_38], rcx
mov [rsp+38h+var_30], r8
mov ecx, 87h
mov r8, rsi
mov r9, rdx
push 0
push 0
call JS_GetPropertyInternal2
add rsp, 10h
mov r14, rax
mov r15, rdx
cmp r15d, 6
jz loc_4AC39
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call JS_IsFunction
test eax, eax
jz short loc_4AC13
sub rsp, 8
lea rax, [rsp+40h+var_38]
mov rdi, rbx
mov rsi, r14
mov rdx, r15
mov rcx, r13
mov r8, r12
mov r9d, 1
push rax
call JS_CallFree
add rsp, 10h
mov r14, rax
mov r15, rdx
mov eax, r15d
inc eax
cmp eax, 7
ja short loc_4ABE8
mov ecx, 89h
bt ecx, eax
jb short loc_4AC39
loc_4ABE8:
mov rdi, [rbx+18h]
mov rsi, r14
mov rdx, r15
call JS_FreeValueRT
lea rsi, aRegexpExecMeth; "RegExp exec method must return an objec"...
xor r14d, r14d
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
mov r15d, 6
jmp short loc_4AC39
loc_4AC13:
mov rdi, [rbx+18h]
mov rsi, r14
mov rdx, r15
call JS_FreeValueRT
mov r8, rsp
mov rdi, rbx
mov rsi, r13
mov rdx, r12
call js_regexp_exec
mov r14, rax
mov r15, rdx
loc_4AC39:
mov rax, r14
mov rdx, r15
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| long long JS_RegExpExec(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
long long a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
unsigned long long PropertyInternal2; // rax
long long v15; // rdx
_DWORD *v16; // r14
long long v17; // r15
long long v18; // rdx
int v19; // ecx
long long v20; // rdx
long long v21; // rcx
long long v22; // r8
long long v23; // r9
__m128 v24; // xmm4
__m128 v25; // xmm5
long long v26; // rcx
long long v27; // r9
__m128 v28; // xmm4
__m128 v29; // xmm5
long long v31[7]; // [rsp+0h] [rbp-38h] BYREF
v31[0] = a4;
v31[1] = a5;
PropertyInternal2 = JS_GetPropertyInternal2(a1, a2, a3, 0x87u, a2, a3, 0LL, 0);
v16 = (_DWORD *)PropertyInternal2;
v17 = v15;
if ( (_DWORD)v15 != 6 )
{
if ( (unsigned int)JS_IsFunction(a1, PropertyInternal2, v15) )
{
v16 = (_DWORD *)JS_CallFree(a1, v16, v17, a2, a3, 1, (long long)v31);
if ( (unsigned int)(v18 + 1) > 7 || (v19 = 137, !_bittest(&v19, v18 + 1)) )
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v16, v18);
v16 = 0LL;
JS_ThrowTypeError(
a1,
(long long)"RegExp exec method must return an object or null",
v20,
v21,
v22,
v23,
a6,
a7,
a8,
a9,
v24,
v25,
a12,
a13,
v31[0]);
}
}
else
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v16, v17);
return js_regexp_exec(a1, a2, a3, a6, a7, a8, a9, v28, v29, a12, a13, v26, v31, v27);
}
}
return (long long)v16;
}
| JS_RegExpExec:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R12,RDX
MOV R13,RSI
MOV RBX,RDI
MOV qword ptr [RSP],RCX
MOV qword ptr [RSP + 0x8],R8
MOV ECX,0x87
MOV R8,RSI
MOV R9,RDX
PUSH 0x0
PUSH 0x0
CALL 0x0012238f
ADD RSP,0x10
MOV R14,RAX
MOV R15,RDX
CMP R15D,0x6
JZ 0x0014ac39
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
CALL 0x001221aa
TEST EAX,EAX
JZ 0x0014ac13
SUB RSP,0x8
LEA RAX,[RSP + 0x8]
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
MOV RCX,R13
MOV R8,R12
MOV R9D,0x1
PUSH RAX
CALL 0x00122089
ADD RSP,0x10
MOV R14,RAX
MOV R15,RDX
MOV EAX,R15D
INC EAX
CMP EAX,0x7
JA 0x0014abe8
MOV ECX,0x89
BT ECX,EAX
JC 0x0014ac39
LAB_0014abe8:
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,R14
MOV RDX,R15
CALL 0x0011ccb2
LEA RSI,[0x19e4c3]
XOR R14D,R14D
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00121953
MOV R15D,0x6
JMP 0x0014ac39
LAB_0014ac13:
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,R14
MOV RDX,R15
CALL 0x0011ccb2
MOV R8,RSP
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R12
CALL 0x00147195
MOV R14,RAX
MOV R15,RDX
LAB_0014ac39:
MOV RAX,R14
MOV RDX,R15
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
int1 [16]
JS_RegExpExec(long param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5)
{
int iVar1;
uint uVar2;
int8 uVar3;
int8 uVar4;
int1 auVar5 [16];
int8 local_38;
int8 local_30;
local_38 = param_4;
local_30 = param_5;
auVar5 = JS_GetPropertyInternal2();
uVar4 = auVar5._8_8_;
uVar3 = auVar5._0_8_;
if (auVar5._8_4_ != 6) {
iVar1 = JS_IsFunction(param_1,uVar3,uVar4);
if (iVar1 == 0) {
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar3,uVar4);
auVar5 = js_regexp_exec(param_1,param_2,param_3);
}
else {
auVar5 = JS_CallFree(param_1,uVar3,uVar4,param_2,param_3,1,&local_38);
uVar2 = auVar5._8_4_ + 1;
if ((7 < uVar2) || ((0x89U >> (uVar2 & 0x1f) & 1) == 0)) {
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),auVar5._0_8_,auVar5._8_8_);
JS_ThrowTypeError(param_1,"RegExp exec method must return an object or null");
auVar5 = ZEXT816(6) << 0x40;
}
}
}
return auVar5;
}
| |
41,678 | 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() | monkey531[P]llama/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;
} | O2 | 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 0x3e7bc
cmpl $0xef, %eax
jne 0x3df01
movq %rbx, %rdi
callq 0x3e7bc
cmpl $0xbb, %eax
jne 0x3df0d
movq %rbx, %rdi
callq 0x3e7bc
cmpl $0xbf, %eax
sete %al
jmp 0x3df0f
movq %rbx, %rdi
callq 0x3e832
movb $0x1, %al
jmp 0x3df0f
xorl %eax, %eax
popq %rbx
retq
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_3DF01
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
jnz short loc_3DF0D
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_3DF0F
loc_3DF01:
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
jmp short loc_3DF0F
loc_3DF0D:
xor eax, eax
loc_3DF0F:
pop rbx
retn
| 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(
long long a1)
{
if ( (unsigned int)((long long (*)(void))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)() == 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(a1);
return 1;
}
| skip_bom:
PUSH RBX
MOV RBX,RDI
CALL 0x0013e7bc
CMP EAX,0xef
JNZ 0x0013df01
MOV RDI,RBX
CALL 0x0013e7bc
CMP EAX,0xbb
JNZ 0x0013df0d
MOV RDI,RBX
CALL 0x0013e7bc
CMP EAX,0xbf
SETZ AL
JMP 0x0013df0f
LAB_0013df01:
MOV RDI,RBX
CALL 0x0013e832
MOV AL,0x1
JMP 0x0013df0f
LAB_0013df0d:
XOR EAX,EAX
LAB_0013df0f:
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<__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;
}
| |
41,679 | get_this_host | eloqsql/libmariadb/unittest/libmariadb/my_test.h | void get_this_host(MYSQL *mysql)
{
MYSQL_RES *res;
MYSQL_ROW row;
if (mysql_query(mysql, "select substr(current_user(), locate('@', current_user())+1)"))
return;
if ((res= mysql_store_result(mysql)))
{
if ((row= mysql_fetch_row(res)))
this_host= strdup(row[0]);
mysql_free_result(res);
}
} | O0 | c | get_this_host:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x3763b(%rip), %rsi # 0x4b1d2
callq 0x1e0d0
cmpl $0x0, %eax
je 0x13ba3
jmp 0x13be5
movq -0x8(%rbp), %rdi
callq 0x1f720
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x13be5
movq -0x10(%rbp), %rdi
callq 0x1fa60
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x13bdc
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x137a0
movq %rax, 0x4c5fc(%rip) # 0x601d8
movq -0x10(%rbp), %rdi
callq 0x16f60
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| get_this_host:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
lea rsi, aSelectSubstrCu; "select substr(current_user(), locate('@"...
call mysql_query
cmp eax, 0
jz short loc_13BA3
jmp short loc_13BE5
loc_13BA3:
mov rdi, [rbp+var_8]
call mysql_store_result
mov [rbp+var_10], rax
cmp rax, 0
jz short loc_13BE5
mov rdi, [rbp+var_10]
call mysql_fetch_row
mov [rbp+var_18], rax
cmp rax, 0
jz short loc_13BDC
mov rax, [rbp+var_18]
mov rdi, [rax]
call _strdup
mov cs:this_host, rax
loc_13BDC:
mov rdi, [rbp+var_10]
call mysql_free_result
loc_13BE5:
add rsp, 20h
pop rbp
retn
| long long get_this_host(long long a1)
{
long long result; // rax
_QWORD *row; // [rsp+8h] [rbp-18h]
long long v3; // [rsp+10h] [rbp-10h]
result = mysql_query(a1, "select substr(current_user(), locate('@', current_user())+1)");
if ( !(_DWORD)result )
{
result = mysql_store_result(a1);
v3 = result;
if ( result )
{
row = (_QWORD *)mysql_fetch_row(result);
if ( row )
this_host = strdup(*row);
return mysql_free_result(v3);
}
}
return result;
}
| get_this_host:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x14b1d2]
CALL 0x0011e0d0
CMP EAX,0x0
JZ 0x00113ba3
JMP 0x00113be5
LAB_00113ba3:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0011f720
MOV qword ptr [RBP + -0x10],RAX
CMP RAX,0x0
JZ 0x00113be5
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0011fa60
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JZ 0x00113bdc
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX]
CALL 0x001137a0
MOV qword ptr [0x001601d8],RAX
LAB_00113bdc:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00116f60
LAB_00113be5:
ADD RSP,0x20
POP RBP
RET
|
void get_this_host(int8 param_1)
{
int iVar1;
long lVar2;
int8 *puVar3;
iVar1 = mysql_query(param_1,"select substr(current_user(), locate(\'@\', current_user())+1)");
if ((iVar1 == 0) && (lVar2 = mysql_store_result(param_1), lVar2 != 0)) {
puVar3 = (int8 *)mysql_fetch_row(lVar2);
if (puVar3 != (int8 *)0x0) {
this_host = strdup((char *)*puVar3);
}
mysql_free_result(lVar2);
}
return;
}
| |
41,680 | my_seek | eloqsql/mysys/my_seek.c | my_off_t my_seek(File fd, my_off_t pos, int whence, myf MyFlags)
{
os_off_t newpos= -1;
DBUG_ENTER("my_seek");
DBUG_PRINT("my",("fd: %d Pos: %llu Whence: %d MyFlags: %lu",
fd, (ulonglong) pos, whence, MyFlags));
DBUG_ASSERT(pos != MY_FILEPOS_ERROR); /* safety check */
/*
Make sure we are using a valid file descriptor!
*/
DBUG_ASSERT(fd != -1);
#ifdef _WIN32
newpos= my_win_lseek(fd, pos, whence);
#else
newpos= lseek(fd, pos, whence);
#endif
if (newpos == (os_off_t) -1)
{
my_errno= errno;
if (MyFlags & MY_WME)
my_error(EE_CANT_SEEK, MYF(0), my_filename(fd), my_errno);
DBUG_PRINT("error", ("lseek: %llu errno: %d", (ulonglong) newpos, errno));
DBUG_RETURN(MY_FILEPOS_ERROR);
}
if ((my_off_t) newpos != pos)
{
DBUG_PRINT("exit",("pos: %llu", (ulonglong) newpos));
}
DBUG_RETURN((my_off_t) newpos);
} | O0 | c | my_seek:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq $-0x1, -0x30(%rbp)
jmp 0xf4e50
jmp 0xf4e52
jmp 0xf4e54
jmp 0xf4e56
jmp 0xf4e58
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x2a700
movq %rax, -0x30(%rbp)
cmpq $-0x1, -0x30(%rbp)
jne 0xf4ecb
callq 0x2a750
movl (%rax), %eax
movl %eax, -0x34(%rbp)
callq 0xf6250
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0xf4ebb
movl -0xc(%rbp), %edi
callq 0x103740
movq %rax, -0x40(%rbp)
callq 0xf6250
movq -0x40(%rbp), %rdx
movl (%rax), %ecx
movl $0x21, %edi
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0xefa80
jmp 0xf4ebd
jmp 0xf4ebf
jmp 0xf4ec1
movq $-0x1, -0x8(%rbp)
jmp 0xf4ee5
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xf4edb
jmp 0xf4ed7
jmp 0xf4ed9
jmp 0xf4edb
jmp 0xf4edd
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
| my_seek:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_C], edi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], rcx
mov [rbp+var_30], 0FFFFFFFFFFFFFFFFh
jmp short $+2
loc_F4E50:
jmp short $+2
loc_F4E52:
jmp short $+2
loc_F4E54:
jmp short $+2
loc_F4E56:
jmp short $+2
loc_F4E58:
mov edi, [rbp+var_C]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
call _lseek64
mov [rbp+var_30], rax
cmp [rbp+var_30], 0FFFFFFFFFFFFFFFFh
jnz short loc_F4ECB
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_28]
and rax, 10h
cmp rax, 0
jz short loc_F4EBB
mov edi, [rbp+var_C]
call my_filename
mov [rbp+var_40], rax
call _my_thread_var
mov rdx, [rbp+var_40]
mov ecx, [rax]
mov edi, 21h ; '!'
xor eax, eax
mov esi, eax
mov al, 0
call my_error
loc_F4EBB:
jmp short $+2
loc_F4EBD:
jmp short $+2
loc_F4EBF:
jmp short $+2
loc_F4EC1:
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
jmp short loc_F4EE5
loc_F4ECB:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_18]
jz short loc_F4EDB
jmp short $+2
loc_F4ED7:
jmp short $+2
loc_F4ED9:
jmp short $+2
loc_F4EDB:
jmp short $+2
loc_F4EDD:
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
loc_F4EE5:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long my_seek(unsigned int a1, const char *a2, unsigned int a3, char a4)
{
unsigned int *v4; // rax
long long v6; // [rsp+0h] [rbp-40h]
int v7; // [rsp+Ch] [rbp-34h]
long long v8; // [rsp+10h] [rbp-30h]
v8 = lseek64(a1, a2, a3);
if ( v8 != -1 )
return v8;
v7 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var(a1, a2) = v7;
if ( (a4 & 0x10) != 0 )
{
v6 = my_filename(a1);
v4 = (unsigned int *)my_thread_var(a1, a2);
my_error(0x21u, 0LL, v6, *v4);
}
return -1LL;
}
| my_seek:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV dword ptr [RBP + -0xc],EDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],-0x1
JMP 0x001f4e50
LAB_001f4e50:
JMP 0x001f4e52
LAB_001f4e52:
JMP 0x001f4e54
LAB_001f4e54:
JMP 0x001f4e56
LAB_001f4e56:
JMP 0x001f4e58
LAB_001f4e58:
MOV EDI,dword ptr [RBP + -0xc]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
CALL 0x0012a700
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],-0x1
JNZ 0x001f4ecb
CALL 0x0012a750
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x34],EAX
CALL 0x001f6250
MOV ECX,dword ptr [RBP + -0x34]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x28]
AND RAX,0x10
CMP RAX,0x0
JZ 0x001f4ebb
MOV EDI,dword ptr [RBP + -0xc]
CALL 0x00203740
MOV qword ptr [RBP + -0x40],RAX
CALL 0x001f6250
MOV RDX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RAX]
MOV EDI,0x21
XOR EAX,EAX
MOV ESI,EAX
MOV AL,0x0
CALL 0x001efa80
LAB_001f4ebb:
JMP 0x001f4ebd
LAB_001f4ebd:
JMP 0x001f4ebf
LAB_001f4ebf:
JMP 0x001f4ec1
LAB_001f4ec1:
MOV qword ptr [RBP + -0x8],-0x1
JMP 0x001f4ee5
LAB_001f4ecb:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x18]
JZ 0x001f4edb
JMP 0x001f4ed7
LAB_001f4ed7:
JMP 0x001f4ed9
LAB_001f4ed9:
JMP 0x001f4edb
LAB_001f4edb:
JMP 0x001f4edd
LAB_001f4edd:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
LAB_001f4ee5:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
__off64_t my_seek(int param_1,__off64_t param_2,int param_3,ulong param_4)
{
int iVar1;
int *piVar2;
int8 uVar3;
int4 *puVar4;
__off64_t local_10;
local_10 = lseek64(param_1,param_2,param_3);
if (local_10 == -1) {
piVar2 = __errno_location();
iVar1 = *piVar2;
piVar2 = (int *)_my_thread_var();
*piVar2 = iVar1;
if ((param_4 & 0x10) != 0) {
uVar3 = my_filename(param_1);
puVar4 = (int4 *)_my_thread_var();
my_error(0x21,0,uVar3,*puVar4);
}
local_10 = -1;
}
return local_10;
}
| |
41,681 | codegen_generate_number_literal | tsotchke[P]eshkol/src/backend/codegen/literals.c | bool codegen_generate_number_literal(CodegenContext* context, const AstNode* node) {
assert(context != NULL);
assert(node != NULL);
assert(node->type == AST_LITERAL_NUMBER);
// Get output file
FILE* output = codegen_context_get_output(context);
// Generate code
fprintf(output, "%g", node->as.number.value);
return true;
} | O3 | c | codegen_generate_number_literal:
pushq %rbx
testq %rdi, %rdi
je 0x1129e
movq %rsi, %rbx
testq %rsi, %rsi
je 0x112bd
cmpl $0x0, (%rbx)
jne 0x112dc
callq 0xb394
movsd 0x48(%rbx), %xmm0
leaq 0x920d(%rip), %rsi # 0x1a49d
movq %rax, %rdi
movb $0x1, %al
callq 0x2200
movb $0x1, %al
popq %rbx
retq
leaq 0x8aba(%rip), %rdi # 0x19d5f
leaq 0xe9ca(%rip), %rsi # 0x1fc76
leaq 0xea1c(%rip), %rcx # 0x1fccf
movl $0x12, %edx
callq 0x2180
leaq 0xa60b(%rip), %rdi # 0x1b8cf
leaq 0xe9ab(%rip), %rsi # 0x1fc76
leaq 0xe9fd(%rip), %rcx # 0x1fccf
movl $0x13, %edx
callq 0x2180
leaq 0xea35(%rip), %rdi # 0x1fd18
leaq 0xe98c(%rip), %rsi # 0x1fc76
leaq 0xe9de(%rip), %rcx # 0x1fccf
movl $0x14, %edx
callq 0x2180
| codegen_generate_number_literal:
push rbx
test rdi, rdi
jz short loc_1129E
mov rbx, rsi
test rsi, rsi
jz short loc_112BD
cmp dword ptr [rbx], 0
jnz short loc_112DC
call codegen_context_get_output
movsd xmm0, qword ptr [rbx+48h]
lea rsi, aG+1; "%g"
mov rdi, rax
mov al, 1
call _fprintf
mov al, 1
pop rbx
retn
loc_1129E:
lea rdi, aContextNull; "context != NULL"
lea rsi, aWorkspaceLlm4b_16; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aBoolCodegenGen_7; "_Bool codegen_generate_number_literal(C"...
mov edx, 12h
call ___assert_fail
loc_112BD:
lea rdi, aNodeNull; "node != NULL"
lea rsi, aWorkspaceLlm4b_16; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aBoolCodegenGen_7; "_Bool codegen_generate_number_literal(C"...
mov edx, 13h
call ___assert_fail
loc_112DC:
lea rdi, aNodeTypeAstLit; "node->type == AST_LITERAL_NUMBER"
lea rsi, aWorkspaceLlm4b_16; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aBoolCodegenGen_7; "_Bool codegen_generate_number_literal(C"...
mov edx, 14h
call ___assert_fail
| char codegen_generate_number_literal(long long a1, long long a2)
{
long long output; // rax
if ( !a1 )
__assert_fail(
"context != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/literals.c",
18LL,
"_Bool codegen_generate_number_literal(CodegenContext *, const AstNode *)");
if ( !a2 )
__assert_fail(
"node != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/literals.c",
19LL,
"_Bool codegen_generate_number_literal(CodegenContext *, const AstNode *)");
if ( *(_DWORD *)a2 )
__assert_fail(
"node->type == AST_LITERAL_NUMBER",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/literals.c",
20LL,
"_Bool codegen_generate_number_literal(CodegenContext *, const AstNode *)");
output = codegen_context_get_output(a1);
fprintf(output, "%g", *(double *)(a2 + 72));
return 1;
}
| codegen_generate_number_literal:
PUSH RBX
TEST RDI,RDI
JZ 0x0011129e
MOV RBX,RSI
TEST RSI,RSI
JZ 0x001112bd
CMP dword ptr [RBX],0x0
JNZ 0x001112dc
CALL 0x0010b394
MOVSD XMM0,qword ptr [RBX + 0x48]
LEA RSI,[0x11a49d]
MOV RDI,RAX
MOV AL,0x1
CALL 0x00102200
MOV AL,0x1
POP RBX
RET
LAB_0011129e:
LEA RDI,[0x119d5f]
LEA RSI,[0x11fc76]
LEA RCX,[0x11fccf]
MOV EDX,0x12
CALL 0x00102180
LAB_001112bd:
LEA RDI,[0x11b8cf]
LEA RSI,[0x11fc76]
LEA RCX,[0x11fccf]
MOV EDX,0x13
CALL 0x00102180
LAB_001112dc:
LEA RDI,[0x11fd18]
LEA RSI,[0x11fc76]
LEA RCX,[0x11fccf]
MOV EDX,0x14
CALL 0x00102180
|
int4 codegen_generate_number_literal(long param_1,int *param_2)
{
FILE *__stream;
if (param_1 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("context != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/literals.c"
,0x12,"_Bool codegen_generate_number_literal(CodegenContext *, const AstNode *)");
}
if (param_2 != (int *)0x0) {
if (*param_2 == 0) {
__stream = (FILE *)codegen_context_get_output();
fprintf(__stream,"%g",*(int8 *)(param_2 + 0x12));
return 1;
}
/* WARNING: Subroutine does not return */
__assert_fail("node->type == AST_LITERAL_NUMBER",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/literals.c"
,0x14,"_Bool codegen_generate_number_literal(CodegenContext *, const AstNode *)");
}
/* WARNING: Subroutine does not return */
__assert_fail("node != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/literals.c"
,0x13,"_Bool codegen_generate_number_literal(CodegenContext *, const AstNode *)");
}
| |
41,682 | get_dataview | bluesky950520[P]quickjs/quickjs.c | static JSObject *get_dataview(JSContext *ctx, JSValue this_val)
{
JSObject *p;
if (JS_VALUE_GET_TAG(this_val) != JS_TAG_OBJECT)
goto fail;
p = JS_VALUE_GET_OBJ(this_val);
if (p->class_id != JS_CLASS_DATAVIEW) {
fail:
JS_ThrowTypeError(ctx, "not a DataView");
return NULL;
}
return p;
} | O0 | c | get_dataview:
subq $0x38, %rsp
movq %rsi, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq %rdi, 0x18(%rsp)
movq 0x28(%rsp), %rax
cmpl $-0x1, %eax
je 0xeb2ef
jmp 0xeb309
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzwl 0x6(%rax), %eax
cmpl $0x21, %eax
je 0xeb330
jmp 0xeb309
movq 0x18(%rsp), %rdi
leaq 0x2c68b(%rip), %rsi # 0x1179a0
movb $0x0, %al
callq 0x335f0
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq $0x0, 0x30(%rsp)
jmp 0xeb33a
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
| get_dataview:
sub rsp, 38h
mov [rsp+38h+var_18], rsi
mov [rsp+38h+var_10], rdx
mov [rsp+38h+var_20], rdi
mov rax, [rsp+38h+var_10]
cmp eax, 0FFFFFFFFh
jz short loc_EB2EF
jmp short loc_EB309
loc_EB2EF:
mov rax, [rsp+38h+var_18]
mov [rsp+38h+var_28], rax
mov rax, [rsp+38h+var_28]
movzx eax, word ptr [rax+6]
cmp eax, 21h ; '!'
jz short loc_EB330
jmp short $+2
loc_EB309:
mov rdi, [rsp+38h+var_20]
lea rsi, aNotADataview; "not a DataView"
mov al, 0
call JS_ThrowTypeError
mov [rsp+38h+var_38], rax
mov [rsp+38h+var_30], rdx
mov [rsp+38h+var_8], 0
jmp short loc_EB33A
loc_EB330:
mov rax, [rsp+38h+var_28]
mov [rsp+38h+var_8], rax
loc_EB33A:
mov rax, [rsp+38h+var_8]
add rsp, 38h
retn
| long long get_dataview(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
char v15; // [rsp+0h] [rbp-38h]
if ( (_DWORD)a3 == -1 && *(_WORD *)(a2 + 6) == 33 )
return a2;
JS_ThrowTypeError(a1, (long long)"not a DataView", a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v15);
return 0LL;
}
| get_dataview:
SUB RSP,0x38
MOV qword ptr [RSP + 0x20],RSI
MOV qword ptr [RSP + 0x28],RDX
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,qword ptr [RSP + 0x28]
CMP EAX,-0x1
JZ 0x001eb2ef
JMP 0x001eb309
LAB_001eb2ef:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOVZX EAX,word ptr [RAX + 0x6]
CMP EAX,0x21
JZ 0x001eb330
JMP 0x001eb309
LAB_001eb309:
MOV RDI,qword ptr [RSP + 0x18]
LEA RSI,[0x2179a0]
MOV AL,0x0
CALL 0x001335f0
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
MOV qword ptr [RSP + 0x30],0x0
JMP 0x001eb33a
LAB_001eb330:
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x30],RAX
LAB_001eb33a:
MOV RAX,qword ptr [RSP + 0x30]
ADD RSP,0x38
RET
|
long get_dataview(int8 param_1,long param_2,int param_3)
{
long local_8;
if ((param_3 != -1) || (local_8 = param_2, *(short *)(param_2 + 6) != 0x21)) {
JS_ThrowTypeError(param_1,"not a DataView");
local_8 = 0;
}
return local_8;
}
| |
41,683 | get_dataview | bluesky950520[P]quickjs/quickjs.c | static JSObject *get_dataview(JSContext *ctx, JSValue this_val)
{
JSObject *p;
if (JS_VALUE_GET_TAG(this_val) != JS_TAG_OBJECT)
goto fail;
p = JS_VALUE_GET_OBJ(this_val);
if (p->class_id != JS_CLASS_DATAVIEW) {
fail:
JS_ThrowTypeError(ctx, "not a DataView");
return NULL;
}
return p;
} | O2 | c | get_dataview:
pushq %rbx
cmpl $-0x1, %edx
jne 0x728aa
movq %rsi, %rbx
cmpw $0x21, 0x6(%rsi)
je 0x728ba
leaq 0x1a026(%rip), %rsi # 0x8c8d7
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x201fd
movq %rbx, %rax
popq %rbx
retq
| get_dataview:
push rbx
cmp edx, 0FFFFFFFFh
jnz short loc_728AA
mov rbx, rsi
cmp word ptr [rsi+6], 21h ; '!'
jz short loc_728BA
loc_728AA:
lea rsi, aNotADataview; "not a DataView"
xor ebx, ebx
xor eax, eax
call JS_ThrowTypeError
loc_728BA:
mov rax, rbx
pop rbx
retn
| long long get_dataview(
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 v14; // rbx
char v16; // [rsp+0h] [rbp-8h]
if ( (_DWORD)a3 != -1 || (v14 = a2, *(_WORD *)(a2 + 6) != 33) )
{
v14 = 0LL;
JS_ThrowTypeError(a1, (long long)"not a DataView", a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v16);
}
return v14;
}
| get_dataview:
PUSH RBX
CMP EDX,-0x1
JNZ 0x001728aa
MOV RBX,RSI
CMP word ptr [RSI + 0x6],0x21
JZ 0x001728ba
LAB_001728aa:
LEA RSI,[0x18c8d7]
XOR EBX,EBX
XOR EAX,EAX
CALL 0x001201fd
LAB_001728ba:
MOV RAX,RBX
POP RBX
RET
|
long get_dataview(int8 param_1,long param_2,int param_3)
{
if ((param_3 != -1) || (*(short *)(param_2 + 6) != 0x21)) {
param_2 = 0;
JS_ThrowTypeError(param_1,"not a DataView");
}
return param_2;
}
| |
41,684 | vsort_char | davidesantangelo[P]vsort/vsort.c | VSORT_API void vsort_char(char arr[], int n)
{
vsort_init();
if (!arr || n <= 1)
return;
vsort_log_debug("Starting vsort (char) for %d elements (using qsort fallback).", n);
qsort(arr, n, sizeof(char), default_char_comparator);
vsort_log_debug("vsort (char) completed for %d elements.", n);
} | O3 | c | vsort_char:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x212c
testq %r14, %r14
sete %al
cmpl $0x2, %ebx
setl %cl
orb %al, %cl
je 0x1354
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x34b3(%rip), %rdi # 0x480e
movl %ebx, %esi
xorl %eax, %eax
callq 0x351a
movl %ebx, %esi
leaq 0x1bfe(%rip), %rcx # 0x2f6b
movl $0x1, %edx
movq %r14, %rdi
callq 0x1080
leaq 0x34cb(%rip), %rdi # 0x484c
movl %ebx, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x351a
| vsort_char:
push r14
push rbx
push rax
mov ebx, esi
mov r14, rdi
call vsort_init
test r14, r14
setz al
cmp ebx, 2
setl cl
or cl, al
jz short loc_1354
add rsp, 8
pop rbx
pop r14
retn
loc_1354:
lea rdi, aStartingVsortC; "Starting vsort (char) for %d elements ("...
mov esi, ebx
xor eax, eax
call vsort_log_debug
mov esi, ebx
lea rcx, default_char_comparator
mov edx, 1
mov rdi, r14
call _qsort
lea rdi, aVsortCharCompl; "vsort (char) completed for %d elements."
mov esi, ebx
xor eax, eax
add rsp, 8
pop rbx
pop r14
jmp vsort_log_debug
| char vsort_char(long long a1, int a2, long long a3, long long a4, long long a5, long long a6, char a7)
{
char v7; // al
int v8; // edx
int v9; // r8d
int v10; // r9d
char result; // al
int v12; // ecx
int v13; // edx
int v14; // ecx
int v15; // r8d
int v16; // r9d
char v17; // [rsp-8h] [rbp-18h]
v17 = v7;
vsort_init();
result = a1 == 0;
LOBYTE(v12) = a1 == 0 || a2 < 2;
if ( !(_BYTE)v12 )
{
vsort_log_debug(
(unsigned int)"Starting vsort (char) for %d elements (using qsort fallback).",
a2,
v8,
v12,
v9,
v10,
v17);
qsort(a1, (unsigned int)a2, 1LL, default_char_comparator);
return vsort_log_debug((unsigned int)"vsort (char) completed for %d elements.", a2, v13, v14, v15, v16, a7);
}
return result;
}
| vsort_char:
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,ESI
MOV R14,RDI
CALL 0x0010212c
TEST R14,R14
SETZ AL
CMP EBX,0x2
SETL CL
OR CL,AL
JZ 0x00101354
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_00101354:
LEA RDI,[0x10480e]
MOV ESI,EBX
XOR EAX,EAX
CALL 0x0010351a
MOV ESI,EBX
LEA RCX,[0x102f6b]
MOV EDX,0x1
MOV RDI,R14
CALL 0x00101080
LEA RDI,[0x10484c]
MOV ESI,EBX
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x0010351a
|
void vsort_char(void *param_1,uint param_2)
{
vsort_init();
if ((int)param_2 < 2 || param_1 == (void *)0x0) {
return;
}
vsort_log_debug("Starting vsort (char) for %d elements (using qsort fallback).",param_2);
qsort(param_1,(ulong)param_2,1,default_char_comparator);
vsort_log_debug("vsort (char) completed for %d elements.",param_2);
return;
}
| |
41,685 | mysql_ping_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_ping_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_ping,
(parms->mysql),
parms->mysql,
int,
r_int)
} | O0 | c | mysql_ping_start_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x28610
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| mysql_ping_start_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
call mysql_ping
mov [rbp+var_14], eax
mov ecx, [rbp+var_14]
mov rax, [rbp+var_20]
mov [rax+8], ecx
mov rax, [rbp+var_20]
mov dword ptr [rax], 0
add rsp, 20h
pop rbp
retn
| _DWORD * mysql_ping_start_internal(long long *a1)
{
_DWORD *result; // rax
_DWORD *v2; // [rsp+0h] [rbp-20h]
v2 = *(_DWORD **)(*(_QWORD *)(*a1 + 1152) + 40LL);
v2[2] = mysql_ping(*a1);
result = v2;
*v2 = 0;
return result;
}
| mysql_ping_start_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x00128610
MOV dword ptr [RBP + -0x14],EAX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x8],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
ADD RSP,0x20
POP RBP
RET
|
void mysql_ping_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_ping(*param_1);
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
| |
41,686 | ggml_scale_impl | llama.cpp/ggml/src/ggml.c | static struct ggml_tensor * ggml_scale_impl(
struct ggml_context * ctx,
struct ggml_tensor * a,
float s,
bool inplace) {
GGML_ASSERT(ggml_is_padded_1d(a));
struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
ggml_set_op_params(result, &s, sizeof(s));
result->op = GGML_OP_SCALE;
result->src[0] = a;
return result;
} | O3 | c | ggml_scale_impl:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq 0x30(%rsi), %rax
movl (%rsi), %esi
imulq $0x38, %rsi, %rcx
leaq 0x4d86a(%rip), %r8 # 0x68dc0
cmpq 0x18(%rcx,%r8), %rax
jne 0x1b5c6
movq 0x18(%rbx), %rcx
movq 0x40(%rbx), %rax
imulq 0x38(%rbx), %rcx
cmpq %rcx, %rax
jne 0x1b5c6
imulq 0x20(%rbx), %rax
cmpq %rax, 0x48(%rbx)
jne 0x1b5c6
movss %xmm0, 0xc(%rsp)
testb %dl, %dl
je 0x1b58e
movq %rbx, %rsi
callq 0x16240
jmp 0x1b5a2
leaq 0x10(%rbx), %rcx
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x19be7
testq %rax, %rax
movss 0xc(%rsp), %xmm0
je 0x1b5e2
movss %xmm0, 0x54(%rax)
movl $0x1e, 0x50(%rax)
movq %rbx, 0x98(%rax)
addq $0x10, %rsp
popq %rbx
retq
leaq 0x2f046(%rip), %rdi # 0x4a613
leaq 0x2f07a(%rip), %rdx # 0x4a64e
leaq 0x31153(%rip), %rcx # 0x4c72e
movl $0xb10, %esi # imm = 0xB10
jmp 0x1b5fc
leaq 0x3119a(%rip), %rdi # 0x4c783
leaq 0x2f05e(%rip), %rdx # 0x4a64e
leaq 0x311cc(%rip), %rcx # 0x4c7c3
movl $0x70, %esi
xorl %eax, %eax
callq 0x17c80
| ggml_scale_impl:
push rbx
sub rsp, 10h
mov rbx, rsi
mov rax, [rsi+30h]
mov esi, [rsi]
imul rcx, rsi, 38h ; '8'
lea r8, type_traits
cmp rax, [rcx+r8+18h]
jnz short loc_1B5C6
mov rcx, [rbx+18h]
mov rax, [rbx+40h]
imul rcx, [rbx+38h]
cmp rax, rcx
jnz short loc_1B5C6
imul rax, [rbx+20h]
cmp [rbx+48h], rax
jnz short loc_1B5C6
movss [rsp+18h+var_C], xmm0
test dl, dl
jz short loc_1B58E
mov rsi, rbx
call _ggml_view_tensor
jmp short loc_1B5A2
loc_1B58E:
lea rcx, [rbx+10h]
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
loc_1B5A2:
test rax, rax
movss xmm0, [rsp+18h+var_C]
jz short loc_1B5E2
movss dword ptr [rax+54h], xmm0
mov dword ptr [rax+50h], 1Eh
mov [rax+98h], rbx
add rsp, 10h
pop rbx
retn
loc_1B5C6:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlIsPadded1d; "ggml_is_padded_1d(a)"
mov esi, 0B10h
jmp short loc_1B5FC
loc_1B5E2:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aTensorNull; "tensor != NULL"
mov esi, 70h ; 'p'
loc_1B5FC:
xor eax, eax
call _ggml_abort
| long long ggml_scale_impl(long long a1, _QWORD *a2, char a3, float a4, long long a5, long long a6, int a7)
{
char *v8; // rax
long long v9; // rsi
char **v10; // r8
long long v11; // rax
long long result; // rax
const char *v13; // rdi
const char *v14; // rcx
int v15; // esi
v8 = (char *)a2[6];
v9 = *(unsigned int *)a2;
v10 = &type_traits;
if ( v8 != (&type_traits)[7 * v9 + 3] || (v11 = a2[8], v11 != a2[7] * a2[3]) || a2[9] != a2[4] * v11 )
{
v13 = "/workspace/llm4binary/github2025/llama.cpp/ggml/src/ggml.c";
v14 = "ggml_is_padded_1d(a)";
v15 = 2832;
goto LABEL_11;
}
if ( a3 )
result = ggml_view_tensor(a1, (long long)a2);
else
result = ggml_new_tensor_impl(a1, v9, 4u, a2 + 2, 0LL, 0LL);
if ( !result )
{
v13 = "/workspace/llm4binary/github2025/llama.cpp/ggml/src/ggml-impl.h";
v14 = "tensor != NULL";
v15 = 112;
LABEL_11:
ggml_abort((_DWORD)v13, v15, (unsigned int)"GGML_ASSERT(%s) failed", (_DWORD)v14, (_DWORD)v10, a7);
}
*(float *)(result + 84) = a4;
*(_DWORD *)(result + 80) = 30;
*(_QWORD *)(result + 152) = a2;
return result;
}
| ggml_scale_impl:
PUSH RBX
SUB RSP,0x10
MOV RBX,RSI
MOV RAX,qword ptr [RSI + 0x30]
MOV ESI,dword ptr [RSI]
IMUL RCX,RSI,0x38
LEA R8,[0x168dc0]
CMP RAX,qword ptr [RCX + R8*0x1 + 0x18]
JNZ 0x0011b5c6
MOV RCX,qword ptr [RBX + 0x18]
MOV RAX,qword ptr [RBX + 0x40]
IMUL RCX,qword ptr [RBX + 0x38]
CMP RAX,RCX
JNZ 0x0011b5c6
IMUL RAX,qword ptr [RBX + 0x20]
CMP qword ptr [RBX + 0x48],RAX
JNZ 0x0011b5c6
MOVSS dword ptr [RSP + 0xc],XMM0
TEST DL,DL
JZ 0x0011b58e
MOV RSI,RBX
CALL 0x00116240
JMP 0x0011b5a2
LAB_0011b58e:
LEA RCX,[RBX + 0x10]
MOV EDX,0x4
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00119be7
LAB_0011b5a2:
TEST RAX,RAX
MOVSS XMM0,dword ptr [RSP + 0xc]
JZ 0x0011b5e2
MOVSS dword ptr [RAX + 0x54],XMM0
MOV dword ptr [RAX + 0x50],0x1e
MOV qword ptr [RAX + 0x98],RBX
ADD RSP,0x10
POP RBX
RET
LAB_0011b5c6:
LEA RDI,[0x14a613]
LEA RDX,[0x14a64e]
LEA RCX,[0x14c72e]
MOV ESI,0xb10
JMP 0x0011b5fc
LAB_0011b5e2:
LEA RDI,[0x14c783]
LEA RDX,[0x14a64e]
LEA RCX,[0x14c7c3]
MOV ESI,0x70
LAB_0011b5fc:
XOR EAX,EAX
CALL 0x00117c80
|
void ggml_scale_impl(int4 param_1,int8 param_2,uint *param_3,char param_4)
{
long lVar1;
char *pcVar2;
int8 uVar3;
char *pcVar4;
if (*(long *)(param_3 + 0xc) == *(long *)(type_traits + (ulong)*param_3 * 0x38 + 0x18)) {
if ((*(long *)(param_3 + 0x10) == *(long *)(param_3 + 6) * *(long *)(param_3 + 0xe)) &&
(*(long *)(param_3 + 0x12) == *(long *)(param_3 + 0x10) * *(long *)(param_3 + 8))) {
if (param_4 == '\0') {
lVar1 = ggml_new_tensor_impl(param_2,(ulong)*param_3,4,param_3 + 4,0,0);
}
else {
lVar1 = ggml_view_tensor(param_2,param_3);
}
if (lVar1 != 0) {
*(int4 *)(lVar1 + 0x54) = param_1;
*(int4 *)(lVar1 + 0x50) = 0x1e;
*(uint **)(lVar1 + 0x98) = param_3;
return;
}
pcVar4 = "/workspace/llm4binary/github2025/llama.cpp/ggml/src/ggml-impl.h";
pcVar2 = "tensor != NULL";
uVar3 = 0x70;
goto LAB_0011b5fc;
}
}
pcVar4 = "/workspace/llm4binary/github2025/llama.cpp/ggml/src/ggml.c";
pcVar2 = "ggml_is_padded_1d(a)";
uVar3 = 0xb10;
LAB_0011b5fc:
/* WARNING: Subroutine does not return */
ggml_abort(pcVar4,uVar3,"GGML_ASSERT(%s) failed",pcVar2);
}
| |
41,687 | inline_mysql_cond_init | eloqsql/include/mysql/psi/mysql_thread.h | static inline int inline_mysql_cond_init(
#ifdef HAVE_PSI_COND_INTERFACE
PSI_cond_key key,
#endif
mysql_cond_t *that,
const pthread_condattr_t *attr)
{
#ifdef HAVE_PSI_COND_INTERFACE
that->m_psi= PSI_COND_CALL(init_cond)(key, &that->m_cond);
#else
that->m_psi= NULL;
#endif
return pthread_cond_init(&that->m_cond, attr);
} | O0 | c | inline_mysql_cond_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x230efe(%rip), %rax # 0x2c0238
movq (%rax), %rax
movq 0x60(%rax), %rax
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq *%rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a360
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| inline_mysql_cond_init_2:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+60h]
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
call rax
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+30h], rcx
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call _pthread_cond_init
add rsp, 20h
pop rbp
retn
| long long inline_mysql_cond_init_2(unsigned int a1, long long a2, long long a3)
{
*(_QWORD *)(a2 + 48) = ((long long ( *)(_QWORD, long long))PSI_server[12])(a1, a2);
return pthread_cond_init(a2, a3);
}
| inline_mysql_cond_init:
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
LEA RAX,[0x3c0238]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x60]
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
CALL RAX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x30],RCX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0012a360
ADD RSP,0x20
POP RBP
RET
|
void inline_mysql_cond_init(int4 param_1,pthread_cond_t *param_2,pthread_condattr_t *param_3)
{
longlong lVar1;
lVar1 = (**(code **)(PSI_server + 0x60))(param_1,param_2);
param_2[1].__align = lVar1;
pthread_cond_init(param_2,param_3);
return;
}
| |
41,688 | my_xml_error_lineno | eloqsql/strings/xml.c | uint my_xml_error_lineno(MY_XML_PARSER *p)
{
uint res=0;
const char *s;
for (s=p->beg ; s<p->cur; s++)
{
if (s[0] == '\n')
res++;
}
return res;
} | O0 | c | my_xml_error_lineno:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x130(%rcx), %rax
jae 0x7ebc4
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x7ebb4
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7ebb6
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7eb8e
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
| my_xml_error_lineno:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], 0
mov rax, [rbp+var_8]
mov rax, [rax+128h]
mov [rbp+var_18], rax
loc_7EB8E:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_8]
cmp rax, [rcx+130h]
jnb short loc_7EBC4
mov rax, [rbp+var_18]
movsx eax, byte ptr [rax]
cmp eax, 0Ah
jnz short loc_7EBB4
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_C], eax
loc_7EBB4:
jmp short $+2
loc_7EBB6:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_7EB8E
loc_7EBC4:
mov eax, [rbp+var_C]
pop rbp
retn
| long long my_xml_error_lineno(long long a1)
{
_BYTE *i; // [rsp+0h] [rbp-18h]
unsigned int v3; // [rsp+Ch] [rbp-Ch]
v3 = 0;
for ( i = *(_BYTE **)(a1 + 296); (unsigned long long)i < *(_QWORD *)(a1 + 304); ++i )
{
if ( *i == 10 )
++v3;
}
return v3;
}
| my_xml_error_lineno:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x128]
MOV qword ptr [RBP + -0x18],RAX
LAB_0017eb8e:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x130]
JNC 0x0017ebc4
MOV RAX,qword ptr [RBP + -0x18]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0xa
JNZ 0x0017ebb4
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
LAB_0017ebb4:
JMP 0x0017ebb6
LAB_0017ebb6:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0017eb8e
LAB_0017ebc4:
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET
|
int my_xml_error_lineno(long param_1)
{
char *local_20;
int local_14;
local_14 = 0;
for (local_20 = *(char **)(param_1 + 0x128); local_20 < *(char **)(param_1 + 0x130);
local_20 = local_20 + 1) {
if (*local_20 == '\n') {
local_14 = local_14 + 1;
}
}
return local_14;
}
| |
41,689 | mi_alloc_rec_buff | eloqsql/storage/myisam/mi_open.c | uchar *mi_alloc_rec_buff(MI_INFO *info, ulong length, uchar **buf)
{
uint extra;
uint32 UNINIT_VAR(old_length);
if (! *buf || length > (old_length=mi_get_rec_buff_len(info, *buf)))
{
uchar *newptr = *buf;
/* to simplify initial init of info->rec_buf in mi_open and mi_extra */
if (length == (ulong) -1)
{
if (info->s->options & HA_OPTION_COMPRESS_RECORD)
length= MY_MAX(info->s->base.pack_reclength, info->s->max_pack_length);
else
length= info->s->base.pack_reclength;
length= MY_MAX(length, info->s->base.max_key_length);
length= MY_MAX(length, info->s->vreclength);
/* Avoid unnecessary realloc */
if (newptr && length == old_length)
return newptr;
}
extra= ((info->s->options & HA_OPTION_PACK_RECORD) ?
ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER)+MI_SPLIT_LENGTH+
MI_REC_BUFF_OFFSET : 0);
if (extra && newptr)
newptr-= MI_REC_BUFF_OFFSET;
if (!(newptr=(uchar*) my_realloc(mi_key_memory_record_buffer,
(uchar*)newptr, length + extra + 8,
MYF(MY_ALLOW_ZERO_PTR))))
return NULL;
*((uint32 *) newptr)= (uint32) length;
*buf= newptr+(extra ? MI_REC_BUFF_OFFSET : 0);
}
return *buf;
} | O3 | c | mi_alloc_rec_buff:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdx), %rax
movq (%rdi), %rcx
testq %rax, %rax
je 0x3ab1e
movq 0x318(%rcx), %rdx
andl $0x1, %edx
negq %rdx
andq $-0x18, %rdx
movl (%rax,%rdx), %edx
cmpq %r14, %rdx
jb 0x3ab1e
jmp 0x3abd1
movq 0x318(%rcx), %r15
cmpq $-0x1, %r14
je 0x3ab86
leaq 0x60(%r14), %rdx
xorl %ecx, %ecx
testb $0x1, %r15b
movq $-0x18, %rsi
cmoveq %rcx, %rsi
cmoveq %r14, %rdx
testq %rax, %rax
leaq 0x37501a(%rip), %rcx # 0x3afb68
movl (%rcx), %edi
cmoveq %rax, %rsi
addq %rax, %rsi
addq $0x8, %rdx
movl $0x40, %ecx
callq 0x60524
movq %rax, %rcx
movl $0x0, %eax
testq %rcx, %rcx
je 0x3abd1
movl %r14d, (%rcx)
leaq 0x18(%rcx), %rax
testb $0x1, %r15b
cmoveq %rcx, %rax
movq %rax, (%rbx)
jmp 0x3abd1
movq 0x148(%rcx), %rsi
testb $0x4, %r15b
je 0x3aba1
movq 0x328(%rcx), %rdi
cmpq %rdi, %rsi
cmovbeq %rdi, %rsi
movl 0x194(%rcx), %r14d
cmpq %r14, %rsi
cmovaq %rsi, %r14
movq 0x340(%rcx), %rcx
cmpq %rcx, %r14
cmovbeq %rcx, %r14
testq %rax, %rax
je 0x3ab2b
movl %edx, %ecx
cmpq %rcx, %r14
jne 0x3ab2b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| mi_alloc_rec_buff:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdx
mov r14, rsi
mov rax, [rdx]
mov rcx, [rdi]
test rax, rax
jz short loc_3AB1E
mov rdx, [rcx+318h]
and edx, 1
neg rdx
and rdx, 0FFFFFFFFFFFFFFE8h
mov edx, [rax+rdx]
cmp rdx, r14
jb short loc_3AB1E
jmp loc_3ABD1
loc_3AB1E:
mov r15, [rcx+318h]
cmp r14, 0FFFFFFFFFFFFFFFFh
jz short loc_3AB86
loc_3AB2B:
lea rdx, [r14+60h]
xor ecx, ecx
test r15b, 1
mov rsi, 0FFFFFFFFFFFFFFE8h
cmovz rsi, rcx
cmovz rdx, r14
test rax, rax
lea rcx, mi_key_memory_record_buffer
mov edi, [rcx]
cmovz rsi, rax
add rsi, rax
add rdx, 8
mov ecx, 40h ; '@'
call my_realloc
mov rcx, rax
mov eax, 0
test rcx, rcx
jz short loc_3ABD1
mov [rcx], r14d
lea rax, [rcx+18h]
test r15b, 1
cmovz rax, rcx
mov [rbx], rax
jmp short loc_3ABD1
loc_3AB86:
mov rsi, [rcx+148h]
test r15b, 4
jz short loc_3ABA1
mov rdi, [rcx+328h]
cmp rsi, rdi
cmovbe rsi, rdi
loc_3ABA1:
mov r14d, [rcx+194h]
cmp rsi, r14
cmova r14, rsi
mov rcx, [rcx+340h]
cmp r14, rcx
cmovbe r14, rcx
test rax, rax
jz loc_3AB2B
mov ecx, edx
cmp r14, rcx
jnz loc_3AB2B
loc_3ABD1:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| _DWORD * mi_alloc_rec_buff(long long *a1, unsigned long long a2, _QWORD *a3)
{
_QWORD *v3; // rbx
unsigned long long v4; // r14
_DWORD *result; // rax
long long v6; // rcx
long long v7; // r15
unsigned long long v8; // rdx
long long v9; // rsi
_DWORD *v10; // rcx
unsigned long long v11; // rsi
unsigned long long v12; // rcx
v3 = a3;
v4 = a2;
result = (_DWORD *)*a3;
v6 = *a1;
if ( !*a3
|| (a3 = (_QWORD *)*(unsigned int *)((char *)result + (-(*(_QWORD *)(v6 + 792) & 1LL) & 0xFFFFFFFFFFFFFFE8LL)),
(unsigned long long)a3 < a2) )
{
v7 = *(_QWORD *)(v6 + 792);
if ( a2 != -1LL )
goto LABEL_4;
v11 = *(_QWORD *)(v6 + 328);
if ( (v7 & 4) != 0 && v11 <= *(_QWORD *)(v6 + 808) )
v11 = *(_QWORD *)(v6 + 808);
v4 = *(unsigned int *)(v6 + 404);
if ( v11 > v4 )
v4 = v11;
v12 = *(_QWORD *)(v6 + 832);
if ( v4 <= v12 )
v4 = v12;
if ( !result || v4 != (unsigned int)a3 )
{
LABEL_4:
v8 = v4 + 96;
v9 = 0x3FFFFFFFFFFFFFFALL;
if ( (v7 & 1) == 0 )
{
v9 = 0LL;
v8 = v4;
}
if ( !result )
v9 = 0LL;
v10 = (_DWORD *)my_realloc(mi_key_memory_record_buffer, &result[v9], v8 + 8, 64LL);
result = 0LL;
if ( v10 )
{
*v10 = v4;
result = v10 + 6;
if ( (v7 & 1) == 0 )
result = v10;
*v3 = result;
}
}
}
return result;
}
| mi_alloc_rec_buff:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
MOV RAX,qword ptr [RDX]
MOV RCX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x0013ab1e
MOV RDX,qword ptr [RCX + 0x318]
AND EDX,0x1
NEG RDX
AND RDX,-0x18
MOV EDX,dword ptr [RAX + RDX*0x1]
CMP RDX,R14
JC 0x0013ab1e
JMP 0x0013abd1
LAB_0013ab1e:
MOV R15,qword ptr [RCX + 0x318]
CMP R14,-0x1
JZ 0x0013ab86
LAB_0013ab2b:
LEA RDX,[R14 + 0x60]
XOR ECX,ECX
TEST R15B,0x1
MOV RSI,-0x18
CMOVZ RSI,RCX
CMOVZ RDX,R14
TEST RAX,RAX
LEA RCX,[0x4afb68]
MOV EDI,dword ptr [RCX]
CMOVZ RSI,RAX
ADD RSI,RAX
ADD RDX,0x8
MOV ECX,0x40
CALL 0x00160524
MOV RCX,RAX
MOV EAX,0x0
TEST RCX,RCX
JZ 0x0013abd1
MOV dword ptr [RCX],R14D
LEA RAX,[RCX + 0x18]
TEST R15B,0x1
CMOVZ RAX,RCX
MOV qword ptr [RBX],RAX
JMP 0x0013abd1
LAB_0013ab86:
MOV RSI,qword ptr [RCX + 0x148]
TEST R15B,0x4
JZ 0x0013aba1
MOV RDI,qword ptr [RCX + 0x328]
CMP RSI,RDI
CMOVBE RSI,RDI
LAB_0013aba1:
MOV R14D,dword ptr [RCX + 0x194]
CMP RSI,R14
CMOVA R14,RSI
MOV RCX,qword ptr [RCX + 0x340]
CMP R14,RCX
CMOVBE R14,RCX
TEST RAX,RAX
JZ 0x0013ab2b
MOV ECX,EDX
CMP R14,RCX
JNZ 0x0013ab2b
LAB_0013abd1:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 * mi_alloc_rec_buff(long *param_1,long *param_2,long *param_3)
{
ulong uVar1;
int4 *puVar2;
int4 *puVar3;
long *plVar4;
long lVar5;
long *plVar6;
puVar3 = (int4 *)*param_3;
lVar5 = *param_1;
plVar4 = param_3;
if ((puVar3 == (int4 *)0x0) ||
(plVar4 = (long *)(ulong)*(uint *)((long)puVar3 +
(-(ulong)((uint)*(int8 *)(lVar5 + 0x318) & 1) &
0xffffffffffffffe8)), plVar4 < param_2)) {
uVar1 = *(ulong *)(lVar5 + 0x318);
if (param_2 == (long *)0xffffffffffffffff) {
plVar6 = *(long **)(lVar5 + 0x148);
if (((uVar1 & 4) != 0) && (plVar6 <= *(long **)(lVar5 + 0x328))) {
plVar6 = *(long **)(lVar5 + 0x328);
}
param_2 = (long *)(ulong)*(uint *)(lVar5 + 0x194);
if ((long *)(ulong)*(uint *)(lVar5 + 0x194) < plVar6) {
param_2 = plVar6;
}
if (param_2 <= *(long **)(lVar5 + 0x340)) {
param_2 = *(long **)(lVar5 + 0x340);
}
if ((puVar3 != (int4 *)0x0) && (param_2 == (long *)((ulong)plVar4 & 0xffffffff))) {
return puVar3;
}
}
plVar4 = param_2 + 0xc;
lVar5 = -0x18;
if ((uVar1 & 1) == 0) {
plVar4 = param_2;
lVar5 = 0;
}
if (puVar3 == (int4 *)0x0) {
lVar5 = 0;
}
puVar2 = (int4 *)
my_realloc(mi_key_memory_record_buffer,lVar5 + (long)puVar3,plVar4 + 1,0x40);
puVar3 = (int4 *)0x0;
if (puVar2 != (int4 *)0x0) {
*puVar2 = (int)param_2;
puVar3 = puVar2 + 6;
if ((uVar1 & 1) == 0) {
puVar3 = puVar2;
}
*param_3 = (long)puVar3;
}
}
return puVar3;
}
| |
41,690 | ma_read_rnd_mempack_record | eloqsql/storage/maria/ma_packrec.c | static int _ma_read_rnd_mempack_record(MARIA_HA *info,
uchar *buf,
register MARIA_RECORD_POS filepos,
my_bool skip_deleted_blocks
__attribute__((unused)))
{
MARIA_BLOCK_INFO block_info;
MARIA_SHARE *share= info->s;
uchar *pos,*start;
DBUG_ENTER("_ma_read_rnd_mempack_record");
if (filepos >= share->state.state.data_file_length)
{
my_errno=HA_ERR_END_OF_FILE;
goto err;
}
if (!(pos= (uchar*) _ma_mempack_get_block_info(info, &info->bit_buff,
&block_info,
&info->rec_buff,
&info->rec_buff_size,
(uchar*)
(start= share->file_map +
filepos))))
goto err;
#ifndef DBUG_OFF
if (block_info.rec_len > info->s->max_pack_length)
{
_ma_set_fatal_error(info, HA_ERR_WRONG_IN_RECORD);
goto err;
}
#endif
info->packed_length=block_info.rec_len;
info->cur_row.lastpos= filepos;
info->cur_row.nextpos= filepos+(uint) (pos-start)+block_info.rec_len;
info->update|= HA_STATE_AKTIV | HA_STATE_KEY_CHANGED;
DBUG_RETURN (_ma_pack_rec_unpack(info, &info->bit_buff, buf,
pos, block_info.rec_len));
err:
DBUG_RETURN(my_errno);
} | O3 | c | ma_read_rnd_mempack_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %rdi
cmpq %rdx, 0x40(%rdi)
jbe 0x65599
movq %rdx, %r15
movq %rsi, %rbx
leaq 0x290(%r14), %r12
leaq 0x3a0(%r14), %rcx
leaq 0x460(%r14), %r8
movq 0x5f0(%rdi), %r13
addq %rdx, %r13
leaq -0x88(%rbp), %rdx
movq %r12, %rsi
movq %r13, %r9
callq 0x66ea9
testq %rax, %rax
je 0x655a4
movq -0x70(%rbp), %r8
movq %r8, 0x450(%r14)
movq %r15, 0x98(%r14)
movl %eax, %ecx
subl %r13d, %ecx
addq %r8, %r15
addq %rcx, %r15
movq %r15, 0xa0(%r14)
orb $-0x7e, 0x624(%r14)
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x655c9
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %rax, %rcx
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x65009
callq 0xc14ee
movl $0x89, (%rax)
callq 0xc14ee
movl (%rax), %eax
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x655c9
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2a280
| _ma_read_rnd_mempack_record:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov rdi, [rdi]
cmp [rdi+40h], rdx
jbe loc_65599
mov r15, rdx
mov rbx, rsi
lea r12, [r14+290h]
lea rcx, [r14+3A0h]
lea r8, [r14+460h]
mov r13, [rdi+5F0h]
add r13, rdx
lea rdx, [rbp+var_88]
mov rsi, r12
mov r9, r13
call _ma_mempack_get_block_info
test rax, rax
jz short loc_655A4
mov r8, [rbp+var_70]
mov [r14+450h], r8
mov [r14+98h], r15
mov ecx, eax
sub ecx, r13d
add r15, r8
add r15, rcx
mov [r14+0A0h], r15
or byte ptr [r14+624h], 82h
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz short loc_655C9
mov rdi, r14
mov rsi, r12
mov rdx, rbx
mov rcx, rax
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _ma_pack_rec_unpack
loc_65599:
call _my_thread_var
mov dword ptr [rax], 89h
loc_655A4:
call _my_thread_var
mov eax, [rax]
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz short loc_655C9
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_655C9:
call ___stack_chk_fail
| long long ma_read_rnd_mempack_record(long long *a1, long long a2, unsigned long long a3)
{
long long v4; // rdi
unsigned long long v6; // r13
long long block_info; // rax
int v8; // r9d
long long v9; // r8
_BYTE v11[24]; // [rsp+8h] [rbp-88h] BYREF
long long v12; // [rsp+20h] [rbp-70h]
unsigned long long v13; // [rsp+60h] [rbp-30h]
v13 = __readfsqword(0x28u);
v4 = *a1;
if ( *(_QWORD *)(v4 + 64) <= a3 )
{
*(_DWORD *)my_thread_var(v4) = 137;
}
else
{
v6 = a3 + *(_QWORD *)(v4 + 1520);
block_info = ma_mempack_get_block_info(v4, a1 + 82, v11, a1 + 116, a1 + 140, v6);
if ( block_info )
{
v9 = v12;
a1[138] = v12;
a1[19] = a3;
a1[20] = (unsigned int)(block_info - v6) + v9 + a3;
*((_BYTE *)a1 + 1572) |= 0x82u;
return ma_pack_rec_unpack(a1, (long long)(a1 + 82), a2, block_info, v9, v8);
}
}
return *(unsigned int *)my_thread_var(v4);
}
| _ma_read_rnd_mempack_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RDI]
CMP qword ptr [RDI + 0x40],RDX
JBE 0x00165599
MOV R15,RDX
MOV RBX,RSI
LEA R12,[R14 + 0x290]
LEA RCX,[R14 + 0x3a0]
LEA R8,[R14 + 0x460]
MOV R13,qword ptr [RDI + 0x5f0]
ADD R13,RDX
LEA RDX,[RBP + -0x88]
MOV RSI,R12
MOV R9,R13
CALL 0x00166ea9
TEST RAX,RAX
JZ 0x001655a4
MOV R8,qword ptr [RBP + -0x70]
MOV qword ptr [R14 + 0x450],R8
MOV qword ptr [R14 + 0x98],R15
MOV ECX,EAX
SUB ECX,R13D
ADD R15,R8
ADD R15,RCX
MOV qword ptr [R14 + 0xa0],R15
OR byte ptr [R14 + 0x624],0x82
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x001655c9
MOV RDI,R14
MOV RSI,R12
MOV RDX,RBX
MOV RCX,RAX
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00165009
LAB_00165599:
CALL 0x001c14ee
MOV dword ptr [RAX],0x89
LAB_001655a4:
CALL 0x001c14ee
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x001655c9
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001655c9:
CALL 0x0012a280
|
ulong _ma_read_rnd_mempack_record(long *param_1,int8 param_2,ulong param_3)
{
long lVar1;
ulong uVar2;
int4 *puVar3;
uint *puVar4;
long lVar5;
long in_FS_OFFSET;
int1 local_90 [24];
long local_78;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar1 = *param_1;
if (param_3 < *(ulong *)(lVar1 + 0x40)) {
lVar5 = *(long *)(lVar1 + 0x5f0) + param_3;
lVar1 = _ma_mempack_get_block_info
(lVar1,param_1 + 0x52,local_90,param_1 + 0x74,param_1 + 0x8c,lVar5);
if (lVar1 != 0) {
param_1[0x8a] = local_78;
param_1[0x13] = param_3;
param_1[0x14] = param_3 + local_78 + (ulong)(uint)((int)lVar1 - (int)lVar5);
*(byte *)((long)param_1 + 0x624) = *(byte *)((long)param_1 + 0x624) | 0x82;
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
uVar2 = _ma_pack_rec_unpack(param_1,param_1 + 0x52,param_2,lVar1);
return uVar2;
}
goto LAB_001655c9;
}
}
else {
puVar3 = (int4 *)_my_thread_var();
*puVar3 = 0x89;
}
puVar4 = (uint *)_my_thread_var();
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return (ulong)*puVar4;
}
LAB_001655c9:
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
41,691 | unlink_hash | eloqsql/storage/maria/ma_pagecache.c | static void unlink_hash(PAGECACHE *pagecache, PAGECACHE_HASH_LINK *hash_link)
{
DBUG_ENTER("unlink_hash");
DBUG_PRINT("enter", ("hash_link: %p block: %p fd: %u pos: %lu requests: %u",
hash_link, hash_link->block, (uint) hash_link->file.file,
(ulong) hash_link->pageno,
hash_link->requests));
DBUG_ASSERT(hash_link->requests == 0);
DBUG_ASSERT(!hash_link->block || hash_link->block->pins == 0);
if ((*hash_link->prev= hash_link->next))
hash_link->next->prev= hash_link->prev;
hash_link->block= NULL;
if (pagecache->waiting_for_hash_link.last_thread)
{
/* Signal that a free hash link has appeared */
struct st_my_thread_var *last_thread=
pagecache->waiting_for_hash_link.last_thread;
struct st_my_thread_var *first_thread= last_thread->next;
struct st_my_thread_var *next_thread= first_thread;
PAGECACHE_PAGE *first_page= (PAGECACHE_PAGE *) (first_thread->keycache_link);
struct st_my_thread_var *thread;
hash_link->file= first_page->file;
DBUG_ASSERT(first_page->pageno < ((1ULL) << 40));
hash_link->pageno= first_page->pageno;
do
{
PAGECACHE_PAGE *page;
thread= next_thread;
page= (PAGECACHE_PAGE *) thread->keycache_link;
next_thread= thread->next;
/*
We notify about the event all threads that ask
for the same page as the first thread in the queue
*/
if (page->file.file == hash_link->file.file &&
page->pageno == hash_link->pageno)
{
DBUG_PRINT("signal", ("thread %s %ld", thread->name,
(ulong) thread->id));
pagecache_pthread_cond_signal(&thread->suspend);
wqueue_unlink_from_queue(&pagecache->waiting_for_hash_link, thread);
}
}
while (thread != last_thread);
/*
Add this to the hash, so that the waiting threads can find it
when they retry the call to get_hash_link(). This entry is special
in that it has no associated block.
*/
link_hash(&pagecache->hash_root[PAGECACHE_HASH(pagecache,
hash_link->file,
hash_link->pageno)],
hash_link);
DBUG_VOID_RETURN;
}
/* Add hash to free hash list */
hash_link->next= pagecache->free_hash_list;
pagecache->free_hash_list= hash_link;
DBUG_VOID_RETURN;
} | O0 | c | unlink_hash:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x30872
jmp 0x30874
jmp 0x30876
jmp 0x30878
jmp 0x3087a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x308a5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x118(%rax)
je 0x309d8
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0xa8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movq -0x30(%rbp), %rsi
movl $0x48, %edx
callq 0x2a090
jmp 0x30910
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0xa8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jne 0x3098d
movq -0x40(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x60(%rcx), %rax
jne 0x3098d
jmp 0x3096a
jmp 0x3096c
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x30e00
movq -0x8(%rbp), %rdi
addq $0x118, %rdi # imm = 0x118
movq -0x38(%rbp), %rsi
callq 0xff650
jmp 0x3098f
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x30920
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x28(%rcx), %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
andq %rcx, %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x30db0
jmp 0x309fb
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x98(%rax)
jmp 0x309fb
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| unlink_hash:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
jmp short $+2
loc_30872:
jmp short $+2
loc_30874:
jmp short $+2
loc_30876:
jmp short $+2
loc_30878:
jmp short $+2
loc_3087A:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rcx, [rbp+var_10]
mov rcx, [rcx+8]
mov [rcx], rax
cmp rax, 0
jz short loc_308A5
mov rax, [rbp+var_10]
mov rcx, [rax+8]
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rax+8], rcx
loc_308A5:
mov rax, [rbp+var_10]
mov qword ptr [rax+10h], 0
mov rax, [rbp+var_8]
cmp qword ptr [rax+118h], 0
jz loc_309D8
mov rax, [rbp+var_8]
mov rax, [rax+118h]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rax, [rax+88h]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov [rbp+var_28], rax
mov rax, [rbp+var_20]
mov rax, [rax+0A8h]
mov [rbp+var_30], rax
mov rdi, [rbp+var_10]
add rdi, 18h
mov rsi, [rbp+var_30]
mov edx, 48h ; 'H'
call _memcpy
jmp short $+2
loc_30910:
mov rax, [rbp+var_30]
mov rcx, [rax+48h]
mov rax, [rbp+var_10]
mov [rax+60h], rcx
loc_30920:
mov rax, [rbp+var_28]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov rax, [rax+0A8h]
mov [rbp+var_40], rax
mov rax, [rbp+var_38]
mov rax, [rax+88h]
mov [rbp+var_28], rax
mov rax, [rbp+var_40]
mov eax, [rax+10h]
mov rcx, [rbp+var_10]
cmp eax, [rcx+28h]
jnz short loc_3098D
mov rax, [rbp+var_40]
mov rax, [rax+48h]
mov rcx, [rbp+var_10]
cmp rax, [rcx+60h]
jnz short loc_3098D
jmp short $+2
loc_3096A:
jmp short $+2
loc_3096C:
mov rdi, [rbp+var_38]
add rdi, 8
call inline_mysql_cond_signal
mov rdi, [rbp+var_8]
add rdi, 118h
mov rsi, [rbp+var_38]
call wqueue_unlink_from_queue
loc_3098D:
jmp short $+2
loc_3098F:
mov rax, [rbp+var_38]
cmp rax, [rbp+var_18]
jnz short loc_30920
mov rax, [rbp+var_8]
mov rdi, [rax+88h]
mov rax, [rbp+var_10]
mov rax, [rax+60h]
mov rcx, [rbp+var_10]
movsxd rcx, dword ptr [rcx+28h]
add rax, rcx
mov rcx, [rbp+var_8]
mov rcx, [rcx+20h]
sub rcx, 1
and rax, rcx
shl rax, 3
add rdi, rax
mov rsi, [rbp+var_10]
call link_hash
jmp short loc_309FB
loc_309D8:
mov rax, [rbp+var_8]
mov rcx, [rax+98h]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov [rax+98h], rcx
jmp short $+2
loc_309FB:
add rsp, 40h
pop rbp
retn
| long long unlink_hash(_QWORD *a1, long long *a2)
{
long long v2; // rax
long long result; // rax
long long v4; // [rsp+0h] [rbp-40h]
long long v5; // [rsp+8h] [rbp-38h]
long long v6; // [rsp+10h] [rbp-30h]
long long v7; // [rsp+18h] [rbp-28h]
long long v8; // [rsp+28h] [rbp-18h]
v2 = *a2;
*(_QWORD *)a2[1] = *a2;
if ( v2 )
*(_QWORD *)(*a2 + 8) = a2[1];
a2[2] = 0LL;
if ( a1[35] )
{
v8 = a1[35];
v7 = *(_QWORD *)(v8 + 136);
v6 = *(_QWORD *)(v7 + 168);
memcpy(a2 + 3, v6, 72LL);
a2[12] = *(_QWORD *)(v6 + 72);
do
{
v5 = v7;
v4 = *(_QWORD *)(v7 + 168);
v7 = *(_QWORD *)(v7 + 136);
if ( *(_DWORD *)(v4 + 16) == *((_DWORD *)a2 + 10) && *(_QWORD *)(v4 + 72) == a2[12] )
{
inline_mysql_cond_signal(v5 + 8);
wqueue_unlink_from_queue(a1 + 35, v5);
}
}
while ( v5 != v8 );
return link_hash(8 * ((a1[4] - 1LL) & (*((int *)a2 + 10) + a2[12])) + a1[17], a2);
}
else
{
*a2 = a1[19];
result = (long long)a1;
a1[19] = a2;
}
return result;
}
| unlink_hash:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x00130872
LAB_00130872:
JMP 0x00130874
LAB_00130874:
JMP 0x00130876
LAB_00130876:
JMP 0x00130878
LAB_00130878:
JMP 0x0013087a
LAB_0013087a:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JZ 0x001308a5
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x8],RCX
LAB_001308a5:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],0x0
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x118],0x0
JZ 0x001309d8
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x118]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x88]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0xa8]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x18
MOV RSI,qword ptr [RBP + -0x30]
MOV EDX,0x48
CALL 0x0012a090
JMP 0x00130910
LAB_00130910:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RAX + 0x48]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x60],RCX
LAB_00130920:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0xa8]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x88]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0x28]
JNZ 0x0013098d
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX + 0x48]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x60]
JNZ 0x0013098d
JMP 0x0013096a
LAB_0013096a:
JMP 0x0013096c
LAB_0013096c:
MOV RDI,qword ptr [RBP + -0x38]
ADD RDI,0x8
CALL 0x00130e00
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x118
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x001ff650
LAB_0013098d:
JMP 0x0013098f
LAB_0013098f:
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x18]
JNZ 0x00130920
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x88]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x60]
MOV RCX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RCX + 0x28]
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX + 0x20]
SUB RCX,0x1
AND RAX,RCX
SHL RAX,0x3
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x00130db0
JMP 0x001309fb
LAB_001309d8:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x98]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x98],RCX
JMP 0x001309fb
LAB_001309fb:
ADD RSP,0x40
POP RBP
RET
|
void unlink_hash(long param_1,long *param_2)
{
long lVar1;
void *__src;
long lVar2;
bool bVar3;
long local_30;
lVar1 = *param_2;
*(long *)param_2[1] = lVar1;
if (lVar1 != 0) {
*(long *)(*param_2 + 8) = param_2[1];
}
param_2[2] = 0;
if (*(long *)(param_1 + 0x118) == 0) {
*param_2 = *(long *)(param_1 + 0x98);
*(long **)(param_1 + 0x98) = param_2;
}
else {
lVar1 = *(long *)(param_1 + 0x118);
local_30 = *(long *)(lVar1 + 0x88);
__src = *(void **)(local_30 + 0xa8);
memcpy(param_2 + 3,__src,0x48);
param_2[0xc] = *(long *)((long)__src + 0x48);
do {
lVar2 = *(long *)(local_30 + 0x88);
if ((*(int *)(*(long *)(local_30 + 0xa8) + 0x10) == (int)param_2[5]) &&
(*(long *)(*(long *)(local_30 + 0xa8) + 0x48) == param_2[0xc])) {
inline_mysql_cond_signal(local_30 + 8);
wqueue_unlink_from_queue(param_1 + 0x118,local_30);
}
bVar3 = local_30 != lVar1;
local_30 = lVar2;
} while (bVar3);
link_hash(*(long *)(param_1 + 0x88) +
(param_2[0xc] + (long)(int)param_2[5] & *(long *)(param_1 + 0x20) - 1U) * 8,param_2);
}
return;
}
| |
41,692 | ModbusServerResource::processInputData(unsigned char const*, unsigned short) | serhmarch[P]ModbusBridge/modbus/src/ModbusServerResource.cpp | StatusCode ModbusServerResource::processInputData(const uint8_t *buff, uint16_t sz)
{
ModbusServerResourcePrivate *d = d_ModbusServerResource(d_ptr);
switch (d->func)
{
#ifndef MBF_READ_COILS_DISABLE
case MBF_READ_COILS:
#endif // MBF_READ_COILS_DISABLE
#ifndef MBF_READ_DISCRETE_INPUTS_DISABLE
case MBF_READ_DISCRETE_INPUTS:
#endif // MBF_READ_DISCRETE_INPUTS
#if !defined(MBF_READ_COILS_DISABLE) || !defined(MBF_READ_DISCRETE_INPUTS_DISABLE)
if (sz != 4) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
d->offset = buff[1] | (buff[0] << 8);
d->count = buff[3] | (buff[2] << 8);
if (d->count > MB_MAX_DISCRETS) // prevent valueBuff overflow
return d->setError(Status_BadIllegalDataValue, StringLiteral("Incorrect data value"));
break;
#endif // !defined(MBF_READ_COILS_DISABLE) || !defined(MBF_READ_DISCRETE_INPUTS_DISABLE)
#ifndef MBF_READ_HOLDING_REGISTERS_DISABLE
case MBF_READ_HOLDING_REGISTERS:
#endif // MBF_READ_HOLDING_REGISTERS_DISABLE
#ifndef MBF_READ_INPUT_REGISTERS_DISABLE
case MBF_READ_INPUT_REGISTERS:
#endif // MBF_READ_INPUT_REGISTERS_DISABLE
#if !defined(MBF_READ_HOLDING_REGISTERS_DISABLE) || !defined(MBF_READ_INPUT_REGISTERS_DISABLE)
if (sz != 4) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
d->offset = buff[1] | (buff[0]<<8);
d->count = buff[3] | (buff[2]<<8);
if (d->count > MB_MAX_REGISTERS) // prevent valueBuff overflow
return d->setError(Status_BadIllegalDataValue, StringLiteral("Incorrect data value"));
break;
#endif // !defined(MBF_READ_HOLDING_REGISTERS_DISABLE) || !defined(MBF_READ_INPUT_REGISTERS_DISABLE)
#ifndef MBF_WRITE_SINGLE_COIL_DISABLE
case MBF_WRITE_SINGLE_COIL:
if (sz != 4) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
if (!(buff[2] == 0x00 || buff[2] == 0xFF) || (buff[3] != 0)) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect data value"));
d->offset = buff[1] | (buff[0]<<8);
d->valueBuff[0] = buff[2];
break;
#endif // MBF_WRITE_SINGLE_COIL_DISABLE
#ifndef MBF_WRITE_SINGLE_REGISTER_DISABLE
case MBF_WRITE_SINGLE_REGISTER:
if (sz != 4) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
d->offset = buff[1] | (buff[0]<<8);
d->valueBuff[0] = buff[3];
d->valueBuff[1] = buff[2];
break;
#endif // MBF_WRITE_SINGLE_REGISTER_DISABLE
#ifndef MBF_READ_EXCEPTION_STATUS_DISABLE
case MBF_READ_EXCEPTION_STATUS:
if (sz > 0) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
break;
#endif // MBF_READ_EXCEPTION_STATUS_DISABLE
#ifndef MBF_DIAGNOSTICS_DISABLE
case MBF_DIAGNOSTICS:
if (sz < 2) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
d->subfunc = buff[1] | (buff[0]<<8);
d->count = sz - 2;
memcpy(d->valueBuff, &buff[2], d->count);
break;
#endif // MBF_DIAGNOSTICS_DISABLE
#ifndef MBF_GET_COMM_EVENT_COUNTER_DISABLE
case MBF_GET_COMM_EVENT_COUNTER:
if (sz > 0) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
break;
#endif // MBF_GET_COMM_EVENT_COUNTER_DISABLE
#ifndef MBF_GET_COMM_EVENT_LOG_DISABLE
case MBF_GET_COMM_EVENT_LOG:
if (sz > 0) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
break;
#endif // MBF_GET_COMM_EVENT_LOG_DISABLE
#ifndef MBF_WRITE_MULTIPLE_COILS_DISABLE
case MBF_WRITE_MULTIPLE_COILS: // Write multiple coils
if (sz < 5) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
if (sz != buff[4]+5) // don't match readed bytes and number of data bytes to follow
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
d->offset = buff[1] | (buff[0]<<8);
d->count = buff[3] | (buff[2]<<8);
if ((d->count+7)/8 != buff[4]) // don't match count bites and bytes
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
if (d->count > MB_MAX_DISCRETS) // prevent valueBuff overflow
return d->setError(Status_BadIllegalDataValue, StringLiteral("Incorrect data value"));
memcpy(d->valueBuff, &buff[5], (d->count+7)/8);
break;
#endif // MBF_WRITE_MULTIPLE_COILS_DISABLE
#ifndef MBF_WRITE_MULTIPLE_REGISTERS_DISABLE
case MBF_WRITE_MULTIPLE_REGISTERS:
if (sz < 5) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
if (sz != buff[4]+5) // don't match readed bytes and number of data bytes to follow
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
d->offset = buff[1] | (buff[0]<<8);
d->count = buff[3] | (buff[2]<<8);
if (d->count*2 != buff[4]) // don't match count values and bytes
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
if (d->count > MB_MAX_REGISTERS) // prevent valueBuff overflow
return d->setError(Status_BadIllegalDataValue, StringLiteral("Incorrect data value"));
for (uint16_t i = 0; i < d->count; i++)
{
d->valueBuff[i*2] = buff[6+i*2];
d->valueBuff[i*2+1] = buff[5+i*2];
}
break;
#endif // MBF_WRITE_MULTIPLE_REGISTERS_DISABLE
#ifndef MBF_REPORT_SERVER_ID_DISABLE
case MBF_REPORT_SERVER_ID:
if (sz > 0) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
break;
#endif // MBF_REPORT_SERVER_ID_DISABLE
#ifndef MBF_MASK_WRITE_REGISTER_DISABLE
case MBF_MASK_WRITE_REGISTER:
if (sz != 6) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
d->offset = buff[1] | (buff[0]<<8);
d->andMask = buff[3] | (buff[2]<<8);
d->orMask = buff[5] | (buff[4]<<8);
break;
#endif // MBF_MASK_WRITE_REGISTER_DISABLE
#ifndef MBF_READ_WRITE_MULTIPLE_REGISTERS_DISABLE
case MBF_READ_WRITE_MULTIPLE_REGISTERS:
if (sz < 9) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
if (sz != buff[8]+9) // don't match readed bytes and number of data bytes to follow
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
d->offset = buff[1] | (buff[0]<<8);
d->count = buff[3] | (buff[2]<<8);
d->writeOffset = buff[5] | (buff[4]<<8);
d->writeCount = buff[7] | (buff[6]<<8);
if (d->writeCount*2 != buff[8]) // don't match count values and bytes
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
if ((d->count > MB_MAX_REGISTERS) || (d->writeCount > MB_MAX_REGISTERS)) // prevent valueBuff overflow
return d->setError(Status_BadIllegalDataValue, StringLiteral("Incorrect data value"));
for (uint16_t i = 0; i < d->count; i++)
{
d->valueBuff[i*2] = buff[10+i*2];
d->valueBuff[i*2+1] = buff[ 9+i*2];
}
break;
#endif // MBF_READ_WRITE_MULTIPLE_REGISTERS_DISABLE
#ifndef MBF_READ_FIFO_QUEUE_DISABLE
case MBF_READ_FIFO_QUEUE:
if (sz < 2) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
d->offset = buff[1] | (buff[0]<<8);
break;
#endif // MBF_READ_FIFO_QUEUE_DISABLE
default:
return d->setError(Status_BadIllegalFunction, StringLiteral("Unsupported function"));
}
return Status_Good;
} | O1 | cpp | ModbusServerResource::processInputData(unsigned char const*, unsigned short):
pushq %rax
movq 0x8(%rdi), %rdi
movzbl 0xc1(%rdi), %eax
decl %eax
cmpl $0x17, %eax
ja 0xe69b
leaq 0xc18e(%rip), %rcx # 0x1a488
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
testw %dx, %dx
jne 0xe667
jmp 0xe707
cmpw $0x4, %dx
jne 0xe667
movzwl (%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc2(%rdi)
movzwl 0x2(%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc4(%rdi)
movzwl %ax, %eax
cmpl $0x7f9, %eax # imm = 0x7F9
jae 0xe37c
jmp 0xe707
cmpw $0x4, %dx
jne 0xe667
movzwl (%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc2(%rdi)
movzwl 0x2(%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc4(%rdi)
movzwl %ax, %eax
cmpl $0x80, %eax
jb 0xe707
movb $0x0, 0x1c9(%rdi)
movl $0x1000003, 0x70(%rdi) # imm = 0x1000003
movq 0x80(%rdi), %rdx
addq $0x78, %rdi
leaq 0xc223(%rip), %rcx # 0x1a5bf
movl $0x14, %r8d
xorl %esi, %esi
callq 0x54b0
movl $0x1000003, %eax # imm = 0x1000003
jmp 0xe709
cmpw $0x6, %dx
jne 0xe667
movzwl (%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc2(%rdi)
movzwl 0x2(%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc6(%rdi)
movzwl 0x4(%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc8(%rdi)
jmp 0xe707
cmpw $0x1, %dx
jbe 0xe667
movzwl (%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc2(%rdi)
addl $-0x2, %edx
movw %dx, 0xc4(%rdi)
addq $0xca, %rdi
addq $0x2, %rsi
movzwl %dx, %edx
callq 0x52a0
jmp 0xe707
cmpw $0x4, %dx
jbe 0xe667
movzwl %dx, %eax
movzbl 0x4(%rsi), %ecx
addl $0x5, %ecx
cmpl %eax, %ecx
jne 0xe64f
movzwl (%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc2(%rdi)
movzwl 0x2(%rsi), %eax
rolw $0x8, %ax
movzwl %ax, %ecx
movw %cx, 0xc4(%rdi)
addl %ecx, %ecx
movzbl 0x4(%rsi), %edx
cmpl %edx, %ecx
jne 0xe64f
cmpw $0x7f, %ax
ja 0xe6df
cmpw $0x0, 0xc4(%rdi)
je 0xe707
xorl %eax, %eax
xorl %ecx, %ecx
movb 0x6(%rsi,%rcx,2), %dl
movb %dl, 0xca(%rdi,%rcx,2)
movb 0x5(%rsi,%rcx,2), %dl
movb %dl, 0xcb(%rdi,%rcx,2)
incq %rcx
movzwl 0xc4(%rdi), %edx
cmpq %rdx, %rcx
jb 0xe48e
jmp 0xe709
cmpw $0x4, %dx
jbe 0xe667
movzwl %dx, %eax
movzbl 0x4(%rsi), %ecx
addl $0x5, %ecx
cmpl %eax, %ecx
jne 0xe64f
movzwl (%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc2(%rdi)
movzwl 0x2(%rsi), %eax
rolw $0x8, %ax
movzwl %ax, %ecx
movw %cx, 0xc4(%rdi)
leal 0x7(%rcx), %eax
shrl $0x3, %eax
movzbl 0x4(%rsi), %edx
cmpl %edx, %eax
jne 0xe64f
cmpl $0x7f9, %ecx # imm = 0x7F9
jae 0xe6df
addq $0xca, %rdi
addq $0x5, %rsi
movl %eax, %edx
jmp 0xe41e
cmpw $0x4, %dx
jne 0xe667
movzbl 0x2(%rsi), %eax
cmpl $0xff, %eax
je 0xe53d
testl %eax, %eax
jne 0xe547
cmpb $0x0, 0x3(%rsi)
je 0xe6f0
movb $0x0, 0x1c9(%rdi)
movl $0x1000102, 0x70(%rdi) # imm = 0x1000102
movq 0x80(%rdi), %rdx
addq $0x78, %rdi
leaq 0xc058(%rip), %rcx # 0x1a5bf
movl $0x14, %r8d
jmp 0xe68d
cmpw $0x4, %dx
jne 0xe667
movzwl (%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc2(%rdi)
movb 0x3(%rsi), %al
movb %al, 0xca(%rdi)
movb 0x2(%rsi), %al
movb %al, 0xcb(%rdi)
jmp 0xe707
cmpw $0x8, %dx
jbe 0xe667
movzwl %dx, %eax
movzbl 0x8(%rsi), %ecx
addl $0x9, %ecx
cmpl %eax, %ecx
jne 0xe64f
movzwl (%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc2(%rdi)
movzwl 0x2(%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc4(%rdi)
movzwl 0x4(%rsi), %ecx
rolw $0x8, %cx
movw %cx, 0xc6(%rdi)
movzwl 0x6(%rsi), %ecx
rolw $0x8, %cx
movzwl %cx, %edx
movw %dx, 0xc8(%rdi)
addl %edx, %edx
movzbl 0x8(%rsi), %r8d
cmpl %r8d, %edx
jne 0xe64f
orl %eax, %ecx
cmpw $0x7f, %cx
ja 0xe6df
cmpw $0x0, 0xc4(%rdi)
je 0xe707
xorl %eax, %eax
xorl %ecx, %ecx
movb 0xa(%rsi,%rcx,2), %dl
movb %dl, 0xca(%rdi,%rcx,2)
movb 0x9(%rsi,%rcx,2), %dl
movb %dl, 0xcb(%rdi,%rcx,2)
incq %rcx
movzwl 0xc4(%rdi), %edx
cmpq %rdx, %rcx
jb 0xe625
jmp 0xe709
leaq 0xb7e0(%rip), %rdx # 0x19e36
movl $0x1000102, %esi # imm = 0x1000102
popq %rax
jmp 0xede8
cmpw $0x1, %dx
ja 0xe6cf
movb $0x0, 0x1c9(%rdi)
movl $0x1000102, 0x70(%rdi) # imm = 0x1000102
movq 0x80(%rdi), %rdx
addq $0x78, %rdi
leaq 0xb7af(%rip), %rcx # 0x19e36
movl $0x1c, %r8d
xorl %esi, %esi
callq 0x54b0
movl $0x1000102, %eax # imm = 0x1000102
jmp 0xe709
movb $0x0, 0x1c9(%rdi)
movl $0x1000001, 0x70(%rdi) # imm = 0x1000001
movq 0x80(%rdi), %rdx
addq $0x78, %rdi
leaq 0xbf19(%rip), %rcx # 0x1a5d4
movl $0x14, %r8d
xorl %esi, %esi
callq 0x54b0
movl $0x1000001, %eax # imm = 0x1000001
jmp 0xe709
movzwl (%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc2(%rdi)
jmp 0xe707
leaq 0xbed9(%rip), %rdx # 0x1a5bf
movl $0x1000003, %esi # imm = 0x1000003
jmp 0xe65b
movzwl (%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc2(%rdi)
movb 0x2(%rsi), %al
movb %al, 0xca(%rdi)
xorl %eax, %eax
popq %rcx
retq
nop
| _ZN20ModbusServerResource16processInputDataEPKht:
push rax
mov rdi, [rdi+8]
movzx eax, byte ptr [rdi+0C1h]
dec eax; switch 24 cases
cmp eax, 17h
ja def_E301; jumptable 000000000000E301 default case, cases 9,10,13,14,18-21
lea rcx, jpt_E301
movsxd rax, ds:(jpt_E301 - 1A488h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_E303:
test dx, dx; jumptable 000000000000E301 cases 7,11,12,17
jnz loc_E667
jmp loc_E707
loc_E311:
cmp dx, 4; jumptable 000000000000E301 cases 1,2
jnz loc_E667
movzx eax, word ptr [rsi]
rol ax, 8
mov [rdi+0C2h], ax
movzx eax, word ptr [rsi+2]
rol ax, 8
mov [rdi+0C4h], ax
movzx eax, ax
cmp eax, 7F9h
jnb short loc_E37C
jmp loc_E707
loc_E347:
cmp dx, 4; jumptable 000000000000E301 cases 3,4
jnz loc_E667
movzx eax, word ptr [rsi]
rol ax, 8
mov [rdi+0C2h], ax
movzx eax, word ptr [rsi+2]
rol ax, 8
mov [rdi+0C4h], ax
movzx eax, ax
cmp eax, 80h
jb loc_E707
loc_E37C:
mov byte ptr [rdi+1C9h], 0
mov dword ptr [rdi+70h], 1000003h
mov rdx, [rdi+80h]
add rdi, 78h ; 'x'
lea rcx, aIncorrectDataV; "Incorrect data value"
mov r8d, 14h
xor esi, esi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
mov eax, 1000003h
jmp loc_E709
loc_E3B3:
cmp dx, 6; jumptable 000000000000E301 case 22
jnz loc_E667
movzx eax, word ptr [rsi]
rol ax, 8
mov [rdi+0C2h], ax
movzx eax, word ptr [rsi+2]
rol ax, 8
mov [rdi+0C6h], ax
movzx eax, word ptr [rsi+4]
rol ax, 8
mov [rdi+0C8h], ax
jmp loc_E707
loc_E3EE:
cmp dx, 1; jumptable 000000000000E301 case 8
jbe loc_E667
movzx eax, word ptr [rsi]
rol ax, 8
mov [rdi+0C2h], ax
add edx, 0FFFFFFFEh
mov [rdi+0C4h], dx
add rdi, 0CAh
add rsi, 2
movzx edx, dx
loc_E41E:
call _memcpy
jmp loc_E707
loc_E428:
cmp dx, 4; jumptable 000000000000E301 case 16
jbe loc_E667
movzx eax, dx
movzx ecx, byte ptr [rsi+4]
add ecx, 5
cmp ecx, eax
jnz loc_E64F
movzx eax, word ptr [rsi]
rol ax, 8
mov [rdi+0C2h], ax
movzx eax, word ptr [rsi+2]
rol ax, 8
movzx ecx, ax
mov [rdi+0C4h], cx
add ecx, ecx
movzx edx, byte ptr [rsi+4]
cmp ecx, edx
jnz loc_E64F
cmp ax, 7Fh
ja loc_E6DF
cmp word ptr [rdi+0C4h], 0
jz loc_E707
xor eax, eax
xor ecx, ecx
loc_E48E:
mov dl, [rsi+rcx*2+6]
mov [rdi+rcx*2+0CAh], dl
mov dl, [rsi+rcx*2+5]
mov [rdi+rcx*2+0CBh], dl
inc rcx
movzx edx, word ptr [rdi+0C4h]
cmp rcx, rdx
jb short loc_E48E
jmp loc_E709
loc_E4B8:
cmp dx, 4; jumptable 000000000000E301 case 15
jbe loc_E667
movzx eax, dx
movzx ecx, byte ptr [rsi+4]
add ecx, 5
cmp ecx, eax
jnz loc_E64F
movzx eax, word ptr [rsi]
rol ax, 8
mov [rdi+0C2h], ax
movzx eax, word ptr [rsi+2]
rol ax, 8
movzx ecx, ax
mov [rdi+0C4h], cx
lea eax, [rcx+7]
shr eax, 3
movzx edx, byte ptr [rsi+4]
cmp eax, edx
jnz loc_E64F
cmp ecx, 7F9h
jnb loc_E6DF
add rdi, 0CAh
add rsi, 5
mov edx, eax
jmp loc_E41E
loc_E524:
cmp dx, 4; jumptable 000000000000E301 case 5
jnz loc_E667
movzx eax, byte ptr [rsi+2]
cmp eax, 0FFh
jz short loc_E53D
test eax, eax
jnz short loc_E547
loc_E53D:
cmp byte ptr [rsi+3], 0
jz loc_E6F0
loc_E547:
mov byte ptr [rdi+1C9h], 0
mov dword ptr [rdi+70h], 1000102h
mov rdx, [rdi+80h]
add rdi, 78h ; 'x'
lea rcx, aIncorrectDataV; "Incorrect data value"
mov r8d, 14h
jmp loc_E68D
loc_E572:
cmp dx, 4; jumptable 000000000000E301 case 6
jnz loc_E667
movzx eax, word ptr [rsi]
rol ax, 8
mov [rdi+0C2h], ax
mov al, [rsi+3]
mov [rdi+0CAh], al
mov al, [rsi+2]
mov [rdi+0CBh], al
jmp loc_E707
loc_E5A1:
cmp dx, 8; jumptable 000000000000E301 case 23
jbe loc_E667
movzx eax, dx
movzx ecx, byte ptr [rsi+8]
add ecx, 9
cmp ecx, eax
jnz loc_E64F
movzx eax, word ptr [rsi]
rol ax, 8
mov [rdi+0C2h], ax
movzx eax, word ptr [rsi+2]
rol ax, 8
mov [rdi+0C4h], ax
movzx ecx, word ptr [rsi+4]
rol cx, 8
mov [rdi+0C6h], cx
movzx ecx, word ptr [rsi+6]
rol cx, 8
movzx edx, cx
mov [rdi+0C8h], dx
add edx, edx
movzx r8d, byte ptr [rsi+8]
cmp edx, r8d
jnz short loc_E64F
or ecx, eax
cmp cx, 7Fh
ja loc_E6DF
cmp word ptr [rdi+0C4h], 0
jz loc_E707
xor eax, eax
xor ecx, ecx
loc_E625:
mov dl, [rsi+rcx*2+0Ah]
mov [rdi+rcx*2+0CAh], dl
mov dl, [rsi+rcx*2+9]
mov [rdi+rcx*2+0CBh], dl
inc rcx
movzx edx, word ptr [rdi+0C4h]
cmp rcx, rdx
jb short loc_E625
jmp loc_E709
loc_E64F:
lea rdx, aIncorrectRecei; "Incorrect received data size"
mov esi, 1000102h
loc_E65B:
pop rax
jmp _ZN27ModbusServerResourcePrivate8setErrorEN6Modbus10StatusCodeEPKc; ModbusServerResourcePrivate::setError(Modbus::StatusCode,char const*)
loc_E661:
cmp dx, 1; jumptable 000000000000E301 case 24
ja short loc_E6CF
loc_E667:
mov byte ptr [rdi+1C9h], 0
mov dword ptr [rdi+70h], 1000102h
mov rdx, [rdi+80h]
add rdi, 78h ; 'x'
lea rcx, aIncorrectRecei; "Incorrect received data size"
mov r8d, 1Ch
loc_E68D:
xor esi, esi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
mov eax, 1000102h
jmp short loc_E709
def_E301:
mov byte ptr [rdi+1C9h], 0; jumptable 000000000000E301 default case, cases 9,10,13,14,18-21
mov dword ptr [rdi+70h], 1000001h
mov rdx, [rdi+80h]
add rdi, 78h ; 'x'
lea rcx, aUnsupportedFun; "Unsupported function"
mov r8d, 14h
xor esi, esi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
mov eax, 1000001h
jmp short loc_E709
loc_E6CF:
movzx eax, word ptr [rsi]
rol ax, 8
mov [rdi+0C2h], ax
jmp short loc_E707
loc_E6DF:
lea rdx, aIncorrectDataV; "Incorrect data value"
mov esi, 1000003h
jmp loc_E65B
loc_E6F0:
movzx eax, word ptr [rsi]
rol ax, 8
mov [rdi+0C2h], ax
mov al, [rsi+2]
mov [rdi+0CAh], al
loc_E707:
xor eax, eax
loc_E709:
pop rcx
retn
| long long ModbusServerResource::processInputData(
ModbusServerResource *this,
const unsigned __int8 *a2,
unsigned __int16 a3)
{
long long v3; // rdi
unsigned __int16 v4; // ax
unsigned __int16 v5; // ax
long long result; // rax
long long v7; // rdi
const unsigned __int8 *v8; // rsi
long long v9; // rdx
unsigned __int16 v10; // ax
unsigned long long v11; // rcx
unsigned __int16 v12; // ax
unsigned int v13; // ecx
unsigned int v14; // eax
long long v15; // rdx
long long v16; // rdi
const char *v17; // rcx
long long v18; // r8
__int16 v19; // ax
unsigned __int16 v20; // cx
unsigned long long v21; // rcx
const char *v22; // rdx
long long v23; // rsi
v3 = *((_QWORD *)this + 1);
switch ( *(_BYTE *)(v3 + 193) )
{
case 1:
case 2:
if ( a3 != 4 )
goto LABEL_46;
*(_WORD *)(v3 + 194) = __ROL2__(*(_WORD *)a2, 8);
v4 = __ROL2__(*((_WORD *)a2 + 1), 8);
*(_WORD *)(v3 + 196) = v4;
if ( v4 >= 0x7F9u )
goto LABEL_9;
return 0LL;
case 3:
case 4:
if ( a3 != 4 )
goto LABEL_46;
*(_WORD *)(v3 + 194) = __ROL2__(*(_WORD *)a2, 8);
v5 = __ROL2__(*((_WORD *)a2 + 1), 8);
*(_WORD *)(v3 + 196) = v5;
if ( v5 < 0x80u )
return 0LL;
LABEL_9:
*(_BYTE *)(v3 + 457) = 0;
*(_DWORD *)(v3 + 112) = 16777219;
std::string::_M_replace(v3 + 120, 0LL, *(_QWORD *)(v3 + 128), "Incorrect data value", 20LL);
return 16777219LL;
case 5:
if ( a3 != 4 )
goto LABEL_46;
if ( a2[2] != 255 && a2[2] || a2[3] )
{
*(_BYTE *)(v3 + 457) = 0;
*(_DWORD *)(v3 + 112) = 16777474;
v15 = *(_QWORD *)(v3 + 128);
v16 = v3 + 120;
v17 = "Incorrect data value";
v18 = 20LL;
goto LABEL_47;
}
*(_WORD *)(v3 + 194) = __ROL2__(*(_WORD *)a2, 8);
*(_BYTE *)(v3 + 202) = a2[2];
return 0LL;
case 6:
if ( a3 != 4 )
goto LABEL_46;
*(_WORD *)(v3 + 194) = __ROL2__(*(_WORD *)a2, 8);
*(_BYTE *)(v3 + 202) = a2[3];
*(_BYTE *)(v3 + 203) = a2[2];
return 0LL;
case 7:
case 0xB:
case 0xC:
case 0x11:
if ( !a3 )
return 0LL;
goto LABEL_46;
case 8:
if ( a3 <= 1u )
goto LABEL_46;
*(_WORD *)(v3 + 194) = __ROL2__(*(_WORD *)a2, 8);
LOWORD(v9) = a3 - 2;
*(_WORD *)(v3 + 196) = v9;
v7 = v3 + 202;
v8 = a2 + 2;
v9 = (unsigned __int16)v9;
goto LABEL_14;
case 0xF:
if ( a3 <= 4u )
goto LABEL_46;
if ( a2[4] + 5 != a3 )
goto LABEL_43;
*(_WORD *)(v3 + 194) = __ROL2__(*(_WORD *)a2, 8);
v12 = __ROL2__(*((_WORD *)a2 + 1), 8);
v13 = v12;
*(_WORD *)(v3 + 196) = v12;
v14 = ((unsigned int)v12 + 7) >> 3;
if ( v14 != a2[4] )
goto LABEL_43;
if ( v13 >= 0x7F9 )
goto LABEL_50;
v7 = v3 + 202;
v8 = a2 + 5;
v9 = v14;
LABEL_14:
memcpy(v7, v8, v9);
return 0LL;
case 0x10:
if ( a3 <= 4u )
goto LABEL_46;
if ( a2[4] + 5 != a3 )
goto LABEL_43;
*(_WORD *)(v3 + 194) = __ROL2__(*(_WORD *)a2, 8);
v10 = __ROL2__(*((_WORD *)a2 + 1), 8);
*(_WORD *)(v3 + 196) = v10;
if ( 2 * v10 != a2[4] )
goto LABEL_43;
if ( v10 > 0x7Fu )
goto LABEL_50;
if ( !*(_WORD *)(v3 + 196) )
return 0LL;
result = 0LL;
v11 = 0LL;
do
{
*(_BYTE *)(v3 + 2 * v11 + 202) = a2[2 * v11 + 6];
*(_BYTE *)(v3 + 2 * v11 + 203) = a2[2 * v11 + 5];
++v11;
}
while ( v11 < *(unsigned __int16 *)(v3 + 196) );
return result;
case 0x16:
if ( a3 != 6 )
goto LABEL_46;
*(_WORD *)(v3 + 194) = __ROL2__(*(_WORD *)a2, 8);
*(_WORD *)(v3 + 198) = __ROL2__(*((_WORD *)a2 + 1), 8);
*(_WORD *)(v3 + 200) = __ROL2__(*((_WORD *)a2 + 2), 8);
return 0LL;
case 0x17:
if ( a3 <= 8u )
goto LABEL_46;
if ( a2[8] + 9 != a3
|| (*(_WORD *)(v3 + 194) = __ROL2__(*(_WORD *)a2, 8),
v19 = __ROL2__(*((_WORD *)a2 + 1), 8),
*(_WORD *)(v3 + 196) = v19,
*(_WORD *)(v3 + 198) = __ROL2__(*((_WORD *)a2 + 2), 8),
v20 = __ROL2__(*((_WORD *)a2 + 3), 8),
*(_WORD *)(v3 + 200) = v20,
2 * v20 != a2[8]) )
{
LABEL_43:
v22 = "Incorrect received data size";
v23 = 16777474LL;
return ModbusServerResourcePrivate::setError(v3, v23, v22);
}
if ( (unsigned __int16)(v19 | v20) > 0x7Fu )
{
LABEL_50:
v22 = "Incorrect data value";
v23 = 16777219LL;
return ModbusServerResourcePrivate::setError(v3, v23, v22);
}
if ( !*(_WORD *)(v3 + 196) )
return 0LL;
result = 0LL;
v21 = 0LL;
do
{
*(_BYTE *)(v3 + 2 * v21 + 202) = a2[2 * v21 + 10];
*(_BYTE *)(v3 + 2 * v21 + 203) = a2[2 * v21 + 9];
++v21;
}
while ( v21 < *(unsigned __int16 *)(v3 + 196) );
return result;
case 0x18:
if ( a3 > 1u )
{
*(_WORD *)(v3 + 194) = __ROL2__(*(_WORD *)a2, 8);
return 0LL;
}
else
{
LABEL_46:
*(_BYTE *)(v3 + 457) = 0;
*(_DWORD *)(v3 + 112) = 16777474;
v15 = *(_QWORD *)(v3 + 128);
v16 = v3 + 120;
v17 = "Incorrect received data size";
v18 = 28LL;
LABEL_47:
std::string::_M_replace(v16, 0LL, v15, v17, v18);
return 16777474LL;
}
default:
*(_BYTE *)(v3 + 457) = 0;
*(_DWORD *)(v3 + 112) = 16777217;
std::string::_M_replace(v3 + 120, 0LL, *(_QWORD *)(v3 + 128), "Unsupported function", 20LL);
return 16777217LL;
}
}
| processInputData:
PUSH RAX
MOV RDI,qword ptr [RDI + 0x8]
MOVZX EAX,byte ptr [RDI + 0xc1]
DEC EAX
CMP EAX,0x17
JA 0x0010e69b
LEA RCX,[0x11a488]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_7:
TEST DX,DX
JNZ 0x0010e667
JMP 0x0010e707
caseD_1:
CMP DX,0x4
JNZ 0x0010e667
MOVZX EAX,word ptr [RSI]
ROL AX,0x8
MOV word ptr [RDI + 0xc2],AX
MOVZX EAX,word ptr [RSI + 0x2]
ROL AX,0x8
MOV word ptr [RDI + 0xc4],AX
MOVZX EAX,AX
CMP EAX,0x7f9
JNC 0x0010e37c
JMP 0x0010e707
caseD_3:
CMP DX,0x4
JNZ 0x0010e667
MOVZX EAX,word ptr [RSI]
ROL AX,0x8
MOV word ptr [RDI + 0xc2],AX
MOVZX EAX,word ptr [RSI + 0x2]
ROL AX,0x8
MOV word ptr [RDI + 0xc4],AX
MOVZX EAX,AX
CMP EAX,0x80
JC 0x0010e707
LAB_0010e37c:
MOV byte ptr [RDI + 0x1c9],0x0
MOV dword ptr [RDI + 0x70],0x1000003
MOV RDX,qword ptr [RDI + 0x80]
ADD RDI,0x78
LEA RCX,[0x11a5bf]
MOV R8D,0x14
XOR ESI,ESI
CALL 0x001054b0
MOV EAX,0x1000003
JMP 0x0010e709
caseD_16:
CMP DX,0x6
JNZ 0x0010e667
MOVZX EAX,word ptr [RSI]
ROL AX,0x8
MOV word ptr [RDI + 0xc2],AX
MOVZX EAX,word ptr [RSI + 0x2]
ROL AX,0x8
MOV word ptr [RDI + 0xc6],AX
MOVZX EAX,word ptr [RSI + 0x4]
ROL AX,0x8
MOV word ptr [RDI + 0xc8],AX
JMP 0x0010e707
caseD_8:
CMP DX,0x1
JBE 0x0010e667
MOVZX EAX,word ptr [RSI]
ROL AX,0x8
MOV word ptr [RDI + 0xc2],AX
ADD EDX,-0x2
MOV word ptr [RDI + 0xc4],DX
ADD RDI,0xca
ADD RSI,0x2
MOVZX EDX,DX
LAB_0010e41e:
CALL 0x001052a0
JMP 0x0010e707
caseD_10:
CMP DX,0x4
JBE 0x0010e667
MOVZX EAX,DX
MOVZX ECX,byte ptr [RSI + 0x4]
ADD ECX,0x5
CMP ECX,EAX
JNZ 0x0010e64f
MOVZX EAX,word ptr [RSI]
ROL AX,0x8
MOV word ptr [RDI + 0xc2],AX
MOVZX EAX,word ptr [RSI + 0x2]
ROL AX,0x8
MOVZX ECX,AX
MOV word ptr [RDI + 0xc4],CX
ADD ECX,ECX
MOVZX EDX,byte ptr [RSI + 0x4]
CMP ECX,EDX
JNZ 0x0010e64f
CMP AX,0x7f
JA 0x0010e6df
CMP word ptr [RDI + 0xc4],0x0
JZ 0x0010e707
XOR EAX,EAX
XOR ECX,ECX
LAB_0010e48e:
MOV DL,byte ptr [RSI + RCX*0x2 + 0x6]
MOV byte ptr [RDI + RCX*0x2 + 0xca],DL
MOV DL,byte ptr [RSI + RCX*0x2 + 0x5]
MOV byte ptr [RDI + RCX*0x2 + 0xcb],DL
INC RCX
MOVZX EDX,word ptr [RDI + 0xc4]
CMP RCX,RDX
JC 0x0010e48e
JMP 0x0010e709
caseD_f:
CMP DX,0x4
JBE 0x0010e667
MOVZX EAX,DX
MOVZX ECX,byte ptr [RSI + 0x4]
ADD ECX,0x5
CMP ECX,EAX
JNZ 0x0010e64f
MOVZX EAX,word ptr [RSI]
ROL AX,0x8
MOV word ptr [RDI + 0xc2],AX
MOVZX EAX,word ptr [RSI + 0x2]
ROL AX,0x8
MOVZX ECX,AX
MOV word ptr [RDI + 0xc4],CX
LEA EAX,[RCX + 0x7]
SHR EAX,0x3
MOVZX EDX,byte ptr [RSI + 0x4]
CMP EAX,EDX
JNZ 0x0010e64f
CMP ECX,0x7f9
JNC 0x0010e6df
ADD RDI,0xca
ADD RSI,0x5
MOV EDX,EAX
JMP 0x0010e41e
caseD_5:
CMP DX,0x4
JNZ 0x0010e667
MOVZX EAX,byte ptr [RSI + 0x2]
CMP EAX,0xff
JZ 0x0010e53d
TEST EAX,EAX
JNZ 0x0010e547
LAB_0010e53d:
CMP byte ptr [RSI + 0x3],0x0
JZ 0x0010e6f0
LAB_0010e547:
MOV byte ptr [RDI + 0x1c9],0x0
MOV dword ptr [RDI + 0x70],0x1000102
MOV RDX,qword ptr [RDI + 0x80]
ADD RDI,0x78
LEA RCX,[0x11a5bf]
MOV R8D,0x14
JMP 0x0010e68d
caseD_6:
CMP DX,0x4
JNZ 0x0010e667
MOVZX EAX,word ptr [RSI]
ROL AX,0x8
MOV word ptr [RDI + 0xc2],AX
MOV AL,byte ptr [RSI + 0x3]
MOV byte ptr [RDI + 0xca],AL
MOV AL,byte ptr [RSI + 0x2]
MOV byte ptr [RDI + 0xcb],AL
JMP 0x0010e707
caseD_17:
CMP DX,0x8
JBE 0x0010e667
MOVZX EAX,DX
MOVZX ECX,byte ptr [RSI + 0x8]
ADD ECX,0x9
CMP ECX,EAX
JNZ 0x0010e64f
MOVZX EAX,word ptr [RSI]
ROL AX,0x8
MOV word ptr [RDI + 0xc2],AX
MOVZX EAX,word ptr [RSI + 0x2]
ROL AX,0x8
MOV word ptr [RDI + 0xc4],AX
MOVZX ECX,word ptr [RSI + 0x4]
ROL CX,0x8
MOV word ptr [RDI + 0xc6],CX
MOVZX ECX,word ptr [RSI + 0x6]
ROL CX,0x8
MOVZX EDX,CX
MOV word ptr [RDI + 0xc8],DX
ADD EDX,EDX
MOVZX R8D,byte ptr [RSI + 0x8]
CMP EDX,R8D
JNZ 0x0010e64f
OR ECX,EAX
CMP CX,0x7f
JA 0x0010e6df
CMP word ptr [RDI + 0xc4],0x0
JZ 0x0010e707
XOR EAX,EAX
XOR ECX,ECX
LAB_0010e625:
MOV DL,byte ptr [RSI + RCX*0x2 + 0xa]
MOV byte ptr [RDI + RCX*0x2 + 0xca],DL
MOV DL,byte ptr [RSI + RCX*0x2 + 0x9]
MOV byte ptr [RDI + RCX*0x2 + 0xcb],DL
INC RCX
MOVZX EDX,word ptr [RDI + 0xc4]
CMP RCX,RDX
JC 0x0010e625
JMP 0x0010e709
LAB_0010e64f:
LEA RDX,[0x119e36]
MOV ESI,0x1000102
LAB_0010e65b:
POP RAX
JMP 0x0010ede8
caseD_18:
CMP DX,0x1
JA 0x0010e6cf
LAB_0010e667:
MOV byte ptr [RDI + 0x1c9],0x0
MOV dword ptr [RDI + 0x70],0x1000102
MOV RDX,qword ptr [RDI + 0x80]
ADD RDI,0x78
LEA RCX,[0x119e36]
MOV R8D,0x1c
LAB_0010e68d:
XOR ESI,ESI
CALL 0x001054b0
MOV EAX,0x1000102
JMP 0x0010e709
caseD_9:
MOV byte ptr [RDI + 0x1c9],0x0
MOV dword ptr [RDI + 0x70],0x1000001
MOV RDX,qword ptr [RDI + 0x80]
ADD RDI,0x78
LEA RCX,[0x11a5d4]
MOV R8D,0x14
XOR ESI,ESI
CALL 0x001054b0
MOV EAX,0x1000001
JMP 0x0010e709
LAB_0010e6cf:
MOVZX EAX,word ptr [RSI]
ROL AX,0x8
MOV word ptr [RDI + 0xc2],AX
JMP 0x0010e707
LAB_0010e6df:
LEA RDX,[0x11a5bf]
MOV ESI,0x1000003
JMP 0x0010e65b
LAB_0010e6f0:
MOVZX EAX,word ptr [RSI]
ROL AX,0x8
MOV word ptr [RDI + 0xc2],AX
MOV AL,byte ptr [RSI + 0x2]
MOV byte ptr [RDI + 0xca],AL
LAB_0010e707:
XOR EAX,EAX
LAB_0010e709:
POP RCX
RET
|
/* ModbusServerResource::processInputData(unsigned char const*, unsigned short) */
int8 __thiscall
ModbusServerResource::processInputData(ModbusServerResource *this,uchar *param_1,ushort param_2)
{
ModbusServerResourcePrivate *pMVar1;
ushort uVar2;
uint uVar3;
ushort uVar4;
ulong uVar5;
char *pcVar6;
size_t __n;
char *pcVar7;
uchar *__src;
int8 uVar8;
pMVar1 = *(ModbusServerResourcePrivate **)(this + 8);
switch(pMVar1[0xc1]) {
case (ModbusServerResourcePrivate)0x1:
case (ModbusServerResourcePrivate)0x2:
if (param_2 == 4) {
*(ushort *)(pMVar1 + 0xc2) = *(ushort *)param_1 << 8 | *(ushort *)param_1 >> 8;
uVar2 = *(ushort *)(param_1 + 2) << 8 | *(ushort *)(param_1 + 2) >> 8;
*(ushort *)(pMVar1 + 0xc4) = uVar2;
if (uVar2 < 0x7f9) {
return 0;
}
LAB_0010e37c:
pMVar1[0x1c9] = (ModbusServerResourcePrivate)0x0;
*(int4 *)(pMVar1 + 0x70) = 0x1000003;
std::__cxx11::string::_M_replace((ulong)(pMVar1 + 0x78),0,*(char **)(pMVar1 + 0x80),0x11a5bf);
return 0x1000003;
}
break;
case (ModbusServerResourcePrivate)0x3:
case (ModbusServerResourcePrivate)0x4:
if (param_2 == 4) {
*(ushort *)(pMVar1 + 0xc2) = *(ushort *)param_1 << 8 | *(ushort *)param_1 >> 8;
uVar2 = *(ushort *)(param_1 + 2) << 8 | *(ushort *)(param_1 + 2) >> 8;
*(ushort *)(pMVar1 + 0xc4) = uVar2;
if (uVar2 < 0x80) {
return 0;
}
goto LAB_0010e37c;
}
break;
case (ModbusServerResourcePrivate)0x5:
if (param_2 == 4) {
if (((param_1[2] == 0xff) || (param_1[2] == '\0')) && (param_1[3] == '\0')) {
*(ushort *)(pMVar1 + 0xc2) = *(ushort *)param_1 << 8 | *(ushort *)param_1 >> 8;
pMVar1[0xca] = *(ModbusServerResourcePrivate *)(param_1 + 2);
return 0;
}
pMVar1[0x1c9] = (ModbusServerResourcePrivate)0x0;
*(int4 *)(pMVar1 + 0x70) = 0x1000102;
pcVar7 = *(char **)(pMVar1 + 0x80);
pcVar6 = "Incorrect data value";
goto LAB_0010e68d;
}
break;
case (ModbusServerResourcePrivate)0x6:
if (param_2 == 4) {
*(ushort *)(pMVar1 + 0xc2) = *(ushort *)param_1 << 8 | *(ushort *)param_1 >> 8;
pMVar1[0xca] = *(ModbusServerResourcePrivate *)(param_1 + 3);
pMVar1[0xcb] = *(ModbusServerResourcePrivate *)(param_1 + 2);
return 0;
}
break;
case (ModbusServerResourcePrivate)0x7:
case (ModbusServerResourcePrivate)0xb:
case (ModbusServerResourcePrivate)0xc:
case (ModbusServerResourcePrivate)0x11:
if (param_2 == 0) {
return 0;
}
break;
case (ModbusServerResourcePrivate)0x8:
if (1 < param_2) {
*(ushort *)(pMVar1 + 0xc2) = *(ushort *)param_1 << 8 | *(ushort *)param_1 >> 8;
*(ushort *)(pMVar1 + 0xc4) = param_2 - 2;
__src = param_1 + 2;
__n = (size_t)(ushort)(param_2 - 2);
LAB_0010e41e:
memcpy(pMVar1 + 0xca,__src,__n);
return 0;
}
break;
default:
pMVar1[0x1c9] = (ModbusServerResourcePrivate)0x0;
*(int4 *)(pMVar1 + 0x70) = 0x1000001;
std::__cxx11::string::_M_replace((ulong)(pMVar1 + 0x78),0,*(char **)(pMVar1 + 0x80),0x11a5d4);
return 0x1000001;
case (ModbusServerResourcePrivate)0xf:
if (4 < param_2) {
if ((ushort)(param_1[4] + 5) == param_2) {
*(ushort *)(pMVar1 + 0xc2) = *(ushort *)param_1 << 8 | *(ushort *)param_1 >> 8;
uVar2 = *(ushort *)(param_1 + 2) << 8 | *(ushort *)(param_1 + 2) >> 8;
*(ushort *)(pMVar1 + 0xc4) = uVar2;
uVar3 = uVar2 + 7 >> 3;
if (uVar3 == param_1[4]) {
if (uVar2 < 0x7f9) {
__src = param_1 + 5;
__n = (size_t)uVar3;
goto LAB_0010e41e;
}
LAB_0010e6df:
pcVar7 = "Incorrect data value";
uVar8 = 0x1000003;
goto LAB_0010e65b;
}
}
LAB_0010e64f:
pcVar7 = "Incorrect received data size";
uVar8 = 0x1000102;
LAB_0010e65b:
uVar8 = ModbusServerResourcePrivate::setError(pMVar1,uVar8,pcVar7);
return uVar8;
}
break;
case (ModbusServerResourcePrivate)0x10:
if (4 < param_2) {
if ((ushort)(param_1[4] + 5) == param_2) {
*(ushort *)(pMVar1 + 0xc2) = *(ushort *)param_1 << 8 | *(ushort *)param_1 >> 8;
uVar2 = *(ushort *)(param_1 + 2) << 8 | *(ushort *)(param_1 + 2) >> 8;
*(ushort *)(pMVar1 + 0xc4) = uVar2;
if ((uint)uVar2 * 2 == (uint)param_1[4]) {
if (uVar2 < 0x80) {
if (*(short *)(pMVar1 + 0xc4) == 0) {
return 0;
}
uVar5 = 0;
do {
pMVar1[uVar5 * 2 + 0xca] = *(ModbusServerResourcePrivate *)(param_1 + uVar5 * 2 + 6);
pMVar1[uVar5 * 2 + 0xcb] = *(ModbusServerResourcePrivate *)(param_1 + uVar5 * 2 + 5);
uVar5 = uVar5 + 1;
} while (uVar5 < *(ushort *)(pMVar1 + 0xc4));
return 0;
}
goto LAB_0010e6df;
}
}
goto LAB_0010e64f;
}
break;
case (ModbusServerResourcePrivate)0x16:
if (param_2 == 6) {
*(ushort *)(pMVar1 + 0xc2) = *(ushort *)param_1 << 8 | *(ushort *)param_1 >> 8;
*(ushort *)(pMVar1 + 0xc6) = *(ushort *)(param_1 + 2) << 8 | *(ushort *)(param_1 + 2) >> 8;
*(ushort *)(pMVar1 + 200) = *(ushort *)(param_1 + 4) << 8 | *(ushort *)(param_1 + 4) >> 8;
return 0;
}
break;
case (ModbusServerResourcePrivate)0x17:
if (8 < param_2) {
if ((ushort)(param_1[8] + 9) == param_2) {
*(ushort *)(pMVar1 + 0xc2) = *(ushort *)param_1 << 8 | *(ushort *)param_1 >> 8;
uVar2 = *(ushort *)(param_1 + 2) << 8 | *(ushort *)(param_1 + 2) >> 8;
*(ushort *)(pMVar1 + 0xc4) = uVar2;
*(ushort *)(pMVar1 + 0xc6) = *(ushort *)(param_1 + 4) << 8 | *(ushort *)(param_1 + 4) >> 8;
uVar4 = *(ushort *)(param_1 + 6) << 8 | *(ushort *)(param_1 + 6) >> 8;
*(ushort *)(pMVar1 + 200) = uVar4;
if ((uint)uVar4 * 2 == (uint)param_1[8]) {
if ((uVar4 | uVar2) < 0x80) {
if (*(short *)(pMVar1 + 0xc4) == 0) {
return 0;
}
uVar5 = 0;
do {
pMVar1[uVar5 * 2 + 0xca] = *(ModbusServerResourcePrivate *)(param_1 + uVar5 * 2 + 10);
pMVar1[uVar5 * 2 + 0xcb] = *(ModbusServerResourcePrivate *)(param_1 + uVar5 * 2 + 9);
uVar5 = uVar5 + 1;
} while (uVar5 < *(ushort *)(pMVar1 + 0xc4));
return 0;
}
goto LAB_0010e6df;
}
}
goto LAB_0010e64f;
}
break;
case (ModbusServerResourcePrivate)0x18:
if (1 < param_2) {
*(ushort *)(pMVar1 + 0xc2) = *(ushort *)param_1 << 8 | *(ushort *)param_1 >> 8;
return 0;
}
}
pMVar1[0x1c9] = (ModbusServerResourcePrivate)0x0;
*(int4 *)(pMVar1 + 0x70) = 0x1000102;
pcVar7 = *(char **)(pMVar1 + 0x80);
pcVar6 = "Incorrect received data size";
LAB_0010e68d:
std::__cxx11::string::_M_replace((ulong)(pMVar1 + 0x78),0,pcVar7,(ulong)pcVar6);
return 0x1000102;
}
| |
41,693 | ModbusServerResource::processInputData(unsigned char const*, unsigned short) | serhmarch[P]ModbusBridge/modbus/src/ModbusServerResource.cpp | StatusCode ModbusServerResource::processInputData(const uint8_t *buff, uint16_t sz)
{
ModbusServerResourcePrivate *d = d_ModbusServerResource(d_ptr);
switch (d->func)
{
#ifndef MBF_READ_COILS_DISABLE
case MBF_READ_COILS:
#endif // MBF_READ_COILS_DISABLE
#ifndef MBF_READ_DISCRETE_INPUTS_DISABLE
case MBF_READ_DISCRETE_INPUTS:
#endif // MBF_READ_DISCRETE_INPUTS
#if !defined(MBF_READ_COILS_DISABLE) || !defined(MBF_READ_DISCRETE_INPUTS_DISABLE)
if (sz != 4) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
d->offset = buff[1] | (buff[0] << 8);
d->count = buff[3] | (buff[2] << 8);
if (d->count > MB_MAX_DISCRETS) // prevent valueBuff overflow
return d->setError(Status_BadIllegalDataValue, StringLiteral("Incorrect data value"));
break;
#endif // !defined(MBF_READ_COILS_DISABLE) || !defined(MBF_READ_DISCRETE_INPUTS_DISABLE)
#ifndef MBF_READ_HOLDING_REGISTERS_DISABLE
case MBF_READ_HOLDING_REGISTERS:
#endif // MBF_READ_HOLDING_REGISTERS_DISABLE
#ifndef MBF_READ_INPUT_REGISTERS_DISABLE
case MBF_READ_INPUT_REGISTERS:
#endif // MBF_READ_INPUT_REGISTERS_DISABLE
#if !defined(MBF_READ_HOLDING_REGISTERS_DISABLE) || !defined(MBF_READ_INPUT_REGISTERS_DISABLE)
if (sz != 4) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
d->offset = buff[1] | (buff[0]<<8);
d->count = buff[3] | (buff[2]<<8);
if (d->count > MB_MAX_REGISTERS) // prevent valueBuff overflow
return d->setError(Status_BadIllegalDataValue, StringLiteral("Incorrect data value"));
break;
#endif // !defined(MBF_READ_HOLDING_REGISTERS_DISABLE) || !defined(MBF_READ_INPUT_REGISTERS_DISABLE)
#ifndef MBF_WRITE_SINGLE_COIL_DISABLE
case MBF_WRITE_SINGLE_COIL:
if (sz != 4) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
if (!(buff[2] == 0x00 || buff[2] == 0xFF) || (buff[3] != 0)) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect data value"));
d->offset = buff[1] | (buff[0]<<8);
d->valueBuff[0] = buff[2];
break;
#endif // MBF_WRITE_SINGLE_COIL_DISABLE
#ifndef MBF_WRITE_SINGLE_REGISTER_DISABLE
case MBF_WRITE_SINGLE_REGISTER:
if (sz != 4) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
d->offset = buff[1] | (buff[0]<<8);
d->valueBuff[0] = buff[3];
d->valueBuff[1] = buff[2];
break;
#endif // MBF_WRITE_SINGLE_REGISTER_DISABLE
#ifndef MBF_READ_EXCEPTION_STATUS_DISABLE
case MBF_READ_EXCEPTION_STATUS:
if (sz > 0) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
break;
#endif // MBF_READ_EXCEPTION_STATUS_DISABLE
#ifndef MBF_DIAGNOSTICS_DISABLE
case MBF_DIAGNOSTICS:
if (sz < 2) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
d->subfunc = buff[1] | (buff[0]<<8);
d->count = sz - 2;
memcpy(d->valueBuff, &buff[2], d->count);
break;
#endif // MBF_DIAGNOSTICS_DISABLE
#ifndef MBF_GET_COMM_EVENT_COUNTER_DISABLE
case MBF_GET_COMM_EVENT_COUNTER:
if (sz > 0) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
break;
#endif // MBF_GET_COMM_EVENT_COUNTER_DISABLE
#ifndef MBF_GET_COMM_EVENT_LOG_DISABLE
case MBF_GET_COMM_EVENT_LOG:
if (sz > 0) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
break;
#endif // MBF_GET_COMM_EVENT_LOG_DISABLE
#ifndef MBF_WRITE_MULTIPLE_COILS_DISABLE
case MBF_WRITE_MULTIPLE_COILS: // Write multiple coils
if (sz < 5) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
if (sz != buff[4]+5) // don't match readed bytes and number of data bytes to follow
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
d->offset = buff[1] | (buff[0]<<8);
d->count = buff[3] | (buff[2]<<8);
if ((d->count+7)/8 != buff[4]) // don't match count bites and bytes
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
if (d->count > MB_MAX_DISCRETS) // prevent valueBuff overflow
return d->setError(Status_BadIllegalDataValue, StringLiteral("Incorrect data value"));
memcpy(d->valueBuff, &buff[5], (d->count+7)/8);
break;
#endif // MBF_WRITE_MULTIPLE_COILS_DISABLE
#ifndef MBF_WRITE_MULTIPLE_REGISTERS_DISABLE
case MBF_WRITE_MULTIPLE_REGISTERS:
if (sz < 5) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
if (sz != buff[4]+5) // don't match readed bytes and number of data bytes to follow
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
d->offset = buff[1] | (buff[0]<<8);
d->count = buff[3] | (buff[2]<<8);
if (d->count*2 != buff[4]) // don't match count values and bytes
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
if (d->count > MB_MAX_REGISTERS) // prevent valueBuff overflow
return d->setError(Status_BadIllegalDataValue, StringLiteral("Incorrect data value"));
for (uint16_t i = 0; i < d->count; i++)
{
d->valueBuff[i*2] = buff[6+i*2];
d->valueBuff[i*2+1] = buff[5+i*2];
}
break;
#endif // MBF_WRITE_MULTIPLE_REGISTERS_DISABLE
#ifndef MBF_REPORT_SERVER_ID_DISABLE
case MBF_REPORT_SERVER_ID:
if (sz > 0) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
break;
#endif // MBF_REPORT_SERVER_ID_DISABLE
#ifndef MBF_MASK_WRITE_REGISTER_DISABLE
case MBF_MASK_WRITE_REGISTER:
if (sz != 6) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
d->offset = buff[1] | (buff[0]<<8);
d->andMask = buff[3] | (buff[2]<<8);
d->orMask = buff[5] | (buff[4]<<8);
break;
#endif // MBF_MASK_WRITE_REGISTER_DISABLE
#ifndef MBF_READ_WRITE_MULTIPLE_REGISTERS_DISABLE
case MBF_READ_WRITE_MULTIPLE_REGISTERS:
if (sz < 9) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
if (sz != buff[8]+9) // don't match readed bytes and number of data bytes to follow
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
d->offset = buff[1] | (buff[0]<<8);
d->count = buff[3] | (buff[2]<<8);
d->writeOffset = buff[5] | (buff[4]<<8);
d->writeCount = buff[7] | (buff[6]<<8);
if (d->writeCount*2 != buff[8]) // don't match count values and bytes
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
if ((d->count > MB_MAX_REGISTERS) || (d->writeCount > MB_MAX_REGISTERS)) // prevent valueBuff overflow
return d->setError(Status_BadIllegalDataValue, StringLiteral("Incorrect data value"));
for (uint16_t i = 0; i < d->count; i++)
{
d->valueBuff[i*2] = buff[10+i*2];
d->valueBuff[i*2+1] = buff[ 9+i*2];
}
break;
#endif // MBF_READ_WRITE_MULTIPLE_REGISTERS_DISABLE
#ifndef MBF_READ_FIFO_QUEUE_DISABLE
case MBF_READ_FIFO_QUEUE:
if (sz < 2) // Incorrect request from client - don't respond
return d->setError(Status_BadNotCorrectRequest, StringLiteral("Incorrect received data size"));
d->offset = buff[1] | (buff[0]<<8);
break;
#endif // MBF_READ_FIFO_QUEUE_DISABLE
default:
return d->setError(Status_BadIllegalFunction, StringLiteral("Unsupported function"));
}
return Status_Good;
} | O3 | cpp | ModbusServerResource::processInputData(unsigned char const*, unsigned short):
pushq %rax
movq 0x8(%rdi), %rdi
movzbl 0xc1(%rdi), %eax
decl %eax
cmpl $0x17, %eax
ja 0xe6ff
leaq 0xb100(%rip), %rcx # 0x19468
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
testw %dx, %dx
jne 0xe6cb
jmp 0xe76b
cmpw $0x4, %dx
jne 0xe6cb
movzwl (%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc2(%rdi)
movzwl 0x2(%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc4(%rdi)
movzwl %ax, %eax
cmpl $0x7f9, %eax # imm = 0x7F9
jae 0xe3ea
jmp 0xe76b
cmpw $0x4, %dx
jne 0xe6cb
movzwl (%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc2(%rdi)
movzwl 0x2(%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc4(%rdi)
movzwl %ax, %eax
cmpl $0x80, %eax
jb 0xe76b
movb $0x0, 0x1c9(%rdi)
movl $0x1000003, 0x70(%rdi) # imm = 0x1000003
movq 0x80(%rdi), %rdx
addq $0x78, %rdi
leaq 0xb195(%rip), %rcx # 0x1959f
movl $0x14, %r8d
xorl %esi, %esi
callq 0x54b0
movl $0x1000003, %eax # imm = 0x1000003
jmp 0xe76d
cmpw $0x6, %dx
jne 0xe6cb
movzwl (%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc2(%rdi)
movzwl 0x2(%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc6(%rdi)
movzwl 0x4(%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc8(%rdi)
jmp 0xe76b
cmpw $0x1, %dx
jbe 0xe6cb
movzwl (%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc2(%rdi)
addl $-0x2, %edx
movw %dx, 0xc4(%rdi)
addq $0xca, %rdi
addq $0x2, %rsi
movzwl %dx, %edx
callq 0x52a0
jmp 0xe76b
cmpw $0x4, %dx
jbe 0xe6cb
movzwl %dx, %eax
movzbl 0x4(%rsi), %ecx
addl $0x5, %ecx
cmpl %eax, %ecx
jne 0xe6b3
movzwl (%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc2(%rdi)
movzwl 0x2(%rsi), %eax
rolw $0x8, %ax
movzwl %ax, %ecx
movw %cx, 0xc4(%rdi)
leal (%rcx,%rcx), %edx
movzbl 0x4(%rsi), %r8d
cmpl %r8d, %edx
jne 0xe6b3
cmpw $0x7f, %ax
ja 0xe743
testw %ax, %ax
je 0xe76b
xorl %eax, %eax
xorl %edx, %edx
movb 0x6(%rsi,%rdx,2), %r8b
movb %r8b, 0xca(%rdi,%rdx,2)
movb 0x5(%rsi,%rdx,2), %r8b
movb %r8b, 0xcb(%rdi,%rdx,2)
incq %rdx
cmpq %rcx, %rdx
jb 0xe4fa
jmp 0xe76d
cmpw $0x4, %dx
jbe 0xe6cb
movzwl %dx, %eax
movzbl 0x4(%rsi), %ecx
addl $0x5, %ecx
cmpl %eax, %ecx
jne 0xe6b3
movzwl (%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc2(%rdi)
movzwl 0x2(%rsi), %eax
rolw $0x8, %ax
movzwl %ax, %ecx
movw %cx, 0xc4(%rdi)
leal 0x7(%rcx), %eax
shrl $0x3, %eax
movzbl 0x4(%rsi), %edx
cmpl %edx, %eax
jne 0xe6b3
cmpl $0x7f9, %ecx # imm = 0x7F9
jae 0xe743
addq $0xca, %rdi
addq $0x5, %rsi
movl %eax, %edx
jmp 0xe48c
cmpw $0x4, %dx
jne 0xe6cb
movzbl 0x2(%rsi), %eax
cmpl $0xff, %eax
je 0xe5a6
testl %eax, %eax
jne 0xe5b0
cmpb $0x0, 0x3(%rsi)
je 0xe754
movb $0x0, 0x1c9(%rdi)
movl $0x1000102, 0x70(%rdi) # imm = 0x1000102
movq 0x80(%rdi), %rdx
addq $0x78, %rdi
leaq 0xafcf(%rip), %rcx # 0x1959f
movl $0x14, %r8d
jmp 0xe6f1
cmpw $0x4, %dx
jne 0xe6cb
movzwl (%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc2(%rdi)
movb 0x3(%rsi), %al
movb %al, 0xca(%rdi)
movb 0x2(%rsi), %al
movb %al, 0xcb(%rdi)
jmp 0xe76b
cmpw $0x8, %dx
jbe 0xe6cb
movzwl %dx, %eax
movzbl 0x8(%rsi), %ecx
addl $0x9, %ecx
cmpl %eax, %ecx
jne 0xe6b3
movzwl (%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc2(%rdi)
movzwl 0x2(%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc4(%rdi)
movzwl 0x4(%rsi), %ecx
rolw $0x8, %cx
movw %cx, 0xc6(%rdi)
movzwl 0x6(%rsi), %ecx
rolw $0x8, %cx
movzwl %cx, %edx
movw %dx, 0xc8(%rdi)
addl %edx, %edx
movzbl 0x8(%rsi), %r8d
cmpl %r8d, %edx
jne 0xe6b3
orl %eax, %ecx
cmpw $0x7f, %cx
ja 0xe743
testw %ax, %ax
je 0xe76b
movzwl %ax, %ecx
xorl %eax, %eax
xorl %edx, %edx
movb 0xa(%rsi,%rdx,2), %r8b
movb %r8b, 0xca(%rdi,%rdx,2)
movb 0x9(%rsi,%rdx,2), %r8b
movb %r8b, 0xcb(%rdi,%rdx,2)
incq %rdx
cmpq %rcx, %rdx
jb 0xe68c
jmp 0xe76d
leaq 0xa760(%rip), %rdx # 0x18e1a
movl $0x1000102, %esi # imm = 0x1000102
popq %rax
jmp 0xee48
cmpw $0x1, %dx
ja 0xe733
movb $0x0, 0x1c9(%rdi)
movl $0x1000102, 0x70(%rdi) # imm = 0x1000102
movq 0x80(%rdi), %rdx
addq $0x78, %rdi
leaq 0xa72f(%rip), %rcx # 0x18e1a
movl $0x1c, %r8d
xorl %esi, %esi
callq 0x54b0
movl $0x1000102, %eax # imm = 0x1000102
jmp 0xe76d
movb $0x0, 0x1c9(%rdi)
movl $0x1000001, 0x70(%rdi) # imm = 0x1000001
movq 0x80(%rdi), %rdx
addq $0x78, %rdi
leaq 0xae95(%rip), %rcx # 0x195b4
movl $0x14, %r8d
xorl %esi, %esi
callq 0x54b0
movl $0x1000001, %eax # imm = 0x1000001
jmp 0xe76d
movzwl (%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc2(%rdi)
jmp 0xe76b
leaq 0xae55(%rip), %rdx # 0x1959f
movl $0x1000003, %esi # imm = 0x1000003
jmp 0xe6bf
movzwl (%rsi), %eax
rolw $0x8, %ax
movw %ax, 0xc2(%rdi)
movb 0x2(%rsi), %al
movb %al, 0xca(%rdi)
xorl %eax, %eax
popq %rcx
retq
nop
| _ZN20ModbusServerResource16processInputDataEPKht:
push rax
mov rdi, [rdi+8]
movzx eax, byte ptr [rdi+0C1h]
dec eax; switch 24 cases
cmp eax, 17h
ja def_E36F; jumptable 000000000000E36F default case, cases 9,10,13,14,18-21
lea rcx, jpt_E36F
movsxd rax, ds:(jpt_E36F - 19468h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_E371:
test dx, dx; jumptable 000000000000E36F cases 7,11,12,17
jnz loc_E6CB
jmp loc_E76B
loc_E37F:
cmp dx, 4; jumptable 000000000000E36F cases 1,2
jnz loc_E6CB
movzx eax, word ptr [rsi]
rol ax, 8
mov [rdi+0C2h], ax
movzx eax, word ptr [rsi+2]
rol ax, 8
mov [rdi+0C4h], ax
movzx eax, ax
cmp eax, 7F9h
jnb short loc_E3EA
jmp loc_E76B
loc_E3B5:
cmp dx, 4; jumptable 000000000000E36F cases 3,4
jnz loc_E6CB
movzx eax, word ptr [rsi]
rol ax, 8
mov [rdi+0C2h], ax
movzx eax, word ptr [rsi+2]
rol ax, 8
mov [rdi+0C4h], ax
movzx eax, ax
cmp eax, 80h
jb loc_E76B
loc_E3EA:
mov byte ptr [rdi+1C9h], 0
mov dword ptr [rdi+70h], 1000003h
mov rdx, [rdi+80h]
add rdi, 78h ; 'x'
lea rcx, aIncorrectDataV; "Incorrect data value"
mov r8d, 14h
xor esi, esi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
mov eax, 1000003h
jmp loc_E76D
loc_E421:
cmp dx, 6; jumptable 000000000000E36F case 22
jnz loc_E6CB
movzx eax, word ptr [rsi]
rol ax, 8
mov [rdi+0C2h], ax
movzx eax, word ptr [rsi+2]
rol ax, 8
mov [rdi+0C6h], ax
movzx eax, word ptr [rsi+4]
rol ax, 8
mov [rdi+0C8h], ax
jmp loc_E76B
loc_E45C:
cmp dx, 1; jumptable 000000000000E36F case 8
jbe loc_E6CB
movzx eax, word ptr [rsi]
rol ax, 8
mov [rdi+0C2h], ax
add edx, 0FFFFFFFEh
mov [rdi+0C4h], dx
add rdi, 0CAh
add rsi, 2
movzx edx, dx
loc_E48C:
call _memcpy
jmp loc_E76B
loc_E496:
cmp dx, 4; jumptable 000000000000E36F case 16
jbe loc_E6CB
movzx eax, dx
movzx ecx, byte ptr [rsi+4]
add ecx, 5
cmp ecx, eax
jnz loc_E6B3
movzx eax, word ptr [rsi]
rol ax, 8
mov [rdi+0C2h], ax
movzx eax, word ptr [rsi+2]
rol ax, 8
movzx ecx, ax
mov [rdi+0C4h], cx
lea edx, [rcx+rcx]
movzx r8d, byte ptr [rsi+4]
cmp edx, r8d
jnz loc_E6B3
cmp ax, 7Fh
ja loc_E743
test ax, ax
jz loc_E76B
xor eax, eax
xor edx, edx
loc_E4FA:
mov r8b, [rsi+rdx*2+6]
mov [rdi+rdx*2+0CAh], r8b
mov r8b, [rsi+rdx*2+5]
mov [rdi+rdx*2+0CBh], r8b
inc rdx
cmp rdx, rcx
jb short loc_E4FA
jmp loc_E76D
loc_E521:
cmp dx, 4; jumptable 000000000000E36F case 15
jbe loc_E6CB
movzx eax, dx
movzx ecx, byte ptr [rsi+4]
add ecx, 5
cmp ecx, eax
jnz loc_E6B3
movzx eax, word ptr [rsi]
rol ax, 8
mov [rdi+0C2h], ax
movzx eax, word ptr [rsi+2]
rol ax, 8
movzx ecx, ax
mov [rdi+0C4h], cx
lea eax, [rcx+7]
shr eax, 3
movzx edx, byte ptr [rsi+4]
cmp eax, edx
jnz loc_E6B3
cmp ecx, 7F9h
jnb loc_E743
add rdi, 0CAh
add rsi, 5
mov edx, eax
jmp loc_E48C
loc_E58D:
cmp dx, 4; jumptable 000000000000E36F case 5
jnz loc_E6CB
movzx eax, byte ptr [rsi+2]
cmp eax, 0FFh
jz short loc_E5A6
test eax, eax
jnz short loc_E5B0
loc_E5A6:
cmp byte ptr [rsi+3], 0
jz loc_E754
loc_E5B0:
mov byte ptr [rdi+1C9h], 0
mov dword ptr [rdi+70h], 1000102h
mov rdx, [rdi+80h]
add rdi, 78h ; 'x'
lea rcx, aIncorrectDataV; "Incorrect data value"
mov r8d, 14h
jmp loc_E6F1
loc_E5DB:
cmp dx, 4; jumptable 000000000000E36F case 6
jnz loc_E6CB
movzx eax, word ptr [rsi]
rol ax, 8
mov [rdi+0C2h], ax
mov al, [rsi+3]
mov [rdi+0CAh], al
mov al, [rsi+2]
mov [rdi+0CBh], al
jmp loc_E76B
loc_E60A:
cmp dx, 8; jumptable 000000000000E36F case 23
jbe loc_E6CB
movzx eax, dx
movzx ecx, byte ptr [rsi+8]
add ecx, 9
cmp ecx, eax
jnz loc_E6B3
movzx eax, word ptr [rsi]
rol ax, 8
mov [rdi+0C2h], ax
movzx eax, word ptr [rsi+2]
rol ax, 8
mov [rdi+0C4h], ax
movzx ecx, word ptr [rsi+4]
rol cx, 8
mov [rdi+0C6h], cx
movzx ecx, word ptr [rsi+6]
rol cx, 8
movzx edx, cx
mov [rdi+0C8h], dx
add edx, edx
movzx r8d, byte ptr [rsi+8]
cmp edx, r8d
jnz short loc_E6B3
or ecx, eax
cmp cx, 7Fh
ja loc_E743
test ax, ax
jz loc_E76B
movzx ecx, ax
xor eax, eax
xor edx, edx
loc_E68C:
mov r8b, [rsi+rdx*2+0Ah]
mov [rdi+rdx*2+0CAh], r8b
mov r8b, [rsi+rdx*2+9]
mov [rdi+rdx*2+0CBh], r8b
inc rdx
cmp rdx, rcx
jb short loc_E68C
jmp loc_E76D
loc_E6B3:
lea rdx, aIncorrectRecei; "Incorrect received data size"
mov esi, 1000102h
loc_E6BF:
pop rax
jmp _ZN27ModbusServerResourcePrivate8setErrorEN6Modbus10StatusCodeEPKc; ModbusServerResourcePrivate::setError(Modbus::StatusCode,char const*)
loc_E6C5:
cmp dx, 1; jumptable 000000000000E36F case 24
ja short loc_E733
loc_E6CB:
mov byte ptr [rdi+1C9h], 0
mov dword ptr [rdi+70h], 1000102h
mov rdx, [rdi+80h]
add rdi, 78h ; 'x'
lea rcx, aIncorrectRecei; "Incorrect received data size"
mov r8d, 1Ch
loc_E6F1:
xor esi, esi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
mov eax, 1000102h
jmp short loc_E76D
def_E36F:
mov byte ptr [rdi+1C9h], 0; jumptable 000000000000E36F default case, cases 9,10,13,14,18-21
mov dword ptr [rdi+70h], 1000001h
mov rdx, [rdi+80h]
add rdi, 78h ; 'x'
lea rcx, aUnsupportedFun; "Unsupported function"
mov r8d, 14h
xor esi, esi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
mov eax, 1000001h
jmp short loc_E76D
loc_E733:
movzx eax, word ptr [rsi]
rol ax, 8
mov [rdi+0C2h], ax
jmp short loc_E76B
loc_E743:
lea rdx, aIncorrectDataV; "Incorrect data value"
mov esi, 1000003h
jmp loc_E6BF
loc_E754:
movzx eax, word ptr [rsi]
rol ax, 8
mov [rdi+0C2h], ax
mov al, [rsi+2]
mov [rdi+0CAh], al
loc_E76B:
xor eax, eax
loc_E76D:
pop rcx
retn
| long long ModbusServerResource::processInputData(
ModbusServerResource *this,
const unsigned __int8 *a2,
unsigned __int16 a3)
{
long long v3; // rdi
unsigned __int16 v4; // ax
unsigned __int16 v5; // ax
long long result; // rax
long long v7; // rdi
const unsigned __int8 *v8; // rsi
long long v9; // rdx
unsigned __int16 v10; // ax
unsigned long long v11; // rcx
unsigned long long v12; // rdx
unsigned __int16 v13; // ax
unsigned int v14; // ecx
unsigned int v15; // eax
long long v16; // rdx
long long v17; // rdi
const char *v18; // rcx
long long v19; // r8
unsigned __int16 v20; // ax
unsigned __int16 v21; // cx
unsigned long long v22; // rcx
unsigned long long i; // rdx
const char *v24; // rdx
long long v25; // rsi
v3 = *((_QWORD *)this + 1);
switch ( *(_BYTE *)(v3 + 193) )
{
case 1:
case 2:
if ( a3 != 4 )
goto LABEL_46;
*(_WORD *)(v3 + 194) = __ROL2__(*(_WORD *)a2, 8);
v4 = __ROL2__(*((_WORD *)a2 + 1), 8);
*(_WORD *)(v3 + 196) = v4;
if ( v4 >= 0x7F9u )
goto LABEL_9;
return 0LL;
case 3:
case 4:
if ( a3 != 4 )
goto LABEL_46;
*(_WORD *)(v3 + 194) = __ROL2__(*(_WORD *)a2, 8);
v5 = __ROL2__(*((_WORD *)a2 + 1), 8);
*(_WORD *)(v3 + 196) = v5;
if ( v5 < 0x80u )
return 0LL;
LABEL_9:
*(_BYTE *)(v3 + 457) = 0;
*(_DWORD *)(v3 + 112) = 16777219;
std::string::_M_replace(v3 + 120, 0LL, *(_QWORD *)(v3 + 128), "Incorrect data value", 20LL);
return 16777219LL;
case 5:
if ( a3 != 4 )
goto LABEL_46;
if ( a2[2] != 255 && a2[2] || a2[3] )
{
*(_BYTE *)(v3 + 457) = 0;
*(_DWORD *)(v3 + 112) = 16777474;
v16 = *(_QWORD *)(v3 + 128);
v17 = v3 + 120;
v18 = "Incorrect data value";
v19 = 20LL;
goto LABEL_47;
}
*(_WORD *)(v3 + 194) = __ROL2__(*(_WORD *)a2, 8);
*(_BYTE *)(v3 + 202) = a2[2];
return 0LL;
case 6:
if ( a3 != 4 )
goto LABEL_46;
*(_WORD *)(v3 + 194) = __ROL2__(*(_WORD *)a2, 8);
*(_BYTE *)(v3 + 202) = a2[3];
*(_BYTE *)(v3 + 203) = a2[2];
return 0LL;
case 7:
case 0xB:
case 0xC:
case 0x11:
if ( !a3 )
return 0LL;
goto LABEL_46;
case 8:
if ( a3 <= 1u )
goto LABEL_46;
*(_WORD *)(v3 + 194) = __ROL2__(*(_WORD *)a2, 8);
LOWORD(v9) = a3 - 2;
*(_WORD *)(v3 + 196) = v9;
v7 = v3 + 202;
v8 = a2 + 2;
v9 = (unsigned __int16)v9;
goto LABEL_14;
case 0xF:
if ( a3 <= 4u )
goto LABEL_46;
if ( a2[4] + 5 != a3 )
goto LABEL_43;
*(_WORD *)(v3 + 194) = __ROL2__(*(_WORD *)a2, 8);
v13 = __ROL2__(*((_WORD *)a2 + 1), 8);
v14 = v13;
*(_WORD *)(v3 + 196) = v13;
v15 = ((unsigned int)v13 + 7) >> 3;
if ( v15 != a2[4] )
goto LABEL_43;
if ( v14 >= 0x7F9 )
goto LABEL_50;
v7 = v3 + 202;
v8 = a2 + 5;
v9 = v15;
LABEL_14:
memcpy(v7, v8, v9);
return 0LL;
case 0x10:
if ( a3 <= 4u )
goto LABEL_46;
if ( a2[4] + 5 != a3 )
goto LABEL_43;
*(_WORD *)(v3 + 194) = __ROL2__(*(_WORD *)a2, 8);
v10 = __ROL2__(*((_WORD *)a2 + 1), 8);
v11 = v10;
*(_WORD *)(v3 + 196) = v10;
if ( 2 * v10 != a2[4] )
goto LABEL_43;
if ( v10 > 0x7Fu )
goto LABEL_50;
if ( !v10 )
return 0LL;
result = 0LL;
v12 = 0LL;
do
{
*(_BYTE *)(v3 + 2 * v12 + 202) = a2[2 * v12 + 6];
*(_BYTE *)(v3 + 2 * v12 + 203) = a2[2 * v12 + 5];
++v12;
}
while ( v12 < v11 );
return result;
case 0x16:
if ( a3 != 6 )
goto LABEL_46;
*(_WORD *)(v3 + 194) = __ROL2__(*(_WORD *)a2, 8);
*(_WORD *)(v3 + 198) = __ROL2__(*((_WORD *)a2 + 1), 8);
*(_WORD *)(v3 + 200) = __ROL2__(*((_WORD *)a2 + 2), 8);
return 0LL;
case 0x17:
if ( a3 <= 8u )
goto LABEL_46;
if ( a2[8] + 9 != a3
|| (*(_WORD *)(v3 + 194) = __ROL2__(*(_WORD *)a2, 8),
v20 = __ROL2__(*((_WORD *)a2 + 1), 8),
*(_WORD *)(v3 + 196) = v20,
*(_WORD *)(v3 + 198) = __ROL2__(*((_WORD *)a2 + 2), 8),
v21 = __ROL2__(*((_WORD *)a2 + 3), 8),
*(_WORD *)(v3 + 200) = v21,
2 * v21 != a2[8]) )
{
LABEL_43:
v24 = "Incorrect received data size";
v25 = 16777474LL;
return ModbusServerResourcePrivate::setError(v3, v25, v24);
}
if ( (unsigned __int16)(v20 | v21) > 0x7Fu )
{
LABEL_50:
v24 = "Incorrect data value";
v25 = 16777219LL;
return ModbusServerResourcePrivate::setError(v3, v25, v24);
}
if ( !v20 )
return 0LL;
v22 = v20;
result = 0LL;
for ( i = 0LL; i < v22; ++i )
{
*(_BYTE *)(v3 + 2 * i + 202) = a2[2 * i + 10];
*(_BYTE *)(v3 + 2 * i + 203) = a2[2 * i + 9];
}
return result;
case 0x18:
if ( a3 > 1u )
{
*(_WORD *)(v3 + 194) = __ROL2__(*(_WORD *)a2, 8);
return 0LL;
}
else
{
LABEL_46:
*(_BYTE *)(v3 + 457) = 0;
*(_DWORD *)(v3 + 112) = 16777474;
v16 = *(_QWORD *)(v3 + 128);
v17 = v3 + 120;
v18 = "Incorrect received data size";
v19 = 28LL;
LABEL_47:
std::string::_M_replace(v17, 0LL, v16, v18, v19);
return 16777474LL;
}
default:
*(_BYTE *)(v3 + 457) = 0;
*(_DWORD *)(v3 + 112) = 16777217;
std::string::_M_replace(v3 + 120, 0LL, *(_QWORD *)(v3 + 128), "Unsupported function", 20LL);
return 16777217LL;
}
}
| processInputData:
PUSH RAX
MOV RDI,qword ptr [RDI + 0x8]
MOVZX EAX,byte ptr [RDI + 0xc1]
DEC EAX
CMP EAX,0x17
JA 0x0010e6ff
LEA RCX,[0x119468]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_7:
TEST DX,DX
JNZ 0x0010e6cb
JMP 0x0010e76b
caseD_1:
CMP DX,0x4
JNZ 0x0010e6cb
MOVZX EAX,word ptr [RSI]
ROL AX,0x8
MOV word ptr [RDI + 0xc2],AX
MOVZX EAX,word ptr [RSI + 0x2]
ROL AX,0x8
MOV word ptr [RDI + 0xc4],AX
MOVZX EAX,AX
CMP EAX,0x7f9
JNC 0x0010e3ea
JMP 0x0010e76b
caseD_3:
CMP DX,0x4
JNZ 0x0010e6cb
MOVZX EAX,word ptr [RSI]
ROL AX,0x8
MOV word ptr [RDI + 0xc2],AX
MOVZX EAX,word ptr [RSI + 0x2]
ROL AX,0x8
MOV word ptr [RDI + 0xc4],AX
MOVZX EAX,AX
CMP EAX,0x80
JC 0x0010e76b
LAB_0010e3ea:
MOV byte ptr [RDI + 0x1c9],0x0
MOV dword ptr [RDI + 0x70],0x1000003
MOV RDX,qword ptr [RDI + 0x80]
ADD RDI,0x78
LEA RCX,[0x11959f]
MOV R8D,0x14
XOR ESI,ESI
CALL 0x001054b0
MOV EAX,0x1000003
JMP 0x0010e76d
caseD_16:
CMP DX,0x6
JNZ 0x0010e6cb
MOVZX EAX,word ptr [RSI]
ROL AX,0x8
MOV word ptr [RDI + 0xc2],AX
MOVZX EAX,word ptr [RSI + 0x2]
ROL AX,0x8
MOV word ptr [RDI + 0xc6],AX
MOVZX EAX,word ptr [RSI + 0x4]
ROL AX,0x8
MOV word ptr [RDI + 0xc8],AX
JMP 0x0010e76b
caseD_8:
CMP DX,0x1
JBE 0x0010e6cb
MOVZX EAX,word ptr [RSI]
ROL AX,0x8
MOV word ptr [RDI + 0xc2],AX
ADD EDX,-0x2
MOV word ptr [RDI + 0xc4],DX
ADD RDI,0xca
ADD RSI,0x2
MOVZX EDX,DX
LAB_0010e48c:
CALL 0x001052a0
JMP 0x0010e76b
caseD_10:
CMP DX,0x4
JBE 0x0010e6cb
MOVZX EAX,DX
MOVZX ECX,byte ptr [RSI + 0x4]
ADD ECX,0x5
CMP ECX,EAX
JNZ 0x0010e6b3
MOVZX EAX,word ptr [RSI]
ROL AX,0x8
MOV word ptr [RDI + 0xc2],AX
MOVZX EAX,word ptr [RSI + 0x2]
ROL AX,0x8
MOVZX ECX,AX
MOV word ptr [RDI + 0xc4],CX
LEA EDX,[RCX + RCX*0x1]
MOVZX R8D,byte ptr [RSI + 0x4]
CMP EDX,R8D
JNZ 0x0010e6b3
CMP AX,0x7f
JA 0x0010e743
TEST AX,AX
JZ 0x0010e76b
XOR EAX,EAX
XOR EDX,EDX
LAB_0010e4fa:
MOV R8B,byte ptr [RSI + RDX*0x2 + 0x6]
MOV byte ptr [RDI + RDX*0x2 + 0xca],R8B
MOV R8B,byte ptr [RSI + RDX*0x2 + 0x5]
MOV byte ptr [RDI + RDX*0x2 + 0xcb],R8B
INC RDX
CMP RDX,RCX
JC 0x0010e4fa
JMP 0x0010e76d
caseD_f:
CMP DX,0x4
JBE 0x0010e6cb
MOVZX EAX,DX
MOVZX ECX,byte ptr [RSI + 0x4]
ADD ECX,0x5
CMP ECX,EAX
JNZ 0x0010e6b3
MOVZX EAX,word ptr [RSI]
ROL AX,0x8
MOV word ptr [RDI + 0xc2],AX
MOVZX EAX,word ptr [RSI + 0x2]
ROL AX,0x8
MOVZX ECX,AX
MOV word ptr [RDI + 0xc4],CX
LEA EAX,[RCX + 0x7]
SHR EAX,0x3
MOVZX EDX,byte ptr [RSI + 0x4]
CMP EAX,EDX
JNZ 0x0010e6b3
CMP ECX,0x7f9
JNC 0x0010e743
ADD RDI,0xca
ADD RSI,0x5
MOV EDX,EAX
JMP 0x0010e48c
caseD_5:
CMP DX,0x4
JNZ 0x0010e6cb
MOVZX EAX,byte ptr [RSI + 0x2]
CMP EAX,0xff
JZ 0x0010e5a6
TEST EAX,EAX
JNZ 0x0010e5b0
LAB_0010e5a6:
CMP byte ptr [RSI + 0x3],0x0
JZ 0x0010e754
LAB_0010e5b0:
MOV byte ptr [RDI + 0x1c9],0x0
MOV dword ptr [RDI + 0x70],0x1000102
MOV RDX,qword ptr [RDI + 0x80]
ADD RDI,0x78
LEA RCX,[0x11959f]
MOV R8D,0x14
JMP 0x0010e6f1
caseD_6:
CMP DX,0x4
JNZ 0x0010e6cb
MOVZX EAX,word ptr [RSI]
ROL AX,0x8
MOV word ptr [RDI + 0xc2],AX
MOV AL,byte ptr [RSI + 0x3]
MOV byte ptr [RDI + 0xca],AL
MOV AL,byte ptr [RSI + 0x2]
MOV byte ptr [RDI + 0xcb],AL
JMP 0x0010e76b
caseD_17:
CMP DX,0x8
JBE 0x0010e6cb
MOVZX EAX,DX
MOVZX ECX,byte ptr [RSI + 0x8]
ADD ECX,0x9
CMP ECX,EAX
JNZ 0x0010e6b3
MOVZX EAX,word ptr [RSI]
ROL AX,0x8
MOV word ptr [RDI + 0xc2],AX
MOVZX EAX,word ptr [RSI + 0x2]
ROL AX,0x8
MOV word ptr [RDI + 0xc4],AX
MOVZX ECX,word ptr [RSI + 0x4]
ROL CX,0x8
MOV word ptr [RDI + 0xc6],CX
MOVZX ECX,word ptr [RSI + 0x6]
ROL CX,0x8
MOVZX EDX,CX
MOV word ptr [RDI + 0xc8],DX
ADD EDX,EDX
MOVZX R8D,byte ptr [RSI + 0x8]
CMP EDX,R8D
JNZ 0x0010e6b3
OR ECX,EAX
CMP CX,0x7f
JA 0x0010e743
TEST AX,AX
JZ 0x0010e76b
MOVZX ECX,AX
XOR EAX,EAX
XOR EDX,EDX
LAB_0010e68c:
MOV R8B,byte ptr [RSI + RDX*0x2 + 0xa]
MOV byte ptr [RDI + RDX*0x2 + 0xca],R8B
MOV R8B,byte ptr [RSI + RDX*0x2 + 0x9]
MOV byte ptr [RDI + RDX*0x2 + 0xcb],R8B
INC RDX
CMP RDX,RCX
JC 0x0010e68c
JMP 0x0010e76d
LAB_0010e6b3:
LEA RDX,[0x118e1a]
MOV ESI,0x1000102
LAB_0010e6bf:
POP RAX
JMP 0x0010ee48
caseD_18:
CMP DX,0x1
JA 0x0010e733
LAB_0010e6cb:
MOV byte ptr [RDI + 0x1c9],0x0
MOV dword ptr [RDI + 0x70],0x1000102
MOV RDX,qword ptr [RDI + 0x80]
ADD RDI,0x78
LEA RCX,[0x118e1a]
MOV R8D,0x1c
LAB_0010e6f1:
XOR ESI,ESI
CALL 0x001054b0
MOV EAX,0x1000102
JMP 0x0010e76d
caseD_9:
MOV byte ptr [RDI + 0x1c9],0x0
MOV dword ptr [RDI + 0x70],0x1000001
MOV RDX,qword ptr [RDI + 0x80]
ADD RDI,0x78
LEA RCX,[0x1195b4]
MOV R8D,0x14
XOR ESI,ESI
CALL 0x001054b0
MOV EAX,0x1000001
JMP 0x0010e76d
LAB_0010e733:
MOVZX EAX,word ptr [RSI]
ROL AX,0x8
MOV word ptr [RDI + 0xc2],AX
JMP 0x0010e76b
LAB_0010e743:
LEA RDX,[0x11959f]
MOV ESI,0x1000003
JMP 0x0010e6bf
LAB_0010e754:
MOVZX EAX,word ptr [RSI]
ROL AX,0x8
MOV word ptr [RDI + 0xc2],AX
MOV AL,byte ptr [RSI + 0x2]
MOV byte ptr [RDI + 0xca],AL
LAB_0010e76b:
XOR EAX,EAX
LAB_0010e76d:
POP RCX
RET
|
/* ModbusServerResource::processInputData(unsigned char const*, unsigned short) */
int8 __thiscall
ModbusServerResource::processInputData(ModbusServerResource *this,uchar *param_1,ushort param_2)
{
ModbusServerResourcePrivate *pMVar1;
ushort uVar2;
uint uVar3;
ushort uVar4;
char *pcVar5;
size_t __n;
ulong uVar6;
char *pcVar7;
uchar *__src;
int8 uVar8;
pMVar1 = *(ModbusServerResourcePrivate **)(this + 8);
switch(pMVar1[0xc1]) {
case (ModbusServerResourcePrivate)0x1:
case (ModbusServerResourcePrivate)0x2:
if (param_2 == 4) {
*(ushort *)(pMVar1 + 0xc2) = *(ushort *)param_1 << 8 | *(ushort *)param_1 >> 8;
uVar2 = *(ushort *)(param_1 + 2) << 8 | *(ushort *)(param_1 + 2) >> 8;
*(ushort *)(pMVar1 + 0xc4) = uVar2;
if (uVar2 < 0x7f9) {
return 0;
}
LAB_0010e3ea:
pMVar1[0x1c9] = (ModbusServerResourcePrivate)0x0;
*(int4 *)(pMVar1 + 0x70) = 0x1000003;
std::__cxx11::string::_M_replace((ulong)(pMVar1 + 0x78),0,*(char **)(pMVar1 + 0x80),0x11959f);
return 0x1000003;
}
break;
case (ModbusServerResourcePrivate)0x3:
case (ModbusServerResourcePrivate)0x4:
if (param_2 == 4) {
*(ushort *)(pMVar1 + 0xc2) = *(ushort *)param_1 << 8 | *(ushort *)param_1 >> 8;
uVar2 = *(ushort *)(param_1 + 2) << 8 | *(ushort *)(param_1 + 2) >> 8;
*(ushort *)(pMVar1 + 0xc4) = uVar2;
if (uVar2 < 0x80) {
return 0;
}
goto LAB_0010e3ea;
}
break;
case (ModbusServerResourcePrivate)0x5:
if (param_2 == 4) {
if (((param_1[2] == 0xff) || (param_1[2] == '\0')) && (param_1[3] == '\0')) {
*(ushort *)(pMVar1 + 0xc2) = *(ushort *)param_1 << 8 | *(ushort *)param_1 >> 8;
pMVar1[0xca] = *(ModbusServerResourcePrivate *)(param_1 + 2);
return 0;
}
pMVar1[0x1c9] = (ModbusServerResourcePrivate)0x0;
*(int4 *)(pMVar1 + 0x70) = 0x1000102;
pcVar7 = *(char **)(pMVar1 + 0x80);
pcVar5 = "Incorrect data value";
goto LAB_0010e6f1;
}
break;
case (ModbusServerResourcePrivate)0x6:
if (param_2 == 4) {
*(ushort *)(pMVar1 + 0xc2) = *(ushort *)param_1 << 8 | *(ushort *)param_1 >> 8;
pMVar1[0xca] = *(ModbusServerResourcePrivate *)(param_1 + 3);
pMVar1[0xcb] = *(ModbusServerResourcePrivate *)(param_1 + 2);
return 0;
}
break;
case (ModbusServerResourcePrivate)0x7:
case (ModbusServerResourcePrivate)0xb:
case (ModbusServerResourcePrivate)0xc:
case (ModbusServerResourcePrivate)0x11:
if (param_2 == 0) {
return 0;
}
break;
case (ModbusServerResourcePrivate)0x8:
if (1 < param_2) {
*(ushort *)(pMVar1 + 0xc2) = *(ushort *)param_1 << 8 | *(ushort *)param_1 >> 8;
*(ushort *)(pMVar1 + 0xc4) = param_2 - 2;
__src = param_1 + 2;
__n = (size_t)(ushort)(param_2 - 2);
LAB_0010e48c:
memcpy(pMVar1 + 0xca,__src,__n);
return 0;
}
break;
default:
pMVar1[0x1c9] = (ModbusServerResourcePrivate)0x0;
*(int4 *)(pMVar1 + 0x70) = 0x1000001;
std::__cxx11::string::_M_replace((ulong)(pMVar1 + 0x78),0,*(char **)(pMVar1 + 0x80),0x1195b4);
return 0x1000001;
case (ModbusServerResourcePrivate)0xf:
if (4 < param_2) {
if ((ushort)(param_1[4] + 5) == param_2) {
*(ushort *)(pMVar1 + 0xc2) = *(ushort *)param_1 << 8 | *(ushort *)param_1 >> 8;
uVar2 = *(ushort *)(param_1 + 2) << 8 | *(ushort *)(param_1 + 2) >> 8;
*(ushort *)(pMVar1 + 0xc4) = uVar2;
uVar3 = uVar2 + 7 >> 3;
if (uVar3 == param_1[4]) {
if (uVar2 < 0x7f9) {
__src = param_1 + 5;
__n = (size_t)uVar3;
goto LAB_0010e48c;
}
LAB_0010e743:
pcVar7 = "Incorrect data value";
uVar8 = 0x1000003;
goto LAB_0010e6bf;
}
}
LAB_0010e6b3:
pcVar7 = "Incorrect received data size";
uVar8 = 0x1000102;
LAB_0010e6bf:
uVar8 = ModbusServerResourcePrivate::setError(pMVar1,uVar8,pcVar7);
return uVar8;
}
break;
case (ModbusServerResourcePrivate)0x10:
if (4 < param_2) {
if ((ushort)(param_1[4] + 5) == param_2) {
*(ushort *)(pMVar1 + 0xc2) = *(ushort *)param_1 << 8 | *(ushort *)param_1 >> 8;
uVar2 = *(ushort *)(param_1 + 2) << 8 | *(ushort *)(param_1 + 2) >> 8;
*(ushort *)(pMVar1 + 0xc4) = uVar2;
if ((uint)uVar2 + (uint)uVar2 == (uint)param_1[4]) {
if (uVar2 < 0x80) {
if (uVar2 == 0) {
return 0;
}
uVar6 = 0;
do {
pMVar1[uVar6 * 2 + 0xca] = *(ModbusServerResourcePrivate *)(param_1 + uVar6 * 2 + 6);
pMVar1[uVar6 * 2 + 0xcb] = *(ModbusServerResourcePrivate *)(param_1 + uVar6 * 2 + 5);
uVar6 = uVar6 + 1;
} while (uVar6 < uVar2);
return 0;
}
goto LAB_0010e743;
}
}
goto LAB_0010e6b3;
}
break;
case (ModbusServerResourcePrivate)0x16:
if (param_2 == 6) {
*(ushort *)(pMVar1 + 0xc2) = *(ushort *)param_1 << 8 | *(ushort *)param_1 >> 8;
*(ushort *)(pMVar1 + 0xc6) = *(ushort *)(param_1 + 2) << 8 | *(ushort *)(param_1 + 2) >> 8;
*(ushort *)(pMVar1 + 200) = *(ushort *)(param_1 + 4) << 8 | *(ushort *)(param_1 + 4) >> 8;
return 0;
}
break;
case (ModbusServerResourcePrivate)0x17:
if (8 < param_2) {
if ((ushort)(param_1[8] + 9) == param_2) {
*(ushort *)(pMVar1 + 0xc2) = *(ushort *)param_1 << 8 | *(ushort *)param_1 >> 8;
uVar2 = *(ushort *)(param_1 + 2) << 8 | *(ushort *)(param_1 + 2) >> 8;
*(ushort *)(pMVar1 + 0xc4) = uVar2;
*(ushort *)(pMVar1 + 0xc6) = *(ushort *)(param_1 + 4) << 8 | *(ushort *)(param_1 + 4) >> 8;
uVar4 = *(ushort *)(param_1 + 6) << 8 | *(ushort *)(param_1 + 6) >> 8;
*(ushort *)(pMVar1 + 200) = uVar4;
if ((uint)uVar4 * 2 == (uint)param_1[8]) {
if ((uVar4 | uVar2) < 0x80) {
if (uVar2 == 0) {
return 0;
}
uVar6 = 0;
do {
pMVar1[uVar6 * 2 + 0xca] = *(ModbusServerResourcePrivate *)(param_1 + uVar6 * 2 + 10);
pMVar1[uVar6 * 2 + 0xcb] = *(ModbusServerResourcePrivate *)(param_1 + uVar6 * 2 + 9);
uVar6 = uVar6 + 1;
} while (uVar6 < uVar2);
return 0;
}
goto LAB_0010e743;
}
}
goto LAB_0010e6b3;
}
break;
case (ModbusServerResourcePrivate)0x18:
if (1 < param_2) {
*(ushort *)(pMVar1 + 0xc2) = *(ushort *)param_1 << 8 | *(ushort *)param_1 >> 8;
return 0;
}
}
pMVar1[0x1c9] = (ModbusServerResourcePrivate)0x0;
*(int4 *)(pMVar1 + 0x70) = 0x1000102;
pcVar7 = *(char **)(pMVar1 + 0x80);
pcVar5 = "Incorrect received data size";
LAB_0010e6f1:
std::__cxx11::string::_M_replace((ulong)(pMVar1 + 0x78),0,pcVar7,(ulong)pcVar5);
return 0x1000102;
}
| |
41,694 | translog_set_only_in_buffers | eloqsql/storage/maria/ma_loghandler.c | static void translog_set_only_in_buffers(TRANSLOG_ADDRESS in_buffers)
{
DBUG_ENTER("translog_set_only_in_buffers");
mysql_mutex_lock(&log_descriptor.sent_to_disk_lock);
DBUG_PRINT("enter", ("in_buffers: " LSN_FMT " "
"in_buffers_only: " LSN_FMT,
LSN_IN_PARTS(in_buffers),
LSN_IN_PARTS(log_descriptor.in_buffers_only)));
/* LSN_IMPOSSIBLE == 0 => it will work for very first time */
if (cmp_translog_addr(in_buffers, log_descriptor.in_buffers_only) > 0)
{
if (translog_status != TRANSLOG_OK)
goto end;
log_descriptor.in_buffers_only= in_buffers;
DBUG_PRINT("info", ("set new in_buffers_only"));
}
end:
mysql_mutex_unlock(&log_descriptor.sent_to_disk_lock);
DBUG_VOID_RETURN;
} | O0 | c | translog_set_only_in_buffers:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x41c62d(%rip), %rdi # 0x4793c0
addq $0x800cc0, %rdi # imm = 0x800CC0
leaq 0xf4f2d(%rip), %rsi # 0x151cce
movl $0x911, %edx # imm = 0x911
callq 0x4fcf0
jmp 0x5cdad
movq -0x8(%rbp), %rax
subq 0xc1d2c0(%rip), %rax # 0xc7a078
cmpq $0x0, %rax
jle 0x5cdd8
cmpl $0x1, 0x41b3eb(%rip) # 0x4781b0
je 0x5cdc9
jmp 0x5cdda
movq -0x8(%rbp), %rax
movq %rax, 0xc1d2a4(%rip) # 0xc7a078
jmp 0x5cdd6
jmp 0x5cdd8
jmp 0x5cdda
leaq 0x41c5df(%rip), %rdi # 0x4793c0
addq $0x800cc0, %rdi # imm = 0x800CC0
callq 0x4fd60
jmp 0x5cdef
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| translog_set_only_in_buffers:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
lea rdi, log_descriptor
add rdi, 800CC0h
lea rsi, aWorkspaceLlm4b_11; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 911h
call inline_mysql_mutex_lock_8
jmp short $+2
loc_5CDAD:
mov rax, [rbp+var_8]
sub rax, cs:qword_C7A078
cmp rax, 0
jle short loc_5CDD8
cmp cs:translog_status, 1
jz short loc_5CDC9
jmp short loc_5CDDA
loc_5CDC9:
mov rax, [rbp+var_8]
mov cs:qword_C7A078, rax
jmp short $+2
loc_5CDD6:
jmp short $+2
loc_5CDD8:
jmp short $+2
loc_5CDDA:
lea rdi, log_descriptor
add rdi, 800CC0h
call inline_mysql_mutex_unlock_8
jmp short $+2
loc_5CDEF:
add rsp, 10h
pop rbp
retn
| long long translog_set_only_in_buffers(long long a1)
{
inline_mysql_mutex_lock_8(
(long long)&log_descriptor[1048984],
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x911u);
if ( a1 - qword_C7A078 > 0 && translog_status == 1 )
qword_C7A078 = a1;
return inline_mysql_mutex_unlock_8((long long)&log_descriptor[1048984]);
}
| translog_set_only_in_buffers:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
LEA RDI,[0x5793c0]
ADD RDI,0x800cc0
LEA RSI,[0x251cce]
MOV EDX,0x911
CALL 0x0014fcf0
JMP 0x0015cdad
LAB_0015cdad:
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr [0x00d7a078]
CMP RAX,0x0
JLE 0x0015cdd8
CMP dword ptr [0x005781b0],0x1
JZ 0x0015cdc9
JMP 0x0015cdda
LAB_0015cdc9:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [0x00d7a078],RAX
JMP 0x0015cdd6
LAB_0015cdd6:
JMP 0x0015cdd8
LAB_0015cdd8:
JMP 0x0015cdda
LAB_0015cdda:
LEA RDI,[0x5793c0]
ADD RDI,0x800cc0
CALL 0x0014fd60
JMP 0x0015cdef
LAB_0015cdef:
ADD RSP,0x10
POP RBP
RET
|
void translog_set_only_in_buffers(long param_1)
{
long lVar1;
inline_mysql_mutex_lock
(&DAT_00d7a080,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x911);
lVar1 = DAT_00d7a078;
if ((param_1 - DAT_00d7a078 < 1) || (lVar1 = param_1, translog_status == 1)) {
DAT_00d7a078 = lVar1;
}
inline_mysql_mutex_unlock(&DAT_00d7a080);
return;
}
| |
41,695 | ggml_dyn_tallocr_free_tensor | monkey531[P]llama/ggml/src/ggml-alloc.c | static void ggml_dyn_tallocr_free_tensor(struct ggml_dyn_tallocr * alloc, size_t offset, size_t size, const struct ggml_tensor * tensor) {
size = aligned_offset(NULL, size, alloc->alignment);
AT_PRINTF("%s: freeing %s at %zu (%zu bytes) - n_free_blocks = %d\n", __func__, tensor->name, offset, size, alloc->n_free_blocks);
#ifdef GGML_ALLOCATOR_DEBUG
remove_allocated_tensor(alloc, offset, tensor);
#endif
// see if we can merge with an existing block
for (int i = 0; i < alloc->n_free_blocks; i++) {
struct free_block * block = &alloc->free_blocks[i];
// check if ptr is at the end of the block
if (block->offset + block->size == offset) {
block->size += size;
// check if we can merge with the next block
if (i < alloc->n_free_blocks - 1 && block->offset + block->size == alloc->free_blocks[i+1].offset) {
block->size += alloc->free_blocks[i+1].size;
alloc->n_free_blocks--;
for (int j = i+1; j < alloc->n_free_blocks; j++) {
alloc->free_blocks[j] = alloc->free_blocks[j+1];
}
}
return;
}
// check if ptr is at the beginning of the block
if (offset + size == block->offset) {
block->offset = offset;
block->size += size;
// check if we can merge with the previous block
if (i > 0 && alloc->free_blocks[i-1].offset + alloc->free_blocks[i-1].size == block->offset) {
alloc->free_blocks[i-1].size += block->size;
alloc->n_free_blocks--;
for (int j = i; j < alloc->n_free_blocks; j++) {
alloc->free_blocks[j] = alloc->free_blocks[j+1];
}
}
return;
}
}
// otherwise, add a new block
GGML_ASSERT(alloc->n_free_blocks < MAX_FREE_BLOCKS && "out of free blocks");
// insert the new block in the correct position to keep the array sorted by address (to make merging blocks faster)
int insert_pos = 0;
while (insert_pos < alloc->n_free_blocks && alloc->free_blocks[insert_pos].offset < offset) {
insert_pos++;
}
// shift all blocks from insert_pos onward to make room for the new block
for (int i = alloc->n_free_blocks; i > insert_pos; i--) {
alloc->free_blocks[i] = alloc->free_blocks[i-1];
}
// insert the new block
alloc->free_blocks[insert_pos].offset = offset;
alloc->free_blocks[insert_pos].size = size;
alloc->n_free_blocks++;
GGML_UNUSED(tensor);
} | O0 | c | ggml_dyn_tallocr_free_tensor:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x30(%rsp), %rsi
movq 0x40(%rsp), %rax
movq (%rax), %rdx
xorl %eax, %eax
movl %eax, %edi
callq 0x5a710
movq %rax, 0x30(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x40(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x5d140
movq 0x40(%rsp), %rax
addq $0x10, %rax
movslq 0x24(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
addq 0x8(%rcx), %rax
cmpq 0x38(%rsp), %rax
jne 0x5d003
movq 0x30(%rsp), %rcx
movq 0x18(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movl 0x24(%rsp), %eax
movq 0x40(%rsp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x5cffe
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
addq 0x8(%rcx), %rax
movq 0x40(%rsp), %rcx
addq $0x10, %rcx
movl 0x24(%rsp), %edx
addl $0x1, %edx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq (%rcx), %rax
jne 0x5cffe
movq 0x40(%rsp), %rax
addq $0x10, %rax
movl 0x24(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movq 0x18(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq 0x40(%rsp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x40(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x5cffc
movq 0x40(%rsp), %rax
addq $0x10, %rax
movslq 0x14(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x40(%rsp), %rcx
addq $0x10, %rcx
movl 0x14(%rsp), %edx
addl $0x1, %edx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x5cfa4
jmp 0x5cffe
jmp 0x5d277
movq 0x38(%rsp), %rax
addq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq (%rcx), %rax
jne 0x5d12e
movq 0x38(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rcx
movq 0x18(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
cmpl $0x0, 0x24(%rsp)
jle 0x5d129
movq 0x40(%rsp), %rax
addq $0x10, %rax
movl 0x24(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq 0x40(%rsp), %rcx
addq $0x10, %rcx
movl 0x24(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
addq 0x8(%rcx), %rax
movq 0x18(%rsp), %rcx
cmpq (%rcx), %rax
jne 0x5d129
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x40(%rsp), %rax
addq $0x10, %rax
movl 0x24(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq 0x40(%rsp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movl 0x24(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq 0x40(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x5d127
movq 0x40(%rsp), %rax
addq $0x10, %rax
movslq 0x10(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x40(%rsp), %rcx
addq $0x10, %rcx
movl 0x10(%rsp), %edx
addl $0x1, %edx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x5d0cf
jmp 0x5d129
jmp 0x5d277
jmp 0x5d130
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x5cebb
movq 0x40(%rsp), %rax
cmpl $0x100, 0x8(%rax) # imm = 0x100
jge 0x5d156
movb $0x1, %al
testb $0x1, %al
jne 0x5d177
jmp 0x5d156
leaq 0x5a06d(%rip), %rdi # 0xb71ca
movl $0x117, %esi # imm = 0x117
leaq 0x57498(%rip), %rdx # 0xb4601
leaq 0x5a333(%rip), %rcx # 0xb74a3
movb $0x0, %al
callq 0x46770
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %ecx
movq 0x40(%rsp), %rdx
xorl %eax, %eax
cmpl 0x8(%rdx), %ecx
movb %al, 0x7(%rsp)
jge 0x5d1b7
movq 0x40(%rsp), %rax
addq $0x10, %rax
movslq 0xc(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq 0x38(%rsp), %rax
setb %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x5d1c1
jmp 0x5d1ce
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5d17f
movq 0x40(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jle 0x5d22e
movq 0x40(%rsp), %rax
addq $0x10, %rax
movslq 0x8(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x40(%rsp), %rcx
addq $0x10, %rcx
movl 0x8(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl 0x8(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x5d1da
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %rax
addq $0x10, %rax
movslq 0xc(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rcx
movq 0x40(%rsp), %rax
addq $0x10, %rax
movslq 0xc(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq 0x40(%rsp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x48, %rsp
retq
nopl (%rax)
| ggml_dyn_tallocr_free_tensor:
sub rsp, 48h
mov [rsp+48h+var_8], rdi
mov [rsp+48h+var_10], rsi
mov [rsp+48h+var_18], rdx
mov [rsp+48h+var_20], rcx
mov rsi, [rsp+48h+var_18]
mov rax, [rsp+48h+var_8]
mov rdx, [rax]
xor eax, eax
mov edi, eax
call aligned_offset
mov [rsp+48h+var_18], rax
mov [rsp+48h+var_24], 0
loc_5CEBB:
mov eax, [rsp+48h+var_24]
mov rcx, [rsp+48h+var_8]
cmp eax, [rcx+8]
jge loc_5D140
mov rax, [rsp+48h+var_8]
add rax, 10h
movsxd rcx, [rsp+48h+var_24]
shl rcx, 4
add rax, rcx
mov [rsp+48h+var_30], rax
mov rax, [rsp+48h+var_30]
mov rax, [rax]
mov rcx, [rsp+48h+var_30]
add rax, [rcx+8]
cmp rax, [rsp+48h+var_10]
jnz loc_5D003
mov rcx, [rsp+48h+var_18]
mov rax, [rsp+48h+var_30]
add rcx, [rax+8]
mov [rax+8], rcx
mov eax, [rsp+48h+var_24]
mov rcx, [rsp+48h+var_8]
mov ecx, [rcx+8]
sub ecx, 1
cmp eax, ecx
jge loc_5CFFE
mov rax, [rsp+48h+var_30]
mov rax, [rax]
mov rcx, [rsp+48h+var_30]
add rax, [rcx+8]
mov rcx, [rsp+48h+var_8]
add rcx, 10h
mov edx, [rsp+48h+var_24]
add edx, 1
movsxd rdx, edx
shl rdx, 4
add rcx, rdx
cmp rax, [rcx]
jnz loc_5CFFE
mov rax, [rsp+48h+var_8]
add rax, 10h
mov ecx, [rsp+48h+var_24]
add ecx, 1
movsxd rcx, ecx
shl rcx, 4
add rax, rcx
mov rcx, [rax+8]
mov rax, [rsp+48h+var_30]
add rcx, [rax+8]
mov [rax+8], rcx
mov rax, [rsp+48h+var_8]
mov ecx, [rax+8]
add ecx, 0FFFFFFFFh
mov [rax+8], ecx
mov eax, [rsp+48h+var_24]
add eax, 1
mov [rsp+48h+var_34], eax
loc_5CFA4:
mov eax, [rsp+48h+var_34]
mov rcx, [rsp+48h+var_8]
cmp eax, [rcx+8]
jge short loc_5CFFC
mov rax, [rsp+48h+var_8]
add rax, 10h
movsxd rcx, [rsp+48h+var_34]
shl rcx, 4
add rax, rcx
mov rcx, [rsp+48h+var_8]
add rcx, 10h
mov edx, [rsp+48h+var_34]
add edx, 1
movsxd rdx, edx
shl rdx, 4
add rcx, rdx
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov eax, [rsp+48h+var_34]
add eax, 1
mov [rsp+48h+var_34], eax
jmp short loc_5CFA4
loc_5CFFC:
jmp short $+2
loc_5CFFE:
jmp loc_5D277
loc_5D003:
mov rax, [rsp+48h+var_10]
add rax, [rsp+48h+var_18]
mov rcx, [rsp+48h+var_30]
cmp rax, [rcx]
jnz loc_5D12E
mov rcx, [rsp+48h+var_10]
mov rax, [rsp+48h+var_30]
mov [rax], rcx
mov rcx, [rsp+48h+var_18]
mov rax, [rsp+48h+var_30]
add rcx, [rax+8]
mov [rax+8], rcx
cmp [rsp+48h+var_24], 0
jle loc_5D129
mov rax, [rsp+48h+var_8]
add rax, 10h
mov ecx, [rsp+48h+var_24]
sub ecx, 1
movsxd rcx, ecx
shl rcx, 4
add rax, rcx
mov rax, [rax]
mov rcx, [rsp+48h+var_8]
add rcx, 10h
mov edx, [rsp+48h+var_24]
sub edx, 1
movsxd rdx, edx
shl rdx, 4
add rcx, rdx
add rax, [rcx+8]
mov rcx, [rsp+48h+var_30]
cmp rax, [rcx]
jnz loc_5D129
mov rax, [rsp+48h+var_30]
mov rcx, [rax+8]
mov rax, [rsp+48h+var_8]
add rax, 10h
mov edx, [rsp+48h+var_24]
sub edx, 1
movsxd rdx, edx
shl rdx, 4
add rax, rdx
add rcx, [rax+8]
mov [rax+8], rcx
mov rax, [rsp+48h+var_8]
mov ecx, [rax+8]
add ecx, 0FFFFFFFFh
mov [rax+8], ecx
mov eax, [rsp+48h+var_24]
mov [rsp+48h+var_38], eax
loc_5D0CF:
mov eax, [rsp+48h+var_38]
mov rcx, [rsp+48h+var_8]
cmp eax, [rcx+8]
jge short loc_5D127
mov rax, [rsp+48h+var_8]
add rax, 10h
movsxd rcx, [rsp+48h+var_38]
shl rcx, 4
add rax, rcx
mov rcx, [rsp+48h+var_8]
add rcx, 10h
mov edx, [rsp+48h+var_38]
add edx, 1
movsxd rdx, edx
shl rdx, 4
add rcx, rdx
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov eax, [rsp+48h+var_38]
add eax, 1
mov [rsp+48h+var_38], eax
jmp short loc_5D0CF
loc_5D127:
jmp short $+2
loc_5D129:
jmp loc_5D277
loc_5D12E:
jmp short $+2
loc_5D130:
mov eax, [rsp+48h+var_24]
add eax, 1
mov [rsp+48h+var_24], eax
jmp loc_5CEBB
loc_5D140:
mov rax, [rsp+48h+var_8]
cmp dword ptr [rax+8], 100h
jge short loc_5D156
mov al, 1
test al, 1
jnz short loc_5D177
jmp short $+2
loc_5D156:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov esi, 117h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAllocNFreeBloc; "alloc->n_free_blocks < MAX_FREE_BLOCKS "...
mov al, 0
call _ggml_abort
loc_5D177:
mov [rsp+48h+var_3C], 0
loc_5D17F:
mov ecx, [rsp+48h+var_3C]
mov rdx, [rsp+48h+var_8]
xor eax, eax
cmp ecx, [rdx+8]
mov [rsp+48h+var_41], al
jge short loc_5D1B7
mov rax, [rsp+48h+var_8]
add rax, 10h
movsxd rcx, [rsp+48h+var_3C]
shl rcx, 4
add rax, rcx
mov rax, [rax]
cmp rax, [rsp+48h+var_10]
setb al
mov [rsp+48h+var_41], al
loc_5D1B7:
mov al, [rsp+48h+var_41]
test al, 1
jnz short loc_5D1C1
jmp short loc_5D1CE
loc_5D1C1:
mov eax, [rsp+48h+var_3C]
add eax, 1
mov [rsp+48h+var_3C], eax
jmp short loc_5D17F
loc_5D1CE:
mov rax, [rsp+48h+var_8]
mov eax, [rax+8]
mov [rsp+48h+var_40], eax
loc_5D1DA:
mov eax, [rsp+48h+var_40]
cmp eax, [rsp+48h+var_3C]
jle short loc_5D22E
mov rax, [rsp+48h+var_8]
add rax, 10h
movsxd rcx, [rsp+48h+var_40]
shl rcx, 4
add rax, rcx
mov rcx, [rsp+48h+var_8]
add rcx, 10h
mov edx, [rsp+48h+var_40]
sub edx, 1
movsxd rdx, edx
shl rdx, 4
add rcx, rdx
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov eax, [rsp+48h+var_40]
add eax, 0FFFFFFFFh
mov [rsp+48h+var_40], eax
jmp short loc_5D1DA
loc_5D22E:
mov rcx, [rsp+48h+var_10]
mov rax, [rsp+48h+var_8]
add rax, 10h
movsxd rdx, [rsp+48h+var_3C]
shl rdx, 4
add rax, rdx
mov [rax], rcx
mov rcx, [rsp+48h+var_18]
mov rax, [rsp+48h+var_8]
add rax, 10h
movsxd rdx, [rsp+48h+var_3C]
shl rdx, 4
add rax, rdx
mov [rax+8], rcx
mov rax, [rsp+48h+var_8]
mov ecx, [rax+8]
add ecx, 1
mov [rax+8], ecx
loc_5D277:
add rsp, 48h
retn
| long long ggml_dyn_tallocr_free_tensor(long long a1, unsigned long long a2, long long a3)
{
long long result; // rax
_QWORD *v4; // rax
_QWORD *v5; // rcx
_QWORD *v6; // rax
_QWORD *v7; // rcx
_QWORD *v8; // rax
_QWORD *v9; // rcx
bool v10; // [rsp+7h] [rbp-41h]
int n; // [rsp+8h] [rbp-40h]
int m; // [rsp+Ch] [rbp-3Ch]
int k; // [rsp+10h] [rbp-38h]
int j; // [rsp+14h] [rbp-34h]
unsigned long long *v15; // [rsp+18h] [rbp-30h]
int i; // [rsp+24h] [rbp-24h]
long long v17; // [rsp+30h] [rbp-18h]
v17 = aligned_offset(0LL, a3, *(_QWORD *)a1);
for ( i = 0; i < *(_DWORD *)(a1 + 8); ++i )
{
v15 = (unsigned long long *)(16LL * i + a1 + 16);
if ( v15[1] + *v15 == a2 )
{
v15[1] += v17;
result = (unsigned int)i;
if ( i < *(_DWORD *)(a1 + 8) - 1 )
{
result = v15[1] + *v15;
if ( result == *(_QWORD *)(16LL * (i + 1) + a1 + 16) )
{
v15[1] += *(_QWORD *)(16LL * (i + 1) + a1 + 16 + 8);
--*(_DWORD *)(a1 + 8);
for ( j = i + 1; ; ++j )
{
result = (unsigned int)j;
if ( j >= *(_DWORD *)(a1 + 8) )
break;
v4 = (_QWORD *)(16LL * j + a1 + 16);
v5 = (_QWORD *)(16LL * (j + 1) + a1 + 16);
*v4 = *v5;
v4[1] = v5[1];
}
}
}
return result;
}
if ( v17 + a2 == *v15 )
{
*v15 = a2;
result = 16LL * i + a1 + 16;
v15[1] += v17;
if ( i > 0 )
{
result = *(_QWORD *)(16LL * (i - 1) + a1 + 16 + 8) + *(_QWORD *)(16LL * (i - 1) + a1 + 16);
if ( result == *v15 )
{
*(_QWORD *)(16LL * (i - 1) + a1 + 16 + 8) += v15[1];
--*(_DWORD *)(a1 + 8);
for ( k = i; ; ++k )
{
result = (unsigned int)k;
if ( k >= *(_DWORD *)(a1 + 8) )
break;
v6 = (_QWORD *)(16LL * k + a1 + 16);
v7 = (_QWORD *)(16LL * (k + 1) + a1 + 16);
*v6 = *v7;
v6[1] = v7[1];
}
}
}
return result;
}
}
if ( *(int *)(a1 + 8) >= 256 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-alloc.c",
279,
(long long)"GGML_ASSERT(%s) failed",
"alloc->n_free_blocks < MAX_FREE_BLOCKS && \"out of free blocks\"");
for ( m = 0; ; ++m )
{
v10 = 0;
if ( m < *(_DWORD *)(a1 + 8) )
v10 = *(_QWORD *)(16LL * m + a1 + 16) < a2;
if ( !v10 )
break;
}
for ( n = *(_DWORD *)(a1 + 8); n > m; --n )
{
v8 = (_QWORD *)(16LL * n + a1 + 16);
v9 = (_QWORD *)(16LL * (n - 1) + a1 + 16);
*v8 = *v9;
v8[1] = v9[1];
}
*(_QWORD *)(16LL * m + a1 + 16) = a2;
*(_QWORD *)(16LL * m + a1 + 16 + 8) = v17;
result = a1;
++*(_DWORD *)(a1 + 8);
return result;
}
| ggml_dyn_tallocr_free_tensor:
SUB RSP,0x48
MOV qword ptr [RSP + 0x40],RDI
MOV qword ptr [RSP + 0x38],RSI
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RSP + 0x28],RCX
MOV RSI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RAX]
XOR EAX,EAX
MOV EDI,EAX
CALL 0x0015a710
MOV qword ptr [RSP + 0x30],RAX
MOV dword ptr [RSP + 0x24],0x0
LAB_0015cebb:
MOV EAX,dword ptr [RSP + 0x24]
MOV RCX,qword ptr [RSP + 0x40]
CMP EAX,dword ptr [RCX + 0x8]
JGE 0x0015d140
MOV RAX,qword ptr [RSP + 0x40]
ADD RAX,0x10
MOVSXD RCX,dword ptr [RSP + 0x24]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RSP + 0x18]
ADD RAX,qword ptr [RCX + 0x8]
CMP RAX,qword ptr [RSP + 0x38]
JNZ 0x0015d003
MOV RCX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x18]
ADD RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV EAX,dword ptr [RSP + 0x24]
MOV RCX,qword ptr [RSP + 0x40]
MOV ECX,dword ptr [RCX + 0x8]
SUB ECX,0x1
CMP EAX,ECX
JGE 0x0015cffe
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RSP + 0x18]
ADD RAX,qword ptr [RCX + 0x8]
MOV RCX,qword ptr [RSP + 0x40]
ADD RCX,0x10
MOV EDX,dword ptr [RSP + 0x24]
ADD EDX,0x1
MOVSXD RDX,EDX
SHL RDX,0x4
ADD RCX,RDX
CMP RAX,qword ptr [RCX]
JNZ 0x0015cffe
MOV RAX,qword ptr [RSP + 0x40]
ADD RAX,0x10
MOV ECX,dword ptr [RSP + 0x24]
ADD ECX,0x1
MOVSXD RCX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RSP + 0x18]
ADD RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0x40]
MOV ECX,dword ptr [RAX + 0x8]
ADD ECX,-0x1
MOV dword ptr [RAX + 0x8],ECX
MOV EAX,dword ptr [RSP + 0x24]
ADD EAX,0x1
MOV dword ptr [RSP + 0x14],EAX
LAB_0015cfa4:
MOV EAX,dword ptr [RSP + 0x14]
MOV RCX,qword ptr [RSP + 0x40]
CMP EAX,dword ptr [RCX + 0x8]
JGE 0x0015cffc
MOV RAX,qword ptr [RSP + 0x40]
ADD RAX,0x10
MOVSXD RCX,dword ptr [RSP + 0x14]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RSP + 0x40]
ADD RCX,0x10
MOV EDX,dword ptr [RSP + 0x14]
ADD EDX,0x1
MOVSXD RDX,EDX
SHL RDX,0x4
ADD RCX,RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV EAX,dword ptr [RSP + 0x14]
ADD EAX,0x1
MOV dword ptr [RSP + 0x14],EAX
JMP 0x0015cfa4
LAB_0015cffc:
JMP 0x0015cffe
LAB_0015cffe:
JMP 0x0015d277
LAB_0015d003:
MOV RAX,qword ptr [RSP + 0x38]
ADD RAX,qword ptr [RSP + 0x30]
MOV RCX,qword ptr [RSP + 0x18]
CMP RAX,qword ptr [RCX]
JNZ 0x0015d12e
MOV RCX,qword ptr [RSP + 0x38]
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x18]
ADD RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
CMP dword ptr [RSP + 0x24],0x0
JLE 0x0015d129
MOV RAX,qword ptr [RSP + 0x40]
ADD RAX,0x10
MOV ECX,dword ptr [RSP + 0x24]
SUB ECX,0x1
MOVSXD RCX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RSP + 0x40]
ADD RCX,0x10
MOV EDX,dword ptr [RSP + 0x24]
SUB EDX,0x1
MOVSXD RDX,EDX
SHL RDX,0x4
ADD RCX,RDX
ADD RAX,qword ptr [RCX + 0x8]
MOV RCX,qword ptr [RSP + 0x18]
CMP RAX,qword ptr [RCX]
JNZ 0x0015d129
MOV RAX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RSP + 0x40]
ADD RAX,0x10
MOV EDX,dword ptr [RSP + 0x24]
SUB EDX,0x1
MOVSXD RDX,EDX
SHL RDX,0x4
ADD RAX,RDX
ADD RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0x40]
MOV ECX,dword ptr [RAX + 0x8]
ADD ECX,-0x1
MOV dword ptr [RAX + 0x8],ECX
MOV EAX,dword ptr [RSP + 0x24]
MOV dword ptr [RSP + 0x10],EAX
LAB_0015d0cf:
MOV EAX,dword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x40]
CMP EAX,dword ptr [RCX + 0x8]
JGE 0x0015d127
MOV RAX,qword ptr [RSP + 0x40]
ADD RAX,0x10
MOVSXD RCX,dword ptr [RSP + 0x10]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RSP + 0x40]
ADD RCX,0x10
MOV EDX,dword ptr [RSP + 0x10]
ADD EDX,0x1
MOVSXD RDX,EDX
SHL RDX,0x4
ADD RCX,RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV EAX,dword ptr [RSP + 0x10]
ADD EAX,0x1
MOV dword ptr [RSP + 0x10],EAX
JMP 0x0015d0cf
LAB_0015d127:
JMP 0x0015d129
LAB_0015d129:
JMP 0x0015d277
LAB_0015d12e:
JMP 0x0015d130
LAB_0015d130:
MOV EAX,dword ptr [RSP + 0x24]
ADD EAX,0x1
MOV dword ptr [RSP + 0x24],EAX
JMP 0x0015cebb
LAB_0015d140:
MOV RAX,qword ptr [RSP + 0x40]
CMP dword ptr [RAX + 0x8],0x100
JGE 0x0015d156
MOV AL,0x1
TEST AL,0x1
JNZ 0x0015d177
JMP 0x0015d156
LAB_0015d156:
LEA RDI,[0x1b71ca]
MOV ESI,0x117
LEA RDX,[0x1b4601]
LEA RCX,[0x1b74a3]
MOV AL,0x0
CALL 0x00146770
LAB_0015d177:
MOV dword ptr [RSP + 0xc],0x0
LAB_0015d17f:
MOV ECX,dword ptr [RSP + 0xc]
MOV RDX,qword ptr [RSP + 0x40]
XOR EAX,EAX
CMP ECX,dword ptr [RDX + 0x8]
MOV byte ptr [RSP + 0x7],AL
JGE 0x0015d1b7
MOV RAX,qword ptr [RSP + 0x40]
ADD RAX,0x10
MOVSXD RCX,dword ptr [RSP + 0xc]
SHL RCX,0x4
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
CMP RAX,qword ptr [RSP + 0x38]
SETC AL
MOV byte ptr [RSP + 0x7],AL
LAB_0015d1b7:
MOV AL,byte ptr [RSP + 0x7]
TEST AL,0x1
JNZ 0x0015d1c1
JMP 0x0015d1ce
LAB_0015d1c1:
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
JMP 0x0015d17f
LAB_0015d1ce:
MOV RAX,qword ptr [RSP + 0x40]
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RSP + 0x8],EAX
LAB_0015d1da:
MOV EAX,dword ptr [RSP + 0x8]
CMP EAX,dword ptr [RSP + 0xc]
JLE 0x0015d22e
MOV RAX,qword ptr [RSP + 0x40]
ADD RAX,0x10
MOVSXD RCX,dword ptr [RSP + 0x8]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RSP + 0x40]
ADD RCX,0x10
MOV EDX,dword ptr [RSP + 0x8]
SUB EDX,0x1
MOVSXD RDX,EDX
SHL RDX,0x4
ADD RCX,RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV EAX,dword ptr [RSP + 0x8]
ADD EAX,-0x1
MOV dword ptr [RSP + 0x8],EAX
JMP 0x0015d1da
LAB_0015d22e:
MOV RCX,qword ptr [RSP + 0x38]
MOV RAX,qword ptr [RSP + 0x40]
ADD RAX,0x10
MOVSXD RDX,dword ptr [RSP + 0xc]
SHL RDX,0x4
ADD RAX,RDX
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x40]
ADD RAX,0x10
MOVSXD RDX,dword ptr [RSP + 0xc]
SHL RDX,0x4
ADD RAX,RDX
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0x40]
MOV ECX,dword ptr [RAX + 0x8]
ADD ECX,0x1
MOV dword ptr [RAX + 0x8],ECX
LAB_0015d277:
ADD RSP,0x48
RET
|
/* WARNING: Removing unreachable block (ram,0x0015d154) */
void ggml_dyn_tallocr_free_tensor(int8 *param_1,ulong param_2,int8 param_3)
{
long lVar1;
ulong *puVar2;
bool bVar3;
int local_40;
int local_3c;
int local_38;
int local_34;
int local_24;
lVar1 = aligned_offset(0,param_3,*param_1);
local_24 = 0;
while( true ) {
if (*(int *)(param_1 + 1) <= local_24) {
if (0xff < *(int *)(param_1 + 1)) {
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-alloc.c"
,0x117,"GGML_ASSERT(%s) failed",
"alloc->n_free_blocks < MAX_FREE_BLOCKS && \"out of free blocks\"");
}
local_3c = 0;
while( true ) {
bVar3 = false;
if (local_3c < *(int *)(param_1 + 1)) {
bVar3 = (ulong)param_1[(long)local_3c * 2 + 2] < param_2;
}
if (!bVar3) break;
local_3c = local_3c + 1;
}
for (local_40 = *(int *)(param_1 + 1); local_3c < local_40; local_40 = local_40 + -1) {
param_1[(long)local_40 * 2 + 2] = param_1[(long)(local_40 + -1) * 2 + 2];
(param_1 + (long)local_40 * 2 + 2)[1] = (param_1 + (long)(local_40 + -1) * 2 + 2)[1];
}
param_1[(long)local_3c * 2 + 2] = param_2;
param_1[(long)local_3c * 2 + 3] = lVar1;
*(int *)(param_1 + 1) = *(int *)(param_1 + 1) + 1;
return;
}
puVar2 = param_1 + (long)local_24 * 2 + 2;
if (*puVar2 + puVar2[1] == param_2) {
puVar2[1] = lVar1 + puVar2[1];
if (*(int *)(param_1 + 1) + -1 <= local_24) {
return;
}
if (*puVar2 + puVar2[1] != param_1[(long)(local_24 + 1) * 2 + 2]) {
return;
}
puVar2[1] = param_1[(long)(local_24 + 1) * 2 + 3] + puVar2[1];
*(int *)(param_1 + 1) = *(int *)(param_1 + 1) + -1;
while (local_34 = local_24 + 1, local_34 < *(int *)(param_1 + 1)) {
param_1[(long)local_34 * 2 + 2] = param_1[(long)(local_24 + 2) * 2 + 2];
(param_1 + (long)local_34 * 2 + 2)[1] = (param_1 + (long)(local_24 + 2) * 2 + 2)[1];
local_24 = local_34;
}
return;
}
if (param_2 + lVar1 == *puVar2) break;
local_24 = local_24 + 1;
}
*puVar2 = param_2;
puVar2[1] = lVar1 + puVar2[1];
if (local_24 < 1) {
return;
}
if (param_1[(long)(local_24 + -1) * 2 + 2] + param_1[(long)(local_24 + -1) * 2 + 3] != *puVar2) {
return;
}
param_1[(long)(local_24 + -1) * 2 + 3] = puVar2[1] + param_1[(long)(local_24 + -1) * 2 + 3];
*(int *)(param_1 + 1) = *(int *)(param_1 + 1) + -1;
for (local_38 = local_24; local_38 < *(int *)(param_1 + 1); local_38 = local_38 + 1) {
param_1[(long)local_38 * 2 + 2] = param_1[(long)(local_38 + 1) * 2 + 2];
(param_1 + (long)local_38 * 2 + 2)[1] = (param_1 + (long)(local_38 + 1) * 2 + 2)[1];
}
return;
}
| |
41,696 | SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/json-schema-to-grammar.cpp | void resolve_refs(json & schema, const std::string & url) {
/*
* Resolves all $ref fields in the given schema, fetching any remote schemas,
* replacing each $ref with absolute reference URL and populates _refs with the
* respective referenced (sub)schema dictionaries.
*/
std::function<void(json &)> visit_refs = [&](json & n) {
if (n.is_array()) {
for (auto & x : n) {
visit_refs(x);
}
} else if (n.is_object()) {
if (n.contains("$ref")) {
std::string ref = n["$ref"];
if (_refs.find(ref) == _refs.end()) {
json target;
if (ref.find("https://") == 0) {
std::string base_url = ref.substr(0, ref.find('#'));
auto it = _refs.find(base_url);
if (it != _refs.end()) {
target = it->second;
} else {
// Fetch the referenced schema and resolve its refs
auto referenced = _fetch_json(ref);
resolve_refs(referenced, base_url);
_refs[base_url] = referenced;
}
if (ref.find('#') == std::string::npos || ref.substr(ref.find('#') + 1).empty()) {
return;
}
} else if (ref.find("#/") == 0) {
target = schema;
n["$ref"] = url + ref;
ref = url + ref;
} else {
_errors.push_back("Unsupported ref: " + ref);
return;
}
std::string pointer = ref.substr(ref.find('#') + 1);
std::vector<std::string> tokens = string_split(pointer, "/");
for (size_t i = 1; i < tokens.size(); ++i) {
std::string sel = tokens[i];
if (target.is_null() || !target.contains(sel)) {
_errors.push_back("Error resolving ref " + ref + ": " + sel + " not in " + target.dump());
return;
}
target = target[sel];
}
_refs[ref] = target;
}
} else {
for (auto & kv : n.items()) {
visit_refs(kv.value());
}
}
}
};
visit_refs(schema);
} | O2 | cpp | SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %rsi
movq %r14, (%rsi)
movq %rdi, 0x8(%rsi)
movq %rbx, 0x10(%rsi)
movq %rdx, 0x18(%rsi)
movq %r14, %rdi
callq 0x961c0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8eabc
leaq 0x8(%rsp), %rdi
callq 0x48638
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x48638
movq %rbx, %rdi
callq 0x23f20
nop
| _ZN15SchemaConverter12resolve_refsERN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEERKSA_:
push r14
push rbx
sub rsp, 48h
mov rbx, rsi
lea r14, [rsp+58h+var_50]
lea rsi, [rsp+58h+var_30]
mov [rsi], r14
mov [rsi+8], rdi
mov [rsi+10h], rbx
mov [rsi+18h], rdx
mov rdi, r14
call _ZNSt8functionIFvRN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEEC2IZN15SchemaConverter12resolve_refsESF_RKSA_EUlSF_E_vEEOT_; std::function<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> &)>::function<SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,std::string const&)::{lambda(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> &)#1},void>(SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,std::string const&)::{lambda(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> &)#1} &&)
mov rdi, r14
mov rsi, rbx
call _ZNKSt8functionIFvRN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEEclESF_; std::function<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> &)>::operator()(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)
lea rdi, [rsp+58h+var_50]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
add rsp, 48h
pop rbx
pop r14
retn
mov rbx, rax
lea rdi, [rsp+arg_0]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
mov rdi, rbx
call __Unwind_Resume
| void SchemaConverter::resolve_refs(long long a1, long long a2, long long a3)
{
_BYTE v3[32]; // [rsp+8h] [rbp-50h] BYREF
_BYTE *v4; // [rsp+28h] [rbp-30h]
long long v5; // [rsp+30h] [rbp-28h]
long long v6; // [rsp+38h] [rbp-20h]
long long v7; // [rsp+40h] [rbp-18h]
v4 = v3;
v5 = a1;
v6 = a2;
v7 = a3;
std::function<void ()(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::function<SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &,std::string const&)::{lambda(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> &)#1},void>(v3);
std::function<void ()(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::operator()((long long)v3);
std::_Function_base::~_Function_base((std::_Function_base *)v3);
}
| resolve_refs:
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV RBX,RSI
LEA R14,[RSP + 0x8]
LEA RSI,[RSP + 0x28]
MOV qword ptr [RSI],R14
MOV qword ptr [RSI + 0x8],RDI
MOV qword ptr [RSI + 0x10],RBX
MOV qword ptr [RSI + 0x18],RDX
MOV RDI,R14
CALL 0x001961c0
LAB_0019618d:
MOV RDI,R14
MOV RSI,RBX
CALL 0x0018eabc
LAB_00196198:
LEA RDI,[RSP + 0x8]
CALL 0x00148638
ADD RSP,0x48
POP RBX
POP R14
RET
|
/* SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>&, std::__cxx11::string const&) */
void __thiscall
SchemaConverter::resolve_refs(SchemaConverter *this,basic_json *param_1,string *param_2)
{
_lambda_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>___1_
local_50 [32];
_lambda_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>___1_
*local_30;
SchemaConverter *local_28;
basic_json *local_20;
string *local_18;
local_30 = local_50;
local_28 = this;
local_20 = param_1;
local_18 = param_2;
std::
function<void(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::
function<SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&,std::__cxx11::string_const&)::_lambda(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>&)_1_,void>
(local_50);
/* try { // try from 0019618d to 00196197 has its CatchHandler @ 001961aa */
std::
function<void(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::operator()((function<void(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
*)local_50,param_1);
std::_Function_base::~_Function_base((_Function_base *)local_50);
return;
}
| |
41,697 | SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/json-schema-to-grammar.cpp | void resolve_refs(json & schema, const std::string & url) {
/*
* Resolves all $ref fields in the given schema, fetching any remote schemas,
* replacing each $ref with absolute reference URL and populates _refs with the
* respective referenced (sub)schema dictionaries.
*/
std::function<void(json &)> visit_refs = [&](json & n) {
if (n.is_array()) {
for (auto & x : n) {
visit_refs(x);
}
} else if (n.is_object()) {
if (n.contains("$ref")) {
std::string ref = n["$ref"];
if (_refs.find(ref) == _refs.end()) {
json target;
if (ref.find("https://") == 0) {
std::string base_url = ref.substr(0, ref.find('#'));
auto it = _refs.find(base_url);
if (it != _refs.end()) {
target = it->second;
} else {
// Fetch the referenced schema and resolve its refs
auto referenced = _fetch_json(ref);
resolve_refs(referenced, base_url);
_refs[base_url] = referenced;
}
if (ref.find('#') == std::string::npos || ref.substr(ref.find('#') + 1).empty()) {
return;
}
} else if (ref.find("#/") == 0) {
target = schema;
n["$ref"] = url + ref;
ref = url + ref;
} else {
_errors.push_back("Unsupported ref: " + ref);
return;
}
std::string pointer = ref.substr(ref.find('#') + 1);
std::vector<std::string> tokens = string_split(pointer, "/");
for (size_t i = 1; i < tokens.size(); ++i) {
std::string sel = tokens[i];
if (target.is_null() || !target.contains(sel)) {
_errors.push_back("Error resolving ref " + ref + ": " + sel + " not in " + target.dump());
return;
}
target = target[sel];
}
_refs[ref] = target;
}
} else {
for (auto & kv : n.items()) {
visit_refs(kv.value());
}
}
}
};
visit_refs(schema);
} | O3 | cpp | SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq $0x0, 0x8(%r12)
movl $0x20, %edi
callq 0x1a870
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %rax, (%r12)
leaq 0x70(%rip), %rcx # 0xcb9c6
movq %rcx, 0x18(%r12)
leaq 0x6c(%rip), %rcx # 0xcb9ce
movq %rcx, 0x10(%r12)
movq %rax, %rdi
movq %r14, %rsi
callq 0xcb9f6
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xcb98b
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xcb9bd
movq %rax, %rbx
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xcb9b5
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x1af20
movq %rax, %rdi
callq 0x2160f
nop
| _ZN15SchemaConverter12resolve_refsERN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEERKSA_:
push r15
push r14
push r12
push rbx
sub rsp, 28h
mov rbx, rdx
mov r14, rsi
mov r15, rdi
lea r12, [rsp+48h+var_40]
mov qword ptr [r12+8], 0
mov edi, 20h ; ' '; unsigned __int64
call __Znwm; operator new(ulong)
mov [rax], r12
mov [rax+8], r15
mov [rax+10h], r14
mov [rax+18h], rbx
mov [r12], rax
lea rcx, _ZNSt17_Function_handlerIFvRN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEZN15SchemaConverter12resolve_refsESF_RKSA_EUlSF_E_E9_M_invokeERKSt9_Any_dataSF_; std::_Function_handler<void ()(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &),SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,std::string const&)::{lambda(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> &)#1}>::_M_invoke(std::_Any_data const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)
mov [r12+18h], rcx
lea rcx, _ZNSt17_Function_handlerIFvRN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEZN15SchemaConverter12resolve_refsESF_RKSA_EUlSF_E_E10_M_managerERSt9_Any_dataRKSM_St18_Manager_operation; std::_Function_handler<void ()(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &),SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,std::string const&)::{lambda(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> &)#1}>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [r12+10h], rcx
mov rdi, rax
mov rsi, r14
call _ZZN15SchemaConverter12resolve_refsERN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEERKSA_ENKUlSF_E_clESF_; SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,std::string const&)::{lambda(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> &)#1}::operator()(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)
mov rax, [rsp+48h+var_30]
test rax, rax
jz short loc_CB98B
lea rdi, [rsp+48h+var_40]
mov rsi, rdi
mov edx, 3
call rax
loc_CB98B:
add rsp, 28h
pop rbx
pop r12
pop r14
pop r15
retn
jmp short loc_CB9BD
mov rbx, rax
mov rax, [rsp+48h+var_30]
test rax, rax
jz short loc_CB9B5
lea rdi, [rsp+48h+var_40]
mov rsi, rdi
mov edx, 3
call rax
loc_CB9B5:
mov rdi, rbx
call __Unwind_Resume
loc_CB9BD:
mov rdi, rax
call __clang_call_terminate
| long long SchemaConverter::resolve_refs(long long a1, long long a2, long long a3)
{
_QWORD *v4; // rax
long long result; // rax
_QWORD v6[2]; // [rsp+8h] [rbp-40h] BYREF
long long ( *v7)(); // [rsp+18h] [rbp-30h]
long long ( *v8)(); // [rsp+20h] [rbp-28h]
v6[1] = 0LL;
v4 = (_QWORD *)operator new(0x20uLL);
*v4 = v6;
v4[1] = a1;
v4[2] = a2;
v4[3] = a3;
v6[0] = v4;
v8 = std::_Function_handler<void ()(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &),SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &,std::string const&)::{lambda(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> &)#1}>::_M_invoke;
v7 = std::_Function_handler<void ()(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &),SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &,std::string const&)::{lambda(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> &)#1}>::_M_manager;
SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &,std::string const&)::{lambda(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> &)#1}::operator()(
v4,
a2);
result = (long long)v7;
if ( v7 )
return ((long long ( *)(_QWORD *, _QWORD *, long long))v7)(v6, v6, 3LL);
return result;
}
| resolve_refs:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
LEA R12,[RSP + 0x8]
MOV qword ptr [R12 + 0x8],0x0
MOV EDI,0x20
CALL 0x0011a870
MOV qword ptr [RAX],R12
MOV qword ptr [RAX + 0x8],R15
MOV qword ptr [RAX + 0x10],R14
MOV qword ptr [RAX + 0x18],RBX
MOV qword ptr [R12],RAX
LEA RCX,[0x1cb9c6]
MOV qword ptr [R12 + 0x18],RCX
LEA RCX,[0x1cb9ce]
MOV qword ptr [R12 + 0x10],RCX
LAB_001cb967:
MOV RDI,RAX
MOV RSI,R14
CALL 0x001cb9f6
MOV RAX,qword ptr [RSP + 0x18]
TEST RAX,RAX
JZ 0x001cb98b
LAB_001cb97c:
LEA RDI,[RSP + 0x8]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001cb98b:
ADD RSP,0x28
POP RBX
POP R12
POP R14
POP R15
RET
|
/* SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>&, std::__cxx11::string const&) */
void __thiscall
SchemaConverter::resolve_refs(SchemaConverter *this,basic_json *param_1,string *param_2)
{
_lambda_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>___1_
*local_40;
int8 local_38;
code *local_30;
code *local_28;
local_38 = 0;
local_40 = (_lambda_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>___1_
*)operator_new(0x20);
*(_lambda_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>___1_
***)local_40 = &local_40;
*(SchemaConverter **)(local_40 + 8) = this;
*(basic_json **)(local_40 + 0x10) = param_1;
*(string **)(local_40 + 0x18) = param_2;
local_28 = std::
_Function_handler<void(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&),SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&,std::__cxx11::string_const&)::{lambda(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>&)#1}>
::_M_invoke;
local_30 = std::
_Function_handler<void(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&),SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&,std::__cxx11::string_const&)::{lambda(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>&)#1}>
::_M_manager;
/* try { // try from 001cb967 to 001cb971 has its CatchHandler @ 001cb999 */
resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&,std::__cxx11::string_const&)
::
{lambda(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>&)#1}
::operator()(local_40,param_1);
if (local_30 != (code *)0x0) {
/* try { // try from 001cb97c to 001cb98a has its CatchHandler @ 001cb997 */
(*local_30)(&local_40,&local_40,3);
}
return;
}
| |
41,698 | is_on_curve | corpus-core[P]colibri-stateless/src/chains/eth/precompiles/precompiles_ec.c | static bool is_on_curve(const uint256_t* x, const uint256_t* y, const uint256_t* modulus) {
// Calculate right side: x^3 + 7 (mod p)
uint256_t x_squared, x_cubed, right_side, b;
intx_init(&x_squared);
intx_init(&x_cubed);
intx_init(&right_side);
uint256_from_be_bytes(&b, SECP256K1_B, 32);
// x^2 mod p
intx_mul(&x_squared, x, x);
intx_mod(&x_squared, &x_squared, modulus);
// x^3 mod p
intx_mul(&x_cubed, &x_squared, x);
intx_mod(&x_cubed, &x_cubed, modulus);
// x^3 + 7 mod p
intx_add(&right_side, &x_cubed, &b);
intx_mod(&right_side, &right_side, modulus);
// Calculate left side: y^2 (mod p)
uint256_t y_squared, left_side;
intx_init(&y_squared);
intx_init(&left_side);
// y^2 mod p
intx_mul(&y_squared, y, y);
intx_mod(&left_side, &y_squared, modulus);
// Check if left_side == right_side
return intx_eq(&left_side, &right_side);
} | O2 | c | is_on_curve:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %rbx
movq %rsi, 0x8(%rsp)
movq %rdi, %r13
leaq 0xb8(%rsp), %rbp
movq %rbp, %rdi
callq 0x7232c
leaq 0x98(%rsp), %r12
movq %r12, %rdi
callq 0x7232c
leaq 0x78(%rsp), %r15
movq %r15, %rdi
callq 0x7232c
movaps 0x34960(%rip), %xmm0 # 0x7f010
leaq 0x10(%rsp), %r14
movaps %xmm0, 0x10(%r14)
movaps 0x3493f(%rip), %xmm0 # 0x7f000
movaps %xmm0, (%r14)
movq %rbp, %rdi
movq %r13, %rsi
movq %r13, %rdx
callq 0x72643
movq %rbp, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x727cd
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x72643
movq %r12, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x727cd
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x724f5
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x727cd
leaq 0x58(%rsp), %r14
movq %r14, %rdi
callq 0x7232c
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x7232c
movq %r14, %rdi
movq 0x8(%rsp), %rdx
movq %rdx, %rsi
callq 0x72643
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x727cd
movq %r12, %rdi
movq %r15, %rsi
callq 0x72c0a
testl %eax, %eax
setne %al
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| is_on_curve:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0D8h
mov rbx, rdx
mov [rsp+108h+var_100], rsi
mov r13, rdi
lea rbp, [rsp+108h+var_50]
mov rdi, rbp
call intx_init
lea r12, [rsp+108h+var_70]
mov rdi, r12
call intx_init
lea r15, [rsp+108h+var_90]
mov rdi, r15
call intx_init
movaps xmm0, cs:xmmword_7F010
lea r14, [rsp+108h+var_F8]
movaps xmmword ptr [r14+10h], xmm0
movaps xmm0, cs:SECP256K1_B
movaps xmmword ptr [r14], xmm0
mov rdi, rbp
mov rsi, r13
mov rdx, r13
call intx_mul
mov rdi, rbp
mov rsi, rbp
mov rdx, rbx
call intx_mod
mov rdi, r12
mov rsi, rbp
mov rdx, r13
call intx_mul
mov rdi, r12
mov rsi, r12
mov rdx, rbx
call intx_mod
mov rdi, r15
mov rsi, r12
mov rdx, r14
call intx_add
mov rdi, r15
mov rsi, r15
mov rdx, rbx
call intx_mod
lea r14, [rsp+108h+var_B0]
mov rdi, r14
call intx_init
lea r12, [rsp+108h+var_D0]
mov rdi, r12
call intx_init
mov rdi, r14
mov rdx, [rsp+108h+var_100]
mov rsi, rdx
call intx_mul
mov rdi, r12
mov rsi, r14
mov rdx, rbx
call intx_mod
mov rdi, r12
mov rsi, r15
call intx_eq
test eax, eax
setnz al
add rsp, 0D8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| bool is_on_curve(long long a1, long long a2, long long a3)
{
_OWORD v5[2]; // [rsp+10h] [rbp-F8h] BYREF
_BYTE v6[32]; // [rsp+38h] [rbp-D0h] BYREF
_BYTE v7[32]; // [rsp+58h] [rbp-B0h] BYREF
_BYTE v8[32]; // [rsp+78h] [rbp-90h] BYREF
_BYTE v9[32]; // [rsp+98h] [rbp-70h] BYREF
_BYTE v10[80]; // [rsp+B8h] [rbp-50h] BYREF
intx_init(v10);
intx_init(v9);
intx_init(v8);
v5[1] = xmmword_7F010;
v5[0] = SECP256K1_B;
intx_mul(v10, a1, a1);
intx_mod(v10, v10, a3);
intx_mul(v9, v10, a1);
intx_mod(v9, v9, a3);
intx_add(v8, v9, v5);
intx_mod(v8, v8, a3);
intx_init(v7);
intx_init(v6);
intx_mul(v7, a2, a2);
intx_mod(v6, v7, a3);
return (unsigned int)intx_eq(v6, v8) != 0;
}
| is_on_curve:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xd8
MOV RBX,RDX
MOV qword ptr [RSP + 0x8],RSI
MOV R13,RDI
LEA RBP,[RSP + 0xb8]
MOV RDI,RBP
CALL 0x0017232c
LEA R12,[RSP + 0x98]
MOV RDI,R12
CALL 0x0017232c
LEA R15,[RSP + 0x78]
MOV RDI,R15
CALL 0x0017232c
MOVAPS XMM0,xmmword ptr [0x0017f010]
LEA R14,[RSP + 0x10]
MOVAPS xmmword ptr [R14 + 0x10],XMM0
MOVAPS XMM0,xmmword ptr [0x0017f000]
MOVAPS xmmword ptr [R14],XMM0
MOV RDI,RBP
MOV RSI,R13
MOV RDX,R13
CALL 0x00172643
MOV RDI,RBP
MOV RSI,RBP
MOV RDX,RBX
CALL 0x001727cd
MOV RDI,R12
MOV RSI,RBP
MOV RDX,R13
CALL 0x00172643
MOV RDI,R12
MOV RSI,R12
MOV RDX,RBX
CALL 0x001727cd
MOV RDI,R15
MOV RSI,R12
MOV RDX,R14
CALL 0x001724f5
MOV RDI,R15
MOV RSI,R15
MOV RDX,RBX
CALL 0x001727cd
LEA R14,[RSP + 0x58]
MOV RDI,R14
CALL 0x0017232c
LEA R12,[RSP + 0x38]
MOV RDI,R12
CALL 0x0017232c
MOV RDI,R14
MOV RDX,qword ptr [RSP + 0x8]
MOV RSI,RDX
CALL 0x00172643
MOV RDI,R12
MOV RSI,R14
MOV RDX,RBX
CALL 0x001727cd
MOV RDI,R12
MOV RSI,R15
CALL 0x00172c0a
TEST EAX,EAX
SETNZ AL
ADD RSP,0xd8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
bool is_on_curve(int8 param_1,int8 param_2,int8 param_3)
{
int iVar1;
int4 local_f8 [10];
int1 local_d0 [32];
int1 local_b0 [32];
int1 local_90 [32];
int1 local_70 [32];
int1 local_50 [32];
intx_init(local_50);
intx_init(local_70);
intx_init(local_90);
local_f8[4] = SECP256K1_B._16_4_;
local_f8[5] = SECP256K1_B._20_4_;
local_f8[6] = SECP256K1_B._24_4_;
local_f8[7] = SECP256K1_B._28_4_;
local_f8[0] = SECP256K1_B._0_4_;
local_f8[1] = SECP256K1_B._4_4_;
local_f8[2] = SECP256K1_B._8_4_;
local_f8[3] = SECP256K1_B._12_4_;
intx_mul(local_50,param_1,param_1);
intx_mod(local_50,local_50,param_3);
intx_mul(local_70,local_50,param_1);
intx_mod(local_70,local_70,param_3);
intx_add(local_90,local_70,local_f8);
intx_mod(local_90,local_90,param_3);
intx_init(local_b0);
intx_init(local_d0);
intx_mul(local_b0,param_2);
intx_mod(local_d0,local_b0,param_3);
iVar1 = intx_eq(local_d0,local_90);
return iVar1 != 0;
}
| |
41,699 | ma_hashtbl_search | eloqsql/libmariadb/libmariadb/ma_hashtbl.c | void* ma_hashtbl_search(MA_HASHTBL *hash,const uchar *key,uint length)
{
MA_HASHTBL_LINK *pos;
uint flag,idx;
flag=1;
if (hash->records)
{
idx=hash_mask((*hash->calc_hashnr)(key,length ? length :
hash->key_length),
hash->blength,hash->records);
do
{
pos= dynamic_element(&hash->array,idx,MA_HASHTBL_LINK*);
if (!hashcmp(hash,pos,key,length))
{
hash->current_record= idx;
return (pos->data);
}
if (flag)
{
flag=0; /* Reset flag */
if (hash_rec_mask(hash,pos,hash->blength,hash->records) != idx)
break; /* Wrong link */
}
}
while ((idx=pos->next) != NO_RECORD);
}
hash->current_record= NO_RECORD;
return(0);
} | O0 | c | ma_hashtbl_search:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x1, -0x2c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x45847
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x4578a
movl -0x1c(%rbp), %eax
movl %eax, -0x44(%rbp)
jmp 0x45794
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdi
movl -0x44(%rbp), %esi
callq *%rax
movl %eax, %edi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
callq 0x45870
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x30(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x458c0
cmpl $0x0, %eax
jne 0x45800
movl -0x30(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4585a
cmpl $0x0, -0x2c(%rbp)
je 0x45831
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
callq 0x45940
cmpl -0x30(%rbp), %eax
je 0x4582f
jmp 0x45845
jmp 0x45831
jmp 0x45833
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
cmpl $-0x1, %eax
jne 0x457b9
jmp 0x45847
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ma_hashtbl_search:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_2C], 1
mov rax, [rbp+var_10]
cmp dword ptr [rax+8], 0
jz loc_45847
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
mov [rbp+var_38], rax
cmp [rbp+var_1C], 0
jz short loc_4578A
mov eax, [rbp+var_1C]
mov [rbp+var_44], eax
jmp short loc_45794
loc_4578A:
mov rax, [rbp+var_10]
mov eax, [rax+4]
mov [rbp+var_44], eax
loc_45794:
mov rax, [rbp+var_40]
mov rdi, [rbp+var_38]
mov esi, [rbp+var_44]
call rax
mov edi, eax
mov rax, [rbp+var_10]
mov esi, [rax+0Ch]
mov rax, [rbp+var_10]
mov edx, [rax+8]
call hash_mask
mov [rbp+var_30], eax
loc_457B9:
mov rax, [rbp+var_10]
mov rax, [rax+18h]
mov ecx, [rbp+var_30]
shl rcx, 4
add rax, rcx
mov [rbp+var_28], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_18]
mov ecx, [rbp+var_1C]
call hashcmp
cmp eax, 0
jnz short loc_45800
mov ecx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax+10h], ecx
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov [rbp+var_8], rax
jmp short loc_4585A
loc_45800:
cmp [rbp+var_2C], 0
jz short loc_45831
mov [rbp+var_2C], 0
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rax, [rbp+var_10]
mov edx, [rax+0Ch]
mov rax, [rbp+var_10]
mov ecx, [rax+8]
call hash_rec_mask
cmp eax, [rbp+var_30]
jz short loc_4582F
jmp short loc_45845
loc_4582F:
jmp short $+2
loc_45831:
jmp short $+2
loc_45833:
mov rax, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_30], eax
cmp eax, 0FFFFFFFFh
jnz loc_457B9
loc_45845:
jmp short $+2
loc_45847:
mov rax, [rbp+var_10]
mov dword ptr [rax+10h], 0FFFFFFFFh
mov [rbp+var_8], 0
loc_4585A:
mov rax, [rbp+var_8]
add rsp, 50h
pop rbp
retn
| long long ma_hashtbl_search(long long a1, long long a2, unsigned int a3)
{
unsigned int v3; // eax
unsigned int v5; // [rsp+Ch] [rbp-44h]
unsigned int v6; // [rsp+20h] [rbp-30h]
int v7; // [rsp+24h] [rbp-2Ch]
long long v8; // [rsp+28h] [rbp-28h]
v7 = 1;
if ( *(_DWORD *)(a1 + 8) )
{
if ( a3 )
v5 = a3;
else
v5 = *(_DWORD *)(a1 + 4);
v3 = (*(long long ( **)(long long, _QWORD))(a1 + 64))(a2, v5);
v6 = hash_mask(v3, *(unsigned int *)(a1 + 12), *(unsigned int *)(a1 + 8));
while ( 1 )
{
v8 = 16LL * v6 + *(_QWORD *)(a1 + 24);
if ( !(unsigned int)hashcmp(a1, v8, a2, a3) )
break;
if ( !v7
|| (v7 = 0, (unsigned int)hash_rec_mask(a1, v8, *(unsigned int *)(a1 + 12), *(unsigned int *)(a1 + 8)) == v6) )
{
v6 = *(_DWORD *)v8;
if ( *(_DWORD *)v8 != -1 )
continue;
}
goto LABEL_11;
}
*(_DWORD *)(a1 + 16) = v6;
return *(_QWORD *)(v8 + 8);
}
else
{
LABEL_11:
*(_DWORD *)(a1 + 16) = -1;
return 0LL;
}
}
| ma_hashtbl_search:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV dword ptr [RBP + -0x2c],0x1
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x8],0x0
JZ 0x00145847
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
CMP dword ptr [RBP + -0x1c],0x0
JZ 0x0014578a
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x44],EAX
JMP 0x00145794
LAB_0014578a:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RBP + -0x44],EAX
LAB_00145794:
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RBP + -0x38]
MOV ESI,dword ptr [RBP + -0x44]
CALL RAX
MOV EDI,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RAX + 0xc]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0x8]
CALL 0x00145870
MOV dword ptr [RBP + -0x30],EAX
LAB_001457b9:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
MOV ECX,dword ptr [RBP + -0x30]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x1c]
CALL 0x001458c0
CMP EAX,0x0
JNZ 0x00145800
MOV ECX,dword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0014585a
LAB_00145800:
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x00145831
MOV dword ptr [RBP + -0x2c],0x0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0xc]
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x8]
CALL 0x00145940
CMP EAX,dword ptr [RBP + -0x30]
JZ 0x0014582f
JMP 0x00145845
LAB_0014582f:
JMP 0x00145831
LAB_00145831:
JMP 0x00145833
LAB_00145833:
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x30],EAX
CMP EAX,-0x1
JNZ 0x001457b9
LAB_00145845:
JMP 0x00145847
LAB_00145847:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x10],0xffffffff
MOV qword ptr [RBP + -0x8],0x0
LAB_0014585a:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
int8 ma_hashtbl_search(long param_1,int8 param_2,int param_3)
{
bool bVar1;
int4 uVar2;
int iVar3;
uint uVar4;
uint *puVar5;
int local_4c;
uint local_38;
bVar1 = true;
if (*(int *)(param_1 + 8) != 0) {
local_4c = param_3;
if (param_3 == 0) {
local_4c = *(int *)(param_1 + 4);
}
uVar2 = (**(code **)(param_1 + 0x40))(param_2,local_4c);
local_38 = hash_mask(uVar2,*(int4 *)(param_1 + 0xc),*(int4 *)(param_1 + 8));
do {
puVar5 = (uint *)(*(long *)(param_1 + 0x18) + (ulong)local_38 * 0x10);
iVar3 = hashcmp(param_1,puVar5,param_2,param_3);
if (iVar3 == 0) {
*(uint *)(param_1 + 0x10) = local_38;
return *(int8 *)(puVar5 + 2);
}
if (bVar1) {
bVar1 = false;
uVar4 = hash_rec_mask(param_1,puVar5,*(int4 *)(param_1 + 0xc),
*(int4 *)(param_1 + 8));
if (uVar4 != local_38) break;
}
local_38 = *puVar5;
} while (local_38 != 0xffffffff);
}
*(int4 *)(param_1 + 0x10) = 0xffffffff;
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.